# How to Use the Manim Skill for Creating Technical Diagram Animations

> Learn how to use the Manim skill for technical diagram animations. Effortlessly author, render, and embed Manim animations directly from Instagit projects with browser-use/video-use.

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

---

**The Manim skill in the browser-use/video-use repository provides a ready-made integration that lets you author, render, and embed Manim-generated animations directly from Instagit-compatible projects without manual installation.**

The **browser-use/video-use** repository ships with a built-in **Manim skill** that streamlines the creation of mathematical and technical animations. This encapsulated skill eliminates the need for manual environment configuration, allowing you to generate publication-ready diagrams directly from your project workspace. Whether you are visualizing algorithms, mathematical functions, or system architectures, the Manim skill for creating technical diagram animations offers a reproducible pipeline from code to video.

## Understanding the Manim Skill Architecture

### Skill Definition and Metadata

The skill metadata resides in [`skills/manim-video/SKILL.md`](https://github.com/browser-use/video-use/blob/main/skills/manim-video/SKILL.md), which declares the command-line entry point (`manim`), exposed files, and optional environment variables like `MANIM_RENDER_QUALITY`. This configuration file tells Instagit how to invoke the renderer and what parameters to pass through to the underlying Manim process.

### Reference Documentation Structure

The `skills/manim-video/references/` directory contains comprehensive markdown guides for animation development:

- [`scene-planning.md`](https://github.com/browser-use/video-use/blob/main/scene-planning.md) – Breaks down narrative structure into separate `Scene` classes
- [`mobjects.md`](https://github.com/browser-use/video-use/blob/main/mobjects.md) – Documents building blocks including shapes, graphs, and equations  
- [`animations.md`](https://github.com/browser-use/video-use/blob/main/animations.md) – Explains time-based property transformations
- [`updaters-and-trackers.md`](https://github.com/browser-use/video-use/blob/main/updaters-and-trackers.md) – Covers live tracking and dynamic updates
- [`rendering.md`](https://github.com/browser-use/video-use/blob/main/rendering.md) – Details CLI flags for resolution, framerate, and output format control
- [`production-quality.md`](https://github.com/browser-use/video-use/blob/main/production-quality.md) – Provides post-processing guidance for professional output

## Execution Pipeline and Rendering

When you invoke the skill via `instagit run manim-video`, the repository's [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) initiates the execution pipeline. The process reads your [`script.py`](https://github.com/browser-use/video-use/blob/main/script.py) (or directory of scripts) from the project root, executes `manim` with the configured quality settings, and stores the resulting video file in the `output/` folder. This abstraction handles virtual environment management and dependency resolution automatically, bridging Instagit skill calls to the actual `manim` process.

## Environment Setup and Dependencies

You do not need to install Manim manually. The [`skills/manim-video/scripts/setup.sh`](https://github.com/browser-use/video-use/blob/main/skills/manim-video/scripts/setup.sh) script automatically provisions a virtual environment with the correct Manim version and optional dependencies like `numpy` or `pandas` for data-driven graphics. This encapsulation ensures reproducible builds across different development machines.

## Creating Technical Diagram Animations

### Basic Scene Setup

Create a [`script.py`](https://github.com/browser-use/video-use/blob/main/script.py) file in your project root with a simple Scene class:

```python
from manim import *

class HelloWorld(Scene):
    def construct(self):
        text = Text("Hello, Manim!").scale(2)
        self.play(Write(text))
        self.wait(2)

```

Run the skill:

```bash
instagit run manim-video

```

The command executes `manim -ql script.py HelloWorld` behind the scenes, writing `output/HelloWorld.mp4` for embedding in markdown reports.

### Complex Diagrams with Graphs and Equations

For technical diagrams combining axes, functions, and mathematical notation:

```python
from manim import *

class Diagram(Scene):
    def construct(self):
        # Axes

        axes = Axes(x_range=[0, 5], y_range=[0, 10])
        graph = axes.plot(lambda x: 2*x + 1, color=BLUE)
        equation = MathTex("y = 2x + 1").next_to(axes, UP)

        # Animate

        self.play(Create(axes), Write(equation))
        self.play(Create(graph), run_time=3)
        self.wait()

```

Execute with quality flags:

```bash
instagit run manim-video --quality high

```

The `MANIM_RENDER_QUALITY` environment variable is used internally to control the render preset.

### Real-time Animations with Updaters

Use updaters for dynamic content that refreshes during animation:

```python
from manim import *

class TrackerDemo(Scene):
    def construct(self):
        axes = Axes()
        dot = Dot().move_to(axes.c2p(0, 0))
        label = always_redraw(
            lambda: MathTex(f"{dot.get_center()[0]:.2f}").next_to(dot, UP)
        )

        self.add(dot, label)
        self.play(dot.animate.move_to(axes.c2p(4, 8)), run_time=4, rate_func=linear)
        self.wait()

```

The `always_redraw` updater automatically refreshes the label as the dot moves, creating live-updating technical visualizations.

## Production Quality and Post-Processing

The [`production-quality.md`](https://github.com/browser-use/video-use/blob/main/production-quality.md) reference suggests post-processing steps including ffmpeg compression, subtitle addition, and stitching multiple scene outputs together. Output files in `output/` can be directly referenced in markdown reports or combined with other footage in your Instagit workflow.

## Summary

- The **Manim skill** is defined in [`skills/manim-video/SKILL.md`](https://github.com/browser-use/video-use/blob/main/skills/manim-video/SKILL.md) and executed through [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py)
- **Automatic setup** via [`skills/manim-video/scripts/setup.sh`](https://github.com/browser-use/video-use/blob/main/skills/manim-video/scripts/setup.sh) eliminates manual dependency management
- Place **Python scripts** in the project root and run `instagit run manim-video` to generate videos
- **Reference documentation** in `skills/manim-video/references/` covers scenes, mobjects, animations, and rendering options
- Output videos are stored in the `output/` directory, ready for embedding or post-processing

## Frequently Asked Questions

### Do I need to install Manim separately?

No. The skill encapsulates all dependencies. The [`setup.sh`](https://github.com/browser-use/video-use/blob/main/setup.sh) script in `skills/manim-video/scripts/` automatically provisions a virtual environment with the correct Manim version and any required extras like NumPy or Pandas.

### How do I configure render quality?

Set the `MANIM_RENDER_QUALITY` environment variable or pass `--quality` flags to the Instagit command. The [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/SKILL.md) file defines these configuration options, and [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) passes them to the Manim CLI during execution.

### Where are the output videos stored?

Rendered animations are automatically placed in the `output/` folder at your project root. You can reference these files directly in markdown using standard image/video syntax, such as `![Description](output/Filename.mp4)`.

### Can I use external libraries like NumPy for data-driven animations?

Yes. The [`setup.sh`](https://github.com/browser-use/video-use/blob/main/setup.sh) script installs common scientific Python packages alongside Manim. You can import NumPy, Pandas, or other libraries directly in your [`script.py`](https://github.com/browser-use/video-use/blob/main/script.py) files to generate data-driven technical diagrams and animations.