You’ve Got 50,000 Issues and Nowhere to Read Them
You ripped your entire manga collection. You’ve got decades of X-Men runs. Somewhere on your NAS there are CBZ files from three different download sources, inconsistently named, living in folders that made sense at the time and now look like a crime scene. You need a server.
Plex handles your movies. Jellyfin handles your TV. But comics and manga are a different beast — page-by-page reading, double-page spreads, right-to-left layouts, ComicInfo.xml metadata, and reading apps on every device you own. You need something purpose-built.
Two options dominate the self-hosting space: Komga and Kavita. Both are free, both run in Docker, both speak OPDS. The question is which one fits your collection and workflow.
Let’s settle this.
Full example: Clone the working Compose files at github.com/KingPin/sumguy-examples/self-hosting/komga-vs-kavita-comic-servers
The Quick Version
TL;DR: Pick Komga for stable comic/manga libraries, a rock-solid REST API, and OPDS v2 support. Pick Kavita if you also need ebook (EPUB/PDF) handling in the same server or want a slicker UI out of the box.
| Komga | Kavita | |
|---|---|---|
| Stack | Java / Spring Boot | .NET 8 |
| Primary focus | Comics & manga | Comics, manga, and ebooks |
| Library structure | Series = folder | Flexible scan modes |
| OPDS support | v1 + v2 | v1 |
| API | Full REST API, well-documented | REST API, growing |
| UI age | Mature, functional | Newer, more polished |
| Metadata | ComicInfo.xml, Anilist, MangaUpdates | ComicInfo.xml, extensive scrapers |
| Active development | Yes | Yes, faster churn |
Komga: The Grizzled Veteran
Komga has been around since 2019. It’s written in Kotlin/Spring Boot, which means it starts slower than you’d like but runs rock-solid once it’s up. The project is mature, the API is stable, and if you want to build tooling around your comic server, Komga is the one that won’t break your scripts every release.
Library Structure: Folders Are Law
Komga’s core assumption is simple: one folder = one series. Drop your Amazing Spider-Man run in /comics/marvel/amazing-spider-man/ and Komga treats every CBZ/CBR/PDF inside it as issues of that series — sorted by filename. This works brilliantly if your collection is organized. It works terribly if it isn’t.
/comics/ manga/ berserk/ Berserk v01.cbz Berserk v02.cbz western/ batman-year-one/ Batman Year One 001.cbz Batman Year One 002.cbzStick to that structure and Komga is magic. Try to deviate and you’ll spend a weekend reorganizing your NAS. Honestly, you should reorganize it anyway. You know it needs it.
Running Komga
services: komga: image: gotson/komga:latest container_name: komga environment: - JAVA_TOOL_OPTIONS=-Xmx512m - TZ=America/New_York volumes: - ./config:/config - /mnt/nas/comics:/data:ro ports: - "25600:25600" restart: unless-stopped user: "1000:1000"Hit http://localhost:25600, create an admin account, add a library pointing at /data, and let it scan. First scan of a large collection will take a while — go make coffee.
The -Xmx512m cap on the JVM heap is important. Without it, Komga will happily eat 2 GB of RAM on a big library. 512 MB is enough for most setups.
OPDS and Reading Apps
Komga supports both OPDS v1 and OPDS v2 (the newer streaming-friendly version). Your OPDS feed lives at:
http://your-server:25600/opds/v1.2/catalog# orhttp://your-server:25600/opds/v2/catalogFor reading apps, the current winners are:
- Mihon (Android) — Tachiyomi’s spiritual successor, supports Komga via the Tachiyomi plugin or direct OPDS
- Paperback (iOS) — OPDS support, solid manga reader
- Panels (iOS) — polished, OPDS works well
- YACReader (desktop/iOS/Android) — OPDS client, handles CBZ/CBR natively
Komga also ships with its own web reader that’s surprisingly capable — double-page spread support, right-to-left mode, reading progress tracking.
Metadata: ComicInfo.xml and Beyond
Komga reads ComicInfo.xml embedded in CBZ files (it’s just a ZIP with a metadata file inside). This is the comic industry standard — tools like Mylar3, Calibre with comics plugins, and most download managers write these automatically.
<?xml version="1.0"?><ComicInfo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <Title>The Beginning</Title> <Series>Berserk</Series> <Number>1</Number> <Volume>1</Volume> <Year>1990</Year> <Writer>Kentaro Miura</Writer> <Genre>Fantasy</Genre> <LanguageISO>en</LanguageISO> <Manga>YesAndRightToLeft</Manga></ComicInfo>The <Manga>YesAndRightToLeft</Manga> field flips the reading direction automatically in the web reader. That one field will save you from accidentally reading 40 chapters backwards. Ask me how I know.
Komga also integrates with Anilist and MangaUpdates for automatic metadata scraping on manga libraries — covers, descriptions, ratings, the works.
The API
Here’s where Komga pulls ahead for power users. The REST API is fully documented at /swagger-ui.html and covers everything: libraries, series, books, reading progress, user management. It’s stable across versions and people have built full automation stacks around it.
# Get all series in a librarycurl -u admin:password \ http://localhost:25600/api/v1/series?library_id=abc123
# Update reading progresscurl -u admin:password -X PATCH \ http://localhost:25600/api/v1/books/xyz789/read-progress \ -H "Content-Type: application/json" \ -d '{"page": 42, "completed": false}'If you want to write scripts that sync progress, do bulk edits, or build a custom dashboard, Komga’s API is the one you want.
Kavita: The New Kid with Better UX
Kavita is younger (2021-ish), written in .NET 8, and starts up noticeably faster than Komga. The UI is more modern — it feels closer to something you’d actually put in front of a non-technical family member. It also supports ebooks (EPUB, PDF) natively alongside comics and manga, which matters if your collection is mixed.
Library Structure: More Flexible
Kavita has multiple scan modes and doesn’t mandate the strict one-folder-one-series approach. It’s smarter about inferring series from filenames, and it handles loose files in a library root better than Komga does.
You can have a library type of Comic, Manga, Books, or Mixed. Kavita adjusts its parsing logic accordingly — right-to-left defaults for manga libraries, ebook reader for book libraries, comic pagination for everything else.
/manga/ berserk/ Berserk v01.cbz one-piece/ One Piece 001.cbz One Piece 002.cbz/ebooks/ dune-frank-herbert.epub project-hail-mary.epubBoth of those can be separate Kavita libraries — comics handled one way, ebooks another, all through one web UI.
Running Kavita
services: kavita: image: jvmilazz0/kavita:latest container_name: kavita environment: - TZ=America/New_York volumes: - ./config:/kavita/config - /mnt/nas/comics:/comics:ro - /mnt/nas/manga:/manga:ro - /mnt/nas/ebooks:/books:ro ports: - "5000:5000" restart: unless-stopped user: "1000:1000"Note the multiple volume mounts — Kavita handles this cleanly because you can add each as a separate library. Komga can do this too, but Kavita’s multi-library UX feels smoother.
Metadata and Scrapers
Kavita reads ComicInfo.xml like Komga does, but its metadata scraping story is broader. It integrates with:
- AniList for manga
- ComicVine for western comics
- MangaUpdates
- MyAnimeList
- Google Books for ebooks
The scrapers are configured per-library and run automatically on new additions. For a mixed collection that includes manga, comics, and light novels, Kavita’s metadata coverage is genuinely better out of the box.
OPDS: The One Downside
Kavita only supports OPDS v1. That’s fine for most reading apps, but if you’ve got a client that specifically wants OPDS v2 streaming (some newer apps do), you’ll hit a wall. For day-to-day use with Mihon, Paperback, or YACReader, OPDS v1 works perfectly.
Your OPDS endpoint:
http://your-server:5000/api/opds/your-api-key/catalogThe API key is per-user and lives in your profile settings. Slightly more friction to set up than Komga, but not a dealbreaker.
The UI Difference
This is subjective, but it’s real. Kavita’s reading UI handles double-page spreads, zoom, and page fitting more gracefully than Komga’s. The library browsing feels more like a polished app. If you’re setting this up for someone who just wants to read their manga without fussing with settings, Kavita is the easier sell.
Head-to-Head: The Details That Matter
Performance at Scale
Both servers handle 50k+ files, but they behave differently:
- Komga front-loads work — initial scans are slower, but queries are fast because everything’s indexed in a SQLite database that Komga manages carefully.
- Kavita scans faster initially but can get sluggish on very large libraries during re-scans. .NET startup time is much faster than Java, which matters if you restart containers frequently.
Neither will melt a modern homelab server. A Pi 4 might struggle with Komga’s JVM overhead. A modest x86 box handles both comfortably.
Reading Progress Sync
Both servers track reading progress server-side and sync it across clients via OPDS or their APIs. If you switch from your phone to your tablet mid-chapter, you’ll land on the right page.
Komga’s progress sync via the Tachiyomi/Mihon plugin is well-tested and reliable. Kavita’s sync works well too but has had more version-to-version quirks historically.
Users and Sharing
Both support multiple users with per-library permissions. Komga has age ratings and content filtering per user — useful if the server is shared and some libraries contain content that isn’t for everyone. Kavita has similar controls but Komga’s have been around longer and are more granular.
Which One Should You Run?
Run Komga if:
- Your collection is comics and manga only, no ebooks
- You want a stable, well-documented API for automation
- You’re building tooling (Mylar3 integration, progress sync scripts, etc.)
- You already have a clean folder structure or are willing to enforce one
- API maturity and long-term stability matter more than UI polish
Run Kavita if:
- You have a mixed collection: comics, manga, AND ebooks
- You want a more polished UI that non-technical users can navigate
- You need broad metadata scraping across multiple sources out of the box
- Faster startup time matters (containers that restart frequently)
- You want library type specialization (manga vs comics vs books all tuned separately)
Honestly, running both isn’t crazy. Komga for your organized western comics library where you want API access. Kavita for the manga + light novel pile where UI and metadata matter more. They don’t conflict on ports and the storage footprint is negligible.
A Note on Reading Apps
Whatever server you pick, the reading app experience matters. Current recommendations as of mid-2026:
Android:
- Mihon — Tachiyomi fork, actively maintained, excellent OPDS support, Komga plugin available
- Tachiyomi forks — check the current alive one, the ecosystem fragments regularly
iOS:
- Paperback — solid OPDS client, good manga reader, free
- Panels — cleaner UI, worth the few dollars, handles comics well
Desktop:
- YACReader — native OPDS client, available everywhere, slightly dated UI but works
- Komga/Kavita web reader — surprisingly good for casual reading, no app install required
Both servers work with all of these. Pick your server based on your collection and workflow, not which reading app you prefer.
The Bottom Line
Your 2 AM self doesn’t want to figure out why chapter 47 imported as a separate series again. Komga’s strict folder structure prevents that headache if you respect it. Kavita’s flexible scanning is more forgiving if your collection is a beautiful disaster.
Both are genuinely excellent pieces of software maintained by small teams doing impressive work. Run them in Docker, point them at your NAS, and stop reading manga in a browser like it’s 2012.
