Manim Video

Manim Video

Purpose

• Use this skill to create precise, code-driven animations for mathematics, computer science, algorithms, and data visualization.
• Prefer Manim when the content is structural, symbolic, or instructional rather than cinematic live-action editing.
• Manim is especially strong for equations, graphs, geometric constructions, and animated explanations of abstract systems.

Install

pip install manim

• On some systems you may also need FFmpeg and LaTeX-related dependencies for full math rendering support.
• Verify the installation with manim --version.

Mental Model

• A Manim scene is a Python class.
• You place visual objects into the scene.
• You animate transitions between states.
• The render command converts the scene into a video file.
• The code is the asset, which makes revisions reproducible.

Minimal Scene Structure

from manim import *

class MyScene(Scene):
    def construct(self):
        text = Text("Hello, Manim")
        self.play(Write(text))
        self.wait()

Basic Workflow

1. Create a Python file such as scene.py.
2. Define one or more scene classes.
3. Render the desired scene by name.
4. Inspect the output video.
5. Revise the code and rerender.

Render Command

manim -pql scene.py MyScene

• -pql means preview plus quality low.
• Use -pqh when you want a higher-quality render for export or sharing.
• Low-quality previews are much faster during iteration.

Core Objects

• Circle
• Square
• Text
• MathTex
• Axes
• NumberPlane
• Arrow

These cover a large fraction of introductory math and CS explainer work.

Shapes Example

from manim import *

class Shapes(Scene):
    def construct(self):
        circle = Circle(color=BLUE)
        square = Square(color=GREEN).shift(RIGHT * 2)
        arrow = Arrow(circle.get_right(), square.get_left(), color=YELLOW)

        self.play(Create(circle), Create(square))
        self.play(Create(arrow))
        self.wait()

Text and Labels

• Use Text for plain words, labels, titles, and UI-like annotations.
• Use MathTex for equations and symbolic math.
• Keep labels short and readable.
• Position text relative to objects with helpers like .next_to() and .to_edge().

Math Rendering

from manim import *

class Derivative(Scene):
    def construct(self):
        expr = MathTex(r"\frac{d}{dx} x^2 = 2x")
        self.play(Write(expr))
        self.wait()

• Use raw strings for LaTeX-heavy expressions.
• Split long formulas into chunks if you want to animate parts independently.
• MathTex is one of Manim's highest-value primitives for educational video.

Graphs

from manim import *

class PlotExample(Scene):
    def construct(self):
        ax = Axes()
        graph = ax.plot(lambda x: x**2, color=BLUE)
        label = ax.get_graph_label(graph, label="x^2")

        self.play(Create(ax))
        self.play(Create(graph), FadeIn(label))
        self.wait()

• Use Axes() for standard 2D coordinate systems.
• Use NumberPlane() when you want a visible grid.
• Use .plot() for function graphs.
• Add labels only when they clarify the message.

Coordinate Grid Example

from manim import *

class PlaneExample(Scene):
    def construct(self):
        plane = NumberPlane()
        point = Dot(plane.c2p(2, 3), color=RED)
        note = Text("Point (2, 3)").scale(0.5).next_to(point, UP)

        self.play(Create(plane))
        self.play(FadeIn(point), Write(note))
        self.wait()

Common Animations

• Create
• Write
• Transform
• FadeIn
• FadeOut
• MoveAlongPath

These are enough to build most educational sequences.

Animation Example

from manim import *

class AnimateBasics(Scene):
    def construct(self):
        circle = Circle(color=BLUE)
        square = Square(color=GREEN)

        self.play(Create(circle))
        self.play(Transform(circle, square))
        self.play(FadeOut(circle))

Move Along Path

from manim import *

class AlongPath(Scene):
    def construct(self):
        path = Circle(radius=2, color=WHITE)
        dot = Dot(color=YELLOW).move_to(path.point_from_proportion(0))

        self.add(path, dot)
        self.play(MoveAlongPath(dot, path), run_time=3)
        self.wait()

• MoveAlongPath is useful for state machines, orbital motion, and process flow visuals.
• Use it for conceptual journeys, packets moving through systems, or points moving across graphs.

Layout Helpers

• .shift()
• .move_to()
• .next_to()
• .align_to()
• .to_edge()
• .to_corner()
• VGroup(...) for grouping and arrangement

Good layout discipline saves time during revision.

Colors

• RED
• BLUE
• GREEN
• YELLOW
• WHITE
• ORANGE
• PURPLE
• TEAL

Use consistent semantic coloring across the scene.

Color Strategy

• Use one color for inputs, another for transformations, and another for outputs.
• Keep background contrast in mind.
• Avoid using too many unrelated colors in the same explanation.
• Use WHITE or light tones for neutral reference geometry.

Camera Control

from manim import *

class CameraExample(Scene):
    def construct(self):
        plane = NumberPlane()
        self.add(plane)
        self.play(self.camera.frame.animate.scale(0.5))
        self.wait()

• Camera animation helps when zooming into local detail.
• Use it sparingly so viewers do not lose context.
• Zooming is most useful for dense graphs, local geometry, or multi-part explanations.

Output

• Manim writes rendered video outputs under media/videos/.
• Preview renders and partial intermediates also appear under the media/ tree.
• Treat the Python source as canonical and the rendered MP4 as generated output.
• Final videos are typically MP4 files.

Timing

• Use self.wait() to hold the frame.
• Adjust run_time= on animation calls to tune pacing.
• Move slower for conceptual reveals and faster for purely decorative transitions.
• Educational clarity depends on timing as much as layout.