Repository avatar
Multimedia
v0.1.1
active

ultrafast

io.github.ultrafastmov/ultrafast

Video shot on the GPU: shaders, 3D, motion type and camera optics, written by your agent.

Documentation

ultrafast: shot on the GPU. A pottery class teaser plays beside an excerpt of the document that made it; it exported in 1.68 s at 1080×1920.

Shaders, 3D, motion type and camera optics,
written by your agent and rendered on the GPU. Open source.

crates.io PyPI npm CI Apache-2.0 or MIT MCP: 20 tools

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

Render time, end to end, for three 10-second videos on one RTX 5090 workstation, Remotion and HyperFrames at their fastest settings. Title card: ultrafast 0.85 s, Remotion 2.32 s, HyperFrames 3.53 s. Chart: 0.88, 2.25, 3.31 s. Footage and captions: 0.98, 6.69, 4.46 s. Tokens an agent writes for one 10-second short: ultrafast 1,234, Remotion 1,868, HyperFrames 1,680, Shotstack 1,657.

ultrafastRemotionHyperFramesShotstack
Draws each frame withGPU kernels, Metal or Vulkan; no browserheadless Chrome, a screenshot per frameheadless Chrome, captured frame by framea hosted renderer
Renders onyour GPU, locally or with uf serveyour machine, or Lambda or Cloud Run in your cloudyour machine; Lambda, Cloud Run or HeyGen's cloudShotstack's cloud only
Render a 10 s video, end to end²0.85–0.98 s2.25–6.69 s at its fastest, 4.45–8.53 s by default3.31–4.46 s at its fastest, 3.71–5.05 s by defaultnot measured: it renders only in its own cloud
Tokens an agent writes for a 10 s short¹1,2341,8681,6801,657
LicenceApache-2.0 or MITsource-available; companies of 4 or more need a paid licenceApache-2.0proprietary API
Cost to renderyour own GPU, nothing elsefree on your machine; a company licence; your cloud billfree on your machine; your cloud bill or HeyGen credits5–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.

Lens launch: a 35 mm lens rendered in 3D by ultrafast, its iris and an exploded view of its elements

Launch films
you A launch film for our 35 mm lens: the knurling, the iris, an exploded view, then the price.

16:9 · 1920×1080 · 16 s · exported in 4.88 s · review: 0 findings · document
Year in review: four members' films from one document, each with its own numbers and colours

One video per customer
you Make every member their year in review from this spreadsheet.

9:16 · 1080×1920 · 12 s · exported in 1.37 s · review: 0 findings · document
The Keeling Curve: Mauna Loa CO₂ drawn month by month

Data stories
you Turn NOAA's Mauna Loa CO₂ file into a chart for Instagram.

4:5 · 1080×1350 · 16 s · exported in 1.50 s · review: 0 findings · document
Celadon dish: a reaction-diffusion pattern grows across a glazed dish

Loops and visuals
you A 15-second loop for the album cover: something growing, in celadon.

1:1 · 1080×1080 · 15 s · exported in 1.06 s · review: 0 findings · document
Two launches, one count: Apollo 11 and Artemis I cut together on the 1969 countdown

Documentaries and recaps
you Cut the Apollo 11 and Artemis I launches together on the 1969 countdown. Make it feel like a documentary.

2.39:1 · 1920×804 · 22.5 s · exported in 3.36 s · review: 0 findings · document · full length, with sound ↓
Podcast clip: an astronaut talks about Earth from orbit, with word-by-word captions

Podcast and interview clips
you Pull the best 25 seconds from this episode. Captions on, vertical, our colours.

9:16 · 1080×1920 · 27.5 s · exported in 4.07 s · 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.

A conversation with a coding agent. You: a 10-second vertical teaser for my pottery class. The agent's film shows a vase on the wheel. You: make it a wide bowl instead of a vase. The agent edited one node, and the film now shows a bowl; the type, light and timing are unchanged.

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.

Contact sheets of two drafts. The first is marked up in red pen: a white flash, a clipped title, low-contrast and tiny text, a line on screen too briefly. The second is stamped 0 findings, beside the loop: new, check, review, export.

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.

Four prints: the lens in 3D; the same lens with the camera turned 84 degrees; a Swiss-style concert poster of type and shapes; the pottery teaser with a 3D pot under set type.

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

894 frames a second at 1920×1080 with 6-sample motion blur on one RTX 5090. Press log: launch film, 16 s, exported in 4.88 s; simulation, 15 s, in 1.06 s; class teaser, 10 s, in 1.68 s.

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

The pottery teaser separated into its six plates (backdrop shader, vessel shader, particles, title, details, grain), beside the six lines of the document, one node per plate.

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

WhereHow
MCP serveruf mcp, 20 tools, on your machineavailable
Coding agentsClaude Code, Codex, Cursor, Gemini CLIavailable
Skill and pluginnpx skills add ultrafastmov/ultrafastavailable
Remote MCP/mcp on your own uf serve, one keyavailable
SDKspip install ultrafastmov · npm i ultrafastmovavailable
Framework startersVercel AI SDK, OpenAI Agents SDK, LangGraph, Mastra (starters)available
Self-hostdocker run --gpus all ghcr.io/ultrafastmov/ultrafast · HTTP APIavailable
ChatGPT app, Claude connectormake and edit videos in a chatcoming soon
ultrafast Cloudhosted GPUs, one API keywaitlist
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

DocWhat's in it
docs/AGENT_GUIDE.mdhow to work in it (start here)
docs/OPS.mdevery op; uf ops prints the same as JSON
docs/MCP.mdultrafast as MCP tools, local and remote
docs/LIVE.mdthe live player, edit protocol, recording
docs/service/SELF_HOST.mdthe render service on your GPU (uf serve) and its HTTP API
sdk/python, sdk/typescriptthe SDKs; starters for agent frameworks
docs/ARCHITECTURE.mdhow it works
docs/LINUX_NVIDIA.md, docs/WINDOWS.mdLinux with NVIDIA, Windows through WSL2
docs/RECONSTRUCTION.mda 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 with lib/libslang.dylib or lib/libslang.so); a slang-* folder beside the executable, as the release archives have; SLANG_DIR at build time; a copy fetched once into the cache (ULTRAFAST_SLANG_FETCH=0 turns 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).


Send your agent to ultrafast.mov

MCPB
https://github.com/ultrafastmov/ultrafast/releases/download/v0.1.1/ultrafast-0.1.1-macos-arm64.mcpb
Install Command
# mcpb: 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-linux-x86_64.mcpb
Install Command
# mcpb: https://github.com/ultrafastmov/ultrafast/releases/download/v0.1.1/ultrafast-0.1.1-linux-x86_64.mcpb