Manim Animation Skill

Create precise, programmatic animations for technical blogs, educational content, and concept visualization using Manim Community Edition (ManimCE).

Test animations: https://docs.manim.community/en/stable/examples.html

Installation (v0.19+)

# Recommended: uv (no ffmpeg needed since v0.19!)
uv venv && source .venv/bin/activate
uv pip install manim

# Or pip (still works)
pip install manim

# Check installation
manim checkhealth

Note: v0.19+ uses pyav internally, eliminating the external ffmpeg dependency.

Virtual environment tip: If not activated, use

uv run manim ...

manim

Windows Quick Start (PowerShell)

# Install uv (if needed)
python -m pip install --user uv

# Verify uv is on PATH
where uv

# One-off run without creating a venv
uv run --with manim manim checkhealth

If

uv

where uv

ManimCE vs ManimGL

pip install manim

pip install manimgl

%%manim

Always use ManimCE unless reproducing exact 3Blue1Brown videos.

Core Concepts

Three Building Blocks

1. Mobjects - Mathematical objects displayed on screen (Circle, Text, Code, etc.)
2. Scenes - Canvas containing animations, subclass of

   Scene

3. Animations - Transformations applied to Mobjects (Create, Write, FadeIn, etc.)

Basic Scene Structure

from manim import *

class MyScene(Scene):
    def construct(self):
        # Create mobjects
        circle = Circle(color=BLUE)

        # Animate
        self.play(Create(circle))
        self.wait(1)

Common Mobjects

Text and Labels

# Plain text
text = Text("Hello", font_size=48)

# With color portions
text = Text("Hello World", t2c={"Hello": RED, "World": BLUE})

# Positioned
label = Text("Label").next_to(circle, UP)

Code Blocks (v0.19+)

# IMPORTANT: Use code_string, NOT code parameter
code = Code(
    code_string="""function example() {
  return 42;
}""",
    language="javascript",       # Specify explicitly (auto-detect is flaky)
    background="rectangle",      # or "window"
    formatter_style="monokai",   # pygments style
)

# Get available styles
styles = Code.get_styles_list()  # ['monokai', 'vim', 'native', ...]

LaTeX

# Simple LaTeX
tex = Tex(r"\LaTeX", font_size=144)

# Math mode (auto-wrapped in $...$)
math = MathTex(r"E = mc^2")

# Multi-line equation
equation = MathTex(r"f(x) &= x^2 \\ g(x) &= x^3")

TeX-Free Numeric Labels (Windows-Safe)

If LaTeX is not installed, avoid

Tex

MathTex

Integer

DecimalNumber

Variable

Use plain text labels instead:

value = 42
label = Text(str(value), font_size=24)

Shapes

circle = Circle(radius=1, color=BLUE, fill_opacity=0.5)
square = Square(side_length=2, color=RED)
rect = Rectangle(width=3, height=1.5)
arrow = Arrow(LEFT, RIGHT)
line = Line(ORIGIN, UP * 2)

Graphs and Axes

axes = Axes(
    x_range=[-3, 3, 1],
    y_range=[-5, 5, 1],
    axis_config={"color": BLUE}
)
graph = axes.plot(lambda x: x**2, color=WHITE)
label = axes.get_graph_label(graph, label="x^2")

Animation Patterns

Basic Animations

# Create vs Write:
# - Create: Simple stroke drawing (use for shapes)
# - Write: Hand-writing effect with border-then-fill (use for text)
self.play(Create(circle))       # For shapes
self.play(Write(text))          # For Text/Tex/MathTex

self.play(FadeIn(mob))          # Fade in
self.play(FadeIn(mob, shift=UP))  # Fade in with direction
self.play(FadeOut(mob))         # Fade out
self.play(GrowFromCenter(mob))  # Grow from center
self.wait(1)                    # Pause 1 second

The .animate Syntax

Prepend

.animate

# Animate movement
self.play(circle.animate.shift(RIGHT * 2))

# Animate scaling
self.play(square.animate.scale(2))

# Animate color change
self.play(text.animate.set_color(RED))

# Chain animations
self.play(mob.animate.shift(UP).scale(0.5).set_color(BLUE))

Transform Animations

# Morph one shape into another
self.play(Transform(square, circle))

# Replace (keeps reference to new object)
self.play(ReplacementTransform(old, new))

Simultaneous Animations

# Multiple objects at once
self.play(
    Create(circle),
    Write(text),
    FadeIn(arrow),
    run_time=2
)

Positioning

Direction Constants

UP, DOWN, LEFT, RIGHT, ORIGIN
UL, UR, DL, DR  # Corners (Up-Left, etc.)

Positioning Methods

# Absolute position
mob.move_to(ORIGIN)
mob.move_to(LEFT * 3 + UP * 2)

# Relative to another object
label.next_to(circle, UP, buff=0.5)

# Shift from current position
mob.shift(RIGHT * 2)

# Align edges
mob.align_to(other, UP)  # Align top edges

Grouping

group = VGroup(circle, square, text)
group.arrange(RIGHT, buff=0.5)           # Horizontal layout
group.arrange(DOWN, aligned_edge=LEFT)   # Vertical, left-aligned

# Grid layout
boxes = VGroup(*[Square() for _ in range(6)])
boxes.arrange_in_grid(rows=2, cols=3, buff=0.5)

Colors

# Named colors
RED, BLUE, GREEN, YELLOW, WHITE, BLACK, GRAY
ORANGE, PINK, PURPLE, TEAL, GOLD

# Shades (A=lightest, E=darkest)
BLUE_A, BLUE_B, BLUE_C, BLUE_D, BLUE_E
GRAY_A, GRAY_B, GRAY_C, GRAY_D, GRAY_E

# Hex colors
color = "#61DAFB"

# Color modules (v0.19+)
from manim.utils.color import X11, XKCD
beige = X11.BEIGE      # '#F5F5DC'
mango = XKCD.MANGO     # '#FFA62B'

Rendering Commands

# One-off render with uv (no manual venv activation)
uv run --with manim manim -pql scene.py SceneName

# Preview with low quality (fast)
manim -pql scene.py SceneName

# High quality render
manim -pqh scene.py SceneName

# Export as GIF (good for blogs)
manim -qm --format=gif scene.py SceneName

# Quality flags
# -ql  480p15 (preview)
# -qm  720p30 (medium)
# -qh  1080p60 (high)
# -qk  4K60 (production)

# Debugging options
manim -pql -s scene.py SceneName     # Output last frame only (fastest)
manim -pql -n 1,3 scene.py SceneName # Render animations 1-3 only
manim --dry_run scene.py SceneName   # No output, just check errors

Jupyter Notebook

Use the

%%manim

%%manim -qm -v WARNING MyScene

class MyScene(Scene):
    def construct(self):
        circle = Circle()
        self.play(Create(circle))

See

references/advanced.md

Best Practices

Keep Animations Focused

For blog posts, create short, focused animations (5-15 seconds) that illustrate one concept. Let surrounding text provide context.

Use Helper Functions

def create_node(label, color):
    """Reusable node factory."""
    rect = RoundedRectangle(width=2, height=1, color=color, fill_opacity=0.3)
    text = Text(label, font_size=20)
    text.move_to(rect)
    return VGroup(rect, text)

Performance Tips

• Use

  -ql

  during development, render high quality only when ready
• Prefer

  Text

  over

  Tex

  when LaTeX isn't needed (faster)
• Use caching: Manim automatically caches partial renders
• Use

  -s

  to quickly preview the final frame

Scene Organization

class MyAnimation(Scene):
    def construct(self):
        self.show_intro()
        self.show_main_concept()
        self.show_conclusion()

    def show_intro(self):
        # Intro animations
        pass

Additional Resources

Reference Files

For detailed syntax and patterns:

• references/mobjects.md

  - Complete Mobject reference (shapes, text, code, graphs, 3D primitives, numbers, positioning)

• references/animations.md

  - All animation types, Transform vs ReplacementTransform, timing control

• references/advanced.md

  - Camera, 3D, ValueTracker, updaters, config, common mistakes, plugins

• references/blog-patterns.md

  - Common patterns for technical blog animations

Example Files

Working examples in

examples/

• examples/basic_scene.py

  - Minimal scene template

• examples/flowchart.py

  - Animated flowchart pattern

• examples/state_diagram.py

  - State transition visualization

• examples/quicksort.py

  - Quicksort bar animation (algorithm visualization template)

External Resources

• Official Docs: https://docs.manim.community/en/stable/
• Example Gallery: https://docs.manim.community/en/stable/examples.html
• GitHub: https://github.com/ManimCommunity/manim
• Discord: Community support and #beginner-resources channel