Calibre is a comprehensive e-book management application that functions as a library manager, format converter, metadata editor, device synchronization tool, and content server. The codebase is a large monolith written primarily in Python with C/C++ extensions for performance-critical operations (PDF rendering, character encoding detection, compression). It provides a full desktop GUI built on PyQt6, a CLI for headless operations (calibredb, ebook-convert), and an embedded HTTP/OPDS server for remote library access. The architecture follows a plugin pattern: format conversion (input/output plugins), device drivers (USBMS, MTP, dedicated reader drivers), store search plugins, metadata source plugins, and AI provider plugins (OpenAI, Anthropic, Ollama). The core database is SQLite with full-text search (FTS5). Extensively cross-platform (Windows, macOS, Linux) with platform-specific launcher code in C. While the codebase shows high craftsmanship in many areas (e.g., SQLite extensions, font parsing, AI abstraction), it also carries legacy components such as an old RTF parser, vendored libraries (tinycss, frozen), and some device drivers for obsolete readers. Overall, it is actively maintained with regular commits and responsive issue triage.
Anx Reader is a cross-platform e-book reader application built with Flutter and Dart. It supports a wide range of formats (EPUB, MOBI, PDF, TXT, FB2, CBZ) by leveraging a forked version of the foliate-js JavaScript library as its core rendering engine, served by an embedded Dart HTTP server and displayed in a platform-abstracted WebView widget. This architecture, while functional, creates a hard dependency on a complex external JavaScript project and a Dart HTTP server for what is fundamentally a local file reader. The application follows a monolithic architecture with a strong emphasis on clean separation of concerns. It uses Riverpod for reactive state management, a service layer for business logic (AI, TTS, Sync, Translation), and a widget layer for UI composition. The codebase is notable for its extensive use of design patterns like Registry (for AI tools and dashboard tiles), Adapter (for platform-specific WebViews and TTS backends), and Repository (for AI tool data access). The Dart code itself is well-structured and demonstrates professional Flutter development practices. Beyond basic reading, it features deep AI integration (chat, summarization, content analysis via configurable providers), text-to-speech with multiple backends, WebDAV synchronization, a customizable statistics dashboard, and a full annotation system. The project is actively maintained with a sophisticated CI/CD pipeline targeting Windows, macOS, Linux, Android, iOS, and OpenHarmony. The Dart code demonstrates high craftsmanship, particularly in the AI tool framework, the dashboard tile system, and the platform abstraction layers. These components are well-isolated and could be extracted for reuse in other Dart projects. The primary risk is the tight coupling to the external foliate-js JavaScript engine and the reliance on multiple third-party AI and TTS APIs, which introduces external dependency risk and potential for API drift.
KOReader is a document viewer application primarily designed for e-ink readers, supporting a wide range of formats including PDF, EPUB, DjVu, CBZ, and more. It provides a full-featured reading experience with file management, annotation, dictionary lookup, OPDS catalog browsing, Calibre integration, cloud storage, and extensive customization through a plugin system. The architecture is a monolithic Lua application built on a custom widget toolkit with an event-driven UI manager, platform-specific device abstraction layers (Kindle, Kobo, PocketBook, reMarkable, Android, SDL), and a robust caching and rendering pipeline. Key entry points are `reader.lua` for the main application and `kodev` for development/testing. The codebase is large and mature, with a strong emphasis on performance and e-ink optimization, but shows some technical drift in the form of deprecated code paths, platform-specific hacks, and a fragmented keyboard layout system.
SimpleUI is a KOReader plugin that provides a highly customizable, distraction-free user interface overlay for the KOReader e-book reader application. It replaces the default homescreen with a modular widget system (clock, currently reading, recent books, reading stats, cover deck, etc.), adds configurable top/bottom bars, quick settings bar, library enhancements (virtual browsing, cover overrides), reading statistics and streaks with heatmaps, backup/restore, and over-the-air updates. The plugin is implemented in Lua and deeply integrates with KOReader's widget framework, extensively monkey-patching core classes like FileChooser, TouchMenu, and TitleBar. Despite heavy coupling to KOReader internals, the codebase exhibits strong engineering practices: lazy loading, parameterized module factories (e.g., GridRenderer), custom caching layers (cover cache, stats cache), a reusable anti-aliased drawing library, and a self-contained i18n system with PO file parsing. The repository is actively maintained with a well-documented public API for external plugins to register quick actions. It is not a standalone application but a plugin that must be installed within KOReader. The primary risk is reliance on KOReader's internal APIs, which may break with upstream changes.
CheatReader is a Flutter-based desktop ebook reader designed for low-distraction reading. It provides a floating, always-on-top window that supports single-line and multi-line reading modes, transparency, a boss key for quick hide/restore, system tray integration, and app disguise (icon/name change). The application imports local files in multiple formats (txt, epub, html, md, fb2, docx, pdf) via text extraction, never modifying the source. It features a bookshelf with reading progress tracking, customizable keyboard shortcuts, auto page-turn, full-text search, and a control panel for all settings. The architecture is a standard Flutter app with platform-specific abstractions for window management, file import, and startup behavior, targeting Windows, macOS, and Linux. The codebase is well-tested, localized in English and Chinese, and uses a spec-driven development process (OpenSpec). While the main reader surface widget is large (~2600 lines), the overall structure demonstrates solid engineering with reusable patterns for platform abstraction, settings persistence, and text extraction.
Foliate is a desktop e-book reader for GNOME/Linux, built with GTK4, Libadwaita, and GJS (GNOME JavaScript). It supports EPUB, Mobipocket, Kindle, FB2, CBZ, and PDF formats, using WebKitGTK to render book content via a custom JavaScript rendering engine (foliate-js). The application provides a full-featured reading experience with paginated and scrolled modes, customizable fonts and themes, annotations (highlights, notes, bookmarks), text-to-speech via Speech Dispatcher, OPDS catalog browsing, and dictionary/Wikipedia lookups. Architecture: The main entry point is src/main.js, which initializes the GJS application and loads the GResource-bundled source files. The core UI is defined in src/app.js (window creation, file handling) and src/book-viewer.js (reading view with sidebar, search, navbar, TTS). The library view (src/library.js) manages book collections and OPDS integration. Reading state (annotations, bookmarks, progress) is persisted per-book as JSON files in the user's data directory. The rendering pipeline lives in the WebView: src/reader/reader.js handles content display, CSS injection, and footnotes, while the foliate-js submodule parses e-book formats into a pageable model. External dependencies: GNOME platform (GTK 4.12, Libadwaita 1.8, WebKitGTK 6.0, GJS 1.82), Speech Dispatcher for TTS, Tracker (optional) for file indexing, and third-party APIs (Wiktionary, Wikipedia, Google Translate) for lookup tools. The build system uses Meson, with Flatpak and Snap packaging provided. Internationalization across 30+ languages is maintained via gettext PO files. Data flows: User opens a file â book is parsed by foliate-js into a structured document model â rendered in WebView â user interactions (scroll, search, annotate, bookmark) are communicated back to GJS via the WebView's async RPC pattern (exec/iter/provide) â state is persisted as JSON files. OPDS catalogs are fetched via HTTP and rendered in a separate WebView frontend (src/opds/main.html).
ReadAny is a full-featured, cross-platform e-book reader application with deep AI integration. It supports reading EPUB, PDF, MOBI, FB2, and other formats via the modified foliate-js engine, and provides text-to-speech, annotations, reading statistics, and cross-device sync (WebDAV, S3, LAN). The AI subsystem offers chat with RAG (semantic search over book content), context-aware tools, and execution of user-defined skills. The application follows a local-first architecture with robust offline capabilities and optional cloud sync. The codebase is structured as a pnpm monorepo with four main packages: 'core' (shared business logic, types, stores, AI, RAG, sync, stats, TTS), 'app' (Tauri desktop client with React+shadcn UI), 'app-expo' (Expo/React Native mobile client), and 'cli' (agent integration via MCP and managed shims). The application exhibits high craftsmanship in its platform abstraction layer, persistent store pattern, and hybrid search engine. However, there is significant platform-driven code duplication (desktop vs. mobile UI components) and a complex dependency graph with multiple patched packages, indicating some architectural debt.
Episteme is a modern, cross-platform e-book and document reader built with Kotlin Multiplatform and Compose Multiplatform. It supports a wide array of formats including EPUB, PDF, MOBI, audiobooks (M4B), FB2, DOCX, ODT, PPTX, and comic archives (CBZ/CBR). The app offers a rich reading experience with paginated and vertical scroll modes, text-to-speech, ink and text annotations, OPDS catalog browsing, cloud sync via Google Drive and Firestore, AI-powered summarization, and extensive customization (themes, fonts, brightness). The codebase is organized into a shared module containing core business logic, models, and policies, with platform-specific implementations for Android (native Compose, Room, WorkManager), iOS (Swift), and Desktop (Compose Desktop, Swing interop). The architecture follows a clean separation of concerns with expect/actual abstractions for platform services, making it a strong example of production-ready KMP application design.
BookWith is a next-generation e-reader application that enhances traditional book reading with AI capabilities. The system allows users to upload and read EPUB books, annotate text, interact with an AI chatbot for contextual questions about the content, and generate AI-powered podcasts from book material. The architecture follows a client-server model with a Next.js/React frontend and a FastAPI/Python backend, employing domain-driven design principles. Key features include a multi-layer memory system for maintaining conversation context, semantic search via Weaviate vector database, and integration with external AI services like Gemini and Google Cloud Text-to-Speech. The frontend uses modern React patterns with Zustand/Jotai for state management, Tailwind CSS for styling, and shadcn/ui-inspired components. The backend utilizes PostgreSQL for relational data, implements clean architecture with separate domain/application/infrastructure layers, and provides a well-structured API with automatic OpenAPI schema generation.
This repository is a KOReader plugin called 'Project: Title' that replaces the default file browser and history with alternative display modes: cover grid, cover list, details list, and filename list. It extracts book metadata and cover images, caches them in a SQLite database (with zstd compression), and displays progress bars, series information, tags, and custom book status screens. The plugin monkey-patches core KOReader widgets (FileChooser, FileManager, Menu, BookStatusWidget) to inject its own UI components. It also provides background metadata extraction, folder cover generation, and a user-patch extension mechanism. The code is written in Lua and is tightly integrated with KOReader's internal APIs, making it non-portable outside that ecosystem. However, several internal modules (gettext proxy, performance debugger, user-patch template) demonstrate reusable patterns for other KOReader plugins.
ColorTxt (åŊŠč¯ģ) is a cross-platform desktop ebook reader built with Electron, Vue 3, and Monaco Editor. It focuses on reading local text/ebook files (TXT, EPUB, PDF, MOBI, FB2, CHM) with an extensive feature set: AI-powered reading assistant (chat, RAG, mindmap, wordcloud, character card generation), multi-engine text-to-speech (Edge, MiniMax, DashScope, MiMo, Volcengine, Windows SAPI), dictionary lookup supporting multiple formats (StarDict, MDict, Babylon, DICT), a book source engine fully compatible with Legado (é č¯ģ) for searching and downloading web novels, WebDAV sync for cross-device backup, and deep customization of reading appearance (themes, fonts, line spacing, backgrounds, reading ruler, pomodoro timer). The architecture follows a standard Electron pattern: a main process handles I/O, AI, TTS, networking, and IPC, while separate renderer processes (main reader, find-book, stealth reader) are Vue 3 SPAs communicating via typed IPC through a preload bridge. The codebase is large and feature-rich, demonstrating solid engineering practices (composable patterns, shared type libraries, clean IPC design) but also carries maintenance complexity from the Legado compatibility layer, numerous third-party API integrations, and platform-specific hacks for stealth mode and native modules.
Koodo Reader is a cross-platform ebook reader application supporting a wide range of formats (EPUB, PDF, MOBI, AZW3, TXT, FB2, CBR/CBZ, MD, DOCX, HTML, etc.). It is built as an Electron desktop app with a React/TypeScript frontend and a separate Go HTTP server for OPDS catalog serving and KOReader sync. The application provides a full-featured reading experience including bookmarks, notes, highlights, text-to-speech (with multiple voice engines), translation and dictionary lookup (via built-in and custom plugins), OCR for scanned PDFs, and cloud sync/backup across many providers (WebDAV, S3, OneDrive, Google Drive, Dropbox, etc.). It also includes a library management system with shelves, tags, search, and import from local files, folders, URLs, and OPDS catalogs. The architecture is a monolith with a clear separation between the Electron main process (Node.js) and the renderer (React), plus an optional Go server for network-facing features. The codebase is large and feature-rich but shows signs of technical debt: widespread use of deprecated React lifecycle methods, heavy reliance on opaque minified libraries (kookit-extra), frequent `as any` type casts, and mixed Chinese/English comments. Despite these issues, the application is actively maintained and offers a robust set of features for ebook enthusiasts.
A cross-platform media aggregation desktop and mobile application built with Tauri v2 and Vue 3. It allows users to create, import, and manage custom JavaScript-based source extensions that scrape or fetch content from websites for books, comics, videos, photos, and music. The app includes a built-in code editor (Monaco) for authoring extensions, a download manager with HTTP and M3U8 support, text-to-speech (Edge TTS), cloud synchronization with conflict resolution (tombstones, incremental sync), DLNA casting (Android), and a source marketplace. The architecture is plugin-heavy, with many custom Tauri plugins for web scraping, media session, and command bridges. While the core functionality is comprehensive and actively maintained, the codebase exhibits tight coupling to custom plugins, limited test coverage, and security concerns from dynamic code execution of user-provided source scripts.
LibreraReader is a full-featured, multi-format e-book reader for Android (with an experimental iOS/desktop port via Kotlin Multiplatform). It supports PDF, EPUB, MOBI, DjVu, FB2, CBR/CBZ, DOC/DOCX, ODT, RTF, and many other formats through a combination of native C/C++ libraries (MuPDF, DjVuLibre, libmobi, libantiword, libwebp, liblame) and Java-based document translators (ODF/SVM/WMF to HTML/SVG). The app provides a rich reading experience with customizable themes, text-to-speech, OPDS catalog browsing, cloud sync (Google Drive, Dropbox), annotations, bookmarks, and a smart reflow feature for scanned documents. The codebase is large and monolithic, with significant third-party code vendored into the source tree. Development has been frozen (as noted in the README), so the project is in a maintenance-only state. Despite its age and complexity, it contains several well-crafted, reusable utility libraries (e.g., LWXML streaming XML framework, SVM-to-SVG translator, and general-purpose Android utilities) that could be extracted for other projects.