When we first started testing viewport performance in Blender a few versions ago, we took advantage of the complex Racing Car project that was bundled with the 2.77 release. Back then, that project proved a bit too much for most of our tested GPUs, so we ended up replacing it with the simpler Controller project. Well, as GPUs have become more powerful, it made sense to bring the Racing Car project back, and see how things fare nowadays.
Generally speaking, the Wireframe and Solid viewport modes don’t require strong GPU performance to deliver a good frame rate, but Material Preview and Rendered do. The latter is just as it sounds – a real render inside of the viewport. When in this mode, moving the camera and stopping it will immediately start the render over, allowing you to get decently quick feedback. Material Preview lowers the performance bar a bit by not looking like the final render, but looking close enough to give you the impression you need of how things are coming together.
That all said, we don’t generally test with any viewport mode other than Material Preview, but we have exceptions coming up. First, let’s look at the Controller project at its three resolutions:
It’s important to not take these charts out of context. As we see with gaming, the lower the rendered resolution, the greater the chance the CPU will make top GPUs all perform the same. We get some hint of that here, although there are still some clear differences across the stack. At 4K, the scaling looks the best, as the GPU is put to best use, but at the top-end, one card can flip-flop positions with each other. It’s this odd project scaling that can result in something like a 2070 Super performing better than a 3090. It’s for this reason that we wanted to re-add the Racing Car project to see if it would give us more linear scaling:
Even with this Racing Car project, the lower resolutions have the tendency to shuffle the top-end of the stack, usually only by a frame or two. With this particular project at 4K, however, that graph gives us the scaling from top-to-bottom we’d expect. Even the RTX 3090 manages to show a strong gain over the RTX 3080 in that test – and the RTX 3080 comes far ahead of the RTX 3070.
To be clear about one thing: whereas 60 FPS is pretty much a necessity in gaming for an enjoyable experience, the nature of manipulating a viewport allows for lower frame rates to feel apt. We wouldn’t recommend a GPU that dips below 20 FPS, however, because you don’t want it to feel outright janky – that only leads to frustration. But if you want a faster viewport, you can just disable objects you’re currently not working on to help improve things.
The most glaring thing about the above performance is the fact that AMD GPUs suffer hard compared to the NVIDIA competition. Even at 1080p, AMD’s biggest RX 6900 XT GPU hits 34 FPS at 1080p, whereas NVIDIA’s lower-end RTX 3070 hits 36 FPS at 4K.
Unfortunately for AMD, the problems extend even further than that. For as long as we’ve been testing Blender’s viewport, we also had our scripts benchmark Solid and Wireframe modes. However, because those have largely been a CPU bottleneck, the results are usually unimportant – 60 FPS is almost always easy to hit on even modest GPUs, unless the project is simply massive.
What we found in Blender 2.91, however, is dramatically degraded performance on Radeon GPUs. These next charts will spell that out quite clearly:
The results here are a little strange in many ways, so we’ll try to explain them as simply as possible. First and foremost, our viewport is tested with a simple method of revolving the camera around the center of the project without changing the angle – not up and down and all around, because it has never made a difference to the scaling in our LookDev (Material Preview) mode. However, wireframe behavior is a little different.
On GeForce cards, opening a project fresh, moving to Wireframe mode, and then immediately rotating the camera gives us our ~60 FPS result. However, if the camera is moved around with the mouse, and then the project view reset to our default, that ~60 FPS suddenly becomes ~90 FPS on those same GPUs – just like we see with the TITAN and Quadro cards on top of these charts. We must stress at this point that there is no intrinsic benefit to workstation class cards here, what you are seeing in the charts is an artifact of our testing method that these workstation cards seem to be immune to.
As unimportant as this truly is, we found that those workstation cards don’t need to have the project camera moved with the mouse to bump the initial ~60 FPS to the higher value from the start. In the future, we’ll need to go about this viewport test differently, if future Blender versions continue to show such degraded performance on certain GPUs. Again, as mentioned above, while we’ve tested Wireframe for quite some time, this is the first occasion where the data has been interesting enough to talk about.
Blender 2.90 (left) vs. 2.91 (right) Wireframe performance on RX 6900 XT
The most important takeaway from these results is that Radeon fares really poorly. People should expect to get great Wireframe performance on even modest GPUs, so what’s the deal here? We’re not quite sure, but we do know one thing: this weak performance is not reflected in 2.90.
An example of that performance detriment can be seen in the shot above. Note that the FPS values seen in those shots are not reflective of our benchmark results, but just what Fraps happened to want to report at the moment we could snap the screenshot. In reality, the 2.90 result was closer to 70 FPS, while the 2.91 one was glued to around 25-27 FPS in our manual testing.
Part of this explains the weak Material Preview performance, as well. In 2.90, we saw the RX 6800 XT hit 44 FPS with the Controller project at 4K, yet that value dropped to 31 FPS in 2.91. Perhaps this is something that Blender itself needs to fix more than AMD – we’re really not sure. Either way, we do know that current viewport performance is really rough on Radeon, and anyone with any one of these models we tested, can do their own testing of 2.90 and 2.91 back-to-back and check for a difference.
When we finally got around to posting our Blender 2.90 performance look, we noted that the biggest reason for the hold-up was the fact that certain Radeon GPUs kept crashing the software. That included the RX 5700 XT, which with five different drivers would fail to render basic projects like BMW and Classroom. Fortunately, that issue has seemingly disappeared in 2.91.
That said, while certain issues are remedied in 2.91, AMD has suffered a bunch of new ones, and we’re not quite sure who’s to blame. It does seem clear one key change was made in 2.91 that greatly impacted Radeon performance, but left GeForce alone. We even tested with the Radeon Pro W5700 to see if the same viewport issues carry over to that series, and sure enough, they do. Clearly, Radeon users are going to want to stick to 2.90 for the time-being.
Even besides those issues, NVIDIA has such a stranglehold on Blender performance right now. The gains its RT cores deliver with Cycles rendering quite literally take things to a new level, and even in Eevee, NVIDIA wins each one of its competitive match-ups. AMD’s fortunate that the performance gap isn’t quite as strong with Eevee, at least.
The reality is this: if you’re a Blender user needing a new GPU, it makes no sense to go with Radeon right now. With 2.90, we had stability issues, and in 2.91, we have noticeable viewport performance issues – and none of those problems have occurred on the NVIDIA side. If you do stick with Radeon, it’s best to use Blender 2.90, because something about 2.91 doesn’t jive well with AMD’s cards. We’re hopeful that 2.92 will return us to previous viewport performance levels for AMD. A potential alternative is to not use Blender’s built-in rendering engine, Cycles, but instead use AMD’s own Radeon ProRender. This assumes that you’re aware that your scene will look different, and will need new shaders to get things looking close to how they did in Cycles (we can’t do a direct performance comparison between Cycles and RPR because the two engines generate two visually different results).
After poring overall of the results here, it seems that NVIDIA’s GeForce RTX 3060 Ti is easily the best value of the bunch. It costs $399 (SRP), and outperforms all of the company’s last-gen top-end parts in Cycles – including 2080 Ti and TITAN RTX. In Eevee, higher VRAM amounts are really favored, so moving up to the $699 RTX 3080 for that use will reveal even steeper performance gains than you’d expect, even though the VRAM bump is modest.
As for CPUs, it’s really hard to recommend high-core count chips for Blender use right now when NVIDIA’s GPU performance is so strong. We saw a GeForce RTX 3060 Ti with OptiX outperform AMD’s top-end 64-core Threadripper, so we don’t know what else needs to be said. You should only opt for a many-core CPU if other workloads demand it, or if you want to eke as much performance out of a CPU+GPU combo as possible. However, it’s imprtant to remember that a large pool of memory would still be benefitial in more complex scene. As we stated earlier, though, your best value would be doubling up on GPUs. You can gain an impression on dual GPU performance from this recent article.