November 18, 2026 Linh Nguyen

Blender Cycles Multi-GPU Rendering (2026): How It Scales, VRAM per Card and One Blender per GPU

Quick answerGetting the most from several GPUs in Cycles
Checked Nov 2026

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.

iRender
Every GPU Holds Its Own Copy of the Scene
Schematic
Your .blend scenegeometry, textures,BVH, render bufferse.g. 18 GBGPU 0 · 32 GBfull copyGPU 1 · 32 GBfull copyGPU 2 · 32 GBfull copyGPU 3 · 32 GBfull copy4 GPUs= 4 copiesof one scene,not 128 GBBlender Manual: each GPU can typically only access its own memoryWith cards of different sizes, the smallest card decides what fits; overflow goes to slower system memorySeveral GPUs add speed, not memory: each card needs the full sceneBlender Manual: GPU Rendering
scene data on each GPUGPU memory capacity
Schematic; scene size is an example

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.

iRender
All GPUs per Frame vs One Blender per GPU
Schematic
A · One Blender, all 4 GPUs on each frameGPU 0GPU 1GPU 2GPU 3B · One Blender per GPU, each on its own framesGPU 0GPU 1GPU 2GPU 3Scene preparation runs on the CPU for every frame, and the GPUs of that instance wait for itA: short frames, so preparation is a larger share. B: each frame is longer, so preparation is a smaller shareOne Blender per GPU overlaps CPU preparation with sampling on the other cardsBlender Manual: Command Line Rendering
scene preparation (CPU)GPU sampling
Schematic; durations are illustrative

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.

CompareBlender + Cycles

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 frameOne Blender per GPU
SetupTick every GPU in Preferences and render as usualOne background process per GPU, started from the command line
Time for one frameShortest, because all cards share itAbout the time of a single card
Long sequencesGPUs wait while each frame’s scene preparation runsOther instances keep sampling while one prepares its next frame
GPU memoryFull scene on every cardFull scene on every card
System RAMOne copy of the sceneOne copy per instance
Best forStills, short shots, scenes heavy on system RAMLong animations with independent frames
Rule of thumbTime 8–10 frames both ways at final settings and keep the faster one; the result depends on how long scene preparation takes and how well one frame scales across GPUs.

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.

iRender
One Blender instance per GPU
PowerShell
1# One Blender per GPU, each rendering every 4th frame of 1–240.
2# Set the two paths, then run this in Windows PowerShell.
3$blender = "C:\Program Files\Blender Foundation\Blender 5.2\blender.exe"
4$scene = "D:\shot\shot.blend"
5
6# Number the GPUs the same way nvidia-smi does
7$env:CUDA_DEVICE_ORDER = "PCI_BUS_ID"
8
90..3 | ForEach-Object {
10 # This instance sees only GPU $_ and starts at frame 1 + $_
11 $env:CUDA_VISIBLE_DEVICES = "$_"
12 $start = 1 + $_
13 Start-Process $blender -ArgumentList @(
14 "-b", "`"$scene`"",
15 "-s", $start, "-e", 240, "-j", 4,
16 "-a", "--", "--cycles-device", "OPTIX"
17 ) -RedirectStandardOutput "D:\shot\log_gpu$_.txt"
18}
Each instance writes its own log, log_gpu0.txt to log_gpu3.txt; watch nvidia-smi to confirm all four cards are busyBlender Manual: Command Line Arguments · NVIDIA: CUDA environment variables

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.

iRender
Four Instances Sharing One Frame Range
Schematic
Blender instance 1CUDA_VISIBLE_DEVICES=0 · same rangeBlender instance 2CUDA_VISIBLE_DEVICES=1 · same rangeBlender instance 3CUDA_VISIBLE_DEVICES=2 · same rangeBlender instance 4CUDA_VISIBLE_DEVICES=3 · same rangerender/ (Overwrite off, Placeholders on)shot_0001doneshot_0002doneshot_0003doneshot_0004doneshot_0005doneshot_0006doneshot_0007doneshot_0008doneshot_0009placeholdershot_0010placeholdershot_0011placeholdershot_0012placeholderEach instance writes an empty placeholder for the frame it starts; the others skip files that already existBlender Manual, Output Properties: disable Overwrite, enable Placeholders, start as many instances as you wishWith Overwrite off and Placeholders on, each instance takes the next free frameBlender Manual: Output Properties
instance 1instance 2instance 3instance 4
Schematic; frame order is an example

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.
iRender
One Blender per GPU: what each copy costs
Schematic
SYSTEM RAM (shared by all instances)Blender 1: scene copyBlender 2: scene copyBlender 3: scene copyBlender 4: scene copysceneRTX 509032 GBsceneRTX 509032 GBsceneRTX 509032 GBsceneRTX 409024 GBsmallest cardsets the limitEvery instance adds a scene copy to system RAM, and every GPU must hold the whole sceneBlender Manual: GPU Rendering; NVIDIA specifications (RTX 5090 32 GB, RTX 4090 24 GB)
system RAMGPU memoryscene data
Schematic, not to scale

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.

iRender
Two Blender runs recorded on iRender servers
Measured
4K Cycles animation, 512 samples, OptiX, one Blender per GPU on 4 GPUsseconds per frame on each GPU (lower is better)4x RTX 4090108 s4x RTX 509087 sabout 19% less timeSeparate scene: 120-frame 1080p animation on 4x RTX 50904x RTX 509072 s per frameSame 4K scene: RTX 5090 took about 19% less time per frame than RTX 4090iRender recorded tests (YouTube videos 1QukaBFpqSs and z0b0PlNv-40)
RTX 4090RTX 5090, 4K testRTX 5090, 1080p test
Measured; two different scenes, do not compare across panels

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

  1. Devices: backend set (OptiX on RTX), every GPU ticked, scene Device is GPU Compute.
  2. Fit: peak memory from --cycles-print-stats stays below the smallest card.
  3. Files: paths relative and caches baked, so every instance finds the same files.
  4. Output: frame padding (#) in the output path; Overwrite and Placeholders set for the method you use.
  5. Test: 8–10 frames timed with all GPUs per frame and with one Blender per GPU.
  6. 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

iRender
How iRender works: your computer controls your own multi-GPU server
IaaS render farm
Your PC or MacNo powerful GPU neededRemote desktopLive screen1:1 like your PCYOUR OWN GPU SERVERbare-metal · not sharedGPUGPUGPUGPUGPUGPUGPUGPU1, 2, 4 or 8 × RTX 5090 (32 GB) or RTX 4090 (24 GB)Threadripper PRO · 256 GB ECC RAM · 2 TB NVMe SSDFull admin access · your setup is saved between sessions1Register, top upFirst $50+ top-up doubled2Upload your projectiRender Drive, free3Start and connectRemote desktop, any OS4Render, shut downBilling stops, per minute✓ Your workstation, just more GPUs: no queue to wait, no farm plugin, no job submission, no settings changed
Your mouse and keyboardServer screen streamed back
Schematic, not to scale
  1. Upload the project folder to iRender Drive before you start the server; uploading is free and does not use rental time.
  2. Start a server with 2, 4 or 8 RTX 5090 (32 GB) or RTX 4090 (24 GB) GPUs and connect by remote desktop.
  3. Install your Blender version and add-ons once; the server image is saved between sessions.
  4. 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.

Accelerate your production pipeline with high-performance IaaS render farm services and dedicated bare-metal workstations powered by up to 8x NVIDIA GeForce RTX 5090 (32GB GDDR7), high-frequency AMD Ryzen™ Threadripper™ PRO processors, 256GB ECC RAM, and dedicated 2TB NVMe SSD storage tailored for your pipeline:
, , , , , , ,

Linh Nguyen

Linh Nguyen works in customer support at iRender, helping artists render Blender and Houdini projects on multi-GPU servers. She has written more than 300 articles for the iRender blog, covering Blender, Houdini and practical GPU rendering.
Contact

iRENDER GPU

Render Farm Pricing
Quick Start
Multi-GPU Benchmarks
iRender GPU App
Blog
Documentation
The Render Farm
The Company
Terms & Conditions

INTEGRATIONS

Autodesk Maya
Blender
Cinema 4D
Houdini
Karma XPU
Lumion
KeyShot
Unreal Engine
Twinmotion
Redshift
Octane
And many more…

iRENDER TEAM

Elite support 7 days a week
SATURDAY – SUNDAY: 6:00 AM – 11:59 PM
(UTC+7)
Hotline: (+84) 912-785-500
Skype: iRender Support
Email: [email protected]
Address 1: 68 Circular Road #02-01, 049422, Singapore.
Address 2: No.22 Thanh Cong Street, Hanoi, Vietnam.

Contact
이 페이지는 한국어로도 제공됩니다. 한국어로 보기 →