Legado Flutter: Best E-Book Reader Apps for Developers in 2026

What Is Legado Flutter?

Legado Flutter is an open-source e-book reader rebuilt by lq-259 from the Android-only Legado app. It uses Flutter 3.0+ for the UI and a Rust 2024 core for networking, parsing, storage, and source rules, and the README snapshot reports 264 cargo tests plus 215+ Flutter widget/unit tests passing. Legado Flutter is one of the best E-Book Reader Apps tools for developers building cross-platform reading software that cannot afford separate native codepaths.

Quick Overview

Who Should Use Legado Flutter?

• Android app maintainers who want to migrate a reading app off Kotlin-only code without rewriting every feature from scratch.
• Cross-platform engineers who need one UI layer for Android, iOS, Windows, macOS, and Linux while keeping business logic in Rust.
• Indie hackers building niche reader apps that depend on book sources, rule-based extraction, and local persistence instead of a hosted backend.
• Rust-oriented teams that want memory-safe networking, parsing, and storage boundaries inside an otherwise Flutter-first product.

Not ideal for:

• Teams that need a fully polished, store-approved iOS/Desktop release today, because the README says iOS and desktop are not fully tested.
• Builders who want a turnkey hosted reading service instead of a local app with embedded rules, cache, and SQLite state.
• Product teams that do not want to maintain Flutter, Rust, and FFI tooling together.

Key Features of Legado Flutter

• Flutter UI layer — The app ships a shared interface for bookshelf, reader, search, source management, settings, TTS, and WebDAV. That means one widget tree drives multiple platforms instead of maintaining separate Android and desktop UIs.
• Rust core engine — The repo splits core logic into core-net, core-parser, core-storage, and core-source. This keeps HTTP, parsing, persistence, and rule evaluation outside the UI layer, which makes the app easier to reason about and test.
• Book-source rule execution — The source engine evaluates rules on the Rust side, including JS evaluation, replacement rules, and scope substring matching. The README also calls out ReDoS protection and SSRF防护 in the networking layer, which matters when handling untrusted sources.
• Reader state restoration — Progress is stored at chapter plus character-offset granularity via durChapterIndex and durChapterPos semantics. That is materially better than page-only bookmarks when you need exact resumption after relaunch or source changes.
• Multiple reading modes — Legado Flutter supports five page-turn animations plus scroll mode, including simulation, cover, slide, fade, and no-animation paths. The README notes that the simulation mode mirrors the MD3 fork’s Bezier geometry and shadow logic.
• Offline-first storage model — core-storage uses SQLite and DAO-style access patterns for local content, reading history, and progress data. This is a practical fit for readers that must keep working without a server.
• Build-time FFI generation — flutter_rust_bridge_codegen generates the Dart bindings when Rust APIs change. That keeps the bridge explicit and avoids hidden sync drift between the Flutter layer and the Rust workspace.

Legado Flutter vs Alternatives

Pick Legado if you only care about the original Android experience and want the upstream codebase rather than a rewrite. Pick Legado-Tauri if your target is desktop-first and you prefer a Tauri shell around Rust core modules.

Pick legado-with-MD3 if you need a Kotlin-based reference for page-turn geometry, progress semantics, or source rule behavior before porting. If you are surveying the broader ecosystem, start with browse all open-source tools or browse all Flutter tools to compare this architecture against other client-side app stacks.

How Legado Flutter Works

Legado Flutter uses a thin UI / thick core design. Flutter renders the bookshelf, reader, search, and settings screens, while Rust owns the parts that are easy to get wrong in a cross-platform app: HTTP, cookie handling, proxy support, SSRF checks, parser logic, and SQLite persistence. That boundary is exposed through flutter_rust_bridge, so Dart calls into native Rust code instead of reimplementing the same logic in multiple languages.

The Rust workspace is deliberately split by responsibility. core-net fetches remote content, core-parser normalizes TXT, EPUB, and UMD inputs, core-storage manages local records, and core-source evaluates book-source rules and content transforms. That split makes the app easier to test because each subsystem can fail independently, and it makes the reader pipeline more predictable when a remote source changes its markup or response shape.

git clone https://github.com/lq-259/legado_flutter.git
cd legado_flutter/core
cargo build --release
cd ../core/bridge
flutter_rust_bridge_codegen generate
cd ../../flutter_app
flutter pub get
flutter run

The commands above build the Rust workspace, regenerate the FFI layer when needed, install Flutter packages, and launch the app. If you change Rust signatures, rerun the code generator before flutter run; otherwise the Dart bindings and Rust APIs will drift and the build will fail.

Pros and Cons of Legado Flutter

Pros:

• The app keeps one Flutter UI for five desktop and mobile targets, which reduces duplicated presentation code.
• Rust handles network and storage boundaries, which lowers the risk of memory bugs in source parsing and content fetch paths.
• The core-net / core-parser / core-storage / core-source split is clean enough for targeted tests and isolated refactors.
• Chapter and character-offset progress restore is precise enough for long-form reading and source swaps.
• The repo already includes practical reader features such as TTS, WebDAV backup, search across sources, and multiple page-turn modes.
• MIT licensing is friendlier than the original Legado AGPL-3.0 posture for teams that want to embed or modify the code.

Cons:

• iOS and desktop support are marked as not fully tested, so shipping those targets still needs verification work.
• The stack is heavier than a pure Flutter app because Rust, FRB, and native build tooling all have to stay in sync.
• flutter_rust_bridge_codegen adds another regeneration step to the developer workflow.
• Android builds depend on a specific NDK version, which can slow down new contributor setup.
• The project is a community rewrite, so behavior parity with upstream Legado is not guaranteed on every edge case.

Getting Started with Legado Flutter

git clone https://github.com/lq-259/legado_flutter.git
cd legado_flutter
cd core
cargo build --release
cd ../bridge
flutter_rust_bridge_codegen generate
cd ../../flutter_app
flutter pub get
bash ../build_android_debug.sh

That path builds the Rust engine first, generates the bridge layer, installs Flutter dependencies, and then produces an Android debug build. If you want to run on iOS or desktop, replace the Android script with flutter run -d ios, flutter run -d windows, flutter run -d macos, or flutter run -d linux on a machine that supports the target.

Expect to configure your own book sources after first launch, because the app is only useful once the source rules point at real content providers. If you are modifying parser or source logic, keep an eye on the Rust workspace tests and rerun code generation whenever the FFI surface changes.

Verdict

Legado Flutter is the strongest option for developers modernizing a Legado-style reader when they need one codebase across Android, iOS, and desktop. Its biggest win is the Rust-backed architecture, which keeps parsing and storage logic testable; the main caveat is incomplete desktop and iOS validation. Choose it if you want an open-source rewrite with serious engineering discipline.