Manim Compared: 3b1b Original vs Community Edition, How to Choose Between 87k+39k Star Math Animation Engines

Smars
Opensource , Animation , Python
23 Jun, 2026

The Problem

You’ve seen 3Blue1Brown’s videos — those buttery smooth math visualizations where Fourier transforms spin on screen, linear algebra matrices warp geometric shapes in real time. You want to make something similar. But PowerPoint can’t do it, After Effects makes you want to quit, and Blender feels like overkill.

The question isn’t “which tool can make animations.” It’s “which tool lets you describe in code exactly what happens at second 3: the curve shifts from blue to red while the camera rotates 45 degrees from top-down to side view.”

Manim was built for exactly this. It’s the engine behind 3Blue1Brown, 87.8k GitHub stars, MIT license, written in Python.

What It Is

Manim — Mathematical Animation Engine — was created by Grant Sanderson (the person behind 3Blue1Brown) as a personal tool for making math visualization videos. But “Manim” now refers to two different projects, which is the first thing every newcomer gets confused by:

	3b1b/manim (Original)	ManimCommunity/manim (Community)
Stars	87.8k	39.1k
Forks	7.3k	2.9k
Watchers	933	52
Commits	6,369	6,264
pip package	`manimgl`	`manim`
Renderer	OpenGL (GPU)	Cairo (CPU), optional OpenGL
Language	Python 96.4%, GLSL 3.6%	Python 98.2%, GLSL 1.6%
Latest version	v1.7.2 (Dec 2024)	v0.20.1 (Feb 2026)
Releases	13	33
Docs	Basic, example-driven	Comprehensive, ReadTheDocs + official site
CI/Testing	None	Full CI + Codecov
Docker	No	Official image
Jupyter	No	%%manim magic
License	MIT	MIT (dual copyright)

In short: 3b1b/manim is what Grant uses. ManimCommunity/manim is what the community uses.

In 2020, the community forked it into Manim Community Edition with a goal of being more stable, better tested, and friendlier for contributions. Grant continues maintaining his own version, but the community edition is where most active development happens.

Why It Stands Out

Code as Animation: Pixel-Level Precision

Manim’s core idea is describing animations in Python code instead of dragging a timeline. Both versions support:

Every object’s position, color, and scale at every frame
Camera movement start/end times, interpolation methods, rotation angles
LaTeX formula highlighting and transformation, symbol by symbol
3D scene camera paths and lighting

This isn’t “make an animation.” It’s “describe a mathematical object’s behavior over time in code.” You’re writing behavior definitions, not scripts.

The Rendering Split: OpenGL vs Cairo

This is the fundamental difference between the two versions:

3b1b/manim uses OpenGL (GPU rendering):

Live preview window — see your animation as you code, no render wait
GPU acceleration — complex scenes render an order of magnitude faster
Custom GLSL shaders — 3.6% of the codebase is GLSL for bespoke effects
Cost: requires OpenGL support, macOS ARM needs extra Cairo install, higher system requirements

ManimCommunity/manim uses Cairo (CPU rendering):

Better cross-platform compatibility — no GPU required
More predictable output — Cairo’s 2D rendering is consistent
Optional OpenGL backend — community edition supports switching, but Cairo is default
Cost: slower rendering, complex scenes may need waiting

Pick 3b1b for 3D and real-time preview. Pick community for 2D math animations and stability.

Battle-Tested by 3Blue1Brown

The 3b1b version’s biggest edge is real-world validation. Every 3Blue1Brown video is built with it, with all source code at 3b1b/videos. That means:

APIs validated by actual production use
Massive library of real-scene code references
The author uses it daily — bugs get fixed

The community edition’s edge is engineering maturity: full CI, Codecov coverage, official Docker image, Jupyter magic command, 33 releases (vs 13 for the original). It’s more of a “proper open-source project” than “someone’s tool that happened to get open-sourced.”

Quick Start

3b1b Original (ManimGL)

# Install (note the package name is manimgl)
pip install manimgl

# Run the examples
manimgl example_scenes.py OpeningManimExample

System dependencies: FFmpeg, OpenGL, LaTeX (optional, for math formulas). On macOS:

brew install ffmpeg mactex
# ARM Mac also needs Cairo
arch -arm64 brew install pkg-config cairo

Community Edition (ManimCE)

# Install (note the package name is manim)
pip install manim

# Run the examples
manim -p -ql example.py SquareToCircle

Community docs are more thorough: docs.manim.community. Docker works out of the box:

docker run -it -v "$PWD":/ manimcommunity/manim manim -p -ql example.py SquareToCircle

Jupyter notebooks support %%manim magic commands.

Code Comparison

The two versions have API differences. Same “square to circle” animation:

3b1b version:

from manimlib import *

class SquareToCircle(Scene):
    def construct(self):
        circle = Circle()
        square = Square()
        square.flip(RIGHT)
        square.rotate(-3 * TAU / 8)
        circle.set_fill(PINK, opacity=0.5)

        self.play(ShowCreation(square))
        self.play(Transform(square, circle))
        self.play(FadeOut(square))

Community version:

from manim import *

class SquareToCircle(Scene):
    def construct(self):
        circle = Circle()
        square = Square()
        square.flip(RIGHT)
        square.rotate(-3 * TAU / 8)
        circle.set_fill(PINK, opacity=0.5)

        self.play(Create(square))
        self.play(Transform(square, circle))
        self.play(FadeOut(square))

Note the differences: from manimlib import * vs from manim import *, ShowCreation vs Create. Code is not interchangeable between versions.

The Killer Demo

The 3b1b/videos repo contains source code for every 3Blue1Brown video. Here’s a simplified version of how matrix transformations work in Essence of Linear Algebra:

class MatrixTransformation(Scene):
    def construct(self):
        # Create a coordinate plane
        plane = NumberPlane()
        
        # Create a vector
        vector = Arrow(ORIGIN, [2, 1, 0], color=YELLOW)
        
        # Matrix: a shear transformation
        matrix = [[1, 1], [0, 1]]
        
        # Show plane and vector
        self.play(ShowCreation(plane))
        self.play(ShowCreation(vector))
        
        # Apply the matrix — the entire plane warps
        self.play(plane.animate.apply_matrix(matrix))
        self.play(vector.animate.apply_matrix(matrix))
        self.wait()

What this does: display a coordinate plane and a vector, then a shear transformation applies to both — the viewer sees intuitively that “matrices are transformations of space.”

For more complex scenes, like the rotating vector summation in the Fourier Transform video, the full source code is in the 3b1b/videos repo. Every frame’s mathematical precision, color palette, and camera movement is code-controlled.

Which Version to Choose

Choose 3b1b/manim if:

You’re building 3D scenes — OpenGL rendering pipeline handles 3D better
You want to replicate 3Blue1Brown’s style — this is the original, API matches video source exactly
You need live preview — pop-up window shows animation as you code, no render wait
You want to write custom GLSL shaders — 3.6% of the codebase is GLSL
You’re willing to read source code and sparse docs — community edition has better docs, but the original is more flexible

Choose ManimCommunity/manim if:

You’re a beginner — comprehensive docs, simple install, active community
You need stable production — 33 releases, full CI, Codecov coverage
You need Docker deployment — official image works out of the box
You want Jupyter Notebook support — %%manim magic command
You’re doing 2D math animations — Cairo rendering is sufficient and more compatible
You want to contribute — community edition has a more structured contribution process

Don’t Mix Them

Different pip package names (manimgl vs manim), different import paths (from manimlib import * vs from manim import *), different method names (ShowCreation vs Create). Don’t install both in the same environment — they’ll conflict.

Community Resources

Community site: manim.community
Community docs: docs.manim.community
Original docs: 3b1b.github.io/manim
Chinese docs: docs.manim.org.cn (maintained by manim-kindergarten)
manim_sandbox: extra utility classes and example code
Reddit r/manim and Discord are active

When to Use (and When Not To)

Good fit:

Math/physics teaching videos — this is its core purpose
Animated data visualization — more expressive than static charts
Science media content — YouTube/Bilibili math explainer videos
Academic presentations — animate concepts from papers

Bad fit:

Quick GIF for social media — overkill, use ffmpeg + PIL instead
Commercial ad animations — Manim’s visual style is academic, not commercial
Real-time interactive apps — it’s an offline renderer, not a game engine
Non-math content — the API is designed for mathematical animation, other uses feel awkward

Heads up:

pip package name is manimgl, not manim. Wrong package causes conflicts with community edition
macOS ARM needs Cairo installed separately or you’ll get errors
3b1b version docs are sparser than community edition — read source code and 3b1b/videos examples when stuck
Migrating old code to new versions may have breaking changes — the 3b1b/videos README mentions this

Verdict

Manim isn’t “another animation library.” It’s the purest implementation of the idea that code should describe mathematical objects’ behavior over time. The dual-repo story — 87.8k + 39.1k stars — tells a clear story: math visualization animation is a real need, and each version serves a different audience.

If you want 3Blue1Brown-style 3D animation and don’t mind sparse docs, go with manimgl. If you’re a beginner, doing 2D animations, or value stability and documentation, go with manim (community edition).

Either way, the first step is the same: install it, run an example scene, and feel what code-controlled animation is like.

Repo (original): https://github.com/3b1b/manim Repo (community): https://github.com/ManimCommunity/manim