Is Blender rendering faster from one version to the next?

We render tens of thousands of frames every day, 365 days per year. During this time, we monitor all the processes, to be able to proactively make adjustments and fixes, when necessary. The resulting data sometimes shows interesting side results; in this case, I’m going to refer to speed differences in rendering.

Starting with Blender 3.0 we have noticed that, for the exact same hardware, different projects behave in quite different ways. Some projects render in comparable times on our CPU and GPU machines. Some projects render way faster on the GPU servers. And a small fraction of the projects actually render faster on CPU – usually, projects that make use of volumetrics and/or motion blur may fall into this category.

This sparked a new question – are there speed differences between various Blender versions, too? And this is a question we can answer, seeing that at the time of writing this, we support Blender starting with version 2.75 until version 3.4.

So we started making some tests. We used the Blender splash screen images for this purpose, as they offer enough variety and they are more complex than the ‘original’ benchmark suite. To that, we added one Eevee file, as Eevee projects are also rendered on our farm. We did alter the resolution and samples count for some of the files, to make the differences more visible. So please look at the samples/resolution settings for each file, to put the results in the correct context.

Here’s how we set up this test: each frame (or frame group) was rendered twice, and the shortest time was considered. The same CPU and GPU machines were used for each individual test. GPU testing started with Blender 2.80, as older Blender versions are not compatible with our GPUs anymore.

(TL;DR: Blender 3.x is faster than all others. Also, the relative speed of a GPU vs a CPU varies from one project to another, so I recommend always making a comparative test when starting to render a new project)

That being said, let’s see the results:

1. Victor, 2,048 x 858 px, 600 Samples

What are the numbers showing us? The first observation is that the oldest Blender version, 2.75, is significantly slower compared to all the subsequent ones. After that, we notice some distinct performance improvement steps. For CPU rendering, there is one such step when moving from version 2.8x to version 2.9x, and a second step when moving from 2.9x to 3.x. The steps may appear small, but comparing version 3.x to version 2.8x shows a 30% decrease in render time. For the same scene, on the same hardware. Which means this is ‘free’ performance. Not bad, is it?

Looking at the GPU performance, we see a single improvement step of approximately 10%, when moving from version 2.x to version 3.x. This was to be expected because version 3.x replaced Cycles with the new and improved Cycles X. Still, it’s nice to actually see it in action.

So now, the question that you might ask is: very well, the new versions are faster, but does the render result look the same? Cycles has been replaced by Cycles X, and then there is the new hair system, and who knows how many other changes between the versions. And the answer is: there are differences between the images, yes. However, for the purpose of this test, I believe they are small enough to consider that the image is the same one. If you want to see the differences between the Blender 2.81 render and the Blender 3.4 render, move your mouse over the image below.

Racing Car, 4,508 x 2,480 px, 500 samples

The second rendered image in this benchmark suite is the splash screen from Blender 2.77 – Racing Car, created by Pokedstudio. The file was originally set up to render at 25%, but we bumped the settings to 100% resolution (which means 16x more pixels to render) for this test.

We can see here that Blender 2.75 is again the slowest version, but the difference is not as big as in the first test. For CPU rendering, the performance gap is not very visible – approximately 10% between the fastest and the slowest version. The GPU renders tell a different story, though. Moving from Blender 2.x to 3.x brings a significant speed increase, with the 3.x renders completing approximately 3 times faster compared to the 2.x times. Again, newer Blender versions bring free performance – and quite a bit of it. On the flip side, we have the only failure from this test here. This file refused to render with Blender 2.93 LTS on the CPU, with Blender crashing during all our render attempts.

Comparing the two projects, we can already see a difference in project behavior in terms of speed difference across Blender versions. You can see the output differences for this file below, and let’s move to see how the next render behaves.

Benchmark 3 – Barbershop, 2048 x 858 px, 800 samples

The third file we have tested is the well-known Barbershop scene. As this scene was originally set up with AA samples, we converted it to normal samples in order to even out the conditions for all Blender versions in this test.

This project paints, again, a different picture. For the CPU rendering, we see again two performance difference steps – one from version 2.8x to 2.9x, and another one from Blender 2.9x to 3.x. But this time, Blender 2.9 is slower than 2.8. Version 3 proves to be, again, the fastest from the lot by an important margin.

The more interesting results are with GPU rendering, though. In this case, versions 2.8x and 2.9x are approximately in the same ballpark. But version 3.x is a lot faster.

The differences between the renders are also a bit more visible when switching from one Blender version to another. You can compare the two below.

Benchmark 4 – Sinosauropteryx Prima, 1,920 x 1,080 px, 250 samples

The fourth scene is the splash screen from Blender 2.92 – Sinosauropteryx Prima, created by Joanna Kobierska. As this is a 2.9x file, the tests start with Blender 2.9x.

Yet again the numbers tell a different image compared to the previous scenes. The render times for the CPU are almost identical in all Blender versions. For GPU, version 3 brings once more a speed improvement of approximately 30%.

There are, as expected, a number of differences between the renders made with version 2.9x and version 3.4, as you can see in the image below. Most of them are likely to be caused by the changes made to the hair system in Blender 3.3.

Benchmark 5 – White Lands, 4,268 x 2,109 px, 128 samples

The fifth test image is the splash screen from Blender 3.2 – White Lands, created by Oksana Dobrovolska. As this is a native Blender 3.x render, we only used this major version for the tests. The original file setup was at 50% size, but we decided to use the full-size (4k+) render for this test.

The test results are quite uniform between the Blender versions. As with the Barbershop scene, the GPU servers complete this scene much faster compared to the CPU ones.

There are some subtle differences as well between the renders resulting from Blender 3.0 and 3.4, you can check them out below.

Benchmark 6 – Scanlands, 2,350 x 1,000 px, 300 samples

The last Cycles benchmark of this suite is the splash screen from Blender 3.3 – Scanlands, by Piotr Krynski.

We observe here the same even performance across the 3.x versions. Similarly to the previous image, GPU rendering is faster than CPU rendering, but not by such a significant margin. Just as a reminder, this is the exact same hardware and software configuration that runs these tests. And yet, the differences in comparative render times are quite significant.

Also, this test shows visible output differences between Blender 3.0 and 3.4, see the comparative image below.

Benchmark 7 (Eevee) – Tree Creature 3,840 x 2,160 px, 128 samples

The last scene from this test is an Eevee one. We decided to include an Eevee render in this suite because Eevee becomes more and more capable and can now successfully replace Cycles in certain types of projects. We have been supporting Eevee on RenderStreet since it was launched, and we’ll continue to support it for the foreseeable future.

We chose a scene that is part of the official Blender demo files: Tree Creature by Daniel Bystedt. As Eevee renders are typically fast, we modified the samples count to 128 (originally 16) and the resolution to 4k (originally 50% of Full HD) so that the differences can be more visible. Even with these settings, the render times are quite fast.

For this test, we added renders made with our “frame group” option as well. This option, available on RenderStreet for all Blender renders, optimizes the rendering process for fast frames (under two minutes per frame). As a result, both the cost and the delivery time are reduced in these cases. All tests were made on GPU, as Eevee only runs on GPU.

The results show a clear speed improvement starting with Blender 2.93. After that, the times are relatively even for the next versions, with one exception: version 3.4 is significantly faster when frame groups are used.

Comparing the render from the first and last Blender versions (2.83 and 3.4) shows a difference in lighting, plus minor changes in textures. But overall the renders are surprisingly similar, considering the number of versions apart.

Conclusion

After looking at the data, what conclusions can we draw? The first one, which is obvious in all the test results, is that Blender 3.x is faster than the previous versions. If you are still working with an older version, I would suggest switching to 3.x as soon as possible. It will save you time and money (either in render farm costs or in power costs if you render on your computer).

The second conclusion is that this test confirmed our previous observations: the comparative performance between CPU and GPU varies quite significantly from one project to another. On our specific hardware configurations and for this particular test suite, the GPU servers were always faster. But on more complex projects, or on your computers with different hardware, things may be different. So my recommendation would be to always make a CPU vs GPU test when you are ready to render a new project, to see which one is faster in that particular situation.

Happy rendering!

Marius Iatan