Manimator: Automated STEM Animations

• Manimator is an open-source tool that automates the production of dynamic visual explanations for STEM concepts using LLMs and the Manim engine.
• It processes research texts, PDFs, or prompts to generate structured scene descriptions, ensuring accurate LaTeX rendering and spatially consistent animations.
• The system streamlines code synthesis and rendering, significantly reducing manual effort in creating high-quality, pedagogically sound STEM animations.

Manimator is an open-source system designed to automate the production of dynamic explanatory animations for STEM concepts directly from research-paper text, PDFs, or natural language prompts, leveraging LLMs to generate pedagogically effective, visually relevant animations using the Manim engine (P et al., 18 Jul 2025). The framework enables researchers, educators, and students to rapidly transform dense mathematical and scientific material into visual scenes executable as Manim Python code, significantly reducing the barrier to high-quality STEM animation production.

1. System Goals and Problem Setting

Manimator's primary motivation is to democratize the creation of dynamic visual explanations in technical domains, particularly where concepts are deeply mathematical or involve abstract constructs. Manual animation for such content is both time-intensive and requires advanced skill sets—technical programming, typographical LaTeX proficiency, and an understanding of animation design principles. Manimator addresses this by automating the entire workflow from ingestion of raw academic content to finished, executable Manim scenes.

Key challenges addressed by the system include:

• Parsing and semantically interpreting academic language, complex mathematical formulas, and logical structure from research papers or unstructured prompts.
• Planning scene flow and selecting pedagogically valid visual metaphors (such as graphs illustrating functional dependencies or annotated equations).
• Automated code synthesis: generating compilable, spatially consistent, semantically faithful Manim Python code.
• Ensuring mathematical notation is preserved as LaTeX and animations progress at a suitable pace for educational contexts.

2. Pipeline Architecture and Processing Stages

The Manimator pipeline comprises three principal stages, each mapping to distinct LLM-mediated tasks (P et al., 18 Jul 2025):

1. Text/PDF Ingestion and Scene Description Generation
   • Inputs are accepted as raw prompt text, arXiv IDs, or uploaded PDFs (for which base64 encoding is used to support multimodal context in LLMs).
   • LLM selection is context-dependent: long PDFs are processed with large-context models (e.g., Gemini 2.0-Flash); short prompts with high-performance LLMs (e.g., Llama 3.3-70B).
   • Prompting guides the LLM to extract the topic, key points (in Markdown with LaTeX), and to enumerate necessary visual elements and animation flow, producing a scene description as a structured Abstract Syntax Tree (JSON/Markdown).
2. Manim Code Synthesis
   • The structured scene plan is given to a second LLM (e.g., DeepSeek-V3), prompted to convert the plan into syntactically correct, semantically faithful Manim Python code (Scene subclass, import statements, and the appropriate animation primitives).
   • Prompting incorporates few-shot examples and is tuned for maximum determinism (temperature ≈ 0.2) to minimize hallucination and ensure compile-ready code.
3. Rendering
   • The code is executed with Manim CE (≥ 0.17.0) and FFmpeg in a suitable Python (≥ 3.8) environment.
   • Rendering is handled via the Manim CLI, typically with commands like manim -pql fourier_scene.py FourierScene, producing videos or GIFs.

3. Representation of Mathematical and Visual Content

Manimator meticulously preserves original LaTeX notation as extracted from the paper or prompt. Formulas are represented using the MathTex or Tex classes in Manim, ensuring high-fidelity rendering of even multi-line, aligned, or complex mathematical expressions. The scene description explicitly specifies how each element (equation, graph, annotation) is displayed, transformed, or animated.

Examples include:

• Simple equations:

  from manim import * class EMassEnergy(Scene): def construct(self): eq = MathTex("E", "=", "m", "c", "^2", font_size=72) self.play(Write(eq)) self.wait(2)

• Aligned equations:

  class AlignedEq(Scene): def construct(self): eq = MathTex( r"\begin{aligned}" r"a &= b + c \" r"d &= e - f" r"\end{aligned}", font_size=48) self.play(Write(eq)) self.wait(2)

The Stage 1 LLM organizes such content into a plan, ensuring pedagogically logical ordering and animation timing (e.g., formula appears after an illustrative graph).

4. Use Cases and Scene Planning

Manimator is optimized for explaining mathematical definitions, theorems, proofs, and scientific concepts encountered in research literature. Its architecture supports sequentially layered animations, such as:

• Sequential introductions of titles, definitions, and equations.
• Animated transitions (e.g., transforming a function graph into its integral expression).
• Arrangement of visual elements to avoid overlap and enhance clarity.

Representative extracted scenes include, for instance, the exposition of the Fourier Transform:

from manim import * class FourierTransformScene(Scene): def construct(self): title = Text("Fourier Transform", font_size=64) formula = MathTex( "F(\omega)=\int_{-\infty}^{\infty}f(x)e^{-i\omega x}dx", font_size=48) graph = Axes(x_range=[-5,5,1], y_range=[-1,1,0.5]).plot(lambda x: np.sin(x), color=YELLOW) self.play(Write(title)) self.wait(1) self.play(Write(formula)) self.wait(1) self.play(Create(graph)) self.wait(1) self.play(TransformFromCopy(graph, formula)) self.wait(2)

This sequence demonstrates Manimator's capacity to generalize across mathematical domains and animation paradigms, automating the mapping from dense academic materials to visual scenes.

5. Implementation and Codebase Structure

The Manimator codebase is segmented for modularity:

• pipeline.py: orchestrates the stages, handling input parsing and managing output.
• stage1.py: contains the ScenePlanner class for text extraction and scene planning.
• stage2.py: implements the CodeGenerator class—LLM prompt templates and Manim code synthesis.
• renderer.py: manages execution of the Manim CLI, error logging, and video export.
• prompts.py/utils.py: stores prompt templates, format converters, and LaTeX sanitization utilities.

Error detection is robust, capturing syntax and semantic mismatches (e.g., unmatched LaTeX braces, missing class imports) and reporting them to users for correction.

6. Evaluation, Performance, and Limitations

Empirical evaluation on the TheoremExplainBench demonstrates Manimator (DeepSeek-V3) achieves a normalized overall score of 0.845, outperforming baselines at 0.79 and 0.77 (P et al., 18 Jul 2025). Notable performance metrics include Visual Relevance (0.899), Logical Flow (0.880), and Element Layout (0.853), substantiating the effectiveness of its LLM-driven planning and generation methodology. Human raters assigned an average normalized score of 0.738.

Identified failure modes are:

• Hallucinated or incomplete formulas when input text is ambiguous.
• Overlapping or poorly arranged elements if scene descriptions lack positional directives.
• LLM context-window limits leading to partial or truncated plans for very large documents.

Future directions include enabling iterative, user-in-the-loop scene refinement, LLM fine-tuning on curated animation datasets, and output expansion to interactive (e.g., Jupyter widget) or web-based formats.

7. Context, Related Systems, and Significance

Relative to prior educational animation tools, Manimator is distinguished by its end-to-end automation for research-grade content and its integration of LLMs for both semantic extraction and code generation. It serves as a direct bridge from research paper to explorable visualization, targeting audiences versed in mathematics, physics, and related fields. The code is open-source, and all dependencies are standard within the Manim and Python ecosystem, increasing accessibility for researchers.

A plausible implication is that Manimator significantly lowers the barrier for rapid prototyping and dissemination of visual educational content in advanced technical fields, potentially impacting pedagogy and scholarly communication within the STEM research community (P et al., 18 Jul 2025).