---
name: manim-video
description: Build clear, reusable Manim videos for technical ideas, charts, workflows, system maps, metrics, and product demos. Use when motion and structure matter more than real-life footage. For full video edits, pass the Manim render to the wider ECC video tools.
origin: ECC
---

# Manim Video

Created from the open-source ECC skill. Credit goes to the ECC authors.

Use Manim to explain hard ideas with clear shapes, text, charts, and motion.

## Tools

Use:

- `manim` to build and render scenes
- `ffmpeg` for cuts, audio, format changes, or file size changes
- `video-editing` for the final edit or polish
- `remotion-video-creation` when the final video needs UI, captions, or more motion layers

Check that each needed tool exists before work starts. If a tool is missing, say what is missing and give the install step. Do not call the web or any outside service.

## Default Files

Make:

- One short 16:9 MP4
- One clean poster frame
- One storyboard
- One scene plan
- The Manim source file

Use another size only when the user asks for it.

## Workflow

1. Write one sentence that states the main visual point.
2. Split the idea into 3 to 6 scenes.
3. State what each scene must prove.
4. Write the scene plan before writing code.
5. Set the frame size, colors, fonts, and safe margins.
6. Build the smallest version that can explain the idea.
7. Run a low-quality test render.
8. Fix errors, text cuts, overlaps, and bad timing.
9. Check the full video with sound off.
10. Render at high quality only after the layout and timing are stable.
11. Export a clear poster frame.
12. Use other video tools only when they add clear value.

## Scene Rules

- Make each scene prove one point.
- Show no more than the viewer can read at one time.
- Reveal parts in steps.
- Use motion to show cause, flow, or change.
- Keep title cards short.
- Keep key text inside safe margins.
- Use large text that stays clear on a phone.
- Keep colors easy to tell apart.
- Do not use color as the only way to show meaning.
- Keep the same colors and shapes for the same ideas.
- Leave enough time to read each label.
- Remove motion that does not teach anything.

## Edge Cases

- If the user gives no length, aim for 20 to 45 seconds.
- If the user gives no frame shape, use 16:9.
- For a vertical video, use 9:16 and move key text away from app buttons and captions.
- If the script is too long, shorten the text or add scenes. Do not shrink text until it is hard to read.
- If a chart is too busy, show fewer data points or split it into more scenes.
- If data is missing, use clear sample data and label it as sample data.
- If a font lacks needed letters, use a font that supports those letters.
- If an asset is missing, use a simple shape or text block and note the swap.
- If Manim fails, read the first useful error, fix it, and run the low-quality render again.
- If audio is given, match key moves to the audio. Do not change the audio unless asked.
- If no audio is given, make the video clear without sound.
- If the final file is too large, lower the bit rate with `ffmpeg` after the high-quality render.
- Do not replace user files. Write new files with clear names.

## Network Graph Rules

For social graphs and network tuning:

- Show the current graph first.
- Mark weak or noisy links in a calm, low-focus style.
- Mark strong bridge links in a clear, high-focus style.
- Show warm-path nodes and the goal group.
- Move from the current graph to the better graph in clear steps.
- Add a final scene about how the skill improves itself only when that idea is part of the story.

Start with [assets/network_graph_scene.py](../../../../skills/manim-video/assets/network_graph_scene.py).

Run a test render:

```bash
manim -ql assets/network_graph_scene.py NetworkGraphExplainer
```

Use `-qh` only after the test render looks right:

```bash
manim -qh assets/network_graph_scene.py NetworkGraphExplainer
```

## Concrete Example

User request:

> Make a 30-second video that shows how a cache makes an app faster.

Plan:

1. Show a user asking the app for data.
2. Show the slow trip from the app to the main data store.
3. Add a cache between the app and the data store.
4. Show the first request filling the cache.
5. Show the next request taking the short path.
6. End with a simple time check, such as `800 ms` before and `80 ms` after.

Core visual point:

> A cache saves a nearby copy, so later requests take a shorter path.

Test render:

```bash
manim -ql cache_scene.py CacheExplainer
```

Final render:

```bash
manim -qh cache_scene.py CacheExplainer
```

## Final Response

Return:

- The core visual point
- The storyboard
- The scene plan
- The render plan
- The source file path
- The MP4 path
- The poster frame path
- Any useful final polish steps

## Related Skills

- Use `video-editing` for the final cut and polish.
- Use `remotion-video-creation` for UI, captions, or extra motion layers.
- Use `content-engine` when the video is one part of a larger launch.