Write with the pen. Muse reads your page and writes back — in a flowing hand, with color, diagrams, and tables.
A conversational AI that lives on your reMarkable Paper Pro. No keyboard, no app switching, no glowing screen — just ink on paper. You write a question by hand; after a short pause the page drinks your ink and a thoughtful, beautifully typeset answer writes itself back.
Muse turns the quietest device you own into a thinking partner. It's a general assistant — ask it to explain an idea, draft a note, plan a trip, work through some math, or sketch how something works — and it answers on the page in the same calm, paper-first way you already write.
It began as a fork of Riddle — the enchanted "diary that writes back" that first proved a pen-and-e-ink LLM could feel magical. That was the spark. Muse takes the idea somewhere new: a rewritten rendering pipeline, a vector-diagram engine, native tables, richer color typesetting, on-device memory, adaptive answer styles, and a great deal of e-ink craft underneath. Same soul — a page that answers you — reimagined into a full assistant.
- Gallery — see it in action
- Features
- The interface & controls
- Requirements
- Install
- Configuration
- How it works
- Build from source
- Lineage & credits
- License
Every picture below is a real photo of the tablet — Muse's own reply, handwritten back onto e-ink. Nothing here is a mockup or a screenshot from another screen. You write a question with the pen; this is what writes itself back.
Write anything, anywhere on the sheet. Muse reads your ink, thinks, and replies in a flowing hand with colour, structure, and — when it helps — a drawing.
 Your question, in your own hand “Can you give me a detailed comparison table b/w RAM & ROM & also CPU & GPU” — read straight off the page. |
 …and the answer writes itself back A definition, a YES/NO diagram, and (over the next pages) working Python. |
Ask how something works and Muse reasons it out visually — data structures, algorithms, mechanisms, processes — laying out the parts and the flow between them.
 Binary search, step by step The search window narrows — low / mid / high — until the target is found. |
 Merge sort as a divide-and-conquer tree Split down to single elements, then merge back up in order. |
 Bucket sort — scatter, sort, gather Values distributed into buckets, each sorted, then concatenated. |
 How a computer's parts talk CPU, GPU, RAM and ROM around the system bus. |
Comparisons, spec sheets and data come back as proper ruled grids and labelled charts — not walls of text.
 RAM vs. ROM A clean comparison table with a shaded header and wrapped cells. |
 CPU vs. GPU Every row legible, sized to fit — no cramming, no shrinking. |
 A labelled bar chart Each bar carries its value, paired with a data table below. |
 Summary comparison Merge sort vs. bucket sort across strategy, complexity and use. |
Even a page of pure prose reads like a printed textbook — coloured headings, highlighted key terms, clean numbered steps, in a warm handwriting face.
 Coloured headings & key terms |
 Clear numbered steps |
 Definitions that read easily |
Fenced code comes back in a monospace hand with keywords, strings and numbers coloured and a rule down the side — the full solution, and the neat one-liner too.
 The full implementation Highlighted Python, exactly as it would print. |
 …and the clever shortcut The same problem in a single, explained line. |
Ask for a picture and Muse draws a friendly, coloured illustration — no labels, just a drawing. Then keep the conversation going: “add a cat beside it.” It isn't only for fun, either — ask for a flag, a classroom board, or a fresh piece of fruit and it obliges.
 A cat for a child |
 “…now add a cat beside it” |
 A familiar face |
 The Tiranga, to scale |
 A glossy red apple |
 A parent-teacher meeting board |
A single reply can weave prose, a labelled infographic, a table and a diagram together — whatever explains the idea best.
 A labelled infographic Fish anatomy, with leader lines to each external feature. |
 Table + concept diagram in one CPU, GPU and TPU — compared, then drawn. |
Every conversation is saved on the tablet. Open the Chats drawer to reopen a past thread in your own hand, or start fresh.
The Chats drawer — tap to reopen, swipe to delete. It all lives on the device.
- General assistant — cooking, writing, planning, ideas, facts, history, math, everyday life. Not a coding tool; it only writes code when you actually ask for it.
- It reads your page — your pen strokes are sent as an image, so it understands exactly what you wrote, diagrams and all.
- Follows the thread — "why?", "shorter", "give an example" build on what was already said.
- Streams as it thinks — the reply inks in sentence by sentence, so writing begins seconds before the model has finished.
- Calibrated depth — a quick question gets a quick answer; "teach me X" earns a full, well-structured explanation.
- Replies are typeset in a flowing script font on the color panel — not a terminal dump.
- Color hierarchy:
#/##/###headings, list markers, bold, andinline codeeach render in their own color. - Syntax-highlighted code blocks (keywords, strings, numbers, functions, comments).
- Every colour, the reply font, and text size are yours to change.
- The model emits a compact drawing language; Muse renders a true vector figure — lines, arrows with solid heads, polygons, bezier curves, circles, ellipses, arcs, rounded rectangles, real pie slices, dashed strokes, and centered text labels — in color.
- Sharp or smooth, by choice.
fillpolygives crisp faceted shapes (low-poly, paper-cut, a faceted gem);fillcurvegives flowing organic silhouettes (an apple, a leaf, a swan). Ask for a geometric look and you get one. - Style adapts to the subject: a precise technical diagram for structures and science, a clean chart for data, a friendly illustration for objects and art.
- Labels always win. Every label is painted after the shapes and ringed with a contrasting halo, so no edge, arrow or fill can ever swallow it — whatever order the model drew things in.
- Colors that survive e-ink. A 27-color natural palette, soft-proofed through reMarkable's own ICC profile. A fill is an area, so it dithers and can be any color — a true red apple, brown bark, a navy sea. A thin line cannot dither, so a color too pale to read is darkened along its own hue (a yellow line draws as dark gold) instead of vanishing.
- Figures are auto-cropped and composed to sit tidily inside the answer — label widths included, so a long callout is never shaved off the edge.
- A real grid with auto-sized columns, a shaded header, and dark, legible text.
- Cells wrap and rows grow — detailed multi-line answers stay just as readable as one-word values.
- Finished pages — your strokes, a transcription, and the reply — are kept entirely on the tablet.
- Recent pages ride along with each turn, so a conversation actually holds together.
- The context stays lean. A figure's drawing commands are pure rendering, so older turns carry only a
[a diagram or drawing was drawn here]note instead of hundreds of lines of coordinates — while the most recent figure is kept intact, so "make that node red" still works. Tables and code are always kept in full: their contents are part of the answer. - Writing "show me…" can conjure a past page back in your own hand.
- Drives the e-ink panel directly through the vendor waveform engine (via Quill) for low-latency ink — not the usual full-screen UI refresh.
- Multi-page replies flow across pages automatically; long answers just keep going.
- Auto-retry — a transient network or model hiccup is silently retried before you ever see a "couldn't reach the model" note.
- Palm rejection — only a single, deliberate finger counts as a gesture; a resting palm is ignored.
Everything is configurable from a phone-friendly form (remagic config muse) — the model and endpoint, reply font and size, the full color palette (per-element hex), bold weights, memory depth, and whether diagrams are on. See Configuration.
Muse is a full-screen, paper-first app: a slim bar on top, your page below, and everything driven by the pen, finger gestures, and the power button — no keyboard.
A slim bar sits across the top at all times:
| Control | What it does |
|---|---|
| Muse (left) | The wordmark. Also your home — you're on the live writing page. |
| page indicator (center) | Shows current / total while you're browsing saved pages. |
| Undo | Rubs out your last pen stroke; once there are no strokes left, it rolls back the whole last turn — removing your question and its answer together. |
| + New | Starts a fresh conversation (the current one is saved to Chats). |
| ☰ (three bars, right) | Opens the Chats drawer. |
Tap ☰ to slide open a panel of your saved conversations, newest first:
- Tap a row (on its left) to reopen that conversation — it re-renders in full, with a small drawn pencil marking each of your questions in a warm sepia.
- Tap "Delete" (right side of a row) to remove that chat.
- Long lists paginate:
^ Newerandv Moreat the bottom, with a page counter. - Tap to the far right / re-tap to close and return to your page.
- Swipe left / right with one finger to flip to the next / previous page of the current conversation.
- While browsing, a bottom scrubber appears — a track with a marker and
current / total; tap anywhere on it to jump straight to a page. - Replies that overrun a page continue on the next; you just swipe through them.
| Do this | Get this |
|---|---|
| Write with the pen below the bar, then lift and pause | The page commits and is sent; the answer streams back in ink |
| Short swipe ← / → (one finger) | Next / previous page |
| Long, deliberate swipe ← (one finger) | Start a new page (kept intentional, so a stray flick won't do it) |
| Tap (one finger) | Press a bar control, a chat row, or the scrubber |
| Five-finger tap (a flat, whole-hand tap works) | Quit Muse back to the launcher |
| Power — single press | Sleep (a "the diary sleeps" page shows, then it suspends) |
| Power — double press (within ~0.8 s) | Crispen — a full color refresh that develops the page's true colors |
On the color panel, streaming ink first appears in fast grayscale, then a color-refresh pass develops the real hues — the double-press triggers that pass on demand.
- A reMarkable Paper Pro (i.MX8MM / aarch64 — Ferrari / Chiappa / Tatsu). Not the reMarkable 1 or 2.
- remagic installed on the tablet (developer mode + the AppLoad launcher). Muse is an AppLoad app and runs on that platform.
- An API key for any OpenAI-compatible, vision-capable model (OpenAI, Google Gemini via its OpenAI-compatible endpoint, OpenRouter, a local server, …). Muse sends the page as an image, so the model must be able to see.
Muse runs on the remagic platform (xovi + AppLoad). If you haven't set it up yet, do that first — it's one command:
→ github.com/MaximeRivest/remagic
That turns on developer mode, installs the AppLoad launcher, and gives you the remagic CLI on your computer.
Pointing to your tablet:
remagicfinds it automatically — over the USB cable (address10.11.99.1) or over Wi-Fi once you've runremagic wifi on. To force a specific address, prefix any command withremagic -host <ip> ….
Two ways: the prebuilt release (easiest, no compiler) or a source build.
- Download
muse-<version>.zipfrom the Releases page and unzip it — you get amuse/folder. - With the tablet connected, push that folder into AppLoad:
remagic install ./muse
- On the tablet: open AppLoad → Reload → Muse.
That's it — Muse restores its own executable bits on launch, so there's no manual chmod step.
For the latest code or your own changes. Note this differs from a catalog app like Riddle — Riddle is prebuilt (remagic install riddle), whereas here you compile Muse yourself (Docker does the work, so no Rust setup) and push it. From the repo root, tablet connected:
bash build/muse-build.sh . muse # cross-build (Docker)
bash muse/scripts/make-bundle.sh # stage muse/dist/
remagic install muse/dist/muse # push to the tabletThen AppLoad → Reload → Muse.
When Muse lands in a remagic catalog, installing becomes a single
remagic install muse(and the on-tablet Store) — no computer needed.
From your computer:
remagic config museThis opens a settings form in your browser and prints a QR code — scan it to type on your phone. Paste your API key (MUSE_OPENAI_KEY). Muse defaults to Google Gemini (gemini-3.5-flash, medium effort), so a Gemini key is all you need; to use OpenAI / OpenRouter / a local server instead, also set the base URL and model. Full reference: muse/oracle.env.example.
Now open Muse, write a question with the pen, lift the pen, and wait a beat. It writes back.
Muse is a full-takeover app — while it's open it takes over the whole screen (the normal reMarkable UI is paused). To leave it:
- Tap the screen with all five fingers at once (a flat, whole-hand tap works) → Muse closes and the normal UI comes back.
- Power button — single press puts the tablet to sleep as usual.
Escape hatch — if the screen ever wedges: you're not stuck. From your computer, with the tablet connected, run:
ssh root@10.11.99.1 'systemctl start xochitl'That restarts the normal reMarkable UI immediately. (Muse also restores it automatically on exit, and a watchdog brings it back even if the app is force-killed — this is just the manual fallback.)
Set from remagic config muse (or an oracle.env beside the binary). Every value is optional except the key; defaults are shown.
Run it on your computer and it spins up a phone-friendly settings form and a QR code — scan it to fill everything in from your phone. There's a lot you can tune here: the model & endpoint, reasoning effort, token cap, temperature, the reply/code fonts and text size, the full per-element color palette, memory depth, pen thickness, streaming speed, and more.
 remagic config museopens the form + a QR to fill it from your phone. |
 The settings form model, key, endpoint, reasoning, tokens, temperature… and much more further down. Your key is stored only on the tablet. |
Set it once — it's saved. When you finish the form,
remagic config musewrites your settings tooracle.envnext to the app on the tablet. That file persists across reboots, and it is not overwritten when you update or reinstall Muse (updates only shiporacle.env.example, never your real file). So you enter your key and model once; change anything later by re-runningremagic config muse.
Muse works with any provider that speaks the OpenAI chat-completions API and offers a vision-capable model — it sends your page as an image, so the model must be able to see. Pick a provider, create a key, and note the model id:
| Provider | Create a key | Find model ids | Example model |
|---|---|---|---|
| OpenAI | platform.openai.com/api-keys | platform.openai.com/docs/models | gpt-4o-mini, gpt-4o |
| Google Gemini | aistudio.google.com/apikey | ai.google.dev — models | gemini-2.5-flash |
| OpenRouter | openrouter.ai/keys | openrouter.ai/models (filter: Vision) | openai/gpt-4o-mini |
You give remagic config muse up to three things:
MUSE_OPENAI_KEY— the key you created (required).MUSE_OPENAI_BASE— the endpoint URL — only if you're not using Gemini (the default).MUSE_OPENAI_MODEL— the model id — only to pick a different model.
⭐ Muse defaults to Google Gemini. If you use a Gemini key, just paste the key and you're done — the base URL, model (
gemini-3.5-flash), and effort (medium) are already set for you. Use the base/model fields only to switch to OpenAI, OpenRouter, etc.
Gemini's Flash models are fast, cheap, genuinely smart, and see images well — a great fit for the pen-and-pause loop, which is why Muse uses them out of the box. Both use the OpenAI-compatible endpoint below and medium thinking:
| Goal | MUSE_OPENAI_MODEL |
MUSE_OPENAI_REASONING |
|---|---|---|
| Balanced — fast and intelligent (recommended) | gemini-3.5-flash |
medium |
| Ultra-fast — snappiest ink, lightest model | gemini-3.1-flash-lite |
medium |
MUSE_OPENAI_BASE=https://generativelanguage.googleapis.com/v1beta/openai
MUSE_OPENAI_MODEL=gemini-3.5-flash # or gemini-3.1-flash-lite for ultra-fast
MUSE_OPENAI_REASONING=mediumTip: a smaller "flash / mini / lite" vision model keeps the ink flowing quickly and costs little; reach for a bigger model only when you want deeper answers. Whatever you pick, confirm it lists vision / image input support.
| Variable | What it does |
|---|---|
MUSE_OPENAI_KEY |
Your API key (required for the HTTP backend). |
MUSE_OPENAI_BASE |
Endpoint base URL. Default …/v1beta/openai (Google Gemini). |
MUSE_OPENAI_MODEL |
Model id. Must be vision-capable. Default gemini-3.5-flash. |
MUSE_OPENAI_REASONING |
reasoning_effort. Default medium; low/high, or off to omit. |
MUSE_OPENAI_MAX_TOKENS |
Reply cap. Default 16000 — roomy, so long multi-figure answers are never truncated. |
MUSE_OPENAI_TEMPERATURE |
Sampling randomness 0.0–2.0. Default 0.6 (steadier diagram coordinates); off omits the field. |
Example: Google Gemini (OpenAI-compatible)
MUSE_OPENAI_BASE=https://generativelanguage.googleapis.com/v1beta/openai
MUSE_OPENAI_MODEL=gemini-3.5-flash # balanced; gemini-3.1-flash-lite for ultra-fast
MUSE_OPENAI_REASONING=mediumSee The default: Google Gemini Flash above.
| Variable | Default | What it does |
|---|---|---|
MUSE_COLORS |
on |
Color palette on, or plain black everywhere. |
MUSE_DIAGRAMS |
on |
Let Muse draw diagrams and tables, or reply in prose only. |
MUSE_REPLY_FONT |
Kalam-Regular.ttf |
Reply handwriting face — any .ttf in the app's fonts/ folder. |
MUSE_REPLY_PX |
84 |
Reply text size (24–200). |
MUSE_BOLD_TEXT |
on |
Heavier, darker-reading body prose. |
MUSE_BOLD_TOKENS |
on |
Heavier, punchier syntax-colored code. |
MUSE_STREAM_MS |
25 |
Per-line reveal delay as the reply inks in (0 = instant). |
MUSE_PEN_MIN |
2 |
Ink radius (px) at the lightest touch. A stroke is 2r+1 px wide. |
MUSE_PEN_MAX |
3 |
Ink radius (px) at full pressure — how much the stroke thickens as you press. |
MUSE_MEMORY |
on |
Remember finished pages on-device and carry recent ones into replies. |
MUSE_EXTRA_INSTRUCTIONS |
— | Standing instructions ("always answer in Hindi", "be concise"). |
The full palette (per-element hex colors for headings, code, bold, bullets, …) and the rest of the knobs are documented in muse/oracle.env.example.
your pen ──▶ page image ──▶ model (OpenAI-compatible, vision) ──▶ streamed reply
│
color e-ink panel ◀── Quill (vendor waveform engine) ◀── typeset + diagrams + tables
- Full-takeover rendering. While Muse is open it takes over the display and drives the Gallery 3 color panel directly through the vendor waveform engine (via Quill), for instant ink instead of the usual UI refresh.
- Typesetting. Replies are parsed as lightweight Markdown and laid out in a script font with a colored hierarchy; code is syntax-highlighted;
```drawblocks become vector figures and```tableblocks become grids. - On-device memory. Finished pages are compressed and stored locally; recent turns are sent with each request so the conversation coheres. Nothing about your notebook leaves the tablet except the single page you're asking about.
- Two backends. An OpenAI-compatible HTTP client (pure-Rust TLS, self-contained) or a resident
piprocess — chosen at startup by whetherMUSE_OPENAI_KEYis set.
Module map lives in muse/src/ — main.rs (state machine), oracle.rs (the model + prompts), markdown.rs / typeset.rs (layout), diagram.rs (the vector + table engine), notebook.rs / memory.rs (pages + memory), and the quill/ display host.
The one dependency is Docker (it holds the reMarkable cross-toolchain). The loop:
bash build/muse-build.sh . muse # cross-build (aarch64)
bash muse/scripts/make-bundle.sh # stage muse/dist/
remagic install muse/dist/muse # push to tabletRun the unit tests with cargo test inside the same image, or off-device, render a reply to a PNG without a tablet:
muse --reply-test reply.md out.png # a whole Markdown reply → image
muse --draw-test figure.draw out.png # a single ```draw block → image(Both render the app's real output to an image without a tablet — handy for testing layout, diagrams, and tables.)
Muse stands on the shoulders of people who opened this device up and made it delightful. Please go star their work.
- Riddle by Maxime Rivest — the enchanted diary that started it all. Muse is a reimagining of that original spark; the "write and it writes back" magic is his idea.
- remagic by Maxime Rivest — the one-command platform (developer mode, AppLoad, the CLI and Store) that Muse installs onto and runs within.
- xovi & rm-appload by asivery — the function-hooking loader and app host underneath.
- xovi-tripletap by rmitchellscott — power-button persistence.
And, of course, reMarkable for the extraordinary paper-like device.
GPLv3 — see LICENSE.
Muse draws through Quill, whose framebuffer layer (quill/src/epfb.cpp, epframebuffer.h) is derived from epfb-re by asivery, licensed under the GNU General Public License v3.0. Because libquill.so is built from that code and Muse links it, the whole combined work is distributed under GPLv3 — see quill/NOTICE for the attribution. The complete corresponding source is this repository. Muse does not redistribute reMarkable's proprietary components.
Not affiliated with reMarkable. Developer mode and third-party software are used at your own risk. Muse avoids the bootloader and your encrypted data and is designed to be reversible, but you are responsible for your device.
Made for the quietest device you own. ✍️