Your awareness of optimization in game development

Development Programming & Scripting
,
1

Subject: Looking for Optimization Advice – My First UE5 Game Turned Out Very Heavy

Hi everyone,

I’m a beginner and recently completed my first game using Unreal Engine 5. While I was proud to finish it, the performance turned out to be a big issue — the game only runs smoothly when all scalability settings are set to the lowest.

Here’s what I did (and now realize were likely mistakes):

スクリーンショット 2025-06-01 202557
スクリーンショット 2025-06-01 2025571854×1007 279 KB

スクリーンショット 2025-06-01 202446
スクリーンショット 2025-06-01 2024461755×1017 377 KB

  • I duplicated a single level three times, and each level ended up around 8GB in size.
  • I used a lot of free assets from Fab without optimizing or considering their impact.
  • I placed many lights without any planning, just to make things look good.
  • My map isn’t very large — it’s basically just a single big house filled with various objects — but performance is extremely poor.

Clearly, the game has become too heavy, even though it’s not an open world or large-scale map.

For my next project, I want to improve and learn how to build more optimized, efficient levels. UE5 allows for beautiful visuals, and I’d like to preserve as much quality as possible without just turning off Lumen or reducing graphics across the board — that feels like wasting UE5’s potential.

I recently studied a lot about UE5 optimization (based on this optimization summary) — things like:

  • Reducing unnecessary collision,
  • Avoiding heavy materials like Masked or Translucent,
  • Disabling unnecessary Tick events,
  • Managing MetaHuman settings (LOD, PostProcessAnimBP, etc.),
  • Avoiding excessive PostProcess or dynamic lights,
  • Using Stat Unit, ProfileGPU, and Unreal Insights to detect bottlenecks.

That helped me understand the core concepts, but I’d really love to hear from more experienced developers.

What are some optimization tips and best practices that you consciously apply when building your own UE5 games?

Please explain in a way that’s easy to understand for a beginner like me. I’d really appreciate your help!

Thank you :folded_hands:

2

Hi, from my experience so far, most problematic for GPU performance are:

(-) Many shadow casting lights or shadows casted by meshes that don’t need it (e.g. grass casting high quality shadows). Unreal has different shadow techniques for different usecases (e.g. for small things like grass you could use contact shadows). For larger scale shadows the new method is virtual shadow maps (is more performance heavy though), the old methods would be cascade shadow maps (does not work performant for high poly meshes) and/or distance field shadows and capsule shadows. And now they also have megalights for handling lots of shadow casting lights, never tried that though but that may be the way to go in a couple of engine versions when it gets more stable.

(-) Lots of overdraw and transparency (dense foliage)

And what I did not know about in the beginning but what also needs to be handled:

(-) Large texture resolution. Previously I thought that larger textures only cost VRAM but not performance, but they seem to also cost quite a lot performance. From your second image it looks like you are using very high res textures, try to keep them as low as possible (e.g. 8192 textures for a small plant would likely look the exact same as a 512 texture). You can set a maximum texture resolution, use mip bias and also make use of texture groups.

(-) Distance culling and mesh merging. Occlusion culling costs quite a lot of performance, so you can’t put in lots of meshes without handling culling. If you don’t use nanite, then you can use CullDistanceVolumes. If you use nanite, then you would need to implement your own distance culling system (maybe world partition also works). And in cases where you can’t use distance culling (e.g. seeing the exterior of a house from a distance, there you can distance cull the interior but not the exterior), you would need to use some kind of hlod system where you merge meshes and replace them with a simplified version. Unreal engine has an hlod system for that build in (I couldn’t get it to work properly when I tried to use it a while back, so I ended up manually merging the meshes via Tools → MergeActors and creating a custom swapping logic). Same for particle systems, those also keep costing performance even if they are not visible on the other end of the map. And lights have a max draw distance, so you can cull those by that.

Generally it would also be helpful to design the level with distance culling in mind, so limiting view distances.

And you can also use RenderDoc to get an in depth view of GPU performance cost, I found it very helpful for learning what costs performance.

Those are the things I found problematic so far and how I handled them, there may be other options now.