Manim: Animation engine for explanatory math videos

Wanted to look for this a while back. Thank you for sharing the link.

This is cool. I immediately clicked because I thought of this awesome video from a couple years ago, Animation vs Math:

https://youtu.be/B1J6Ou4q8vE

I like math but showing someone a giant graph isn’t always the best approach. :)

I have been using this with cursor to make videos to explain papers and math concepts to myself.

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.

> 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.

This gets submitted quite regularly to HN with many good discussions- so instead of posting the discussions I'll just link the search.

https://hn.algolia.com/?q=manim

See also :

https://github.com/ManimCommunity/manim

aren't HN supposed to deduplicate links? I thought duplicate URL submissions not allowed..

HN allows duplicate submissions after a certain amount of time has passed

It seems like the community fork would be the better link for most people.

https://github.com/ManimCommunity/manim/

Grant's work with 3blue1brown and Manim is simply amazing. The quality of the videos is so high, not the least thanks to the visualizations. Not an easy task given the abstract nature of the topic.

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

another youtuber-math-video-library: https://github.com/2swap/swaptube

from what i can tell they render their whole videos start to finish using it?

3b1b is truly a wonder of the internet world. Such beautiful animations, such well thought out explanations.

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.

> What I don't quite understand is how one library can animate so many different concepts.

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...

For good reasons or for drama reasons? I read the blurb about the fork and can’t tell why exactly if Grant is continuing to maintain the original.

Well, to me it seems like he just shared the original so that others could benefit from the work he had already done, but that since his main priority is to continue making new videos, he may not have the time resources to:

- 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)

Can in it do interactive 3d diagrams.

Looks like the projects have slightly different goals.

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.

Yeah for sure! Listing that kind of thing would probably be helpful. I think this is one of those “you’ve gotta already be on the inside and already know” things as the fork’s read me doesn’t seem to explain it.

I agree, but want to add that while we may perceive other creative works as 'finished' (to an extent), code often is not. It unfortunately, needs perpetual work.

This is pretty clear from the readme though?

> 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

Is there an awesome list for manim the software?

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+

Hm, yeah. And I read that. But I still didn’t feel equipped to know which I ought to focus on. Maybe it’s just too early on a Saturday for me.

It's pretty wild to me (I do hardware) that data goods like code can rot the way they do. If my electronics designs sit for a couple years, they'll need changes to deal with parts obsolescence etc. if you want to make new units.

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'?

That’s actually a really good point! I wonder if one day there will be analogues for music and writing?

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

It's fairly common for artists to release a single or two from an upcoming album. Some artists release more singles than they do albums.

> 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.

I don't think base manim support interactive 3D env. But Grant & Ben Eater built "an interactive video" back then about quaternion which you can interact with.

Links:

- https://eater.net/quaternions

- https://eater.net/quaternions/video/intro

The biggest factor is dependencies' changes, so a good defense against bitrot is to reduce the dependencies as much as possible and try to limit dependencies to those which are exceptionally stable.

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.

Manim and LLMs; LLMs are great for first drafts but fix this sentence, almost working API examples, and links to manim API docs for 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,

One big thing is just losing knowledge of why things were done a certain way and how they actually work.

Documentation helps and keeping code simple helps.

But what really what rots away is human memory.

As we are in HN:

https://github.com/vydd/sketch

Math animaton package for Common Lisp.

There is also the coopling issue: when your code depend of another part of your own code, it may be broken by this inner dependecy. If the code is not intégration tested enough, then rarely used features may be broken without you noticing, thus the roting expression. Modern standards help protect against this with the test pyramid.

And it shouldn't need to. Making (relatively) simple changes like checking-in fixed versions of dependencies in the code base and abstracting away core logic from the platform layer goes a long way. This works well for video games

In some of grant’s video, it sort of do 3d, not’interacively though: https://youtu.be/KTzGBJPuJwM

And more common nowadays, to re-release/master the recording as 'the artist intended'. But once you are familiarised with an original work and its (unintended) artefacts, a re-do is likely to lose some of the initial magic that drew you to the work in the first place.

I used Manim for one of my class presentations, absolutely a delight to use and as expected many people recognized the style and overall the presentation was well received. Incredibly, I had the opportunity to meet Grant as well a few years back. I told him I have used Manim and he was genuinely excited. Such a cool person with so much contribution to human knowledge and understanding.

It's the same sort of thing, parts obsolescence. The world around you changes and the interfaces you used to interact with the world may not exist anymore. Your dependencies may have been abandoned and have gone through their own bitrot.

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.

Made math like building blocks vs a foreign language.

ABI compatibility is one of several components involved. The OS the software runs out plays a small role in this problem.

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.

Write it in a specific version of a language with a strong history of backwards compatibility, like Fortran90. Maybe c99? And just use very famous libraries, like BLAS, that are never going away.

No idea what to do if it needs a gui, though.

Fwiw this absolutely works amazingly well with modern coding assistants. “I want a diagram of equation X morphing into Y” or similar is always a one shot success for me.

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.

Is there a typescript alternative?

Try to run it on a 20-year-old system.

If it ran 20 years ago and it still runs now, it's very likely to still run in another 20 years.

The sort of project Grant made is exquisite. It's not built by OSS library maintainers: It's built by someone who is interested in the application, and is an expert in the domain. Suitable tools didn't exist, so he built and maintains a tool that works well for his real-world applications.

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 himself advocated for the use of the fork and discourages the use of his own version. I’ve heard that directly from him in person.

Curious to see how it'll combine with a RAG on its documentation.

I remember listening to a podcast where Grant Sanderson basically said the opposite. He tried generating manim code with LLMs and found the results unimpressive. Probably just goes to show that competence in manim looks very different to us layman than it does to Grant haha

Think you need to go with a "dead" language with a simple runtime and keep everything vendored. My top contender would be Lua 5.1. Simple runtime (~20k(?) lines of C) which has been implemented in many other platforms (Javascript, Go, Rust). The side benefit of 5.1 is while you can make the standard compiler your target, you can probably run on LuaJIT (not dead, sophisticated assembly, and potential for breaking changes) as well.

I’m having 100% success even when doing transitions between screens etc on the latest agents. Wonder if this is due to time and the agents vastly improving lately. Possibly also grant knows manim so well he can beat the time to type a prompt. For the rest of us i’m tempted to make a website for educators to type a prompt to get a video out since it’s been that reliable for me.

It has been my understanding that video games do not patch libraries. Pick a version that is available today and use it forever.

C? Java? Perl? PHP? I have significant amounts of 20+ year old code in production, you just need to steer clear of the desire to use a huge framework/tons of dependencies and a language that breaks compatibility every few years.

Great question. It really depends. 10 years isn’t very long, so most well known languages & platforms will be fine. But 20 or 30 or 50 or 100 years, that gets more interesting.

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.

I wonder if that’s also because Grant uses his own branch of manim from which the mainstream public one (manim-ce) has diverged quite a bit.

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”.

If you're passionate about it, then go for it! Though be aware that several others have tried similar things:

- 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

The fork is better for normal people. There is no drama or controversy here.

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.

Related:

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)

Yup. "In the last year or so" is the cutoff: https://news.ycombinator.com/newsfaq.html#reposts

I'd love to see this for English grammar

Yes. I have not interacted with him directly, but I have observed him making the same statements in recorded interviews. It really is the case that for most "not Grant" people, the community version is probably where you should start (and possibly remain).

I'm searching badly for a similar tool (code-based animation renderer) but not focused on math, but rather on general-purpose infographic/charts/motion graphics. The traditional approach for that, of course, is to use After Effects/Davinci Fusion/Blender/Cavalry/etc., but since I've first tried PovRay back in the early 2000s and then tools like Manim, I can't stop thinking about a code/text-based motion graphics tool. It would shine in use with LLMs, of course, and while I see some new "ChatGPT-wrappers for Motion Graphics" pop up now and then, I don't need yet another chat to send me cloud-rendered videos in the Electron app. I want a templated code/language for the graphics and style I'll settle on to use with different data and be able to render it locally (or event automate) as much as I want.

Yeah I've mostly had Grant's experience. Some frameworks have hooked in VLMs to "review" the manim animations and drawings but it doesn't help much.

I have used Tiger AI Lab's harness and have several issues/tickets I opened there. It's not a very serious project and doesn't work... basically at all. It's a good idea especially with VLM review but the results are not good whatsoever.

When I tried to use it about 4 years ago it definitely suffered from kwargs-itus. Everything is kwargs. No type annotations (it wasn't even possible to write type annotations for kwargs at the time). Definitely made it unnecessarily difficult to use.

I did make an attempt at fixing that but it got zero traction. I wonder if they've made any progress.

If you're ok with C++ you can try https://github.com/2swap/swaptube

That's cool, thanks for sharing! In my perfect finding I would see some primitives for infographic/charts/etc. This library is great for pendulums :) (currently watching your video on non-chaotic double pendulums and it's awesome!)

Thanks, but it's not my channel! I just stumbled upon it and made a mental note to remember the repo.