Academa Labs releases ManimGX, a Rust/wgpu engine compatible with Manim CE's Python API that renders 3D motion graphics 90x faster than ManimCE, targeting coding agents with llms.txt and browser-based Pyodide execution.

state: watchingheat: lowuncertainty: mediumconvergesscott: highagent-tool-use motion-graphics video-generation local-inference rust wgpusinaatalayAcadema Labs

What is this?

Academa Labs (creator sinaatalay) released ManimGX — a from-scratch Rust/wgpu animation engine that implements Manim CE's Python API. The engine was built independently first, then retrofitted for API compatibility so existing Manim code and coding agents familiar with the Manim API can use it. It compiles to WebAssembly via PyO3/Pyodide to run in browsers targeting WebGPU, enabling real-time GPU rendering with no local install. A Show HN post and GitHub repo publish benchmarks claiming ~90x speedup over ManimCE for 3D motion graphics. The project explicitly targets coding agents via llms.txt and browser-based Pyodide execution.

Why it matters to Scott

ManimGX independently arrives at multiple load-bearing Scott frameworks: it is a code-first agent tool (llms.txt discovery, PyO3/Pyodide execution, Rust/wgpu performance) that runs machine-native in the browser (WebGPU) with human-legible video output — exactly the agent-native computing posture. It also embodies agent hands-and-eyes: the engine acts as hands (GPU rendering) while the rendered frames serve as eyes for agent iteration. The 90x speedup over ManimCE makes local inference economics viable for agent-generated motion graphics, converging with hardware-aware local inference and sovereign software assurance (no vendor runtime).

ip:framework.code-first-architectureip:framework.agent-native-computingip:concept.agent-hands-and-eyesdev:concept.hardware-aware-local-inferencedev:technology.hyperframesradar:37signals-agent-driven-defaultradar:abyss-acp-agent-isolationradar:notebookllm-notebooklm-podcast-to-illustrated-video-pipelineradar:kidsbook-shortcraft-ai-transcript-driven-childrens-shorts-generator

queries asked of Scott's wikis

agent-tool-use llms.txt pattern for coding agents
local-inference browser-based Pyodide WebGPU execution model
rust wgpu python bindings PyO3 architecture for agent tooling
video-generation motion-graphics engine as agent tool vs human tool
open-weights model sovereignty local inference economics for creative tools

Measured heat

now 0 pts/hpeak 3 pts/hcomments 0/hpeers p37momentum: steady2 platformsage 27h

points/hour across evidence · reading as of 2026-10-12 02:59:37.977291+11:00 · deterministic, not a model opinion

How the heat travelled

10-10 13:00	⭐ origin echo-reconstructed	ManimGX is a blazingly fast 3D animation engine for agents, compatible with Manim CE's API, powered by Rust and wgpu. It installs via pip or Academa Labs on github (echo) · attributed from hn.story.50037852	—
10-10 22:33	first on hacker news · published · +9.6h	Show HN: ManimGX – Manim's API on a Rust/wgpu engine, for 3D videos in Python sinaatalay	—
10-10 22:33	amplified on hacker news 👑	hn.story.50037852 sinaatalay	peak 8 · 1 comments · 101% of case engagement
10-10 23:29	our radar first saw it · +10.5h	discovery anchor: hn.story.50037852	—

pace: p45 vs 968 stories at the 24h mark (now 27h old) — ahead of addom-local-coding-harness (1.5x), behind agent-chaperone-jev-tool-screening (0.8x)

Evidence (2) — ⭐ canonical anchor

source	object	author	score	comments
🟧 hn	Show HN: ManimGX – Manim's API on a Rust/wgpu engine, for 3D videos in Python Retrieved article excerpt Open article · Retrieved 2026-10-11T00:36:56.942338+00:00 [ManimGX](https://manimgx.academa.ai) Blazingly fast 3D animation engine for agents, compatible with [Manim CE's API](https://www.manim.community). Powered by Rust and wgpu. Install with a prompt or pip. Run in the browser. [Documentation](https://manimgx.academa.ai) · [Quickstart](https://manimgx.academa.ai/user-guide/quickstart/) · [Examples](https://manimgx.academa.ai/gallery/) · [API Reference](https://manimgx.academa.ai/reference/) [Test coverage](https://coverage.manimgx.academa.ai) [PyPI version](https://pypi.org/project/manimgx/) [npm version](https://www.npmjs.com/package/manimgx) [PyPI total downloads](https://pepy.tech/projects/manimgx) [npm monthly downloads](https://www.npmjs.com/package/manimgx) [The quadratic formula: completing a square by moving colored rectangles and equation terms](https://github.com/academa-labs/manimgx/blob/main/examples/quadratic_formula.py) [Fourier series: a chain of rotating arrows draws the outline of π](https://github.com/academa-labs/manimgx/blob/main/examples/fourier_pi.py) [A matrix moves the plane: a grid, basis arrows and a unit square transform together](https://github.com/academa-labs/manimgx/blob/main/examples/linear_maps.py) [A tangent slides along a curve as its slope traces the derivative](https://github.com/academa-labs/manimgx/blob/main/examples/derivative.py) [Complex functions bend a grid into parabolas, circles and rays](https://github.com/academa-labs/manimgx/blob/main/examples/complex_maps.py) [The Lorenz attractor: nearby trajectories separate as they trace a butterfly in three dimensions](https://github.com/academa-labs/manimgx/blob/main/examples/lorenz_attractor.py) [Three spinning tops precess and nod as their axes trace curves on glass spheres](https://github.com/academa-labs/manimgx/blob/main/examples/heavy_top.py) [The Hopf fibration: colorful linked circles form nested tori as beads travel along them](https://github.com/academa-labs/manimgx/blob/main/examples/hopf_fibration.py) [A rainbow helicoid bends into a catenoid while preserving its intrinsic curvature](https://github.com/academa-labs/manimgx/blob/main/examples/catenoid_helicoid.py) 36.2 seconds of video, rendered in 3.08 seconds. Across five scenes at 1080p60 on an Apple M4 Pro, ManimGX is 90.6× faster than ManimCE, 11.5× faster than ManimGL, and 18.7× faster than Blender Workbench, from launch to finished MP4. [How it was measured](https://github.com/academa-labs/manimgx/tree/main/benchmarks): the scenes, the settings and every run. Total render times: ManimGX 3.08 s, ManimGL 35.28 s, Blender Workbench 57.61 s, ManimCE 278.83 s, Blender EEVEE 601.40 s All engines use the fastest encoding preset available. Lower is better. Compare the same scene. Linked rings at 2.5 seconds, rendered by each engine. \| ManimGX \| ManimCE \| ManimGL \| Blender Workbench \| Blender EEVEE \| \| --- \| --- \| --- \| --- \| --- \| \| [Eight linked rings rendered by ManimGX at 2.5 seconds](https://camo.githubusercontent.com/b18cb8c680730ffd6bac05d5d744ad7d5b8d01866832890c2460a206e449278a/68747470733a2f2f6d616e696d67782e61636164656d612e61692f696d616765732f62656e63686d61726b2d7175616c6974792f6d616e696d67782d6c696768742e706e67) \| [Eight linked rings rendered by ManimCE at 2.5 seconds](https://camo.githubusercontent.com/22c5ef8d7686d40e407e26c7ae2297a00682fe6ea4003d267c184360f4c53604/68747470733a2f2f6d616e696d67782e61636164656d612e61692f696d616765732f62656e63686d61726b2d7175616c6974792f6d616e696d5f63652d6c696768742e706e67) \| [Eight linked rings rendered by ManimGL at 2.5 seconds](https://camo.githubusercontent.com/b881552fca1ac9a8fbbce5ea4d98bf0bb8c5dbde879d817eb0de1324339b8ec3/68747470733a2f2f6d616e696d67782e61636164656d612e61692f696d616765732f62656e63686d61726b2d7175616c6974792f6d616e696d676c2d6c696768742e706e67) \| [Eight linked rings rendered by Blender Workbench at 2.5 seconds](https://camo.githubusercontent.com/0b7dd8893417f37e3939c9b09804af465690cb557f88c3683ae0a2d3439216c1/68747470733a2f2f6d616e696d67782e61636164656d612e61692f696d616765732f62656e63686d61726b2d7175616c6974792f626c656e6465725f776f726b62656e63682d6c696768742e706e67) \| [Eight linked rings rendered by Blender EEVEE at 2.5 seconds](https://camo.githubusercontent.com/e571bf8ac0df863e5526226d743a47ba7b2205bc634e687f87aff1b16a1a088a/68747470733a2f2f6d616e696d67782e61636164656d612e61692f696d616765732f62656e63686d61726b2d7175616c6974792f626c656e6465725f65657665652d6c696768742e706e67) \| ## Get started With a prompt. Paste into Claude Code, Codex, or Cursor. Your agent handles setup: ``` Follow https://manimgx.academa.ai/llms.txt. Install ManimGX, make a 3D animation of the solar system, and open it. ``` With pip. Install on macOS, Linux or Windows with Python 3.13+: ``` pip install manimgx ``` Fonts, typesetting and video encoding are included. For editor setup and a guided first animation, follow the [Quickstart](https://manimgx.academa.ai/user-guide/quickstart/). ## From Python to MP4 Save this 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) ``` Render it: ``` manimgx render scene.py ``` You get `Hello3D.mp4`, a 1080p60 video: A blue cube is drawn as the camera circles it ## Why ManimGX? An API for 3D video in the age of agents. Your agent writes Python using [Manim CE's API](https://www.manim.community). ManimGX's Rust + wgpu engine renders the MP4, blazingly fast. - Fully statically typed. Keyword arguments and `.animate` chains included. - 2D and 3D together. Surfaces, meshes and moving cameras alongside text, equations and plots. - Runs in the browser. `npm install manimgx`. [Pyodide](https://pyodide.org) runs Python in a Web Worker; WebGPU renders the scene. [Embed a scene](https://manimgx.academa.ai/user-guide/rendering/#embed-in-a-web-page) with no render server. - Agent feedback. [`manimgx inspect`](https://manimgx.academa.ai/user-guide/rendering/#inspect): storyboards and 2D layout checks, at play endings or times you choose. - Text and math. Write LaTeX or Typst. No LaTeX installation needed. - Speech in sync. [Match animations to spoken words](https://manimgx.academa.ai/user-guide/sound-and-voice/) with `self.say()`. ## Documentation [manimgx.academa.ai](https://manimgx.academa.ai) has the guides, rendered examples with source code, and API reference: - [Quickstart](https://manimgx.academa.ai/user-guide/quickstart/): install, set up your editor, and render your first scene. - [User Guide](https://manimgx.academa.ai/user-guide/the-basics/): learn scenes, animations, 3D, text and sound, one idea at a time. - [Examples](https://manimgx.academa.ai/gallery/): watch complete films and read the Python that makes them. - [API Reference](https://manimgx.academa.ai/reference/): look up classes, methods and their typed parameters. - [Coming from Manim CE](https://manimgx.academa.ai/user-guide/coming-from-manim-ce/): adapt existing scenes and check where behavior differs. For agents, [llms.txt](https://manimgx.academa.ai/llms.txt) provides setup instructions and links to the documentation as Markdown. ## On the shoulders of giants [Grant Sanderson](https://www.3blue1brown.com) created [Manim](https://github.com/3b1b/manim). ManimGX targets the API of [Manim Community Edition](https://www.manim.community), the widely used community-maintained fork. The Rust renderer uses [wgpu](https://wgpu.rs) for native GPU rendering and WebGPU in the browser. Its 3D lighting is adapted from Google's [Filament](https://github.com/google/filament): physically based materials, image-based lighting, ambient occlusion, bloom and AgX tone mapping. [Typst](https://typst.app) typesets text and math, with [mitex](https://github.com/mitex-rs/mitex) translating LaTeX input to Typst. [x264](https://www.videolan.org/developers/x264.html) encodes native video exports as H.264; [FFmpeg](https://ffmpeg.org) decodes imported audio, using [libopus](https://opus-codec.org) for Opus. [Pyodide](https://pyodide.org) runs Python scenes in a browser worker. Linux wheels bundle [Mesa](https://mesa3d.org)'s lavapipe for Vulkan rendering on the CPU when no suitable GPU is available. ## Community Questions, bug reports and feature requests start with an [issue](https://github.com/academa-labs/manimgx/issues/new/choose). To contribute, read [Contributing](https://github.com/academa-labs/manimgx/blob/main/.github/CONTRIBUTING.md) and the [Developer Guide](https://manimgx.academa.ai/developer-guide/). [Changelog](https://manimgx.academa.ai/changelog/) · [Citing ManimGX](https://github.com/academa-labs/manimgx/blob/main/CITATION.cff) Everyone participating follows the [Code of Conduct](https://github.com/academa-labs/manimgx/blob/main/.github/CODE_OF_CONDUCT.md). Report vulnerabilities privately through the [security policy](https://github.com/academa-labs/manimgx/blob/main/.github/SECURITY.md). ## License ManimGX's own code is [MIT-licensed](https://github.com/academa-labs/manimgx/blob/main/LICENSE). Native wheels include x264 and are GPL-3.0-or-later as a whole. Bundled components retain their licenses: see the [third-party notices](https://github.com/academa-labs/manimgx/blob/main/LICENSE-THIRD-PARTY), [Linux renderer notices](https://github.com/academa-labs/manimgx/blob/main/LICENSE-LAVAPIPE), and the [Noto](https://github.com/academa-labs/manimgx/blob/main/fonts/manimgx-fonts/LICENSE) and [Noto CJK](https://github.com/academa-labs/manimgx/blob/main/fonts/manimgx-fonts-cjk/LICENSE) font licenses. This software uses code of [FFmpeg](https://ffmpeg.org) licensed under [LGPL-2.1-or-later](https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html). Complete source, including FFmpeg, is in `manimgx-X.Y.Z-source.tar.xz` on each [GitHub release](https://github.com/academa-labs/manimgx/releases).	sinaatalay	8	1
🟧 echo.github ⭐	ManimGX is a blazingly fast 3D animation engine for agents, compatible with Manim CE's API, powered by Rust and wgpu. It installs via pip or	Academa Labs	—	—

source

object

author

score

comments

🟧 hn

Show HN: ManimGX – Manim's API on a Rust/wgpu engine, for 3D videos in Python

Retrieved article excerpt

Open article · Retrieved 2026-10-11T00:36:56.942338+00:00

[ManimGX](https://manimgx.academa.ai)

**Blazingly fast 3D animation engine for agents, compatible with [Manim CE's API](https://www.manim.community).**  
Powered by Rust and wgpu. Install with a prompt or pip. Run in the browser.

**[Documentation](https://manimgx.academa.ai)** ·
[Quickstart](https://manimgx.academa.ai/user-guide/quickstart/) ·
[Examples](https://manimgx.academa.ai/gallery/) ·
[API Reference](https://manimgx.academa.ai/reference/)

[Test coverage](https://coverage.manimgx.academa.ai)
[PyPI version](https://pypi.org/project/manimgx/)
[npm version](https://www.npmjs.com/package/manimgx)
[PyPI total downloads](https://pepy.tech/projects/manimgx)
[npm monthly downloads](https://www.npmjs.com/package/manimgx)

[The quadratic formula: completing a square by moving colored rectangles and equation terms](https://github.com/academa-labs/manimgx/blob/main/examples/quadratic_formula.py)
[Fourier series: a chain of rotating arrows draws the outline of π](https://github.com/academa-labs/manimgx/blob/main/examples/fourier_pi.py)
[A matrix moves the plane: a grid, basis arrows and a unit square transform together](https://github.com/academa-labs/manimgx/blob/main/examples/linear_maps.py)
  
[A tangent slides along a curve as its slope traces the derivative](https://github.com/academa-labs/manimgx/blob/main/examples/derivative.py)
[Complex functions bend a grid into parabolas, circles and rays](https://github.com/academa-labs/manimgx/blob/main/examples/complex_maps.py)
[The Lorenz attractor: nearby trajectories separate as they trace a butterfly in three dimensions](https://github.com/academa-labs/manimgx/blob/main/examples/lorenz_attractor.py)
  
[Three spinning tops precess and nod as their axes trace curves on glass spheres](https://github.com/academa-labs/manimgx/blob/main/examples/heavy_top.py)
[The Hopf fibration: colorful linked circles form nested tori as beads travel along them](https://github.com/academa-labs/manimgx/blob/main/examples/hopf_fibration.py)
[A rainbow helicoid bends into a catenoid while preserving its intrinsic curvature](https://github.com/academa-labs/manimgx/blob/main/examples/catenoid_helicoid.py)

**36.2 seconds of video, rendered in 3.08 seconds.** Across five scenes at 1080p60 on an Apple M4 Pro, ManimGX is **90.6× faster than ManimCE**, **11.5× faster than ManimGL**, and **18.7× faster than Blender Workbench**, from launch to finished MP4. [How it was measured](https://github.com/academa-labs/manimgx/tree/main/benchmarks): the scenes, the settings and every run.

Total render times: ManimGX 3.08 s, ManimGL 35.28 s, Blender Workbench 57.61 s, ManimCE 278.83 s, Blender EEVEE 601.40 s

All engines use the fastest encoding preset available. Lower is better.

**Compare the same scene.** Linked rings at 2.5 seconds, rendered by each engine.

| ManimGX | ManimCE | ManimGL | Blender Workbench | Blender EEVEE |
| --- | --- | --- | --- | --- |
| [Eight linked rings rendered by ManimGX at 2.5 seconds](https://camo.githubusercontent.com/b18cb8c680730ffd6bac05d5d744ad7d5b8d01866832890c2460a206e449278a/68747470733a2f2f6d616e696d67782e61636164656d612e61692f696d616765732f62656e63686d61726b2d7175616c6974792f6d616e696d67782d6c696768742e706e67) | [Eight linked rings rendered by ManimCE at 2.5 seconds](https://camo.githubusercontent.com/22c5ef8d7686d40e407e26c7ae2297a00682fe6ea4003d267c184360f4c53604/68747470733a2f2f6d616e696d67782e61636164656d612e61692f696d616765732f62656e63686d61726b2d7175616c6974792f6d616e696d5f63652d6c696768742e706e67) | [Eight linked rings rendered by ManimGL at 2.5 seconds](https://camo.githubusercontent.com/b881552fca1ac9a8fbbce5ea4d98bf0bb8c5dbde879d817eb0de1324339b8ec3/68747470733a2f2f6d616e696d67782e61636164656d612e61692f696d616765732f62656e63686d61726b2d7175616c6974792f6d616e696d676c2d6c696768742e706e67) | [Eight linked rings rendered by Blender Workbench at 2.5 seconds](https://camo.githubusercontent.com/0b7dd8893417f37e3939c9b09804af465690cb557f88c3683ae0a2d3439216c1/68747470733a2f2f6d616e696d67782e61636164656d612e61692f696d616765732f62656e63686d61726b2d7175616c6974792f626c656e6465725f776f726b62656e63682d6c696768742e706e67) | [Eight linked rings rendered by Blender EEVEE at 2.5 seconds](https://camo.githubusercontent.com/e571bf8ac0df863e5526226d743a47ba7b2205bc634e687f87aff1b16a1a088a/68747470733a2f2f6d616e696d67782e61636164656d612e61692f696d616765732f62656e63686d61726b2d7175616c6974792f626c656e6465725f65657665652d6c696768742e706e67) |

## Get started

**With a prompt.** Paste into Claude Code, Codex, or Cursor. Your agent handles setup:

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

**With pip.** Install on macOS, Linux or Windows with Python 3.13+:

```
pip install manimgx
```

Fonts, typesetting and video encoding are included.
For editor setup and a guided first animation, follow the
[Quickstart](https://manimgx.academa.ai/user-guide/quickstart/).

## From Python to MP4

Save this 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)
```

Render it:

```
manimgx render scene.py
```

You get `Hello3D.mp4`, a 1080p60 video:

A blue cube is drawn as the camera circles it

## Why ManimGX?

**An API for 3D video in the age of agents.** Your agent writes Python using
[Manim CE's API](https://www.manim.community).
ManimGX's Rust + wgpu engine renders the MP4, blazingly fast.

- **Fully statically typed.** Keyword arguments and `.animate` chains included.
- **2D and 3D together.** Surfaces, meshes and moving cameras alongside text, equations
  and plots.
- **Runs in the browser.** `npm install manimgx`. [Pyodide](https://pyodide.org) runs
  Python in a Web Worker; WebGPU renders the scene.
  [Embed a scene](https://manimgx.academa.ai/user-guide/rendering/#embed-in-a-web-page) with no render server.
- **Agent feedback.** [`manimgx inspect`](https://manimgx.academa.ai/user-guide/rendering/#inspect): storyboards and 2D layout checks, at play endings or times you choose.
- **Text and math.** Write LaTeX or Typst. No LaTeX installation needed.
- **Speech in sync.** [Match animations to spoken words](https://manimgx.academa.ai/user-guide/sound-and-voice/)
  with `self.say()`.

## Documentation

**[manimgx.academa.ai](https://manimgx.academa.ai)** has the guides, rendered examples
with source code, and API reference:

- [Quickstart](https://manimgx.academa.ai/user-guide/quickstart/): install, set up your
  editor, and render your first scene.
- [User Guide](https://manimgx.academa.ai/user-guide/the-basics/): learn scenes,
  animations, 3D, text and sound, one idea at a time.
- [Examples](https://manimgx.academa.ai/gallery/): watch complete films and read the
  Python that makes them.
- [API Reference](https://manimgx.academa.ai/reference/): look up classes, methods
  and their typed parameters.
- [Coming from Manim CE](https://manimgx.academa.ai/user-guide/coming-from-manim-ce/):
  adapt existing scenes and check where behavior differs.

For agents, [llms.txt](https://manimgx.academa.ai/llms.txt) provides setup instructions
and links to the documentation as Markdown.

## On the shoulders of giants

[Grant Sanderson](https://www.3blue1brown.com) created
[Manim](https://github.com/3b1b/manim). ManimGX targets the API of
[Manim Community Edition](https://www.manim.community), the widely used
community-maintained fork.

The Rust renderer uses [wgpu](https://wgpu.rs) for native GPU rendering and WebGPU in
the browser. Its 3D lighting is adapted from Google's
[Filament](https://github.com/google/filament): physically based materials,
image-based lighting, ambient occlusion, bloom and AgX tone mapping.
[Typst](https://typst.app) typesets text and math, with
[mitex](https://github.com/mitex-rs/mitex) translating LaTeX input to Typst.
[x264](https://www.videolan.org/developers/x264.html) encodes native video exports as
H.264; [FFmpeg](https://ffmpeg.org) decodes imported audio, using
[libopus](https://opus-codec.org) for Opus.

[Pyodide](https://pyodide.org) runs Python scenes in a browser worker. Linux wheels
bundle [Mesa](https://mesa3d.org)'s lavapipe for Vulkan rendering on the CPU when no
suitable GPU is available.

## Community

Questions, bug reports and feature requests start with an
[issue](https://github.com/academa-labs/manimgx/issues/new/choose).
To contribute, read [Contributing](https://github.com/academa-labs/manimgx/blob/main/.github/CONTRIBUTING.md)
and the [Developer Guide](https://manimgx.academa.ai/developer-guide/).

[Changelog](https://manimgx.academa.ai/changelog/) ·
[Citing ManimGX](https://github.com/academa-labs/manimgx/blob/main/CITATION.cff)

Everyone participating follows the
[Code of Conduct](https://github.com/academa-labs/manimgx/blob/main/.github/CODE_OF_CONDUCT.md).
Report vulnerabilities privately through the
[security policy](https://github.com/academa-labs/manimgx/blob/main/.github/SECURITY.md).

## License

ManimGX's own code is [MIT-licensed](https://github.com/academa-labs/manimgx/blob/main/LICENSE).
Native wheels include x264 and are GPL-3.0-or-later as a whole.

Bundled components retain their licenses: see the
[third-party notices](https://github.com/academa-labs/manimgx/blob/main/LICENSE-THIRD-PARTY),
[Linux renderer notices](https://github.com/academa-labs/manimgx/blob/main/LICENSE-LAVAPIPE),
and the [Noto](https://github.com/academa-labs/manimgx/blob/main/fonts/manimgx-fonts/LICENSE)
and [Noto CJK](https://github.com/academa-labs/manimgx/blob/main/fonts/manimgx-fonts-cjk/LICENSE) font licenses.

This software uses code of [FFmpeg](https://ffmpeg.org) licensed under
[LGPL-2.1-or-later](https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html).
Complete source, including FFmpeg, is in `manimgx-X.Y.Z-source.tar.xz` on each
[GitHub release](https://github.com/academa-labs/manimgx/releases).

sinaatalay

🟧 echo.github ⭐

ManimGX is a blazingly fast 3D animation engine for agents, compatible with Manim CE's API, powered by Rust and wgpu. It installs via pip or

Academa Labs

—

Interpretation history

2026-10-11T00:59:43Z
grounded: converges/high — ManimGX independently arrives at multiple load-bearing Scott frameworks: it is a code-first agent tool (llms.txt discovery, PyO3/Pyodide execution, Rust/wgpu pe
2026-10-11T00:48:46Z
case created — Show HN release with detailed GitHub repo (first-party) demonstrates a lightweight, agent-oriented 3D animation engine with published benchmarks and agent-friendly installation via llms.txt.

Decision trace

10-11 13:16attention_communicatedAcadema Labs released ManimGX, a Manim CE API-compatible 3D engine written in Rust/wgpu. It installs via pip/npm, runs in browser (Pyodide/WebGPU), and benchmarks show 90.6× speedup over ManimCE (3.08
10-11 13:16attention_routeReleased artifact with benchmarks and agent-friendly design; directly relevant to Scott's local inference and agent tooling stack.
10-11 12:07attention_routeReleased artifact with benchmarks and agent-friendly design; directly relevant to Scott's local inference and agent tooling stack.
10-11 12:00attention_candidatecreate
10-11 11:59groundManimGX independently arrives at multiple load-bearing Scott frameworks: it is a code-first agent tool (llms.txt discovery, PyO3/Pyodide execution, Rust/wgpu performance) that runs machine-native in t
10-11 11:48createShow HN release with detailed GitHub repo (first-party) demonstrates a lightweight, agent-oriented 3D animation engine with published benchmarks and agent-friendly installation via llms.txt.