LumiRead v3.1.0 — silent OCR calibration + offline dictionary

v3.1.0 — silent OCR calibration + real offline dictionary (backend only, UI unchanged)

Silent OCR calibration

Every photo now passes through a calibration pipeline that is completely invisible to the child:

• LayoutNormalizer — picture-book reading order (left page before right on spreads), page-number exclusion, skewed-decoration filtering
• OcrQualityGate — confidence thresholds (accept ≥0.88 / silently correct 0.40–0.88 / silently drop <0.40), with automatic heuristic fallback when ML Kit reports no usable confidence
• OcrCorrectionStage — Gemma fixes obvious OCR errors ("litt1e → little") via JSON-constrained structured generation; malformed output always degrades to the raw text, never crashes
• OcrCorrectionValidator + ProtectedTokenDetector — deterministic guards: numbers, names, dates and quoted text can never be "corrected"; rewrites and fabrications are rejected

No retake prompts, no error bubbles — bad text is silently repaired or silently dropped and the companion talks about the picture instead.

Real offline dictionary for lookup_word

• WordNet 3.1 (≈147k English entries) + CC-CEDICT (≈188k Chinese entries) compiled into a ~31 MB SQLite database bundled in the APK
• Definitions are age-shaped (toddler gets one sentence; preadolescent gets the full gloss); misses degrade gracefully — the model never fabricates a definition
• Hard-verified by JVM and on-device tests that exercise the exact production query

More

• 4th fallback level: deterministic template reading when the model is unavailable — the app never dead-ends
• Self-made 8-category picture-book OCR test set + on-device CER/WER metrics (clear pages: 0–6% CER)
• Richer OCR structure (bounding boxes, corner points, angles, per-line language)
• UI, the 3-tool set, settings, TTS, and privacy posture are all unchanged; models still download on first launch

Install

1. Download LumiRead-v3.1.0.apk below and install it (signed with the same key as v3.0.0 — installs as an update).
2. Models are not bundled. Follow README §6 to download Gemma 4 E2B/E4B and the TTS model, or adb push them to /sdcard/Android/data/com.lumiread/files/.

⚠ The offline dictionary is bundled — no extra download needed for lookup_word.

Full changelog: see README §13.

LumiRead v3.0.0 — paper-warm UI redesign

LumiRead v3.0.0 — "paper-warm" UI/UX redesign

An offline picture-book reading companion for kids, powered by on-device Gemma 4 (LiteRT-LM). This release is a full UI/UX redesign on top of the v2 reasoning core.

Highlights

• Paper-warm Kids UI: cream paper surface, deep-ink + warm-gold palette, magic-book frame, soft star/dot décor. No mascot/avatar/animal/anthropomorphic helper.
• Tier system (Toddler · Preschool · Preadolescent) drives type scale, sizing, radii, décor density, animation, chip counts, and answer length — live & persisted.
• Full snap-to-read flow: home → camera → crop → celebrate → thinking → dialog, with a v3 camera viewfinder (gold corners + big gold shutter) and an upgraded crop (gold handles, rule-of-thirds grid, select-all, live pixel size).
• Story mode (no book): snap an object, pick an opener generated on-device by the local model, or type your own.
• Dialog with free text + microphone (system STT) + TTS, with graceful fallbacks.
• Redesigned parent area: number gate, learning stats, settings, privacy — calm and restrained.
• Accessibility: 1.5× font-scale safe, large touch targets, content descriptions, reduced-motion fallbacks, and no scary offline banners.
• First-launch onboarding dialog when no model is installed (model download/import guidance).

The :core reasoning pipeline and LiteRT-LM / Gemma 4 / ML Kit / sherpa-onnx integration are unchanged. See the README for the full feature list and the honest reliability/latency picture.

Install

• Download LumiRead-v3.0.0.apk below (≈ 288 MB; includes the on-device TTS model). Min Android 8.0 (API 26).
• On first launch you'll be guided to download the ~2.6 GB Gemma 4 model (Hugging Face, then import in Settings). Everything runs offline afterward.

Note: this APK is signed with the Android debug key for convenience (hackathon build). Your device may warn about an unknown developer; install is functionally identical. To ship via Play, rebuild :app:assembleRelease with your own keystore.

LumiRead v2.0.0

LumiRead v2.0.0 — Native Gemma 4 Function Calling

This release re-architects the backend around Gemma 4's native function calling while
keeping the UI unchanged. The model now natively calls small on-device tools (via LiteRT-LM's
tool API) and answers from their results, with the previous two-stage text pipeline kept as a
graceful-degradation fallback.

Highlights

• Native function calling (manual LiteRT-LM tool mode): three offline tools
  classify_scene / lookup_word / read_aloud, triggered by Gemma 4's native tool tokens,
  running real on-device Kotlin — not string parsing.
• Modular :core agent layer: SocraticEngine + FunctionCallingEngine +
  TwoStagePipelineEngine + AgentOrchestrator. UI untouched.
• Model policy: E4B tools always-on / E2B only when the scene is complex; multimodal turns
  use the two-stage path.
• Hidden warm-up generation; per-turn served-by / latency metrics.

Honest notes (please read)

• On-device function calling is not yet fully reliable (a structured eval measured Gemma 4
  E2B tool-call pass rate ~71%; adding a 4th tool degraded it, so the set is locked at 3).
  Any tool-call failure falls back to the two-stage text pipeline, so the app never crashes —
  the reliable baseline is guaranteed by the fallback, not by the function calling itself.
• Performance: usable latency depends on the GPU backend (~52 tok/s officially). On our test
  phone (a Snapdragon device) the GPU backend did not initialize for either model and fell back
  to CPU, so it was slow — about 16 s (E2B) / 46 s (E4B) for a full reply. GPU-capable
  devices are much faster.
• For demos we recommend E2B + separate OCR, or a device with a working GPU backend.
• lookup_word ships without an offline dictionary in this release (returns an age-appropriate
  fallback); an offline dictionary is on the roadmap.

Model choice (in app Settings)

• Younger children → E2B + separate OCR (faster, more natural back-and-forth).
• Older children → E4B + separate OCR.
• All-in-one multimodal mode is experimental and not very stable — choose with caution.

Getting the model

The APK does not contain the model (Apache-2.0 Gemma 4 weights are ~2.59 GB for E2B).
On first launch the app opens the HuggingFace model page; accept the Gemma license, download,
and import the file via the app's settings. The MeloTTS voice model is downloaded similarly.

APK

• app-release.apk — 289 MB (302,017,588 bytes)
• SHA-256: c8714f6eef4fa491776af969766a4288b65c29dac37e5e1ef0dfecb34ceee57f
• Debug-signed (for evaluation only) — no production keystore is committed to the repo.
• Contains no model weights.

LumiRead v1.2.0

LumiRead v1.2.0 — Dual-mode UI, Bilingual & Voice

Built for the 2026 Gemma Developer Hackathon · Edge AI track.

What's new

• Dual-mode UI — Kids mode (cartoon, ZCOOL KuaiLe font, bouncy press) × Parent mode (minimal Material 3). Offline parent gate guards the Kids → Parent transition.
• Bilingual output — Chinese · English, decoupled from system locale. New paired (zh + en line-by-line) rendering mode.
• Per-app locale — Follow system / 中文 / English, switchable without touching system settings.
• Three age bands — Toddler / Preschool / Preadolescent, each adjusts vocabulary, sentence length, TTS speed, and Kids-mode touch targets.
• Auto / manual TTS toggle — child decides when to listen.
• OCR mode setting — default two-stage (ML Kit + text-only Gemma 4 E2B) for fastest first-word; experimental native-multimodal path on Gemma 4 E4B.
• My Learning page — local-only stats. Nothing leaves the device.

APK

• File: `app-release.apk` (≈ 288 MB)
• SHA-256: `8220046ed2f824664e5b41aa306e356356ed96649a5df651d5c4ec40d319e459`
• Debug-signed for hackathon distribution. Does NOT contain Gemma 4 model weights or MeloTTS acoustic model — the app guides you to download them on first launch (≈ 2.59 GB + 189 MB, Wi-Fi recommended), or you can side-load via `adb push` (see README §6.3).

System requirements

• Android 8.0+ (API 26+), 6 GB RAM, ≥ 4 GB free storage, OpenCL-capable GPU.

Privacy

Fully offline after the one-time model download. No telemetry, no analytics, no accounts, no audio recording. See README §8.

License

LumiRead source code: Apache-2.0. Models, frameworks, and ML Kit have their own licenses — see THIRD_PARTY_NOTICES.md.

LumiRead v1.0.0 — Initial public release

LumiRead 光语伴读 is a fully offline, privacy-first picture-book reading companion for children, powered by on-device Gemma 4 E2B via LiteRT-LM. Every photo, every reply — nothing leaves the phone.

Built for the 2026 Gemma Developer Hackathon · Edge AI track.

What's in this release

• app-release.apk — ~290 MB. The app itself. Does NOT bundle the Gemma 4 model weights (~2.59 GB); the app downloads them on first launch, or you can adb push them yourself (see the README).

APK verification

SHA-256: 75f4c435e34501b2b05229e866db90da72b869567916401d730e279104a4c81b
Size:    304,771,037 bytes

Verify before installing:

sha256sum app-release.apk
# Should match the SHA-256 above.

Requirements

• Android 8.0 (API 26) minimum, Android 12+ recommended
• 6 GB RAM minimum, 8 GB recommended
• ≥ 4 GB free storage after install (for the Gemma 4 model)
• GPU backend (Adreno / Mali / Xclipse with OpenCL) strongly recommended

See README for the full matrix.

First launch

On first launch the app guides you through downloading:

• Gemma 4 E2B weights (gemma-4-E2B-it.litertlm, ~2.59 GB) — Wi-Fi recommended
• MeloTTS bilingual zh+en model (~189 MB)

After that the app is fully usable in airplane mode — no network calls.

Evaluators / slow-network users: you can adb push the models directly to skip the in-app download. See README §5.3.

Privacy posture

• No network at runtime (apart from the optional first-launch model download)
• No telemetry, analytics, or crash-reporting backend
• No accounts, no login
• Camera frames stay on device — written to the app's private cache and cleared at session end
• No microphone recording — LumiRead reads through the screen, never through the mic
• Study history is local-only, kept in an on-device Room DB

License

Source code under Apache License 2.0 (see LICENSE and NOTICE).

Models, frameworks and SDKs used at runtime carry their own licenses — see THIRD_PARTY_NOTICES.md.

---

For paper picture books, and the little readers who love them.