How do I render a Blender scene on a cloud GPU?

Cover: Render a Blender scene on a cloud GPU, blender -b, Cycles, --cycles-device OPTIX

Deploy a Raw GPU instance, download the Linux build of Blender from blender.org, upload a packed .blend file, and run blender -b scene.blend -E CYCLES -o //renders/frame_#### -F PNG -a -- --cycles-device OPTIX inside tmux, then copy the frames off before you destroy the instance.

Updated 2026-10-29

This guide follows the official Blender manual (Rendering from the command line, Command line arguments, Cycles GPU rendering, Installing on Linux) and the blender.org download page, all read on 2026-10-29. The LTS release on blender.org that day was Blender 5.2.3. It is for 3D artists who want to render a Cycles still or animation on a rented NVIDIA GPU such as the RTX 5090 or the other cards listed on /pricing.

What you need

Item Official value (read 2026-10-29) Source
Blender build 5.2.3 LTS, blender-5.2.3-linux-x64.tar.xz blender.org download page
Linux 64-bit distribution with glibc 2.28 or newer blender.org requirements
Display Not needed for command line rendering; render over SSH Blender manual, command line rendering
CUDA device NVIDIA card with compute capability 5.0 or higher Blender manual, GPU rendering
OptiX device Compute capability 5.0 or higher and a driver version of at least 575 Blender manual, GPU rendering
GPU option -- --cycles-device OPTIX or CUDA, after a double dash at the end Blender manual, command line arguments

VRAM need depends on model, precision and workflow; see How much VRAM do I need to run an LLM? for the general method. For Blender, the scene (geometry and textures) has to fit in GPU memory; the VRAM of each card is in the Performance table on /pricing (CloudGPU’s own listing).

Step 1: Pack the .blend file on your computer

According to the Blender manual’s Packed Data page, File > External Data > Pack Resources marks the external files the scene uses (such as image textures) as packed, and they go inside the .blend file on the next save. Save the file after packing. The manual notes that videos and movie clips cannot be packed, so upload those next to the .blend file with the same folder layout.

Step 2: Deploy a Raw GPU and connect

On /deploy, pick an NVIDIA GPU and the Raw GPU option (JupyterLab + CUDA pre-installed, root SSH on a dedicated container). Connect over SSH with the host, port and user shown for your instance, or open a terminal in JupyterLab.

Step 3: Check the GPU and driver

nvidia-smi          # GPU name, driver version and the "CUDA Version" the driver supports
nvcc --version      # CUDA toolkit compiler, if installed (Blender does not need it to render)
ldd --version       # glibc version; blender.org asks for 2.28 or newer
which tmux rsync xz

Read the driver version in the nvidia-smi header. If it is 575 or higher, use OPTIX below; otherwise use CUDA. If tmux, rsync or xz is missing, install it with the package manager (you are root on the container).

Step 4: Download and check Blender

The Blender manual says to download the Linux build from blender.org and decompress it; it also notes that some distribution packages are built without Cycles GPU rendering support, so use the official build:

cd ~
wget https://download.blender.org/release/Blender5.2/blender-5.2.3-linux-x64.tar.xz
wget https://download.blender.org/release/Blender5.2/blender-5.2.3.sha256
grep linux-x64 blender-5.2.3.sha256 | sha256sum -c -
tar -xf blender-5.2.3-linux-x64.tar.xz
ls -d ~/blender-5.2.3-linux-x64
export BLENDER=~/blender-5.2.3-linux-x64/blender
$BLENDER --version

sha256sum -c should print OK. If ls shows a different folder name, use that path in BLENDER. If $BLENDER --version stops with error while loading shared libraries, the message names the missing library; install the package that provides it and run the check again.

Step 5: Upload the scene

From your computer, copy the project folder to the instance:

rsync -avP -e "ssh -p <ssh-port>" ./my-project/ <ssh-user>@<ssh-host>:render/

Step 6: Render one frame on the GPU

Start a tmux session so the render keeps running if SSH disconnects, then render a single test frame:

tmux new -s render
cd ~/render
$BLENDER -b scene.blend -E CYCLES -o //renders/frame_#### -F PNG -f 1 -- --cycles-device OPTIX

According to the official Blender manual:

  • -b renders in the background, without the user interface.
  • -E CYCLES uses the Cycles engine; $BLENDER -E help lists the engines.
  • -o //renders/frame_#### writes next to the .blend file (// is relative to the blend-file) and #### becomes the zero-padded frame number.
  • -F PNG overrides the image format saved in the file.
  • Arguments run in the order given, so -f or -a goes last, before the -- Cycles options.
  • --cycles-device accepts CPU, CUDA, OPTIX, HIP, ONEAPI and METAL; appending +CPU (for example OPTIX+CPU) renders on both.

Use CUDA instead of OPTIX if the driver is older than 575. Detach from tmux with Ctrl-b then d, and reattach with tmux attach -t render.

Step 7: Render the animation

When the test frame looks right, render the frame range saved in the file with -a, or set it with -s and -e:

$BLENDER -b scene.blend -E CYCLES -o //renders/frame_#### -F PNG -a -- --cycles-device OPTIX
$BLENDER -b scene.blend -E CYCLES -o //renders/frame_#### -F PNG -s 1 -e 250 -a -- --cycles-device OPTIX

The manual also lists --cycles-print-stats, which logs render memory and time statistics for your own scene; add it after --cycles-device OPTIX.

Check your own setup

These are checks you can run yourself; this page does not assume the result.

  • Driver: the nvidia-smi header shows the driver version you need for OptiX (575 or higher) or CUDA.
  • Blender runs: $BLENDER --version prints Blender 5.2.3.
  • The render uses the GPU: while a frame renders, nvidia-smi in a second SSH session lists a blender process on the GPU.
  • Frames are written: ls ~/render/renders shows frame_0001.png after Step 6.

If the GPU render fails

According to the Blender manual’s GPU rendering FAQ, the most common reason a scene renders on the CPU but not on the GPU is that there is not enough memory on the graphics card. With CUDA and OptiX, Blender tries to use system memory when GPU memory is full, which has a performance impact. The manual suggests smaller resolution textures to reduce memory use; otherwise, deploy a card with more VRAM from /pricing. To see how full the card is while rendering, see How to check GPU utilization on a cloud GPU.

Before you destroy the instance

According to /terms, data on the instance is permanently deleted when you destroy it. Copy the rendered frames to your computer first:

rsync -avP -e "ssh -p <ssh-port>" <ssh-user>@<ssh-host>:render/renders/ ./renders/

GPU time is billed per minute, rounded up, with a 1-minute minimum, and billing stops when you destroy the instance; see /terms.

FAQ

Can I render a Blender scene on a rented GPU without a display?

Yes. According to the official Blender manual, command line rendering does not need a graphical display, so you can render over SSH. Download the Linux build from blender.org, extract it, upload your .blend file and run blender -b scene.blend -E CYCLES -o //renders/frame_#### -F PNG -f 1 – --cycles-device OPTIX.

How do I make Blender render with OptiX or CUDA from the command line?

Put the Cycles option after a double dash at the end of the command: blender -b scene.blend -f 1 – --cycles-device OPTIX. The Blender manual lists CPU, CUDA, OPTIX, HIP, ONEAPI and METAL as valid values, and you can append +CPU to a GPU device to render on both.

What NVIDIA driver does Blender need for OptiX rendering?

The Blender manual says OptiX needs an NVIDIA card with compute capability 5.0 or higher and a driver version of at least 575. CUDA needs compute capability 5.0 or higher. Run nvidia-smi on the instance to see the driver version before you choose OPTIX or CUDA.

Why does my Blender scene render on the CPU but not on the GPU?

The Blender manual says the most common cause is not enough memory on the graphics card. With CUDA and OptiX, Blender tries to use system memory when GPU memory is full, which is slower. Smaller image textures reduce memory use, or you can deploy a GPU with more VRAM.

How is the GPU billed while Blender renders?

GPU time is billed per minute, rounded up, with a 1-minute minimum, and billing stops when you destroy the instance. Copy your rendered frames off first, because data on the instance is deleted on destroy. See https://cloudgpu.app/terms for the full billing terms.

Sources