Goodbye Rented Services, Hello Pi: Choosing Between RomM and Kavita for Your Game Library
RomM and Kavita are often compared for self-hosted ROMs, but they do different jobs. RomM identifies and manages ROM libraries with saves and browser play; Kavita is a manga/comic/PDF reader that complements it for guides, manuals, and artbooks.
Goodbye Rented Services, Hello Pi: Choosing Between RomM and Kavita for Your Game Library
The post sitting near the top of my feed this week is titled "Goodbye Claude, hello Pi." A developer walked away from a rented frontier model and moved their workflow onto a Raspberry Pi — their own hardware, their own network, their own electricity bill. It's at 752 points on HN, and I don't think that's an accident. The mood right now is people getting tired of renting the thing that holds their work.
I've been making the same move in a much less glamorous corner of the homelab: the game shelf. Same instinct, zero press coverage.
RomM and Kavita keep getting mentioned in the same breath in self-hosting threads, usually as "which one do I use for my ROMs?" They are not competing for the same job. One is a ROM manager with a web front end bolted on. The other is a reading server that people keep pointing at game files because it renders a nice library grid. Getting this wrong means either a MariaDB stack chewing 1GB of RAM to display your manga, or a comic reader that stares blankly at a folder of .chd files.
If you've already gone down the "build a retro console you actually own" path, this is the layer above it: the part that decides what's actually in the library and keeps it there.
What the Claude-to-Pi shift actually signals
Three stories this month are the same story. Goodbye Claude, hello Pi: run it on your own box. Goldman Sachs pulling Claude Code from its bankers and traders: the rental can be revoked by procurement on a Tuesday. And llama-modchip running a 284B DeepSeek model on 64GB of RAM with no GPU: the hardware you already own is getting embarrassingly capable.
That last one matters most for a game library, because the reason self-hosting ROM management was miserable five years ago wasn't ideology. It was capability. You scraped metadata with a Perl script and a prayer, named folders by hand, and copied saves to a handheld over USB like an animal.
What changed is hash-based identification, real metadata APIs, and an emulator that runs in the browser. You point a container at a folder now and it tells you what you own. That's genuinely new, and it's why the RomM-vs-Kavita question even exists — nobody asked it in 2019 because neither tool would have helped. The other half of the reason is the one in "Patrick Stewart Voiced the First Ten Minutes of Oblivion": the physical media is decaying, the storefronts are shutting down, and the library is the part worth keeping.
RomM: a real ROM manager
RomM (ROM Manager) is the closest thing to a proper library system for ROMs that I've run. The stack is a Vue front end, a Python backend, MariaDB, and Redis. It's fat, and you pay for that fat in RAM — the same tradeoff I complained about in Ollama vs llama.cpp vs vLLM, just with fewer GPUs involved.
What it gets right:
- Identification. It hashes your files (Hasheous) instead of trusting filenames, then matches against IGDB, MobyGames, or ScreenScraper. My library was full of
Final Fantasy VII (USA) [Disc1 of 3] (Rev 1).bingarbage and it sorted it out without me renaming anything. - The annoying formats. Multi-disc games,
.m3uplaylists, BIOS files, patches. This is where hand-rolled setups die, and RomM handles it. - Play in browser. EmulatorJS. It is not how I'd play Metal Gear Solid, but it's how I verify a ROM actually boots before I sync 300GB to a handheld.
- An API. This is the underrated part. RomM exposes your library, covers, saves, and save states over HTTP, and the community has built small sync tools on top of it. Saves follow me from desktop to handheld without me thinking about it.
- Multi-user with per-platform permissions. My kid gets the SNES and Genesis shelves. That's it.
Where it's weak: RomM is under heavy development, and I have broken my install twice by pulling latest. Pin your image tag. Dump the MariaDB volume before every upgrade. And it will not touch your manga, your PDFs, or your strategy guides — that's not what it's for.
Kavita: a reader that people keep pointing at games
Kavita is a .NET reading server. Manga, comics, ebooks, PDFs, image folders. Its entire design is series parsing, reading progress, and a reader that is genuinely pleasant at 1am on a tablet. SQLite by default with Postgres optional, a few hundred megabytes of RAM, and a scanner that eats a 50,000-file library for breakfast. It speaks OPDS, so Mihon/Tachiyomi and a pile of other readers connect to it directly. Metadata beyond filename parsing and scrobbling live behind the paid Kavita+ tier.
And here's where I have to be blunt with you: Kavita has no launcher, no ROM identification, no save sync, and no emulator. Its library types are built for reading formats. There's a long-running feature request about games; whatever eventually lands there is going to be a shelf for cover art and PDFs, not a manager. If a forum post told you Kavita is "the other ROM server," they meant it as a reading companion and the thread lost that detail somewhere around page four.
Where Kavita actually earns its slot in a game-focused setup is the paper that comes with games. Strategy guides. Artbooks. Manuals. The comic adaptations. The scanned Nintendo Power issues you absolutely did not download. I run a /srv/books/games tree in Kavita alongside the RomM library, and for anyone with more than a shoebox of gaming ephemera it's the correct answer — Kavita is much better at being a reader than RomM will ever be, and RomM is much better at being a manager than Kavita will ever be.
The comparison
| RomM | Kavita | |
|---|---|---|
| Built for | ROM libraries and emulation | Manga, comics, ebooks, PDFs |
| Formats | ROMs, ISOs, disc images, multi-file sets | CBZ/CBR, EPUB, PDF, image folders |
| Identification | File hash + IGDB / MobyGames / ScreenScraper | Series/volume parsing from filenames |
| Launches games | Yes — EmulatorJS in browser, API for external frontends | No |
| Save/state sync | Yes, via API and community sync tools | No (reading progress only) |
| Database | MariaDB + Redis (required) | SQLite by default, Postgres optional |
| RAM footprint | ~600MB–1.5GB for the full stack | ~150–400MB |
| Mobile access | Responsive web UI, API clients | OPDS, Mihon/Tachiyomi, web UI |
| Metadata cost | Free, but IGDB needs Twitch credentials; ScreenScraper rate-limits | Free; extras behind paid Kavita+ |
| Failure mode | Upgrades break things; scrapers get throttled | You point it at ROMs and it does nothing useful |
| Best for | Owning a ROM library | Owning a reading library |
What I actually run (with compose)
Both, on the same box, behind one reverse proxy. They don't conflict — different ports, different databases, different jobs.
# /srv/romm/docker-compose.yml
services:
romm:
image: rommapp/romm:3.7.1 # pin it. seriously.
container_name: romm
restart: unless-stopped
environment:
DB_HOST: romm-db
DB_NAME: romm
DB_USER: romm
DB_PASSWD: ${DB_PASSWD}
ROMM_AUTH_SECRET_KEY: ${ROMM_AUTH_SECRET_KEY}
IGDB_CLIENT_ID: ${IGDB_CLIENT_ID}
IGDB_CLIENT_SECRET: ${IGDB_CLIENT_SECRET}
volumes:
- ./library:/romm/library # roms/<platform>/<files>
- ./assets:/romm/assets # covers, manuals, saves
- ./config:/romm/config
ports:
- "8080:8080"
depends_on:
romm-db:
condition: service_healthy
romm-db:
image: mariadb:11
restart: unless-stopped
environment:
MARIADB_ROOT_PASSWORD: ${DB_ROOT_PASSWD}
MARIADB_DATABASE: romm
MARIADB_USER: romm
MARIADB_PASSWORD: ${DB_PASSWD}
volumes:
- romm-db-data:/var/lib/mysql
healthcheck:
test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
interval: 10s
retries: 5
romm-cache:
image: redis:7-alpine
restart: unless-stopped
volumes:
- romm-redis:/data
volumes:
romm-db-data:
romm-redis:
Generate the two secrets with openssl rand -base64 32 and drop them in a .env next to the file. Env var names do shift between RomM releases — diff your file against the upstream compose before upgrading.
Kavita is a one-liner:
docker run -d --name kavita -p 5050:5000 \
-v /srv/books/games:/books/games \
-v /srv/kavita/config:/kavita/config \
--restart unless-stopped jvmilazz0/kavita:latest
And for verifying the RomM API is doing what you think it is:
# list platforms RomM has identified in your library
curl -s -u "kutak:${ROMM_PASS}" http://romm.lan:8080/api/platforms \
| jq -r '.[].name'
If that comes back empty after a scan, your library mount is wrong — nine times out of ten it's a read-only bind or a UID mismatch on the host directory.
The parts nobody warns you about
Metadata sources are rate-limited and contractual. ScreenScraper has daily quotas, and IGDB requires Twitch developer credentials that you have to keep alive. Pointing a fresh RomM at 400GB and letting it rip will get you throttled and produce a half-scraped library with gaps you'll be re-running for a month. Scan one platform first.
Back up the database, not the library. Your ROMs are replaceable-ish — you own the discs, or the store receipts. The MariaDB volume, the assets directory, and the config directory are not. Nightly mariadb-dump plus a restic snapshot of the configs is enough. This is the same boring backup discipline from Practical Homelab: Self-Hosting for Real-World DevOps Automation, and it's the difference between a bad evening and a lost archive.
Filenames still matter. Hash matching saves you from bad names, but a clean roms/<platform>/<Title (Year)>.zip layout makes scans faster and rescrapes far more accurate. Don't fight it because you're proud of your 2011 naming scheme.
Kavita+ is a paid tier on an open-source core. I'm not mad at it — metadata infrastructure costs money and I'd rather pay for it than lose the project — but it's a licensing pattern worth understanding before you build a workflow on top of it.
What to do next
Decide by format, not by vibes. If the collection is ROMs and disc images, run RomM and accept the MariaDB stack as the cost of doing business. If it's manga, guides, artbooks, and PDFs, run Kavita and be happy with 300MB of RAM. If you have both — and most of us do — run both and stop treating it as a choice.
Then do three things in this order: pick the image tags and write them down, set up the DB dump before you add a single ROM, and scan one platform end to end to see what your metadata sources actually give you.
The Pi post is right about the shape of the thing. Renting the layer that holds your library means someone else can change the terms, throttle you, or turn it off. Building it yourself means an evening of compose files and a lifetime of it not being someone else's decision.
Recommended tools & services
Disclosure: some links below are affiliate links. If you buy through them I may earn a commission at no extra cost to you. I only list tools I actually run.
| Tool | Why it is here | |
|---|---|---|
| Amazon - SSDs & NVMe | Boot drives and storage for your homelab | Visit |
| Amazon - Mini PCs | Low-power always-on nodes (ProDesk, EliteDesk, N100 boxes) | Visit |
| Amazon - PC Components | CPUs, RAM and cases for a build | Visit |
| Amazon - GPUs | Consumer GPUs for local inference (16GB VRAM is the sweet spot) | Visit |
| Amazon - RAM & Memory | More RAM is the cheapest upgrade for VMs and containers | Visit |
| Amazon - Raspberry Pi & SBCs | Pi 5, Zero and clones for Pi-hole, DNS and thin clients | Visit |