Coming from Manim to Manic

If you’ve written Manim scenes, you already think the right way: a scene is a sequence of things that appear, move, and change over time. Manic keeps that mental model and drops most of the plumbing. This page is a translation guide — what your favourite Manim moves look like in Manic, and where the two languages genuinely differ.

Every scene mentioned here is a runnable file in the gallery under Coming from Manim. Read this page for the why; open those for the how.

Manic is not “Manim with different syntax.” It’s a small declarative language built for people who aren’t programmers. Where Manim hands you Python objects and asks you to wire them together, Manic gives you a builtin that already knows the intent. Most reactive rigs — a ValueTracker feeding an updater feeding an always_redraw — collapse to a single verb. The examples below are the same tutorial scenes you already know, written the Manic way.

The three big differences

1. No ValueTracker, no add_updater, no always_redraw. This is the headline. In Manim, “keep this line connected to those two dots as they move” is a hand-written updater. In Manic, a segment between two points is reactive by construction — it reflows to its endpoints every frame because the constraint pass runs for you. You rarely write the reactive glue; you state the relationship once and animate the inputs.

point(a, (200, 400)); point(b, (600, 300));
segment(l, a, b);            // stays connected — no updater
slidex(a, 840, 2);           // move one dot; the line follows

2. The timeline is deterministic and scrubbable. Animations in Manic resolve to a pure function of time t. A motion trail (trail) isn’t accumulated frame-by-frame like a Manim updater that appends points — it’s sampled from the resolved timeline, so scrubbing backwards shows exactly the trail up to that moment. You get correct reverse playback for free.

3. You say what happens, not how to redraw it. Manim’s self.play(Create(x)), Transform, Restore, MoveAlongPath are render instructions. Manic’s verbs — show, draw, move, to, turn, grow, fade — are intentions, sequenced with wait and grouped with par { }.

The translation table

Two things that trip people up

hidden is a base state, not an animation. hidden(x) means “x starts invisible from t=0” — it’s declared once, up top, alongside the constructors. To hide something mid-scene, use the timeline verb fade(x). (Symmetrically, show(x) reveals it.) Constructors run at build time, so anything you don’t want on screen at the start should be declared and hidden before the timeline begins.

zoom is inverted from Manim’s camera scale. Manim shrinks the camera frame to magnify (frame.scale(0.5)); Manic zooms the view directly, so zoom(2) magnifies and zoom(1) is the wide shot.

Porting a scene, step by step

A comfortable way to move a Manim scene across:

1. Set the frame. Replace the whole Axes(...) block with one coords(...) — ranges, per-axis scale, tips, ticks, numbers, and axis names all live there. Point your plots at the same origin, sx, sy and they line up.
2. Delete the reactive rig. Every ValueTracker, add_updater, and always_redraw has a direct verb (slidex, mark, boxto, anglemark, segment, trail, …). Find the builtin that already encodes the relationship instead of re-wiring it — the table above is your lookup.
3. Sequence with wait and par. self.play(a, b) becomes par { a; b; }; self.wait(t) becomes wait(t). Reveals are show/draw; hides are fade.
4. Declare-and-hidden up top. Anything that shouldn’t be on screen at the start is constructed and hidden before the timeline, then shown when its moment comes.

If a Manim move isn’t in the table, check the API reference — Manic’s vocabulary is broad, and there’s usually a builtin that says it in one line.

Beyond the core: domain kits

Here’s the biggest difference the table above doesn’t show. Manim is a general animation library: for a neural network you hand-build a NetworkMobject out of Circles and Lines and fake the activations; for a slider you subclass NumberLine; for a gradient surface you wire up a Surface and animate the vectors yourself. (That is literally how the 3Blue1Brown neural-network, high-dimensions, and gradient-descent videos are made.)

Manic ships kits that compute the object for you — the maths is real, not drawn — and because every kit object is an ordinary tagged entity, the core rhetoric (framebox, brace, arrow, say, equation, pulse) dresses it directly.

Because they are just entities, you mix core and kit freely — this is the whole point of the language:

network(net, (600, 360), "4 6 3", "relu softmax");
framebox(fb, net.hidden, 14);      // core box around a whole KIT layer (a group)
brace(br, (720, 165), (720, 555), 26, right);
surround(fb, net.output, 1.0);     // glide the box across, layer by layer
pulse(net.output);                 // flash the prediction

The kit computes the object; the core gives you the explanation. See the ML kit, the 3D chapter, and the kits overview.

Where to go next

• Coming from Manim gallery — every scene above, runnable.
• 3Blue1Brown, reproduced — longer-form math lessons built the same way.
• The graphing & calculus kit — coords, plot, area, riemann, and friends in depth.
• Motion graphics — the relationship verbs (attach, become, travel) that replace updaters.