guide

Coming From Manim

If you have made animations with Manim, either the Community Edition or 3Blue1Brown's ManimGL, most of what you know carries over to Monocurl. Both let you describe a math animation in code. The difference is that Monocurl is a desktop app with its own language: you see the scene update as you type, scrub through it on a timeline, and present it as slides without a plugin.

Monocurl is not a fork of Manim. It is written from scratch in Rust and is free and open source under the MIT license. This page maps Manim concepts to their Monocurl counterparts so you can get started quickly.

Concepts At A Glance

The Same Scene In Both

Here is a short Manim scene. A circle and a label appear, then the circle moves right and turns orange while the label changes from "hello" to "world".

from manim import *

class FirstScene(Scene):
    def construct(self):
        circle = Circle(radius=0.4, color=BLUE).shift(1.4 * LEFT)
        label = Text("hello", font_size=28).next_to(circle, DOWN)
        self.play(FadeIn(circle), Write(label))
        self.next_section()
        world = Text("world", font_size=28).move_to(label).shift(2.8 * RIGHT)
        self.play(
            circle.animate.shift(2.8 * RIGHT).set_color(ORANGE),
            Transform(label, world),
        )

In Monocurl you declare each mesh once, with named arguments for the parts that will change. A later slide edits those arguments and a play statement animates the change.

slide "intro"
    mesh circle =
      center{pos: 1.4l}
      color{col: BLUE}
      Circle(0.4)
    mesh label =
      center{pos: 1.4l + 0.75d}
      Text(text: "hello", 0.65)
    play [Write(0.9, [&label]), Fade(0.9, [&circle])]

slide "transform"
    circle.pos = 1.4r
    circle.col = ORANGE
    label.pos = 1.4r + 0.75d
    label.text = "world"
    play Trans(1.2)

What Works Differently

You change state, then play

In Manim you hand objects to animations: self.play(Transform(a, b)). In Monocurl you assign the new value to a mesh first, and then play says how the screen should catch up. Each mesh has a leader, which your code reads and writes, and a follower, which is what gets drawn. Assigning to the leader changes nothing on screen until the next play. The Animation lesson covers this in detail.

Because of this, most scenes don't need to name what they animate. play Lerp(1) animates every mesh you changed since the last play. When you want only some of them, pass references, as in play Lerp(1, [&circle]).

Labeled arguments instead of value trackers

When you build a mesh with labeled arguments, as in Circle(radius: 0.35), Monocurl remembers the call. Writing ball.radius = 0.6 edits that one argument and rebuilds the mesh, and Lerp then interpolates each argument from its old value to the new one. This covers most of what .animate and ValueTracker are used for in Manim.

r = ValueTracker(0.35)
ball = always_redraw(lambda: Circle(radius=r.get_value(), color=BLUE))
self.add(ball)
self.play(r.animate.set_value(0.6))

mesh ball = color{BLUE} Circle(radius: 0.35)

slide
    ball.radius = 0.6
    play Lerp(1)

When many meshes depend on one value, declare it with param and read it with $, for example Circle($radius). Animating the param redraws everything that reads it, and top-level params also show up as sliders in presentation mode. See Stateful Values And Parameters.

Slides and presenting are built in

A Manim scene usually becomes one video, and presenting it as slides takes a plugin such as manim-slides. In Monocurl, slide is part of the language. Press Cmd/Ctrl-P to present: each slide boundary becomes a pause, and you can drag params live in front of an audience. The same file still exports to .mp4 or .png.

You preview instead of re-rendering

With Manim you edit, render, and watch the output. Monocurl re-runs the scene as you type and shows the frame at the current point of the timeline, so you can jump to the fourth slide and check one animation without rendering the first three. If you prefer the command line, monocurl video scene.mcs and monocurl image scene.mcs render without opening the editor.

It is not Python

Monocurl scenes use the Monocurl language, not Python. It has lambdas, lists, maps, loops, and operators like fill{...} and center{...} that read right to left as a pipeline. You can't import NumPy or other Python packages, so if a scene depends on scientific Python, Manim is still the better tool. The Language Basics lesson is a quick reference for the syntax.

Questions

Is Monocurl a fork of Manim?

No. Monocurl is written from scratch in Rust, with its own language, editor, and renderer. It shares Manim's goal of making math animations with code.

Can I use Python libraries?

No. If you need NumPy, SciPy, or another Python package inside a scene, Manim is a better fit.

Does it replace manim-slides?

For most uses, yes. Every slide block is a stop in presentation mode, and top-level params become sliders you can drag while presenting.

Is it free?

Yes. Monocurl is free and open source under the MIT license, and runs on macOS, Windows, and Linux. Download it here, then start with the Overview lesson.