26 fps
Remotion, per worker
Holds ~26 fps whether the scene has 6 nodes or 201 — you pay the browser tax, not for the drawing.
● Benchmark
ONDA vs Remotion, measured.
The same 1080p composition, rendered on the same machine, with the same encoder. ONDA draws natively on the GPU; Remotion drives every frame through a headless browser. The numbers below are from the repo's reproducible suite — higher fps is better.
217 fps
ONDA GPU, the heavy scene
Renders the 33× heavier scene only 1.4× slower than trivial. Cost tracks the graphics, not the browser.
How it's measured
Same scene. Same machine. Same encoder.
onda-bench's cluster(i) and Remotion's <Cluster i>
use identical geometry and scatter formula, so the two stay directly comparable as the
scene scales from trivial to complex.
- Apple M4 PromacOS, same machine for both
- 1920 × 1080120 frames, one warm-up
- libx264identical encoder on both engines
- The scene: a clustertwo translucent discs, an accent bar, a title and a subtitle.
repeatsscatters N identical clusters — from 1 (6 nodes) to 40 (201 nodes, heavy overdraw + 80 text runs). - Steady-statemeasured after warm-up; small run-to-run variance
Raster throughput · draw only
Remotion's cost is flat. ONDA's tracks the scene.
Pure drawing throughput, before any encode. On a trivial scene ONDA already pulls ahead; on a complex one the gap widens — because Remotion pays a fixed browser tax per frame while ONDA only pays for what it actually draws.
Trivial scene
ONDARemotionComplex scene
ONDARemotionHonest caveat: ONDA's CPU reference rasterizer is software and overdraw-bound, so it falls behind on heavy scenes — use the GPU path for those. The GPU renders the 33×-heavier scene only 1.4× slower than trivial.
Full pipeline · render → MP4
What an export actually costs
End-to-end: GPU render, readback, and the same libx264 encode both engines
use. One single-threaded ONDA process still beats Remotion's whole multi-worker pool.
Trivial scene
ONDARemotionComplex scene
ONDARemotionWith libx264 on both, one ONDA process exports ~5.4× faster than a Remotion worker on the trivial scene and ~4.1× on the complex one — and ~1.7–1.8× faster than Remotion's whole pool, single-threaded. Hardware encode is slower here: VideoToolbox's per-call overhead loses to libx264 on short clips (it pays off at 4K / long renders), so libx264 stays the portable default.
The trajectory
Measured multiples today. A 100× architectural ceiling.
The per-thread gap already grows with scene complexity. The 100× figure is the realized goal on real workloads — it comes from what this microbenchmark doesn't capture: cold-start (ONDA ~ms vs a Chromium launch + bundle + warmup), a real-time GPU present, and offloaded codec work. It's a target, not a single-scene result.
- 3.8× trivial scene per thread · ONDA CPU vs a Remotion worker
- 8.5× complex scene per thread · ONDA GPU vs a Remotion worker
- 100× target architectural ceiling complex × GPU present × cold-start × concurrency — not a single benchmark
Reproduce
Run it yourself
No performance claim without a benchmark. The full harness lives in the repo — clone it and run both engines on your own hardware.
# ONDA (Rust, CPU + GPU backends) — args: <frames> <clusters>
cargo run --release -p onda-bench -- 120 1 # trivial
cargo run --release -p onda-bench -- 120 40 # complex
# Remotion (React → headless Chromium → screenshot → encode)
pnpm --filter benchmark bench 1
pnpm --filter benchmark bench 40
# ONDA full export (Vello raster + readback + encode → mp4)
pnpm --filter benchmark bench:onda 120 1
pnpm --filter benchmark bench:onda 120 40Numbers on this page are steady-state on an Apple M4 Pro and vary a little run-to-run and by hardware, scene and configuration. Full method, tables & source →
Render your first frame without a browser
Clone the repo, write a composition, ship a video. The source is all public.
Get started