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.

Home server setup with retro game controllers, manga, and art books for RomM and Kavita.

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.

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.

ToolWhy it is here
Amazon - SSDs & NVMeBoot drives and storage for your homelabVisit
Amazon - Mini PCsLow-power always-on nodes (ProDesk, EliteDesk, N100 boxes)Visit
Amazon - PC ComponentsCPUs, RAM and cases for a buildVisit
Amazon - GPUsConsumer GPUs for local inference (16GB VRAM is the sweet spot)Visit
Amazon - RAM & MemoryMore RAM is the cheapest upgrade for VMs and containersVisit
Amazon - Raspberry Pi & SBCsPi 5, Zero and clones for Pi-hole, DNS and thin clientsVisit