3b1b/manim: Create precise mathematical animations with Python
A Python animation engine for math-video creators, with more precise code control than manual editing.
GitHub 3b1b/manim Updated 2026-09-04 Branch master Stars 93.6K Forks 7.7K
Python 3.10+ Math videos ManimGL OpenGL FFmpeg LaTeX

🧭 Decision Guide

Why trending now: Cannot be determined from the materials

Try it if you

  • You need to create explanatory math videos with Python and can provide FFmpeg, OpenGL, and Python 3.10+.
    The README describes Manim as a programmatic animation engine for explanatory math videos, and the installation section lists these system requirements.
  • You want to start by running the OpeningManimExample ManimGL scene.
    The README's Using manim section provides the command manimgl example_scenes.py OpeningManimExample.
  • You need -w, -o, -s, or -f to control output files, final frames, and the playback window.
    The README's Using manim section lists these CLI options.
  • You need an MIT License project and are willing to use the ManimGL version in 3b1b/manim.
    The project metadata states MIT License, and the README installation section identifies this repository as 3b1b's ManimGL.

Skip it if you

  • You have already decided to use Manim Community instead of the ManimGL in 3b1b/manim.
    The README installation warning says to choose a version first and not mix the two sets of installation instructions.
  • Your environment cannot provide Python 3.10+, FFmpeg, or OpenGL.
    The README installation section requires Python 3.10 or higher, FFmpeg, and OpenGL.
  • You require stable documentation, continuous integration, or a more active contribution ecosystem.
    The README says Community Edition has a more active contribution ecosystem, testing, and continuous integration; this README says its documentation is in progress.
  • You plan to reuse old 3blue1brown video code without handling compatibility.
    The README's Using manim section says code from older videos may not be compatible with the most recent Manim version.

Requirements

  • Python 3.10 or higher
  • FFmpeg
  • OpenGL
  • LaTeX (optional if LaTeX is needed)
  • Linux also requires Pango and its development headers
  • Use the package name manimgl for pip installation, not manim or manimlib
  • The Linux Ubuntu/Debian example requires libpango1.0-dev; the ARM Mac example requires Cairo

First step (verbatim from README)

pip install manimgl

Watch out

  • Do not use manim or manimlib as the pip package name for this repository.
    The Installation section explicitly states that the package name is manimgl.
  • Do not mix ManimGL and Manim Community installation instructions.
    The WARNING in the Installation section explicitly says that mixing them causes problems.
  • Linux requires Pango development headers, while LaTeX is only needed for LaTeX rendering.
    The Linux installation section requires libpango1.0-dev and marks LaTeX as optional.
  • Full MacTeX is about 6GB; BasicTeX can be used instead with packages added gradually.
    The Mac OSX section gives the approximately 6GB figure and the BasicTeX alternative.
  • Older 3blue1brown video code may not work with the current Manim version.
    The Using manim section directly warns that code from older videos may be incompatible.

Alternatives

  • Manim Community：When you need the greater stability, testing, faster community response, and friendlier onboarding described by the README.
    README body and Installation section

Not stated in the README

  • The latest update date is unknown; the README and project data do not provide a verifiable maintenance date.
  • The data reports 0 contributors, 0 releases, and 0 recent commits, but the materials do not explain whether these statistics are missing or accurate.
  • The README does not provide rendering performance, output resolution, GPU requirements, or large-scene runtime data.
  • The README does not state the current ManimGL version or provide a compatibility matrix for Python 3.10+ versions.
  • The README does not provide test coverage or a specific continuous-integration status.
  • The README does not describe functional differences among Windows, Linux, and Mac OSX.

💡 Deep Analysis

6
Yes I am creating 3Blue1Brown-style math videos in Python with LaTeX formulas, geometric transformations, and continuous animations, and I want to re-render them reproducibly through code. Is ManimGL suitable for my workflow?
For: A creator of 3Blue1Brown-style explanatory math videos using Python, LaTeX, OpenGL, and FFmpeg

Yes, because ManimGL is specifically designed for precise, programmatic mathematical animation rather than ordinary video editing.

  • The README describes it as an “engine for precise programmatic animations” designed for explanatory math videos.
  • Scenes are expressed as code, with reusable objects, animation types, and ordered playback; the example scenes demonstrate the library’s syntax and object model.
  • LaTeX can render formulas, FFmpeg writes video output, and OpenGL provides a preview window.
  • The main compatibility constraint is that this is ManimGL, not Manim Community Edition. Code from older 3Blue1Brown videos may also be incompatible with the current version.
  • README opening: “Manim is an engine for precise programmatic animations, designed for creating explanatory math videos.”
  • README Using manim: example scenes show the library’s “syntax, animation types and object types”
  • README Installation: system requirements include FFmpeg and OpenGL; LaTeX is optional for LaTeX rendering
  • README opening: this repository is ManimGL, and older video code may be incompatible
pip install manimgl
Not stated in the README：The README does not specify rendering performance for a particular mathematical object, animation composition, or complex scene on the target machine.；It does not define the compatibility boundary for any specific 3Blue1Brown video codebase.
No I prioritize stability, test coverage, and responsiveness to community contributions over reproducing 3Blue1Brown’s personal video workflow. Should I choose this repository?
For: A Python developer comparing 3b1b/ManimGL with Manim Community Edition and prioritizing stability, testing, and responsiveness to community contributions

No, because the README explicitly associates stability, testing, and responsiveness to community contributions with the Community Edition, while this repository originated as a personal video-production project.

  • The README says this repository began as a personal project by the author of 3Blue1Brown for animating those videos.
  • It describes the 2020 Community Edition fork as aiming to be “more stable, better tested, quicker to respond to community contributions, and all around friendlier to get started with.”
  • The installation warning tells users to choose a version first and warns that mixing manimgl, manim, and manimlib installation instructions causes problems.
  • Therefore, if stability and community-maintenance characteristics are the primary constraints, the README points toward Community Edition rather than this repository.
  • README opening: “This repository began as a personal project by the author of 3Blue1Brown”
  • README opening: Community Edition aims to be “more stable, better tested, quicker to respond to community contributions”
  • README Installation Warning: “These instructions are for ManimGL only” and warns against mixing installation instructions
Not stated in the README：The README provides no current version, test-coverage, or maintenance-activity metrics for ManimGL versus Community Edition.；It does not document an API-by-API compatibility comparison for the target scenes.
It depends I create math animations with LaTeX formulas on Ubuntu/Debian using Python 3.10+, but the machine does not yet have FFmpeg, Pango development packages, or LaTeX. Can I install ManimGL directly?
For: An educational video creator on Ubuntu/Debian running Python 3.10+, requiring Pango development headers and LaTeX formula rendering

It depends: the Python package can be installed, but a complete formula-rendering workflow on Linux cannot rely on pip alone.

  • The README requires Python 3.10 or higher and lists FFmpeg and OpenGL as system requirements.
  • Linux additionally requires Pango and its development headers; the Ubuntu/Debian instructions explicitly install ffmpeg, python3-pip, and libpango1.0-dev.
  • LaTeX is optional at the project level, but your formula requirement makes it necessary. The README provides a lightweight setup using texlive-science, texlive-fonts-extra, and texlive-latex-extra.
  • The README recommends a virtual environment to avoid conflicts with system packages. Therefore, installation is appropriate only after these system dependencies are available.
  • README Installation: “Manim runs on Python 3.10 or higher.”
  • README Linux (Ubuntu/Debian): “sudo apt install ffmpeg” and “sudo apt install libpango1.0-dev”
  • README Linux (Ubuntu/Debian): LaTeX installation commands
  • README Linux (Ubuntu/Debian): “It is recommended to use a virtual environment to avoid conflicts with system packages.”
sudo apt update
Not stated in the README：The README does not state whether the target Ubuntu/Debian release exactly matches the listed Pango and LaTeX packages.；It does not enumerate every possible LaTeX package; the formulas used may require additional packages.
Yes I use conda to create a Python 3.10 environment and want centralized control of video output directories, image and sound asset paths, and default video quality. Does ManimGL support this workflow?
For: A math-content producer using Python and conda who needs centralized control over formulas, asset paths, sound paths, and video quality

Yes, because the README documents both a conda-based Python environment and a custom_config.yml configuration mechanism covering the workflow you described.

  • The Anaconda section explicitly uses conda create -n manim python=3.10, followed by conda activate manim and pip install -e ..
  • custom_config.yml can specify video output locations, search paths for image and sound files, and defaults for style and video quality.
  • This separates scene scripts from environment configuration, and the README allows another file with the same name in the directory from which Manim is run.
  • LaTeX is still required for formulas and FFmpeg for video output; conda does not replace those system components.
  • README Anaconda Install: `conda create -n manim python=3.10`, `conda activate manim`, and `pip install -e .`
  • README Using manim: `custom_config.yml` can configure video output, image and sound paths, default style, and video quality
  • README Using manim: another `custom_config.yml` may be placed in the directory where Manim is run
  • README Installation: FFmpeg is a system requirement and LaTeX is optional for formula rendering
conda create -n manim python=3.10
Not stated in the README：The README does not explain precedence when multiple projects or scenes use different `custom_config.yml` files.；It does not list every video-quality field or its default value.
Yes I am on an ARM-based Mac, managing FFmpeg and LaTeX through Homebrew, and plan to use ManimGL with Python 3.10+. Do I need to handle any additional graphics dependencies?
For: A Python developer on an ARM-based Mac using Homebrew and wanting to render mathematical animations with LaTeX

Yes, but an ARM-based Mac requires the additional Cairo step documented by the README; the generic Python installation alone is not enough.

  • The Mac instructions first install ffmpeg mactex with Homebrew. BasicTeX is offered as a lighter alternative to the approximately 6GB MacTeX bundle.
  • For an ARM-based processor, the README explicitly requires arch -arm64 brew install pkg-config cairo.
  • The source workflow uses an editable install and then validates the setup with manimgl example_scenes.py OpeningManimExample.
  • If the final manimgl command is unavailable, the README says to check whether the directory containing the pip-installed executable is on PATH.
  • README Mac OSX: `brew install ffmpeg mactex`
  • README Mac OSX: “If you are using an ARM-based processor, install Cairo.”
  • README Mac OSX: `arch -arm64 brew install pkg-config cairo`
  • README Mac OSX: `manimgl example_scenes.py OpeningManimExample` and the PATH note
brew install ffmpeg mactex
Not stated in the README：The README does not specify the exact macOS version, Homebrew architecture state, or whether additional OpenGL configuration is needed after Cairo installation.；It does not provide a complete list of packages required by every formula when using BasicTeX.
It depends I want to run ManimGL with Python in a headless CI/server environment and produce video through FFmpeg. Is the README enough to show that this deployment path will work directly?
For: An engineer planning to render math animations in headless CI or on a server while depending on OpenGL, FFmpeg, and optionally LaTeX

It depends: the README supports command-line rendering, but it does not confirm the OpenGL setup required in a headless environment, so direct deployment cannot be established from the README alone.

  • OpenGL and FFmpeg are listed as system requirements, indicating that rendering and video encoding depend on both graphics and media components.
  • The -w and -o flags write a scene to a file, while -s jumps to the final frame and -so saves that frame as an image; these are useful for non-interactive command flows.
  • However, the standard example “should pop up a window playing a simple scene,” which reflects a preview workflow involving a display.
  • The README gives no instructions for headless mode, virtual displays, GPU drivers, or CI images. Whether deployment works therefore depends on undocumented graphics-environment details.
  • README Installation: FFmpeg and OpenGL are system requirements; LaTeX is optional
  • README Using manim: the `-w`, `-o`, `-s`, and `-so` command-line flags
  • README Using manim: “This should pop up a window playing a simple scene.”
manimgl example_scenes.py OpeningManimExample
Not stated in the README：The README does not specify virtual-display, OpenGL-backend, GPU-driver, or software-rendering settings for display-less environments.；It does not describe resource requirements or failure diagnostics for full video rendering in CI.

✨ Highlights

  • ManimGL supports precise mathematical animations generated from code
  • The README provides OpeningManimExample for an immediate run
  • The CLI includes rendering controls such as -w, -o, -s, and -f
  • The project uses the MIT License and has 93,008 GitHub stars

🔧 Engineering

  • Run Python scenes with manimgl to generate videos or final-frame images
  • Use custom_config.yml to configure output paths, asset directories, and video quality
  • Use -n to skip animations, -f for fullscreen playback, and inspect example scenes

⚠️ Risks

  • The README warns that ManimGL and Community Edition installation instructions must not be mixed
  • The install package is named manimgl, not manim or manimlib
  • Documentation is still in progress, and older 3blue1brown code may be incompatible
  • Running requires FFmpeg, OpenGL, and Python 3.10 or higher

👥 For who?

  • Python developers or educational creators who need explanatory math videos
  • Animation developers familiar with FFmpeg, OpenGL, and LaTeX environments
  • Users who want to reuse 3blue1brown video code or example scenes