Performance & Profiling

A frame is CPU-bound when the processor's work (logic, draw-call setup) takes longest, and GPU-bound when the graphics card's work (shading, pixels) takes longest. The slower side caps frame rate, so profile first.

An LOD is a simpler version of a mesh with fewer triangles, swapped in as the object moves farther away. Distant objects look nearly the same with less geometry, so LODs cut rendering cost without visible quality loss.

Tick is the per-frame update called on every enabled Actor and Component. The engine runs your logic once each frame, so many ticking objects multiply work. Disable Tick when unneeded or use timers.

Start with stat unit to see frame, game, draw, and GPU times, then drill in with stat game, stat gpu, or stat scenerendering. For deep traces use Unreal Insights, which captures CPU, GPU, and memory timelines.

Run stat unit and compare: if Game or Draw is the largest number you are CPU-bound; if GPU dominates you are GPU-bound. Frame time roughly equals the max of the threads, since CPU and GPU run in parallel.

Use stat game to see aggregate tick cost, then capture an Unreal Insights trace and inspect the game-thread timeline for Tick events. TickGroup rows and per-actor timing pinpoint which classes dominate the frame.

Instancing draws many copies of one mesh in a single draw call. An ISM (Instanced Static Mesh) holds those instances; a HISM adds per-instance culling and automatic LOD selection, making it suited to large outdoor scatter.

An LOD is a lower-detail version of one mesh swapped in by distance to cut triangles. HLOD merges many distant actors into a single combined proxy mesh, reducing both triangle count and draw calls for whole regions.

Pre-spawn a fixed set of projectile actors once, keep them deactivated, and hand out a free one on fire instead of calling SpawnActor. Return spent projectiles to the pool by deactivating them rather than calling Destroy.

Occlusion culling skips rendering objects hidden behind other geometry. Unreal uses hardware occlusion queries and a Hierarchical Z-Buffer test each frame, so occluded meshes issue no draw calls even though they are inside the frustum.

Avoid per-frame work in Event Tick, prefer events and timers, and enable Blueprint Nativization or move hot logic to C++. Cache references instead of repeated Get and Cast calls, and trim heavy nodes from loops.

Use simple collision primitives instead of per-triangle complex collision, disable collision on meshes that never need it, and tune collision channels and object types so queries test only relevant objects. Avoid overlapping query volumes.

Use object pooling: pre-spawn actors once and recycle them by toggling visibility, collision, and Tick instead of calling SpawnActor/Destroy. This avoids per-spawn allocation, component registration, and garbage-collection pressure.

Merge static meshes, use Instanced Static Meshes for repeated assets, and share materials so the renderer can batch. Fewer unique mesh-material pairs and aggressive culling cut the number of draw calls the render thread issues.

Disable Tick by default (bCanEverTick = false) and enable it only where needed. Replace per-frame polling with timers, events, or delegates, and raise TickInterval so logic that does not need every frame runs less often.

Dynamic (movable) lights re-render the scene into shadow depth maps every frame, multiplying geometry passes and draw calls. Static and stationary lights bake shadows offline, so they are far cheaper at runtime.

Drive the bar from a delegate: the health component broadcasts an OnHealthChanged event, and the widget updates its ProgressBar only in that handler. No Event Tick and no per-frame property binding are needed.

Replace per-frame property bindings with event-driven updates, set static widgets to SelfHitTestInvisible, mark unchanging subtrees as Is Volatile = false so Slate caches them, and use Invalidation Box to skip redrawing stable UI.

Use stat memory and Memreport for a snapshot, the Memory Insights track in Unreal Insights for live allocation traces, and obj list to break down UObject counts. Profile a packaged build for realistic figures.

Enable URO (Update Rate Optimization) so distant skeletal meshes evaluate less often, use animation LODs, and move heavy logic into Fast Path or threaded Animation Blueprint updates. Cull or freeze meshes that are off-screen.

Capture an Unreal Insights trace and find the spiking frame, then read which track widened — game thread, GPU, GC, or asset streaming. The spike's call stack names the culprit; stat unit only confirms a hitch happened. Here the game thread is blocked by CollectGarbage for most of the frame on an even multi-second cadence — a GC pause, not GPU or streaming work.

Profile before and after with stat unit to see which thread regressed, then capture an Unreal Insights trace to locate the new system's cost. Bisect: disable the system to confirm it is the cause before optimizing. Here game time tripled while draw and GPU held — a game-thread regression; the trace shows a synchronous pathfind in every crowd agent's per-frame Tick, multiplied across all agents.