Techgage logo

Blender 2.92 Linux & Windows Performance: Best CPUs & Graphics Cards

Blender 2.92 Splash Screen Project - Sinosauropteryx Prima Thumbnail

Date: March 3, 2021
Author(s): Rob Williams

Blender’s latest version, 2.92, has just released, and as usual, we’re going to dig into its performance and see which CPUs and GPUs reign supreme. For something a bit different this go-around, we’re adding Linux results to our rendering and viewport tests, and not surprisingly, the results are interesting!



Blender 2.92 Rendering Tests: CPU, GPU, Hybrid & NVIDIA OptiX

It’s time once again to take an in-depth look at CPU and GPU performance in Blender, something we’ve been doing more frequently lately as major Blender releases have accelerated. While a new version doesn’t always mean that we’ll see substantially different results from the previous one, things do change over time, so it’s good to retest.

You can read about Blender’s 2.92 features in our recent news post, where you can click through to an official video that will give you an even fuller run-down. While there are plenty of new features and improvements in 2.92, Geometry Nodes is easily one of the coolest. Be sure to check out some of the official Geometry Nodes demo files to experience it quickly. Likewise, you can grab the latest version of Blender in its many forms on the official downloads page. Lastly, if you want to check out Radeon ProRender performance in Blender, you can refer to our recent article investigating it.

Blender 2.92 Splash Screen Project
Blender 2.92 w/ Joanna Kobierska’s Sinosauropteryx Prima project

When a new major version of Blender releases, we typically retest all of our hardware in Windows, and only Windows. After hearing your requests loud and clear, this article will also take care of Linux performance. Given the amount of time that it takes to test both OSes, we can’t promise that we’ll do this with every major release, but this certainly won’t be the last time.

This article is going to tackle rendering to the CPU, the GPU, as well as mixed rendering with CPU and GPU combined. Our initial GPU render testing showed that Windows and Linux perform virtually the same, so we opted to show only Windows for the GPU results. There are, however, notable differences in performance with regards to CPU rendering when it comes to Windows vs. Linux, so CPUs were tested on both OSes.

Our viewport tests will be found on the next page, where we will use two projects to see how our collection of graphics cards scale from one viewport mode to the next, again in both OSes.

Without further ado, let’s get to it. Here’s a quick run-down of the hardware tested for this article:

CPUs & GPUs Tested in Blender 2.92
AMD Ryzen Threadripper 3990X (64-core; 2.9 GHz; $3,990)
AMD Ryzen Threadripper 3970X (32-core; 3.7 GHz; $1,999)
AMD Ryzen Threadripper 3960X (24-core; 3.8 GHz; $1,399)
AMD Ryzen 9 5950X (16-core; 3.4 GHz; $799)
AMD Ryzen 9 5900X (12-core; 3.7 GHz; $549)
AMD Ryzen 7 5800X (8-core; 3.8 GHz; $449)
AMD Ryzen 5 5600X (6-core; 3.7 GHz; $299)
Intel Core i9-10980XE (18-core, 3.0 GHz; $999)
Intel Core i9-10900K (10-core; 3.7 GHz; $499)
Intel Core i5-10600K (6-core; 3.8 GHz; $269)
AMD Radeon RX 6900 XT (16GB; $999)
AMD Radeon RX 6800 XT (16GB; $649)
AMD Radeon RX 6800 (16GB; $579)
AMD Radeon RX 5700 XT (8GB; $399)
AMD Radeon RX 5700 (8GB; $349)
AMD Radeon RX 5600 XT (6GB; $279)
AMD Radeon RX 5500 XT (8GB; $199)
NVIDIA RTX 3090 (24GB, $1,499)
NVIDIA RTX 3080 (10GB, $699)
NVIDIA RTX 3070 (8GB, $499)
NVIDIA RTX 3060 Ti (8GB, $399)
NVIDIA RTX 3060 (12GB, $329)
NVIDIA GeForce RTX 2080 Ti (11GB; $1,199)
NVIDIA GeForce RTX 2080 SUPER (8GB, $699)
NVIDIA GeForce RTX 2070 SUPER (8GB; $499)
NVIDIA GeForce RTX 2060 SUPER (8GB; $399)
NVIDIA GeForce RTX 2060 (6GB; $349)
NVIDIA GeForce GTX 1660 Ti (6GB; $279)
GPU test platform (Intel Core i9-10900K) used 8GBx4 DDR4-3200 memory.
CPU and CPU+GPU test platforms used 16GBx4 DDR4-3200 memory.
OS and chipset drivers are fully updated on each platform before testing.

AMD Radeon Graphics Driver: Linux: 20.45 | Windows: 21.2.3
NVIDIA GeForce Graphics Driver: Linux: 460.39 | Windows: 461.40 *
* Linux: 460.56 | Windows: 461.72 for GeForce RTX 3060

All product links in this table are affiliated, and support the website.

Each system was tested in a largely stock state, aside from our memory XMP being enabled. In the event that enabling XMP likewise enables a non-reference automatic overclock (eg: ASUS MultiCore Enhancement), we enforce default CPU clock values. In addition to the latest graphics drivers being used for testing, motherboard chipset drivers were updated as well (if there was an update, that is.)

Our Windows 10 testing was performed in the latest 20H2 release, which has been fully updated through Windows Update. For our Linux testing, we’re using Ubuntu 20.04.2, again fully updated. We also upgraded Ubuntu’s Linux kernel from 5.8 to 5.11, as certain GPUs (namely AMD’s RDNA2 series) require it to unlock their full performance potential.

GPU: CUDA, OptiX & OpenCL Rendering

Blender 2.92 - Linux and Windows Rendering Performance (Cycles GPU, BMW) (March 2021)

If you’ve read any one of our recent Blender in-depth performance looks, you’re likely aware that GPU rendering is probably the direction you’re going to want to go. CPUs have their place, but for the price of a huge CPU that would make a significant difference to rendering performance, you could purchase multiple mid-range GPUs and likely greatly outperform it. Well – you know, assuming you can find a GPU to buy (grumble grumble).

With a CUDA render time of 20 seconds on the beefy RTX 3090 with the BMW scene, it’s clear that we’ll have to retire this project at some point, or at least crank its sample count. More than likely, though, we’ll eventually replace all of our projects with more recent demo files for a fresh coat of paint.

If 20 seconds makes it seem as though there’s still a fair bit of breathing room, lest we forget the trick NVIDIA pulled out of its sleeves a couple of years ago: OptiX ray tracing acceleration. With that API enabled, and the RTX series’ ray tracing cores engaged, render times can be slashed. Such as where the RTX 3090 can cut its 20 second render time down to 11 seconds:

Blender 2.92 - Cycles OptiX Render Performance (BMW) (March 2021)

When we take a look at the totality of NVIDIA’s current- and last-gen RTX cards, the just-released RTX 3060 sits in the middle, outperforming last-gen’s RTX 2080 SUPER. The RTX 3060 Ti with OptiX renders this BMW project in as much time as the RTX 3090 does with CUDA, so that card seems quite powerful for its (ideally uninflated) price.

A happy accident occurred during our testing, where our testing scripts thought the GTX 1660 Ti was an RTX card, and proceeded to run the OptiX tests. Since the GTX series doesn’t include RT (or Tensor) cores, that API was typically unavailable. At some point, that changed, because OptiX works on this RT-coreless GTX 1660 Ti, and actually improves performance by doing so. If you have an NVIDIA card, but one that’s not RTX-enabled, you should try out the OptiX option as well and see if performance improves. We unfortunately didn’t see improvement on our older Pascal-based GeForce GTX 1080 Ti, but it’s still worth testing out for yourself in case you see different.

Note that as of Blender 2.92, OptiX supports ambient occlusion and bevels, so the list of what the new API doesn’t support is becoming seriously thin.

Let’s see how the Classroom project behaves:

Blender 2.92 - Linux and Windows Rendering Performance (Cycles GPU, Classroom) (March 2021)
Blender 2.92 - Cycles OptiX Render Performance (Classroom) (March 2021)

The Classroom project has historically scaled a little differently from the BMW one, and that tradition has been upheld with 2.92. AMD’s Radeon once again perform really well in this project when compared to the BMW one, with the RX 6900 XT creeping up on the RTX 3080 – until OptiX acceleration is once again introduced, that is.

Blender 2.92 - Linux and Windows Rendering Performance (Cycles GPU, Controller) (March 2021)

This third Cycles project, of an Xbox controller, yet again shakes things up, with NVIDIA’s new RTX 3060 performing on par with the RX 6800 XT. This project is a perfect example of one that wouldn’t have rendered in OptiX in 2.91, but now does in 2.92 thanks to the API’s improvements (we didn’t officially benchmark it, but did verify that it rendered correctly.)

Cycles isn’t the only render engine in Blender. The new Eevee seems to be growing in popularity really quickly, which is great to see, and pretty much expected, because it’s powerful, and getting better all of the time. It’s also an engine that doesn’t take advantage of NVIDIA’s RT cores, and the result is a playing field that’s a bit more even:

Blender 2.92 - Linux and Windows Rendering Performance (Eevee GPU, Mr. Elephant) (March 2021)

One of the highlights featured on the Blender 2.92 features page is improved Cycles rendering performance, but interestingly enough, we didn’t actually see much change at all between 2.91 and 2.92. Where we did see an obvious improvement was with Eevee.

Between 2.91 and 2.92, Eevee render times improved from 111s to 77s on the RTX 3090, from 144s to 121s on the RX 6900, and from 179s to 122s on the RTX 3070. What’s really impressive is how much performance has changed on lower-end hardware. The RX 5500 XT’s render time dropped from 646s to 413s, while the the RTX 2060 SUPER dropped from 269s to 199s. It’s really great to see this kind of improvement from one Blender version to the next, so the developers who made it happen deserve some kudos!

CPU Rendering

Blender 2.92 - Linux and Windows Rendering Performance (Cycles CPU, BMW) (March 2021)
Blender 2.92 - Linux and Windows Rendering Performance (Cycles CPU, Classroom) (March 2021)
Blender 2.92 - Linux and Windows Rendering Performance (Cycles CPU, Controller) (March 2021)

Every time we publish one of our Blender performance reports, someone inevitably asks us to run the same tests in Linux – and it’s for good reason. We’ve seen many times in the past, throughout our many CPU performance articles, where Linux had the upper-hand, and often, rendering is included in that.

If your workstation is blessed with a many-core CPU, you will enjoy dramatic rendering performance improvements over smaller chips. When AMD first unveiled Ryzen’s first-generation CPUs a few years ago, the company talked at length about its rendering benefits in Blender. Later, we even saw the company boast about it on its 256-thread servers. Fortunately, Cycles really does scale that well.

Not surprisingly, the 64-core Ryzen Threadripper 3990X takes the top spot, with well defined performance deltas between all of the chips. In every single case, renders done in Linux were speedier than Windows, with gains that would be appreciated by someone who owns either a low-end or top-end CPU. For most chips, the total render time is cut down by about 20%.

As we’ve likely conveyed already, modern GPUs are so powerful, that for rendering, you’re going to likely find the best value there. But, if you do happen to have a great CPU, it may just complement your GPU quite well. We’re going to explore that next, but do want to mention up front that a good CPU can also improve things like baking, physics, and compositing – so you probably don’t want to go too low-end, either. Another factor at play is memory, and as projects get larger, the GPU will end up using more system memory to compensate for its smaller framebuffer.

CPU + GPU Rendering

Blender 2.92 - Linux and Windows Rendering Performance (Cycles CPU+GPU, BMW) (March 2021)
Blender 2.92 - Linux and Windows Rendering Performance (Cycles CPU+GPU, Classroom) (March 2021)
Blender 2.92 - Linux and Windows Rendering Performance (Cycles CPU+GPU, Controller) (March 2021)

We mentioned earlier in the article that we stuck to Windows for our GPU rendering tests, as both OSes delivered virtually identical performance. Because the GPU is so powerful, the advantages on Linux when using heterogeneous rendering are not nearly as notable, but there are still some gains to be seen.

Ideally, if your workstation has a many-core (eg: 16+ cores) CPU, it’ll be because you have other workloads that need it, or you’re a huge multi-tasker. For most Blender users, we’d quicker recommend a more modest core count for your CPU, assuming that the chip is going to be clocked higher. CPUs with higher clock speeds, better IPC (instructions-per-clock), and generally higher single-threaded performance will make the OS and software snappier, even if the differences are hard to perceive through benchmarks. This is something we’ll talk about a bit more on the next page, where we dive into viewport performance.


Blender 2.92 Viewport Tests: Material Preview, Solid & Wireframe

Rendering performance is undoubtedly important when it comes to retaining sanity in your workflow, but viewport performance can be equally important, if not more so. After all, the viewport is where you’ll be doing all of your actual design work, so the laggier it is, the more frustrating it will be to work with.

The release of Blender 2.80 introduced Material Preview mode, which lets users see an advanced look at their project, complete with improved shading and shadows –  without having to wait on a render every time they’re not sure something’s going to look right. Not surprisingly, which GPU you have will greatly determine your level of satisfaction with this mode.

We’ve generally only tested Material Preview for Blender viewport tests because Solid and Wireframe modes are usually CPU-bound. With 2.91, however, we encountered anomalies with AMD Radeon GPUs that crippled performance in both of those modes, although only Wireframe was looked at. Thankfully, the Blender developers squashed the bug that caused the issue in time for the 2.92 release. That inspired us to return to Wireframe testing, and also include Solid mode for good measure.

We’re using two projects for our viewport tests, so let’s start with the lighter one:

Blender 2.92 - Linux and Windows Viewport Performance (4K Material Preview, Controller) (March 2021)

There’s quite a bit to dissect here. Overall, most of the GPUs scale as we’d expect, although it’s clear that NVIDIA has an inherent advantage. RTX’s special ray tracing features are not used in this look development mode, but NVIDIA’s architecture seems to be well-suited for it, anyway. Anything above an RX 5700 XT will deliver reasonable performance, but you may want to seek out a higher-end GPU if you want to better handle more complex projects down-the-road. We’ll touch on the weird Windows results for AMD cards a little later.

Let’s ramp up the difficulty and test out the Racing Car project:

Blender 2.92 - Linux and Windows Viewport Performance (4K Material Preview, Racing Car) (March 2021)

At 4K res, this project is a bit of a brute force test compared to the Controller one, as even the RTX 3090 can’t hit 60 FPS here, despite clearing 140 FPS with the other test. Naturally, you don’t actually need 60 FPS in a viewport, but it’s undoubtedly going to offer a more satisfying experience if it’s close to that – and again, you have to think about future projects. With the case of this “brute force” test, lower resolutions will fare a lot better – as we’ll see in a bit.

Turning our attention to Linux again, we were impressed to see improvements in all cases. That’s especially so because we’re dealing with the most graphics-intensive mode, and didn’t see any difference in performance between the OSes in GPU rendering.

One set of results we found interesting between these two tests were for the RDNA and RDNA2 cards (AMD’s 5000 and 6000-series GPUs). In the Controller project, RDNA (eg: RX 5700 XT) cards experienced a much larger improvement in Linux over Windows. Or, should we say, suffer a performance hit in Windows, since it scales as expected under Linux. With the Racing Car project, it was RDNA2 (eg: RX 6800 XT) that saw that weird performance flip.

Let’s see how things change in Solid mode:

Blender 2.92 - Linux and Windows Viewport Performance (4K Solid, Controller) (March 2021)
Blender 2.92 - Linux and Windows Viewport Performance (4K Solid, Racing Car) (March 2021)

Hoo boy. Racing Car, being much more complex than Controller, shows the most expected type of scaling. Whereas Material Preview had RDNA 1 and 2 GPUs scaling differently between projects, both RDNA series see the same kind of performance regression in Solid mode for Windows. Does it matter if you have 100 or 200 FPS? Probably not, but that doesn’t make the differences less interesting!

In another chapter of the Anomaly Files, the RX 5600 XT performed very strangely in the Racing Car project in Solid (and Wireframe) mode. Somehow, that was the only GPU in this bunch to see the reverse trend between Windows and Linux – something we ended up sanity checking twice over on different days because we just couldn’t wrap our heads around it.

For the most part, there are certainly performance issues with AMD under Windows, at least with the viewport. Whether that is an issue with Blender, AMD’s drivers, or Windows in general, we can’t say. But, it is something to be mindful of.

Are you tired of looking at charts yet? No? Well good, because here are some more, taking a look at Wireframe mode in the same projects:

Blender 2.92 - Linux and Windows Viewport Performance (4K Wireframe, Controller) (March 2021)
Blender 2.92 - Linux and Windows Viewport Performance (4K Wireframe, Racing Car) (March 2021)

It may not be immediately obvious, but wireframe modes involve a lot of information, and they can actually run slower than the Solid mode. This basically comes down to object occlusion and culling being disabled, since all vertices need to be visible (this a good example of how much performance can be gained from occlusion detection).

For the sake of time, we left the 1440p and 1080p viewport testing to Windows:

Blender 2.92 - 1440p Material Preview Viewport Performance (Controller) (March 2021)
Blender 2.92 - 1080p Material Preview Viewport Performance (Controller) (March 2021)
Blender 2.92 - 1440p Material Preview Viewport Performance (Racing Car) (March 2021)
Blender 2.92 - 1080p Material Preview Viewport Performance (Racing Car) (March 2021)

As you’d imagine, using a resolution lower than 4K is going to deliver a much faster viewport, but that shouldn’t deter you too much if you’d like a higher-res screen. If your viewport uses a fraction of the total screen, it will run a lot better than if it’s taking up the entire thing. We benchmark using a full-screen viewport to stress the hardware the best we can, so it acts as a “worst case” scenario for that project and resolution.

It was also at this point we realized the mistake with using Windows only for finishing up testing with 1080p and 1440p, as it meant we saw weird issues such as how a 5700 XT was performing better than a 6800 XT, and a 3060 beat out the 6900 XT. This comes down to the issues we saw earlier with AMD and Windows in Blender. We didn’t have time to retest all results, but did some sanity checks, and found in the Controller project 1080p material preview mode, the 5700 XT jumps from 69 FPS in Windows to 112 FPS in Linux. It also bumps from 60 to 108 FPS at 1440p, with similar scaling being seen with the Racing Car scene: 17 to 27 FPS at 1080p, Windows to Linux. In general, most of the AMD GPUs are performing about 40% worse under Windows than in Linux in viewport tests. This is something we’ll have to be more mindful of in future testing, at least until Blender and/or AMD figure out what might be the cause.

In advance of conducting our reportable benchmarking for this article, testing had been done on both our Ryzen Threadripper 3990X and Ryzen 9 5950X platforms as a comparison of viewport performance scaling between CPUs. We didn’t plan to provide this info, but there are some useful things to glean:

Racing Car Viewport FPS Material Wireframe Solid
(3990X) Windows: 5700 XT
(3990X) Linux: 5700 XT
8
14
58
48
110
74
(3990X) Windows: 6900 XT
(3990X) Linux: 6900 XT
14
20
57
56
100
104
(3990X) Windows: 2060S
(3990X) Linux: 2060S
13
31
82
84
155
143
(3990X) Windows: 3090
(3990X) Linux: 3090
42
48
135
167
160
197
(5950X) Windows: 3090
(5950X) Linux: 3090
45
47
179
175
299
313

On the previous page, we mentioned that your CPU choice for Blender should largely depend on how you use the software. If you prefer CPU rendering, you’d want a big, multi-core CPU. If you’re rendering with a GPU, and want the snappiest UI / interaction experience, modest core count CPUs with higher clock speeds can help – at least to some extent.

As you can see at the bottom of the table above, when the same GPU (RTX 3090) is tested in a 5950X 16-core platform instead of the 3990 64-core one, the Solid mode gains almost 100 FPS. Again, it doesn’t matter too much from a design perspective if you can flick the screen at 60 or 300 FPS – this ain’t a twitch-reflex shooter – but it still proves a point.

There are other aspects to CPU performance that we haven’t been able to cover, such as baking, physics, fluids, composition filters, and so on, where, for the most part, Blender is still largely single-core limited. The physics engine is going through an overhaul to be more multi-threaded, though, and it’s something we’re looking into building a test project for.

Memory is something else that needs to be considered. AMD’s Ryzen and Intel’s Core processors support up to 128GB, but their bandwidth will be limited to two-channel. The workstation-focused Ryzen Threadripper and Core X series support up to 256GB, and enjoy the extra bandwidth provided by a quad-channel memory controller. The complexity of your project, and how efficient you are with its resources, will determine how much memory you need, and whether GPU rendering will need access to system memory if its framebuffer is full. Testing these high-complexity scenes is something we’ll have to consider in the future.

Wrapping Up

Well, that was one heck of a Blender render (and viewport) bender. As it happens, Blender 2.92 brings not only many feature enhancements, but performance improvements, as well. We weren’t able to find the improved performance in our Cycles testing, either for CPU or GPU, but we did see a notable jump with Eevee across our tested stack.

One aspect of Blender performance we haven’t tackled in a while is tile sizes for CPU and GPU rendering, although that’s largely because the defaults are usually good enough. You can refer to some of our benchmarking from the Blender 2.83 deep-dive, but a good rule of thumb is that you use 32×32 for CPU, and 256×256 for GPU. Of course, if you really want to eke out the best performance, you can run your own quick tests using a region of your scene.

Blender 2.92 Splash Screen Project - Sinosauropteryx Prima (Credit - Joanna Kobierska)
Blender 2.92 Splash Screen “Sinosauropteryx Prima” (Credit: Joanna Kobierska)

We’d love to say that we hope this article helps you decide on a new GPU easier, but whether or not you’ll actually be able to find what you want available for purchase is the big question. The ongoing global chip shortage (or, extreme demand, if you want to look at it that way) is horrible for most who want to build a system right now. All we can say is good luck, and we hope your attempt is rendered a success (no pun, of course.)

Before wrapping up: a quick reminder that Radeon ProRender performance in Blender can be investigated in this article. With the RTX 3060 having just been released, and AMD’s RX 6700 XT due soon, we’ll soon be publishing a fuller look at rendering and content creation performance – so stay tuned.

Copyright © 2005-2021 Techgage Networks Inc. - All Rights Reserved.