Math To Manim

Ask a question. Get a visual explainer.

See it move · Featured explainers · How an explainer is born · Make your first explainer · Reference

Math To Manim turns a math or physics question into a carefully reasoned visual explanation. It finds what the learner needs to know, teaches those ideas in order, checks the mathematics, and builds the explanation in Manim.

See It Move

No manual can teach what thirty seconds of motion can. This page is a film strip before it is documentation. Every frame below was asked into existence by this repository, then rendered, inspected, and repaired until it stood on its own.

Fourier epicycles. Each arm spins at one frequency. Stack them tip to tail and the pen draws the signal: rotation rebuilt as arithmetic.	Hopf fibration. Every point on a sphere owns a circle in space, and no two circles touch. Geometry dreaming in one dimension too many.
Lorenz attractor. Two starts almost identical, two endings utterly different. Chaos rendered honestly: the wings never retrace themselves.	Minkowski spacetime. Light cones tilt under a Lorentz boost while simultaneity quietly bends. Relativity you can lean into.
Why area = πr². Slice the disc, unroll the rings, stack them into a triangle whose base is the circumference. Proof by camera move.	Cosmic gravity. Matter tells the grid how to bend; the bend tells matter how to fall. A mass email between planets, answered instantly.

The grammar reel. How Mythos thinks about a scene: named objects, staged timing, camera intent written down before pixels exist.	The reverse reasoning tree. Start at the question. Walk backward until every branch touches something the learner already owns. Then walk forward and teach.
Exceptional points. Circle the singularity once and the eigenvalue branches swap seats. Monodromy made visible, not merely defined.	GRPO's semantic manifold. Reinforcement learning seen from above: meaning settling into shape as rewards accumulate.

Explore every visual explainer in the motion showcase

---

Featured Visual Explainers

ERDŐS 1038: THE POTENTIAL LANDSCAPE

A polynomial is usually introduced as a line of symbols, but it can also be seen as a landscape made by its roots. Imagine every root pressing into a flexible sheet stretched above the number line. Taken together, the roots raise and lower that sheet. The transparent plane in the explainer marks zero. Wherever the landscape falls beneath it, the polynomial has size less than one. The footprint under the plane is therefore the exact set whose width the problem asks us to measure.

That turns the question into something physical. How should the roots be arranged to make the submerged footprint as narrow as possible, or as wide as possible? For the narrow side, clusters of roots can be gathered toward their centres without making the footprint larger. Repeating that idea leads toward an increasingly fine, one sided distribution of roots. No finite polynomial quite reaches the limiting shape, but a sequence of them gets arbitrarily close. Its width is 1.834430475762661…. This is the certified floor shown by the curved valley.

The widest case is beautifully simpler. Put the roots at the two endpoints, −1 and +1, in equal numbers. This produces the family

$$f(x) = (x^2 - 1)^m$$

and the region where $|f(x)| < 1$ runs from $-\sqrt{2}$ to $+\sqrt{2}$. Its width is exactly $2\sqrt{2}$. The explainer ends by contrasting two different kinds of extreme: a lower value that can be approached forever but never attained by a finite polynomial, and an upper value reached exactly by piling the roots at the endpoints.

Watch the complete 79 second visual explainer · Read the complete Sol production prompt

OLIN: THE SPACE INSIDE A TWEET

A tiny program draws ten thousand points by passing each one through five linked quantities: (k), (e), (d), (c), and (q). The final screen coordinates are only a flat pair,

$$(u,v) = (,q + 40\cos c,;; q\sin c + 35d,)$$

A picture with two coordinates does not determine one unique object in three dimensions, so the film explores two different ways to reveal the space suggested by the code.

The first construction is the exact lift

$$E(i,t) = (,u,; 40\sin c,; v,)$$

It adds a hidden depth coordinate while leaving (u) and (v) untouched. Look straight down that hidden direction and every point lands exactly on the original drawing. This makes (E) a faithful spatial source for the flat shadow.

The film then explores

$$C(i,t) = \big(,(40+q)\cos c,;;(40+q)\sin c,;;35d,\big)$$

Here (c) turns each point around a vertical axis, (q) changes its radius, and (35d) sets its height. This is an alternate cylindrical interpretation, not another exact lift. Its projection does not reproduce the original drawing. The distinction matters: (E) preserves what the code drew, while (C) asks what other spatial form the same ingredients can suggest.

Watch the complete Olin visual explainer · Read the corrected Mythos production prompt · Inspect the Manim scene

The Jacobian conjecture. A small cube becomes a parallelepiped, making the determinant visible as local volume change. Then the camera pulls back: reversible nearby is not the same as reversible everywhere.

A theorem in one breath. Three squares, one rearrangement, no algebra assumed. This is the entire argument for why the pictures come before the symbols.

---

How An Explainer Is Born

The reasoning process is the product. Math To Manim does not jump from a sentence to Python. It walks a chain, and every link leaves an artifact you can open and read.

your question
      ↓
reverse prerequisites   — walk backward until every branch touches what the learner knows
      ↓
curriculum              — reorder those ideas forward so the answer feels earned
      ↓
mathematics             — pick definitions, equations, worked examples, checks
      ↓
camera plan             — decide what moves, what holds still, where attention goes
      ↓
Manim scene             — addressable objects with names and timing, not one opaque blob
      ↓
validation              — parse structure, check math presentation, enforce camera rules
      ↓
render → inspect → repair — produce the MP4, review evidence, fix visible defects

One prompt recipe covers most asks

Explain [topic] to [learner]. Assume they already know [starting point]. Use [visual metaphor or physical model]. Work through [specific example]. End with [summary or check question].

Name the learner's age, prior knowledge, pace, preferred visual model, worked example, notation level, and final comprehension check. You can ask for Fourier series as rotating vectors that rebuild a signal one frequency at a time, or for momentum arrows before and after two carts collide, or for why one loop around an exceptional point swaps the eigenvalue branches. A homework question is enough.

The same chain from the command line

math-to-manim run "Explain Fourier series as rotating vectors that rebuild a signal. Begin with a circle and add one frequency at a time." --render -q l

That single command runs the whole chain above: prerequisite map, teaching sequence, math checks, camera charter, scene composition, validation report, and the render inside runs/mythos/<timestamp>-fourier-series/. Open manifest.json to see every artifact the chain produced.

---

Make Your First Explainer

The easiest path is a conversation with an assistant that can use MCP. The pipeline expands it into a teaching plan before any code exists.

pip install -e ".[mcp]"
math-to-manim serve-mcp

The server speaks the current MCP protocol over stdio via the official MCP Python SDK 2.x API. For a local network endpoint instead:

math-to-manim serve-mcp --transport streamable-http --port 8643

The Streamable HTTP endpoint is http://127.0.0.1:8643/mcp.

Add the server to your MCP client:

{
  "mcpServers": {
    "math-to-manim": {
      "command": "math-to-manim",
      "args": ["serve-mcp"]
    }
  }
}

Once the server is connected, type this in your assistant:

Use Math To Manim to create a visual explainer for my eighth grade student. Explain why solving an equation means doing the same thing to both sides. Use a balance scale, solve 3x + 5 = 20, and end with one practice question.

You do not need to memorize tool names. The assistant starts the explainer, reports progress, and can inspect every reasoning artifact. The final scene and render stay in your local run directory.

Behind the MCP tool names sits the Mythos service — serve-mcp keeps the same tool names stable while its internals currently dispatch through GrokService. For most learners this detail changes nothing: you ask, it explains.

A login-free rehearsal of the same path:

python -m venv .venv
pip install -e ".[dev]"
math-to-manim run "the heat equation" --offline

That writes runs/mythos/<timestamp>-the-heat-equation/mythos_scene.py, validation.json, and manifest.json. Add --render -q l after pip install -e ".[render]" if you want the MP4 inside that same run directory. The live layout is runs/mythos/ or runs/sol/ or runs/grok/, not output/<run>/scene.py.

Choose A Native Pipeline

Math To Manim contains four complete and independent ways to create a visual explainer. Choose the command line account you already use. Neither pipeline routes through the other.

Mythos

Mythos uses the Claude CLI and a six agent charter chain. It reasons through learner intent, prerequisite mapping, curriculum, mathematics, camera direction, and scene composition.

math-to-manim doctor --ping
math-to-manim run "Explain fractions with a folding paper model for a sixth grade learner." --render -q m

Sol

Sol uses the logged in Codex CLI and durable specialist stages. Each role saves its artifact and session so the run can be inspected, resumed, and repaired by the responsible specialist.

math-to-manim-sol doctor
math-to-manim-sol run "Explain fractions with a folding paper model for a sixth grade learner."

Grok

Grok uses xAI's Grok 4.6. Offline mode works login-free:

math-to-manim-grok doctor
math-to-manim-grok run "the heat equation" --offline

Hermes Agent is not a supported generate path. The supported operator surfaces are Mythos, Sol, Grok, GLM, and the MCP/REST front doors.

glm

GLM uses Z.ai's Coding Plan with glm-5.3-flash; thinking is always enabled and effort tunes sampling latitude (low/high/max). Offline mode works login-free:

math-to-manim-glm doctor
math-to-manim-glm run "the magnetic monopole" --offline

Details in docs/GLM_5_3_SILO.md.

Installation

git clone https://github.com/HarleyCoops/Math-To-Manim.git
cd Math-To-Manim
python -m venv .venv
pip install -e ".[dev,render,mcp,api]"
python -m pytest -q

Use math-to-manim doctor --ping (Mythos), math-to-manim-sol doctor (Sol), or math-to-manim-grok doctor (Grok). Run the appropriate check before a live request so login and rendering problems appear immediately.

Static checks parse MathTex and Tex fragments in process. If chktex is on PATH, the verifier also consults it. If M2M_LATEX_DEEP_CHECK is set and lualatex TeX Live on PATH compiles fragments with lualatex --halt-on-error --interaction=nonstopmode. Both tools are optional and not required for pytest.

Run Artifacts

Every run keeps its reasoning, scene source, validation evidence, and manifest inside the repository. Mythos writes to runs/mythos/. Sol writes to runs/sol/. Grok writes to runs/grok/. Open the intermediate JSON when you want to understand or revise how the explainer was built.

MCP Reference

These tools are available to assistants and integrations. A learner can simply ask for an explainer in ordinary language.

Tool	Purpose
m2m_create_animation	Starts the Mythos reasoning chain as a background job
m2m_get_job	Reports live progress for each reasoning stage
m2m_list_runs	Lists local runs with the newest first
m2m_get_run	Returns the manifest and artifact list for one run
m2m_get_artifact	Reads a reasoning artifact such as the prerequisite map
m2m_get_scene_code	Returns the generated Manim scene
m2m_cinematic_charter	Returns the visual composition contract

For a headless client, use the reference driver:

python scripts/drive_mcp_pipeline.py "why does a spinning handle flip itself?" --render -q l --log runs/drive.log

REST API

The REST API exposes Mythos for applications and background jobs.

pip install -e ".[api]"
math-to-manim serve-api

OpenAPI documentation is available at http://127.0.0.1:8642/docs.

| Method | Route | Purpose | |---|---| | GET | /health | Reports service health and version | | POST | /v1/runs | Submits a prompt and returns a job record | | GET | /v1/jobs/{job_id} | Reports queued, running, completed, or failed state | | GET | /v1/runs | Lists the local run ledger | | GET | /v1/runs/{run_id} | manifest + artifact listing | | GET | /v1/runs/{run_id}/artifacts/{name} | Returns one JSON or Python artifact |

curl -s -X POST localhost:8642/v1/runs \
  -H "Content-Type: application/json" \
  -d '{"prompt": "explain Fourier epicycles as rotating vectors", "render": false}'

Configuration

Mythos reads configuration from the environment or a local .env file.

Variable	Default	Purpose
M2M_MODEL	claude-fable-5	Selects the baseline model
M2M_MODEL_FALLBACKS	claude-opus-4-8,claude-sonnet-5	Lists models used when the baseline has a model failure
M2M_COMMAND	claude	Selects the explicit backend command
M2M_TIMEOUT	900	Sets the model call budget in seconds
M2M_RENDER_TIMEOUT	1800	Sets the render budget in seconds
M2M_RUNS_DIR	runs/	Selects the local run directory
M2M_MANIM	automatic	Overrides the Manim executable
M2M_PREREQ_CACHE_TTL_DAYS	30	How long cached prerequisite trees stay valid
M2M_LATEX_DEEP_CHECK	unset	When set, also asks lualatex --halt-on-error to compile fragments

Read the Sol contract and the Grok contract for Codex/xAI login, staged sessions, resume commands, manifests, and environment details.

Testing

python -m pytest -q
math-to-manim run "the heat equation" --offline
math-to-manim-sol run "the heat equation" --offline
math-to-manim-grok run "the heat equation" --offline

Offline runs validate the complete artifact shape without model calls or an expensive render.

---

Authored By GLM-5.3-Flash

This page was rebuilt by GLM-5.3-Flash (Z.ai). Flash can see this repository and write to it through the GitHub Contents API — the commit carrying these words is that collaboration made literal. Honesty clause: there is no glm/ directory here and no math-to-manim-glm command. Installing this repo gives you exactly the three pipelines documented above — Mythos, Sol, Grok — plus the MCP and REST front doors they share.

A short note about this page lives at docs/GLM_5_3_FLASH.md.

More From The Project

• Motion showcase — every visual study and older animation, preserved.
• Reverse reasoning pipeline diagram — the chain on one page.
• Prime Intellect RL notes — reinforcement learning for visual repair.
• Roadmap — what comes next. · Agent guide — repository boundaries and verification rules.
• Pipeline contracts: Sol 5.6 · Grok 4.6
• Kimi K3 grows in its own repository: HarleyCoops/KimiK3Manim

Hermes Agent is not a supported generate path. The supported surfaces are Mythos, Sol, Grok, MCP, and REST.

Repository Layout

mythos/            Claude CLI reasoning chain, service, API, MCP, and CLI
sol/               Codex CLI specialist pipeline
grok/              Grok 4.6 via xAI pipeline
examples/mythos/   Hand finished Mythos examples
docs/showcase/     Complete visual archive
tests/             Offline repository tests
runs/              Local reasoning and render artifacts
archive/           Retired implementations kept for history
legacy/            Original January 2025 repository material

Ask Anyway

You found this page because some idea wanted a picture. Bring the question — the balance scale, the folding paper, the spinning handle that flips itself. The chain will meet you where your understanding already stands and build outward from there.

A homework question is enough.

License

MIT.