In my application I use Blender's Internal rendering engine (headless mode) to render quick mock-ups of various items. BI yields plenty quality, however speed is essential (it's a web app) and I wish it was faster.

I wanted to try out Eevee so I ported one of my scenes to 2.80, fixed the textures & lighting and tried rendering the scene.

The scene is very simple - two objects with a basic texture material and three (!) light sources. It renders this: enter image description here

My 2.79 Blender Internal environment is run on an 8-core (2.7 GHz Intel Xeon® Platinum 8168) 16G RAM compute-optimized VM.

I tested 2.80 Eevee on a Tesla K80 6-core 56G RAM VM, which is comparable in price.

It seems that Eevee is slightly faster than BI. The difference is even more significant when multiple clients are rendering in parallel.

Unfortunately, everyone keeps comparing Eevee to Cycles and I haven't been able to find any relevant data on Eevee vs BI. My questions are thus:

  1. Would one expect Eevee to be faster than BI in general? If not, under what circumstances would BI be faster?
  2. Which one has more potential for optimization (e.g. reducing samples vs optimizing tile size, etc.)?

I appreciate that there are many factors in play, especially when it comes to hardware. Hopefully that does not make this question too broad.


My scenes are here:

I don't really have any specific requirements... Here's what I am thinking:

  1. The final result should not look like it's from Counter Strike 1.6. This is what I have now, and it's fine: http://www.filedropper.com/phone_2 (yes, I am stitching two images together)
  2. Potential load is not yet known, but I might want to plan for maybe 100s of people rendering at the same time...
  • $\begingroup$ On a side note, if you have suggestions on how to do this better, I'm all ears. I guess learning something like Unity and porting/recreating the scene there is an option. Too bad I have 0 experience in 3d programming, wouldn't even know where to begin... $\endgroup$
    – Avius
    Feb 20, 2020 at 18:31
  • 1
    $\begingroup$ I'm curious why you decided to do server side rendering for 3D assets. This sounds like it would scale very poorly and a client side solution would be preferable. $\endgroup$
    – Robert Gützkow
    Feb 20, 2020 at 18:40
  • $\begingroup$ Agree with Robert, also I'd suggest upload a scene and your requirements so we can compare against each other along with optimized settings. $\endgroup$
    – brockmann
    Feb 20, 2020 at 18:43
  • $\begingroup$ The biggest problem in all of this is my lack of relevant knowledge. I assume you mean migrating to WebGL? Sadly, I am not a GL programmer, so it would be quite time-consuming. I also need to be able to manipulate (using image processing - rotation, resize, composition) and set arbitrary textures. Not even sure if I can do that using Canvas. Finally, there's a need to store a lot of the generated content on the server. I thought it would be a little awkward to upload client-generated content to the server, especially since some of them have to be quite hi-res (~15mb+ TIFFs). $\endgroup$
    – Avius
    Feb 20, 2020 at 19:25
  • 1
    $\begingroup$ Yes you should be definitely running the rendering client-side on WebGL, take a look at blend4web.com/en. Even making your own WebGL/three.js renderer isn't that hard. BI and Eevee are both rasterizing engines, BI is a software renderer, Eevee is hardware accelerated on GPU with openGL. Eevee apart from compiling the shaders should be realtime/instant for your use-case. Don't know if Tesla GPU's are best for you, you will probably have better results with Quadros. $\endgroup$ Jun 19, 2021 at 21:42

1 Answer 1


I know I'm late to the party, but I'll leave this here for reference. Blender Internal is an extremely outdated engine, hence why they replaced it in 2.80 with Eevee, which is far superior in every way.

The most prominent difference between Eevee and Blender Internal is that, while Blender Internal renders offline using the CPU only when you manually go to render, Eevee is a real-time rendering engine that runs on the GPU utilizing OpenGL. This means that Eevee is significantly faster than Internal in every situation, even when rendering on the CPU. In fact, Blender 2.80's material view actually utilizes Eevee for its rendering.

Furthermore, Eevee is much easier to use and has a node-based material system identical to that of Cycles, including PBR support. (Eevee materials are actually compatible with Cycles and vice-versa.) No longer do you have to fiddle with a million settings in order to get a decent result, although optimization settings are still present and very powerful for those so inclined. But your optimization (or lack thereof) in the scene will only ever affect render times in matters of seconds, as the main bottleneck when it comes to Eevee is the time it takes Blender to save the frame to disk and queue up the next frame.

In short, use Eevee and your render times will be faster and your results will look way better.

PS: I don't actually know that much about the technical side of Blender Internal, so forgive me if I got something wrong.


You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .