figma-ai/motion-graphics-bench

MotionGraphicsBench: Evaluating Motion Graphics Generation with Programmatic Verification

Jiaju Ma^1,2,*    Ashvini Kumar Jindal^2,*    Chuhua Wang²    Sumithra Bhakthavatsalam^2
1Stanford University    ²Figma    ^*Equal contribution

MotionGraphicsBench is an expert-curated benchmark for evaluating how well large language models (LLMs) can animate static vector graphics. It consists of 100 tasks, each of which provides a model with an input static SVG and a motion edit prompt and asks it to animate the static visual elements according to the prompt. Each task is paired with a deterministic, human-readable verification program that evaluates the generated animation as an ordered sequence of SVG frames. The program measures the elements' geometry, appearance, and motion over time to check the prompt requirements, and then returns a verification report with an overall decision and the checks that passed or failed.

Read our blog for an overview of the benchmark and results, and our paper for the full methods and evaluation. Explore all 100 tasks and animations on the project page.

Quick start

Clone the repository:

git clone https://huggingface.co/datasets/figma-ai/motion-graphics-bench
cd motion-graphics-bench

From the repository root, install the dependencies:

uv sync --locked --no-dev
npm ci
uv run playwright install chromium

Or use a Python virtual environment with pip:

python3.12 -m venv .venv
source .venv/bin/activate
python -m pip install "mover==0.4.0" "pyarrow>=25.0.1"
npm ci
python -m playwright install chromium

Next, try the benchmark on the Scissor task (10175370): animate its SVG with a JavaScript program, and inspect which verification checks pass or fail. The commands below use uv; with the pip installation, replace uv run python with python.

Save the following as program.js:

const root = document.querySelector("svg");
const upperHalf = root.querySelector("#scissors-1");
const lowerHalf = root.querySelector("#scissors-2");

const tl = gsap.timeline();

tl.set([upperHalf, lowerHalf], { rotation: 0, svgOrigin: "1176.172 1080.996" }, 0);
tl.to(upperHalf, { rotation: 22, duration: 1.3, ease: "power2.inOut" }, 0);
tl.to(lowerHalf, { rotation: -22, duration: 1.3, ease: "power2.inOut" }, 0);
tl.to(upperHalf, { rotation: 0, duration: 1.3, ease: "power2.inOut" }, 1.7);
tl.to(lowerHalf, { rotation: 0, duration: 1.3, ease: "power2.inOut" }, 1.7);

Render and verify the animation:

uv run python scripts/benchmark_pipeline.py \
  --animation-id 10175370 \
  --program program.js \
  --output-dir outputs/scissor

The results are saved in outputs/scissor/:

• outputs/scissor/frames.json: the rendered SVG frames.
• outputs/scissor/report.json: rendering details, checks that passed or failed, the overall verification decision, and any execution errors.
• outputs/scissor/render/: files used to render the animation, including the individual frames.

This program passes seven of the task's eight checks. The scissors close and reopen, but the blades stop too far apart to reach the requested nearly closed pose, so the overall verification decision is false.

Benchmark

Our benchmark contains 100 motion editing tasks, each with an input static SVG, a PNG version of the SVG, a motion edit prompt, and a verification program.

The benchmark configuration contains one task per row.

Field	Type	Description
animation_id	string	Stable task identifier.
animation_name	string	Task name.
input_svg	string	Complete input static SVG, including geometry that may initially be hidden.
input_svg_as_png	binary	PNG rendering of the input static SVG.
motion_edit_prompt	string	Motion instructions given to the model.
source_lottie_json	string	Complete source Lottie animation stored as JSON.
source_svg_frames	list of strings	Ordered SVG frames rendered from the source Lottie animation.
verification_program	string	Python source code for the task's verification program.

The source animations (source_lottie_json and source_svg_frames) are real-world Lottie animations from LottieAnimation-660K used to construct each task's input static SVG and human-reviewed motion edit prompt. Each source animation shows one valid way to satisfy its prompt, but a generated animation does not need to match it exactly.

Our blog and paper describe how we build the benchmark with the source animations and evaluate its verification programs.

Load the benchmark configuration using the Datasets library:

from datasets import load_dataset

benchmark = load_dataset(
    "figma-ai/motion-graphics-bench",
    "benchmark",
    split="test",
)

Model outputs

We release 53,180 model outputs in the model_outputs configuration: 51,200 generation attempts used to evaluate 32 LLMs across 47 model settings and 1,980 outputs collected for human review.

Field	Type	Description
animation_id	string	Identifier of the corresponding benchmark task.
animation_name	string	Task name.
model_id	string	Model identifier.
reasoning_effort	string	Recorded reasoning-effort setting.
inference_params	string	Generation settings as JSON; unknown defaults and internal request details are omitted.
response_index	int32	Generation attempt index, starting at zero.
generated_animation_program	string or null	Saved GSAP animation program, or null if unavailable.
rendered_svg_frames	list of strings or null	Ordered SVG frames from the generated animation, or null if unavailable.
output_usage	string	Why the output was collected: model_evaluation or human_labeling.
passed_checks	list of strings or null	Names of checks that passed, or null if no completed check results are available.
failed_checks	list of strings or null	Names of checks that failed, or null if no completed check results are available.
verification_decision	boolean or null	Recorded overall verification decision, or null if unavailable.
human_decision	string or null	approve, reject, cannot_judge, unresolved, or null when not reviewed.
human_rationales	list of strings or null	Reviewer comments; an empty list means a reviewed output had no comments.

Load the model_outputs configuration:

from datasets import load_dataset

model_outputs = load_dataset(
    "figma-ai/motion-graphics-bench",
    "model_outputs",
    split="test",
)

Verify an animation

Vector animations can be created in many ways, including CSS animations, JavaScript libraries, and formats such as Lottie. The verification of MotionGraphicsBench is independent of how animations are created: each verification program evaluates an ordered sequence of compatible SVG frames. In this repository, we provide a renderer built on MoVer to convert JavaScript animations written with GSAP into SVG frames.

Run only verification programs you trust. Verification programs run in Python subprocesses with timeouts, but this is not a security sandbox: the code can access files and the network. Use an isolated container or virtual machine without secrets for untrusted code or dataset files. Browser network restrictions apply only to rendering, not Python verification.

scripts/benchmark_pipeline.py supports animation generation, GSAP rendering, and SVG-frame verification:

benchmark_pipeline.py (--animation-id ID [ID ...] | --all-animations)
                      [--model MODEL] [--model-params JSON] [--num-generations N]
                      [--stages STAGE [STAGE ...]] [--program FILE] [--frames FILE]
                      --output-dir DIR [--dataset PATH]
                      [--system-prompt-suffix TEXT]
                      [--capture-duration SECONDS] [--timeout SECONDS]

List all command-line options:

uv run python scripts/benchmark_pipeline.py --help

Pipeline options

• --model MODEL: LiteLLM model identifier; required for generation.
• --animation-id ID: Select one task; required when using a saved program or frame sequence.
• --animation-id ID1 ID2: Generate for several selected tasks.
• --all-animations: Generate for every task instead of using --animation-id.
• --num-generations N: Number of independent generation attempts per task; defaults to 1.
• --stages ...: Choose generate, generate render, generate render verify, render, verify, or render verify. Defaults to generate render verify with --model, otherwise render verify.
• --program FILE: GSAP JavaScript file to render without a model call.
• --frames FILE: JSON file containing an ordered list of SVG strings; use with --stages verify.
• --model-params JSON: Model request settings, such as output-token limits, reasoning effort, or "stream": true. LiteLLM validates these settings; supported options depend on the model and provider.
• --system-prompt-suffix TEXT: Append model-specific text to the system prompt.
• --output-dir PATH: New output directory.
• --dataset PATH: Benchmark Parquet file or directory; defaults to the released benchmark.
• --capture-duration SECONDS: Capture duration in seconds for repeating animations; requires rendering.
• --timeout SECONDS: Time limit in seconds for each model request, rendering, measurement, or verification operation; defaults to 900.

For retries within a model request, set num_retries in --model-params (default 0). These retries do not count as separate generation attempts.

Verify SVG frames

uv run python scripts/benchmark_pipeline.py \
  --animation-id 10175370 \
  --stages verify \
  --frames frames.json \
  --output-dir outputs/scissor-verify

frames.json contains an ordered list of SVG strings. The pipeline loads the task's verification program and runs its checks on those frames.

Render and verify an animation program

uv run python scripts/benchmark_pipeline.py \
  --animation-id 10175370 \
  --program program.js \
  --output-dir outputs/scissor

This command renders the animation program written with GSAP into SVG frames, then runs the task's verification program on those frames.

To render without verification, add --stages render:

uv run python scripts/benchmark_pipeline.py \
  --animation-id 10175370 \
  --stages render \
  --program program.js \
  --output-dir outputs/scissor-render

Generate animations

We use MoVer to generate JavaScript animation programs with GSAP. MoVer provides access to cloud and local LLMs through LiteLLM. Models receive the input static SVG, motion edit prompt, and duration and frame-rate requirements, but not source animations or verification programs. Each generation attempt is independent and receives no feedback from earlier attempts.

For example, use Qwen3-Coder through OpenRouter to generate four GSAP animation programs for the Scissor task (10175370). Set OPENROUTER_API_KEY before running the following command:

uv run python scripts/benchmark_pipeline.py \
  --animation-id 10175370 \
  --model openrouter/qwen/qwen3-coder-30b-a3b-instruct \
  --model-params '{"max_output_tokens":4096}' \
  --num-generations 4 \
  --stages generate \
  --output-dir outputs/scissor-generated

For OpenAI, set OPENAI_API_KEY and use an openai/... model. Other provider configurations can be found at https://docs.litellm.ai/docs/providers. See pipeline options for task selection, stages, and defaults. Omit --stages generate to also render and verify each program.

Outputs

• <animation_id>/messages.json: The system and user messages for each task, including any system-prompt suffix.
• <animation_id>/<response_index>/: One directory per generation attempt, numbered from zero. Contains program.js when generation succeeds and a report.json with the full model response when available, partial streamed text, and any errors. Rendering also produces SVG frames.
• report.json: A summary of the run, including each attempt and selected model settings (recorded_model_params).

Reports may include full model responses, so keep secrets out of prompts and request metadata.

Local models

Ollama

Server setup: https://docs.ollama.com/cli

uv run python scripts/benchmark_pipeline.py \
  --animation-id 10175370 \
  --model ollama_chat/qwen2.5-coder:3b \
  --model-params '{"api_base":"http://127.0.0.1:11434","num_ctx":32768,"max_output_tokens":4096}' \
  --output-dir outputs/scissor-ollama

vLLM

Server setup: https://docs.vllm.ai/en/stable/serving/online_serving/openai_compatible_server/

uv run python scripts/benchmark_pipeline.py \
  --animation-id 10175370 \
  --model hosted_vllm/Qwen/Qwen2.5-Coder-3B-Instruct \
  --model-params '{"api_base":"http://127.0.0.1:8000/v1","use_chat_completions_api":true,"max_output_tokens":4096}' \
  --output-dir outputs/scissor-vllm

License and attribution

We release the MotionGraphicsBench datasets and benchmark media under CC BY-NC-SA 4.0, and repository-authored code, including the benchmark verification programs, under the MIT License.

We built the benchmark from LottieAnimation-660K, which is distributed under CC BY-NC-SA 4.0. Rights in individual source animations remain with their original creators and may be subject to additional terms.

The runtime depends on:

• MoVer, distributed under the Apache License 2.0.
• GSAP, used under its own licensing terms.

These dependency licenses do not replace the MotionGraphicsBench data and code licenses above.

Citation

If you use MotionGraphicsBench, please cite our paper:

@article{ma2026motiongraphicsbench,
  title   = {MotionGraphicsBench: Evaluating Motion Graphics Generation with Programmatic Verification},
  author  = {Ma, Jiaju and Jindal, Ashvini Kumar and Wang, Chuhua and Bhakthavatsalam, Sumithra},
  journal = {arXiv preprint arXiv:2611.10592},
  year    = {2026},
  url     = {https://arxiv.org/abs/2611.10592}
}