riddle: The Open-Source Diary That Makes a reMarkable Tablet Feel Haunted
A Rust-powered takeover of the Paper Pro that erases the interface, turns handwriting into a ritual, and uses an LLM as the voice behind the page.
- riddle is not a chat app with a handwriting skin, it is an enchanted object whose interface all but disappears.
- The model is not just generating prose, it is helping route the app's state through memory, reply, and special gestures.
- The project's magic comes from low-level control of the Paper Pro, from raw pen capture to direct e-ink takeover.
- Its real competition is not better productivity software, but every ordinary way of talking to AI on a tablet.
No screen glow, no keyboard, no chat UI. That is the point. Maxime Rivest's riddle turns a reMarkable Paper Pro into a Tom Riddle diary replica, where the page drinks your ink and answers in cursive instead of showing you a familiar app shell.
The project is interesting because it refuses the obvious shape of an AI interface. There are no bubbles, no panels, and no little prompt box waiting at the bottom of the screen. The device behaves like a fictional object first, a computer second.
The page that answers back
The hook is not that `riddle` can chat. The hook is that it makes the interaction feel physically authored. You write a line, the ink dissolves, and a reply appears as if the page itself has taken up the pen.
No screen glow, no keyboard, no chat UI. Just ink appearing on paper.
That sentence from the README gets the design philosophy exactly right. The interface is not reduced. It is removed.
Why the interface nearly disappears
`riddle` starts from raw pen events, not from a polished chat layer. The app grabs the digitizer, reads stylus input directly, and draws to the device's display path with almost no visible software chrome in the way.
// The app's personality comes from the control flow, not a wrapper UI.
let mode = oracle.stream(prompt, ink_snapshot)?;
match mode {
OracleMode::Reply(text) => render_handwritten_reply(text),
OracleMode::Recall(page) => replay_memory(page),
OracleMode::Help => show_help_panel(),
}That architecture is why the project feels so strange in a good way. The model is not a copilot bolted onto a notebook. It is part of the device's behavior.
The takeover move
The high-stakes move is deeper than UI design. `riddle` can stop the stock `xochitl` experience and drive the e-ink engine directly, which gives it the latency and control needed to sell the illusion. On a device like the Paper Pro, that is the difference between a demo and a spell.
| Approach | Interaction style | Output style | Where the intelligence lives | What it optimizes for |
|---|---|---|---|---|
| Official reMarkable handwriting conversion | Write, then export or convert | Typed text | Cloud OCR pipeline | Productivity |
| Typical ChatGPT-on-tablet workflow | Type into a chat box | Chat bubbles | Remote model service | Answer quality |
| `riddle` | Write, watch ink vanish, receive a handwritten reply | Animated cursive on the page | LLM in the app's control flow | Enchantment |
That table is the key distinction. `riddle` is not trying to be the fastest way to ask an AI a question. It is trying to be the most convincing fictional object.
How the diary drinks ink
The effect in `ink.rs` is not a generic fade. It uses deterministic per-pixel hashing, which means the disappearance is patterned, repeatable, and just irregular enough to feel like the page is doing the work itself.
That matters. A uniform fade would look like software. A broken, staggered dissolve looks like a material event.
How handwriting comes back to life
The reply pipeline is equally disciplined. Text is rendered in a cursive font, thinned with Zhang-Suen, traced into ordered paths, and animated stroke by stroke. The result is not just handwritten-looking text. It is handwriting with a believable sequence.
// The stroke order is part of the illusion.
let glyphs = rasterize_cursive(text);
let skeleton = zhang_suen_thin(glyphs);
let paths = trace_paths(skeleton);
for stroke in paths {
animate(stroke)?;
}That sequence is why the output feels authored instead of printed. The eye tracks line order, pauses, and pacing. If those details are wrong, the spell breaks.
Why the LLM is the router, not the chatbot
This is the conceptual core. `riddle` uses the model as a state router, not just a text generator. It streams output, parses sentinel markers, and can branch into memory retrieval when the response asks for a previous page.
That makes the system feel less like a chat app and more like a small language-driven operating system. The model can decide whether the user is getting a reply, a memory, or help.
The special `show:N` directive is especially telling. It is not just content. It is a command that changes what the app does next.
Fable turned my remarkable into Tom Riddle's diary from Harry Potter. My prompts fade, a LLM respond. Magical!
That line is playful, but the implementation backs it up. The model is not a detached oracle. It is embedded in the app's control logic.
What it replaces, and what it refuses to be
`riddle` sits in a different lane from the obvious alternatives. It is not an official handwriting conversion feature, and it is not a normal AI notebook workflow. It is a fiction machine built on top of a tablet.
| Approach | What you feel | What it actually does | Main constraint |
|---|---|---|---|
| Official reMarkable handwriting conversion | Utility | Turns handwriting into typed text | Productivity-first |
| ChatGPT on a tablet | Convenience | Sends prompts to a model | Interface-heavy |
| Older reMarkable hacks | Playground | Adds custom apps and tools | Device-specific tinkering |
| `riddle` | Enchantment | Makes the page behave like a responsive diary | Illusion first |
That is the payoff. The project is not competing on throughput or enterprise features. It is competing on believability.
What this project says about AI interfaces
`riddle` argues for a different kind of AI interface. The most interesting one may not look like an interface at all. It may look like a familiar object that has become responsive, a device that keeps its shape while changing its behavior.
That is why this project lingers. It is technically clever, but its real achievement is emotional. It makes software disappear without pretending the machine is gone.
