Let’s Solve Discoverability: FiSh for FujiNet

We live in an age of digital abundance. Decades of Atari software- commercial releases, public domain utilities, demoscene productions, homebrew games- have been preserved, archived, and made available online. That’s an incredible achievement. But abundance without discoverability is just a very large pile. And a pile, no matter how valuable the contents, isn’t useful if you can’t find what you’re looking for.

Discoverability is the bridge between “it exists somewhere” and “I’m running it right now.” It’s the difference between knowing that Star Raiders is out there on some server in some folder, and actually having it mounted and ready to play in under 30 seconds. When discoverability works well, you don’t even think about it- you want something, you find it, you use it. When it doesn’t work, you spend more time hunting through directories than actually enjoying your hardware.

The retro computing community has done amazing work preserving software. But preservation without access is just archiving for archiving’s sake. The real goal is to make this stuff usable- to let someone sit down at their Atari and find that game they played 35 years ago, or discover something new they’ve never seen. That’s what turns a museum into a living platform.

If you’ve been using FujiNet for any length of time, you’ve probably run into the discoverability problem. You know you want to play Dropzone, or load up that demo you saw at a party last year, but actually finding it across the various TNFS servers? That’s become its own adventure.

The thing is- the FujiNet ecosystem has grown. A lot. There are now multiple public TNFS servers around the world hosting thousands of files. The Atari Online server in Europe alone has over 10,000 files. That’s amazing for preservation and access, but it creates a real problem when you’re sitting at your Atari trying to find that one specific title you want to just play.

Enter FiSh.

What is FiSh?

FiSh (FujiNet Interface Shell) is a new app created by Bocianu that tackles this discoverability problem head-on. In short, it lets you search across a pool of TNFS servers and mount files directly from the results. No more navigating through endless directories on different servers trying to remember which one had what.

The amazing bit is the architecture. FiSh uses a client-server model where the heavy lifting happens on a backend server called FishEye. FishEye indexes files across multiple TNFS servers and maintains a searchable database. When you search from your Atari, the query goes to FishEye and you get results back. This makes sense because- let’s be honest- the Atari wasn’t exactly built for indexing hundreds of thousands of files across the internet.

The Discoverability Problem

Before diving into what FiSh does, it’s worth understanding why we needed it in the first place.

The traditional FujiNet CONFIG app gives you eight host slots. You point each slot at a TNFS server, browse the directory structure, find your file, mount it, and boot. That works great when you have a handful of files on one or two servers. But the reality today is different. There are servers maintained by the community all over the world- fujinet.pl, apps.irata.online, atarionline.eu, fujinet.diller.org, fujinet.online, and many more- each with their own organizational schemes.

Finding a specific game means either knowing which server has it, or spending time browsing through each server’s folder hierarchy. Many popular titles appear on multiple servers, sometimes in different locations or with different filenames. Star Raiders might be in /games/S/ on one server and /commercial/atari/ on another.

On a 40-column screen, scrolling through thousands of entries isn’t exactly a pleasant experience. And with only eight host slots available, constantly reconfiguring to check different servers gets old fast.

How FiSh Works

The magic happens because FishEye (the backend) does continuous indexing of the configured TNFS server pool. It knows what files exist where, and it tracks which servers are currently online. When you search for something, FishEye returns matches from across all indexed servers.

From the Atari side, you just type what you’re looking for. The results show you the filename, which server it’s on, and the path. Select one and FiSh handles the mounting for you. It even has smart host slot management- if the server is already configured in one of your host slots, FiSh reuses that slot instead of wasting another one.

FiSh 0.70 Features

The latest version (0.70) adds some nice improvements:

• Preset Manager (/PRESET) – Save and load up to 4 configurations per user, with up to 8 drive mappings per slot. Perfect for setting up your demo night configuration or your collection of productivity tools.

• Smart Host Slot Reuse – The client now automatically detects existing hosts and uses free slots instead of creating duplicates. A small thing, but it matters when you only have eight slots.

• Batch Unmount (/UMOUNT 0) – Unmounts all slots at once. Handy when you want a clean slate.

• Server Pool Visibility (/POOL) – See all available TNFS servers in the index. Inactive servers are automatically hidden from this list, search results, and shortcuts.

• Improved Help Screens – Command shortcuts and parameters are now explained right in the app.

Getting Started

The easiest way to try FiSh is to boot it directly from TNFS:

fujinet.pl/fish/fish.xex

Just mount that, boot it, and you’re off. No need to download anything to your SD card first- though you certainly can if you prefer having it local.

Once you’re in, type a search term and hit return. The results show what’s available across all indexed servers. Navigate to what you want and mount it. It really is that straightforward.

Why This Matters

The FujiNet project has always been about making vintage hardware more useful while respecting what makes these machines special. FiSh continues that tradition. It takes a real pain point- finding software across an ever-growing distributed archive- and solves it in a way that works within the constraints of the Atari platform.

For new users, this lowers the barrier to enjoying the Atari software library significantly. You don’t need to learn which server has what or navigate unfamiliar folder structures. Just search for what you want.

For the rest of us who’ve been around the scene for a while, it also enables discovery. Search for a genre or a partial title and find things you didn’t know existed. The Atari library is vast, and there’s always something you haven’t seen.

My Fork: SQLite and PostgreSQL Support

I’ve created a fork of the FishEye backend that adds support for both SQLite and PostgreSQL databases. The original implementation worked fine, but I prefer SQLite for simpler deployments- it’s file-based and requires zero configuration, which makes it easy to get a FishEye server up and running without standing up a separate database server.

The fork uses a factory pattern in data/db.js that loads the appropriate database driver based on your configuration. Both backends share the same API interface, so the application code works seamlessly with either option.

Why Two Backends?

SQLite is great for:
– Development and testing
– Single-user deployments
– Personal FujiNet servers
– Situations where you don’t want to manage a separate database process

PostgreSQL makes sense for:
– Production public servers
– Multi-user deployments
– High concurrency scenarios
– When you need advanced indexing features

If you want to run your own FishEye instance and don’t want to deal with PostgreSQL, grab my fork and use SQLite. Full documentation is in the README-DUAL-DB.md file.

My Fork: gitlab.com/dillera/fisheye

Resources for Followup

• FiSh Client: fujinet.pl/fish/fish.xex
• Source Code (Client & Server): gitlab.com/bocianu/fisheye
• FujiNet Project: fujinet.online
• Bocianu’s Projects: bocianu.atari.pl
• Public TNFS Server List: Maintained by Steve Boswell

As with everything in the FujiNet ecosystem, both the client and server source are open and available on GitLab. If you want to see how it works, contribute improvements, or run your own FishEye instance, it’s all there.

Give FiSh a try. It’s one of those tools that once you use it, you wonder how you got along without it.

Fishhead

Thomas Cherryhomes has also created fishhead – a simple one screen app that monitors a fishhead server. It’s a great example of using the Fujinet device to show Internet status on your eight bit. –