A 2021 Rust repository picked up 722 GitHub stars in a day just as its 1.x releases landed. That is a striking response for a video tool that asks web developers to trade JSX and a browser renderer for Rust structs, SVG trees and native graphics libraries. By the time of writing, fframes had passed 1,600 stars. The rush is less interesting as a popularity contest than as a test of what developers now want from code-generated video: faster renders, yes, but also a workflow that an AI coding agent can check without pretending to watch the result.
Fframes turns each frame into an SVG tree, rasterizes it with a CPU or Skia backend, and sends the output through FFmpeg. Its first stable tag arrived on September 28, followed by version 1.1.0 two days later. The project is MIT-licensed, and the repository already contains 229 commits, so the release is the public arrival of a long-running build rather than a weekend experiment. Version 1.1.0 made one focused fix, limiting codec threads when render segments run in parallel.
The render loop leaves the browser
A fframes video is a Rust type that implements the Video trait. It declares its dimensions, frame rate and duration, then returns an SVG tree for every frame through the svgr! macro. The crate documentation says those frame functions run concurrently and must remain pure: they should read prepared data, avoid I/O and avoid panics. That constraint is more rigid than an ordinary React composition, but it also gives the renderer a predictable unit of work.
The speed argument starts below the application layer. Static parts of the SVG tree receive hashes at compile time so a renderer can reuse their rasterized output across frames. The built-in CPU backend uses tiny-skia and splits video into segments across processor threads. A separate Skia backend walks the tree on the GPU through Metal on macOS or Vulkan on Linux and Windows. FFmpeg libraries handle encoding and audio muxing inside the process rather than through a shell command, according to the project's architecture notes.
That design suits motion graphics made from text, shapes, charts and repeated layouts. It also supports SkSL or Shadertoy GLSL shaders when SVG cannot express an effect. The project includes examples for vertical clips, podcast visualizations, conference splash screens and polygon-heavy stress tests. Each one still follows the same contract: code calculates a frame, a backend draws it, and FFmpeg assembles the video and sound. The examples are published in the repository, rather than hidden behind a hosted editor.
The 31x result comes with a large asterisk
Fframes publishes a reproducible benchmark against Remotion, but its most shareable number needs the test conditions beside it. The scene contains 99,000 rectangles and 1,000 changing text digits at 1000 by 1000 pixels. On the Remotion side, the list is unkeyed and each element receives 12 dependent effect and state updates. The benchmark README explicitly says the result applies to this React workload with many effects.
Both renderers process frames serially without a video encoder. The test includes PNG compression, uses three warm-up frames and reports the median of three 30-frame runs. On a Linux ARM64 Docker system, fframes with Skia on the CPU took 3.877 seconds. Remotion 4.0.529 took 120.801 seconds, making the Rust path 31.16 times faster in that test. The machine had no hardware GPU, so the fframes GPU run was skipped. Those details prevent the result from supporting a blanket claim about every Remotion project.
The comparison still identifies a real pressure point. Browser rendering carries costs when a composition creates a very large DOM and repeatedly drives state through it. Fframes computes the scene directly and can cache unchanged subtrees. Developers producing simpler videos, using well-structured React, or leaning on footage rather than thousands of vector nodes should run their own composition before expecting anything close to 31x. The benchmark script and workload are in the same public test directory, which makes that check possible.
The repository separately says its Skia GPU backend runs about 10 times faster than its built-in CPU backend. That is a maintainer claim, not the published Remotion benchmark, because the benchmark's GPU column has no result. Keeping those two numbers apart matters. The measured comparison is CPU against browser-based Remotion on one hostile scene. The GPU estimate compares two fframes backends. Fframes documents both backends, but independent results across ordinary compositions are still missing.
An agent gets instruments instead of eyesight
The more unusual part of fframes is its answer to a basic problem with AI-generated video. A coding agent can write animation code, yet it cannot reliably judge motion and sound from an MP4 alone. Fframes ships a coding-agent skill plus command-line checks that translate the result into images, text and numbers. The skill describes a video as a Rust struct with a per-frame SVG function, then tells the agent how to create, inspect and revise a project.
The inspect command checks frames every quarter-second as well as the first and last frame of each scene. It reports missing fonts, missing images, invalid SVG, text outside the canvas and panics, with an exit code of 2 when it finds errors. strip builds a labeled contact sheet from evenly spaced frames, while onion blends several frames so a movement's path and easing appear in one image. The command reference also exposes JSON output, which gives an agent structured evidence instead of a vague request to review the video.
Sound gets a similar treatment. audio analyze reports loudness in LUFS, true peak, clipping and silence for each scene, and it can write a waveform with scene boundaries and cue points. A snapshot command compares selected frames with approved PNGs and writes diff images when pixels change. Humans still have a native preview window and a WebAssembly editor with a timeline. These automated checks can catch several concrete failures before a person presses play.
The bundled skill connects fframes to the recent wave of coding-agent tools without treating a prompt as the product. The API is intentionally explicit, and the repository says that verbosity delayed its release. An agent absorbs much of that typing cost, while deterministic frame functions and inspection commands make its output easier to audit. That bargain is specific: fframes reduces the distance between generated code and testable video, though a human still decides whether the pacing, hierarchy and sound feel right.
Native speed brings native setup
The switch away from browser rendering carries a heavier toolchain. A basic project starts with Rust and cargo-fframes:
cargo install --locked cargo-fframes
cargo fframes new my-video
cd my-video && cargo run --release -- preview
On macOS and Linux, the first build can download prepared Skia and FFmpeg libraries for ARM64 or x86-64. Other targets and feature combinations may compile them from source, which the installation notes say can take up to roughly 20 minutes. Linux users also need packages such as Clang, NASM and the development libraries for the codecs they enable. Windows uses a shared FFmpeg 9 build and LLVM configuration rather than the same source-build route.
That setup will narrow the audience. Teams already using Rust, native CI images or large batches of generated motion graphics have a reason to pay the installation cost. A designer-developer who wants React components, browser CSS and the npm ecosystem may value Remotion's familiar model more than a faster pathological benchmark. Our review of fframes covers the setup reality and project fit in more detail.
There are also operational questions the star spike cannot answer. The 1.1.0 release's codec-thread fix shows that parallel rendering and native encoders can interact in ways that only appear under load. The documentation warns that caching source-built FFmpeg artifacts across machines with different CPUs can produce an illegal-instruction crash unless portable build settings are enabled. The README gives a build-portable configuration for that exact case.
Fframes earned its 722-star day with an easy promise to understand: stop waiting on a browser to draw coded video. Its more durable contribution may be the set of inspection surfaces around the renderer. The next useful evidence will be independent timings on normal projects, GPU results on supported hardware, and reports from CI systems that build the native stack repeatedly. If those arrive, developers can judge the trade with their own render queues rather than with a single dramatic ratio.