What is ManimGX? Fast 3D animation for AI agents with Manim's API

What is ManimGX?

ManimGX calls itself "the 3D animation engine for agents." Sina Atalay introduced it on X on October 10, 2026 with four selling points: speed, a Rust + wgpu core, compatibility with Manim's Python API, and "one pip install, no system dependencies."

The idea is simple. Manim is the Python library behind the precise math animations in 3Blue1Brown's videos, and a lot of Manim code already exists. ManimGX keeps that API, so scenes look familiar to people and to models, and swaps the renderer underneath for one written in Rust that draws each frame on the GPU. The code is on GitHub and the docs live at manimgx.academa.ai.

It handles 2D and 3D in the same scene: surfaces, meshes and moving cameras next to text, equations and plots. The examples in the repo include a Fourier series drawing the outline of π, the Lorenz attractor, the Hopf fibration and three spinning tops tracing curves on glass spheres.

How does ManimGX do 3D animation for AI agents?

Most of the agent work is in the setup, not the engine. The project publishes an llms.txt file written as step-by-step instructions for an AI agent: how to install, a starter scene, how to check it, how to render, and an API cheat sheet, followed by links to every docs page as Markdown.

So you don't have to install anything yourself. The README suggests pasting this into Claude Code, Codex or Cursor:

Follow https://manimgx.academa.ai/llms.txt.
Install ManimGX, make a 3D animation of the solar system, and open it.

Two features give the agent feedback before it spends time on a full render. The whole API is statically typed, so a type checker like ty catches a wrong name or a misspelled keyword before anything runs. And manimgx inspect runs a scene without making video, prints its timeline and writes a storyboard image with 2D layout problems, like text overlapping other text, outlined and numbered. For 3D scenes you still get storyboards and timelines, but layout checks are skipped.

If you already hand work to agents, this slots in as one more task. We covered how Claude Code Projects runs parallel coding threads and how Codex suggests your next message.

How do you install ManimGX?

With Python 3.13 or newer, on macOS, Linux or Windows:

pip install manimgx

Fonts, typesetting and video encoding come with it. The agent instructions are stricter about versions (Python 3.13 or 3.14) and recommend uv tool install --python 3.14 manimgx. They also tell the agent not to install the manim package, ffmpeg or LaTeX, because ManimGX doesn't need them.

It draws with Metal on macOS, Direct3D 12 on Windows and Vulkan on Linux. On a machine with no GPU, such as a server or a container, the Linux wheels bundle Mesa's lavapipe and render on the CPU. There's also a browser build: npm install manimgx runs Python scenes through Pyodide in a Web Worker and renders with WebGPU.

A minimal 3D scene from the README, saved as scene.py:

import manimgx as m

class Hello3D(m.ThreeDScene):
    def construct(self) -> None:
        self.set_camera_orientation(phi=65 * m.DEGREES, theta=-45 * m.DEGREES)
        self.begin_ambient_camera_rotation(rate=0.5)
        cube = m.Cube(side_length=3, fill_opacity=0.3, stroke_width=2)
        self.play(m.Create(cube), run_time=2)
        self.wait(4)

Run manimgx render scene.py and you get Hello3D.mp4, a 1080p60 video of a cube being drawn while the camera circles it.

Is ManimGX really 90x faster than ManimCE?

That's the team's number, and they show their work. According to the README, five scenes totaling 36.2 seconds of 1080p60 video rendered in 3.08 seconds on an Apple M4 Pro, measured from launch to finished MP4. On that setup they report ManimGX at 90.6x faster than ManimCE, 11.5x faster than ManimGL and 18.7x faster than Blender Workbench, with every engine on its fastest encoding preset.

The scenes, settings and runs are published in the repo's benchmarks folder. We haven't reproduced the results. Treat them as a claim for one machine and one set of scenes, and expect your numbers to differ.

Manim vs ManimGL vs ManimGX: which is which?

The names get confusing, so here's the history from the official Manim Community FAQ. Grant Sanderson created Manim as a personal project for his YouTube channel, 3Blue1Brown. In mid-2020 a group of developers forked it into the community edition. Today:

• Manim, or ManimCE: the community-maintained version. Its PyPI package is manim.
• ManimGL: the version Grant Sanderson develops in 3b1b/manim. It has more experimental features, and the FAQ notes breaking changes between versions aren't documented. Its package is manimgl.
• ManimGX: a separate engine from Academa that targets ManimCE's API, not ManimGL's.

Per the docs' Coming from Manim CE page, most ManimCE code runs after you replace manim with manimgx. But ManimGX decides how that code behaves, and some things differ. Quality flags like -ql become -r and --fps. LaTeX in Tex and MathTex is converted to Typst, and LaTeX packages and \def don't convert. It also folds in what plugins used to do: self.say() syncs animations to spoken words, and manimgx present shows a scene's sections as slides.

Is ManimGX a good Manim alternative?

It depends on what you're after. If an agent is writing the code, the typed API, the inspect command and the llms.txt instructions are built for exactly that. The same goes for anyone who has fought LaTeX or ffmpeg installs. If you rely on custom LaTeX packages, need an older Python, or want the exact behavior of an existing ManimCE project, read the differences page first.

Anthropic is taking a similar code-first route for business videos. Claude Motion, launched in beta on October 8, writes each animation as code instead of using a video generation model, then exports an MP4.

It's also very new. The GitHub repository was created on October 5, 2026, a few days before the launch post. On licensing, ManimGX's own code is MIT, but the README notes that native wheels include x264 and are GPL-3.0-or-later as a whole. That's worth knowing if you plan to ship it inside a product.

Key facts

• Launched on X by Sina Atalay on October 10, 2026, as an open-source 3D animation engine for agents, from Academa.
• Core: Rust + wgpu. Scenes use Manim Community Edition's Python API.
• Install: pip install manimgx with Python 3.13+. No LaTeX or ffmpeg install needed.
• Speed: the team reports 90.6x faster than ManimCE and 11.5x faster than ManimGL on five scenes at 1080p60 on an Apple M4 Pro. Not independently verified.
• Agent setup: instructions at manimgx.academa.ai/llms.txt. The manimgx inspect command writes storyboards and checks 2D layouts.
• Also runs in the browser via npm install manimgx (Pyodide + WebGPU).
• License: MIT for ManimGX's code. Native wheels include x264 and are GPL-3.0-or-later as a whole.

FAQ

Sources

• @sinaatalay launch post, Oct 10, 2026
• ManimGX repository and README on GitHub
• ManimGX documentation
• ManimGX llms.txt (agent instructions)
• ManimGX docs: Coming from Manim CE
• ManimGX benchmarks
• Manim Community docs: Why are there different versions of Manim?
• Manim Community Edition on GitHub
• 3b1b/manim (ManimGL) on GitHub

Keep reading

• What is Claude Code Projects? How Anthropic's parallel coding threads work
• What are Microsoft Execution Containers (MXC)? Windows' new sandbox for AI agents
• Codex composer predictions: how OpenAI's next-message suggestions work
• Claude Dashboards and Motion: how Anthropic's live dashboards and animations work
• All posts on the Era of Minds blog