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

> Integrate Manim with video-use to create stunning technical diagrams and mathematical animations. Follow our guide to leverage Manim Community Edition for your video production pipeline.

- Repository: [Browser Use/video-use](https://github.com/browser-use/video-use)
- Tags: how-to-guide
- Published: 2026-07-03

---

**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`](https://github.com/browser-use/video-use/blob/main/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
bash skills/manim-video/scripts/setup.sh

```

This helper script, located at [`skills/manim-video/scripts/setup.sh`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/skills/manim-video/SKILL.md):

1. **Plan** – Create a [`plan.md`](https://github.com/browser-use/video-use/blob/main/plan.md) file containing your narrative outline
2. **Code** – Write a [`script.py`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/plan.md) – Narrative outline and scene descriptions
- [`script.py`](https://github.com/browser-use/video-use/blob/main/script.py) – Single Python file defining your `Scene` classes
- [`concat.txt`](https://github.com/browser-use/video-use/blob/main/concat.txt) – ffmpeg manifest listing video clips for stitching

As outlined in [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/script.py). According to [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/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:

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

```bash
manim -ql script.py DiagramWithEquation

```

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

```bash
manim -qh script.py DiagramWithEquation

```

As documented in [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/concat.txt) file listing the rendered video paths:

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

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

```

This stitching process, described in [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/plan.md), [`script.py`](https://github.com/browser-use/video-use/blob/main/script.py), and [`concat.txt`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/setup.sh) script explicitly checks for these versions and aborts if your environment does not meet the requirements documented in [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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.