Blender Cycles Multi-GPU Rendering (2026): How It Scales, VRAM per Card and One Blender per GPU
Cycles can render one frame on every GPU you enable, but each card keeps its own copy of the scene, so more GPUs add speed, not memory. For animations there is a second option: run one Blender per GPU, each rendering its own frames. Which one finishes a sequence sooner depends on the scene, so time both on a few frames.
- Enable: Preferences › System › Cycles Render Devices (OptiX on RTX cards), tick every GPU, and set the scene Device to GPU Compute.
- Memory: each GPU uses only its own memory, so the smallest card sets the scene limit; overflow goes to slower system RAM.
- Animation: one Blender per GPU keeps every card busy on long sequences; split frames with -s, -e and -j, or with Placeholders.
- Measure: -- --cycles-print-stats logs render memory and time.
A multi-GPU machine renders Cycles faster only when the scene fits on each card and every GPU stays busy. Cycles can share one frame between all enabled GPUs, or you can run several Blender processes, each driving one GPU on its own frames. Both are standard Blender features; which one finishes a sequence sooner depends on the scene.
This guide explains how Cycles uses several GPUs, why VRAM does not add up, how to run one Blender per GPU from the command line, and how to compare the two methods on your own shot. If a single frame seems slow before the GPUs even start, see where Synchronizing Object and Updating BVH time goes.
Checked against the Blender Manual (GPU Rendering, Command Line Arguments, Output Properties) and NVIDIA’s CUDA documentation, November 2026.
1. How Cycles uses more than one GPU
The Blender Manual lists three steps: choose a backend (CUDA, OptiX, HIP, oneAPI or Metal) under Preferences › System › Cycles Render Devices, enable the devices you want for that backend, and set each scene’s Device to GPU Compute (Blender Manual: GPU Rendering). On NVIDIA RTX cards, OptiX uses the hardware ray-tracing cores; our guide to CUDA or OptiX on the RTX 5090 covers the choice. Every enabled GPU then works on the same frame.
Memory is the catch. The Manual states that a GPU can typically only use its own memory, and that several GPUs do not usually increase the memory available to a scene: every card needs its own full copy. With cards of different sizes, the smallest one decides what fits. When GPU memory runs out, CUDA, OptiX, HIP and Metal devices automatically try to use system memory; the render continues with a performance cost, though the Manual notes it is usually still faster than rendering on the CPU.
2. Two ways to use several GPUs for an animation
All GPUs on each frame. One Blender instance with every GPU enabled renders frame after frame. It is the simplest setup and the only way to get a single still sooner. Each frame still begins with scene preparation on the CPU, such as syncing objects, building the BVH and loading textures, before the GPUs start sampling, and that part does not get shorter with more GPUs.
One Blender per GPU. Several Blender instances run at the same time, each limited to one GPU and rendering its own frames. Each frame takes about as long as on a single card, but several frames are in progress at once, and one instance’s preparation overlaps with sampling on the others. The cost is system RAM, because every instance loads the scene, and a little more setup.
The table puts the two setups side by side. In short, all GPUs on one frame is the right choice for a single still, and one Blender per GPU usually finishes an animation sooner because the CPU steps of one instance overlap with GPU sampling in the others.
All GPUs per frame vs one Blender per GPU
Both render the same .blend with the same settings; they differ in how the work is split.
| All GPUs on each frame | One Blender per GPU | |
|---|---|---|
| Setup | Tick every GPU in Preferences and render as usual | One background process per GPU, started from the command line |
| Time for one frame | Shortest, because all cards share it | About the time of a single card |
| Long sequences | GPUs wait while each frame’s scene preparation runs | Other instances keep sampling while one prepares its next frame |
| GPU memory | Full scene on every card | Full scene on every card |
| System RAM | One copy of the scene | One copy per instance |
| Best for | Stills, short shots, scenes heavy on system RAM | Long animations with independent frames |
3. How to run one Blender per GPU
Each Blender process should see only the GPU it is meant to use. NVIDIA’s CUDA_VISIBLE_DEVICES environment variable controls which GPUs a CUDA application can see, using the index shown by nvidia-smi, starting at 0 (NVIDIA: CUDA environment variables). CUDA enumerates GPUs fastest first by default; setting CUDA_DEVICE_ORDER to PCI_BUS_ID orders them by PCI bus, the same order nvidia-smi shows, so index 0 is the card you expect. Set both variables before launching each instance.
The options are documented on the Manual’s Command Line Arguments page: -b runs without the interface, -s and -e set the first and last frame, -j sets how many frames to step forward after each rendered frame, and -a renders the range. Cycles options come after a double dash; --cycles-device OPTIX selects the backend. Blender reads the arguments in order, so -s, -e and -j have to come before -a. The scene path is wrapped in quotes so a folder name with spaces still works, and -RedirectStandardOutput gives each instance its own log. With a step of 4, the four instances render frames 1, 5, 9…, 2, 6, 10… and so on, so they finish at about the same time.
Let instances pick the next free frame. If frame times vary a lot, use the method the Manual calls a primitive render farm: in Output Properties turn Overwrite off and Placeholders on, save, and start every instance with the same full range (-a). Each instance writes an empty placeholder for the frame it starts, and the others skip files that already exist (Blender Manual: Output Properties). If you stop an instance in the middle of a frame, delete its empty placeholder before restarting.
You can also enable a single device from a Python script run with -P, through the Cycles add-on preferences (bpy.context.preferences.addons["cycles"].preferences.devices), if you prefer not to use environment variables.
4. Check memory before you scale up
Every GPU holds a full copy of the scene, and with one Blender per GPU every process also holds one in system RAM. Measure before you add GPUs or instances:
- Render one frame with
-- --cycles-print-stats; the Manual describes it as logging render memory and time usage. - Compare peak GPU memory with the smallest card in the machine. NVIDIA lists the RTX 5090 with 32 GB, against 24 GB on the RTX 4090.
- With one Blender per GPU, watch system RAM in Task Manager while all instances run.
- If a card overflows into system memory, that instance slows down. Our guide to choosing a GPU for Blender covers VRAM sizing.
The figure shows why both limits matter at once: four instances mean four scene copies in system RAM, and each GPU, including the smallest card, must fit the whole scene on its own.
5. What our own tests show
On iRender servers we recorded a 4K Cycles animation (3840×2160, 512 samples, OptiX, one Blender per GPU): 4x RTX 5090 took 87 seconds per frame per GPU against 108 seconds on 4x RTX 4090, about 19% less time. A 120-frame 1080p animation on 4x RTX 5090 ran at 72 seconds per frame. Both runs are on our multi-GPU render benchmarks page with the videos. These are single scenes; for comparing devices across many scenes the Manual points to Blender Open Data.
The two panels come from different scenes, so compare the cards within the top panel only. The 4K test is the one that compares RTX 5090 and RTX 4090 on the same work.
A checklist before a multi-GPU Cycles render
- Devices: backend set (OptiX on RTX), every GPU ticked, scene Device is GPU Compute.
- Fit: peak memory from
--cycles-print-statsstays below the smallest card. - Files: paths relative and caches baked, so every instance finds the same files.
- Output: frame padding (#) in the output path; Overwrite and Placeholders set for the method you use.
- Test: 8–10 frames timed with all GPUs per frame and with one Blender per GPU.
- RAM: enough system memory for every instance you start.
For scene settings to check before any farm render, see our 10-point Blender Cycles pre-flight checklist.
On a submission (SaaS) farm, the farm decides how frames are split across its machines, which suits finished scenes. On an IaaS server you control the whole machine, so you can choose either method and run the timing test above yourself.
Running both methods on an iRender server
- Upload the project folder to iRender Drive before you start the server; uploading is free and does not use rental time.
- Start a server with 2, 4 or 8 RTX 5090 (32 GB) or RTX 4090 (24 GB) GPUs and connect by remote desktop.
- Install your Blender version and add-ons once; the server image is saved between sessions.
- Time a short range both ways, then render the sequence with the faster method and shut down; multi-GPU servers are billed per minute.
Frequently asked questions
1. Does Blender Cycles use multiple GPUs automatically?
No. Enable each GPU under Preferences › System › Cycles Render Devices and set the scene Device to GPU Compute. For background renders you can choose the backend with — –cycles-device, for example OPTIX.
2. Do two GPUs double the VRAM in Blender?
Typically no. The Blender Manual says each GPU can only access its own memory, so every card holds the full scene and the smallest card sets the limit.
3. Is one Blender per GPU faster than all GPUs on one frame?
Often for long animations, because other instances keep sampling while one prepares its next frame, but it depends on the scene. Time a few frames both ways at final settings.
4. How do I limit a Blender instance to one GPU?
Set NVIDIA’s CUDA_VISIBLE_DEVICES variable to the GPU index before launching that instance, or enable a single device in a Python script run with -P.
5. How can several Blender instances share one frame range?
Turn Overwrite off and Placeholders on in Output Properties, save, and start each instance with the same range. The Blender Manual describes this as a primitive render farm.
6. What happens when a GPU runs out of memory in Cycles?
CUDA, OptiX, HIP and Metal devices fall back to system memory. The render continues, but more slowly.
Render your Blender projects on iRender
iRender is an IaaS GPU render farm: you rent a bare-metal server with 1, 2, 4 or 8 NVIDIA RTX 4090 (24 GB) or RTX 5090 (32 GB) GPUs, an AMD Ryzen™ Threadripper™ PRO CPU, 256 GB ECC RAM and a 2 TB NVMe SSD, connect by remote desktop and work on it like your own workstation, with full administrator access. You install Blender once; your server image is saved between sessions, so Blender and your add-ons stay installed.
Multi-GPU servers are billed per minute (1-GPU servers have a one-hour minimum), and sessions of 3 hours or more get 10% off. Our 4-GPU and 8-GPU servers are liquid-cooled; in our own measurements the GPUs hold 60–70°C under sustained render load. Elite support is available 7 days a week by hotline, live chat, Skype, WhatsApp and email.
This quick start shows how to start a server and render Blender on it:
Two Blender runs we recorded on our servers: 120 frames at 1080p on 4x RTX 5090 at 72 seconds per frame, and the same 4K scene on 4x RTX 5090 and 4x RTX 4090 at 87 and 108 seconds per frame per GPU:
New users get a 100% bonus on the first top-up (minimum $50). See plans on the Blender render farm page or download the iRender GPU app.




