
ultrafast
io.github.ultrafastmov/ultrafast
Video shot on the GPU: shaders, 3D, motion type and camera optics, written by your agent.
Documentation
Shaders, 3D, motion type and camera optics,
written by your agent and rendered on the GPU. Open source.
ultrafast.mov · Quickstart · Examples · Use cases · Agent guide · Compare
curl -fsSL https://ultrafast.mov/install.sh | sh
Then tell your agent “Go to ultrafast.mov and make…”, or connect it yourself (Claude Code, Codex, Cursor, Gemini CLI). macOS (Apple silicon) and Linux; other ways to install.
How it compares
| ultrafast | Remotion | HyperFrames | Shotstack | |
|---|---|---|---|---|
| Draws each frame with | GPU kernels, Metal or Vulkan; no browser | headless Chrome, a screenshot per frame | headless Chrome, captured frame by frame | a hosted renderer |
| Renders on | your GPU, locally or with uf serve | your machine, or Lambda or Cloud Run in your cloud | your machine; Lambda, Cloud Run or HeyGen's cloud | Shotstack's cloud only |
| Render a 10 s video, end to end² | 0.85–0.98 s | 2.25–6.69 s at its fastest, 4.45–8.53 s by default | 3.31–4.46 s at its fastest, 3.71–5.05 s by default | not measured: it renders only in its own cloud |
| Tokens an agent writes for a 10 s short¹ | 1,234 | 1,868 | 1,680 | 1,657 |
| Licence | Apache-2.0 or MIT | source-available; companies of 4 or more need a paid licence | Apache-2.0 | proprietary API |
| Cost to render | your own GPU, nothing else | free on your machine; a company licence; your cloud bill | free on your machine; your cloud bill or HeyGen credits | 5–20¢ a rendered minute |
¹ Measured 22 November 2026: the same 10-second 1080×1920 short (footage, an animated title, three lines of detail, captions timed to each word, a grade and grain), written the way each tool's own docs and agent skills recommend, counted with the o200k_base tokenizer over the files the agent writes. Counting only what is typed after each tool's scaffold: 1,218, 1,660, 1,500 and 1,657. Remotion 4.0.545, HyperFrames 0.9.79; the Shotstack edit was validated, not rendered. Projects and counts: ultrafastmov/benchmarks/tokens. Competitor facts are from their own docs: Remotion and HyperFrames, Shotstack.
² Three 10-second videos: a 1080×1920 title card, a 1920×1080 chart, and 1080×1920 footage with word-timed captions. Each is 300 frames to H.264, timed from command start to the finished MP4, median of 5 warm runs on one RTX 5090 workstation (Ryzen 9 9950X3D2). “Fastest” is the best of every setting tried for each tool (concurrency 2 to 32, a prebuilt bundle, GPU flags, NVENC); ultrafast ran its default command. Cold first runs: ultrafast 2.5 s, Remotion 8.4–12.6 s, HyperFrames 3.7–5.6 s. At the same nominal CRF, ultrafast's hardware-encoded files are 2 to 4.4 times larger. Every project, run and caveat: ultrafastmov/benchmarks.
Pick a browser renderer instead when your team already builds the parts as React components or HTML, or you need Remotion's embeddable web player or HeyGen's avatars and voices; pick Shotstack when you want a hosted API and no GPU of your own.
Made by asking.
What agents made with it, and each brief in a sentence. Every film comes with the document that made it.
|
Launch films review: 0 findings · document
|
One video per customer review: 0 findings · document
|
|
Data stories review: 0 findings · document
|
Loops and visuals review: 0 findings · document
|
|
Documentaries and recaps review: 0 findings · document · full length, with sound ↓
|
Podcast and interview clips review: 0 findings · document · full length, with sound ↓
|
Export times are wall-clock uf export runs on one RTX 5090. The documentary and the podcast cut NASA film and sound, which is in the public domain. More films, each with its document: ultrafast.mov/examples.
Watch three at full length
https://github.com/user-attachments/assets/97a03c21-85e9-4bd4-8cf5-e0e954d8869f
https://github.com/user-attachments/assets/4dc54f6a-fc8e-41ad-92c7-d5dd55e85242
https://github.com/user-attachments/assets/279b8b3e-051a-412d-b155-2d2e94f7f137
The documentary (sound on), the lens launch film and the podcast clip (sound on). The lens, its iris and every element of the exploded view are geometry and materials in the document, lit and rendered by ultrafast.
Edit it by asking.
Your agent edits the video, not the pixels. One sentence changed one node: the
pot's shape, its camera and its shader. The type, light and timing stayed as
they were. This works today in Claude Code, Codex, Cursor and Gemini CLI with
uf mcp.
First draft: eight findings. Second: none.
Agents check their own work before anyone watches. uf review read all 300
frames of the teaser in 4.7 s and reported what a person would catch: text
that is clipped, too small, too low in contrast or on screen too briefly, and
seizure-risk flashing (WCAG 2.3.1). The agent fixed the document and ran it
again.
uf new vertical teaser.json # start from a template
uf check teaser.json # problems, without rendering
uf review teaser.json # reads every frame
uf export teaser.json teaser.mp4
3D, 2D, or both.
One engine renders 3D models, type, vector shapes, charts and footage, and composites them in the same frame. No Blender, no After Effects, no plugins. The lens and the pot are geometry and materials in their documents, lit and rendered by ultrafast, not made in a 3D app; turning the camera is one more render of the same node, about 0.3 s.
Speed
The planner fuses chains of ops into one generated kernel per group, caches what does not change, skips what cannot be seen and renders costly looks at reduced resolution. Motion blur samples only what moves. Exports render straight into the hardware encoder with no readbacks, and geometry that holds still is not drawn again. No browser anywhere in the loop.
How it works
A frame is a stack of plates, and each plate is a node in one document. The agent writes the document (JSON, or the MCP tools), ultrafast compiles it to GPU kernels once, then draws and encodes every frame on the GPU: Metal on macOS, Vulkan everywhere else. How it works in detail.
"vessel": { "op": "shader", "code": "// a lathe, its profile keyed…", "u4": { "keys": [ … ] } },
"dust": { "op": "particles", "rate": 34, "life": [6, 9] },
"title": { "op": "text", "text": "Spin something new.", "font": "ultrafast:display", "size": 176 },
"grain": { "op": "grain", "amount": 0.05 }
Wherever your agent runs
| Where | How | |
|---|---|---|
| MCP server | uf mcp, 20 tools, on your machine | available |
| Coding agents | Claude Code, Codex, Cursor, Gemini CLI | available |
| Skill and plugin | npx skills add ultrafastmov/ultrafast | available |
| Remote MCP | /mcp on your own uf serve, one key | available |
| SDKs | pip install ultrafastmov · npm i ultrafastmov | available |
| Framework starters | Vercel AI SDK, OpenAI Agents SDK, LangGraph, Mastra (starters) | available |
| Self-host | docker run --gpus all ghcr.io/ultrafastmov/ultrafast · HTTP API | available |
| ChatGPT app, Claude connector | make and edit videos in a chat | coming soon |
| ultrafast Cloud | hosted GPUs, one API key | waitlist |
claude mcp add ultrafast -- uf mcp # Claude Code
codex mcp add ultrafast -- uf mcp # Codex
gemini extensions install https://github.com/ultrafastmov/ultrafast # Gemini CLI
Cursor, Claude Desktop and the rest take {"command": "uf", "args": ["mcp"]};
the Claude Code plugin is claude plugin marketplace add ultrafastmov/ultrafast
then claude plugin install ultrafast@ultrafast. Every client and tool is in
docs/MCP.md.
Listed on the official MCP Registry as mcp-name: io.github.ultrafastmov/ultrafast
Install
curl -fsSL https://ultrafast.mov/install.sh | sh # macOS (Apple silicon), Linux x86_64
brew install ultrafastmov/tap/ultrafast # Homebrew, prebuilt
cargo install ultrafast # from crates.io
docker run --gpus all ghcr.io/ultrafastmov/ultrafast:latest info
Prebuilt archives for macOS (Apple silicon) and Linux x86_64 (glibc 2.28 and
newer) are on the releases page;
each carries the Slang libraries it loads, and the image carries everything.
cargo install fetches Slang once, on first use. On Linux you need your GPU's
Vulkan driver, ffmpeg for exports, and espeak-ng and tesseract for voiceover
and ocr (macOS uses its own voices and Vision). Windows runs it in WSL2
(docs/WINDOWS.md). uf is the same command as ultrafast,
short.
Try it
uf new vertical film.json
uf check film.json
uf sheet film.json --count 9 --out sheet.png
uf live film.json
uf review film.json
uf export film.json film.mp4
uf export film.json overlay.mov --codec prores --alpha --size 4k
uf export film.json preview.gif --quality draft --size 480p --fps 15
The films in examples/films (each a short Python script
that writes the document) show the range: ink, riso, glass, clay,
kinetic, chrome, signal_film, terminal, warp, pulse, assemble,
flow, launch, numbers_film, blocks, prism, ledger (charts on
paper), ship (code typing into a live preview).
What's in the box
Compose anything in one graph. Shapes, gradients, noise, images and video; shaped text with variable fonts, glyph animators, text on paths and counters; vector paths with strokes, dashes, trims and morphs; SVG files as editable vector nodes; Lottie animations as editable paths and keyframes (closely matching lottie-web, rendered hundreds of frames a second); agent-written Slang shaders; 3D (extruded and bevelled type, glTF, primitives) with image-based lighting, shadows, fog, depth of field and refractive glass; particles and swarms that form type; fluid (ink, smoke) and feedback simulations (trails, echo tunnels, reaction-diffusion), exact on export and seekable; masks, 19 blend modes, warps, blurs; looks such as bloom, grain, grades, halftone, CRT, glitch, glass panes, lens flares and light leaks; sound mixed into exports, with params driven by a soundtrack's loudness.
Every deliverable from one document. H.264, HEVC and AV1 MP4s, ProRes (proxy to 4444 XQ) and transparent ProRes 4444, VP9 WebM with alpha, GIFs, PNG and EXR sequences and sound alone; rendered at any size, so 720p and a sharp 4K come from the same 1080p document; any frame rate; four quality levels from a fast draft to a master.
Made for agents. Write JSON or call MCP tools. uf check finds mistakes
before rendering; uf review renders the film and reports text that is
unreadable, clipped, overlapping or on screen too briefly, and seizure-risk
flashing. block gives finished titles, lower thirds, quotes, stats, chapter
markers, end cards and charts (bars, lines, donuts that build themselves from
values); code types highlighted source into a window; one text node mixes
faces and colors ("Video is *live*", [300 fps]{highlight=#ff4d6d});
stack lays content out by its measured size; captions animates a
transcript; uf voiceover speaks a script with word times; uf new starts
from a template. Five typefaces are bundled so documents look the same
everywhere.
Live. uf live plays a document in a player while agents edit it over a
socket; parameter edits apply on the next frame without recompiling,
structural edits compile in the background, and the player outlines what an
edit touched. uf record films a document being edited.
Docs
| Doc | What's in it |
|---|---|
| docs/AGENT_GUIDE.md | how to work in it (start here) |
| docs/OPS.md | every op; uf ops prints the same as JSON |
| docs/MCP.md | ultrafast as MCP tools, local and remote |
| docs/LIVE.md | the live player, edit protocol, recording |
| docs/service/SELF_HOST.md | the render service on your GPU (uf serve) and its HTTP API |
| sdk/python, sdk/typescript | the SDKs; starters for agent frameworks |
| docs/ARCHITECTURE.md | how it works |
| docs/LINUX_NVIDIA.md, docs/WINDOWS.md | Linux with NVIDIA, Windows through WSL2 |
| docs/RECONSTRUCTION.md | a finished video back into an editable document |
Your GPU today. ultrafast Cloud soon.
The engine is free under Apache-2.0 or MIT, for commercial use, at any scale: Metal on macOS (Apple silicon), Vulkan on Linux and Windows (WSL2), with the MCP tools, the live player and the render service in the box. ultrafast Cloud will run the same engine and HTTP API on hosted GPUs with one API key, and the ChatGPT app, the Claude connector and remote MCP with sign-in will run on it. Join the waitlist for one email when it opens.
Questions
What is ultrafast?
An open-source video engine built for AI agents. A video is a document of nodes (footage, type, shapes, 3D, effects); ultrafast checks it, shows the agent its frames and renders it on the GPU at hundreds of frames a second.
Do I need a GPU?
Yes, for now: a Mac with Apple silicon, or a computer with a Vulkan GPU on Linux or Windows (through WSL2). ultrafast Cloud, which renders on hosted GPUs, is coming soon: join the waitlist.
Can it edit my own footage?
Yes. Cut, trim, speed-ramp, reframe, grade, key and caption video files, mix in music and voiceover, and add titles, logos and charts. The footage examples cut, caption and grade NASA film and sound.
Is the 3D in the examples rendered by ultrafast?
Yes. The pot, the lens, the compass, the chrome ring, the Earth and the Moon are geometry and materials written in each film's document. ultrafast lights and renders them on the GPU every frame, in the same pass as the type. Nothing was filmed, and nothing was made in a 3D app.
Which sizes and formats can it make?
Any size and frame rate: 9:16, 1:1, 4:5, 16:9, 21:9 or your own, up to 4K. MP4 (H.264, HEVC, AV1), ProRes up to 4444 XQ, transparent ProRes and WebM, GIF, PNG and EXR sequences, and sound alone.
What does it cost?
Nothing. The engine is free under Apache-2.0 or MIT, for commercial use, at any scale.
Building from source
- Rust (stable;
cargo build --release) - Slang 2026.19 or newer,
found in this order:
ULTRAFAST_SLANG_DIR(the folder withlib/libslang.dyliborlib/libslang.so); aslang-*folder beside the executable, as the release archives have;SLANG_DIRat build time; a copy fetched once into the cache (ULTRAFAST_SLANG_FETCH=0turns fetching off). - ffmpeg for exports on the Vulkan backend, recordings, and media off macOS.
Releases: packaging/ builds the archives, the Homebrew formula and the
image, and .github/workflows/release.yml builds, tests and publishes all
of them from a v* tag.
Build with --features vulkan to run the Vulkan backend on a Mac through
MoltenVK; every GPU test passes on both backends. On Windows with an NVIDIA
GPU, tools/windows/build.sh builds and installs ultrafast from WSL2
(docs/WINDOWS.md); Linux with NVIDIA is
docs/LINUX_NVIDIA.md.
Contributing and security
See CONTRIBUTING.md. Report vulnerabilities privately as described in SECURITY.md.
License
Licensed under either of Apache License, Version 2.0 or MIT license, at your option. Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in ultrafast by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
Bundled fonts are under the SIL Open Font License (see
examples/assets/fonts/licenses).
https://github.com/ultrafastmov/ultrafast/releases/download/v0.1.1/ultrafast-0.1.1-macos-arm64.mcpb# mcpb: https://github.com/ultrafastmov/ultrafast/releases/download/v0.1.1/ultrafast-0.1.1-macos-arm64.mcpbhttps://github.com/ultrafastmov/ultrafast/releases/download/v0.1.1/ultrafast-0.1.1-linux-x86_64.mcpb# mcpb: https://github.com/ultrafastmov/ultrafast/releases/download/v0.1.1/ultrafast-0.1.1-linux-x86_64.mcpb