Eevee is better than you may think


... which one of the renders bellow is Cycles and which one is Eevee, would you be able to tell at a first glance?


I'm a really stubborn girl, it's really hard for me to change once I stick with something I like (such as Cycles). Once I learned about Eevee in 2018 I didn't even want to try it. "Why try it? Cycles works just fine and is suuuper realistic", I said. I said that for 3 years, and now I regret it. Eevee is great and has it's place, and we're going to talk about it today.

Hey folks! :)
I've missed you!

It's time for a new tutorial. But before we proceed, I'd like to do a couple things: apologize for the delay, and give you a small update on my personal status. If you'd like to read it, click here, otherwise let's get to the tutorial bellow :D

As with my first tutorial, I'll briefly go over what you should and should not expect from today's read.

What you should expect:

- A quick yet effective way to get into Eevee for interior scenes;

- A brief explanation of render techniques, how they differ from each other, and where Cycles and Eevee sit in the rendering category;

- An understanding of when and why to use Eevee for interior scenes instead of Cycles;

- How to setup a basic world lighting, interior lighting, and materials for Eevee;

- A very basic example of animations using Eevee.

What you should not expect:

- A technical review of Eevee (while I'm fairly technical with Linux and firewalling and technology in general, I'm not an expert in Eevee and how it works deep under the hood);

- A tutorial for exterior scenes using Eevee.

So what is Eevee?

You probably heard the term "Ray Tracing" since the 2000 series of NVIDIA GPU's rolled out in 2018. The term has been discussed a lot since then and has gained quite a bit of popularity, specially among gamers. Ray Tracing is one way of rendering images onto your display. There's also Rasterization, Ray Casting, Path Tracing, Wireframe, Scanline, Radiosity, and a few others.

So to get things out of the way, let's have a basic understanding of the most common rendering methods used in the industry. (If you want a video explanation, Andrey Lebrov has done a great job here).


- What Ray Tracing does is shoot rays out of the camera (1). Once a ray hits something (like a wall, a table, anything physical) the computer will use this collision coordinate to cast one or more rays to the light sources (2). This means Ray Tracing has basically once light bounce.


There's some confusion in the Blender world where people say Cycles is a "Ray Tracing Engine". Literally speaking, Cycles also shoots rays out of the camera, but it's not limited to a single bounce. Cycles is a Path Tracer, which we'll see bellow.

- Path Tracing follows the same principle of Ray Tracing: you shoot virtual rays out of the camera, and they bounce.... but they bounce A LOT more. Now, in real life there isn't really a limit on how many bounces a photon can have - one can shoot out of your lamp, bounce on the table and then be absorbed later on the wall - or bounce at the wall then bounce on your face to then later be absorbed somewhere else. This is why real life looks so good, and why Path Tracing renders look so good, because light bounces a lot and it will follow a sort of natural path the same way a real photon would.

The image bellow helps visualize how a Path Tracer works:


As you can see, the number of bounces in a Path Tracing engine can be a lot bigger than a simple Ray Tracer, but it doesn't mean you need to configure Blender to use a trillion bounces in your scene (nor does it make sense to do so). Cycles by default has a cutoff at 4 Diffuse bounces and 4 Glossy bounces, which is enough in the vast majority of cases. In fact, as Andrew Price once showed, even 1 to 2 bounces can be enough. But why is that?

To understand it, we need to know how color works.




If I were to ask you "what color is a red apple?", what would be your answer? I wouldn't blame you if you said "red", but that's not the correct answer. While red light is what you see, the apple's true color is "all but red". Remember in elementary school when your science teacher taught you that "color is light reflecting out of objects"? That's what's happening to our red apple: light is hitting the apple's surface, and the red light is bouncing off of it. So the apple can't be red, because it's reflecting the red color.


In a hypothetical perfectly red apple, almost all light waves/particles would be absorbed by the apple and the only light bouncing off it would be red. That's not so different from how it happens in real life, and this is one of the reasons you don't need "1 bazillion light bounces": light won't travel too far in a colorful scene without being absorbed somewhere (as with most of the light hitting our apple).

In the kitchen scenario showed earlier, one virtual photon had 4 bounces. Now imagine what 1 million photons, all with 4 bounces each, would do. Combine that with the fact that light won't travel too far without quickly being absorbed and it's easy to understand why you don't need more than 2, 3 or 4 bounces to achieve realistic lighting both in Cycles and in Eevee.

So what about Eevee?

Eevee is no different than your average game engine, which means it achieves rendering by rasterization [1][2][3]. But for our purpose (ArchViz), we can think of Eevee as a "midground" between rasterization and Path Tracing, because in order to achieve the best realism we will shoot rays into our scene and calculate light too, but it won't be all in real time. The idea is that we'll bake most of the lighting information (like Andrew Price showed here). That's how my first comparison in this tutorial was made.


Don't believe that's Eevee? Check the video bellow.

So, without further ado, let's get our hands dirty  and do a very similar scene to mine :)





The first thing you must learn about making interior scenes with Eevee is that walls need to be solid like real walls, they need to be T H I C C. If you've seen my first tutorial on ArchViz you know that we literally made our walls as thin as paper. That's because, for Cycles, a simple plane counts as a physical object that doesn't let light pass through it (in any direction), but that won't work for Eevee. So if you have the file from my first tutorial and simply try to render it in Eevee, the scene will look like as if there are no walls to block light coming in and it will look just horrible.



Such wall setup works for Cycles as a simple plane

will block all the light trying to pass through it.




However, for Eevee we need to make the walls T H I C C.


Start from the beginning

Just as in real life, we're going to start out room from the lowest point possible. In our case, the floor. The measure of our project's floor is 3m x 3.5m. After that, we extrude it upwards to make the walls and ceiling. Now, ceiling heights are usually 2,4 meters, going up to 2,7 in some fancy homes. In our case, we'll make it 2,6m.

If you're with me so far, here's where we stand:


Apply the scale to the object (Ctrl + A), then do a solidify on it. This is where we make the walls T H I C C.

Now, I'm going to use the measurements from here in Brasil for the walls (and most of my scene), but feel free to use your local measurements for this. Walls here have usually two thicknesses: one for the outer walls and one for the inner walls. 99% of homes where I live are made of bricks. The home's inner walls are a little thicker than a brick (9 cm) so I'll use 10 cm. The extra 1 cm is for plastering (see reference bellow). For the outer walls, the bricks are either layered lengthwise or "lying down", and the outer walls' measurement for me is 20 cm (19 cm for the brick + 1 cm for plastering).



There are many types of bricks that are used here: 3 holes, 6 holes, 12 holes, solid bricks, concrete ones, bricks in many different shapes and sizes. But the overall dimensions expressed here are safe for my specific area and usually the outer walls are twice as thick as the inner ones. It may be completely different where you live, so use whatever dimensions fit your realism the best.

While you can (and should) use two dimensions on your scene (one for the inner and one for the outer walls), I won't be doing that, because this project is really about one or two shots where only the interior wall appears. So mine will have 20 cm all around.

Remember to make the thickness outwards, so use an Offset of 1 instead of -1.

Also, check "Even thickness" otherwise the solidify won't have the measurements you specified.


I won't be making any doors, so no holes there. But we will need a window. Measurements for it's base height here range from 90 to 115 cm. For this project, I'll use 90 cm. For it's top height, 140 cm (above the 90). Make it as wide as the walls, as follows:


Some basic UV unwrapping on the inside (all we're going to need):


Add a camera. Resolution at 1266x1920.



Now, if you want to have my exact files (to have the same result as me, materials and everything), you can do so by becoming a Patreon.

Downloads at:

The file with the progress so far is called "Home_Office_001.blend).

Level 2 Patreons have access specific files (in stages) of the tutorials (such as the stage we are now).

Level 3 Patreons the stages, more assets, and also the final completed files (among other benefits).

You can also donate to me at PayPal and ask for the files (following the same "levels" as my Patreons). You can donate HERE.

Decor is important, but we need something to put it in!

Decore is very important, but we need something to put it in first. So, we'll make a table, some shelves and "I don't know the name of the thing" down there :P

The first thing I'll do is book shelves. The wooden one.


Measurements are:

A: 100 cm Lenght

      40 cm Depth

        3 cm Height

B: 3,16 cm Lenght

       36 cm Depth

     78,5 cm Height

C: 45 cm Lenght

    36 cm Depth

      3 cm Height

D: 3,16 cm Lenght

       36 cm Depth

     78,5 cm Height

Backplate: 100 cm Lenght

                      3 cm Depth

                 78,5 cm Height


I usually leave a small gap between 0,5 and 1 mm between objects, along with a small bevel (0,2 cm in this case). Both give a better sense of realism as nothing really touches perfectly, and no corner is as sharp as a default cube in 3D (if it were you'd cut your finger on it).

I'm also making these "L's" for support and some screws. You can make them as you wish. Mine looks like this:


No need to go crazy on the details as it's only going to be seen from far away - but it will give a more "umph" to your scene.


Next is the second shelf.


Bellow are the measurements. This shelf is essentially a cuboid with an inset of 3 cm for the main big hole, and 3 planks (2 horizontal, 1 vertical) with 3 cm of wall thickness).


Bellow are the measurements for the wood grid. Each strip is separated by ~1 cm.


Bellow are the rough placement for both shelves.


And here's where I stand at the moment. The image on the left is rendered by Cycles just to show our progress. On the right is the overall placement of the shelves.


Let's do a simple table:


Now, I don't know the name of this thing that goes on the floor, but here we go with the measurements. It's essentially the same idea as the grey shelves, only with a small difference: the walls are 2,5 cm thick instead of 3.


Here's how it looks on the scene (table finished too):


At this point, most of what "makes the scene" is already there. We need props, and we now have somewhere to put them. It's up to you what you chose to put in it, but I'll leave a download for my props so my Patreons can use the same ones I used. Whatever I publish was modeled by me or they were downloaded from websites and had a non-atribution license.

But before that, we just need two things: a window, and a ceiling plaster thing (used for night lighting). For now I'll just make the ceiling plaster.


As for the window, it's a simple Rail Window (Addons - Add Mesh - Archimesh) with some very simple shades (Array) and some other embezzlements. There's really nothing really special about it.


Forgot to mention something. On the plaster, we need holes so we can fit our spotlights. The video bellow shows how I do it for my scenes.

You can make the spots into any shape you want or just do some research on a shape you like. Over here, the shape I used is common.


And here's how the scene looks. Don't worry, we're still in Cycles, but we're going to move to Eevee soon.





Bellow is how the scene looks rendered in Cycles. We're still using Cycles, because it's much faster to just click "Render" in Cycles than to configure Eevee. Trust me, you'll see understand it later ;-)
(There will be, however, a great tradeoff after we configure Eevee, but that's coming in a bit.


And bellow is the props used in the scene. Everything was modeled by me, with the exception of the flowers which I've gotten from TurboSquid like 3 years ago. As you can see, not many props were needed in our scene - most were, in fact, books, which you can have for free from many, many websites out there :)

But since I'm not sure I can redistribute the books I've used, I'll let you do some research. Or use something else in place of the books.



If you want to use the props I've modeled, you can do so by becoming a Patreon.

Downloads at:


​​You can use them for any purpose you want, commercial or not.

Level 2 Patreons will have:

- All electrical props (tubing, outlets, wires, plugs);

- Lamp;

- 3 Picture frames;

- Pen glass with 6 pens;

- A creeper from Minecraft;

- An alarm clock;

- A glass with roses;

- A coffee mug.

Level 3 (VIP ) Patreons will have everything from Level 2, but also:

- the chair;

- The iMac clone.

You can also donate to me at PayPal and ask for the files (following the same "levels" as my Patreons). You can donate HERE.




And now that our scene is complete,  we'll do one final render with Cycles.


So now that we have a good base scene:



There are only a few things you really need to care about when doing interior scenes with Eevee:

- Screen Space Reflections: Reflections that you only see when the objects (or whatever you want reflected) are on the screen. If they're not visible to the camera, they won't appear in the reflections. Now, this is part of the limitations of non-real-time Render Engines like Eevee or Unreal Engine, and there's not much we can do about it. It sucks, but that's how it is. If you're not shooting rays all the time, at all directions, the software won't know there's something away from the camera's POV that needs to be reflected.

- Reflection Cubemap: this will be your go-to solution to fix the limitations of SSR. Reflection Cubemaps capture all reflections on the scene, but it comes with a catch: you can't add new objects to the scene and expect them to be reflected (in the case of, e.g., someone walking in front of a shinny surface in an animation). Blender will essentially capture all reflections, but they will be static. They'll look nice, but they won't update with newer/changing objects. It may be needed to turn off SSR in order to use a Reflectin Cubemap.

- Reflection Planes: now, don't worry, if you want good reflections that update at all times, Reflection Planes are the solution. Need a mirror that updates when something moves in front of it? Place a RF in it. Need a good reflecting floor? Same deal. The limitation is that, the more Reflection Planes you have, the slower the renders will be. If these planes work the same way as in Unreal Engine, they literally have a virtual camera rendering off of them.

- Irradiance Volume: This is where the magic happens and it's mandatory to have if you want good results for ArchViz. This process is also completely horrible in Blender and needs to be changed as soon as possible, the way Unreal Engine handles irradiance volumes is light-years ahead of Blender, there's not even a comparison to be had here.

But put simply, Irradiance Volumes are where the indirect lighting is stored, but you can think of it a bit differently: you can imagine the lights bouncing everywhere on the scene, hitting objects and being frozen in place as if they (objects) are wearing a new texture. You can move objects after compiling the light, but the textures will remain the same (see videos bellow).

Reflection Cubemap


Let's start with the Reflection Cubemap. Essentially, it dictates the limits of the baked reflections. When you add a Reflection "cubemap" Blender will give you a sphere, for whatever weird reason. Change it to a cube as it best fits the shape of our room.

On the image on the left you can see 4 lines and 4 red circles. At the end of each line there's a small dot - use this dot as clipping, a limit to the reflections. If you make these dots smaller than what you're trying to reflect, whatever is outside of the dots limits won't get proper reflections.

But there's a big problem when trying to fix this: because of whatever weird reason, the dots won't be centered, it's as if the scale is wrong after you, well, scale something in Blender and the normals/measurements won't work peroperly. Sadly, there's no way

of applying a scale onto the cube, and so the dots won't come out the same size everywhere. This needs to be fixed ASAP. If I make my cubemap 3x5 m and I want the clipping to be 30 cm, the clipping needs to be 30 cm all around.

If you need to, you can place more than one RC on the scene to mitigate this.


Here's how my reflection cubemap is setup.

You can see how the lines/dots aren't equally spaced out from the cubemap's limits (the problem discussed before). But since I won't need super nice reflections on this project, this cubemap is fine the way it is (and I'll place something else later when I need better reflections).

Bellow are my settings.


Here's a closeup of the walls and the cubemap. Red are the walls, yellow is the cubemap.

You may also notice that there's essentially no falloff. I'm doing this because I'm only using one cubemap and it covers everything.

This essentially covers everything from the Reflection Cubemap. There are other techniques to be used, but for now this is enough for me,

Reflection Planes

Now, if there were no glass in our scene we wouldn't need this part. But because there is, we will have to enable Screen Space Reflections so that we can also enable Screen Space Refractions (should they really be tied together?).

If you decide not to use some glass props, you can skip this part. But since I will, this means I'll face a limitation of SSR: the reflections on the floor will be horribly wrong, which means I'll have to add a reflection plane on it.

As you can see on the image bellow, the reflection plane has 5 "lines". The middle line (3) is what matters to us. Place it just a little above the floor's most top surface. I'll place one one on the monitor later.


Irradiance Volume

This is the worst part of the tutorial. I understand that "hate" is a strong word, so let's just say "I truly dislike doing this in Blender".

If you've done ArchViz in Unreal Engine you know that all you need is to literally create a simple box around the meshes, saying "here is where light is important" and you're done, the lighting comes out beautiful after one compile and you know one compile is all it takes in Unreal Engine. Not in Blender.

It requires a little sacrifice to do this in Blender. You will lose hair doing it, because it will stress you out.... because the system is horrible.

Bellow a few viewport examples from Unreal Engine.


Looks good, right? And that was on the "Medium" light settings (from Preview, Medium, High, and Production settings available). It only took me one compile, and a simple box as shown bellow. This is fantastic because it speeds up the workflow and good results are guaranteed. This is the way it should be everywhere, Blender included.


See how simple it is to setup the Lightmass Importance Volume inside Unreal Engine:


As you can see, it's literally just a simple box bigger than the overall meshes. But what about Blender? Blender has this:


On the left is a default Irradiance Volume.


The main idea is to have the dots/probes inside the walls.

The first/smallest box you see is the cutoff area: beyond this box, meshes will start to not be affected by the Irradiance Volume and will start to fade towards the second/bigger/outer box. Since we're placing the cutoff box inside the walls, we don't really need the falloff box, so you can disable it by setting the distance to 0.


While not different from how Unreal Engine handles irrandiance, the Irradiance Volume in Blender simply horrible to control. If the probes get close to a mesh you'll get black spots all over your scene, and this is far from how many problems this system has. This is by far the worst part of doing anything realistic in Eevee, because you have to keep resizing and re-placing the Irradiance Volume many, many, many times over to try and get it right, and each time you do it you must compile the lighting again which can take anywhere from 5 to 90 minutes depending on the resolution (number of probes) you chose. It's not a good system and it needs to change.

One way of dealing with this problem is to reduce the number of dots from e.g. 16 to 12 or 10. However, the more you reduce the sampling, the lower the quality of the lighting will be.

Again, this system needs to change.

Here's how mine looks with 12 probes. Notice the black spots near the wall and table.


Reducing the number of probes from 12 to 10 could solve the problem, but it's far from the perfect solution. Another way of reducing these problems is to reduce the Visibility settings:


However, as you might have guessed, the fix comes with problems, which means we'll have to compile the lighting again and try to find suitable Irradiance Volume settings for our specific scene.

Bellow is the problem introduced after changing the visibility settings.


It took me a while, but I was able to find a good spot for my Irradiance Volume.


Aaaaand, that's essentially it. I've only really cared about 3 things while converting a scene from Cycles to Eevee: Reflection Cubemap, Reflection Planes, and the Irradiance Volume.

While the process could be much, much faster, it' still worth it to try Eevee.



We've reached the end of this project's files. VIP's can download everything (including the final file).

Downloads at:


You can also donate to me at PayPal and ask for the files (following the same "levels" as my Patreons). You can donate HERE.

​By why waste so much time?, I hear you ask. If we can get a single render in Cycles much faster than if we were to configure everything in Eeve, why would we use Eevee at all?

The answer is rather simple: if you want to do a wakthrough (animation), the overall time required to render all the frames will be lower. For instance, while it would take 2 to 10 minutes per frame in Clcyes (and that makes sense for a single frame), what if you needed to render 500, 1000 frames? Since Eevee can achieve roughly the same render quality as Cycles, and the time to render each frame will be from 5 to 20 seconds in the case of this home office we just did, it's easy to understand why Eevee can make a lot of sense. 500 frames at 10min/frame is 5000 minutes (83 hours) - if it takes 20 seconds per frame, it's 1000 minutes (16 hours).

Bellow is my first animation using Eevee and is what motivated me to make this tutorial in the first place. It's really simple and has many flaws, but it was rendered in a fraction of the time it would take to rneder it in Cycles.

Understanding the limitations


So now that we've reached the end of the tutorial, I'll show you a few limitations with Eevee, starting with reflections.

As you can see on the video bellow, I'll add a sphere to our scene and move it in front of the monitor.

As you can see, the sphere does not appear in the reflection. That's a limitation of the Reflection Cube as the reflections are baked in. To solve this, we can add a Reflection Plane to the monitor:


You may remember me saying about how baking the textures is like using new textures. I'll show it to you now. I'll move the monitor, which should update the shadows - but it won't, as if the walls are using a new texture.

It's like the photons are frozen in place, right?

Sadly, the only way of changing this is to bake the lighting again. But hopefully it will be worth it as you make beautiful scenes too :)

We're done! Hopefully this tutorial was useful to you. Don't forget to click "Get notified of new posts" bellow to get notified by e-Mail everytime I make a new tutorial!