reMarkable Riddle: Fable-Style Vision LLM Diary on E-Ink (Tom Riddle's Diary)

A GitHub repo titled "Fable turned remarkable into Tom Riddle's diary from Harry Potter" sounds like a meme — until you watch the demo: you write on reMarkable Paper Pro e-ink, your ink fades, the page thinks, and an answer writes itself back in a flowing script, stroke by stroke, then fades away. No chat box. No keyboard. No glow.

Riddle by Maxime Rivest is real — MIT licensed, ~450 GitHub stars in days, and one of the clearest examples of vision LLMs leaving the browser for slow, deliberate hardware. The HN title riffs on Claude Fable 5 mystique; the stack is OpenAI-compatible vision or pi RPC — not an Anthropic API. Here's how it works, what it costs, and why e-ink + LLM beats another chat tab.

TL;DR — Riddle at a glance

The experience — why "Tom Riddle" landed

From the README:

"Write on the page with your pen. After a pause, the diary drinks your ink — your words fade into the paper — the page thinks for a moment, and an answer writes itself back in a flowing hand, stroke by stroke, then fades away."

No screen glow, no keyboard, no chat UI. Just ink appearing on paper.

That is the opposite of Fable's consumer chat — thousands of lines of XML, artifacts, memory — and closer to embodied AI: one surface, one ritual, one persona ("Tom") embedded in the oracle prompt (riddle/src/oracle.rs).

HN reactions split:

• Delight — "sick in the 90's Tony Hawk sense"; bang projects into existence era
• Skepticism — Harry Potter horcrux comparisons and wellbeing debates
• UX — README needs video above fold (demo on X/Twitter linked from repo)

explainx.ai treats it as a form-factor experiment — where multimodal meets calm technology.

Architecture — pen, oracle, quill

 pen (evdev, 4096 pressure)
   │ strokes
   ▼
 riddle (Rust) ── idle 2.8s → page PNG ──► oracle (resident LLM)
   │                                          streams sentences
   ▼
 handwriting synthesis
   Dancing Script → rasterize → Zhang-Suen thin → stroke paths
   ▼
 display backend
   ├── qtfb     — windowed inside xochitl (AppLoad)
   └── quill    — takeover: stop xochitl, vendor e-ink direct

riddle/ — the Rust app

• Ink surface + gesture handling
• Oracle process manager — keeps LLM warm, streams tokens
• Handwriting replay — not a font blit; skeletonized single-pixel pen paths animated like real ink

quill/ — takeover display (C/C++)

• Interposes on vendor libqsgepaper.so waveform engine
• quill_init / quill_buffer / quill_swap C ABI
• scribble — minimal pen-to-glass latency demo
• Built with reMarkable SDK (~/rm-sdk-3.26) — proprietary libs from your device, not redistributed

Takeover mode is what the viral demo uses: lowest e-ink latency because xochitl is stopped and the engine is driven directly. Trade-off: runs as root, vendor UI gone until exit.

Gestures and safety exits

SSH escape hatch: ssh root@10.11.99.1 'systemctl start xochitl' if wedged.

README is explicit: not affiliated with reMarkable AS; you use at your own risk.

The oracle — two backends

Option A: OpenAI-compatible vision API (easiest)

export RIDDLE_OPENAI_KEY="sk-..."
export RIDDLE_OPENAI_BASE="https://api.openai.com/v1"   # optional
export RIDDLE_OPENAI_MODEL="gpt-4o-mini"                # must see images

Works with OpenRouter, Groq, local OpenAI-compatible servers. Pure-Rust HTTPS — no extra tablet deps.

Test before launch:

riddle --oracle-test path/to/handwriting.png

OpenRouter example:

export RIDDLE_OPENAI_KEY="$OPENROUTER_API_KEY"
export RIDDLE_OPENAI_BASE="https://openrouter.ai/api/v1"
export RIDDLE_OPENAI_MODEL="openai/gpt-4o-mini"

Option B: pi RPC (power path)

If RIDDLE_OPENAI_KEY unset, riddle spawns resident pi --mode rpc — Node + subscription auth loaded once; each turn pays model latency only.

Both backends stream sentence-by-sentence so the quill starts before the model finishes — critical for perceived magic on slow e-ink.

Install paths

Prebuilt bundle (recommended)

1. Download riddle-appload-aarch64.zip from releases
2. scp -O -r riddle root@10.11.99.1:/home/root/xovi/exthome/appload/
3. cp oracle.env.example oracle.env → add RIDDLE_OPENAI_KEY
4. AppLoad → Reload → The Diary

Build windowed (AppLoad/qtfb)

cd riddle
cargo build --release --target aarch64-unknown-linux-gnu

Deploy binary + external.manifest.json + appload-launch.sh to appload folder.

Build takeover (demo-grade)

cd quill && ./build.sh    # pulls libqsgepaper.so from device via ssh
cd ../riddle && ./build-takeover.sh

Launch via AppLoad script → transient systemd unit, stops xochitl, restores on exit.

Why vision-on-PNG beats OCR pipelines

Naive approach: OCR handwriting → text → LLM → text → render.

Riddle sends the page image to a vision-capable model. Benefits:

• Layout context — diagrams, arrows, marginalia survive
• No OCR error cascade on messy pen strokes
• Single multimodal call — aligns with GPT-4o-class routing

Trade-off: PNG payload size and API cost per page — fine for diary sessions, not for millisecond typing loops.

Compare to Fable inner voice: consumer models hide reasoning; Riddle shows the medium (ink) as the interface — no leaked CoT, just visible strokes.

Fable branding vs Riddle reality

The HN joke maps Fable mystique onto enchanted paper — useful marketing, not technical dependency. Enterprises evaluating Fable export rules still deploy Riddle with their own API keys and data boundaries.

Who should build on this pattern

Good fits:

• Journal / therapy apps — slow, private, no notification UI
• Field notes + LLM — inspectors, archaeologists, scientists
• Education — handwriting practice with Socratic replies
• Art installations — e-ink as performance medium

Poor fits:

• Real-time collaboration
• Compliance workflows needing audit logs in vendor SaaS
• Users without tolerance for developer mode friction

Adjacent stack: Same author ships Ternlight for browser semantic search — together they sketch on-device ML without chat chrome.

Risks and limitations

• Root + takeover — bricking risk if SSH lost; keep escape paths
• OS lock-in — Paper Pro 3.26–3.27 only per README
• API dependency — offline diary needs local vision model (not shipped)
• Persona prompt — Tom Riddle framing is playful; customize oracle.rs for production tone
• Wellbeing — any diary LLM can over-engage vulnerable users; Anthropic's wellbeing blocks exist because chat products need them — roll your own for hardware hacks

Developer mode — what "drop riddle in" actually means

Riddle is not a sideloaded APK — it targets reMarkable Paper Pro developer mode:

1. remagic or manual xovi + AppLoad setup (launcher ecosystem on tablet)
2. SSH to root@10.11.99.1 over USB — your escape hatch
3. Copy riddle-appload-aarch64.zip to /home/root/xovi/exthome/appload/
4. Configure oracle.env with vision API key
5. AppLoad → Reload → launch The Diary

Windowed mode keeps xochitl (vendor UI) running — safer for daily carry.Takeover mode (demo video) stops xochitl, runs quill shim over libqsgepaper.so — lowest latency, highest brick risk if SSH breaks.

Build-from-source path needs aarch64-unknown-linux-gnu cross-compile and, for takeover, reMarkable SDK 3.26 plus libqsgepaper.so pulled from your device — proprietary blob not in repo.

Handwriting pipeline — why Zhang-Suen matters

The "magic" is not GPT writing cursive — it is riddle converting model text to animated pen strokes:

1. Rasterize Dancing Script (SIL OFL font in repo)
2. Zhang-Suen thinning → single-pixel skeleton
3. Trace skeleton into pen paths
4. Replay paths on e-ink at hardware event rate

That is why replies feel written rather than typed — and why e-ink latency dominates UX more than token latency. First ink at ~0.9–1.1s with API oracle; streaming sentences hides the rest.

What people are asking (from HN)

Comparison — chat UI vs embodied ink

This is calm technology in the spirit of screenless fitness trackers — AI without feed scroll.

Cost model — vision API per page turn

Unlike chat sessions with hundreds of turns, Riddle bills roughly one vision call per idle commit:

explainx.ai tip: cap daily commits in settings for demo tablets; use cheaper vision models for drafts and upgrade model for "serious" pages only — pattern similar to effort parameters in API products.

Privacy trade-off: PNG leaves device to API unless you self-host a vision model — Riddle does not ship local VLM weights in July 2026 release.

Preservation angle: Unlike always-online AAA games, a diary on e-ink with exported PNGs + your oracle logs is archivable — ironic given Tom Riddle lore.

Star trajectory: ~450 GitHub stars within days suggests appetite for non-chat LLM UX — watch forks for Kindle, Boox, or Supernote ports (none official yet).

What builders should do with this pattern

• Fork the oracle prompt — replace Tom persona with field-note or Socratic tutor tone in oracle.rs
• Stay windowed until takeover is tested on your firmware pin
• Budget vision API — one PNG per page turn; cache nothing you cannot redact
• Pair with Ternlight if you later index handwritten archives on desktop

Related on explainx.ai

• Claude Fable 5 launch guide
• Fable 5 system prompt leak analysis
• Fable inner voice — leaked reasoning
• Multimodal AI complete guide
• Ternlight — browser embeddings (same author)
• Build a personal local AI system

External: riddle GitHub · Release 0.2.0 · Demo video (X)

Device compatibility, oracle latency, and star counts reflect July 2026 public releases. reMarkable firmware updates can break takeover mode — pin OS version in production experiments.