Patrick Stewart Voiced the First Ten Minutes of Oblivion. Your ROM Library Should Outlive the Disc.
RomM manages and plays ROMs with rich metadata; Kavita handles manuals, art books, manga, and scans. They solve different parts of self-hosting a game library, and running both often makes sense.
Patrick Stewart Voiced the First Ten Minutes of Oblivion. Your ROM Library Should Outlive the Disc.
Patrick Stewart died on October 29. If you played The Elder Scrolls IV: Oblivion in 2006, you heard him before you saw a single goblin — Emperor Uriel Septim VII, in a cell under the Imperial City, telling you the dreams have been troubled. It's one of the more unlikely pieces of casting in game history and it worked completely.
That's the part nobody talks about when a storefront shuts down. Oblivion is still buyable, more or less. The Dreamcast library mostly isn't. Neither is a long tail of PS2, Saturn, and DS titles that only exist now as ISO files on someone's NAS. The games keep getting delisted, the discs keep rotting, and the hardware keeps dying — which is why I've spent a stupid amount of evenings getting my game library into something I actually own.
Two names come up constantly when you look into this: RomM and Kavita. They get compared a lot. They are not the same tool, and the comparison is half wrong — but you still have to decide where your files live, so let's do it properly.
What these two things actually are
RomM is a ROM manager and browser-based player. You point it at a directory of ROMs, it hashes them, matches them against metadata providers (IGDB, Screenscraper, MobyGames), pulls box art, screenshots, release dates, and lets you play a chunk of them in the browser through EmulatorJS. It also exposes an API that RetroArch and MuOS can talk to, so your handheld gets its library from the server instead of from a microSD card you keep forgetting to sync.
Kavita is a reading server. Manga, comics, PDFs, EPUBs, and — relevant here — art books, strategy guides, scanned manuals, and the enormous pile of fan-translated material that comes bundled with a lot of ROM sets. Kavita does not manage ROMs. It will not launch an emulator. It does not know what a .gba file is.
So when someone asks "RomM or Kavita for my game library," the honest answer is that Kavita isn't in that category. The real question is whether you need one server or two, and I think the answer is usually two, running side by side, sharing the same storage pool.
I run both. RomM handles the games, Kavita handles everything printed that came with them, and the overlap is smaller than you'd expect.
Why this matters more than it did five years ago
Delisting isn't new, but the pace changed. Between storefront closures, license expirations on licensed music, and the general willingness of publishers to pull anything that isn't currently monetizing, the "I'll just buy it later" plan has an expiry date. Physical media rots, too — disc rot on CD-based consoles is real, and pressing quality on some 90s runs was not great.
If you already went down the route of building a retro console you actually own, you've solved the playback problem. The library problem is the next one: a folder with 4,000 files named things like Final Fantasy VII (USA) (Disc 1) [!].bin is technically a collection and functionally a mess.
That's the actual job here. Not emulation. Cataloging.
RomM vs Kavita: the honest comparison
| RomM | Kavita | |
|---|---|---|
| Primary purpose | ROM library management, metadata, browser play | Manga/comic/book/PDF reading server |
| Handles ROMs | Yes | No |
| In-browser play | Yes (EmulatorJS, platform-dependent) | N/A |
| Metadata sources | IGDB, Screenscraper, MobyGames, SteamGridDB | ComicVine, MangaDex, MyAnimeList, Hardcover |
| Formats | ROM/ISO archives, multi-disc, saves, BIOS | CBZ, CBR, PDF, EPUB |
| Native clients | Web, RetroArch, MuOS (API) | Web, OPDS, Tachiyomi/Mihon extensions |
| Scanner behavior | Hash-based matching, dedupe | Folder/chapter parse, series grouping |
| Database | MariaDB, Redis | SQLite |
| Resource footprint | Heavier (DB + Redis + app) | Light (~200–400MB RAM idle) |
| Backup story | Dump MariaDB + library + assets | Copy SQLite file + library |
| Best fit | Your actual game collection | Manuals, art books, guides, manga scans |
Notice the footprint row. RomM is a real application stack now — MariaDB, Redis, the app container. Kavita is a single .NET binary with a SQLite file behind it. If you're running this on a Raspberry Pi alongside six other things, that difference is not academic.
Getting RomM running
Here's the compose file I use. This is trimmed to the parts that matter; everything else is defaults.
services:
romm:
image: rommapp/romm:latest
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}
- SCREENSCRAPER_USER=${SCREENSCRAPER_USER}
- SCREENSCRAPER_PASSWORD=${SCREENSCRAPER_PASSWORD}
- TZ=Europe/Amsterdam
volumes:
- /srv/romm/library:/romm/library
- /srv/romm/assets:/romm/assets
- /srv/romm/config:/romm/config
- /srv/romm/resources:/romm/resources
ports:
- "8080:8080"
depends_on:
romm-db:
condition: service_healthy
romm-db:
image: mariadb:11
restart: unless-stopped
environment:
- MARIADB_DATABASE=romm
- MARIADB_USER=romm
- MARIADB_PASSWORD=${DB_PASSWD}
- MARIADB_ROOT_PASSWORD=${DB_ROOT_PASSWD}
volumes:
- /srv/romm/db:/var/lib/mysql
healthcheck:
test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
interval: 10s
timeout: 5s
retries: 5
Generate the auth key properly — don't paste a placeholder:
openssl rand -hex 32
The library volume is the one that matters. RomM expects a folder per platform, named by platform slug:
/srv/romm/library/
├── snes/
├── psx/
├── gba/
└── dreamcast/
Slugs come from the IGDB platform list, so psx not playstation-1, gba not gameboy-advance. Get this wrong and the scanner will happily ingest 800 files into a platform called "Unknown" and you'll be renaming things by hand for an hour. I know this because I did it in August.
If your existing collection is organized some other way, a small loop saves you the pain:
# Move loose SNES roms into the slug folder RomM expects
mkdir -p /srv/romm/library/snes
find /srv/old-roms -maxdepth 1 -iname '*.sfc' -o -iname '*.smc' \
| while read -r f; do mv -n "$f" /srv/romm/library/snes/; done
Then run a scan from the RomM UI and let the hashing do its thing. Multi-disc games get grouped automatically if the filenames follow No-Intro conventions — (Disc 1), (Disc 2). If you renamed everything to ff7_disc1_final.bin in 2009, you'll want to fix that first.
Where Kavita earns its place
Here's the thing nobody mentions in RomM reviews: a huge number of good ROM sets ship with scanned manuals, and fan translations often come with PDF patches, readme files, and the occasional art book. RomM will index none of that. It has no concept of a PDF.
Kavita does, and it does it well. Point a library at your scans directory, pick "Manga" or "Comic" or "Book" depending on what's actually in there, and it parses series, volumes, and chapters from the folder structure. The OPDS feed means you can pull it into a phone reader. The Tachiyomi/Mihon extension means you can read a scanned PS1 manual on the train like it's 1998 and you're avoiding eye contact.
My setup splits cleanly:
/srv/romm/library— the ROMs themselves, managed by RomM/srv/kavita/library/manuals— scanned manuals, art books, guides, PDFs- Both backed up nightly to a separate physical disk
Kavita's config is a SQLite file. Backing it up is cp kavita.db kavita.db.bak. RomM's is a MariaDB dump plus the assets and resources volumes, which is three times the work. If you're going to run exactly one of these and your interest is games, run RomM and put the manuals in a Nextcloud share. If your pile is mostly manga with a couple of game art books, run Kavita and don't think about ROMs at all.
The operational bits people skip
Both of these run fine as LXC containers on Proxmox, which is how I deploy them. If you're doing that, the notes in my Proxmox tips for a privacy-forward stack are worth reading before you start — particularly the bit about bind mounts versus passing through a whole disk. A 4TB library on an LXC bind mount is fine. A 4TB library on a ZFS dataset that you also snapshot hourly is going to make you sad when the snapshot delta hits 200GB because RomM re-downloaded cover art.
Two things I'd flag from experience:
Don't put RomM's assets and resources volumes on slow storage. They're thousands of small images. On a spinning disk, the web UI feels like it's running through treacle. Move them to SSD.
Rate-limit your metadata scrapes. Screenscraper will throttle you and IGDB has a quota. Scanning 5,000 ROMs in one pass on first setup will burn through it and leave you with half-populated entries. Do it in platform batches. The rescan button exists and works fine.
And backups: the scalable homelab stack writeup covers the pattern I use, but the short version is that the library itself is the irreplaceable part and the database is the disposable part. Snapshot the ROMs offsite. If the MariaDB volume dies, you re-scan and lose your play history and save states. Annoying, not fatal.
What to actually do
If you have more than a hundred ROMs sitting in a folder somewhere, install RomM this weekend. Fifteen minutes of compose file, another hour of fixing platform slugs, and you'll have something that looks like a real library instead of a hoard. The box art alone changes how often you actually play the things.
If you have scanned manuals, art books, or manga, install Kavita too. It's a single container, it uses almost nothing, and it's the only one of the two that will ever show you a PDF.
And if you're staring at a shelf of discs going cloudy, rip them. Patrick Stewart's Emperor Uriel Septim has been preserved on a million hard drives already. The stuff with a print run of 12,000 copies and no digital release hasn't been. That's the part worth doing this weekend.
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 |