Stump vs Komga: Which Comic Server to Self-Host?

Quick Verdict

Komga is the better choice today. It’s mature, stable, and has a rich ecosystem of third-party reader apps. Stump is a promising Rust-based alternative with a modern UI, but it’s still pre-release software (v0.0.12) and not ready for production use. Pick Komga now; keep an eye on Stump for later.

Overview

Both Stump and Komga are self-hosted comic and manga servers that scan your library of CBZ, CBR, PDF, and EPUB files, organize them into series, and serve them through a web-based reader.

Komga is a mature Java/Kotlin application built by gotson. It’s been in active development since 2019, has a stable API, strong OPDS support, and a large ecosystem of compatible reader apps. It’s the go-to recommendation for self-hosted comics.

Stump is a newer Rust-based alternative built by Aaron Leopold. It aims to be a faster, lighter comic server with a modern React UI. However, as of v0.0.12 (October 2025), it’s still explicitly marked as “not ready for normal usage” by its developer.

Feature Comparison

Feature	Stump (v0.0.12)	Komga (v1.24.1)
Web reader	Yes	Yes
OPDS support	Basic	Full (OPDS + OPDS-PSE)
Format support	CBZ, CBR, PDF, EPUB	CBZ, CBR, PDF, EPUB
Metadata scraping	Basic	Advanced (ComicInfo.xml, epub metadata)
Read progress tracking	Yes	Yes
User management	Yes (multi-user)	Yes (multi-user, with age restrictions)
Collections/read lists	Basic	Yes (collections + read lists)
API	REST API	Full REST API + SSE events
Third-party app ecosystem	Minimal	Large (Tachiyomi, Panels, Chunky, etc.)
Duplicate detection	No	Yes
Full-text search	No	Yes
Docker image size	~30 MB	~200 MB
Language	Rust	Kotlin/Java
License	MIT	MIT

Installation Complexity

Both are single-container deployments. Setup is straightforward for either.

Stump:

services:
  stump:
    image: aaronleopold/stump:0.0.12
    container_name: stump
    ports:
      - "10801:10801"
    environment:
      - PUID=1000
      - PGID=1000
    volumes:
      - stump-config:/config
      - /path/to/comics:/data
    restart: unless-stopped

volumes:
  stump-config:

Komga:

services:
  komga:
    image: gotson/komga:1.24.1
    container_name: komga
    ports:
      - "25600:25600"
    environment:
      - PUID=1000
      - PGID=1000
    volumes:
      - komga-config:/config
      - /path/to/comics:/data
    restart: unless-stopped

volumes:
  komga-config:

Neither requires an external database — both use embedded SQLite. Stump’s smaller image makes initial pull faster, but that’s a one-time difference.

Performance and Resource Usage

Stump’s Rust foundation gives it a significant edge in resource efficiency.

Metric	Stump	Komga
RAM (idle)	~30-50 MB	~200-400 MB
RAM (scanning)	~80-150 MB	~500 MB-1 GB
CPU (idle)	Minimal	Minimal
Startup time	~1 second	~5-10 seconds
Docker image	~30 MB	~200 MB
Disk (config)	~50 MB	~100 MB

Komga’s higher memory usage comes from the JVM. For Raspberry Pi or low-memory setups, Stump has a clear advantage. For any server with 2+ GB RAM, the difference is irrelevant.

Community and Support

Metric	Stump	Komga
GitHub stars	1K+	4K+
Release cadence	Slow (months between releases)	Regular (monthly)
Documentation	Basic	Comprehensive
Third-party apps	Few	Many (Tachiyomi/Mihon, Panels, etc.)
Community size	Small	Large
Project maturity	Pre-release (v0.0.x)	Stable (v1.x)

Komga’s ecosystem is its strongest advantage. Tachiyomi/Mihon (Android manga reader) has native Komga support. Panels (iOS) supports Komga via OPDS. These integrations make Komga a much better experience if you read comics on mobile devices.

Use Cases

Choose Komga If…

• You want a stable, production-ready comic server
• You read comics on mobile and need Tachiyomi/Mihon or Panels support
• You have a large library and need advanced metadata management
• You want OPDS support for third-party readers
• You need multi-user access with age restrictions

Choose Stump If…

• You’re experimenting and want to try the newest option
• You run a very low-memory server (Raspberry Pi, 512 MB RAM)
• You prefer a modern React UI over Komga’s interface
• You want to contribute to an early-stage open-source project
• You only use the web reader (no mobile app dependency)

Final Verdict

Komga is the clear winner for production use. It’s stable, feature-complete, and has the third-party app ecosystem that makes a comic server actually useful day-to-day. Mobile reading through Tachiyomi/Mihon alone is worth the choice.

Stump is an interesting project with technical advantages — it’s faster, lighter, and has a more modern frontend. But “not ready for normal usage” (per the developer) means exactly that. You’ll hit missing features and rough edges that Komga solved years ago.

Recommendation: Use Komga now. Watch Stump’s GitHub for a v1.0 release. If Stump reaches feature parity with a stable release, the Rust-based performance and modern UI could make it the better long-term choice.

FAQ

Can Stump import my Komga library?

Not directly. Both scan directories of comic files, so you can point Stump at the same library folder. But read progress, collections, and metadata edits won’t transfer between them.

Does Stump support Tachiyomi/Mihon?

Stump has a basic OPDS implementation, but it’s not fully compatible with Tachiyomi’s Komga-specific extension. You’d need to use the generic OPDS extension, which has fewer features.

Which handles large libraries better?

Komga. It has been tested with libraries of 100,000+ files and has optimizations for large-scale scanning and searching. Stump hasn’t been battle-tested at that scale yet.

Related

• How to Self-Host Komga
• How to Self-Host Stump
• Kavita vs Komga
• Kavita vs Calibre-Web
• Best Self-Hosted Ebooks & Reading
• Best Self-Hosted Media Servers
• Docker Compose Basics