Performance problems in UE5 are rarely caused by one catastrophic mistake. They're caused by ten small ones compounding. Each one costs a few milliseconds. Together, they drop you from 60 FPS to 30.

These are the ten most common performance mistakes we've seen in UE5 projects, ranked roughly by how frequently they cause problems.

1. Tick-Heavy Blueprints

The problem: Event Tick fires every frame. Any logic on the Tick event runs 60+ times per second. Developers put collision checks, distance calculations, AI decisions, and UI updates on Tick because it's convenient.

The cost: A single Blueprint with heavy Tick logic might cost 0.1ms. Multiply by 200 actors and that's 20ms — your entire frame budget at 60 FPS.

The fix:

• Use timers instead of Tick. An AI decision that runs every 0.5 seconds costs 120x less than one that runs every frame. Set Timer by Function Name with a reasonable interval.
• Disable Tick when unnecessary. Actors that are off-screen, far from the player, or in an idle state don't need to tick. Call Set Actor Tick Enabled(false) and re-enable when needed.
• Move per-frame logic to C++. If something genuinely needs to run every frame (camera follow, interpolation), C++ Tick is significantly cheaper than Blueprint Tick.
• Use event-driven architecture. Instead of checking "is the player nearby?" every frame, use overlap events on a collision volume.

2. Unoptimized Shadow Maps

The problem: Dynamic shadows are one of the most expensive rendering features. Every shadow-casting light renders the scene from its perspective. A level with 50 point lights casting dynamic shadows is rendering 50 additional scene passes.

The cost: Shadow rendering often consumes 30–50% of the GPU frame time. It's frequently the single largest cost in a scene.

The fix:

• Limit shadow-casting lights. Not every light needs to cast shadows. Ambient fill lights, accent lights, and distant lights can have shadows disabled.
• Use cascaded shadow maps wisely. Reduce cascade count (3 instead of 4) and lower the max shadow distance for the directional light.
• Shadow resolution budget. Lower shadow resolution on lights the player won't closely inspect. Point lights in hallways don't need 2048x2048 shadow maps.
• Static shadows where possible. Lights that don't move and illuminate static geometry can use baked shadows with zero runtime cost.
• Distance-based shadow culling. Disable shadows on lights beyond a certain distance from the player.

3. Too Many Draw Calls

The problem: Each unique mesh-material combination in view generates a draw call. A scene with 5,000 unique actors using different materials can generate thousands of draw calls, overwhelming the CPU.

The cost: Draw call overhead is CPU-bound. Above 2,000–3,000 draw calls (depending on hardware), the CPU can't submit commands to the GPU fast enough.

The fix:

• Use instanced rendering. Identical meshes (trees, rocks, grass) should use Instanced Static Meshes or HISM. The Procedural Placement Tool uses HISM by default for exactly this reason.
• Merge static actors. UE5's Merge Actors tool combines nearby static meshes into single draw calls.
• Use Nanite. Nanite meshes have virtually no draw call cost regardless of instance count. Enable Nanite on all eligible meshes.
• Reduce material variety. Use material instances that share the same parent material. Same parent = same shader = more efficient batching.
• LOD aggressively. Non-Nanite meshes need LODs. The engine can batch lower LODs more efficiently.

4. Overdraw from Translucency

The problem: Translucent materials (glass, particles, foliage with alpha) are rendered in a separate pass without depth testing. Overlapping translucent surfaces are drawn multiple times — each layer costs the full fragment shader.

The cost: A particle system with 500 overlapping sprites can multiply your pixel fill rate by orders of magnitude. Fullscreen fire effects are notorious offenders.

The fix:

• Reduce particle count. Fewer, larger particles look similar but cost far less than many small ones.
• Use opaque masking instead of translucency where possible. Masked materials (alpha test) are drawn in the opaque pass with depth testing — no overdraw.
• Limit translucent surface area. A small glass window is fine. A full-screen fog plane is expensive.
• Sort your render order. Draw nearer translucent objects first so the depth buffer can reject occluded fragments.
• Use Niagara's distance culling. Particle systems far from the camera can reduce particle count or disable entirely.

5. Collision Complexity

The problem: Complex collision meshes — especially meshes using "Use Complex as Simple" — run expensive per-triangle collision tests. When multiple actors overlap or test frequently, collision eats CPU budget.

The cost: Physics queries (traces, overlaps, sweeps) against complex geometry can cost 0.5–2ms each. A Tick event doing a complex line trace every frame for 50 actors is catastrophic.

The fix:

• Use simple collision. Box, sphere, and capsule primitives are orders of magnitude faster than mesh collision.
• Generate convex decomposition for objects that need mesh-like collision but not triangle-perfect accuracy.
• Reduce trace frequency. Don't trace every frame. Trace every 0.1 seconds and cache the result.
• Use collision channels to exclude irrelevant actors from collision tests. A projectile doesn't need to test against decorative foliage.
• Spatial partitioning. The engine's built-in spatial hashing handles this, but you need to ensure your collision settings aren't bypassing it.

6. Unculled Off-Screen Actors

The problem: Actors outside the camera view should be culled (not rendered). But if their bounding boxes are incorrect, excessively large, or if culling is disabled, off-screen actors still consume GPU resources.

The cost: Rendering actors the player can't see is pure waste. In open-world games, this can mean rendering 10x more geometry than visible.

The fix:

• Verify bounding boxes. Use Show > Advanced > Bounds in the viewport. Oversized bounds prevent culling.
• Set culling distances. Use per-actor or per-component cull distance volumes. Small detail actors should cull at 50–100m, not render at 5km.
• Use occlusion culling. UE5's hardware occlusion queries hide actors behind walls and terrain. Ensure it's enabled in project settings.
• Level streaming. Divide your world into sublevels and stream them based on player proximity. Actors in unloaded sublevels cost nothing.

7. Blueprint Nativization Neglect

The problem: Blueprint code runs through the virtual machine, which has overhead per-node. A Blueprint function with 50 nodes costs more than the equivalent C++ code, even if the logic is identical.

The cost: Individual Blueprint functions are rarely problematic. But many Blueprint-heavy projects accumulate thousands of Blueprint nodes running per frame, and the VM overhead adds up.

The fix:

• Profile first. Use stat Blueprint to see which Blueprint functions consume the most time. Optimize the expensive ones, not all of them.
• Move hot paths to C++. Identify the 5% of Blueprint functions that consume 95% of Blueprint CPU time. Convert those to C++ and expose them to Blueprint.
• Use UE5.7's Node to Code. The automatic Blueprint-to-C++ conversion handles straightforward logic and is a quick win for performance-critical functions.
• Reduce node count. Collapse long node chains into custom functions. Use macros for repeated patterns. Fewer nodes = less VM overhead.

8. Texture Streaming Stalls

The problem: UE5 streams textures into memory on demand. If many high-resolution textures need to load simultaneously (entering a new area, turning quickly), the streaming system can't keep up. You see blurry textures that take seconds to sharpen.

The cost: Texture streaming stalls don't reduce FPS directly, but they cause visible quality drops and can trigger I/O bottlenecks that stall other systems.

The fix:

• Use appropriate texture sizes. A 4K texture on a small prop is wasteful. Match texture resolution to the screen space the object occupies.
• Set streaming priority. High-visibility objects (player character, main environment surfaces) should have higher streaming priority than background elements.
• Preload textures for known transitions. Before a level transition or cutscene, preload the textures you know will be needed.
• Limit unique textures. Reuse textures through material instances and tiling. Fewer unique textures = less streaming pressure.

9. Garbage Collection Spikes

The problem: Unreal's garbage collector periodically cleans up unreferenced UObjects. If many objects are created and destroyed rapidly (spawning/destroying actors, creating temporary UObjects), GC runs become long and cause frame hitches.

The cost: GC spikes typically last 1–5ms but can hit 10–20ms in severe cases. They cause irregular hitches rather than consistent low FPS, which feels worse than a steady lower frame rate.

The fix:

• Use object pooling. Instead of spawning and destroying projectiles, spawn a pool at startup and recycle them. Pooled objects aren't garbage collected.
• Reduce UObject allocation. Use structs (FStruct) instead of UObjects where possible. Structs don't participate in garbage collection.
• Tune GC settings. gc.TimeBetweenPurgingPendingKillObjects controls GC frequency. Longer intervals mean less frequent but longer GC passes.
• Cluster GC. Group related objects so they're collected together in a single pass rather than individually.

10. Unoptimized Audio

The problem: Audio is frequently ignored in performance profiling. But spatializing 100+ audio sources with occlusion, attenuation, and reverb calculations consumes measurable CPU time.

The cost: Audio rarely dominates frame time, but in dense scenes with many ambient sound sources, it can consume 1–3ms — enough to push a borderline scene below target.

The fix:

• Set attenuation distances. Sounds beyond audible range should stop updating, not just play silently.
• Limit concurrent sounds. Set a maximum concurrency per sound class. 50 simultaneous footstep sounds are inaudible and expensive.
• Reduce occlusion queries. Audio occlusion uses line traces. Reduce trace frequency for ambient sounds.
• Use sound groups. Group nearby ambient sounds into a single source with random variation instead of many individual sources.

The Profiling Workflow

Don't guess. Profile. The debugging workflow:

1. stat FPS — are you hitting your target?
2. stat unit — is the bottleneck Game (CPU), Draw (CPU render), GPU, or RHIT (render thread)?
3. If Game: stat Blueprint, stat Game, Unreal Insights CPU trace
4. If GPU: GPU Visualizer, stat SceneRendering, stat ShadowRendering
5. If Draw: stat SceneRendering for draw call count, merge meshes and reduce material count
6. Fix the biggest bottleneck first. Don't optimize 0.1ms functions when a 5ms function exists.

Start With the Easy Wins

Fixes #1 (Blueprint Tick), #2 (shadow maps), and #6 (culling distances) can often be applied in an afternoon and recover 5–10ms. Start there before diving into deeper optimization.

For environment-specific performance, the Procedural Placement Tool uses HISM instancing and configurable culling distances by design. If you're placing vegetation and props procedurally, the performance groundwork is handled automatically.

The goal isn't perfect optimization — it's hitting your target frame rate consistently. Profile, fix the biggest bottleneck, profile again, repeat.