A Blender render server needs no desktop: the official Linux build renders from the command line with blender -b file.blend -a -- --cycles-device OPTIX, where -b runs without an interface and the Cycles option after the double dash selects the NVIDIA OptiX backend. Blender's manual requires driver version 575 or newer for OptiX, and when a scene exceeds GPU memory Cycles spills into system memory "with a performance impact", which makes the 24 GB versus 96 GB choice the main sizing question. This guide sets it up on a MassiveGRID GPU dedicated server, from $449.99 per month for 24 GB to $1,656.15 for 96 GB.
You need a clean Ubuntu 24.04 LTS server with root SSH access and a working NVIDIA driver. Driver installation is covered step by step in the first-hour guide to NVIDIA drivers, CUDA and Docker on Ubuntu; Blender itself needs only the driver, not the CUDA toolkit or Docker.
Which Blender version should a render server run?
Run the same version the artists use. A .blend file saved in a newer Blender can behave differently in an older one, so the server follows the workstations, not the other way round.
Where you have a choice, these are the facts as of 16 November 2026. Blender's download index lists blender-5.2.4-linux-x64.tar.xz and a 5.3.0 build, both dated 10 November 2026. Blender's release page describes 5.2 as the current long-term support line, released on 14 July 2026 and supported until July 2028; we read that from a search result, because the page itself refused a direct request, so confirm it on blender.org. The 5.3 line is reported as a regular, non-LTS release. For a long production, an LTS line is the conservative pick.
Use the official build from blender.org. The manual warns that distribution packages may be outdated and that "some distributions do not build Blender with Cycles GPU rendering support, for licensing or other reasons".
How do you install Blender headless on Ubuntu 24.04?
1. Check the driver. OptiX in Cycles "requires a NVIDIA graphics cards with compute capability 5.0 and higher and a driver version of at least 575" (Blender manual). NVIDIA's current Linux driver, 620.70.06, lists both the RTX PRO 4000 Blackwell SFF and the RTX PRO 6000 Blackwell Max-Q as supported.
nvidia-smi --query-gpu=name,driver_version,memory.total --format=csv
2. Download and unpack the official build. The manual's instruction is to "download the Linux version for your architecture and decompress the file to the desired location".
apt update && apt install -y wget xz-utils tmux rsync
cd /opt
wget https://download.blender.org/release/Blender5.2/blender-5.2.4-linux-x64.tar.xz
tar -xf blender-5.2.4-linux-x64.tar.xz
ln -s /opt/blender-5.2.4-linux-x64/blender /usr/local/bin/blender
3. Verify that it starts.
blender --version
On a minimal server install, the first start can stop with "error while loading shared libraries", because Blender links against a few X11 and OpenGL libraries even when it renders in the background. List what is missing and install the Ubuntu packages that provide those files:
ldd /opt/blender-5.2.4-linux-x64/blender | grep "not found"
When that command prints nothing and blender --version prints a version, the install is done.
What is the command for headless Cycles rendering with OptiX?
All of these come from the command-line pages of the Blender manual. Two rules from it prevent most mistakes: "Always position -f or -a as the last arguments", and "Cycles add-on options must be specified following a double dash".
| Goal | Command from the Blender manual |
|---|---|
| Render frame 10 in the background | blender -b file.blend -f 10 |
| Render the whole animation | blender -b file.blend -a |
| Cycles, frames 10 to 500, 2 threads | blender -b file.blend -E CYCLES -s 10 -e 500 -t 2 -a |
| Set output path and format, render the second-to-last frame | blender -b file.blend -o /project/renders/frame_##### -F OPEN_EXR -f -2 |
| Render frame 20 on the GPU with OptiX | blender -b file.blend -f 20 -- --cycles-device OPTIX |
The valid values for --cycles-device are CPU, CUDA, OPTIX, HIP, ONEAPI and METAL, and the manual adds: "Append +CPU to a GPU device to render on both CPU and GPU". On an NVIDIA RTX card, OPTIX is the backend that uses the hardware ray-tracing cores, so it is the one to start with.
Test with a single frame first, and add --cycles-print-stats, which the manual describes as "log statistics about render memory and time usage":
blender -b /srv/render/project/shot010.blend -o /srv/render/out/test_##### -f 1 -- --cycles-device OPTIX --cycles-print-stats
Verify two things: nvidia-smi in a second session shows a blender process using vRAM while it renders, and the image in /srv/render/out opens and looks right. Note the render time the log reports for this frame; it is the number the cost comparison below needs.
How do you render a frame range and fetch the results with rsync?
1. Upload the project. In Blender on the workstation, make the file self-contained first (File, External Data, Pack Resources), or keep textures and caches in a folder beside the .blend with relative paths. Then, from the workstation:
rsync -avP ./project/ root@YOUR_SERVER_IP:/srv/render/project/
2. Render inside tmux so the job survives a dropped SSH connection. This line combines the manual's frame-range example with its OptiX example: engine, start frame, end frame, output pattern, then -a last, then the Cycles option after the double dash.
tmux new -s render
blender -b /srv/render/project/shot010.blend -E CYCLES -o /srv/render/out/shot010_##### -F OPEN_EXR -s 1 -e 240 -a -- --cycles-device OPTIX 2>&1 | tee /srv/render/shot010.log
Detach with Ctrl+B then D, and return later with tmux attach -t render.
3. Verify progress by counting frames and reading the end of the log:
ls /srv/render/out/shot010_*.exr | wc -l
tail -n 5 /srv/render/shot010.log
4. Fetch the frames from the workstation. rsync only transfers what is new, so you can run it repeatedly while the render is still going and review frames as they land:
rsync -avP root@YOUR_SERVER_IP:/srv/render/out/ ./renders/
If a job stops at frame 131, restart it with -s 131; nothing before it is lost. To split a long range across the four cards of the 4x RTX PRO 6000 server, start four Blender processes with different frame ranges and one card each by prefixing CUDA_VISIBLE_DEVICES=0 to 3. That is a general NVIDIA mechanism for hiding the other cards from a process, not a Blender option, so confirm with nvidia-smi that each process landed on its own GPU.
Does your scene fit in 24 GB or does it need 96 GB?
The Blender manual is direct about GPU memory. "Typically, the GPU can only use the amount of memory that is on the GPU", and when it is full, "Blender will automatically try to use system memory. This has a performance impact, but will usually still result in a faster render than using CPU rendering". On multiple cards: "each GPU can only access its own memory", so four 96 GB cards render four frames at once but do not make a 384 GB scene fit.
| Server | GPU memory | System RAM for spill-over | Monthly | Suits |
|---|---|---|---|---|
| RTX PRO 4000 | 24 GB | 64 GB DDR4 | $449.99 | Product shots, motion graphics, stylised animation, scenes whose textures and geometry stay under 24 GB |
| RTX PRO 6000 | 96 GB | 128 GB DDR5 | $1,656.15 | Heavy texture sets, dense scattering, volumes and simulation caches that overflow smaller cards |
| 4x RTX PRO 6000 | 4x 96 GB | 128 GB DDR5 ECC | $5,966.44 | Four frames in parallel, each with a 96 GB budget |
Do not guess which row you are in. Render one representative heavy frame with --cycles-print-stats and read the peak memory it logs, or watch nvidia-smi during the render. If the peak is comfortably below 24 GB, the smaller server renders the scene entirely on the card. If it is above, the render still completes through system memory but slower; measure that slowdown before paying for 96 GB. The comparison of the RTX PRO 4000 and RTX PRO 6000 Blackwell cards lists the other hardware differences.
We publish no render times; the manual points to the Blender Open Data results for current figures per device.
Monthly server or render farm: how do you compare the cost?
Farm prices vary by provider, priority tier and hardware, and we quote none here. The comparison is a method you can run with your own numbers in ten minutes.
- Measure minutes per frame on the server for a representative frame of the project, using the test command above.
- Compute server-hours for the job: frames x minutes per frame / 60. A 2,400-frame sequence at 3 minutes per frame is 7,200 minutes, or 120 hours.
- Compute what those hours cost you. The server is billed per month whether it renders or not, so the honest rate is the monthly price divided by the hours you actually use. A fully used month is 730 hours.
- Get the farm's quote for the same frames from its calculator, at the priority you would really buy, and divide both totals by the frame count.
| Render hours used per month | RTX PRO 4000 server, effective rate | RTX PRO 6000 server, effective rate |
|---|---|---|
| 50 hours | $9.00 per hour | $33.12 per hour |
| 120 hours | $3.75 per hour | $13.80 per hour |
| 365 hours (half the month) | $1.23 per hour | $4.54 per hour |
| 730 hours (all month) | $0.62 per hour | $2.27 per hour |
The table is only division, and it is the whole argument: a server that renders around the clock is inexpensive per hour, and one that renders a weekend a month is not. Add the one-time setup fee ($346.48 or $1,656.15) to the first month.
There is a third option between the two. Hourly GPU clouds rent the same class of card by the hour: on 16 November 2026 the on-demand price for an RTX PRO 6000 with 96 GB was $2.69 per hour on RunPod Secure Cloud and $3.36312 for an AWS g7e.2xlarge in us-east-1. The 120-hour job above costs about $323 or $404 at those rates. The dedicated 96 GB server becomes the lower bill above roughly 616 and 492 hours a month respectively; below that many hours, paying by the hour costs less. The dedicated versus hourly cloud GPU pricing breakdown has the full comparison.
When does a render farm win?
- Deadlines. A farm puts many machines on your job at once. One server renders frames one after another, or four at a time on the 4-GPU model. If 120 server-hours must be finished by tomorrow morning, only parallel capacity helps.
- Occasional work. A studio that renders one project a quarter pays three idle months on a server. Per-frame or per-hour pricing matches that pattern.
- No administration. A farm handles versions, drivers and failed nodes. On a dedicated server that is your job: it arrives with a clean operating system and root access, and you install and maintain everything on it.
The dedicated server wins when rendering is continuous: work in the queue every day, an animation in production for months, or a card that does other GPU work between shots. It also gives a fixed monthly bill, a 1 Gbps port with unlimited traffic for moving EXR sequences, and scenes that never leave a machine you control.
What goes wrong?
- The render runs on the CPU. The Cycles option was placed before the double dash or the dash is missing. It must read
... -a -- --cycles-device OPTIX. Watchnvidia-smiduring the test frame: no blender process on the GPU means the option was not applied. - A rig or driver-based animation renders wrong. Automatic Python execution, including Python drivers, is disabled by default on the command line. Add
-ybefore the file name for scenes you trust. - Frames render with the wrong settings. The manual warns that "arguments are executed in the order they are given". An
-o,-sor-eplaced after-ahas no effect on that render, which is why the manual says to put-for-alast. - The render slows sharply on heavy frames. The scene exceeded GPU memory and Cycles is using system memory. Reduce texture resolution, or move the job to the 96 GB card.
- Lost frames after a disk failure. A dedicated server is a single machine. Mirror the two NVMe drives with RAID 1 if you keep work on it, and treat the server as a place where frames are made, not where they are archived: rsync them off as they finish.
Security. A render node needs exactly one open port. Use SSH keys, disable password logins, and close the rest with ufw allow OpenSSH followed by ufw enable. Do not render .blend files from people you do not trust: a .blend can carry Python scripts. The manual lists -Y, --disable-autoexec, as the default, which also disables Python drivers; pass -y to enable them only for files from your own team.
Frequently Asked Questions
Can Blender render on a server without a monitor or desktop?
Yes. blender -b runs in the background with no interface, and the official Linux build needs no desktop environment, only the NVIDIA driver and a few shared libraries. The command blender -b file.blend -f 20 -- --cycles-device OPTIX from the Blender manual renders frame 20 on the GPU.
Which driver does Cycles OptiX need on Linux?
The Blender manual states a driver version of at least 575 and a card with compute capability 5.0 or higher. NVIDIA's Linux driver 620.70.06 lists both the RTX PRO 4000 Blackwell SFF and the RTX PRO 6000 Blackwell as supported (checked on 16 November 2026).
What happens if my scene needs more than 24 GB of GPU memory?
Cycles does not simply fail. According to the manual, when GPU memory is full Blender automatically tries to use system memory, with a performance impact. Measure the slowdown on a heavy frame; if it is large, the 96 GB RTX PRO 6000 server keeps the whole scene on the card.
Is a dedicated GPU server cheaper than a render farm?
Only if you keep it busy. Divide the monthly price by the hours you actually render: $449.99 is $0.62 per hour over a full 730-hour month but $9.00 per hour if you use 50 hours. Compare that with a farm quote for the same frames. For occasional or deadline-driven work a farm or an hourly cloud GPU usually costs less.
A render node that is yours all month
MassiveGRID GPU dedicated servers for Cycles: RTX PRO 4000 Blackwell with 24 GB for $449.99 per month, RTX PRO 6000 Blackwell with 96 GB for $1,656.15 per month, or four RTX PRO 6000 cards for $5,966.44 per month. Bare metal, root access, a 1 Gbps port with unlimited traffic. One-time setup fee applies.
Compare GPU Dedicated ServersFurther Reading
- Blender manual: rendering from the command line (examples and argument order)
- Blender manual: command-line arguments (--cycles-device, --cycles-print-stats)
- Blender manual: Cycles GPU rendering (OptiX driver requirement, GPU memory, multiple GPUs)
- Blender manual: installing on Linux (official build, packages, snap)
- Blender download index: 5.2 release files
- NVIDIA Linux driver 620.70.06: supported products list
- RunPod pricing (Secure Cloud rates, checked on 16 November 2026)
- AWS EC2 on-demand pricing (checked on 16 November 2026)