/manim-video

name: manim-video
description: Create mathematical animations and explainer videos with Manim Community - code-driven animations for math, CS concepts, data visualization.
version: 1.0.0
author: hermes-CCC (ported from Hermes Agent by NousResearch)
license: MIT
metadata:
  hermes:
    tags: [Creative, Manim, Animation, Video, Mathematics, Visualization]
    related_skills: []

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 writ