// Generate diagram and animation videos from natural language descriptions using Manim. Outputs MP4 (default) or GIF on request.
| name | manimate |
| description | Generate diagram and animation videos from natural language descriptions using Manim. Outputs MP4 (default) or GIF on request. |
Generate diagram and animation videos from natural language descriptions using Manim. Outputs MP4 video by default; GIF available on request.
/manimate "explain how binary search works"
/manimate "show the Pythagorean theorem proof"
/manimate "visualize bubble sort step by step"
When the user invokes /manimate, execute these 12 steps in order:
Parse the user's prompt and infer rendering parameters:
| Parameter | Range | Default | How to infer |
|---|---|---|---|
scenes | 1-6 | 2 | Count distinct concepts/steps/phases in the prompt |
quality | l/m/h | h | Default high; use medium for quick drafts |
format | gif/mp4/both | mp4 | Default mp4; use gif or both only if user explicitly requests GIF |
style | educational/minimal/cinematic | educational | Infer from the tone/subject |
duration_per_scene | 5-15s | 8 | Longer for complex concepts, shorter for simple transitions |
Write to $WORK_DIR/params.json:
{
"prompt": "explain how binary search works",
"scenes": 3,
"quality": "h",
"format": "mp4",
"style": "educational",
"duration_per_scene": 8
}
Write $WORK_DIR/manim.cfg:
[CLI]
quality = high_quality
format = mp4
renderer = cairo
disable_caching = True
[output]
media_dir = media
video_dir = {media_dir}/videos
images_dir = {media_dir}/images
Why
renderer = cairo: Cairo is the safe default for headless/CI environments. It requires no GPU, no display server, and no OpenGL context.
Verify dependencies and set pipeline-wide capability flags:
# Required: Python 3.8+
python3 --version 2>/dev/null || { echo "python3 not found"; exit 1; }
# Required: ManimCE
python3 -c "import manim; print(f'manim {manim.__version__}')" 2>/dev/null || {
echo "manim not found. Install: pip install manim"
exit 1
}
# Required: ffmpeg
command -v ffmpeg >/dev/null 2>&1 || { echo "ffmpeg not found"; exit 1; }
# Optional: LaTeX + dvisvgm
LATEX_AVAILABLE=false
if command -v latex >/dev/null 2>&1 && command -v dvisvgm >/dev/null 2>&1; then
LATEX_AVAILABLE=true
echo "LaTeX + dvisvgm available — MathTex/Tex enabled"
else
echo "LaTeX or dvisvgm not found. Falling back to Text-only mode."
echo " Install: brew install --cask mactex-no-gui (macOS) or apt install texlive-full (Linux)"
fi
# Detect timeout command (used for render timeouts in Step 10)
TIMEOUT_CMD=""
if command -v gtimeout >/dev/null 2>&1; then
TIMEOUT_CMD="gtimeout"
elif command -v timeout >/dev/null 2>&1; then
TIMEOUT_CMD="timeout"
else
echo "Neither timeout nor gtimeout found. Render hangs won't be caught."
fi
Create a run-scoped working directory to allow concurrent pipeline executions:
WORK_DIR=".manimate-$(date +%s)-$$"
mkdir -p "$WORK_DIR"/scenes "$WORK_DIR"/assets "$WORK_DIR"/lastframes "$WORK_DIR"/output
echo "Working directory: $WORK_DIR"
WORK_DIRis the pipeline root for this run. All subsequent steps reference$WORK_DIRinstead of a hardcoded.manimatepath. This prevents data loss when multiple/manimateinvocations run concurrently.
Pipeline-wide LATEX_AVAILABLE flag: When
false, scene code must NOT use MathTex or Tex — use Text() for all text, including math expressions. Render equations as Unicode or ASCII.
Break the prompt into scenes. Each scene specifies visual elements, animations, and narrative arc.
Default to SVG icons for every real-world concept. For each scene, identify concepts that can be icons and add them to asset_manifest. Every video should have at least 2 SVG assets — if the manifest is empty, revisit the decomposition.
Use basic Manim shapes only for: array cells, flowchart boxes, graphs/axes, code blocks, containers, math expressions. Everything else gets an SVG.
Write $WORK_DIR/story.json with a top-level asset_manifest and per-scene svg_assets referencing manifest keys:
{
"title": "How Binary Search Works",
"asset_manifest": {
"magnifier_icon": {
"description": "Magnifying glass with circular lens and angled handle",
"viewbox": "0 0 64 64",
"primary_color_token": "ACCENT",
"used_in": [1]
},
"checkmark_icon": {
"description": "Bold checkmark inside a rounded square",
"viewbox": "0 0 64 64",
"primary_color_token": "SUCCESS",
"used_in": [3]
}
},
"scenes": [
{
"id": 1,
"title": "The Problem",
"description": "Show a sorted array of numbers. Highlight that we need to find a target value.",
"visual_elements": ["sorted array of boxes with numbers", "target value highlighted"],
"animations": ["Create array", "Highlight target", "Write question text"],
"svg_assets": ["magnifier_icon"],
"scene_class": "TheProblem",
"duration": 8,
"template": "basic",
"text_elements": ["title: 3 words", "description: 12 words"],
"estimated_reading_pauses": 6.0,
"continuity_in": null,
"continuity_out": "Array remains visible, target highlighted"
}
],
"shared_style": {
"NOTE": "LOCKED — copy these values verbatim into shared.py. Do NOT change any hex code.",
"bg_color": "#2a2a3a",
"surface_color": "#3a3a4a",
"border_color": "#4a4a5a",
"primary_color": "#ff3366",
"accent_color": "#33ccff",
"highlight_color": "#ffcc00",
"success_color": "#66ff66",
"negative_color": "#ff4444",
"text_color": "#ffffff",
"muted_color": "#8a8aaa",
"font_heading": "Helvetica Neue",
"font_body": "Helvetica Neue",
"font_code": "Monaco",
"font_size_title": 44,
"font_size_body": 26
},
"latex_available": true
}
asset_manifest schema: Each key is an asset ID (snake_case). Fields:
description — what the icon depicts, enough detail for accurate SVG generationviewbox — SVG viewBox (tall: "0 0 80 100", square: "0 0 64 64", wide: "0 0 100 60")primary_color_token — which palette token to use as the main fill (PRIMARY, ACCENT, HIGHLIGHT, SUCCESS, NEGATIVE)used_in — list of scene IDs that use this assetPer-scene svg_assets is a list of asset IDs from the manifest (not freeform hints). If a scene needs no SVG assets, use an empty list [].
Asset density target: Aim for 1-2 SVG assets per scene, 3-6 per video. Scenes with SVG icons are dramatically more engaging than scenes with only basic shapes.
If no scenes need SVG assets (e.g., a pure math derivation), set asset_manifest to {} and all svg_assets to []. Steps 6-7 will no-op.
Continuity rules:
continuity_out of scene N must match continuity_in of scene N+1shared_style)Pacing rules:
text_elements lists each text block with its approximate word count — used to calculate reading pausesestimated_reading_pauses is the total seconds of self.wait() needed for reading time (sum of max(2, words / 3) for each text block)duration must be >= animation time + estimated_reading_pauses — increase duration if needed to fit reading timeself.wait(max(2, word_count / 3)) after every text appearanceBefore generating any code, present the story outline to the user for review and approval.
Build a readable summary from $WORK_DIR/story.json:
Scene Outline for: "{title}"
Scene 1: {scene_title}
{description}
Key visuals: {visual_elements joined as comma-separated list}
Duration: {duration}s
Scene 2: {scene_title}
{description}
Key visuals: {visual_elements joined as comma-separated list}
Duration: {duration}s
...
SVG Assets to generate:
- magnifier_icon
Icon: Magnifying glass with circular lens and angled handle
Color: ACCENT (#33ccff)
Used in: Scene 1
- checkmark_icon
Icon: Bold checkmark inside a rounded square
Color: SUCCESS (#66ff66)
Used in: Scene 3
Total duration: {sum of all durations}s
Output format: MP4 (default). Would you like GIF, or both?
Present this outline to the user and ask:
Does this outline look good? You can:
1. Approve and continue
2. Request changes (add/remove/reorder scenes, adjust descriptions, change durations)
3. Change output format (mp4 / gif / both)
⛔ HARD STOP — Do NOT proceed past this point until the user explicitly approves.
After presenting the outline, STOP. Do not generate any code, write any files, or start any subsequent steps. Wait for the user to respond. This is a mandatory approval gate.
Revision loop:
$WORK_DIR/story.json accordingly (add/remove scenes, edit descriptions, adjust durations, etc.) and re-present the outline.$WORK_DIR/params.json (format field) and $WORK_DIR/manim.cfg to match.Once — and ONLY once — the user explicitly approves, proceed to Step 5.
Generate $WORK_DIR/shared.py — a single module containing palette constants, helpers, and asset loading that all scenes import. This eliminates ~50 lines of duplicated boilerplate from each scene file.
Write $WORK_DIR/shared.py by copying the code block below VERBATIM. Do NOT change ANY hex value — not even the background tones (BG, SURFACE, BORDER). The exact hex codes below are the Creative Chaos brand palette and must appear character-for-character in the generated file:
from manim import *
import tempfile, os
# ── Creative Chaos Dark — LOCKED palette, do not modify ──
BG = "#2a2a3a"
SURFACE = "#3a3a4a"
BORDER = "#4a4a5a"
PRIMARY = "#ff3366"
ACCENT = "#33ccff"
HIGHLIGHT = "#ffcc00"
SUCCESS = "#66ff66"
NEGATIVE = "#ff4444"
TEXT_CLR = "#ffffff"
TEXT_DIM = "#8a8aaa"
# ── Asset directory ──
ASSET_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "assets")
def svg_icon(svg_string, scale=1.0):
"""Write inline SVG to temp file and load as SVGMobject.
Use for rare one-off SVGs (under 5 lines). Prefer load_asset() for validated assets."""
tmpdir = tempfile.mkdtemp()
path = os.path.join(tmpdir, "icon.svg")
with open(path, "w") as f:
f.write(svg_string)
return SVGMobject(path).scale(scale)
def load_asset(asset_id, scale=1.0):
"""Load a validated SVG asset from the assets directory."""
path = os.path.join(ASSET_DIR, f"{asset_id}.svg")
if not os.path.exists(path):
raise FileNotFoundError(f"Asset not found: {path}")
return SVGMobject(path).scale(scale)
def tw(text_str):
"""Calculate reading time wait duration: max(2, word_count / 3)."""
return max(2, len(text_str.split()) / 3)
def dot_grid():
"""Create the signature Creative Chaos dot grid background."""
return VGroup(*[
Dot([x, y, 0], radius=0.02, fill_opacity=0.08, color=TEXT_CLR)
for x in range(-7, 8) for y in range(-4, 5)
])
def setup_scene(scene):
"""Set background color and add dot grid. Call at the start of construct()."""
scene.camera.background_color = BG
scene.add(dot_grid())
def title_card(scene, text, wait=2.0):
"""Show title with signature underline, then move to corner.
Args:
scene: the Scene instance (pass `self` from construct)
text: the title string
wait: seconds to display before moving to corner (default 2.0)
Returns:
title Mobject (now in the UL corner at scale 0.55)
"""
title = Text(text, font="Helvetica Neue", font_size=44, color=TEXT_CLR, weight=BOLD)
underline = Line(
title.get_left() + DOWN * 0.35,
title.get_right() + DOWN * 0.35,
color=PRIMARY, stroke_width=2.5,
)
scene.play(
FadeIn(title, shift=UP * 0.4),
GrowFromCenter(underline),
run_time=0.7,
)
scene.wait(wait)
scene.play(
title.animate.scale(0.55).to_corner(UL, buff=0.5),
FadeOut(underline, run_time=0.3),
run_time=0.5,
)
return title
def make_node(label, color=None, w=2.5, h=0.8):
"""Create a labeled rounded rectangle node. Box auto-sizes to fit text."""
if color is None:
color = PRIMARY
text = Text(label, font="Helvetica Neue", font_size=22, color=TEXT_CLR)
box_w = max(w, text.width + 0.6)
box_h = max(h, text.height + 0.4)
box = RoundedRectangle(
corner_radius=0.15, width=box_w, height=box_h,
fill_color=SURFACE, fill_opacity=1,
stroke_color=color, stroke_width=1.5,
)
text.move_to(box)
return VGroup(box, text)
def progress_bar(width=8, height=0.4, fill_color=None):
"""Create a progress bar. Returns VGroup(track, fill) with fill at 0%.
Animate with: self.play(set_progress(bar, 0.75), run_time=1.0)"""
if fill_color is None:
fill_color = PRIMARY
pad = height * 0.12
track = RoundedRectangle(
corner_radius=height / 2, width=width, height=height,
fill_color=SURFACE, fill_opacity=1,
stroke_color=BORDER, stroke_width=1.5,
)
fill = RoundedRectangle(
corner_radius=max(0.05, (height - 2 * pad) / 2),
width=pad, height=height - 2 * pad,
fill_color=fill_color, fill_opacity=1, stroke_width=0,
)
fill.align_to(track, LEFT).shift(RIGHT * pad)
return VGroup(track, fill)
def set_progress(bar, pct):
"""Return animation for bar fill to reach pct (0.0-1.0).
Rebuilds the fill shape each frame to avoid .animate vertex interpolation artifacts."""
track, fill = bar[0], bar[1]
pad = track.height * 0.12
start_w = fill.width
target_w = max(pad, (track.width - 2 * pad) * max(0.0, min(1.0, pct)))
cr = max(0.05, (track.height - 2 * pad) / 2)
fc = fill.get_fill_color()
def _update(mob, alpha):
w = interpolate(start_w, target_w, alpha)
mob.become(RoundedRectangle(
corner_radius=cr, width=w, height=track.height - 2 * pad,
fill_color=fc, fill_opacity=1, stroke_width=0,
))
mob.move_to([track.get_left()[0] + pad + w / 2, track.get_center()[1], 0])
return UpdateFromAlphaFunc(fill, _update)
def make_cell(value, color=None, w=0.7, h=0.7):
"""Create a data cell — sharp-cornered square with a number inside.
Use for array elements, grid data, table cells."""
if color is None:
color = PRIMARY
box = Square(
side_length=max(w, h),
fill_color=SURFACE, fill_opacity=0.6,
stroke_color=color, stroke_width=1.5,
)
text = Text(str(value), font="Monaco", font_size=22, color=TEXT_CLR)
text.move_to(box)
return VGroup(box, text)
def make_array(values, color=None, cell_w=0.7, cell_h=0.7, buff=0.05):
"""Create a horizontal array of data cells."""
if color is None:
color = PRIMARY
cells = VGroup(*[make_cell(v, color, cell_w, cell_h) for v in values])
cells.arrange(RIGHT, buff=buff)
return cells
IMPORTANT — PALETTE IS LOCKED: Every hex value above is final. BG must be #2a2a3a, SURFACE must be #3a3a4a, BORDER must be #4a4a5a. Do NOT substitute theme-specific or topic-specific colors. The only exception is the light theme palette from the style guide. If the generated shared.py contains any hex value not listed above, it is wrong — fix it before proceeding.
Semantic aliases are allowed: After the palette block, you may add project-specific aliases that map to palette tokens (e.g., US_COLOR = ACCENT, SENDER_COLOR = PRIMARY). These improve scene code readability without introducing custom hex values. Never assign a raw hex code to an alias.
Scene files import via:
import sys, os
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
from shared import *
This works because render runs from $WORK_DIR as CWD (cd "$WORK_DIR" && manim render scenes/scene_NN.py).
For each entry in asset_manifest from story.json, generate a validated SVG file.
If asset_manifest is empty {}, pause — are there real-world concepts that could use icons? Only skip for purely mathematical/abstract videos. Otherwise revisit Step 3.
For each asset in the manifest:
description, viewbox, and primary_color_token from the manifest entrylibrary/style-guide.md<text> elements, NO stroke-dasharrayshared_style (e.g., #ff3366 for PRIMARY, not Manim color names)stroke="#ffffff" stroke-width="2"stroke-width="1.5"stroke-linecap="round" stroke-linejoin="round"$WORK_DIR/assets/{asset_id}.svg# Verify each asset file was written
for ASSET_ID in $(python3 -c "
import json
m = json.load(open('$WORK_DIR/story.json'))['asset_manifest']
print(' '.join(m.keys()))
"); do
[ -f "$WORK_DIR/assets/${ASSET_ID}.svg" ] || echo "Missing asset: ${ASSET_ID}"
done
Verify all generated SVG assets render correctly in Manim before using them in scenes.
If asset_manifest is empty, skip this step.
Procedure:
$WORK_DIR/scenes/_asset_validation.py:import sys, os
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
from shared import *
class AssetValidation(Scene):
def construct(self):
setup_scene(self)
title = Text("Asset Validation", font="Helvetica Neue", font_size=32,
color=TEXT_CLR, weight=BOLD)
title.to_edge(UP, buff=0.5)
self.add(title)
assets = []
# One VGroup(icon, label) per asset — filled dynamically
# ASSET_ENTRIES_PLACEHOLDER
if assets:
grid = VGroup(*assets).arrange_in_grid(
rows=max(1, (len(assets) + 2) // 3),
cols=min(3, len(assets)),
buff=1.0,
)
grid.move_to(DOWN * 0.3)
self.add(grid)
self.wait(1)
Fill in the asset loading code for each manifest entry (load via load_asset(), add a label below each icon)
Render the validation scene as a still frame:
cd "$WORK_DIR" && manim render -ql -s --renderer=cairo --disable_caching \
scenes/_asset_validation.py AssetValidation 2>/dev/null
VALIDATION_PNG=$(find "$WORK_DIR"/media/images -name "AssetValidation*.png" 2>/dev/null | head -1)
Inspect the grid image. For each asset, verify:
primary_color_token)If any asset fails: regenerate its SVG file, re-render the grid (max 2 retries per asset)
Clean up: rm "$WORK_DIR/scenes/_asset_validation.py"
Generate each scene file. Scenes import from shared.py and load assets via load_asset() — no inlined palette constants or helper functions.
For each scene N (sequentially):
Read the scene spec from $WORK_DIR/story.json — extract the scene entry, shared_style, and latex_available flag.
Read the relevant library files based on scene template type:
| Scene template | Always read | Conditionally read |
|---|---|---|
| All types | library/cheatsheet.md, library/style-guide.md, library/common-errors.md | — |
basic | — | library/animations.md |
math | — | library/animations.md, library/text-and-math.md |
graph | — | library/animations.md |
code | — | library/text-and-math.md |
Read the template from templates/{template}.py (e.g., templates/basic.py).
Write the scene file to $WORK_DIR/scenes/scene_NN.py following these rules:
import sys, os / sys.path.insert(...) / from shared import *{scene_class} (from story.json)construct(self) methodsetup_scene(self) at the start of construct() (sets BG + dot grid)title_card(self, "...") for the title entranceload_asset(asset_id, scale) for SVG icons from the manifestsvg_icon() only for rare one-off inline SVGs (under 5 SVG lines)tw(text_string) for reading time: self.wait(tw("your text here"))make_node(label, color) for diagram nodeslatex_available is false: do NOT use MathTex or Tex — use Text() for all text including math. Render equations as Unicode. If true: use MathTex (not Tex) for math expressions.Layout Rules (CRITICAL — prevents overlapping elements):
next_to(), arrange(), arrange_in_grid() for spatially-related elements — NOT absolute coordinatesVGroup() before positioning — position the group, not individual itemsleft_panel.move_to(LEFT * 3))Text Pacing Rules (CRITICAL — text must be readable):
self.wait(tw("your text content")) — this gives ~180 WPM reading speed with a 2-second minimum.self.wait() after text — always calculate from word countself.wait(0.5) or self.wait(1) after text that has more than 3 wordsself.wait(1.5) as a transition pauseVisual Polish Rules (CRITICAL — prevents rendering issues):
TEXT_CLR. Use TEXT_DIM ONLY for captions (font_size 16) and axis labels.max(desired_w, text.width + 0.6). Or use make_node() which auto-sizes. NEVER hard-code a container width without checking the text.progress_bar() and set_progress() from shared.py. NEVER animate a raw Rectangle's width for progress — it will overflow the track.Expected scene size: 80-130 lines (vs 180-230 with inlined constants).
FILE="$WORK_DIR/scenes/scene_$(printf "%02d" $N).py"
SCENE_CLASS="<scene_class from story.json>"
python3 -c "compile(open('$FILE').read(), '$FILE', 'exec')" 2>/dev/null || {
echo "Syntax error in $FILE — fix before rendering"
}
python3 -c "
import ast, sys
tree = ast.parse(open('$FILE').read())
classes = [n.name for n in ast.walk(tree) if isinstance(n, ast.ClassDef)]
if '$SCENE_CLASS' not in classes:
print(f'$FILE does not define class $SCENE_CLASS (found: {classes})')
sys.exit(1)
print('$FILE defines $SCENE_CLASS')
"
If validation fails (syntax error or wrong class name), fix the file immediately and re-validate before moving on.
After writing each scene, validate the layout visually. Scenes end with FadeOut(*self.mobjects) which makes the last frame blank — so we extract a mid-animation frame instead.
For each scene N:
cd "$WORK_DIR" && manim render -ql --renderer=cairo --disable_caching \
scenes/scene_$(printf "%02d" $N).py $SCENE_CLASS 2>/dev/null
SCENE_FILE="scene_$(printf "%02d" $N)"
VIDEO_PATH=$(find "$WORK_DIR"/media/videos/${SCENE_FILE} -name "${SCENE_CLASS}.mp4" 2>/dev/null | head -1)
ffmpeg -i "$VIDEO_PATH" \
-vf "select=eq(n\,30)" -vframes 1 -y \
"$WORK_DIR"/lastframes/${SCENE_FILE}_layout.png 2>/dev/null
| Check | Pass condition |
|---|---|
| Text readability | No text cut off or extending beyond frame |
| No overlaps | All elements visible, no unintended overlap |
| Asset rendering | SVG icons recognizable and properly colored |
| Safe margins | Nothing within 0.8 units of frame edge |
-ql, re-inspect (max 2 retries per scene)Cost: ~5-10s per scene for a
-qlrender vs 60-180s for a wasted full render. This catches layout issues early.
For each scene, render at the target quality. If rendering fails, read the error output, fix the scene file directly, and retry. Max 3 attempts per scene.
Output path resolution: Manim writes to structured subdirs. After each render, resolve the actual output path.
For each scene N, run the render command:
SCENE_FILE="scene_$(printf "%02d" $N)"
SCENE_CLASS="<scene_class from story.json>"
RENDER_LOG=$(mktemp)
RENDER_CMD="manim render scenes/${SCENE_FILE}.py $SCENE_CLASS \
--renderer=cairo -qh --format=mp4 --disable_caching"
if [ -n "$TIMEOUT_CMD" ]; then
RENDER_CMD="$TIMEOUT_CMD 180 $RENDER_CMD"
fi
cd "$WORK_DIR" && eval $RENDER_CMD 2>"$RENDER_LOG"
RENDER_EXIT=$?
cd ..
On success: locate the output MP4:
QUALITY_SUBDIR="1080p60" # matches -qh
EXPECTED_PATH="$WORK_DIR/media/videos/${SCENE_FILE}/${QUALITY_SUBDIR}/${SCENE_CLASS}.mp4"
if [ ! -f "$EXPECTED_PATH" ]; then
FOUND_PATH=$(find "$WORK_DIR"/media/videos -name "${SCENE_CLASS}.mp4" 2>/dev/null | head -1)
fi
On failure (up to 3 retries):
library/common-errors.md{scene_class}Run the render script to concatenate scene videos and convert to GIF:
bash "scripts/render.sh" \
--scenes-dir "$WORK_DIR"/scenes \
--media-dir "$WORK_DIR"/media \
--output-dir "$WORK_DIR"/output \
--format "$FORMAT" \
--story-file "$WORK_DIR"/story.json
scripts/render.shis relative to the skill directory.$FORMATcomes from$WORK_DIR/params.json.
Animation complete!
Prompt: "explain how binary search works"
Scenes: 3 (all rendered successfully)
Duration: 28s (8s + 12s + 8s)
Quality: 1080p @ 60fps
Renderer: cairo
Assets: 2 SVGs generated and validated (magnifier_icon, checkmark_icon)
Layout validation: 3/3 scenes passed
Output:
MP4: $WORK_DIR/output/animation.mp4 (1.2MB)
GIF: $WORK_DIR/output/animation.gif (3.4MB)
Layout previews: $WORK_DIR/lastframes/
Read these library files before writing each scene (see Step 8 for which files apply per scene type):
| File | Purpose | Used by |
|---|---|---|
library/cheatsheet.md | Manim API quick reference | All scene types |
library/style-guide.md | Color palette, font sizes, timing, SVG style rules, layout best practices | All scene types |
library/animations.md | Animation patterns with code | basic, math, graph |
library/text-and-math.md | Text, MathTex, Code patterns | math, code |
library/common-errors.md | Known pitfalls and fixes | All scene types |
from manim import * (never manimlib). Cairo renderer for headless safety..py file for isolated error recovery.shared.py contains palette constants, helpers (setup_scene, title_card, dot_grid, tw, make_node, progress_bar, set_progress), and asset loading (load_asset). Scenes import, not copy.load_asset(), not inline SVG strings.from shared import * for palette, helpers, and asset loading. No inlined constants.Text() instead of MathTex().