A headless 3D and VFX engine built for agents.

An agent writes a scene as code, renders it, looks at the result and revises the code. Written in Rust and Slang, rendering on the GPU through Vulkan and Metal.

InstallRun on Voyager cloud GPUsSource on GitHub

Research preview. Source-available and free during the preview.

A car drives into the night, and the world turns into its own triangles. Every cyan branch is a real triangle edge from a tree mesh, drawn by a shader the agent wrote. Astra wrote this shot as code.

Credit: “Car Concept” by Unity Fan, glTF adaptation by Eric Chadwick / Darmstadt Graphics Group, CC BY 4.0. Changes: scaled, animated, brighter head and tail lights, wheel pose. Trees, ground and asphalt from Poly Haven (CC0). The far mountains and sky are an image-model painting on a curved 3D card; everything else that moves is rendered.

Blender, Houdini, Unreal and Nuke were built for humans. vork is built for agents.

Tools built for humans need thousands of settings, because a person can’t write a shader in the middle of a shot. An agent can. So vork’s kernel holds only what agents can’t write on the fly, like geometry and ray queries, and the rest of the shot is code it writes as it goes.

  • Programs, not settings

    Scene programs define materials, cameras, light, simulation and compositing. An agent can rewrite the physics of light to curve it around a black hole, turn a forest into glowing wireframe mid-shot, or write its own flocking simulation.

  • A small kernel

    Getting-started help is about 2,500 tokens, including a complete first scene. More topics and detailed field lookups cover the rest. Ordinary shots need only scene data; the programming hooks are there when the shot needs something unusual.

  • Real footage too

    Composite against tracked footage using external camera/matte tools and authored proxy geometry.

What you can make.

Recipes demonstrate base effects; some final looks include extra staging, relighting and editorial composites.

A million birds

This is a million birds, each one steering itself, simulated and rendered in 97 seconds on one GPU. Blender’s EEVEE would need a projected 13-18 minutes just to draw them, about 8-11x longer, even if we handed it the finished flock. Astra wrote this shot as code, using a flocking simulation GPT-6.1 Sol wrote earlier.

The eight-second skim movie took 97 seconds after 244 seconds of setup and 166 seconds of scene warmup on an L4; asset preparation is separate. EEVEE’s 13-18 minutes is an eight-frame draw-only projection at the same four samples, across two runs, with the flock handed to Blender; quality, material translation and motion differ. The camera and nine foreground birds are authored, and the million simulated birds don’t flap.

Credit: This work is based on “Crow” by Alexei Ostapenko, CC BY 4.0. Changes: sampled flight pose, reduced distant mesh, rescaled, articulated flight wings, extracted wings for the starling body, resized textures.

VFX on real footage

This is real footage, and the glowing seed and the light it throws on the room are rendered 3D. Each wipe shows another step: the tracked camera and geometry, the seed, then the room relit to evening and night. GPT-6.1 Sol built the seed and repaired the camera solve. Astra made the later relight, composite and final wipes.

Credit: Footage: Ron Lach / Pexels, modified under the Pexels Licence. Original performer; no endorsement implied. Real footage + rendered 3D; no generative video.

Black hole

In most renderers, light travels in straight lines, but here that’s only a default. The agent wrote the physics of this black hole as a program, plugged into vork’s public light hook, with no black-hole code in the engine.

Credit: This work is based on “Corinth Cargo Transporter” by Yvo Pors, licensed under CC BY 4.0. Changes: decimated geometry, resized, compressed and exposure-adjusted textures, adjusted material roughness and metallic weight, placement and scale.

Cake

This cake isn’t real, and neither is anything else in the shot. It’s rendered 3D using Poly Haven assets, not a photographed take.

Credit: Poly Haven CC0 assets; carrot cake photography by Greg Zaal, processing by James Ray Cock; scene and render in vork.

Blender’s splash scene

This is Blender’s 3.5 splash scene rendered in vork.

Credit: “Cozy Kitchen” (Blender 3.5 splash scene) by Nicole Morena, source .blend, CC BY-SA (version unspecified by source). Adapted and rendered in vork: camera orbit, animated lighting, widescreen framing, material translation and staging changes. This adapted animation is shared under CC BY-SA. No artist endorsement implied.

Water

Agents wrote this GPU liquid simulation as Slang compute programs. vork isn’t Houdini yet, but more simulation is on the roadmap.

Isn’t this just an AI video model?

No. Everything that moves in these shots is rendered 3D, or real footage with rendered 3D and compositing on top. On real footage the agent fetched free tools like OpenCV and SAM 2.1 for tracking and cutouts. The one place an image model helped is the far mountains and sky behind the car, a painted backdrop the camera moves past. Nothing here came from a video model.

Install

Runs on Windows and Linux with a recent NVIDIA GPU, and on Apple Silicon with Metal; the bundled Slang toolchain targets macOS 26, and older macOS versions are unqualified. The installer verifies the release and runs vork setup. Manual archives and SDKs are in the README.

Linux x64, Ubuntu 22.04+ or glibc 2.35+, recent NVIDIA GPU

Install the NVIDIA driver for your GPU first. On Ubuntu 22.04+:

Terminal
sudo apt-get update
sudo apt-get install -y ca-certificates curl tar libvulkan1 libgomp1 ffmpeg
curl -fL https://github.com/voyager-so/vork/releases/latest/download/install.sh -o /tmp/vork-install.sh
sh /tmp/vork-install.sh
export PATH="$HOME/.local/bin:$PATH"
vork --version
vork help
Mac Apple Silicon with Metal, macOS 26

Apple Silicon with Metal; the bundled Slang toolchain targets macOS 26. Older macOS versions are unqualified. The README’s Mac table lists each binary’s deployment target. In Terminal:

Terminal
curl -fL https://github.com/voyager-so/vork/releases/latest/download/install.sh -o /tmp/vork-install.sh
sh /tmp/vork-install.sh
export PATH="$HOME/.local/bin:$PATH"
vork --version
vork help
Windows x64 Windows 10/11, recent NVIDIA GPU

Install the NVIDIA driver for your GPU and ffmpeg (winget install Gyan.FFmpeg). Open a new PowerShell window so ffmpeg is on PATH, then:

PowerShell
$installer = Join-Path $env:TEMP 'vork-install.ps1'
Invoke-WebRequest -UseBasicParsing https://github.com/voyager-so/vork/releases/latest/download/install.ps1 -OutFile $installer
powershell -NoProfile -ExecutionPolicy Bypass -File $installer
$env:Path = "$env:LOCALAPPDATA\Programs\vork;$env:Path"
vork --version
vork help

Give it to an agent

Start with vork help. There is no editor to drive. A useful first instruction is:

Prompt
Read vork help. Make a small scene, render a preview and inspect the image. Refine the camera and lighting before rendering at final quality. Read the relevant help topic when you need a feature the first page doesn’t explain.

Or write the scene yourself

Python and TypeScript can author scene JSON through the SDKs. You can also write JSON directly. Save this as shot.json:

shot.json
{"version":2,"nodes":[
  {"type":"mesh","geometry":{"std":"sphere","radius":1},
   "materials":[{"inputs":{"base_color":[0.12,0.35,0.65],"specular_roughness":0.3}}]},
  {"type":"mesh","translation":[0,-1,0],"geometry":{"std":"grid","size":[10,10]},
   "materials":[{"inputs":{"base_color":[0.35,0.35,0.35]}}]},
  {"type":"light","shape":"rectangle","translation":[-3,5,4],"target":[0,0,0],
   "energy":700,"size":4,"color":[1,0.92,0.8]},
  {"type":"camera","translation":[3,2,5],"target":[0,0,0]}
],"render":{"resolution":[640,480]}}
Terminal
vork render shot.json --profile std/previs --out preview.png
vork render shot.json --profile std/final --out final.png

Render on Voyager cloud GPUs

No NVIDIA GPU or Apple Silicon to hand? Voyager can lease your agent a cloud GPU that runs vork, billed by the second from a paid Voyager workspace. Give your agent this prompt, or read more on Vork Cloud.

Agent prompt
Make a video with Vork (https://github.com/voyager-so/vork) on Voyager cloud GPUs.
Needs a paid Voyager workspace (Starter or above). If access is refused, show me the billing link from the error.
1. Install the CLI (if voyager-cloud isn't installed yet):
   macOS / Linux:  curl -fsSL https://voyager.so/cloud/install.sh | sh
   Windows (PowerShell):  irm https://voyager.so/cloud/install.ps1 | iex
2. Sign in: voyager-cloud login (opens my browser). If VOYAGER_API_KEY is set, use it instead. Never ask me to paste a key.
3. Read the guide: voyager-cloud help vork. Example scenes are in the repo's examples/ folder; many need their prepare script run first.
4. Default to a video (MP4) unless I ask for a still. Before leasing, tell me the GPU, its price per minute and a rough
   time and cost for the whole job (run `voyager-cloud estimate --frames N --res 1080p` for a time and cost estimate), and wait for my OK.
5. Lease one GPU and keep it for the whole session: voyager-cloud lease render --wait --json  (render-lite is cheaper for drafts)
   Don't release it after a preview: I'll usually want changes. It pauses by itself after 15 minutes idle.
6. Once per machine: voyager-cloud exec <machine> -- vork setup   (a few minutes the first time; it is not hung)
7. Loop: edit the scene locally → voyager-cloud push <machine> scene/ →
   render a quick check (std/previs; a few frames or a low-res pass of the video) → voyager-cloud pull <machine> out/ →
   SHOW me the result: open the file (macOS `open`, Linux `xdg-open`, Windows `start`) and give me its path → revise.
   std/final (or std/path) only for the final render.
8. Long renders: voyager-cloud exec --detach <machine> -- vork render … prints a job id; follow it with
   voyager-cloud logs <job> --follow so I can see progress. Re-estimate the finish time from the measured rate
   (seconds per frame) once the first frames are done, and tell me if it changes a lot.
9. When I say we're done: pull the final outputs, then voyager-cloud release <machine>.
   Tell me how long it ran and what it cost (release prints both).
Using MCP instead? Add https://mcp.voyager.so/mcp/machines to your agent; it has the same steps as tools.

Under the hood

  • Default rendering combines raster visibility with hardware ray-traced lighting, and a path tracer is there too.
  • The scene and render plan stay installed. Frames use the retained GPU resources, with GPU-to-hardware-video encoding on supported native paths.
  • We test against physics as well as other renderers, using furnace tests and analytic oracles.

Research-preview limits

This is a research preview. Fog and volumes aren’t in yet, heavy interiors can abort on Mac, and our path tracer is slower than Cycles in the measured cases. Final approximates indirect lighting; more samples cannot restore omitted transport. Next up: fog, volumes, broader simulation, and better reliability and performance on demanding scenes. Run vork help limits before committing to a shot.

Point your agent at it and show us what it makes.

InstallSource on GitHub

Source-available and free during the research preview. Licence terms.