A Blender benchmark GPU score tells you how fast one device renders Cycles path-tracing samples on several production scenes. Cycles path tracing runs mostly in FP32, and those scenes fit comfortably in VRAM. That makes the score a guide to rendering speed for scenes that fit in VRAM, and a weak guide to anything else. If your real interest is inference or general GPU compute, treat the Blender number as one signal about fit: it tells you something about FP32 throughput and memory bandwidth on a divergent, ray-heavy workload. Then profile your own workload before you commit money to a card.
How does the Blender GPU benchmark work, and what does the score mean?
The Blender Benchmark has two parts: a downloadable client that runs Blender on several production files, and the Open Data portal on blender.org, where results can optionally be uploaded. The client also records the operating system, RAM, graphics card and CPU model along with the performance data. You choose a Blender version and a render device (CPU or GPU) before the run.
Blender defines the score as “the estimated number of samples per minute, summed for all benchmark scenes”, and higher is better. In Cycles, one sample is one light-path calculation per pixel. SaladCloud’s write-up of its 27-GPU-model run lists the scenes as Classroom (1920×1080, 300 samples per pixel), Monster (1024×1024, 256) and Junkshop (2000×1000, 240). Each one is rendered for a fixed 30 seconds or until it reaches its target sample count. A Blender developer’s comment on the bug tracker describes the method: render one sample first so the kernels are compiled, then render for 30 seconds and count the finished samples. Kernel compilation is thereby kept out of the timed render. The score counts samples finished in a fixed time, not time to a finished frame.
So the score is a relative performance metric. SaladCloud states that the score allows comparison across CPUs and GPUs, but “does not directly reflect absolute rendering times or costs for real-world scenes”, which depend on scene complexity, resolution, sample count and hardware.
What does the Blender Cycles benchmark actually stress on a GPU: and what does it not measure?
Cycles uses wavefront path tracing on the GPU. Instead of following each light path from start to finish in one large kernel, it splits the work into smaller kernels and queues or sorts millions of paths, so that threads run the same kernel or shader together. The reason is divergence. Paths end at different points and hit different materials, so threads in one kernel end up running different code, and on a GPU that is expensive.
An NVIDIA research paper on wavefront path tracing names the same pressures. SIMT warps waste work when threads branch apart. High register use reduces the number of resident threads and with it the GPU’s ability to hide memory latency. Ray casts suffer from this especially badly, because they do many memory accesses relative to math. In that paper, ray casts still took 44% to 56% of rendering time across the paper’s own three test scenes, which are not Blender’s. SaladCloud reports that performance scales with CUDA core count and memory bandwidth.
What the score does not measure matters just as much for a hardware decision:
- Memory capacity. SaladCloud measured the three scenes at between 1 and 5 GB of VRAM each. Renderjuice notes that VRAM variants of a card may share one score, and that the score “does not predict performance when VRAM runs out”.
- Out-of-memory behaviour. Cycles can move some scene memory to host memory so that larger scenes still render, with slower memory access. Other working memory must stay on the GPU. The Blender manual says the most common cause of GPU render failure is too little memory on the card.
- Low-precision and tensor arithmetic. Cycles with the CUDA backend does most of its computation in FP32, so a CUDA-backend score says little about FP16, FP8 or tensor-core throughput.
- Other Blender workloads. The Cycles score does not measure EEVEE or viewport performance.
How do CUDA, OptiX and HIP backends change a Blender GPU benchmark result?
Each GPU vendor reaches Cycles through its own backend: CUDA and OptiX for NVIDIA (OptiX adds hardware ray tracing), HIP for AMD, oneAPI for Intel and Metal on macOS. A Blender GPU score therefore measures a card and its backend together, and a different backend can produce a different score on the same silicon.
When Blender 2.81 introduced the OptiX backend for RTX cards, Phoronix tested 19 NVIDIA GPUs and found OptiX “much faster” than CUDA, which was in turn much faster than Blender’s OpenCL path. OptiX only works on RTX cards. In a later Phoronix comparison, OptiX was the fastest option for RTX GPUs, and even the CUDA backend on current NVIDIA cards beat the Radeon RX 6000 series on HIP. A GeForce RTX 3060 Ti finished the BMW scene faster than an RX 6800 XT. On the heavier Classroom scene, the RX 6800 XT on HIP matched the RTX 3070 series. So the cross-vendor ranking depended on both backend and scene. The Blender manual makes the same point in general terms: compute times differ by technology and by the scene tested.
The Blender version adds a second variable. Blender 3.0 rewrote the GPU kernels and scheduling, with real-world scenes rendering between 2x and 8x faster. That release also introduced the HIP backend for RDNA and RDNA2 cards on Windows. Blender 5.1’s release notes report a further 5-10% GPU gain on various benchmark scenes. Renderjuice states plainly that comparisons across Blender versions are approximate. The portal data can also contain errors. One confirmed bug report showed unrealistic Metal results for Apple M1 on the Junkshop scene, and a user saw a GPU render stop after 20 seconds as if it had finished.
Why NVIDIA often leads Blender charts, and why a gaming card can beat an H100
Backend matters to NVIDIA’s position: OptiX, which adds hardware ray tracing on RTX cards, was the fastest backend in Phoronix’s tests. SaladCloud found that consumer cards such as the RTX 4090 and 5090 often beat the A100 and H100 in Cycles. Its explanation is that consumer cards are tuned for high FP32 throughput, faster clocks and graphics-oriented memory, while data-centre parts are designed primarily for FP64 and AI workloads. The same report notes that an older generation’s flagship often outruns the next generation’s entry-level card, because raw FP32 throughput and bandwidth outweigh incremental architectural gains. Neither ordering predicts which card serves a transformer faster.
When does a Blender GPU score transfer to inference or compute workloads?
A Blender score transfers when your workload is limited by the same resources Cycles uses: FP32 arithmetic, memory bandwidth and latency hiding under divergent control flow, all on a working set that fits in VRAM. It misleads when any of those conditions breaks.
Large language model inference is one example. A roofline survey of LLM inference finds that the prefill stage is mostly compute-bound while the decode stage is entirely memory-bound. Because decode runs repeatedly for every generated token, optimising its memory-bound behaviour is crucial to inference performance. The same survey notes that model weights range from a few gigabytes to over a hundred, and that the KV cache can take several to tens of gigabytes depending on sequence length and batch size. A benchmark whose scenes fit in 1 to 5 GB tells you nothing about whether your model and its KV cache fit at all. Precision shifts the picture too. The survey reports that FP16-trained models can often be quantised to FP8 without significant accuracy loss, and NVIDIA ships FP8 tensor cores on the H100. None of that arithmetic appears in an FP32 Cycles run.
Our own guidance on measuring GPU benchmarks for AI makes the same argument from the inference side: a useful benchmark maps to your model mix, prompt distribution, batching rules and latency targets. A device that looks fast on a micro-test can stall once the data path, collectives or KV cache reach their real limits.
Quick decision table: does the Blender score apply to my workload?
| Your workload’s profiled character | Does a Blender Cycles score carry over? | Why |
|---|---|---|
| FP32, divergent, ray- or shader-heavy compute such as path tracing, on a working set that fits in VRAM | Reasonably, as a relative ordering | Same stressed resources: FP32 throughput, bandwidth, latency hiding |
| LLM decode, small-batch generation | Poorly | Memory-bound on weights and KV cache; capacity and bandwidth dominate |
| Any workload whose working set exceeds VRAM | No | The score does not predict behaviour once VRAM runs out |
| Multi-GPU training or serving | No | Benchmark runs measure one device |
Reading benchmark scores as a hardware-fit signal rather than an absolute ranking
A benchmark score ranks devices on the workload it runs; it becomes evidence about your workload only after profiling shows that both are limited by the same resource. That follows TechnoLynx’s working principle: profile before you optimise, because best practice only makes sense in the context profiling gives. The same principle applies when choosing hardware. A card that leads the Blender charts has shown it can handle one kind of load, and whether your load is that kind is a separate question.
In practice, a disciplined read of the Open Data portal looks like this:
- Hold the backend and Blender version constant. Compare OptiX with OptiX and HIP with HIP, on the same release, because both backend and version move the scores.
- Read ratios as bands, not exact ranks. Renderjuice expresses differences as multipliers of a reference card’s throughput, calls cross-version comparisons approximate and warns that real-project render times are not guaranteed.
- Gate on memory first. Renderjuice states that a score and a VRAM figure do not establish compatibility. Rule out any card that cannot hold your working set before you look at speed.
- Do not compare across workload families. We have made the same point about CPU and GPU benchmarks: comparing Cinebench integers to FP16 teraflops conflates unrelated dimensions, because each metric targets different compute patterns under different execution models. A Cycles score sits next to an inference result in the same way.
For the broader version of this argument, see why GPU performance is not a single number.
How do we profile our own workload to confirm a benchmark represents the real bottleneck?
You confirm it by measuring which hardware resource your workload saturates first, then checking whether the benchmark saturates the same one. GPU performance is governed by whichever resource is saturated first (compute throughput, memory bandwidth or launch overhead), and the right decision depends on which one that is. AMD’s profiling guide puts the condition simply: “a good benchmark should be representative of the real work that needs to be done”.
A procedure using NVIDIA and AMD tools:
- Start at the framework level. For PyTorch inference,
torch.profilershows which operators are most expensive, along with their input shapes and device kernel activity. Shape recording adds overhead and can introduce extra tensor copies, so keep it off when you take timings. Profile with your real batch sizes and sequence lengths, because arithmetic intensity changes with both. - Trace the timeline. On AMD, rocprof’s application trace shows which kernel took longest and what share of time went to memory copies. For NVIDIA tools, see our GPU profiler workflow with Nsight Systems and Nsight Compute.
- Read the speed-of-light numbers for the hot kernels. Nsight Compute’s GPU Speed Of Light section reports each unit’s achieved throughput as a percentage of its theoretical maximum. NVIDIA’s peak-performance-percentage triage method reads the top unit’s value. Above 80% means the workload is running efficiently and you have to remove work from that unit. Below 60% means it is underused or stalling. Between the two, both approaches apply.
- Place each kernel on a roofline. A roofline chart combines peak compute and memory bandwidth with arithmetic intensity. Where the kernel lands, under the bandwidth slope or under the compute ceiling, tells you what limits it. The LLM roofline survey applies the same method layer by layer to decide whether a model is memory-bound or compute-bound on given hardware.
- Separate latency from bandwidth. If long-scoreboard stalls dominate, Nsight Compute’s guide classes the kernel as memory-latency-bound, “which is not necessarily memory-bandwidth-bound”.
- Make the measurement repeatable. Nsight Compute locks clocks to their boost value and flushes caches before each replay pass, because warm caches and clock states otherwise distort the numbers. On AMD, rocprof replays kernels when you request more counters than one pass can collect, and results vary by device.
If they come out bandwidth-bound in decode or tensor-core-bound in prefill, set the Blender chart aside and benchmark candidates on your own AI workload.
What should you know about Blender benchmarks GPU results in practice?
A Blender number is usable only when version, backend, memory fit, precision and limiter all match; check each before it enters a hardware decision:
- Same Blender version and same backend for every card compared
- Your working set (weights, activations, KV cache or scene) fits in the candidate’s VRAM with headroom
- Your workload’s dominant precision is FP32; if not, the score does not cover the arithmetic you run
- Profiling shows your hot path has the same limiter as path tracing, not memory-bound decode
- The result is not an outlier on the portal; check for scatter and known reporting bugs
- You are not ranking a data-centre card against a consumer card on a render score alone
Who can help us decide whether a GPU clears our inference or compute target?
TechnoLynx’s GPU Performance Engineering work profiles your workload on the target hardware to show where its time goes and what makes it faster.
This is not the right engagement if you are choosing a card for Blender rendering itself. The Open Data portal answers that question directly, and the Blender manual points there for current device performance. It is also more than you need if your model runs on one card and already meets its latency target. The profiling steps above, done in-house, will show whether anything is at stake.
FAQ
Does Blender have a built-in benchmark?
Blender ships a separate Benchmark client that renders production files and can upload results to the Open Data portal. The client offers a choice of Blender version and of CPU or GPU device.
Does Blender rely on CPU or GPU?
Cycles can render on either. The CPU backend uses multithreading, and GPU backends exist for NVIDIA, AMD and Intel GPUs and for macOS. GPUs are usually faster but limited by on-card memory on complex scenes.
Is Blender available on Mac?
Yes. Cycles has a Metal backend for rendering on macOS.
How does OpenCL compare to CUDA in Blender?
In Phoronix’s Blender 2.81 tests, the CUDA backend was much faster than Blender’s OpenCL path, and OptiX was faster again on RTX cards.