Why we ran this
Dmitriy Kovalenko, who makes fframes, quoted a user whose heavy 81 second video went from 700 seconds in Remotion to under 21 in fframes. We pick a renderer for short product videos, so we wanted our own number on a plain clip built in both tools. We did not rebuild that heavy video, so this post does not test the 700 to 21 claim.
How the two tools draw a frame
Remotion renders a React page in headless Chrome (a browser with no window), screenshots each frame and hands the frames to FFmpeg. By default it ran 8 browser tabs in parallel on our Mac. fframes draws each frame as an SVG straight to the GPU with Skia, the graphics library inside Chrome, with no browser and no screenshot step.
The clip
We first made a small probe scene with fframes, then ported it element by element to Remotion: a 1920 by 1080 card at 30 frames a second with a drifting glow (an SVG gradient, no blur), a headline that springs up and fades in, a growing underline, a subtitle, a frame counter and the DM Sans font. Both encode with x264 at CRF 20, its quality dial, and the medium preset. fframes also sets x264's animation option, which Remotion does not.
To check that both tools drew the same thing, we compared the two 6 second files frame by frame with FFmpeg's SSIM score, where 1 means identical. They scored 0.997.
Render times: three sessions
Each number is the elapsed time of the whole render command, from start to a finished MP4. Session 1 ran each tool 3 times, one tool after the other, through cargo run (Rust's build-and-run command, which adds 2 to 4 seconds) and npx remotion render. Its machine load was not recorded. Sessions 2 and 3 ran the built fframes program directly and alternated the tools, 5 runs each. The Mac was shared with other jobs: load average 65 to 78 in session 2 and 17 to 41 in session 3, on 18 cores, where 18 means every core busy. We had no idle machine that day, so every number below comes from a busy Mac.
| Clip and session | fframes, fastest / median / slowest | Remotion, fastest / median / slowest | Median gap |
|---|---|---|---|
| 6 s, session 1 | 2.3 / 2.3 / 3.4 s | 9.8 / 13.0 / 14.7 s | 5.6 times |
| 6 s, session 2 | 1.0 / 1.3 / 5.9 s | 8.1 / 10.2 / 21.1 s | 7.6 times |
| 6 s, session 3 | 0.85 / 0.89 / 0.96 s | 6.9 / 7.3 / 8.2 s | 8.1 times |
| 60 s, session 1 | 12.3 / 21.5 / 22.1 s | 37.3 / 38.1 / 40.2 s | 1.8 times |
| 60 s, session 2 | 6.6 / 9.0 / 23.9 s | 37.1 / 50.0 / 60.1 s | 5.6 times |
| 60 s, session 3 | 5.8 / 8.8 / 11.3 s | 30.9 / 36.0 / 40.2 s | 4.1 times |
- No fframes run was slower than any Remotion run of the same clip in the same session. That holds in all 6 rows, which is a firmer claim than any one ratio.
- Noise was large. The same command varied by up to 5.6 times between runs in the busy session 2. Even session 3, the quietest, ran at load 17 to 41, and the 60 second gap moved from 1.8 to 5.6 times between sessions. Read the ratios as a range, not one number.
- We tried more Remotion tabs once. One session 1 run of the 60 second clip with every core given to Remotion (
--concurrency 100%) took 47.2 seconds, against 37 to 40 at the default. One run is not enough to conclude anything.
A straight line through session 3's medians at 6 and 60 seconds gives Remotion about 4 seconds of start-up plus 18 ms a frame, and fframes almost no start-up plus 5 ms a frame. So the gap has two parts: Remotion's browser start-up, which dominates a short clip, and a cheaper frame in fframes. Session 1's noisier medians give a smaller per-frame gap (15 against 12 ms), so treat the split as an estimate.
The edit-to-video loop
Render speed is only half of daily use. In a fourth session we made 5 one-line text edits in each tool, alternating, and timed each edit through to a finished 6 second MP4 (load 22 to 38).
| Edit then render, 6 s clip | Fastest / median / slowest |
|---|---|
| fframes: release rebuild with cargo, then render | 14.1 / 16.5 / 22.8 s |
| Remotion: render, no compile step | 8.1 / 9.1 / 10.8 s |
Remotion was quicker in all 5 pairs. The render itself takes fframes under a second, and nearly all of its time is the Rust compile. The first fframes release build, before any of this, took 2 minutes 8 seconds.
What we read from it
If you render many videos from a fixed scene, such as one template with new text per customer, fframes rendered this card 1.8 to 8.1 times faster on the median and was never slower in our runs. If you change the scene between short renders, Remotion gets you to the next video sooner, and React may be a language your team already knows.
For a heavy scene we have one fframes-only number. Its own 128 second intro example took 124 seconds on this Mac on 2026-10-09, about 16 ms a frame against 5 for our card. The maker reports 36 seconds for that video. 124 is 3.4 times that, and we do not know which hardware difference explains it. We did not run the intro in Remotion.
What we did not test
- A heavy scene in Remotion, or any scene other than this one card.
- A fully idle machine, any machine other than this Mac, Linux or a CI server.
- A scene written for Remotion first: ours was written for fframes and ported, which may favour fframes.
- Remotion tuning beyond one concurrency run, and fframes on its CPU backend.
- An fframes debug build, which compiles faster, or Remotion Studio's live preview. Either could change the edit-loop result.
How to repeat it
Our scene code for both tools is linked under Sources. Time each command 5 times with /usr/bin/time -p, alternating the tools:
cargo build --release && ./probe render
npx remotion render src/index.ts Probe out/remotion.mp4 --crf 20 --x264-preset medium --overwrite
ffmpeg -i fframes.mp4 -i remotion.mp4 -lavfi ssim -f null -
If the SSIM score is well under 0.99, the scenes differ and the times do not compare. Log uptime before each run. On a busy machine, alternate the tools so both see the same load.
If you only need a still share card rather than a video, our Live Card renders one from HTML in headless Chrome, the same capture model as Remotion. We did not benchmark it here.
The same numbers as 10 slides: fframes vs Remotion in 10 slides.
Sources
- Dmitriy Kovalenko on X, 2026-10-10: quotes a user whose 81 second video went from 700 seconds in Remotion to under 21 seconds in fframes.
- Dmitriy Kovalenko on X: the fframes intro video, "rendered in 36 seconds", also linked from the fframes README.
- fframes on GitHub: the Rust video library we used, version 1.2.0.
- Remotion CLI render options: the concurrency, CRF and frame range options we set.
- FFmpeg filters, SSIM: the frame-by-frame similarity score.
- Our run file: every render and edit time from sessions 1 to 4 on 2026-10-10, plus the 2026-10-09 intro run, with session, tool, clip, run order, load and notes.
- Our scene code: fframes lib.rs and main.rs, Remotion Probe.tsx and Root.tsx.