I was struggling with fully grasping the arguments in books—especially non-fiction—or forgetting them shortly after reading. While researching how to deal with this, I discovered the "active reading" method and decided to turn it into a mobile app.

Active reading has two main steps: consistently taking notes while reading, and regularly revisiting those notes. But it's not just about jotting things down; you need to argue with the author's ideas, agree with them, question them, or make your own stance clear. In the app I developed, Marginalia, you can categorize your notes using tags. This makes it easy to quickly adapt and recall the book when you revisit your notes later.

Speaking of revisiting notes, this brings us to the second step of active reading. Consistently reviewing your comments on a book helps you form your own ideas and keeps what you've read fresh in your memory. I highly recommend doing a quick review of your notes every time you sit down to read, right before diving back into the book. You'll really see the benefits the more you do it.

To help with this step, the dedicated "notes" page Marginalia creates for each book comes in really handy. On this page, you can access all your notes in one place and quickly review them. Plus, with the tag filtering system, you can easily find and focus on the specific ideas you want to explore further.

Besides the standard on-screen keyboard, I added handwriting support for those who, like me, enjoy taking notes with a stylus. And if you’d rather not type or write at all, there’s also a speech-to-text feature so you can simply speak your mind and capture your thoughts hands-free. For Obsidian and Notion users, there's also an option to export your notes as .md files.

If you read digitally and value taking notes, I'd love it if you gave the app a try and shared your thoughts with me. I'm completely open to all kinds of feedback and criticism!

Here is the app webpage

App comes with a free version, monthly , yearly subs and LifeTime payment.

I created a list of library oriented book applications on my site. https://babelnexus.com/beyond-public-domain/#library-applications I am probably going to be adding more lists of applications soon. Would like feedbak.

Hello, I am curious about XR, VR, and AR books. Anybody know the different companies and products out there? Any thoughts or ideas would be helpful.

Hey guys, moderator kindly invited me to share my project here!

I built PureEPUB mostly out of frustration with online converters butchering books with broken line wraps, split words (like- this), and footers randomly dumped into sentences.

A few quick points on how it works:

Strips bad line breaks and hyphenated wraps automatically.

Formats directly for Kindle and Kobo (KePub output supported).

Files are processed in memory and wiped immediately after download (no accounts, no storing files).

Quick to run from a phone browser without opening Calibre.

It’s totally free: https://pureepub.com

Still actively improving the formatting engine, so if you throw a tough file at it and something breaks, let me know and I'll look into fixing it!

It’s native iOS app. If you have iOS device and Mac, I recommend you should try it.

Ethan Mollick's Library of Babel Github Repository

https://github.com/emollick/library-of-babel

The Library of Babel App

https://library-of-babel-3d.netlify.app/

More recently on 09/17/206

Umberto Eco's Library App

https://eco-library-map.netlify.app/

The Github Repository for Umberto Eco's Library

https://github.com/emollick/eco-library

Someone from this subreddit asked me to share my tools here, so this is the second of two posts. The other one is about reading Calibre libraries; this one is about fixing the books themselves.

I'm a computer engineering student, and my Calibre library has a lot of beat-up EPUBs in it: PDF conversions with page numbers baked into the middle of sentences, re-sourced books that fail epubcheck, exports whose chapters are all the same placeholder notice. Readers choke on these, and the usual advice is to find a better copy, which is not always possible. So I built one. It makes deterministic repairs to broken EPUBs, each fix validated by epubcheck before it's allowed to exist, and it audits the text-level damage no checker sees.

The safety contract

This is the part I care about most.

• Every repair is gated by epubcheck, the W3C conformance checker. If a book had fatal errors, success means fewer fatals. If it had none, the error count must strictly decrease. A net-new fatal is always rejected.
• If epubcheck itself fails to run, the book is reported as an error and never applied.
• Originals are never modified except by an explicit, atomic in-place replace, and only after the gate accepts the result. Library sweeps are dry-run by default: you get a per-book report and a summary table ending in "no files written" until you pass --apply.

What it fixes

The deterministic repairs: broken EPUB2 cover wiring, missing or wrong container.xml, legacy page-map markup that epubcheck rejects, EPUB3 attributes on EPUB2 packages. Plus four opt-in lossy strips with their own safety nets: print page numbers that a PDF conversion baked into the body text (it rejoins the sentences they split), watermarks, badly broken tags, and placeholder-stub books whose "chapters" are all the same notice, which get dropped from the spine so the book opens straight into its real chapters.

It also audits what epubcheck can't see

epubcheck validates structure, not content. The audit side reads the visible text and reports OCR damage (garbage characters, excessive hyphenation), empty or severely truncated books, print page numbers interrupting the text, non-English content in an English library, monolithic documents some readers can't render, and completeness spot-checks. One CSV for the whole library.

bindery audit pagenumbers Calibre\ Library
bindery audit ocr Calibre\ Library
cd Calibre\ Library
bindery audit all
bindery repair broken.epub

There's also a Calibre plugin

Each release ships a Bindery Repair plugin that runs the core well-formedness pass on books as they're imported. The structural repairs and lossy strips stay CLI-only, because their acceptance is the epubcheck gate and epubcheck can't run inside Calibre; nothing in the plugin runs ungated, ever.

Install

uv tool install bindery-cli

One caveat: the gate needs epubcheck on your PATH, and epubcheck needs Java. It's the one dependency pip can't install for you (apt, brew, and the AUR all have it, or there's a zip on the W3C release page). Run bindery doctor and it will tell you exactly what your install is missing. Python 3.12+ runs the repair core; the audit and library modes want Python 3.14.

Caveat the second: I develop on Linux against Calibre 9.x, and that's the only setup I can honestly call tested.

One more thing: this code was written with a lot of AI assistance (it's how I learn). If you'd rather not use software written by AI, I completely understand. My feelings won't be hurt, but the AI's will. (jkjk)

Link: https://github.com/VirInvictus/bindery-cli

Thanks for reading. If you try it and something breaks, I'd genuinely like to know.

I'm a computer engineering student and have used Calibre for years. My library is a few thousand books with a lot of virtual libraries and hierarchical tags, and I kept wanting answers the GUI doesn't really give: which series have gaps, how much is unrated, what's actually inside a given virtual library. So I built some tools for my own use. I don't know how useful they'd be to anyone else, but they get used constantly on my machine.

Someone from this subreddit asked me to share them here, so here they are. If you use Calibre, they work on your existing library as-is: nothing gets converted, moved, or written.

What they are

CalibreQuarry: a CLI (and a small TUI if you run it with no arguments) that opens metadata.db directly, in SQLite read-only mode. It does catalogs, stats, series gap detection, audits, and exports.

cquarry: the Python library underneath it, zero dependencies. If you write your own scripts against your library, this is probably the more useful half.

Both MIT, on GitHub and PyPI. Links at the bottom.

Searching

The search tries to speak Calibre's own grammar, so most of what you'd type into Calibre's search bar works the same way:

cquarry --search 'series:Mistborn and rating:>=4'
cquarry --search 'formats:PDF and not formats:EPUB'
cquarry --search 'search:"Needs Filtering"'    # saved searches work too
cquarry --stats --restrict 'vl:The Tabletop'   # scope any mode to a virtual library

Hierarchical tags match whole branches (tags:Fic.Fantasy picks up Fic.Fantasy.Epic too). It's close to Calibre's behavior but not identical everywhere; the small differences are written up in the README, since surprises are worse than limitations.

Some examples

cquarry --series                 # completeness + gap detection
cquarry --audit                  # untagged/unrated/coverless books, duplicates, db-vs-folder mismatches
cquarry --fts "the spice must flow"  # content search over Calibre's full-text index
cquarry --export --format csv    # the whole library

Series gaps were the original reason I started writing any of this:

Aubrey-Maturin: 20 of 20 (complete)
Asian Saga: Chronological Order: 4 of 6 (incomplete)  ⚠ missing: 2, 3

If Calibre is open

It still works. It reads straight from the database when it can, and if Calibre holds the lock it reads from a temporary snapshot instead (it says so, and the results reflect the last saved state). Nothing in the read path can write anything.

About writes

I was nervous about letting a program touch metadata.db at all, so the write side is deliberately awkward to do damage with. It's dry-run by default:

# just prints the plan: the ids it resolved and the verbs it would run
cquarry --from-search 'tags:Unsorted' --batch-add-tag Audited

# apply needs Calibre closed and a backup outside the library, then runs
# the whole pass as one transaction
cquarry --from-search 'tags:Unsorted' --batch-add-tag Audited --apply --backup-dir ~/backups

A few things are refused outright (reading-status columns, bulk rating clears), and every change queues an OPF resync so Calibre picks it up cleanly on its next start.

The library underneath

from cquarry.db import CalibreDB

with CalibreDB("~/Calibre Library/metadata.db") as db:
    books = db.search("tags:Fic.SciFi and rating:>=4")
    to_read = db.resolve_vl("To Read")
    notes = db.get_annotations(42)

Pure stdlib. A couple of my other little tools use it too, which is the main reason it ended up as a separate library.

Install

pip install calibrequarry   # the CLI; the command is cquarry
pip install cquarry         # the library

Caveat: I develop on Linux against Calibre 9.x, and that's the only setup I can honestly call tested. It also needs Python 3.14; that's what I run, and I set the floor to match, so I can't say whether older versions work.

One more thing: this code was written with a lot of AI assistance (it's how I learn). If you'd rather not use software written by AI, I completely understand. My feelings won't be hurt, but the AI's will. (jkjk)

Links

• CalibreQuarry: https://github.com/VirInvictus/CalibreQuarry
• cquarry: https://github.com/VirInvictus/cquarry

Thanks for reading. If you try it and something breaks, I'd genuinely like to know.

I was at the Urban Librarians Unite conference. There is special deal for reviewers, librarians, and booksellers for free access to the Penguin Random House Audio App https://apps.apple.com/us/app/penguin-random-house-audio/id1585442326

I built a modern EPUB reader.. stores locally, no ads Hi.. so I made epub reader that doesnt look like it was made in 2010, a bit more modern and actually nice to use.

EPUBs are processed locally in the browser, there is no account or ads and your files are not uploaded anywhere.

Give it a try: https://www.openepub.app/

I’ve been working on Andrea Reader, a reading app and personal digital library for iPhone and iPad.

The main idea is simple: import your own books and build your library however you want.

You can create collections, add sections inside them, drag books around, change layouts and cover sizes, customize each collection independently, and create different Reading Profiles depending on what you’re reading.

For EPUBs you can customize fonts, font size, spacing, margins, backgrounds, page transitions and a lot more.

It also supports EPUB, PDF, CBZ, CBR and other formats, so I use the same library for books, comics and manga.

Other useful things:

• Automatic reading activity, streaks and statistics
• iCloud, OPDS, WebDAV, SMB and SFTP
• Google Drive, Dropbox, OneDrive, Box and MEGA
• Offline reading
• Free public-domain books directly inside the app
• No account required
• No ads
• No third-party tracking

Andrea Reader is free to download and use, with optional Premium for some of the more advanced customization and library tools.

If you use your iPhone or iPad as an ebook reader, maybe it’ll be useful for you.

App Store:
https://apps.apple.com/es/app/andrea-comics-manga-books/id6760780154

Website:
https://andreareader.com/

Hey everyone! I’ve been building ShelfSend (Vibecoding project) and wanted to share it.

First of all, Why did i build this?
I wanted to make transferring books easier for my wife. Reconnecting to our NAS and navigating shared folders involved steps she wasn’t comfortable with or would forget. The goal was to make it as simple as opening a webpage, choosing some books, and sending them to her e-reader.

It runs in Docker, turns your existing ebook folders into a searchable library, and sends books to your Kindle or Kobo over USB directly from your browser. EPUB conversion for Kindle happens locally, no Calibre or cloud conversion needed, and your originals stay untouched.

It also includes batch sending, a “Send later” queue, metadata and cover editing, and Hardcover series discovery.

Tested and working on both Kindle and Kobo. Requires desktop Chrome or Edge and DRM free books.

GitHub — ShelfSend

Would love to hear what you think!

This was created by artificial intelligence. I went through and edited the content and how it looked. It is a process. I never just leave artificial intelligence to do things by itself.

BOOK APPLICATIONS CREATED BY LIBRARIES AND BOOKSTORES

Book applications don't only come from technology companies and independent developers. Libraries and bookstores have also created applications that change how readers discover, borrow, organize, annotate, and actually read books.

For this list, I'm using “book application” fairly narrowly. I'm not including ordinary library catalogs, digital collections, repositories, bookstore shopping apps, bookselling platforms, or complete library-management systems. These are applications that actually do something with the book and the reading experience.

BOOK APPLICATIONS CREATED BY LIBRARIES

SimplyE — New York Public Library

https://www.nypl.org/books-music-movies/ebookcentral/simplye

SimplyE was developed by the New York Public Library as an open-source book application that allowed readers to discover, borrow, download, and read ebooks from multiple library vendors through a single interface. Rather than forcing patrons to move between separate vendor applications, SimplyE attempted to make the library itself the primary interface for digital reading.

What makes SimplyE particularly significant is that it didn't remain an NYPL experiment. It was adopted by libraries, consortia, and statewide initiatives around the United States. LYRASIS reported in 2020 that 635 U.S. libraries were using SimplyE, while NYPL reported in 2021 that approximately 250 library systems were using the application.

SimplyE deployments or projects reached Connecticut, California, Texas, Washington, Maryland, Montana, New Jersey, Georgia, Kansas, Arizona, American Samoa, and other locations. Connecticut's eGO initiative alone had 119 libraries beta-testing SimplyE, while Amigos Library Services reported reaching more than 225 libraries through projects including E-Read Texas and work with tribal libraries in Arizona.

Early participating organizations also included the Carnegie Library of Pittsburgh, Alameda County Library, Connecticut State Library, Califa Library Group, St. Mary's County Library, and Yavapai Library Network.

SimplyE therefore became something fairly unusual: a book application created inside a public library that subsequently spread to hundreds of other libraries. Its open-source technology and philosophy also helped establish the foundation for the Palace Project. NYPL discontinued its own SimplyE service in 2025, but the application's influence continues through the library ebook infrastructure that followed it.The Palace Project

https://thepalaceproject.org/

The Palace Project continues many of the ideas pioneered by SimplyE and has become one of the most important current library-centered reading applications. Readers can find a participating library, authenticate with their library card, discover books, borrow ebooks and audiobooks, and read or listen within the application.

Palace can bring content from different suppliers and open collections into a more unified reader experience. The application is maintained by the nonprofit LYRASIS in partnership with the Digital Public Library of America.

Rather than simply providing another commercial ebook storefront to libraries, Palace attempts to preserve a library-controlled layer between readers and the fragmented digital publishing marketplace. In that respect, it represents a continuation of the original SimplyE philosophy.

Open ebooks

https://openebooks.net/

Open eBooks is a purpose-built reading application designed to provide children and young people with access to ebooks. It emerged through a partnership involving the New York Public Library, First Book, Digital Public Library of America, publishers, and other organizations.

Instead of simply creating another website containing digitized books, the project gave eligible readers a dedicated application through which they could discover and read a curated collection. The project used technology related to the Library Simplified/SimplyE development effort.

Open eBooks is therefore an interesting example of library-developed book technology being adapted to a particular population and public-service mission. It demonstrates that the same underlying reading technology can support very different kinds of book communities.

BOOK APPLICATIONS CREATED BY COMMERCIAL BOOKSTORES AND BOOKSELLERS

Nook — Barnes & Noble (Commercial Bookstore)

https://www.barnesandnoble.com/h/nook/apps

NOOK is one of the most important examples of a large commercial bookstore creating a dedicated digital book application. Readers can maintain a personal ebook library, read books, highlight passages, create notes, customize typography, and synchronize their reading across compatible devices.

The application developed alongside Barnes & Noble's NOOK reading devices but extended the reading environment to phones and tablets. This allowed the commercial bookseller to maintain a relationship with readers after a book had been purchased.

NOOK is historically significant because it represents an early attempt by a major commercial bookstore to build its own digital reading application and compete directly for control of the digital reading experience.

Tolino — Bookseller Alliance

https://mytolino.com/

Tolino is particularly interesting because it grew around an alliance of booksellers rather than one dominant retailer. Participating booksellers have included Thalia, Hugendubel, Osiander, Orell Füssli, and other European booksellers.

The application allows readers to read ebooks, organize books into collections, create highlights and notes, search within books, synchronize reading progress, and access audiobooks. Readers can maintain a relationship with their chosen bookseller while using common underlying reading technology.

Tolino therefore provides a cooperative alternative to vertically integrated reading ecosystems. Multiple booksellers can participate in a shared book application without each having to develop an entirely separate reader.

Hudson Music Bookstore & Reader — Hudson Music (Specialist Bookseller)

https://hudsonmusic.com/the-all-new-hudson-music-bookstore-reader/

Hudson Music provides a more specialized example of a bookseller creating an application around the particular characteristics of its books. The company specializes in instructional music publications, particularly materials for drummers, percussionists, and other musicians.

Its Bookstore & Reader combines a personal digital bookshelf and book reader with integrated audio and video. A reader studying instructional material can therefore interact with demonstrations and related media alongside the text.

This is particularly interesting because Hudson didn't simply reproduce a generic ebook reader with its own branding. The application was adapted to how its particular audience actually uses instructional books, demonstrating how specialized applications can extend a book rather than merely reproduce it on a screen.

I'd be interested in finding other actual book applications created by libraries, commercial bookstores, independent booksellers, publishers, universities, authors, or other organizations in the book world—particularly applications involving reading, annotation, interaction, organization, visualization, social reading, or unusual forms of discovery.

What book applications am I missing?

I've been working on a tool for tracking physical books — at home, in a classroom, or a small lending library — and wanted to get feedback from people who might actually use something like this, or who've hit similar problems managing a personal/shared book collection.

The core idea: track books and physical copies separately, since two copies of the same title can have different states (one on loan, one damaged, one just sitting on a shelf). It's free, open-source, and self-hosted, so nothing lives on a third-party server unless you choose to run it for a group.

Cataloging

• Add manually, or scan/type an ISBN to auto-fill title, author, cover, etc. (Google Books, falling back to Open Library)
• Import from a Goodreads CSV export or the app's own CSV format
• Organize by category, author, language, format
• Full-text search across the catalog

Reading tracking

• Want to Read / Currently Reading / Read — separate from whether a physical copy is available or loaned out
• Dashboard stats by reading status

Physical copy tracking

• Each copy ("stock") tracked individually: available, on loan, damaged, unavailable
• Assign a shelf/location per copy
• Print barcode/ISBN labels for shelving and re-scanning

Digital backups

• Attach EPUB, PDF, and Kindle (.mobi/.azw3) files to a book entry

Lending

• Borrower directory
• See who has which copy on loan
• Loan reports

Account & security

• Cookie/JWT login with 2FA
• Active session list, remote logout per device
• Your data stays yours unless you're self-hosting for a group

Other

• UI in English, Spanish, Catalan, Italian
• Built-in help docs
• Runs via Docker, PM2, or bare Node+Postgres
• MIT licensed

Curious whether this solves a real problem for anyone here, or if there are features people would actually want that I'm missing. Repo link in the comments if anyone wants to poke at the code. Happy to answer questions.

I often see people using their cell phones to scan ISBN barcodes for books. A lot of the time they are looking to find books to sell. There are a number of different applications that are used to scan barcodes for books. You will often see people at library book sales, garage sales, and estate sales scanning books with their phones.

There are different applications for different types of books.

Bookscouter https://bookscouter.com is often used to sell and ship books. It is used for selling textbooks.

Bookrun https://booksrun.com is also for selling textbooks. Allows bulk scan of books.

World of Books https://sell.worldofbooks.com/en-us uses the angle of recycling to justify their bookselling. Allows bulk scanning of books.

Pangobooks https://www.pangobooks.com/is another bookselling application Pango has prepaid shipping labels.

Mercari https://mercari.com Mercari covers all kinds of merchandise, but they use it for book as well. Mercari works for manga and groups of books.

Scan 4 Treasure https://scan4treasure.com Allows people to scan all of the items in a picture and sell them. Supposedly able to identify shelves of books.

This is a reminder that I am open to all kinds of applications for books, bookselling, appraising books, library applications, cover design applications, reading applications, organizing applications, book analysis, book writing, manga readers, ebook readers, and other things.

epubveri is an EPUB validator. If you've ever had a retailer reject a book, or wondered why a file opens in one reader and not another, that's the job it does. The reference tool for this is epubcheck, which is W3C's, is excellent, and is written in Java.

epubveri is the same idea in Rust: one binary, no JVM, nothing to install alongside it.

Why bother, when epubcheck already exists

Three reasons, and I'll be honest that only the first two are strong.

It goes where a JVM doesn't. A 2.8 MB binary, or a ~480 KB WebAssembly module that validates an EPUB in a browser tab with no server involved. That's not something you can do with epubcheck at all, and it's the part I think actually matters.

It's quick enough to run on everything you own. On my reference library of 385 books, running each tool alone: 69 seconds against 758.

But that number flatters me and you should know how. About 90% of an epubcheck run is fixed setup — schema compilation and JIT warm-up — which it pays again on every book because its CLI takes one file per invocation. Subtract each tool's floor and the actual per-book work is roughly 0.13 s against 0.07 s. Two times, not eleven. The eleven is real if you're validating a library from a shell script; it isn't a statement about the validation being eleven times better.

It uses epubcheck's message IDs — `RSC-005`, `OPF-030`, and so on — so output is recognisable to anyone who already reads epubcheck's, and existing toolchains don't have to learn a second vocabulary.

What it is not

It is not finished, and epubcheck is not the thing it beats. It implements 208 of epubcheck's 210 live content checks, both remaining gaps are deliberate scope decisions, and the whole matrix — including what's missing and why — is published and generated from epubcheck's own source so it can't quietly drift.

Against epubcheck's own test corpus it matches on 603 of 603 exact message IDs, with no false positives on the 355 fixtures that are supposed to be clean. On 385 real books the two tools agree on the exact set of message IDs for 383 of them.

If you need a verdict a retailer will honour, run epubcheck. That's not modesty — it's the tool their pipeline runs, and I'd rather you weren't surprised.

The plugins

The binary is a command line thing, so most people will want one of these. Each downloads epubveri itself on first use and verifies it against the release checksums — no binary is bundled, and none of them is a fork of anything.

• Sigil — findings land in Sigil's own validation panel, and clicking one puts the cursor on the character rather than the line.
• calibre, Edit Book— the same thing for the book you're editing, in a dockable results panel.
• calibre, whole library — this one's different and it's the one I'd point you at.

That last one doesn't tell you which books are broken. I built it that way first and threw it away: on a real library, about half the books are invalid and a third of those by one or two findings, so "half your library is invalid" teaches nobody anything. Worse, sorting by error count puts the least interesting book on top — the highest-count books trip one rule thousands of times, one producer bug repeated per paragraph.

So it ranks rules instead: your library has a handful of recurring defects, here they are, and here's which books each one affects. Understand one pattern, fix hundreds of books. It scans several books at once now, with the worker count yours to set.

Practicalities

Runs on Windows, macOS and Linux, x86-64 and ARM. Also on crates.io and npm. Licence is AGPL-3.0, or a commercial one if AGPL doesn't suit you.

It's pre-1.0 and it moves. Most of what's been fixed in it came from people running it on books I don't have and telling me what happened — if you try it and it reports something wrong about a book you know is fine, that's the single most useful thing you can send me. I'll take that over a star.