How to Reduce Draw Calls and Improve FPS in Unreal Engine

Are you struggling with performance issues in your Unreal Engine project? Finding your game stuttering or running at low framerates? The culprit might be excessive draw calls. As a game developer myself, I've been there, and I'm going to share some battle-tested techniques that have saved many of my projects.

What Are Draw Calls and Why Do They Matter?
Simply put, a draw call happens every time your game tells the GPU to render something on screen. Each mesh, particle effect, or UI element potentially triggers a separate draw call. The more draw calls your game makes, the harder your CPU has to work to communicate with the GPU, often resulting in that dreaded framerate drop.

10 Proven Strategies to Reduce Draw Calls
1. Use Instanced Static Meshes
When you need to place multiple copies of the same object in your scene, Instanced Static Meshes (ISMs) are your best friend. Instead of creating separate draw calls for each copy, ISMs allow the engine to render multiple instances in a single draw call.

Just select your static mesh, create an Instanced Static Mesh Component, and you can add hundreds of instances with minimal performance impact.

2. Implement Level of Detail (LOD)
LOD systems automatically reduce the complexity of objects as they move farther from the camera. This not only reduces polygon count but can also merge draw calls for distant objects.

1. Select your Static Mesh in the Content Browser
2. Open the Static Mesh Editor
3. In the Details panel, look for the LOD section
4. Click "Add LOD" and adjust the settings for each distance threshold

3. Master the Art of Material Instancing
Each unique material can potentially create a separate draw call. Instead of creating dozens of materials from scratch, use Material Instances:

1. Create a comprehensive parent material with parameters
2. Create Material Instances that share the same shader but vary in texture or color
3. Use Material Parameter Collections for global changes

4. Merge Static Meshes
For complex environmental elements that don't need individual manipulation, consider merging them:

1. Select multiple Static Meshes in your level
2. Right-click and select "Merge Actors"
3. Choose appropriate settings for materials and lightmaps
4. Confirm the merge This reduces multiple draw calls into a single one.

5. Optimize Your Lighting
Dynamic lights can significantly increase draw calls. Consider these alternatives:

1. Use baked lighting where possible
2. Limit the number of shadow-casting lights
3. Set appropriate attenuation distances
4. Use Light Functions rather than multiple lights for complex effects

6. Implement Hierarchical Level of Detail (HLOD)
For large open worlds, HLOD is a game-changer:

1. Go to Window > Hierarchical LOD Outliner
2. Set up your HLOD settings
3. Generate clusters

HLOD combines multiple actors into a single mesh when viewed from a distance, dramatically reducing draw calls.

1. Utilize Occlusion Culling
   Why render what players can't see? Occlusion culling prevents the rendering of objects that are hidden behind other objects:

2. Enable "Generate Mesh Distance Fields" in Project Settings

3. Set up proper bounds for your actors

4. Use "Cull Distance Volumes" in large levels

8. Optimize Your Particle Systems
Particles can be draw call nightmares if not handled properly:

1. Use GPU particles when possible
2. Reduce overdraw by using appropriate sprites
3. Limit the number of active emitters
4. Use LODs for particle systems

9. Be Strategic with Blueprints
While Blueprints are fantastic for rapid development, they can impact performance:

1. Convert performance-critical Blueprints to C++
2. Use the Construction Script to set up static elements
3. Avoid excessive "Tick" events

4. Use Blueprint nativization for shipping builds
   10. Leverage Unreal's Profiling Tools
   You can't optimize what you don't measure:

5. Use the "stat unit" command to monitor frame times

6. Check "stat game" for game thread performance

7. Analyze "stat gpu" for rendering bottlenecks

8. Use "stat drawcalls" to specifically monitor draw call counts

Real-World Example: From 60 to 120 FPS
On a recent project, I was struggling with a dense forest scene that was barely hitting 60 FPS on mid-range hardware. After applying these techniques:

1. I replaced 5,000 individual trees with ISMs
2. Implemented a 3-level LOD system for vegetation
3. Merged static rocks and ground debris
4. Set up HLOD for distant viewing
5. Optimized materials to use instances from just 12 parent materials The result? A solid 120 FPS without any visual quality compromise.

Conclusion
Optimizing draw calls isn't just about better performance—it's about creating a smoother, more immersive experience for your players. The techniques above have helped countless developers create beautiful, complex worlds that run smoothly even on modest hardware.

Remember, optimization is an ongoing process, not a one-time task. Make it a habit to check your draw call count regularly as you develop, and address issues before they become deeply embedded in your project.

Do you have any specific draw call optimization techniques that have worked well for your Unreal projects? I'd love to hear about them in the comments!