At a glance
Side by side.
| ultrafast | HyperFrames | |
|---|---|---|
| How a frame is made | GPU kernels compiled from the document; encoded on the same GPU | a page laid out in Chrome via Puppeteer, captured per frame, encoded with FFmpeg; 1 to 24 browsers of about 256 MB each |
| You write | one JSON document with a published schema | HTML and CSS with data-* timing, and a paused GSAP timeline or another adapter |
| Output tokens for a 10 s short | about 1,100, all of it the video | about 4,400, most of it web code |
| Speed, 300 frames of 1080p | 0.34 s with 6-sample motion blur, one RTX 5090 | 9.8 s; 25 s with one costly CSS rule |
| Same pixels everywhere | bundled fonts, the same kernels on every machine | fonts and Chrome versions can shift pixels; --docker pins them |
| Install | one binary | Node 22+, FFmpeg, a managed Chrome |
| For agents | 20 MCP tools (local and remote) including check, review and inspect; frames returned as images; ChatGPT and Claude apps coming soon | 9 skills; plugins for 6 agents; a Claude connector with compose and render_video; a ChatGPT Work plugin |
| Review of the result | every frame read for unreadable, clipped or too-brief text and flashing | no built-in review |
| Effects | 3D with image-based light and glass, raymarching, particles, fluid and feedback sims, Slang shaders | Three.js, WebGPU, Lottie, WebGL shader transitions, motion blur |
| Export | H.264, HEVC and AV1 MP4; ProRes proxy to 4444 XQ; transparent ProRes 4444 and VP9 WebM; GIF; PNG and EXR sequences; sound alone. Any size and frame rate; draft, standard, high and master | H.264 and H.265 MP4, ProRes, transparent WebM and MOV, GIF, PNG sequences, HLS, HDR10; draft, standard and high; 1080p or 4K |
| Licence | Apache-2.0 or MIT | Apache-2.0 |
| Hosted rendering | your own GPU with uf serve; ultrafast Cloud has a waitlist | HeyGen credits, or your own Lambda or Cloud Run |
Speed
About 30 times their own number.
HyperFrames' performance guide renders 300 frames of 1080p in 9.8 s. ultrafast renders 300 frames of 1080p, with 6-sample motion blur, in 0.34 s.
- ultrafast 0.34 s
- HyperFrames 9.8 s
- HyperFrames, one costly CSS rule 25 s
Tokens
A quarter of the tokens.
Output tokens an agent writes for a 10-second vertical short: footage, a title, three lines of detail, captions timed to each word, a grade and grain. In a web project most of them are web code. In an ultrafast document, every token describes the video.
- ultrafast 1,100
- HyperFrames 4,400
describes the video; web code around it: imports, components, styles, timeline set-up, project files
The same title, both ways.
The pottery teaser’s title, its letters rising in one by one.
ultrafast
"title": {
"op": "text",
"params": {
"text": "Spin something new.",
"font": "ultrafast:display", "weight": 300, "size": 176,
"color": "#f1e8dc", "position": [80, 380], "valign": "baseline",
"width": 880, "line_height": 0.9, "tracking": -3,
"stagger": 0.03,
"glyph_opacity": { "keys": [
{ "t": 0.7, "v": [0], "ease": "in_out_sine" },
{ "t": 1.5, "v": [1] } ] },
"glyph_offset": { "keys": [
{ "t": 0.7, "v": [0, 56],
"ease": { "bezier": [0.16, 1, 0.3, 1] } },
{ "t": 1.8, "v": [0, 0] } ] }
}
}HyperFrames
<div id="root" data-composition-id="teaser" data-start="0"
data-width="1080" data-height="1920">
<h1 id="title" class="clip" data-start="0" data-duration="10"
data-track-index="1">Spin something new.</h1>
</div>
<style>
@import url("https://fonts.googleapis.com/css2?family=Fraunces:wght@300");
#title {
position: absolute; left: 80px; top: 222px; width: 880px;
margin: 0; font: 300 176px/0.9 "Fraunces", serif;
letter-spacing: -3px; color: #f1e8dc;
}
#title .w, #title .c { display: inline-block; }
</style>
<script src="https://cdn.jsdelivr.net/npm/gsap@3/dist/gsap.min.js">
</script>
<script>
const title = document.getElementById("title");
title.innerHTML = title.textContent.split(" ").map((w) =>
'<span class="w">' + [...w, "\u00a0"].map((c) =>
'<span class="c">' + c + "</span>").join("") + "</span>"
).join("");
const tl = gsap.timeline({ paused: true });
tl.from("#title .c", { opacity: 0, duration: 0.8,
ease: "sine.inOut", stagger: 0.03 }, 0.7);
tl.from("#title .c", { y: 56, duration: 1.1,
ease: "expo.out", stagger: 0.03 }, 0.7);
window.__timelines = window.__timelines || {};
window.__timelines["teaser"] = tl;
</script>The rest of the gap is the effects: grain, a grade and captions timed to each word are a script or a canvas each in HyperFrames and one node each in ultrafast.
| 10,000 shorts a month | output tokens | at $20 per million |
|---|---|---|
| ultrafast | 11 million | $220 |
| HyperFrames | 44 million | $880 |
Beyond the browser
What a page can't do quickly.
In a browser, every glass refraction, particle and fluid step is work done inside a web page. In ultrafast they are nodes in the same graph as the captions, fused into GPU kernels.
3D
Extruded and bevelled type, glTF, image-based light, shadows, depth of field, refractive glass, and raymarched product shots.
Simulation
Particles and swarms that form type; ink and smoke fluid; feedback loops for trails and reaction-diffusion. Exact on export, and scrubbable.
Shaders
Agents write Slang shaders as nodes. check compiles them before anything renders.
Choose ultrafast when
- Render time and cost matter: shorts at scale, every aspect ratio, one per customer.
- An agent should review its own video before a person sees it.
- You need the same pixels on every machine without pinning a browser.
- You want 3D, simulation or shaders without a page doing the work.
Choose HyperFrames when
- You think in HTML, CSS and GSAP, or have compositions in them already.
- You need HeyGen's avatars and voices in the same tool.
- You need HDR10 or HLS output today.
- You have no GPU and want to render on CPUs.
Questions
Common questions.
Both are open source. What's the difference?
HyperFrames renders HTML and GSAP in headless Chrome; ultrafast renders a JSON document on the GPU. That makes ultrafast about 30 times faster on HyperFrames' own published numbers, and lets agents review the frames they made.
Will my video look the same on every machine?
With ultrafast, yes: fonts are bundled or fetched by name, and the GPU kernels are the same on every machine. HyperFrames notes that fonts and Chrome versions can shift pixels between machines unless you render in Docker.
Can I use GSAP or HTML I already have?
Not directly. Ask your agent to rewrite the composition as an ultrafast document, or run uf reconstruct on a finished render to get an editable draft.
Do I need Node or FFmpeg?
No Node. ultrafast is one binary; exports on Vulkan use FFmpeg, and the prebuilt binaries and Docker image bring what they need.
How many tokens does an agent spend on a HyperFrames video?
About 4,400 output tokens for a 10-second short: the HTML, the CSS, the GSAP timeline and the scripts for captions and grain. The same short as an ultrafast document is about 1,100. At $20 per million output tokens, 10,000 shorts cost about $880 to write in HyperFrames and $220 in ultrafast.
HyperFrames facts from its docs, checked 21 November 2026: repository, CLI, performance, determinism, plugins, MCP, Lambda. HyperFrames and HeyGen are trademarks of their owner.
Make one and time it.
Install the engine and time a render on your own GPU.
Want it hosted? Join the ultrafast Cloud waitlist.