Manim: Animation Engine for Explanatory Math Videos
Original: Manim: Animation engine for explanatory math videos
Key topics
Regulars are buzzing about Manim, an animation engine for explanatory math videos, with many praising its ability to make complex concepts more accessible and engaging. Commenters riff on how Manim has fostered a community around 3Blue1Brown, a popular YouTube channel, and how it's been used to create helpful visualizations for understanding math concepts and research papers. Some users share their own experiences using Manim with AI tools like Cursor to create explanatory videos, while others point out that the project has been shared before, sparking a discussion about duplicate submissions and the site's policies. The thread feels relevant now because it taps into the ongoing interest in making complex ideas more intuitive and interactive.
Snapshot generated from the HN discussion
Discussion Activity
Very active discussionFirst comment
54m
Peak period
40
0-6h
Avg / period
11.3
Based on 68 loaded comments
Key moments
- 01Story posted
Aug 23, 2025 at 3:35 AM EDT
5 months ago
Step 01 - 02First comment
Aug 23, 2025 at 4:30 AM EDT
54m after posting
Step 02 - 03Peak activity
40 comments in 0-6h
Hottest window of the conversation
Step 03 - 04Latest activity
Aug 26, 2025 at 5:44 AM EDT
5 months ago
Step 04
Generating AI Summary...
Analyzing up to 500 comments to identify key contributors and discussion patterns
Want the full context?
Jump to the original sources
Read the primary article or dive into the live Hacker News thread when you're ready.
https://youtu.be/B1J6Ou4q8vE
I like math but showing someone a giant graph isn’t always the best approach. :)
Agreed. 3Blue1Brown has, by making their videos, publishing Manim, and critically by fostering a broader community of math YouTubers instead of trying to hoard the audience for themselves (through SoME), moved mathematics pedagogy forward immensely. (Sal Khan also deserves credit here.) He's created a genre that makes math feel like an exciting and approachable journey, rather than a process of memorization and symbol manipulation.
https://hn.algolia.com/?q=manim
Manim: Math Animation
Src: ManimCommunity/manim: https://github.com/ManimCommunity/manim
Docs: https://docs.manim.community/en/stable/
GH topic: manim: https://github.com/topics/manim :
manimML, manim-physics, chanim, manim-web (dart), JAnim (java), ranim (rust), manim-voiceover, git-sim, TheoremExplainAgent, reactive-manim, jupyter-manim, manim-sideview (vscode), manim-studio (Qt, Cairo)
ManimCommunity/awesome-manim has a list of creators that create with manim: https://github.com/ManimCommunity/awesome-manim
/?youtube manim: https://www.youtube.com/results?sp=mAEA&search_query=Manim+
From https://news.ycombinator.com/item?id=39296310 re: StageCraft / UE:
> "Ask HN: What's the state of the art for drawing math diagrams online?" (2023) https://news.ycombinator.com/item?id=38355444 ; generative-manim, manimGPT, BlenderGPT, ipyblender [ Blender MCP, ]
generative-manim: https://github.com/marcelo-earth/generative-manim
manimGPT: https://chatgpt.com/g/g-dtA3t9WRW-manimgpt
What are some of the similarities and differences between Subagents to dev on Manim the software, and Subagents to teach with manim?
AGENTS.md, awesome-claude-code-subagents > Language specialists, :https://github.com/VoltAgent/awesome-claude-code-subagents#0...
A prompt prefix for Manim with really any LLM:
Generate Manim Python code, to visually demonstrate and visually explain,
Generate Manim Python code With reactive pattern like reactive-manim and components like MathTex and MathString, to visually demonstrate and visually explain,
https://github.com/ManimCommunity/manim/
- Avoid breaking changes
- Keep APIs stable
- Test and document everything, etc.
I personally think there's nothing wrong with that. We wouldn't say that a musician is *obligated* to put out a second album or a remaster. We wouldn't say that an author *must* make a sequel to their popular book. But when it comes to code sometimes we feel like the original author has an obligation to keep working on it just because it would convenience us.
(edited for formatting)
> While Grant Sanderson continues to maintain his own repository, we recommend this version for its continued development, improved features, enhanced documentation, and more active community-driven maintenance. If you would like to study how Grant makes his videos, head over to his repository
If you did want your software project to run the same as today when compiled/interpreted 10 years from now, what would you have to reach for to make it 'rot-resistant'?
Target Windows, avoid Linux.
There is a relevant point about OSes though, and it has a different conclusion from yours: Write our software (And OSes) in a way that doesn't create barriers and friction between systems.
No idea what to do if it needs a gui, though.
If it ran 20 years ago and it still runs now, it's very likely to still run in another 20 years.
I think the best defence is to choose a platform that has longevity, like x86 Linux, and then seriously limit dependencies beyond the platform to the point of maybe not having any extra dependencies.
The problem is eventually platforms change too. The longest lasting platform for software ever created is x86 + BIOS which lasted from 1981 to 2020 when Intel officially deprecated BIOS.
I’ve kept all my dumb little side projects for my entire life, starting from Basic, Pascal & x86 assembly as a teenager 30 or more years ago, lots of C++ and OpenGL in college, python over the last 15 years, and HTML+Javascript mostly from ~10 years ago.
Surprisingly, the stuff that still runs with the least trouble from my teenage years several decades ago is the assembly code. Basic and Pascal I can do with emulators, but it takes more work. My C++ OpenGL projects from 15-25 years ago take some work to resurrect, but can be done. C++ command line code from 25 years ago compiles and runs without issues. Python from 15 years ago still runs, even the python 2.x code. HTML+JS from 10 years ago still runs without changes. My Arduino projects from 10 years ago might have bit rotted the most; they almost require starting over to get them going again.
Ironically even though the JS ecosystem has had some of the highest churn, I feel like it’s one of the safer bets, as long as you keep dependencies down. Don’t pull a ton of crap from npm/yarn/whatever. Use mostly vanilla JS+HTML, and it will definitely run on almost any OS and mobile device 10 years from now.
Anything with standards behind it necessarily moves pretty slowly. What C++ looks like is changing over time, but old code is pretty safe most of the time, and code written today should continue to work for 10 years easily.
Documentation helps and keeping code simple helps.
But what really what rots away is human memory.
This greatly limits velocity, though, and still doesn't help against security issues that need patching.. or if any of the stable dependencies made certain assumptions about hardware that has since changed. But, with the right selection of dependencies and some attention to good design, it is possible to write code durable against bitrot. It's just very uncommon.
I suppose you have gumroad / serialized novels or webcomics but I’m not sure if there’s any albums where the musician is putting out one song at a time
Grant developed the software originally as a personal tool for his YouTube videos. The software is optimized for his personal needs.
The community version tries to make the tool useful for more people. They’ve built out the docs and apparently improved testing.
My pattern-matching brain thinks the fork is by people who want to build infrastructure that will suit its own end, at the cost of the original purpose of supporting the applications that call it. It is and will continue to decouple from the intended application. Design-by-committee, expanded to too many use cases, and just a general loss of UX. I think this is a clear case of comparing
"Expert who wants to get-shit-done" / "Library maintainers who want to maintain and promote a library"
Grant built a brilliant tool for himself. He's not interested in doing the work to make it useful to others, or even allow PRs to do so. He's glad to have others do that in their own fork.
The community edition does all the stuff needed to make this useful to anyone who isn't Grant. Everyone, Grant included, seems to appreciate that.
Grant's version has poor documentation, bugs, quirks, etc. Unless you're Grant, get CE.
Grant did the hard work of inventing this thing. That's harder than it sounds; many tried before and failed.
CE did the boring work of making it usable for others.
What I don't quite understand is how one library can animate so many different concepts. To me they seem like they'd all be a custom job, but I guess he works on a higher plane of mathematical existence.
It's because there are a _lot_ of community objects built from the core primitives that are good starting points that you can customize from there:
https://docs.manim.community/en/stable/reference_index/mobje...
Links:
- https://eater.net/quaternions
- https://eater.net/quaternions/video/intro
Part of it is the simplistic syntax and the sheer amount of open source manim examples to train on but it’s a pretty great demonstration of ai coding agents time saving. Especially since the output video looking correct is all you care about here. Ie. I don’t actually care about the specifics of how my explanatory videos were created, just that they were created via a simple prompt and it gave me what i wanted.
- https://www.befreed.ai/knowledge-visualizer
- https://kodisc.com/
- https://github.com/hesamsheikh/AnimAI-Trainer
- https://tiger-ai-lab.github.io/TheoremExplainAgent/
- https://tma.live/, HN discussion: https://news.ycombinator.com/item?id=42590290
- https://generative-manim.vercel.app/
No doubt the results can be impressive: https://x.com/zan2434/status/1898145292937314347
Only reason I'm aware of all these attempts is because I'm betting the 'one-shot LLM animation' technique is not scalable long term. I'm trying to build an AI animation app that has a good human-in-the-loop experience. Though I'm building with bevy instead of manim
I can imagine LLMs being very confused being asked to write “manim” when everyone talking about “manim” (and the vast majority of public manim code) is actually the subtly-but-substantially different “manim-ce”.
It's linked in the readme, but I want to highlight the demo video [0], where Grant explains how he works with Manim.
[0] https://www.youtube.com/watch?v=rbu7Zu5X1zI
https://github.com/vydd/sketch
Math animaton package for Common Lisp.
Some of the results are not perfect (AI sometimes misaligns some shapes), but it's quite helpful and with a couple of iterations you get to a really good explainer video.
https://github.com/ManimCommunity/manim
I did make an attempt at fixing that but it got zero traction. I wonder if they've made any progress.
from what i can tell they render their whole videos start to finish using it?
Show HN: Python library to add voiceovers to Manim videos programmatically - https://news.ycombinator.com/item?id=35961318 - May 2023 (6 comments)
Manim: Animation engine for explanatory math videos - https://news.ycombinator.com/item?id=31636657 - June 2022 (16 comments)
Manim – Python library for creating mathematical animations - https://news.ycombinator.com/item?id=30658390 - March 2022 (25 comments)
Manim: An animation engine for explanatory math videos - https://news.ycombinator.com/item?id=28245277 - Aug 2021 (67 comments)
Manim – an animation engine for explanatory math videos - https://news.ycombinator.com/item?id=26498527 - March 2021 (75 comments)
Show HN: I made a parser visualizer using manim - https://news.ycombinator.com/item?id=26382729 - March 2021 (15 comments)
A Manim Code Template - https://news.ycombinator.com/item?id=24985609 - Nov 2020 (1 comment)
Manim: Animation engine for explanatory math videos - https://news.ycombinator.com/item?id=24926947 - Oct 2020 (19 comments)
Manim – 3Blue1Brown's animation engine for explanatory math videos - https://news.ycombinator.com/item?id=19716019 - April 2019 (80 comments)