> ## Documentation Index
> Fetch the complete documentation index at: https://docs.voyager.so/llms.txt
> Use this file to discover all available pages before exploring further.

# Render with Blender on Voyager cloud GPUs

> Render a Blender scene on a Voyager cloud GPU: a ready-made scene template, the push-render-pull loop, render tiers, and your own .blend files, and Blender's UI in your browser with voyager cloud view.

Every Voyager cloud machine has Blender installed, and it renders Cycles on the GPU by itself. You push a scene, render it on the machine and pull back the image.

> [!NOTE]
>
> **Before you start:** a paid Voyager workspace (Starter or above) and the `voyager` CLI, signed in ([quickstart](https://docs.voyager.so/api/machines/quickstart.md)). The machine bills by the second until you release it. `render-lite` (an L4) is the cheapest preset that renders Blender; `render` is faster for final frames.

## Render a scene in five commands

This example starts from **product-sweep**, one of the ready-made scene templates. It builds a lit product shot from library assets and renders a draft still.

**1. Write the scene template**

```sh theme={"system"}
voyager cloud guide template product-sweep --to shot
```

This writes `shot/` on your computer: `recipe.json` (what goes where), `build_scene.py` (builds the scene in Blender), the render presets and a `README.txt`. Nothing is leased yet.

**2. Lease a machine**

```sh theme={"system"}
m=$(voyager cloud lease render-lite --wait --yes)
```

`lease` prints only the machine id on stdout, so `$m` holds it. It's usually ready in under a minute.

**3. Push the scene**

```sh theme={"system"}
voyager cloud push $m shot/ shot
```

Only the small scripts go up. The models, materials and HDRI come from the asset library on the machine, never from your computer.

**4. Render on the machine**

```sh theme={"system"}
voyager cloud exec $m -- "cd shot && blender -b -P build_scene.py -- recipe.json --tier draft --render out/product-sweep.png"
```

It builds the scene, saves `product-sweep.blend` beside the recipe and renders the still. On an L4 this took about 20 seconds.

**5. Pull the result and release**

```sh theme={"system"}
voyager cloud pull $m shot/out/ shot/out
voyager cloud release $m
```

`shot/out/product-sweep.png` is on your computer. `release` prints how long the machine ran and what it cost.

## Tiers

`--tier` sets resolution, samples, denoising and bounces for one purpose:

| Tier | Use it for |
| - | - |
| `draft` | Framing and layout. Fast and noisy. |
| `preview` | Lighting and materials. |
| `final` | The frames you deliver. Render it once, when the preview is right. |

Edit `shot/recipe.json` to move things, swap assets (its `swap` list has alternatives) or change the tier. Add `--hero model.glb --hero-size 0.3` to the render command to put your own product in the hero slot. Other templates: `tabletop-food`, `interior-room`, `night-street`, `outdoor-nature` and `space` (`voyager cloud guide template` lists them).

## Your own .blend

Push the file and render it the usual way. The default image has two Blenders on the machine's `PATH`: `blender` is Blender 5.2.4 LTS and `blender-5.3` is Blender 5.3. A file saved by Blender 5.3 needs `blender-5.3` (5.2 stops with "File written by newer Blender binary"); `voyager cloud images` lists every image's tools. The machine picks the GPU (OptiX) for Cycles without any setup:

```sh theme={"system"}
voyager cloud push $m scene.blend scene.blend
voyager cloud exec $m -- blender -b scene.blend -o //out/#### -s 1 -e 48 -a
voyager cloud pull $m out/ renders
```

To apply the same tiers, light rigs and cameras to your own file, write the presets beside it with `voyager cloud guide presets --renderer blender --to scene/` and run Blender with `-P voyager_presets.py -- --tier preview`.

## Estimate a render

Before a long render, find out what it will take and cost:

```sh theme={"system"}
voyager cloud estimate --blend scene.blend --frames 1-250
```

```text theme={"system"}
≈ 41–58 min · 310–440 credits on RTX-PRO-6000 · from 5 sample frames (frames vary ±18%) · sample cost 21 credits
```

It renders a few frames spread across the range (3, or 5 for more than 100 frames), on the cheapest GPU with ray tracing. Then it scales their times to the whole range on the GPU you'll render on. The sample machine is capped at \$2 and released afterwards, also on Ctrl-C. In a terminal it asks before it starts; `--yes` skips that.

* **Frame range:** with Blender installed locally, it reads the frame range from the scene and warns about missing external files. Only the `.blend` is sent, so pack external files first (**File › External Data › Pack Resources**).
* **The range:** the estimate is a range. How much the sample frames differ from each other widens it, and so does converting from the sample's GPU to yours.

| Flag | |
| - | - |
| `--gpu CARD`, `--gpus N` | The GPU the estimate is for (default: the default card). |
| `--samples N` | Sample frames, 2 to 10. |
| `--sample-gpu CARD` | Render the sample on this card; `same` uses the GPU the estimate is for. |
| `--machines N` | Also show the time on a [farm](https://docs.voyager.so/api/machines/farm.md) of N machines. |
| `--json` | The numbers as JSON. |

* **Assets:** use library models, materials and HDRIs instead of uploading your own copies. See [Assets on machines](https://docs.voyager.so/api/machines/assets.md).
* **Many frames:** split a frame range over several machines with [Farm a frame range](https://docs.voyager.so/api/machines/farm.md).
* **Versions:** `voyager cloud images` lists each image's tools and their versions, Blender's included.

## Blender's UI in your browser

To work in Blender itself (look around a scene, fix a material, check a camera), open its UI from the machine in your browser. The machine needs the `creative-view` image and a GPU with a video encoder, so any `render` preset works; H100, A100 and B200 don't.

```sh theme={"system"}
m=$(voyager cloud lease render-lite --image creative-view --wait --yes)
voyager cloud push $m scene
voyager cloud view $m
```

`view` starts a desktop on the machine and opens `https://app.voyager.so/view/<machine>`. Sign in with Voyager there; only you (the machine's starter) and your workspace's admins can open it, and the link works for no one else. Blender runs on the machine's GPU and streams to the tab; your mouse and keyboard drive it. The desktop ends after 15 minutes without input, or with `voyager cloud view $m --stop`; the machine keeps running until it idles or you release it. API: `POST /v1/machines/{id}/view`.

## If something went wrong

> [accordion] `exec` says MACHINE\_PAUSED, or the CLI says it resumed the machine
>
> The machine paused itself after 15 minutes without a command, file transfer or busy GPU. `exec`, `push` and `pull` resume it first and say so; billing starts again. Pass `--no-resume` to fail instead.

> [accordion] The render is black or missing textures
>
> Check that every path in the scene is relative to the `.blend` (`//textures/…`), and that you pushed the textures with it. For library assets, run `voyager-cloud assets sync` on the machine ([Assets on machines](https://docs.voyager.so/api/machines/assets.md)).

## Next

> [card] [Farm a frame range](https://docs.voyager.so/api/machines/farm.md)
>
> Render an animation across several machines at once.

> [card] [Assets on machines](https://docs.voyager.so/api/machines/assets.md)
>
> Find library models, materials and HDRIs and put them on the machine.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.