# Manim

> This skill should be used when the user asks to "create an animation", "make a manim video", "animate this concept", "visualize this process", "create a GIF for my blog", "plot a graph", "animate a value", or mentions "manim", "mathematical animation", "code animation", "process visualization", "technical animation", "3D scene", "camera animation", "ValueTracker", "number animation". Provides ManimCE (Community Edition) syntax, patterns, and best practices for creating programmatic animations.

- Skill: `majiayu000/manim` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add majiayu000/manim`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/manim/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/manim

---


# 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+)

```bash
# 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 ...` instead of `manim`.

### Windows Quick Start (PowerShell)

```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` is not found, restart the terminal and run `where uv` again.

## ManimCE vs ManimGL

| Aspect | ManimCE (Recommended) | ManimGL |
|--------|----------------------|---------|
| Package | `pip install manim` | `pip install manimgl` |
| Stability | Stable, well-documented | Experimental, breaking changes |
| Jupyter | Supported (`%%manim` magic) | Limited |
| ffmpeg | Not required (v0.19+) | Required |
| Caching | Supported | Not supported |

**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

```python
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

```python
# 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+)

```python
# 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

```python
# 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`, and number mobjects that may trigger TeX rendering (`Integer`, `DecimalNumber`, `Variable` with math labels).

Use plain text labels instead:

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

### Shapes

```python
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

```python
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

```python
# 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` to any method to animate the change:

```python
# 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

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

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

### Simultaneous Animations

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

## Positioning

### Direction Constants

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

### Positioning Methods

```python
# 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

```python
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

```python
# 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

```bash
# 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` magic command:

```python
%%manim -qm -v WARNING MyScene

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

See `references/advanced.md` for full Jupyter usage details.

## 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

```python
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

```python
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