Manim Explained: the Python Animation Engine Behind 3Blue1Brown

You've probably seen those hypnotic math videos on YouTube where circles morph into sine waves, and equations write themselves on screen. That's manim at work — a Python animation engine built by Grant Sanderson, the creator of the channel 3Blue1Brown, to visualize mathematical concepts in a way no textbook ever could.

The appeal is obvious: math feels less intimidating when you can see it. The challenge is remembering what you've learned after the video ends. That's where tools like Nibble can help, combining bite-sized math lessons with quizzes designed to reinforce understanding through active recall.

As beautiful as those animations look, building them yourself is a different story. We'll get into that. First, here is a quick summary of what this guide covers:

• Manim is a free, open-source Python library originally built by Grant Sanderson for his 3Blue1Brown YouTube channel.
• There are two main versions: ManimCE (community edition, stable and well-documented) and ManimGL (the original 3b1b/manim fork, experimental).
• Core building blocks include Mobjects, Scenes, and the construct() method — the three things you need to understand before writing a single line.
• Setup involves installing dependencies like FFmpeg and LaTeX, where most beginners get stuck.
• If you want the visual, intuitive feel of manim without the terminal headaches, Nibble's interactive lessons get you there faster.

🎓 Curious about math and science but don't have hours to spare? Nibble teaches complex ideas in under 10 minutes — download it free

Manim is an open-source Python library for generating precise mathematical animations programmatically. Grant Sanderson built it to create the visuals for 3Blue1Brown — the YouTube channel known for making topics like linear algebra, calculus, and topology feel almost intuitive. The name comes from Mathematical Animation.

What makes it different from standard animation software is that everything is scripted. You write Python code describing shapes, positions, and transformations, and Manim renders the frames into a video. It's distributed under the MIT license, so it's free to use, modify, and distribute for personal and commercial projects alike.

The channel 3Blue1Brown now has over 5 million subscribers, and a huge part of its appeal is those animations. That's what puts Manim on the radar for students, educators, and developers who want to explain complex systems visually.

One of the first things that trips people up is that there are two separate repositories, and they are not the same.

The community edition, also called ManimCE, is maintained by an open-source developer community. It is the one you install with pip install manim. It is stable, has solid documentation, and supports a growing library of plugins. If you are just starting out, this is your version.

ManimGL, also known as 3b1b/manim, is Grant Sanderson's personal fork. It uses hardware-accelerated OpenGL rendering and GLSL shaders, making it faster and more flexible. However, it is experimental, less documented, and not built for outside contributors. It is what Grant uses for his own videos, and it drifts in unexpected directions.

⚡ Skip the version confusion. Nibble delivers expert-crafted visual lessons across math, science, and more — no setup required. Try it free

Before you write any code, you need to understand three concepts. Once these clicks, the rest of Manim starts to make sense.

Short for Mathematical Objects, Mobjects are everything you see on screen. A Circle, a Square, a NumberPlane grid, a MathTex formula — these are all Mobjects. They have positions, colors, sizes, and transformations. You can group them with VGroup to treat multiple objects as one unit.

Animations are the actions applied to Mobjects. The common ones you'll use constantly: FadeIn, FadeOut, Transform, and Rotate. You can also use Updaters — functions that run on every frame to create continuous motion, like a dot tracing a curve in real time.

Every scene you create inherits from the Scene class and defines its logic inside the construct() method. This is the main execution block where you place your Mobjects, call your animations, and control timing. If manim were a recipe, the construct() method is where you actually cook.

🧠 Love how visual learning clicks? Nibble uses the same principle — short, visual, interactive lessons that make ideas stick. Start learning free

This is where the romance ends, and reality begins. Installing Manim isn't a one-line operation.

You need Python 3.8 or above, then install Manim's external dependencies before the library works properly:

• FFmpeg — required to render video output. Most systems don't have it pre-installed.
• LaTeX — required if you want to render mathematical text with MathTex. On Windows, that means MiKTeX. On Mac, MacTeX. Both are large downloads.
• Cairo — handled automatically via pip on most systems, but worth knowing it's there.

For installation, you have a few options. The most reliable for beginners is Conda because it handles dependencies automatically. Docker is a solid choice if you want a fully isolated environment that does not affect your machine's global Python setup. If you want to experiment without installing anything locally, Jupyter Notebooks via Google Colab can run manim in the cloud, though rendering speeds are limited.

⏱ No time for terminal errors? Nibble's bite-sized lessons on math, logic, and science are ready the second you open the app. Download Nibble free

The secret aesthetics of complex equations

Dive into hundreds of stories tracking math, logic, and creative design.

Continue the discovery

Once the environment is ready, here's what a minimal Manim scene looks like. This example creates a square, transforms it into a circle, and fades out — the Manim equivalent of 'Hello, world.'

from manim import *

class SquareToCircle(Scene):

   def construct(self):

       square = Square()

       circle = Circle()

       self.play(FadeIn(square))

       self.play(Transform(square, circle))

       self.play(FadeOut(circle))

You initialize a Square and a Circle as Mobjects. Inside the construct() method, you call self.play() with each animation: FadeIn brings the square onto the screen, Transform morphs it into the circle, and FadeOut removes it. The NumberPlane can be added as a background grid to give your shapes spatial context.

That is the skeleton of every manim scene. From here, you build variations on this structure by adding MathTex formulas, animating functions on a plane, stacking VGroups, and triggering updaters for real-time motion.

🔬 Prefer learning concepts over configuring environments? Nibble turns complex ideas into clear, satisfying lessons — try it free

Here's where most people quietly close the terminal and never come back. And it's not because they're not smart enough.

Manim was built by one person for one person's workflow. Grant Sanderson's videos look effortless because he has spent years building his own libraries on top of the tool. For everyone else, the process looks more like this:

• You spend 45 minutes getting FFmpeg and LaTeX installed correctly.
• Your first scene throws a dependency error that has nothing to do with your code.
• You fix it, render a 4-second animation, and realize you spent three hours on something you don't fully understand yet.
• The documentation assumes you're already comfortable with Python class inheritance and OpenGL rendering pipelines.

The Manim community is active and helpful. The GitHub repo (3b1b/manim) has thousands of stars, and the community forums are full of workarounds. But the point stands: Manim is a tool for creating visual explanations, not for experiencing them. If your goal is to understand mathematical animations, not build them, then you spend most of your time on the building, not the understanding.

That's the real friction. You wanted an 'aha!' moment. You got a broken LaTeX path instead.

💡 Want the 'aha!' moment without the debugging spiral? Nibble gives you visual, expert-crafted lessons that just work. Start your first lesson

Don't let a busy schedule waste your curiosity

Reignite it with Nibble

Get started

Manim promises a beautiful, intuitive understanding of complex ideas. The animations are just the vehicle. If that's the outcome you're after, there's a way to get there without burning the midnight oil on dependency errors.

Nibble is a knowledge app built for exactly this: expert-crafted lessons on subjects like math, science, philosophy, and history delivered in short, visual, interactive formats that fit into your actual day. No installation. No Python environment. No LaTeX.

Here's what a Nibble session looks like for someone who fell in love with the 3Blue1Brown style of learning:

• Short text lessons that explain one concept clearly, then test you on it right away.
• Videos designed like educational explainers — visual, focused, and under 10 minutes.
• Audio episodes for commutes and coffee breaks.
• Educational games that make abstract topics stick through active recall.
• AI-powered chats with historical figures — ask Euler about his identity or Pythagoras about geometry.

Nibble covers 20-plus topics, has 9M-plus downloads, and ranks in the Top 15 Free Education Apps on the App Store in the US, Canada, and Australia. It's been App of the Day in 46-plus countries.

If you're curious about what else it covers, take a look at how Nibble compares to Brilliant, or see how it stacks up against other MasterClass alternatives. You can also compare it directly with Imprint or check how it holds up against Finelo if you've been shopping around.

​🚀 Get the visual math breakthrough — minus the broken dependencies. Download Nibble free and start your first lesson today