Kapowarr is a comic book library manager in the shape of the *arr apps

A library manager shaped like the *arr applications

Kapowarr describes itself as software to build and manage a comic book library, fitting in the *arr suite of software, and it leans on that comparison deliberately. The README lists the recognisable UI from the *arr suite as a feature, which is shorthand for a specific workflow: you describe what you want in the settings, the application searches for it, grabs it, and puts the file where it belongs under a name you chose.

The unit of work is the volume, not the issue. You add a volume, map it to a folder, and then the app manages the issues inside it, including trade paperbacks, one shots and hard covers. Search comes in two modes, a Search Monitored that downloads whole volumes with one click and a Manual Search where you pick what to download yourself. There is also a path for people who already have comics on disk, since the README says you can import your existing library right into Kapowarr.

The stack is a Python web application. Kapowarr.py is the entry point, with backend/ and frontend/ directories, a Dockerfile, a docker-compose.yml, an entrypoint.sh and a pyproject.toml that names the author as Cas van Tijn and the version as 1.3.2. The requirements are pinned with compatible release operators rather than exact versions, and they pull in Flask with waitress as the server, flask-socketio for the live updates the *arr interface is known for, aiohttp and requests for outbound calls, beautifulsoup4 for parsing pages, cryptography for handling encrypted links, bencoding for torrent metadata, and cron-converter for turning scheduling expressions into something runnable.

The Python floor is stated in pyproject.toml as requires-python = ">= 3.8", while the Docker image builds on Python 3.13.

The Docker image is the documented deployment

The repository ships a Dockerfile and a docker-compose.yml, and the compose file is short enough to read in full.

services:
  kapowarr:
    container_name: kapowarr
    image: mrcas/kapowarr:latest
    environment:
      - PUID=0
      - PGID=0
      - TZ=Etc/UTC
    volumes:
      - "kapowarr-db:/app/db"
      - "/path/to/download_folder:/app/temp_downloads"
      - "/path/to/comics:/comics"
    ports:
      - 5656:5656

Three volume mounts carry the state. The database lives in a named volume so it survives a container replacement, downloads land in a temp_downloads directory that the app manages, and the final library sits in a separate path mounted at /comics. Port 5656 is where the web interface is served, and the PUID and PGID variables exist so the process can run as the user who owns those files on the host.

The Dockerfile itself is a multi-stage build. The base image is python:3.13-slim-bookworm, with the distro and Python version as build arguments, and a separate rust:slim stage compiles the dependency wheels so that the runtime image installs from local files with no index. The runtime stage copies the gosu binary in, creates a kapowarr group and user with uid and gid 1000, makes the db, logs and temp_downloads directories, and exposes port 5656. The entrypoint is /app/entrypoint.sh, and the default command runs Kapowarr.py with a --LogFolder argument pointing at /app/logs.

The README does not duplicate the install steps, it points at the installation documentation on the project site, so the container path is where the configuration surface lives: the compose file is the reference for the environment variables and the volume layout.

Renaming, moving and extraction are the part you configure

The feature list is where the practical detail sits. Downloaded files automatically get moved wherever you want and renamed in the format you desire. Archive files can be extracted and their contents renamed after downloading or with a single click. The whole process is automated and can be customised in the settings.

That last sentence is doing the heavy lifting. Kapowarr is a set of conventions you define, and the value of the tool depends on how well those conventions match a real folder tree. A comic library is full of series, volumes and issue numbers with publisher naming variations, and the rename format is where that gets resolved. The README does not enumerate the available format tokens, so that part of the configuration is something you will look up in the documentation hub rather than in the README.

Downloads come from a list of services rather than a single source. The README names DDL, Pixeldrain, Mega and many other services, and the repository topics include comic-downloader and comics-downloader, so a downloader plugin model is implied. A note in the requirements list, cryptography, suggests that some of these links are encrypted, and bencoding points to torrent magnet or file handling in the pipeline. The bencoding and aiohttp combination is the kind of detail that tells you the download path handles more than a plain HTTP GET.

The comic metadata side is a separate dependency. The repository topics include comicvine-api, which indicates that a metadata provider is what drives the search, and it is presumably also what Search Monitored relies on.

Where Kapowarr stops short

The most obvious limit is that this is a management tool and not a reader. Nothing in the repository description or the feature list mentions viewing comics, reading issues in the browser, or converting to a format for reading on a phone. The conversion the README does mention is part of the file handling, not a reading pipeline.

The second limit is the metadata dependency. If the search is driven by a provider through an API, then the app's coverage of a title is only as good as that provider's catalogue. A series that is missing or misnumbered upstream is a series the monitor will never find, and the manual search path is where you would notice. The README does not discuss provider configuration, key management, or rate limits, and it does not say how many providers are supported.

The third limit is that the automation is broad. Download, move, rename, extract and rename again, all in one pipeline, acting on files in a directory you point it at. The extraction step in particular takes an archive and unpacks it into your library path. Nothing in the README describes a confirmation step, a quarantine area, or a way to preview a rename before it happens, so the sensible approach is to point the temp_downloads mount at a directory you are willing to let the app reorganise.

The fourth limit is platform. The README claims support for all major operating systems, and the Flask and waitress combination means the app is portable in principle, but the Docker image is the only deployment path actually described here, with the ports, volumes and user variables already set up for it.

Development setup, typing configuration and tests

The repository is set up for contributors in a fairly conventional Python way. Alongside pyproject.toml there are requirements-dev.txt, a tests/ directory, a.pre-commit-config.yaml, a CONTRIBUTING.md, a CODE_OF_CONDUCT.md and a.vscode/ directory, plus a.zipignore and a.dockerignore so the packaged artifacts exclude the development files.

The pyproject.toml is mostly tooling configuration. The mypy section sets warn_unused_configs and turns on caching, and then does something unusual: it enables a set of error codes including method-assign, func-returns-value, name-match, no-overload-impl, unused-coroutine, top-level-await, str-format and redundant-expr, while disabling a long list of others. The result is a deliberately narrow mypy profile. It tells you the project is checking a specific class of mistakes rather than running a strict type pass, which is a reasonable choice for a codebase with a lot of dynamic web handling, and it also tells you that a strict type-checking contributor will not be fighting the same rules the maintainers fight.

The formatting side is split between tools. autopep8 is configured with aggressive = 3, experimental = true and max_line_length = 80, and it ignores a specific set of continuation-line and whitespace rules. isort is configured with balanced_wrapping and combine_star imports.

Version numbers in this project follow a scheme worth noting: 1.3.0 shipped on 2026-03-06, 1.3.1 on 2026-03-29 and 1.3.2 on 2026-09-14, and pyproject.toml carries the same 1.3.2.

Support channels, project board and licence

The README routes everything to the documentation site at casvt.github.io/Kapowarr, with the installation instructions on their own page. That is the pattern for this project: the README is short and the manual carries the detail.

Support comes in three forms, and all three are named. There is a Discord server, a subreddit at r/kapowarr, and the option to make an issue on the GitHub repository. For planning, the README points at a GitHub project board, which is where feature requests and their progress are tracked. Donations are handled through a Ko-Fi page.

The project is licensed GPL-3.0, with the LICENSE file at the top of the tree and pyproject.toml pointing at that file for the licence declaration. GPL-3.0 requires that distributed derivatives keep the same terms.

Maintenance is active in the documented sense. The last push was on 2026-10-14, a few days before this review, and the repository is not archived. The most recent release, V1.3.2, came on 2026-09-14, and the release naming uses a capital V prefix. The README also links a write-up on the site noted.lol, which is an external mention rather than a project document.

Editorial conclusion

Kapowarr suits someone who already keeps a comic library in folders and wants the same monitor, search, rename and move pipeline that the *arr applications provide for other media, and it does not suit someone who wants a reader or a comic viewer, since the repository contains no reading or browsing component. Before adopting it, check that the comic metadata source you want is one of the indexers it supports, since the search is driven by a metadata provider rather than by files on disk. Verify first that the download services you intend to use are among the ones the README lists, and treat the extracted archive and automatic renaming behaviour as the part most likely to need adjusting to your own folder conventions.

Frequently asked questions

Official sources

1. Casvt/Kapowarr on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases