Start Building

With combat, audio, and VFX in place, the next step is performance: making sure your FPS runs at a stable frame rate on your target hardware. This lesson covers how to profile in Unreal Engine 5, find bottlenecks, and use LOD and scalability settings so the game scales from low-spec to high-end without redoing content.

You will finish with a clear picture of where time is spent and how to keep frame time under control.

Why optimization matters

Players expect a consistent frame rate (e.g. 60 FPS or 30 FPS cap). Drops during combat or in busy areas feel bad and can affect aim and readability. Profiling tells you where time is spent (CPU, GPU, draw calls, etc.); then you can reduce cost or scale quality so the game stays within budget on your target platform.

Step 1: Profile first

  1. Unreal Profiler (Session Frontend)

    • Open Window → Developer Tools → Session Frontend (or Profile → Session Frontend). Start a Profile session, play in editor or in a packaged build, then stop and inspect.
    • Use the CPU and GPU tabs to see which threads or stages take the most time. Look for spikes that line up with frame hitches when you play.

  2. Stat commands

    • In game, press ~ (tilde) to open the console. Useful commands:
      • stat unit – Frame time breakdown (game thread, draw thread, GPU).
      • stat game – Game thread costs.
      • stat gpu – GPU timing.
      • stat scenerendering – Draw calls, triangles, etc.
    • Walk through your level and trigger combat; note which stats spike when you feel a hitch.

  3. Identify the bottleneck

    • Game thread – Too much logic, tick, or Blueprint per frame. Optimize or spread work.
    • Draw / GPU – Too many draw calls, overdraw, or heavy shaders. Use LOD, occlusion, and scalability.
    • RHI / Present – Driver or resolution-related; try different quality settings or resolution.

Do not guess; use data to decide what to optimize first.

Step 2: LOD (Level of Detail) for meshes

  1. Static meshes

    • For characters, props, and environment meshes, ensure LODs are generated (Editor: LOD Group or Generate LODs). At distance, fewer triangles and simpler materials reduce GPU cost.
    • Set LOD screen size (or distance) so the first LOD switch happens at a reasonable distance; avoid popping in the player’s face.

  2. Skeletal meshes

    • Use LOD for enemy and character meshes so distant characters use fewer bones and triangles.
    • Reduce update rate for far-away characters (e.g. tick animation at 15 Hz instead of 60) if your project supports it.

  3. VFX and Niagara

    • Use LOD in Niagara so particle count or quality drops at distance. Limit active systems (e.g. cap impact effects) so many explosions do not tank the frame rate.

Step 3: Scalability settings

  1. Engine scalability

    • In Project Settings → Engine → General Settings (or Scalability), you have Low / Medium / High / Epic (and sometimes Cinematic) for View Distance, Anti-Aliasing, Post Process, Shadows, Textures, Effects, and Foliage.
    • Players (or you) can choose a preset (e.g. “Low”) so the game runs on weaker hardware. Ensure your game is playable and readable at Low; use Epic for high-end.

  2. Per-feature toggles

    • Consider toggles for shadows, reflections, volumetric fog, or motion blur so users can disable the heaviest options.
    • Drive these from Scalability or from a custom settings screen that sets the same cvars.

  3. Resolution and frame cap

    • Allow resolution scale (e.g. 50%–100%) and a frame rate cap (30 / 60 / 120 / unlimited) so low-end machines can reduce resolution or cap FPS for stability.

Step 4: Content-level wins

  • Occlusion – Use Occlusion Culling or Precomputed Visibility so off-screen or occluded objects are not drawn.
  • Culling distance – Use Cull Distance volumes or Cull Distance on meshes so very far objects are not rendered.
  • Light count – Limit overlapping lights; use static or baked lighting where possible and dynamic lights sparingly.
  • Texture size – Use appropriate texture resolution; avoid 4K everywhere. Use streaming and mip maps.
  • Blueprints and tick – Reduce Event Tick usage; use timers or events instead. Avoid heavy logic every frame on many actors.

Step 5: Packaging and testing

  1. Package for target platform

    • Package Project (e.g. Windows) and test the shipping build. Editor performance is not the same as packaged; always verify on a real build.

  2. Test on min-spec hardware

    • Run on the lowest GPU/CPU you intend to support. Tune scalability and LOD so that configuration stays within your frame budget (e.g. 30 FPS or 60 FPS).

  3. Automated perf tests (optional)

    • Use Unreal’s automation or external tools to capture frame time over a fixed path so regressions show up before release.

Common mistakes

  • Optimizing before profiling – You may optimize the wrong thing. Use Session Frontend and stat commands first.
  • No LODs – Everything at full detail at all distances is expensive. Always use LOD for meshes and consider it for VFX.
  • Ignoring Low preset – If “Low” is unplayable or ugly, low-spec users will have a bad experience. Tune for it.
  • Only testing in editor – Editor has overhead. Profile and test packaged builds.

Troubleshooting

Frame spikes when many enemies spawn

  • Profile with stat game and stat gpu. Often game thread (AI, Blueprint) or draw calls. Add LOD, reduce tick cost, or limit simultaneous actors.

GPU-bound even on Low

  • Check draw calls (stat scenerendering), overdraw, and shader cost. Reduce draw calls (merge meshes, LOD), simplify materials, or lower resolution scale.

Stuttering when loading

  • Use async loading and streaming; avoid blocking the game thread with large loads. Use level streaming so only visible regions are in memory.

Mini challenge – optimization checklist

Before moving to multiplayer and polish:

  • [ ] Run Session Frontend or stat unit and note the main bottleneck (game vs GPU).
  • [ ] Ensure key meshes have LODs and that LOD transition distance is reasonable.
  • [ ] Test Low scalability preset and fix anything broken or unreadable.
  • [ ] Package and run a shipping build; confirm frame time is stable on your target hardware.

Recap and next steps

You used profiling to find bottlenecks, LOD to reduce mesh and VFX cost at distance, and scalability so the game runs on a range of hardware. In the next phase you will add multiplayer networking and replication, then move on to testing, publishing, and launch.

For more on profiling, see the Unreal Engine profiling documentation. For VFX performance, revisit Lesson 11: Visual Effects & Particle Systems.

Found this useful? Bookmark it and share your before/after stats with your team.