# How to Render LaTeX Equations and Text Using TexMobject in Manim Animations

> Learn to render LaTeX equations and text in Manim animations using TexMobject. Easily integrate mathematical expressions and styled text into your visualizations for dynamic educational content.

- Repository: [Grant Sanderson/manim](https://github.com/3b1b/manim)
- Tags: how-to-guide
- Published: 2026-02-28

---

**Manim renders LaTeX by converting strings to SVG images through external compilers, wrapping them in the `Tex` class that handles scaling, coloring, and symbol isolation for animation.**

In the 3b1b/manim library, mathematical typesetting is powered by the `Tex` class (historically referred to as TexMobject) defined in [`manimlib/mobject/svg/tex_mobject.py`](https://github.com/3b1b/manim/blob/main/manimlib/mobject/svg/tex_mobject.py). This Mobject compiles LaTeX source into scalable vector graphics, enabling precise control over individual symbols and seamless integration with Manim's animation system.

## The LaTeX-to-SVG Architecture

Manim's LaTeX rendering relies on three coordinated components that transform raw strings into animatable Mobjects.

### Core Components

- **`Tex` class** ([`manimlib/mobject/svg/tex_mobject.py`](https://github.com/3b1b/manim/blob/main/manimlib/mobject/svg/tex_mobject.py), lines 35-78): The high-level interface that parses LaTeX strings, manages color mappings, and scales the resulting SVG to match Manim's coordinate system.

- **`latex_to_svg`** ([`manimlib/utils/tex_file_writing.py`](https://github.com/3b1b/manim/blob/main/manimlib/utils/tex_file_writing.py), lines 40-82): The low-level utility that orchestrates the external compilation pipeline, converting LaTeX → DVI → SVG.

- **[`tex_templates.yml`](https://github.com/3b1b/manim/blob/main/tex_templates.yml)** ([`manimlib/tex_templates.yml`](https://github.com/3b1b/manim/blob/main/manimlib/tex_templates.yml)): Configuration file defining compiler presets (e.g., `default`, `xelatex`, `tikz`) and preamble settings.

### The Compilation Pipeline

When you instantiate `Tex(r"E=mc^2")`, the following sequence occurs:

1. **String Processing**: The `Tex.__init__` method (lines 38-79) stores the raw LaTeX string and merges the `tex_to_color_map` dictionary with legacy `t2c` arguments (line 67).

2. **SVG Generation**: The method `get_svg_string_by_content` forwards the string to `latex_to_svg` (lines 81-83), which builds a temporary LaTeX document via `get_full_tex`.

3. **External Compilation**: `latex_to_svg` (lines 50-82) selects a compiler and preamble from `get_tex_config`, writes the temporary file, invokes the LaTeX compiler and `dvisvgm`, and returns the SVG string.

4. **Scaling Calibration**: The resulting Mobject is scaled by `get_tex_mob_scale_factor() * font_size` (lines 77-78). This factor is computed by rendering a reference "0" and measuring its height, ensuring a `font_size` of 48 yields a height of 1 Manim unit.

5. **Color Injection**: The `set_color_by_tex_to_color_map` method (line 76) parses the LaTeX source to find matching spans and injects `\color[RGB]{…}` commands via `get_color_command` and `get_command_string`.

## Configuring Templates and Unicode Support

The `template` argument (line 44) allows switching between LaTeX engines without modifying source code. This is essential for Unicode support or TikZ graphics.

```python
from manim import *

class UnicodeExample(Scene):
    def construct(self):
        text = Tex(
            r"\text{Привет, мир!}",
            template="xelatex"  # Uses xelatex compiler from tex_templates.yml

        )
        self.play(Write(text))
        self.wait()

```

The [`tex_templates.yml`](https://github.com/3b1b/manim/blob/main/tex_templates.yml) file defines the compiler path, preamble packages, and font settings for each template name.

## Isolating Symbols for Granular Animation

The `isolate` argument (lines 51-56) marks specific substrings as separate sub-Mobjects, enabling individual symbol animation.

```python
class IsolateExample(Scene):
    def construct(self):
        expr = Tex(r"x^2 + y^2 = r^2", isolate=["x", "y", "r"])
        x, y, r = expr.get_parts_by_tex(["x", "y", "r"])
        
        self.play(Write(expr))
        self.play(
            x.animate.shift(UP),
            y.animate.shift(LEFT),
            r.animate.scale(2)
        )
        self.wait()

```

Each isolated part becomes its own sub-Mobject accessible via `get_parts_by_tex`, allowing targeted transformations.

## Coloring Mathematical Expressions

Use `tex_to_color_map` to apply colors to specific symbols without manual index tracking. The class automatically injects color commands into the generated LaTeX.

```python
class ColorMapExample(Scene):
    def construct(self):
        formula = Tex(
            r"\frac{a}{b} = c",
            tex_to_color_map={"a": RED, "b": BLUE, "c": GREEN}
        )
        self.play(FadeIn(formula))
        self.wait()

```

## Performance Optimization Through Caching

Both `latex_to_svg` and `get_tex_mob_scale_factor` are decorated with `@lru_cache` (as implemented in [`manimlib/utils/tex_file_writing.py`](https://github.com/3b1b/manim/blob/main/manimlib/utils/tex_file_writing.py)). Identical LaTeX strings compile only once per session, dramatically reducing render times for repeated equations.

## Handling Edge Cases

The `Tex` class includes safeguards for common LaTeX issues:

- **Empty Strings**: Automatically substitutes a dummy line break (`\\`) to prevent LaTeX compilation errors (lines 59-62).
- **Alignment Environments**: Supports standard LaTeX environments like `align*` through the raw string interface.

```python
class AlignExample(Scene):
    def construct(self):
        system = Tex(r"""
            \begin{align*}
                a &= b + c \\
                d &= e - f
            \end{align*}
        """, font_size=72)
        self.play(FadeIn(system))
        self.wait()

```

## Summary

- Manim's `Tex` class (located in [`manimlib/mobject/svg/tex_mobject.py`](https://github.com/3b1b/manim/blob/main/manimlib/mobject/svg/tex_mobject.py)) converts LaTeX strings to SVG via external compilers.
- The `latex_to_svg` utility in [`manimlib/utils/tex_file_writing.py`](https://github.com/3b1b/manim/blob/main/manimlib/utils/tex_file_writing.py) handles the LaTeX → DVI → SVG pipeline with LRU caching for performance.
- **Scaling** is calibrated automatically so that `font_size=48` equals 1 Manim unit height.
- **`tex_to_color_map`** injects color commands automatically; **`isolate`** creates separate sub-Mobjects for individual symbol animation.
- **Templates** defined in [`manimlib/tex_templates.yml`](https://github.com/3b1b/manim/blob/main/manimlib/tex_templates.yml) enable switching between compilers (e.g., `xelatex` for Unicode) via the `template` argument.

## Frequently Asked Questions

### What is the difference between Tex and TexMobject in Manim?

In the 3b1b/manim library, the class is named `Tex` and is defined in [`manimlib/mobject/svg/tex_mobject.py`](https://github.com/3b1b/manim/blob/main/manimlib/mobject/svg/tex_mobject.py). Older documentation and community versions often refer to this functionality as "TexMobject," but the modern implementation uses the `Tex` class with an improved API including `tex_to_color_map` and `isolate` parameters.

### Why is my LaTeX compilation slow on the first run?

Manim must invoke external LaTeX compilers and `dvisvgm` to generate SVG files. However, the `latex_to_svg` function uses `@lru_cache` to store results. Subsequent uses of identical LaTeX strings retrieve the cached SVG instantly, eliminating compilation overhead.

### How do I use Unicode characters or custom fonts in Manim equations?

Pass `template="xelatex"` to the `Tex` constructor. This selects the XeLaTeX compiler configuration from [`manimlib/tex_templates.yml`](https://github.com/3b1b/manim/blob/main/manimlib/tex_templates.yml), which supports Unicode input and system fonts. Ensure your LaTeX installation includes `xelatex` and the necessary font packages.

### Can I animate individual parts of a fraction or subscript?

Yes. Use the `isolate` parameter when creating the `Tex` object, passing a list of strings to treat as separate sub-Mobjects. For example, `Tex(r"\frac{a}{b}", isolate=["a", "b"])` allows you to target the numerator and denominator independently via `get_parts_by_tex("a")` and standard animation methods.