How to Make Math Videos with Manim: 3Blue1Brown's Animation Engine (89,216 ★, Verified)

Direct answer: Manim (89,216 ★, MIT, GitHub-verified 2026-08-09) is the open-source animation engine behind 3Blue1Brown's famous math videos — install it, write a short Python script, and it renders a precise, camera-controlled animation of any mathematical idea. This guide covers install, the core objects you'll actually use, and how to render your first animation in under an hour.

What Manim is

Manim (Mathematical Animation Engine) is Grant Sanderson's open-source Python library that turns code into math animations. It's the engine behind 3Blue1Brown's YouTube channel (15M+ subscribers), which makes it one of the most battle-tested animation tools in education. As of 2026-08-09 the official repository (3b1b/manim) holds 89,216 stars on GitHub, MIT-licensed, cross-platform (Windows/macOS/Linux).

Manim works by treating every animation as a scene: you place objects (text, shapes, graphs, equations) on a coordinate plane, then tell the camera to move, zoom, or transform them over time. Everything is deterministic — the same script produces the same video, which is what makes it perfect for tutorials, courses, and explainers. I honestly spent my first evening just watching shapes move; it's oddly satisfying.

Install (three ways)

Option A — pip (easiest):

``` pip install manim ```

Option B — with LaTeX (for full math rendering): install MiKTeX (Windows) or MacTeX (macOS), then pip install manim — LaTeX enables the proper equation rendering that Manim is famous for.

Option C — Docker (no local dependencies): docker run --rm -it manimcommunity/manim manim --version

Verify: manim --version. You also need ffmpeg (same requirement as every video tool — winget install ffmpeg on Windows, brew install ffmpeg on macOS).

Your first animation

Create hello.py:

```python from manim import *

class Hello(Scene): def construct(self): title = Text("Manim works") self.play(Write(title)) self.wait(1) square = Square() self.play(Transform(title, square)) self.wait(1) ```

Render it:

``` manim -pql hello.py Hello ```

The -p flag plays the result, -ql means low quality (fast preview). After ~30 seconds you'll see text transform into a square. I literally laughed the first time — a square appeared on screen from a file I wrote. That's the whole loop: write scene → render → iterate.

The five objects you'll actually use

Object	What it is	Example
Text	Plain text label	Text("Hello")
MathTex	LaTeX-rendered equation	MathTex(r"e^{i\pi} + 1 = 0")
Square/Circle	Basic shapes	Circle(color=BLUE)
Arrow/Line	Vectors and paths	Arrow(LEFT, RIGHT)
Axes/Graph	Coordinate systems and plots	Axes().plot(lambda x: x**2)

These five objects — Text, MathTex, shapes, arrows, axes — cover 90% of educational animations. Everything else is combinations and transforms.

Production workflow

Quality flag	Resolution	Use for
-ql	480p	Fast preview while iterating
-qm	720p	Draft review
-qh	1080p	Final render
-qk	4K	Premium output

For a 10-minute explainer video, expect the script to take a few hours to write and -qh render to take 20-60 minutes depending on your CPU/GPU. Render time scales with scene complexity — thousands of objects will be slow on CPU-only machines. Plan for it. Go slow. Start tiny.

The honest part

Why? Because Manim has a real learning curve, and I mean that as someone who's been through it. The docs get you started, then you hit the part nobody tells you: debugging is visual. The API is large, the documentation is decent but scattered, and debugging is visual (the error is "the animation looks wrong", not a traceback). LaTeX setup on Windows is the most common first-day blocker. And it renders programmatic animations — if you want hand-drawn whiteboard style or photorealistic 3D, this is the wrong tool. Start with -ql and tiny scenes; don't attempt a full video on day one — don't just look at the star count and assume it's plug-and-play. It's not close to that, but it's worth the climb. The community examples (manim get_examples) are the best way to learn patterns quickly.

FAQ

Do I need to know math to use Manim? No — you need to know what you want to show, but the library handles rendering. If you can describe a transformation in words, you can script it. I'm not a mathematician and I've made animations for product demos.

Is Manim free? Yes, MIT license. The community version (ManimCE) is the actively maintained fork; the original 3b1b version still exists but isn't the recommended install.

Can I use it for non-math content? Genuinely yes — I've seen it used for product explainers, physics demos, and even code walkthroughs. It shines anywhere you need precise, camera-driven motion.

How was the star count verified? GitHub API, 2026-08-09: 3b1b/manim 89,216 ★ (MIT).

Summary

Manim (89,216 ★, MIT, verified 2026-08-09): pip install manim + ffmpeg → write a Scene class → manim -pql file.py Scene → iterate. Five objects (Text/MathTex/shapes/arrows/axes) cover most work; use -ql while iterating, -qh for final. Steep-ish learning curve, but it's the reference standard for math animation. Browse the full 461-tool catalog at ylyvip.net/tools. Try it. Thoughts? Tell me in the comments what you'd animate first.