# Librum, a book reader that treats your library as data you own

> Librum pairs a Qt and C++ reading experience with a library manager, a free catalogue of more than 70,000 books, device syncing and an optional self-hosted backend. The interesting part is the split between the client and Librum-Server.

**Librum-Reader/Librum** — The Librum client application

- Repository: https://github.com/Librum-Reader/Librum
- Website: https://librumreader.com
- Stars: 5,319 · Forks: 191
- Language: C++
- License: GPL-3.0
- Published: 2026-10-08 · Updated: 2026-10-08 · Language: en
- Canonical page: https://hysenlabs.com/projects/librum-reader-librum

## What Librum actually is, according to its own README

Librum opens by insisting it is not just an e-book reader. The README makes the larger claim explicit: you can manage your own online library and reach it from any device, and it offers free access to more than 70,000 books. That framing matters because it changes what you are evaluating. A reading view is easy to build and hard to differentiate. A library manager with a catalogue, sync between devices, and metadata editing is a much bigger surface with much more room to go wrong.

The stated feature set covers a modern e-reader, a customizable online library, book metadata editing, a free in-app bookstore with more than 70,000 books, syncing across devices, highlighting, bookmarking, text search, a folder system, and customization. The format support is broad: PDF, EPUB, CBZ for comics, FB2, TIFF, Mobi, XPS, and plain images. TIFF and image support alongside the document formats is a small signal that this is aimed at people who read scanned material, not only reflowable books.

The project is GPL-3.0, written in C++, and built around Qt 6.5 with QML. The repository topics back that up, listing cmake, cpp, qml, qt, and qt6 alongside reader, ebooks, and library-management. The tree is structured the way you would expect from a native desktop project: `src/`, `libs/`, `cmake/`, `resources/`, `tests/`, and `scripts/` at the top level, plus platform packaging files such as `librum.desktop`, `app_info.json`, and `com.librumreader.librum.metainfo.xml` for Linux distribution metadata.

## The README contradicts itself on note-taking, and reading statistics

Here is a real inconsistency worth knowing about before you install anything. The introduction lists note-taking among the features Librum has, alongside AI tooling and highlighting, and it also claims the project provides personal reading statistics. Later, in the detailed feature list, three items carry a Coming Soon marker: note-taking, TTS, and personalized reading statistics.

So the same document presents note-taking and reading statistics as existing capabilities in its opening paragraph and as unimplemented in its feature list. Rather than guess which is current, the honest reading is that the marketing paragraph runs ahead of the shipped build, and the feature list is the more reliable of the two. Check the issue tracker before planning around either feature.

There is a related gap between release and repository. The most recent push to the repository is dated 2026-04-26, but the newest tagged release is v.0.12.2 from March 2024, with v.0.12.1 and v.0.12.0 shortly before it. The development version numbering carries a stray dot, as in v.0.12.2, which suggests a convention that predates Semantic Versioning. All of this means work is landing on `main` without a matching tagged release, so building from source will give you something newer than the last published binary, and you should expect the shape of the interface to differ from what a released build shows you.

## Formats, platforms, and what is not finished yet

The platform story is straightforward with one important asterisk. Windows, GNU/Linux, and macOS are supported today. iOS and Android are both listed as Coming Soon. The README still insists that Librum's aim is to work on any platform so you can always continue your book, and it calls the application cross platform, but two of the five listed platforms are not there. Note also that when people search for this project they land on a mod list called Librum Modlist, which is an entirely different thing.

The asterisk is the sync story. Book syncing across devices only delivers on the promise if your other devices can run the client, so today the feature is really cross-platform desktop sync. That does not make it less useful; three desktop platforms plus a self-hosted server is a coherent setup. It does mean the marketing sentence oversells the current state by a factor of five.

On the feature side, the Coming Soon markers are the place to look before you commit. Note-taking, text to speech, and personalized reading statistics are all listed as forthcoming. Everything else on the list, including highlighting, bookmarking, text search, folders, and metadata editing, is presented as current.

## Self-hosting is a config flag, not a fork

This is the most architecturally interesting decision in the project. Librum does not bundle its own server. To run against your own backend you install and run Librum-Server separately, then point the client at it with two configuration values.

On Linux you edit the config file at `~/.config/Librum-Reader/Librum.conf` and set `selfHosted=true` along with `serverHost` pointing at your server's URL, with the README giving `serverHost=https://127.0.0.1:5001` as the example. On Windows you open the registry editor and set the same two values under the Librum-Reader key in HKEY_CURRENT_USER. There is a practical gotcha the README calls out: run the application once before making these edits, because it generates the required files on first launch.

The consequence is that the free catalogue of more than 70,000 books is a function of which server the client talks to. Self-hosting means you own the catalogue too, and it means the moment you flip that flag your reading library stops being a curated service and becomes whatever your server holds. For a reader worried about vendor lock-in on their own reading history, that is the whole ballgame, and the GPL-3.0 licence on both halves means you can read the code behind both.

## Building from source on Linux

The build guide is short because the project is a conventional CMake application. The prerequisites are cmake, make, g++, python3-venv, and Qt 6.5, with a note to install python3-venv via apt on Ubuntu. The Qt version floor is worth noting: 6.5 is not the current Qt release, so check what your distribution ships before you start.

The clone, configure and build sequence is the standard out-of-source CMake pattern, which keeps your build artifacts out of the source tree:

```sh
git clone https://github.com/Librum-Reader/Librum.git --recursive
cd Librum
mkdir build-Release
cd build-Release
cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTS=Off -DCMAKE_PREFIX_PATH=<path/to/Qt> ..
```

The `--recursive` flag on the clone matters because the repository has a `.gitmodules` file, and the submodules are needed for a working build. The cmake line is where the real configuration happens: it sets the install prefix, forces a Release build, turns off the test targets with `BUILD_TESTS=Off`, and points at your Qt installation. There is a `tests/` directory in the tree, so if you intend to work on the codebase you would drop that flag and build the tests too.

One documentation flaw to be aware of: the cmake fence in the README is closed with a single backtick rather than three, so if you copy the block wholesale from the rendered page you may pick up stray characters. The command itself is correct.

## Where a new user should start, and where the docs actually live

The README is strong on screenshots and on the parts of the product that are finished, and thin on anything you would need to configure. There is no settings reference, no keyboard shortcut list, and no explanation of the folder system beyond the word unlimited customization. The table of contents makes this explicit: Documentation points to the project GitHub wiki, and Contributing points to a page on the Librum Reader website rather than to anything in the repository.

That split matters for evaluating the project. The repository tells you what the application is and how to compile it. The wiki and the website tell you how to use it. If you are deciding whether to switch from a commercial reader, the wiki is where the answer lives.

Contributing is unusually approachable for a project this size. Feature requests, bugs and tasks are all tracked in the issue tracker, easy tasks are labelled good first issue, and the maintainer asks to be tagged directly in issue comments for questions. Translations follow a documented path through Qt Linguist, with the English source file named `librum_en.ts` and new files following a locale suffix convention. The translation instructions also carry practical advice that most projects skip: keep translations roughly the same length as the original, and check spelling and punctuation carefully. That is what happens when a project is small enough for one person to hold the whole translation workflow in their head.

Finally, the funding model is worth knowing. Donations and GitHub sponsorship cover server costs, which tells you the free catalogue and the hosted sync are subsidised rather than being a separate paid tier. If you self-host, that cost disappears from your side of the ledger.

## Conclusion

Librum sits in a useful middle position: more capable than a bare reading view, more open than a store-locked reader, and small enough to read in an afternoon. Its C++ and Qt 6.5 build with CMake is approachable for anyone who has compiled a native project before, and the folder and metadata features are the ones worth knowing about. The two things to check before committing are the release gap, since the newest tagged build is well behind the last push, and the mobile story, which the README still lists as coming soon.

## FAQ

### What is Librum Reader?

Librum is an open source e-book reader and library manager for Windows, Linux and macOS, built in C++ with Qt 6.5 and QML. It manages a personal library, supports formats including PDF, EPUB, CBZ, FB2, TIFF, Mobi and XPS, and syncs books across devices.

### Can I self-host Librum?

Yes, by running Librum-Server separately and pointing the client at it. On Linux you set selfHosted=true and serverHost in the config file at ~/.config/Librum-Reader/Librum.conf; on Windows you set the same two values in the registry. You must launch the app once first so it creates those files.

### Does Librum have a mobile app for iOS and Android?

Not yet. The README lists Windows, GNU/Linux and macOS as supported, with iOS and Android both marked Coming Soon. Device syncing therefore currently means syncing between desktop platforms.

### How do you build Librum from source on Linux?

Install cmake, make, g++, python3-venv and Qt 6.5, clone the repository with the --recursive flag so submodules are fetched, create a build folder, and run cmake with -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTS=Off pointing at your Qt path. The README has the full sequence for GNU/Linux.

### What book formats can Librum open?

The README lists PDF, EPUB, CBZ for comics, FB2, TIFF, Mobi, XPS and images, alongside other formats. Support for scanned material through TIFF and image files suggests it handles both reflowable and fixed-layout books.

## Sources

- [Librum-Reader/Librum on GitHub](https://github.com/Librum-Reader/Librum)
- [License: GPL-3.0](https://github.com/Librum-Reader/Librum/blob/main/LICENSE)
- [Project website](https://librumreader.com)
- [README](https://github.com/Librum-Reader/Librum/blob/main/README.md)
- [Releases](https://github.com/Librum-Reader/Librum/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/librum-reader-librum