Penmentor - Claude marks up your handwritten math like a teacher
<p align="center">
A maths mentor at the tip of your pen. Press a key while you work by hand: Claude, Gemini or GPT marks your work on the screen like a teacher with coloured pens, gives you hints instead of answers, and shows the idea as a 3Blue1Brown-style animation.
</p>
!Image description
<sub>Handwriting in xournal++ → one key → the slip is marked on the page → box the integral → an interactive manim animation.
(<a href="docs/demo.mp4">video</a>; for a repeatable recording the pen is scripted and the model's answer is a fixed example.)</sub></p>
Why I use it
I study calculus with a pen tablet in xournal++. I kept screenshotting my work into Claude and reading long answers
back, when what I wanted was a teacher looking over my shoulder: circle the mistake, tick what's right, nudge me toward
the next step, and show me why. penmentor is that, one key away, on my own Claude subscription.
How it helps you learn
- Hints, not answers. A ladder from a nudge to naming the technique to a faint ghost of the next line: you do
the thinking, which is what makes it stick.
- Feedback on your own work. The first real mistake circled where you made it, correct lines ticked, later lines
that inherit the mistake underlined. The marks stay while you keep writing; Esc clears them.
- Practice that makes you recall. Questions on your key steps (answer by typing or by writing), find-the-error
drills, "which technique fits?".
- See it. Box what you want to understand and get an interactive animation made with 3Blue1Brown's own
manim: drag the bounds, retype a value, watch Riemann sums close in.
- Whole page aware. A small xournal++ plugin shares the page you are on, not just what fits on screen.
Works with Claude Code, Codex and Antigravity
penmentor runs on the AI command-line agent you already use, on that subscription. Pick the model in Settings; its
prefix says which agent answers:
| Prefix | Agent | For example |
|---|---|---|
| claude: | Claude Code | claude:opus, claude:sonnet, claude:haiku |
| codex: | Codex | codex:gpt-5.6-terra |
| agy: | Antigravity CLI | agy:gemini-4-argon-medium, agy:gemini-3.8-flash-medium |
Settings lists the agents you have installed. How each one is run and what it sees: [the guide](docs/guide.md#how-it-works-and-what-leaves-your-computer).
Quick start
git clone https://github.com/AbdullahAlhariri/penmentor ~/src/penmentor
~/src/penmentor/bin/penmentor --selftest
Linux on X11 (best with i3), with one of those agents logged in (claude, codex or agy), plus rofi, slop,
xdotool and PyQt6. Bind bin/penmentor to a key ([example](contrib/i3.conf)). Setup, keys and how it works: [the guide](docs/guide.md).
Star History
!Image description
License
[MIT](LICENSE)
1 reaction
How I built a realtime editor for ManimGL
> TL;DR: With AI helping write the code, we built Manim Studio, a realtime desktop editor for ManimGL scenes: code on the left, a live preview on the right, a scrubbable timeline below. No render-wait-tweak loop: save the file and the preview updates in place; retime an animation by dragging it. It went from an empty project to v1.1.0 in 124 commits. This is Part 1: why it exists, what it does, and how it went. Part 2 is the technical deep-dive into the architecture and every choice that shaped it.
The itch
Manim makes beautiful math animations, and I make them for my YouTube channel. The trouble is the making. My loop was always the same: write a scene, wait for the render, watch the result, tweak one number, wait again. It was slow, and nothing about it felt like editing.
I tried the tools that already existed. The Manim Community version. VS Code extensions driving Jupyter notebooks. Neither stuck. The iteration speed was the killer, and Jupyter never felt like an editor. It's a place to run code and inspect output, not a place to work on an animation.
So I stopped looking and started building: something faster, that feels like a video editor.
That single sentence turned out to be a design brief for everything that followed. "Faster" meant never rendering a video just to see a change. "Feels like a video editor" meant a timeline you scrub, a playhead, and retiming an animation by dragging its edge instead of editing a run_time= literal and re-rendering.
I didn't write all the code by hand. I used AI to help write it. When I say "we" in this post, I mean me and the AI working on the implementation. "I" still means my own experience, goals, and decisions.
The premise
Before writing code I wrote down what I actually wanted, and gave myself three non-negotiables:
- Realtime preview. A persistent OpenGL context, updated at 30 fps, with no ffmpeg encode per edit.
- Production-grade, no hacks. Fully tested. Whenever a design decision changed course, I wrote down why. That habit became an AGENTS.md contract and nine architecture decision records.
- Drivable by an agent. I wanted to be able to say "build me a CircleToSquare scene" and have a CLI do it. Everything in the GUI is also a command.
The shape of the app is almost boringly simple: a code editor on the left, the running scene on the right, the timeline below. Everything else exists to keep those three in sync.
!ManimStudio
The editor: code on the left, live preview on the right, timeline below.
What it actually does
Concretely, this is what's in the box:
- A real code editor. Scintilla, not a textbox: manimlib autocomplete and call signatures, error markers that jump to the failing line, syntax highlighting, full undo/redo.
- A live preview, embedded in the window by default or shown in a separate GL window, plus a live IPython shell wired to the running scene.
- A timeline built from a runtime trace of play() and wait(), so loops and branches produce the right blocks. Drag to scrub the live scene, wheel to pan, Ctrl+wheel to zoom, arrow keys to step one frame.
- An editable timeline. Retime or delete an animation by dragging it or typing an exact duration. The edit is anchored to the code, saved next to your scene, and baked into the export.
- One-click export to MP4 (up to 4K/60), GIF, or a still, using headless manimgl -w and honouring your timeline edits.
- A CLI for everything. Every feature is also a command, so the editor can be driven by an agent.
That last point mattered more than I expected. Because the GUI only ever talks to the preview host through a message protocol, the exact same commands are available from a terminal: check, trace, export, new, and preview. I can say "build me a CircleToSquare scene" and the tooling can actually do it.
The trajectory
Three shippable states, each with a job to do:
| Release | What landed |
| --- | --- |
| 0.1.0: initial shareable build | Scintilla editor, embedded realtime preview, runtime-traced timeline with replay-based scrubbing and a filmstrip cache, live IPython shell, video/still export, and the headless CLI |
| 1.0.0: first public release | Pygments syntax highlighting, Jedi autocomplete + calltips, app icon, live memory/RAM status, and a one-click frozen Windows build (portable zip + per-user installer) |
| 1.1.0 | The editable timeline: retime and delete animations as anchored edits stored beside the scene, baked into exports. Themes. A big rendering-performance pass |
0.1.0 is "it works." 1.0.0 is "someone else can install it." 1.1.0 is where it stops being a preview and becomes an editor: you don't just watch the timeline, you work on it.
!Timeline Editor
Lanes per animation, a block inspector, scrub, and the orphan tray.
How it actually went
A few habits kept the project honest as it grew. Every decision that bent the design got written down as an ADR the moment I made it: nine of them, in order, from "why a separate process" to "how to reuse cached frames after an edit." We kept the test suite green before every commit (by the first release: 474 passing tests), and we optimised nothing without a benchmark to prove the change.
It wasn't smooth, though. Scrubbing took three designs to get right, and the obvious one didn't work.
<!-- TODO: add one or two sentences on what went wrong with the first attempt and what it cost you. This is the most relatable part of the post. -->
The written decisions are what stopped me re-litigating the same question three times, and the tests are what let us refactor a 1,000-line file into eight without breaking it.
Becoming Manim Studio
The product began as "Manim Editor" and was renamed Manim Studio on the way to the first public release: import package manim_studio, CLI manim-studio, Windows bundle ManimStudio. "Studio" describes what it grew into: not a text editor that also shows you a preview, but an environment you work in. The same stretch of work made the repository real: an MIT license, a CI pipeline (format, lint, types, and tests, currently on Windows), a tagged release workflow, Dependabot, and the usual community files. "It works on my machine" became "it works on yours."
Try it
Manim Studio is MIT-licensed and open source. The packaged build is for Windows (a portable zip or a per-user installer); CI currently runs on Windows too. Grab it from the Releases page, or clone the repo from AzadKshitij/manim-studio. If you make Manim animations, I'd love to hear what's missing. Issues, feedback, and stars are all welcome.
What Part 2 covers
Part 1 was the story. Part 2 is the engineering, and it's where the interesting decisions live:
- Why the preview runs in a separate process that owns the only OpenGL context, and why the editor's GUI never touches GL.
- Why the timeline is a runtime trace, not a parsed AST.
- Scrubbing, three designs deep, and why the obvious one doesn't work.
- How "make it fast" became a measured discipline with before/after numbers.
- How the timeline became an editor through anchored patches in a sidecar file.
- The long tail: LaTeX on demand, frozen packaging, themes-as-data, and the gotchas that cost real hours.
5 reactions
Mentions
Manim: An animation engine for explanatory math videos (42k stars) What it does All text below is quoted directly from the project README. >A community-maintained Python framework for creating mathematical animations. Usage: - Manim is an animation engine for explanatory math videos. - It's used to create precise animations programmatically, as demonstrated in the videos of 3Blue1Brown. - Manim is an extremely versatile package. - You should see your native video player program pop up and play a simple scene in which a square is transformed into a circle. - Manim also ships with a %%manim IPython magic which allows to use it conveniently in JupyterLab (as well as classic Jupyter) notebooks. >manim -p -ql example.py SquareToCircle Repository ManimCommunity/manim Repository stats |Metric|Value| |:-|:-| |Stars|42,018| |Forks|3.2k| |Last release|v0.22.1 (2026-10-27)| |Languages|Python 98.4%, GLSL 1.4%, Other 0.2%| |Contributors|516| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|None| |AI co-authored commits|Claude: 3| Main contributor |Field|Value| |:-|:-| |Name|Grant Sanderson| |GitHub|@3b1b| |Commits to this repo|2,235 (top contributor)| |Bio|I make videos about math.| |Company / Location|3Blue1Brown| |Followers|42.2k| ────────────────────────────── 📌 If you want to browse more repos like this, we've organized them by category and rankings here: bestgithubrepositories.com 🗂️ We're also archiving repos where possible, so useful projects don't disappear when they're removed from GitHub.
@amritwt He created an animation tool specifically for this to happen. But it was before AI slop was an issue. 3b1b/manim
Penmentor - Claude marks up your handwritten math like a teacher <p align="center"> A maths mentor at the tip of your pen. Press a key while you work by hand: Claude, Gemini or GPT marks your work on the screen like a teacher with coloured pens, gives you hints instead of answers, and shows the idea as a 3Blue1Brown-style animation. </p> !Image description <sub>Handwriting in xournal++ → one key → the slip is marked on the page → box the integral → an interactive manim animation. (<a href="docs/demo.mp4">video</a>; for a repeatable recording the pen is scripted and the model's answer is a fixed example.)</sub></p> Why I use it I study calculus with a pen tablet in xournal++. I kept screenshotting my work into Claude and reading long answers back, when what I wanted was a teacher looking over my shoulder: circle the mistake, tick what's right, nudge me toward the next step, and show me why. penmentor is that, one key away, on my own Claude subscription. How it helps you learn - Hints, not answers. A ladder from a nudge to naming the technique to a faint ghost of the next line: you do the thinking, which is what makes it stick. - Feedback on your own work. The first real mistake circled where you made it, correct lines ticked, later lines that inherit the mistake underlined. The marks stay while you keep writing; Esc clears them. - Practice that makes you recall. Questions on your key steps (answer by typing or by writing), find-the-error drills, "which technique fits?". - See it. Box what you want to understand and get an interactive animation made with 3Blue1Brown's own manim: drag the bounds, retype a value, watch Riemann sums close in. - Whole page aware. A small xournal++ plugin shares the page you are on, not just what fits on screen. Works with Claude Code, Codex and Antigravity penmentor runs on the AI command-line agent you already use, on that subscription. Pick the model in Settings; its prefix says which agent answers: | Prefix | Agent | For example | |---|---|---| | claude: | Claude Code | claude:opus, claude:sonnet, claude:haiku | | codex: | Codex | codex:gpt-5.6-terra | | agy: | Antigravity CLI | agy:gemini-4-argon-medium, agy:gemini-3.8-flash-medium | Settings lists the agents you have installed. How each one is run and what it sees: [the guide](docs/guide.md#how-it-works-and-what-leaves-your-computer). Quick start git clone https://github.com/AbdullahAlhariri/penmentor ~/src/penmentor ~/src/penmentor/bin/penmentor --selftest Linux on X11 (best with i3), with one of those agents logged in (claude, codex or agy), plus rofi, slop, xdotool and PyQt6. Bind bin/penmentor to a key ([example](contrib/i3.conf)). Setup, keys and how it works: [the guide](docs/guide.md). Star History !Image description License [MIT](LICENSE)
Lantern: animated code explainers (made with Lantern) | GitHub Spotlight ⬇ Download / try it: ivarvong/lantern Live demo: lantern.ivar.workers.dev GitHub Spotlight: Lantern, a 1-day-old repo by Ivar Vong (Principal Engineer at Cloudflare) that makes animated, step-by-step explainers for code. 174 stars on day one. What it is: a zero-dependency TypeScript port of manim's core (the engine behind 3Blue1Brown), rendering to SVG in the browser, Node or Cloudflare Workers. How it works: shapes are point buffers, animations are pure functions of time, a fixed-timestep loop makes every frame reproducible and every step linkable, and "sinks" output live SVG, SVG strings, plain text or a state trace for AI agents. What's different: vs Manim, Remotion and Motion Canvas (video-first), Lantern has zero deps, runs anywhere JS runs, gives each step a URL, and checks animations against the real program. Caveats: 1 day old, not on npm yet, no 3D or LaTeX. Every animated diagram in this video was drawn with Lantern itself. Chapters 0:00 Lantern: 1 day old 0:12 What it is 0:32 How it works 0:56 What makes it different 1:25 What you could build 1:42 Caveats 1:52 Get it Sources • Repo: ivarvong/lantern • Author: github.com/ivarvong • Manim: 3b1b/manim • Remotion: remotion-dev/remotion • Motion Canvas: motion-canvas/motion-canvas Narration: Kokoro TTS · Made by Benchmarkvincible
Manim 是用于制作数学动画的 Python 工具，3Blue1Brown 的视频就使用了这类工具。 它可以展示函数图像、几何变换、向量运动和公式推导，适合制作数学、计算机相关的教学视频。下面这个仓库是原作者维护的 ManimGL，与社区版 Manim 有区别，安装和使用时需要对应各自的文档。 3b1b/manim
manim: make math videos dance with Python Manim lets you script every frame of a math animation in Python, so you get precise, programmatic control. Install it with a single pip command (pip install manimgl) and start rendering scenes right away. Perfect for anyone who wants clear code over keyframes. Built by Grant Sanderson: 3b1b/manim
Math videos that dance Manim lets you script every frame of a math animation in Python, so you get precise, programmatic control. Install it with a single pip command (pip install manimgl) and start rendering scenes right away. 🍒 Built by Grant Sanderson 3b1b/manim #opensource #python
和就能生成。 它跟同类工具最大的区别是 别人做的是"画图工具"，它做的是"可编程的动画引擎" 适合做教育内容、技术讲解、论文配图的兄弟，不适合想拖拽出片的人。 你们平时做数学或算法讲解，是手搓动画还是直接录屏？ 🔗 3b1b/manim #效率工具 #开源
How I built a realtime editor for ManimGL > TL;DR: With AI helping write the code, we built Manim Studio, a realtime desktop editor for ManimGL scenes: code on the left, a live preview on the right, a scrubbable timeline below. No render-wait-tweak loop: save the file and the preview updates in place; retime an animation by dragging it. It went from an empty project to v1.1.0 in 124 commits. This is Part 1: why it exists, what it does, and how it went. Part 2 is the technical deep-dive into the architecture and every choice that shaped it. The itch Manim makes beautiful math animations, and I make them for my YouTube channel. The trouble is the making. My loop was always the same: write a scene, wait for the render, watch the result, tweak one number, wait again. It was slow, and nothing about it felt like editing. I tried the tools that already existed. The Manim Community version. VS Code extensions driving Jupyter notebooks. Neither stuck. The iteration speed was the killer, and Jupyter never felt like an editor. It's a place to run code and inspect output, not a place to work on an animation. So I stopped looking and started building: something faster, that feels like a video editor. That single sentence turned out to be a design brief for everything that followed. "Faster" meant never rendering a video just to see a change. "Feels like a video editor" meant a timeline you scrub, a playhead, and retiming an animation by dragging its edge instead of editing a run_time= literal and re-rendering. I didn't write all the code by hand. I used AI to help write it. When I say "we" in this post, I mean me and the AI working on the implementation. "I" still means my own experience, goals, and decisions. The premise Before writing code I wrote down what I actually wanted, and gave myself three non-negotiables: - Realtime preview. A persistent OpenGL context, updated at 30 fps, with no ffmpeg encode per edit. - Production-grade, no hacks. Fully tested. Whenever a design decision changed course, I wrote down why. That habit became an AGENTS.md contract and nine architecture decision records. - Drivable by an agent. I wanted to be able to say "build me a CircleToSquare scene" and have a CLI do it. Everything in the GUI is also a command. The shape of the app is almost boringly simple: a code editor on the left, the running scene on the right, the timeline below. Everything else exists to keep those three in sync. !ManimStudio The editor: code on the left, live preview on the right, timeline below. What it actually does Concretely, this is what's in the box: - A real code editor. Scintilla, not a textbox: manimlib autocomplete and call signatures, error markers that jump to the failing line, syntax highlighting, full undo/redo. - A live preview, embedded in the window by default or shown in a separate GL window, plus a live IPython shell wired to the running scene. - A timeline built from a runtime trace of play() and wait(), so loops and branches produce the right blocks. Drag to scrub the live scene, wheel to pan, Ctrl+wheel to zoom, arrow keys to step one frame. - An editable timeline. Retime or delete an animation by dragging it or typing an exact duration. The edit is anchored to the code, saved next to your scene, and baked into the export. - One-click export to MP4 (up to 4K/60), GIF, or a still, using headless manimgl -w and honouring your timeline edits. - A CLI for everything. Every feature is also a command, so the editor can be driven by an agent. That last point mattered more than I expected. Because the GUI only ever talks to the preview host through a message protocol, the exact same commands are available from a terminal: check, trace, export, new, and preview. I can say "build me a CircleToSquare scene" and the tooling can actually do it. The trajectory Three shippable states, each with a job to do: | Release | What landed | | --- | --- | | 0.1.0: initial shareable build | Scintilla editor, embedded realtime preview, runtime-traced timeline with replay-based scrubbing and a filmstrip cache, live IPython shell, video/still export, and the headless CLI | | 1.0.0: first public release | Pygments syntax highlighting, Jedi autocomplete + calltips, app icon, live memory/RAM status, and a one-click frozen Windows build (portable zip + per-user installer) | | 1.1.0 | The editable timeline: retime and delete animations as anchored edits stored beside the scene, baked into exports. Themes. A big rendering-performance pass | 0.1.0 is "it works." 1.0.0 is "someone else can install it." 1.1.0 is where it stops being a preview and becomes an editor: you don't just watch the timeline, you work on it. !Timeline Editor Lanes per animation, a block inspector, scrub, and the orphan tray. How it actually went A few habits kept the project honest as it grew. Every decision that bent the design got written down as an ADR the moment I made it: nine of them, in order, from "why a separate process" to "how to reuse cached frames after an edit." We kept the test suite green before every commit (by the first release: 474 passing tests), and we optimised nothing without a benchmark to prove the change. It wasn't smooth, though. Scrubbing took three designs to get right, and the obvious one didn't work. <!-- TODO: add one or two sentences on what went wrong with the first attempt and what it cost you. This is the most relatable part of the post. --> The written decisions are what stopped me re-litigating the same question three times, and the tests are what let us refactor a 1,000-line file into eight without breaking it. Becoming Manim Studio The product began as "Manim Editor" and was renamed Manim Studio on the way to the first public release: import package manim_studio, CLI manim-studio, Windows bundle ManimStudio. "Studio" describes what it grew into: not a text editor that also shows you a preview, but an environment you work in. The same stretch of work made the repository real: an MIT license, a CI pipeline (format, lint, types, and tests, currently on Windows), a tagged release workflow, Dependabot, and the usual community files. "It works on my machine" became "it works on yours." Try it Manim Studio is MIT-licensed and open source. The packaged build is for Windows (a portable zip or a per-user installer); CI currently runs on Windows too. Grab it from the Releases page, or clone the repo from AzadKshitij/manim-studio. If you make Manim animations, I'd love to hear what's missing. Issues, feedback, and stars are all welcome. What Part 2 covers Part 1 was the story. Part 2 is the engineering, and it's where the interesting decisions live: - Why the preview runs in a separate process that owns the only OpenGL context, and why the editor's GUI never touches GL. - Why the timeline is a runtime trace, not a parsed AST. - Scrubbing, three designs deep, and why the obvious one doesn't work. - How "make it fast" became a measured discipline with before/after numbers. - How the timeline became an editor through anchored patches in a sidecar file. - The long tail: LaTeX on demand, frozen packaging, themes-as-data, and the gotchas that cost real hours.
@renjunkgoreng Claude, terus make 3b1b/manim untuk minta bikin visualisasi nya