1. ultrafast
  2. Docs

Docs

Quickstart

Install it, make your first video, then hand the loop to your agent.

Install

One binary, ultrafast, with uf as its short name. Pick one:

shell
brew install ultrafastmov/tap/ultrafast    # macOS and Linux, prebuilt
cargo install ultrafast                    # from crates.io, Rust 1.91 or later
docker run --gpus all ghcr.io/ultrafastmov/ultrafast:latest info

Or download a prebuilt archive for macOS (Apple silicon) or Linux x86_64 from GitHub releases. It renders with Metal on macOS and Vulkan on Linux, and on Windows through WSL2 (WINDOWS.md). Exports on Vulkan use ffmpeg, and on Linux voiceover and OCR use eSpeak NG and Tesseract. The Docker image includes all of them; the prebuilt binaries include everything else. No GPU? ultrafast Cloud is coming soon.

check the GPU
$ uf info
backend: vulkan
device:  NVIDIA GeForce RTX 5090

Your first video

Start from a template, look at it, then export it.

shell
uf new vertical film.json                       # 1080×1920, 6 s, already looks finished
uf check film.json                              # problems, before anything renders
uf sheet film.json --count 9 --out sheet.png    # nine frames in one image
uf live film.json                               # plays it; edits show on the next frame
uf review film.json --safe social               # what a viewer would trip over
uf export film.json film.mp4                    # hardware-encoded mp4

Other templates: title, square, promo, explainer and product. Edit the words in film.json and run uf export again.

What you just made

A video is one JSON document: a format, a graph of nodes, and the node to output. Nodes are sources (footage, type, shapes, 3D), effects and composites; any param can be animated.

hello.json
{
  "version": 1,
  "format": { "width": 1920, "height": 1080, "fps": 60, "duration": 4.0 },
  "output": "comp",
  "nodes": {
    "bg":   { "op": "gradient", "params": { "a": "#0b0b1a", "b": "#2a1650" } },
    "disc": { "op": "shape", "params": {
      "kind": "circle", "color": "#ff7a2e", "size": [360, 360],
      "center": { "keys": [
        { "t": 0, "v": [560, 540], "ease": "in_out_cubic" },
        { "t": 4, "v": [1360, 540] }
      ] } } },
    "comp": { "op": "over", "inputs": { "fg": "disc", "bg": "bg" } }
  }
}

The whole vocabulary is in the op reference, and uf ops prints it as JSON. The shape of a document is in The document.

The loop

This is how an agent works, and how you should too:

  1. Start from uf new or a copy of an example.
  2. Check: uf check reports unknown ops, misspelled params (with suggestions), wrongly shaped values, broken shaders and missing files, without rendering.
  3. Look: uf sheet for motion at a glance, uf render --at 2.5 for one exact frame, uf inspect --at 2.5 for which node drew what.
  4. Review: uf review renders the film and reports unreadable, clipped, overlapping, tiny or too-brief text, text under social app buttons, and flashing faster than three times a second.
  5. Export: uf export, hardware-encoded with sound and motion blur.

Connect an agent

uf mcp serves all of this as 20 MCP tools over stdio. Frames and contact sheets come back as images, so the agent sees what it made.

Claude Code
claude mcp add ultrafast -- uf mcp

Codex, Cursor, Gemini CLI and remote MCP over HTTP are on the MCP page. Agents can also read llms.txt and every page of these docs as Markdown.

Run it as a service

uf serve puts the engine behind an HTTP API and remote MCP on your GPU, with one API key, for apps, the SDKs and agents on other machines.

shell
uf serve --port 8080                   # prints its API key at first start
export ULTRAFAST_API_KEY=uf_live_...
jq '{document: ., output: {inline: true}}' film.json |
curl http://localhost:8080/v1/render -H "Authorization: Bearer $ULTRAFAST_API_KEY" \
  -H "Content-Type: application/json" --data-binary @- -o film.mp4

The requests are in HTTP API. A hosted version, ultrafast Cloud, is coming soon: join the waitlist.

Next