# ManimGX: Python math animation with a Rust and wgpu engine

> ManimGX targets Python users and coding agents that need mathematical and 3D animations through a Manim CE compatible API. Its Rust and wgpu rendering core supports local and browser workflows, but the project has only two releases and the README does not document a direct scene-rendering command.

**academa-labs/manimgx** — The animation engine for agents: blazingly fast math and 3D videos with Manim's Python API, on a Rust GPU core.

- Repository: https://github.com/academa-labs/manimgx
- Website: https://manimgx.academa.ai
- Stars: 2,599 · Forks: 185
- Language: Python
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/academa-labs-manimgx

## Why ManimGX targets agent-generated mathematical video

ManimGX addresses a specific production problem: creating math and 3D animations through Python without retaining the implementation architecture of Manim CE. Its intended users include Python programmers, educators who build explanatory animations, and agents asked to produce a finished visual artifact rather than a generic Python script. The project presents Manim CE's API as its interface while placing a Rust engine and wgpu underneath it. That combination is relevant when an agent needs a compact API surface, local rendering, and browser presentation in one workflow.

The examples establish the intended subject matter. The `examples/` directory contains `derivative.py`, `linear_maps.py`, `complex_maps.py`, `lorenz_attractor.py`, `hopf_fibration.py`, and `catenoid_helicoid.py`. The README also links examples for completing the square, drawing a Fourier approximation of π, transforming a plane with a matrix, visualizing a derivative along a curve, deforming grids with complex functions, and animating linked circles in three dimensions. These are specialized visualization workloads, not a general video editor in disguise.

ManimGX also presents an agent-oriented installation path. Instead of requiring the user to assemble a native rendering environment manually, the README suggests giving Claude Code, Codex, or Cursor a short instruction that points to `https://manimgx.academa.ai/llms.txt`. That makes it plausible for an agent to locate the installation and workflow documentation, but it also shifts part of the setup burden into a separately hosted instructions file. The repository includes a `skills/` directory and a browser package, although the README does not explain their behavior in detail.

## ManimGX rendering architecture and compatibility boundary

The repository layout shows two principal layers. Python supplies the animation API, while Rust and wgpu form the GPU-oriented rendering core. `pyproject.toml` identifies the Python package as `src/manimgx` and points to Rust crates under `rust/`. It also states that the distribution includes fonts, typesetting, and video encoding. A published wheel therefore carries more than a pure-Python animation module.

The API compatibility claim needs careful interpretation. The README says ManimGX is compatible with Manim CE's API, and the package description says it uses "Manim's Python API." That supports using familiar Manim concepts, but it does not prove that every Manim CE class, plugin, configuration key, or rendering behavior is reproduced. The README contains no compatibility matrix or unsupported-feature list. Ported Manim CE modules are mentioned in the third-party licensing statement, which confirms that some code is carried into the package, but it does not establish complete API parity.

The repository also contains a `browser/` directory, and the project README says ManimGX can run in the browser. It does not state how browser rendering differs from local rendering, whether the browser engine has the same feature set as the native extension, or which Python runtime executes in each case. The `justfile` includes a task for checking the browser engine without native-extension features, but the command itself is truncated. Browser availability is documented, while feature parity remains an open adoption question.

## Benchmark claims reflect project-specific scenes, not general proof

The README publishes a specific benchmark for five scenes at 1080p60 on an Apple M4 Pro. It reports 3.08 seconds to render 36.2 seconds of video, compared with 278.83 seconds for Manim CE, 35.28 seconds for ManimGL, 57.61 seconds for Blender Workbench, and 601.40 seconds for Blender EEVEE. Those figures correspond to the README's stated multipliers of 90.6 times, 11.5 times, and 18.7 times for the first three comparisons. The README says all engines used the fastest available encoding preset and links to `benchmarks/` for the scenes, settings, and runs.

These numbers describe one reported test, not a guarantee for every animation. The hardware, five-scene workload, 1080p60 target, encoding settings, and implementation choices are all relevant. A different resolution, codec, machine, scene complexity, or quality target could change the relationship. The README also includes intermediate images for a linked-rings scene at 2.5 seconds, but it specifies no numerical image-quality threshold and does not explain how visual fidelity was scored.

For an engineer, the useful response is not to repeat the multipliers as universal performance claims. The `benchmarks/` directory provides a place to inspect the exact scene definitions and settings, after which those inputs can be compared with the animation that needs to be produced. That verification is more concrete than relying on a single completion time, although the README does not report an independent reproduction.

## Installing ManimGX and creating a first agent-driven animation

The README gives one direct installation path for macOS, Linux, and Windows. It requires Python 3.13 or newer and installs the published `manimgx` package from PyPI. This command installs the project only. It does not create or render an animation by itself.

```sh
pip install manimgx
```

After it completes, the package should be available to the Python environment used by the renderer. The README says fonts, typesetting, and video encoding are included, so users should not assume that this first command needs a separate font or encoder package.

For a first real use, the README provides an agent prompt rather than a direct Python scene. Paste the following text into Claude Code, Codex, or Cursor. The project states that the agent should follow `llms.txt`, install ManimGX, create a 3D solar-system animation, and open it.

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

The expected visible result is a browser presentation containing the requested solar-system animation. The README does not give a direct `python scene.py` command, scene template, renderer flag, or output filename. The linked Quickstart is therefore part of completing the first use, especially for users not using an agent. Users should not infer a command-line interface from the example filenames in `examples/`.

## Repository examples expose both the API target and documentation gaps

The example inventory identifies the visualization areas the project currently intends to support. File names include `bifurcation_mandelbrot.py`, `cherenkov_cone.py`, `circle_area.py`, `clifford_torus.py`, `colliding_blocks.py`, `dla_coral.py`, `euler_identity.py`, `galton_board.py`, `harmonic_drive.py`, `hilbert_curve.py`, `kuramoto_fireflies.py`, `lagrange_points.py`, `life_spacetime.py`, `lozenge_cubes.py`, and `menger_slice.py`. Several files refer to fractal geometry, physics, mathematical identities, spatial systems, and procedural geometry.

That breadth is useful when judging the engine's intended scope. A deterministic geometric animation and a dynamically connected 3D scene can place different demands on geometry, text, lighting, encoding, and camera handling. The presence of many examples does not prove equal maturity across those areas, but it gives adopters concrete files to inspect before deciding whether the project covers their subject matter.

The README does not show the execution order or required scene classes from `examples/README.md`. It also ends after linking to the Quickstart, without showing a direct render invocation. A first-use tutorial therefore cannot safely provide a scene command. This is a documentation limitation rather than a known rendering failure, but it affects reproducibility for users who prefer direct Python commands over an agent or the hosted Quickstart.

## ManimGX versus Manim CE, ManimGL, and Blender workflows

The clearest architectural comparison is with Manim CE. ManimGX explicitly targets Manim CE's Python API while replacing the implementation layer with Rust and wgpu. That can reduce migration friction for code already written around Manim CE, subject to compatibility gaps. ManimGX also packages fonts, typesetting, and encoding and presents a browser workflow. The README does not list those as separate installation steps.

The README compares rendered results and timing with ManimGL, Manim CE, Blender Workbench, and Blender EEVEE. It does not explain the internal rendering architectures of those alternatives, so a deeper technical comparison would go beyond the README. What can be confirmed is that ManimGX positions itself between a Python-oriented mathematical animation API and a GPU-oriented Rust engine, then reports much lower completion times for its five-scene benchmark. Blender remains a visibly different kind of workflow in the comparison because the README names Workbench and EEVEE separately, but it does not document how users author equivalent scenes in those tools.

ManimGX is therefore most directly relevant when API continuity with Manim CE matters and a browser or agent-assisted output path is desired. Existing Blender-centered production pipelines, or projects that depend on undocumented Manim CE behavior, require a separate compatibility review.

## Maintenance, upgrades, and bundled-license obligations

The repository is not archived, and the last push was on 2026-10-15. It has two recent releases: `v0.1.0` and `v0.1.1`, both published on 2026-10-07. The current package version in `pyproject.toml` is `0.1.1`. This is recent project activity, but two releases do not establish a long compatibility history or a predictable upgrade cadence.

Maintenance work spans Python, Rust, browser tooling, tests, documentation, and release licensing. The `justfile` shows `uv sync` for development dependencies and a separate `bun install --frozen-lockfile` command for browser tools. Dependency upgrades use `uv lock --upgrade`, `cargo update --manifest-path rust/Cargo.toml`, and `scripts/release/licenses.py`. The `justfile` defines a `check` recipe for running the complete local checks with `uv run --frozen prek run --all-files --show-diff-on-failure`.

The project itself is identified as MIT, but the distribution is not solely MIT. `pyproject.toml` lists GPL-2.0-or-later, LGPL-2.1-or-later, Apache-2.0, font licenses, and other third-party terms. It specifically mentions x264 under GPL-2.0-or-later, FFmpeg under LGPL-2.1-or-later, Mesa's lavapipe in Linux wheels, and DXC in Windows wheels. The repository includes `LICENSE-THIRD-PARTY`, `LICENSE-LAVAPIPE`, and `LICENSE-DXC`. Distribution review must therefore account for bundled components rather than the top-level MIT label alone.

## Conclusion

ManimGX fits Python developers, mathematical animators, and agents that can follow llms.txt and operate a browser-based workflow. It is a poor fit for teams requiring a long release history or expecting the README alone to document every rendering and compatibility detail. Before adoption, verify Python 3.13 support, the Manim CE API coverage needed by an existing project, and the licensing terms of the distributed binaries, especially x264 and FFmpeg.

## FAQ

### What operating systems and Python versions does ManimGX support for installation?

The README says `pip install manimgx` works on macOS, Linux, and Windows with Python 3.13 or newer. It also says fonts, typesetting, and video encoding are included.

### Is ManimGX compatible with the Manim Community Python API?

ManimGX describes itself as compatible with Manim CE's API. The README does not include a feature matrix, so complete class-level or configuration-level compatibility cannot be confirmed.

### How can an agent install ManimGX and create a first 3D animation?

The README suggests pasting a prompt into Claude Code, Codex, or Cursor that points the agent to `https://manimgx.academa.ai/llms.txt` and asks it to install ManimGX, make a 3D solar-system animation, and open it.

## Sources

- [academa-labs/manimgx on GitHub](https://github.com/academa-labs/manimgx)
- [License: MIT](https://github.com/academa-labs/manimgx/blob/main/LICENSE)
- [Project website](https://manimgx.academa.ai)
- [README](https://github.com/academa-labs/manimgx/blob/main/README.md)
- [Releases](https://github.com/academa-labs/manimgx/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/academa-labs-manimgx