How to Set Up Manim Integration for Technical Diagrams and Equations in Video-Use

The video-use repository provides a dedicated Manim Video Skill that renders mathematical animations and technical diagrams through a five-stage production pipeline using Manim Community Edition.

Setting up Manim integration in the browser-use/video-use repository enables you to generate publication-quality mathematical animations and technical diagrams from textual prompts. The integration follows a strict workflow—plan, code, render, stitch, audio—that delegates all heavy lifting to the Manim Community Edition rendering backend. This guide walks you through the exact setup steps, project structure, and rendering commands required to produce equation animations and vector graphics.

Prerequisites and Environment Setup

System Requirements

Before creating animations, verify that your environment meets the baseline requirements specified in skills/manim-video/SKILL.md. The Manim Video Skill requires Python 3.10+, the Manim Community Edition package, a LaTeX distribution for math rendering, and ffmpeg for video processing. According to the source documentation, the setup script aborts immediately if any component is missing from your system path.

Verification with setup.sh

Run the automated verification script to confirm your installation:

bash skills/manim-video/scripts/setup.sh

This helper script, located at skills/manim-video/scripts/setup.sh, checks your Python version, confirms that manim, latex, and ffmpeg are accessible on the $PATH, and prints a success message when the environment is ready. As detailed in README.md lines 19-23, this script serves as the gatekeeper for the entire pipeline.

Project Structure and Workflow

The Five-Stage Pipeline

The Manim integration follows a rigid production pipeline documented in skills/manim-video/SKILL.md:

1. Plan – Create a plan.md file containing your narrative outline
2. Code – Write a script.py containing one Scene class per visual segment
3. Render – Execute Manim commands to generate video files
4. Stitch – Use ffmpeg to concatenate scene clips via a concat.txt manifest
5. Audio – Optionally add voice-over using ElevenLabs or Qwen3-TTS

This architecture deliberately avoids browser automation or GPU-specific code, delegating all rendering to Manim’s native backend.

Directory Layout

Each animation project requires a specific scaffold. Create a folder (e.g., my-animation/) containing:

• plan.md – Narrative outline and scene descriptions
• script.py – Single Python file defining your Scene classes
• concat.txt – ffmpeg manifest listing video clips for stitching

As outlined in SKILL.md lines 65-73, this layout separates planning from execution and enables the automated stitching workflow.

Creating Technical Diagrams and Equations

Scene Implementation Standards

Manim objects such as Text, MathTex, and Axes are instantiated within Scene classes. Each scene must inherit from Manim’s Scene base class and implement a construct() method that defines the animation sequence. The repository enforces specific conventions to ensure consistent output across different environments.

Style Constants and Typography

All scenes must use shared color and font constants defined at the top of script.py. According to SKILL.md lines 9-14, the MONO font (specifically "Menlo") is mandatory for all textual elements to prevent kerning glitches in the final render. The standard palette includes:

• BG = "#1C1C1C" – Background color
• PRIMARY = "#58C4DD" – Accent color for diagrams and text
• MONO = "Menlo" – Monospace font for equations and labels

Here is a minimal working example that renders a Fourier Series diagram:

from manim import *

# Shared style constants (see SKILL.md for the full palette)

BG = "#1C1C1C"
PRIMARY = "#58C4DD"
MONO = "Menlo"

class DiagramWithEquation(Scene):
    def construct(self):
        # Set background

        self.camera.background_color = BG

        # Title

        title = Text("Fourier Series", font_size=48,
                     font=MONO, color=PRIMARY, weight=BOLD)
        self.play(Write(title), run_time=1.5)
        self.wait(1.0)

        # Equation (raw string is mandatory)

        eq = MathTex(r"\displaystyle f(x)=\sum_{n=-\infty}^{\infty}"
                     r"c_n e^{i n x}", font_size=36, font=MONO)
        eq.to_edge(DOWN, buff=0.8)
        self.play(FadeIn(eq, shift=UP), run_time=2.0)
        self.wait(2.0)

        # Diagram (simple axes)

        ax = Axes(x_range=[-6, 6, 2], y_range=[-2, 2, 1],
                  axis_config={"color": PRIMARY})
        ax.shift(DOWN*1.5)
        self.play(Create(ax), run_time=1.5)
        self.wait(1.0)

        # Clean up

        self.play(FadeOut(VGroup(title, eq, ax)), run_time=1.0)

Rendering and Production

Draft vs. Production Quality

The skill supports two quality levels controlled via command-line flags. For rapid iteration during development, use the low-quality flag -ql:

manim -ql script.py DiagramWithEquation

For final delivery, switch to high-quality rendering with -qh:

manim -qh script.py DiagramWithEquation

As documented in SKILL.md lines 66-71, the pipeline wraps these commands to process multiple scenes sequentially: manim -ql script.py MyScene1 MyScene2 ….

Stitching Scenes with FFmpeg

When your project contains multiple scenes, create a concat.txt file listing the rendered video paths:

cat > concat.txt <<'EOF'
file 'media/videos/script/480p15/DiagramWithEquation.mp4'
file 'media/videos/script/480p15/AnotherScene.mp4'
EOF

Then concatenate the clips into a final video:

ffmpeg -y -f concat -safe 0 -i concat.txt -c copy final.mp4

This stitching process, described in SKILL.md lines 45-51, enables you to composite complex animations from modular scene components. Optional voice-over tracks can be added post-stitch using ElevenLabs or Qwen3-TTS integrations.

Summary

• The Manim Video Skill in browser-use/video-use provides a complete pipeline for generating mathematical animations and technical diagrams.
• Run skills/manim-video/scripts/setup.sh to verify Python 3.10+, Manim CE, LaTeX, and ffmpeg installation.
• Follow the plan → code → render → stitch → audio workflow using plan.md, script.py, and concat.txt files.
• Use the MONO font constant and shared color palette to avoid rendering artifacts.
• Render drafts with -ql and final productions with -qh, then stitch scenes using ffmpeg concatenation.

Frequently Asked Questions

What versions of Python and Manim are required?

The Manim Video Skill requires Python 3.10 or higher and the Manim Community Edition (installable via pip install manim). The setup.sh script explicitly checks for these versions and aborts if your environment does not meet the requirements documented in SKILL.md lines 25-28.

Why is the MONO font enforced in all scenes?

The MONO font (set to "Menlo") is mandatory to prevent kerning glitches and ensure consistent typography across different operating systems. As specified in SKILL.md lines 9-14, all Text and MathTex objects must use this constant to maintain visual parity in the final render.

How do I combine multiple scenes into a single video?

Create a concat.txt manifest file listing each scene's video path, then run ffmpeg -f concat -safe 0 -i concat.txt -c copy final.mp4. This method, detailed in SKILL.md lines 45-51, concatenates the per-scene clips generated by Manim into a seamless final video without re-encoding.

Can I add voice-over to Manim animations?

Yes. After stitching your video clips with ffmpeg, you can add voice-over using ElevenLabs or Qwen3-TTS integrations. The audio stage is the final step in the five-stage pipeline, allowing you to synchronize narration with your technical diagrams and equation animations.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}