ManimCode: Learning Visual Self-Correction for Educational Animation

arXiv:2611.08294 · cs.CV · Submitted 2026-11-05 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: We're looking at the paper: "ManimCode: Learning Visual Self-Correction for Educational Animation".

Jane: Here's the gist of the paper. ManimCode introduces ManimData and ManimCode as a data and training framework for feedback-driven educational animation generation The resulting system achieves 96.6% and 97.0% render success on ManimData-test and ManimBench, compared with 52.6% and 82.0% for the untrained 4B model under the same inference setup Pruning redundant reasoning tokens Educational animations help explain abstract STEM concepts by showing mathematical relationships, geometric constructions, and processes that unfold over time A successful render can still produce a poor teaching video because defects are difficult to fix because the video does not directly identify the required code changes Existing agentic frameworks typically rely on large models, often proprietary, and their refinement loops become much less reliable with smaller open alternatives ManimBench contains render-verified programs but is relatively small, while community datasets and JanusCode-800K lack systematic rendering and quality checks Existing data therefore offers little guidance on how a model should review and revise its own animations How the training signal is built ManimData is constructed through a render-guided pipeline that iteratively generates, executes, reviews, and revises Manim programs with retrieved API documentation This pipeline preserves intermediate programs, execution errors, visual critiques, and corrective revisions in its 24,034 render-verified records ManimCode is trained using role-conditioned supervised fine-tuning on these trajectories to write, review, and revise animation programs The training involves organizing the recorded trajectories into role-conditioned supervised fine-tuning (SFT) tasks where the Writer generates programs from requests and retrieved API documentation The Reviewer assesses rendered frames and identifies visual defects, while the Reviser corrects execution failures and improves programs based on visual critiques To improve correction of errors that differ from those in the collected trajectories, the Reviser is trained with reinforcement learning on self-generated states using rendering outcomes and reference-free quality feedback Where the gains come from ManimCode achieves 96.6% and 97.0% render success on ManimData-test and ManimBench, compared with 52.6% and 82.0% for the untrained 4B model under the same inference setup Integrating ManimCode into two long-form educational video generation systems increases completed videos from 19/117 to 107/117 and from 53/239 to 239/239, alongside improvements in educational effectiveness and visual quality The Reviser RL brings additional render success gains of 8.0 and 5.0 percentage points, reaching 96.6% and 97.0%, while maintaining comparable video quality (2.94 and 3.44) Data Sources and API Knowledge Base ManimData pairs each request with a render-verified program, its video, and the trajectory of errors, critiques, and revisions that produced the program The data draws on two sources: requests derived from Wikipedia STEM topics and public community programs Requests are derived from 639,700 English Wikipedia articles through a coarse-to-fine filter using various Qwen models to keep 22,058 requests across 11,150 topics A knowledge base of 2,219 API cards is compiled for the Writer and Reviser to look up APIs for ManimCE v0.19.1 with eight domain plugins Evaluation and Human Agreement The judge is Gemini 3.8 Flash, which assigns scores for request alignment, content completeness, and semantic correctness Human preferences show stronger agreement with the judge when quality differences are larger: for VQ gaps of at least 0.5, the annotator agrees with the judge on 79% of decided pairs The system achieves a mean VQ of 2.94 and 3.44, which is comparable to GPT-4o and approaches those of recent MoE models When integrated into Code2Video and TheoremExplainAgent, completed videos rise from 19/117 to 107/117 in Code2Video and from 53/239 to 239/239 in TheoremExplainAgent The final system shows that the Reviser can correct defects such as overlapping text by moving the table down and placing the current-state label below it, which is scored higher by the Reviewer The model's performance on ManimData-test and ManimBench is significantly better than that of general-purpose models like GPT-4o ManimData and ManimCode provide a data and training framework for feedback-driven educational animation generation ManimCode uses role-conditioned supervision and reinforcement learning on self-generated revision states to train a 4B model to write, review, and revise animation programs It achieves 96.6% and 97.0% render success on ManimData-test and ManimBench, while maintaining competitive video quality against larger general-purpose models When integrated into Code2Video and TheoremExplainAgent, ManimCode also improves long-form video completion and visual quality scores The paper's contributions include introducing a dataset of 24,034 render-verified, quality-filtered animations that preserve execution errors, visual critiques, and corrective revisions It proposes ManimCode to train a single 4B model to run the complete render–review–revise process It achieves high performance on scene-level benchmarks and increases video completion in long-form systems The framework is designed to make feedback-driven refinement learnable by small open models The final system successfully handles complex visual errors through iterative refinement guided by human critiques and automated quality checks Page 1 --- ManimCode Learning Visual Self-Correction for Educational Animation Pruning redundant reasoning tokens ManimCode introduces ManimData and ManimCode as a data and training framework for feedback-driven educational animation generation The resulting system achieves 96.6% and 97.0% render success on ManimData-test and ManimBench, compared with 52.6% and 82.0% for the untrained 4B model under the same inference setup Where the gains come from ManimCode achieves 96.6% and 97.0% render success on ManimData-test and ManimBench, compared with 52.6% and 82.0% for the untrained 4B model under the same inference setup Integrating ManimCode into two long-form educational video generation systems increases completed videos from 19/117 to 107/117 and from 53/239 to 239/239, alongside improvements in educational effectiveness and visual quality Evaluation and Human Agreement The judge is Gemini 3.8 Flash, which assigns scores for request alignment, content completeness, and semantic correctness Human preferences show stronger agreement with the judge when quality differences are larger: for VQ gaps of at least 0.5, the annotator agrees with the judge on 79% of decided pairs The system achieves a mean VQ of 2.94 and 3.44, which is comparable to GPT-4o and approaches those of recent MoE models When integrated into Code2Video and TheoremExplainAgent, completed videos rise from 19/117 to 107/117 in Code2Video and from 53/239 to 239/239 in TheoremExplainAgent The final system shows that the Reviser can correct defects such as overlapping text by moving the table down and placing the current-state label below it, which is scored higher by the Reviewer Page 2 --- ManimCode SMU Research Page 3 --- ManimCode SMU Research Data Sources and API Knowledge Base ManimData pairs each request with a render-verified program, its video, and the trajectory of errors, critiques, and revisions that produced the program The data draws on two sources: requests derived from Wikipedia STEM topics and public community programs Requests are derived from 639,700 English Wikipedia articles through a coarse-to-fine filter using various Qwen models to keep 22,058 requests across 11,150 topics A knowledge base of 2,219 API cards is compiled for the Writer and Reviser to look up APIs for ManimCE v0.19.

Title and authors: Tom: Moving on to the summary of "ManimCode: Learning Visual Self-Correction for Educational Animation", they are essentially describing the system they built to solve the problem that generating educational animations is hard because rendering doesn't tell you how to fix visual problems >

Jane: The paper explains that educational animations are great for explaining abstract STEM concepts by showing mathematical relationships and geometric constructions over time, but creating them manually requires both subject knowledge and programming skills >

Lu: So they highlight that recent work using language models to write programs for animation engines like Manim creates precise control over formulas and geometry, which is hard to maintain with pixel space video generation >

Meng: And the problem they identified is that a successful render can still produce a poor teaching video, with things like labels overlapping or objects falling outside the frame >

Tom: Because those visual defects are hard to fix because the video doesn't automatically tell you what code changes are needed to correct them >

Jane: So instead of just rendering and moving on, we need a way to inspect the output and revise the program based on those visual defects, which is what they propose with ManimData and ManimCode >

Lu: They build ManimData by creating a render-guided pipeline that iteratively generates, executes, reviews, and revises programs using API documentation to create twenty-four thousand four hundred three render-verified records > <ref:2611.08294#pg1,a render-guided pipeline that iteratively generates, executes, reviews, and revises>

Meng: This pipeline is crucial because it keeps the history of execution errors, visual critiques, and those corrective revisions in place for training purposes >

Tom: So ManimData is essentially this dataset that contains the entire journey from a bad program to a good one >

Jane: And ManimCode is the framework that uses this data to train a single four billion parameter model to perform all three roles: writing, reviewing, and revising animation programs >

Lu: The core idea of ManimCode is role-conditioned trajectory supervised fine-tuning where the Writer generates programs from requests and API documentation, the Reviewer assesses rendered frames for visual defects, and the Reviser corrects execution failures based on those critiques >

Meng: And to make sure it learns to fix things that weren't in the collected data, they add reinforcement learning on self-generated states using rendering outcomes and reference-free quality feedback >

Tom: So they are teaching the model how to generate, critique, and correct animation programs in sequence using these different roles >

Jane: That’s a very structured way to teach the AI this complex visual self-correction task >

The paper's summary: Tom: Now let's talk about what they actually improved. They aren't just saying they built a new tool; they are showing how this framework improves the performance of existing systems.

Jane: They show that ManimCode achieves ninety six point six percent and ninety seven point zero percent render success on two scene-level benchmarks, which is compared to fifty two point six percent and eighty two point zero percent for an untrained four billion parameter model under the same setup >

Lu: That improvement comes from integrating ManimCode into those long form educational video generation systems, where it increases completed videos from nineteen out of one hundred seventeen to one hundred seven out of one hundred seventeen, and from fifty three out of two hundred thirty nine to two hundred thirty nine out of two hundred thirty nine >

Meng: That means for the long-form stuff, the system goes from failing nearly half the time to completing every single video in that test set >

Tom: They also mentioned improvements in educational effectiveness and visual quality when these systems are integrated >

Jane: The Reviser reinforcement learning brings additional render success gains of eight point zero and five point zero percentage points, pushing the total success to ninety six point six percent and ninety seven point zero percent while keeping video quality scores comparable at two point nine four and three point four four >

Lu: That’s a lot of gain from adding that specific component because it shows the value of targeted training for error correction >

Meng: It shows that this targeted approach works better than letting a general model just try to guess the fix on its own, which is what they are implicitly comparing against >

Tom: And one specific improvement they pointed out was the Reviser correcting visual defects like overlapping text by moving the table down and placing the current state label below it, which is scored higher by the reviewer >

Jane: So we’ve seen concrete examples of how this iterative process actually leads to better visual outcomes, not just theoretical improvements >

The paper's improvements: Tom: To wrap up, the main point here is that ManimData and ManimCode provides a data and training framework for feedback-driven educational animation generation >

Jane: This means we have a structured way to make the process of learning visual self-correction learnable by small open models >

Lu: They use role-conditioned supervision and reinforcement learning on self-generated revision states to train a four billion parameter model to write, review, and revise animation programs >

Tom: And when integrated into long form systems like Code2Video and TheoremExplainAgent, it also improves video completion rates in those systems >

Jane: The paper's title, "ManimCode: Learning Visual Self-Correction for Educational Animation", really sums up the goal of making that visual correction learnable through iterative refinement guided by human critiques and automated quality checks >

Conclusion: Tom: So we've looked at ManimCode and ManimData, which is this whole framework designed to teach an AI how to write, review, and revise educational animation programs >

Jane: Right, it’s about taking those messy execution errors and visual critiques from actual rendering runs and turning them into training data for a single four billion parameter model >

Lu: The core mechanism there is role-conditioned supervised fine-tuning combined with reinforcement learning on self-generated states to handle those complex visual corrections >

Meng: But the real win here is seeing how this pushes long form video generation systems, like Code2Video and TheoremExplainAgent, up to completion rates of nearly all videos >

Tom: And the numbers behind that are pretty impressive. We're talking ninety six point six percent and ninety seven point zero percent render success on specific benchmarks compared to the untrained model which was struggling badly >

Jane: That jump from fifty two point six percent and eighty two point zero percent up to those high numbers really shows how much targeted feedback helps a model learn visual nuance >

Lu: The data they collected, ManimData, is twenty-four thousand four hundred three render-verified records that keep the history of errors and revisions in place >

Meng: It’s interesting how they built that dataset using requests from Wikipedia STEM topics and then filtered them down to twenty-two thousand requests across eleven thousand topics >

Tom: And they compiled a knowledge base of two thousand two hundred nineteen API cards for both the writer and the reviewer so the AI knows exactly what functions it can call >

Jane: So, for someone just listening, it means we're getting an AI that doesn't just try to draw a picture but actually learns how to fix its own mistakes when things go wrong visually >

Lu: The fact that their Reviser reinforcement learning component brings those extra eight point zero and five point zero percentage points is significant because it shows the self-correction loop really has teeth >

Meng: From my side, at scale, I'm looking at how robust this is when you try to deploy it into a production environment where the rendering budget might be tighter than what they tested on >

Tom: That’s a fair concern. They did mention their limitations—that the data quality depends heavily on the human critiques and that it still relies on these specific benchmarks for its success >

Jane: So, to wrap up, ManimCode is this framework that uses trajectory supervision and reinforcement learning to train a single four billion parameter model to write, review, and revise animation programs >

Lu: It successfully achieves high performance on scene-level benchmarks and increases video completion in long form systems >

Meng: It's definitely a solid step toward making these complex visual tasks manageable for open models >

Tom: Alright then. That was ManimCode Learning Visual Self-Correction for Educational Animation. Next up, we’re looking at how other models are handling error propagation in diffusion processes >

Zhengyang Liang, Lizi Liao

Singapore Management University

cs.CV

Submitted: 2026-11-05

Updated: 2026-11-05

Project page: https://liang-zhengyang.github.io/manimcode

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 91/100

The gist: ManimCode introduces ManimData and ManimCode as a data and training framework for feedback-driven educational animation generation The resulting system achieves 96.6% and 97.0% render success on…

Key concepts

ManimData
This is a dataset built through an iterative pipeline that generates, executes, reviews, and revises Manim programs. It captures every step of the process—including errors, visual critiques, and corrections—to provide rich training signals for the model.
ManimCode
This is the resulting data and training framework that trains a single 4B model to perform three tasks: writing programs based on requests, reviewing rendered frames for defects, and revising execution failures. It uses role-conditioned supervised fine-tuning on recorded trajectories.
Role-Conditioned Supervised Fine-Tuning (SFT)
The training organizes recorded trajectories into specific tasks where the model learns different roles. The Writer learns to generate programs from requests, the Reviewer learns to assess visual defects, and the Reviser learns to correct execution issues based on human feedback.
Reinforcement Learning on Self-Generated States
To improve error correction beyond what is in the training data, the Reviser component uses reinforcement learning. It learns by trying self-generated states and receiving quality feedback from rendering outcomes, allowing it to correct novel visual defects.

Terminology

Summary

ManimCode introduces ManimData and ManimCode as a data and training framework for feedback-driven educational animation generation The resulting system achieves 96. p. 0

Where the paper says it

Existing Manim datasets primarily contain final programs and often lack quality verification and the trajectories of feedback and revisions needed to learn this refinement process. We introduce ManimData and ManimCode, a data and training framework for feedback-driven educational animation generation.

6% and 97.0% render success on ManimData-test and ManimBench, compared with 52. p. 0
Where the paper says it

ManimCode achieves 96. 0% render success on ManimData-test and ManimBench, compared with 52.

p. 0
Where the paper says it

ManimCode achieves 96. 0% render success on ManimData-test and ManimBench, compared with 52.

p. 0
Where the paper says it

ManimCode achieves 96. 0% render success on ManimData-test and ManimBench, compared with 52.

p. 0
Where the paper says it

ManimCode achieves 96. 0% render success on ManimData-test and ManimBench, compared with 52.

6% and 82.0% for the untrained 4B model under the same inference setup

Pruning redundant reasoning tokens

Educational animations help explain abstract STEM concepts by showing mathematical relationships, geometric constructions, and processes that unfold over time A successful render can still produce a poor teaching video because defects are difficult to fix because the video does not directly identify the required code changes Existing agentic frameworks typically rely on large models, often proprietary, and their refinement loops become much less reliable with smaller open alternatives ManimBench contains render-verified programs but is relatively small, while community datasets and JanusCode-800K lack systematic rendering and quality checks Existing data therefore offers little guidance on how a model should review and revise its own animations

How the training signal is built

ManimData is constructed through a render-guided pipeline that iteratively generates, executes, reviews, and revises Manim programs with retrieved API documentation This pipeline preserves intermediate programs, execution errors, visual critiques, and corrective revisions in its 24,034 render-verified records ManimCode is trained using role-conditioned supervised fine-tuning on these trajectories to write, review, and revise animation programs The training involves organizing the recorded trajectories into role-conditioned supervised fine-tuning (SFT) tasks where the Writer generates programs from requests and retrieved API documentation The Reviewer assesses rendered frames and identifies visual defects, while the Reviser corrects execution failures and improves programs based on visual critiques To improve correction of errors that differ from those in the collected trajectories, the Reviser is trained with reinforcement learning on self-generated states using rendering outcomes and reference-free quality feedback

Where the gains come from

ManimCode achieves 96.6% and 97.0% render success on ManimData-test and ManimBench, compared with 52.6% and 82.0% for the untrained 4B model under the same inference setup Integrating ManimCode into two long-form educational video generation systems increases completed videos from 19/117 to 107/117 and from 53/239 to 239/239, alongside improvements in educational effectiveness and visual quality The Reviser RL brings additional render success gains of 8. p. 0

Where the paper says it

94 and from 3. Integrating ManimCode into two long-form educational video generation systems increases completed videos from 19/117 to 107/117 and from 53/239 to 239/239, alongside improvements in educational effectiveness and visual quality.

0 and 5.0 percentage points, reaching 96. p. 7
Where the paper says it

Reviser RL brings additional render success gains of 8. 0 percentage points, reaching 96.

6% and 97.0%, while maintaining comparable video quality (2. p. 7
Where the paper says it

0 percentage points, reaching 96. 0%, while maintaining comparable video quality (2.

94 and 3.44)

Data Sources and API Knowledge Base

ManimData pairs each request with a render-verified program, its video, and the trajectory of errors, critiques, and revisions that produced the program The data draws on two sources: requests derived from Wikipedia STEM topics and public community programs Requests are derived from 639,700 English Wikipedia articles through a coarse-to-fine filter using various Qwen models to keep 22,058 requests across 11,150 topics A knowledge base of 2,219 API cards is compiled for the Writer and Reviser to look up APIs for ManimCE v0.19.1 with eight domain plugins

Evaluation and Human Agreement

The judge is Gemini 3.8 Flash, which assigns scores for request alignment, content completeness, and semantic correctness Human preferences show stronger agreement with the judge when quality differences are larger: for VQ gaps of at least 0. p. 8

Where the paper says it

A blinded annotator selects the video better suited for teaching or marks a tie (Appendix C. Human preferences show stronger agreement with the judge when quality differences are larger: for VQ gaps of at least 0.

p. 8
Where the paper says it

A blinded annotator selects the video better suited for teaching or marks a tie (Appendix C. Human preferences show stronger agreement with the judge when quality differences are larger: for VQ gaps of at least 0.

5, the annotator agrees with the judge on 79% of decided pairs The system achieves a mean VQ of 2. p. 8
Where the paper says it

5, the annotator agrees with the judge on 79% of decided pairs, compared with only 29% for gaps below 0. At the system level, human preferences align with the judge’s rankings in three of four comparisons (Table 11), favoring ManimCode over GPT-4o overall but Qwen3.

p. 8
Where the paper says it

5, the annotator agrees with the judge on 79% of decided pairs, compared with only 29% for gaps below 0. At the system level, human preferences align with the judge’s rankings in three of four comparisons (Table 11), favoring ManimCode over GPT-4o overall but Qwen3.

94 and 3.44, which is comparable to GPT-4o and approaches those of recent MoE models When integrated into Code2Video and TheoremExplainAgent, completed videos rise from 19/117 to 107/117 in Code2Video and from 53/239 to 239/239 in TheoremExplainAgent The final system shows that the Reviser can correct defects such as overlapping text by moving the table down and placing the current-state label below it, which is scored higher by the Reviewer The model's performance on ManimData-test and ManimBench is significantly better than that of general-purpose models like GPT-4o

Conclusion

ManimData and ManimCode provide a data and training framework for feedback-driven educational animation generation ManimCode uses role-conditioned supervision and reinforcement learning on self-generated revision states to train a 4B model to write, review, and revise animation programs It achieves 96.6% and 97.0% render success on ManimData-test and ManimBench, while maintaining competitive video quality against larger general-purpose models When integrated into Code2Video and TheoremExplainAgent, ManimCode also improves long-form video completion and visual quality scores The paper's contributions include introducing a dataset of 24,034 render-verified, quality-filtered animations that preserve execution errors, visual critiques, and corrective revisions It proposes ManimCode to train a single 4B model to run the complete render–review–revise process It achieves high performance on scene-level benchmarks and increases video completion in long-form systems The framework is designed to make feedback-driven refinement learnable by small open models The final system successfully handles complex visual errors through iterative refinement guided by human critiques and automated quality checks

--- Page 1 ---

ManimCode Learning Visual Self-Correction for Educational Animation

ManimCode introduces ManimData and ManimCode as a data and training framework for feedback-driven educational animation generation The resulting system achieves 96.6% and 97.0% render success on ManimData-test and ManimBench, compared with 52.6% and 82.0% for the untrained 4B model under the same inference setup

ManimCode achieves 96.6% and 97.0% render success on ManimData-test and ManimBench, compared with 52.6% and 82.0% for the untrained 4B model under the same inference setup Integrating ManimCode into two long-form educational video generation systems increases completed videos from 19/117 to 107/117 and from 53/239 to 239/239, alongside improvements in educational effectiveness and visual quality

The judge is Gemini 3.8 Flash, which assigns scores for request alignment, content completeness, and semantic correctness Human preferences show stronger agreement with the judge when quality differences are larger: for VQ gaps of at least 0.5, the annotator agrees with the judge on 79% of decided pairs The system achieves a mean VQ of 2.94 and 3.44, which is comparable to GPT-4o and approaches those of recent MoE models When integrated into Code2Video and TheoremExplainAgent, completed videos rise from 19/117 to 107/117 in Code2Video and from 53/239 to 239/239 in TheoremExplainAgent The final system shows that the Reviser can correct defects such as overlapping text by moving the table down and placing the current-state label below it, which is scored higher by the Reviewer

--- Page 2 ---

ManimCode SMU Research

--- Page 3 ---

ManimCode SMU Research

ManimData pairs each request with a render-verified program, its video, and the trajectory of errors, critiques, and revisions that produced the program The data draws on two sources: requests derived from Wikipedia STEM topics and public community programs Requests are derived from 639,700 English Wikipedia articles through a coarse-to-fine filter using various Qwen models to keep 22,058 requests across 11,150 topics A knowledge base of 2,219 API cards is compiled for the Writer and Reviser to look up APIs for ManimCE v0.19.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. ManimCode can write, review, and revise animation programs by learning from role-conditioned supervised fine-tuning on trajectory data, which allows a single 4B model to perform all three tasks.

  2. The Reviser component is trained with reinforcement learning on self-generated states using rendering outcomes and reference-free quality feedback to improve the correction of errors that differ from those in the collected trajectories.

  3. ManimCode can run a complete render-review-revise loop at inference time, where it iteratively refines educational animations within a fixed rendering budget, achieving 96.6% and 97.0% render success on benchmarks compared to untrained models.

  4. The system can improve long-form educational video generation by integrating ManimCode into systems like Code2Video and TheoremExplainAgent, increasing completed videos from 19/117 to 107/117 in Code2Video and from 53/239 to 239/239 in TheoremExplainAgent.

  5. The framework can be enhanced by using the trajectory supervision examples, which include execution-repair and quality-revision examples, to specifically teach the model how to turn a crashed program into one that renders or how to correct visual defects based on review scores.

Abstract

Manim supports precise, programmatic video generation, but a successfully rendered educational animation can still have visual defects, missing explanations, or incorrect content. Rendering does not directly identify the code changes needed to correct these visual failures, so feedback-driven revision is needed. Existing agentic frameworks use iterative rendering and revision but typically rely on large models, often proprietary. Existing Manim datasets primarily contain final programs and often lack quality verification and the trajectories of feedback and revisions needed to learn this refinement process. We introduce ManimData and ManimCode, a data and training framework for feedback-driven educational animation generation. We construct ManimData through a render-guided pipeline that iteratively generates, executes, reviews, and revises Manim programs with retrieved API documentation. Its 24,034 render-verified, quality-filtered records preserve intermediate programs, execution errors, visual critiques, and corrective revisions. We use role-conditioned supervised fine-tuning on these trajectories to train ManimCode, a single 4B model, to write, review, and revise animation programs. To improve correction of errors that differ from those in the collected trajectories, we then train the Reviser with reinforcement learning on self-generated states, using rendering outcomes and reference-free quality feedback. ManimCode achieves 96.6% and 97.0% render success on ManimData-test and ManimBench, compared with 52.6% and 82.0% for the untrained 4B model under the same inference setup, while also improving video quality scores from 2.48 to 2.94 and from 3.00 to 3.44. Integrating ManimCode into two long-form educational video generation systems increases completed videos from 19/117 to 107/117 and from 53/239 to 239/239, alongside improvements in educational effectiveness and visual quality.

Sources

Related papers