I wanted to sit down with a handheld, open my game library, and play. My collection already lived in RomM. What I wanted was a better front door on the devices I actually use: my phone, a Retroid Pocket 5, and a Steam Deck.
That became Rommayo, an independent companion to RomM. The original request sounded manageable: connect to my server, remember my login, show my games, and make everything feel a little more like Steam. Then I pressed a controller button, and the interesting engineering started.
The public project is at rommayo.quentinmayo.com, with source at quentinmayo/Rommayo. It is an alpha, and there are several development paths behind that simple name. The packaged desktop app uses Electron. Android has native library screens with web players. A Qt Quick and SDL3 player, central hosting, co-op, and casting are separate experiments. Those distinctions matter when deciding what to install.
RomM was already doing the difficult work of organizing a collection, exposing metadata, and providing players. I did not want to replace it. Rommayo connects to the user’s own server, using its existing account and permissions. There is no separate Rommayo account to create.
For the ordinary companion, login means a server address, username, and password, followed by a session cookie. Remembering that session is a choice; logging out needs to be equally obvious. An app that forgets you every time feels unfinished before you reach a game.
The companion and experimental native player share a library source, but they are different playback paths.
A library that feels at home
My first strong design correction was that Android should feel like an Android application. A browser inside a window can provide broad access to RomM, but it does not automatically create a comfortable handheld library. Search, platform filters, recents, game details, settings, and navigation became native screens. WebView still has a useful job: hosting the existing web player and the full RomM interface when needed.
The Steam influence is about how the application behaves as much as its blue accents. A focused game should look focused. The D-pad should move predictably. A should select, B should return, and shoulder buttons should help move between sections. Selecting a tab should leave focus on that tab until I choose to move down into its content.
Testing on the Retroid exposed details that mouse testing missed. One press opened a platform filter and immediately closed it. The opening press was reaching the next screen as an action of its own. Fixing that required treating a fresh press and its matching release as a unit, rather than interpreting any arriving release as a click.
Other fixes included blank search letters, overflowing diagnostics, clipped button labels, and missing artwork. Together, they determined whether I wanted to keep using the application.
Test input before blaming gameplay
Steam Deck testing pushed the project further. Electron remains useful for the packaged companion, but our controller experience made me want to test a native gameplay path before committing both apps to a migration. We chose Qt Quick for the interface and SDL3 for input and gameplay integration. That was a prototype decision, not a completed replacement of the public desktop packages.
We first checked the buttons independently of a game. Then we ran gameplay. I physically tested movement and jumping, followed by additional face-button mappings. That sequence was much more useful than assuming a game had frozen because nothing happened when I pressed A. A library focus test, an input test, and a gameplay test answer different questions.
Keep progress connected to RomM
I also stopped to ask whether we were losing the original reason for using RomM: my saves. The experimental native player now has a tested path that resumes compatible progress from RomM and saves back through its integration. That does not make every save interchangeable. A state belongs to an emulator core and its serialization format; a browser player, native core, and co-op host can have different expectations.
Returning to the library needed a confirmation too. An accidental click should not end a session. The prototype’s exit flow became a real operation with a result to check, rather than a navigation button that optimistically claimed everything was saved.
The useful questions became: what owns input, what owns progress, and what did we actually verify?
Let the server run the game
The next experiment moved emulation to a central host. Instead of asking every handheld to run the game, a Docker-hosted service can run a native core and stream video and audio while a client sends controller input. That creates an interesting path for a browser, handheld, and TV to participate in the same session. It is still experimental, not a promise of desktop and web feature parity.
It also taught me that “the stream is connected” is a weak success criterion. A TV can show video while feeling noticeably behind the handheld. Network round-trip time, receiver buffering, decoding, and presentation are separate measurements. A frame counter does not prove that pressing jump feels immediate.
We found another input lesson in repeated controller reports. Sending the same held direction over and over can crowd out the release that matters. The safer direction is immediate effective button changes, a bounded heartbeat, and explicit neutral handling when a controller changes ownership. Increasing a limit would have hidden the underlying problem.
Co-op and casting experiments grew into a shared system called Boogie Woogie. The intention is to reuse that foundation across both companions while keeping its tooling separate. Host approval, spectator-only TV access, clear exit controls, and honest preview labels are part of that work. They should not be confused with a finished public multiplayer service.
Rommayo does not include games, BIOS files, or a way to find unauthorized downloads. Bring content you are entitled to use, check the current compatibility notes, and back up progress before experimenting. RomM remains a separate upstream project; Rommayo is my companion to it.
What I am carrying forward
What began as “put my website in an app” has become a lesson in ownership: of focus, controller state, authentication, saves, and expectations. I still want the same simple outcome. Pick up a device, find a game, and keep playing. Now I have a much better appreciation for everything that has to behave correctly between those steps.