# vork vs Blender for AI agents: speed, quality, limits and which to use A comparison from the team that makes vork. Blender wins on features, path tracing and reach; vork on scene text, programs and draft speed. Measured numbers, limits and a verdict per job. Author: Ravi Parikh Canonical: https://voyager.so/blog/vork-vs-blender Published: 2026-11-06T14:26:33-08:00 Updated: 2026-11-06 For most 3D work with an AI agent, use Blender. It has far more features, a faster path tracer in every case we have numbers for, a person-friendly interface when the agent gets stuck, and it won our one side-by-side brief. vork, which we make at Voyager, is worth choosing for a narrower job: an agent writing shots as short text files, with custom shader programs, on a supported GPU, where you want quick draft renders and the shot avoids its gaps. The short version: choose Blender for existing scenes, fog and volumes, simulation, modelling, final path-traced frames, and anything a person will also touch. Choose vork for agent-written scenes with custom light, cameras or GPU compute, and for fast non-path-traced renders where you've checked the quality holds. vork's numbers come from [its README](https://github.com/voyager-so/vork) and [benchmark results](https://github.com/voyager-so/vork/blob/main/benchmarks/RESULTS.md), and Blender's facts from [its manual](https://docs.blender.org/manual/en/latest/) and site, all read on 6 November 2026. We also ran both on a Mac that day. We build vork and this is our comparison, so check our work: the benchmark inputs and rerun scripts are public. We will update this page as vork changes. **Key takeaways** * Blender wins most jobs: volumes, simulation, modelling, hardware support, maturity, and path tracing, where vork was 1.99 and 5.81 times slower than Cycles in the two named scenes. * vork's default final renders beat retained EEVEE baselines by 1.14 to 2.32 times on movies in the project's measurements, with eight denoised samples against 64. They are not equal-quality comparisons, and vork can lose fine detail. * Given the same brief, Claude Code took about seven and a half minutes on each, and Blender's picture was better. vork's scene file was a quarter of the size. ## What each is **Blender** is a free, complete 3D suite from the Blender Foundation, for modelling, sculpting, rigging, animation, simulation, rendering, compositing and more. Version 5.2 is the current LTS. It has two main renderers: [EEVEE](https://docs.blender.org/manual/en/latest/render/eevee/index.html), a physically based real-time renderer, and Cycles, a path tracer. Agents reach it through the `bpy` Python API, `blender -b` for headless runs, or MCP, including an [official server](https://www.blender.org/lab/mcp-server/) from Blender Lab. It is [GPL software](https://www.blender.org/about/license/), with Cycles under Apache 2.0. **vork** is a headless 3D and VFX engine for agents, written in Rust and Slang, rendering through Vulkan and Metal. It has no interface. A scene is JSON, written by hand or through Python and TypeScript SDKs, and rendered by one command. Scenes can include Slang programs for materials, cameras, light propagation, film response, simulation and compositing. 0.1.0 is a [research preview](/blog/what-is-vork), and it is [source-available](https://github.com/voyager-so/vork/blob/main/LICENSE), not open source. They aren't full substitutes. Blender replaces a whole 3D department's toolset. vork replaces only the render and scene-authoring step, for shots an agent can write. ## At a glance | | Blender 5.2 | vork 0.1.0 | | ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | | Made by | Blender Foundation and community | Voyager | | Licence | GPL, open source; Cycles Apache 2.0 | vork Preview License, source-available, free during the preview | | Interface | Full desktop app, plus background mode | None | | Agent surface | Python API, CLI, MCP | JSON scene, CLI, Python and TypeScript SDKs, Slang programs | | Modelling, sculpting, rigging | Yes | No; imports glTF or builds geometry from code | | Fog and volumes | Yes ([Principled Volume](https://docs.blender.org/manual/en/latest/render/shader_nodes/shader/volume_principled.html)) | Ignored in 0.1.0 | | Simulation | [Mature physics tools](https://docs.blender.org/manual/en/latest/physics/index.html) | Slang compute programs; the water example is an experiment | | Custom programs in a scene | Python, shader nodes, [OSL shaders and custom cameras](https://docs.blender.org/manual/en/latest/render/cycles/osl/camera.html) in Cycles | Slang programs for surfaces, cameras, light propagation, sensors, compute | | Hardware | Wide range of GPUs; Cycles also on CPU | Recent NVIDIA with hardware ray tracing, or Apple Silicon | | Cold start | EEVEE cold still 20.6 s in the README's retained run | Setup of minutes, and new programs can compile for minutes on first use | | Path tracing | Cycles: faster in measured cases | `std/path`: slower in measured cases | Sources are linked throughout; read 6 November 2026. ## Authoring: what an agent actually writes Both can be driven by text, which is the main thing. They differ in how much text. Blender's API is huge, and it exposes years of interface decisions. [Operators can depend on UI context](https://docs.blender.org/api/current/info_gotcha.html), and because the API changes across versions, models sometimes write older calls. In return, an agent can reach almost anything, including a very wide range of formats and add-ons. vork's surface is deliberately small. The getting-started help is about 2,500 tokens with a complete scene, and the full help about 19,400. Here is a first scene, tested on 0.1.0: ```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]}} ``` The same blocking in Blender took us about 40 lines of Python, which you can see in [our headless rendering guide](/blog/headless-3d-rendering). Materials use OpenPBR inputs, and cameras and lights follow Blender's physical conventions. Unknown fields are errors that suggest the nearest valid name, and in our run the agent corrected one on the next try. Choose Blender if you need the reach. Choose vork if a small, strict surface matters more, and your scene can live inside what it offers. ## The agent test: one brief, one run each We gave Claude Code the same brief for each: a red toy rocket on a wooden table at dusk, preview, refine, final still and three-second video, 960x540 at most. [The full walkthrough](/blog/render-3d-with-claude-code) has the prompts and details. | | Blender | vork | | ------------------- | --------------------------------------------------------------- | ---------------------------------------------------------------- | | Time | About 7.5 min | About 7.4 min | | Scene errors to fix | 0 | 1 | | Scene source | 25 KB of Python | 6.6 KB of JSON | | The picture | Warm rim light, plank table, depth of field, a lake it invented | Cleaner, simpler, flatter, a lot of near-black behind the rocket | ![Two renders of a red toy rocket on a wooden table at dusk. Left, from Blender: a tall rocket on planks, with a lake and out-of-focus lights. Right, from vork: a shorter rocket on a plain table against dark hills.](https://cdn.moda.app/voyager/blog/render-3d-with-claude-code/rocket-blender-vs-vork-c2b879bbcdf9bcb0.webp) One brief, one run each, from Claude Code. Left: Blender 5.2.1. Right: vork 0.1.0. ![A slow camera move past a tall red toy rocket on a plank table at dusk, with a lake and out-of-focus lights behind it. Rendered in Blender.](https://cdn.moda.app/voyager/blog/render-3d-with-claude-code/rocket-blender-poster-cc1e79541c99ce6c.webp) [Video: A slow camera move past a tall red toy rocket on a plank table at dusk, with a lake and out-of-focus lights behind it. Rendered in Blender.](https://cdn.moda.app/voyager/blog/render-3d-with-claude-code/rocket-blender-d2aff866babcf370.mp4) Blender 5.2.1, as delivered by Claude Code: three seconds, 960x540. No edits. ![A slow camera move past a shorter red toy rocket on a plain wooden table, with dark hills and a dusk sky behind it. Rendered in vork.](https://cdn.moda.app/voyager/blog/render-3d-with-claude-code/rocket-vork-poster-ad78201c7b3b8684.webp) [Video: A slow camera move past a shorter red toy rocket on a plain wooden table, with dark hills and a dusk sky behind it. Rendered in vork.](https://cdn.moda.app/voyager/blog/render-3d-with-claude-code/rocket-vork-fd6767a8e674f29e.mp4) vork 0.1.0, as delivered by Claude Code: three seconds, 960x540. No edits. Blender's picture was better, and it hit no errors. vork's file was a quarter of the size and its video rendered in 50 seconds against about two minutes at a higher sample count, but that isn't what you would look at. It's one run of one brief. Our permissions also kept the vork agent off the Python SDK, though both runs were limited in the same way on ffmpeg. Take it as a signal, not a score. Choose Blender if you are starting from a loose brief and care how the first result looks. ## Speed This is where it gets easy to mislead, so here are the numbers with their conditions. Draft and final figures are complete command times on one frozen build on an NVIDIA L4, from the project's results; the path figures are carried forward from an earlier build. Blender times are retained from earlier runs with different settings: EEVEE uses 64 samples with no denoiser, and vork `std/final` uses eight with a denoiser. [The project says these are not equal-quality speedups](https://github.com/voyager-so/vork#speed-with-the-qualifications), and visual review found softer edges, grainier defocus and changed highlights. | Test | Blender | vork | Result | | ----------------------------------------- | ----------------- | ------------------------- | --------------------------- | | 1080p still, `B-blocking` | EEVEE 2.405 s | 2.094 s | vork 1.15x faster | | 1080p still, `B-interior` | EEVEE 2.892 s | 1.738 s | vork 1.66x faster | | 1080p still, `B-car-pan` | EEVEE 2.458 s | 1.691 s | vork 1.45x faster | | 240-frame 1080p movie, `B-night` | EEVEE 213.5 s | 92.2 s | vork 2.32x faster | | 240-frame 1080p movie, `B-car-pan` | EEVEE 93.5 s | 81.7 s | vork 1.14x faster | | Path-traced 1080p still, `B-car-pan` | Cycles 4.6 s | 26.9 s | Cycles 5.81x faster | | Path-traced 1080p still, `B-night` | Cycles 16.0 s | 31.9 s | Cycles 1.99x faster | | Setup and first still, `B-blocking` | EEVEE cold 20.6 s | Setup 250.8 s, then 2.3 s | Blender is quicker to start | | Worst first render listed, `B-rack-focus` | Not measured | 82 s vs 1.8 s warm | vork compiles on first use | Preview renders are vork's largest speed difference. On the prior build, `std/previs` ran 14.63 to 36.40 times faster than EEVEE over seven simple clips, which helps an agent's iteration loop, but previews have different lighting and shadows and aren't final quality. On a tiny scene on our Mac, the gap was under half a second: warm `std/final` took about 0.43 seconds at 640x480, EEVEE about 0.83 seconds, and Cycles 2.2 to 4 seconds. The Cycles image was the cleanest. Then there's the bird shot. vork rendered eight seconds of a million simulated birds at 1080p24 and four samples in 97 seconds, using Slang compute. EEVEE at the same four samples is **projected, not measured**, at 13 to 18 minutes, or 8 to 11 times longer. That projection extrapolates eight warm frames across two retained runs and hands Blender the finished flock as geometry. It leaves out simulation, startup and encoding. vork's 97 seconds leaves out setup and a one-time warmup. The camera and nine foreground birds are authored, and the simulated million do not flap. Choose Blender for path-traced finals and when you can't verify lower-sample quality. Choose vork for fast drafts and for scenes like the flock where GPU compute is the shot. ## Quality and looks At its default sample counts, vork gives up detail for speed. The README lists softer edges, fine facades and hair losing detail, stepped or grainy defocus, wall mottling, and sparse sparks or spectral highlights changing brightness and colour. `--set samples=32` helps, at more cost. Its default `std/final` also [approximates indirect lighting](https://github.com/voyager-so/vork/blob/main/docs/help/limits.md) and can darken interiors, and more samples don't restore what it omits. `std/path` addresses that but is slower. Blender's Cycles is a well-proven reference, and EEVEE is a mature real-time option with its own well-understood approximations. We would not claim vork's looks match either in general. Choose Blender when the frame has to hold up to scrutiny without manual checking. ![A camera orbits a miniature kitchen diorama with pumpkins on the roof.](https://cdn.moda.app/voyager/blog/vork/kitchen-poster-f75bd499b1a9bf91.webp) [Video: A camera orbits a miniature kitchen diorama with pumpkins on the roof.](https://cdn.moda.app/voyager/blog/vork/kitchen-720-b32813f792ff949f.mp4) Blender's 3.5 splash scene imported into vork. Materials were translated rather than preserved exactly, and this render has additional staging and animated lighting. It is not a like-for-like comparison with the original. Credit: **Cozy Kitchen** (Blender 3.5 splash scene) by [Nicole Morena](https://www.artstation.com/nickyblender), [source .blend](https://download.blender.org/demo/splash/blender-3.5-splash.blend), [CC BY-SA](https://creativecommons.org/licenses/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. ## Custom programs: where vork is different Blender lets you script nearly everything and offers shader nodes, plus OSL shaders and custom cameras in Cycles. We found no documented public hook for curved light propagation. vork exposes one. A scene can supply a program that changes how camera rays, material response, light propagation and film response behave, with no renderer edits. The [black hole example](https://github.com/voyager-so/vork/tree/main/examples/black-hole) supplies Schwarzschild light propagation this way, and the [million birds](https://github.com/voyager-so/vork/tree/main/examples/murmuration) are steered by compute programs in the scene. Both are shots an agent can write as text, though these programs still take skill and a lot of checking. The black hole is a numerical approximation, not an exact solver. The cost is that new programs compile on first use, and that can take minutes on NVIDIA. Choose vork if your shot needs that kind of control. ## Reliability Blender has decades of production use. vork is new. Large scenes and dense transparency [can fail](https://github.com/voyager-so/vork#research-preview-limits), including on Mac, and reducing resolution doesn't necessarily fix it. Solid glass and heavy interiors can abort on Apple Silicon, where a retry sometimes succeeds. Its frozen benchmark sweep on Linux and NVIDIA delivered 583 of 585 images, with one stress scene running out of GPU memory in both profiles; Mac reliability was not revalidated in that run. Choose Blender for anything you can't afford to redo. ## Hardware, licence and cost Both are free to use today. Blender's GPL grants it to you for any purpose, permanently, and your output is your own. vork is free during the preview for any use, including commercial work, and what you make is yours. But later versions may have different terms, you can't redistribute modified versions or offer vork as a hosted rendering service without permission, and it isn't open source. On hardware, Blender runs far more widely, including on CPU with Cycles. vork needs a recent NVIDIA GPU with a ray tracing driver, or Apple Silicon. AMD, Intel and software rendering aren't supported, which rules out most cheap cloud instances and CI runners. ## Using them together You don't have to choose once. The vork repository includes an optional Blender bridge, a separate GPL component that is not part of the renderer or SDK packages, and it exports a `.blend` to files vork can render: ```sh blender -b --disable-autoexec source.blend --python integrations/blender/export.py -- --out /tmp/vork-scene ``` It lives in [the vork repository](https://github.com/voyager-so/vork/tree/main/integrations/blender), and it writes a report of each material variant, substitution and missing feature. Expect differences from the original look, as with the kitchen above. We did not run the bridge for this post. ## Verdict by job | If your work is mostly | Choose | Because | | --------------------------------------------------------------- | ---------------------------------- | ---------------------------------------------------------------- | | Existing `.blend` files | Blender | They are already there, and the bridge isn't lossless | | Fog, smoke, volumes | Blender | vork 0.1.0 ignores them | | Modelling, sculpting, rigging | Blender | vork has none | | Mature simulation | Blender | vork's water is an experiment | | Path-traced final frames | Blender | Cycles was 2 to 5.8 times faster | | Interiors with bounced light | Blender, or test vork's `std/path` | `std/final` can darken them | | Heavy glass or very large scenes | Blender | vork can fail on them | | A person and an agent sharing the file | Blender | vork has no interface | | Agent-written shots needing custom light propagation or sensors | vork | Programs in the scene with no engine changes | | GPU compute as the shot, such as large flocks | vork | Compute programs run alongside rendering | | A fast, small, strict scene format for an agent | vork | Short JSON and a small help surface | | Fast drafts where you will check the quality | vork | Faster than EEVEE baselines in measured cases, not equal quality | | AMD, Intel or CPU-only machines | Blender | vork doesn't run there | ## Frequently asked questions ### Is vork better than Blender? Not overall. Blender has more features, a faster path tracer in the measured cases and far wider hardware support, and did better in our single agent test. vork is better for a narrower job: agents writing scenes as short text, custom programs in the scene, and quick drafts. ### Is vork faster than Blender? Sometimes. On the README's measured scenes, default final renders ran 1.14 to 2.32 times faster than retained EEVEE baselines, at fewer samples with denoising and not at equal quality. vork's path tracer was 1.99 to 5.81 times slower than Cycles. First renders of new programs can take minutes. ### Can vork import Blender files? Through an optional bridge that exports a `.blend` to scene files, not directly. It also imports glTF. Materials are translated and reported, not guaranteed to match. ### Does vork have a GUI? No. It's a command-line engine for agents, and you review its output as images and video. ### Can Claude use Blender without MCP? Yes. `blender -b -P script.py` is enough. We used that route in [our test](/blog/render-3d-with-claude-code). [Our MCP guide](/blog/blender-mcp) covers when live control is worth it. ### Is vork open source like Blender? No. Blender is GPL. vork is source-available under the vork Preview License: free during the preview and modifiable for your own use, but you can't redistribute modified versions or host it as a service without permission. ### Will vork get fog and volumes? The README names fog and volumes, broader simulation, and better reliability on demanding scenes as the next direction, with no release date promised. Check `vork help limits` for your version. ## Voyager is a desktop AI agent for creative work Describe what you want to make; Voyager plans it, uses your apps and tools, and keeps everything editable. [Sign up](/sign-up)