Blog |

My Unreal Engine Profiling & Tracing Launch Arguments

Tue, 02 Jun 2026 00:00:00 +0000

A reference list of executable launch parameters for profiling Unreal Engine with Unreal Insights—covering CPU traces, Garbage Collection logging, Slate UI performance, context switches, File I/O, and world streaming.

The Base Settings

Most of these configurations share a common set of baseline parameters designed to stabilize performance and enable standard profiling markers:

-statnamedevents
- Translates traditional engine stat counters (like stat game or custom cycle counters) into named event markers that appear in the Unreal Insights timeline.
-NoVerifyGC
- Disables heavy garbage collection validation checks. This avoids massive frame spikes that would otherwise pollute profiling captures.
-DPCvars="gc.VerifyAssumptionsOnFullPurge=0"
- Directly overrides the Device Profile Config (DPC) variable to disable verifying GC assumptions during a full purge, further speeding up GC behavior during profiling.

1. CPU Tracing

For basic CPU profiling, use this layout to capture the default engine events along with detailed task graph scheduling.

-trace=default,task -statnamedevents -NoVerifyGC -DPCvars="gc.VerifyAssumptionsOnFullPurge=0"

-trace=default,task
- Enables the standard performance counters (default) and tracks task execution across the Engine’s Thread Pool (task).

2. CPU Tracing with In-Game Graphs

If you need visual feedback on performance spikes in real-time while recording a trace, this variation displays the unit graph and FPS counters on screen.

-trace=default,task -statnamedevents -NoVerifyGC -DPCvars="gc.VerifyAssumptionsOnFullPurge=0" -ExecCmds="stat unitgraph, stat fps"

-ExecCmds="stat unitgraph, stat fps"
- Executes these console commands immediately on launch so that the scrolling timeline and framerate graphs are visible as you test.

3. Garbage Collection Profiling

Garbage collection (GC) can cause sudden, periodic frame drops. Use these arguments to output detailed GC logging alongside your performance trace to correlate hitches with GC sweeps.

-trace=default,task -statnamedevents -NoVerifyGC -DPCvars="gc.VerifyAssumptionsOnFullPurge=0" -ExecCmds="stat unitgraph, stat fps" -LogCmds="LogGarbage Verbose"

-LogCmds="LogGarbage Verbose"
- Sets the garbage collection logger to Verbose level, printing detailed reports of every object collected, sweep duration, and purge cycle to the log.

4. Profiling Without Ensures

An ensure or ensureAlways statement that fails will capture a callstack, which can stall the game thread for several milliseconds. To make sure developer-facing ensures don’t artificially skew your profiling data, use this configuration to ignore them.

-trace=default,task -statnamedevents -NoVerifyGC -DPCvars="gc.VerifyAssumptionsOnFullPurge=0" -ExecCmds="stat unitgraph, stat fps" -HandleEnsurePercent=0

-HandleEnsurePercent=0
- Instructs the engine to skip capturing callstacks or executing error-handling routines for ensures, treating them as simple pass-through statements.

5. Combined CPU, GC, & Ensure-disabled Profiling

For a comprehensive profiling configuration that tracks CPU and task graphs, outputs verbose Garbage Collection logging, displays in-game statistics, disables heavy GC verification, and ignores ensures, combine all parameters:

-trace=default,task,counters -statnamedevents -NoVerifyGC -DPCvars="gc.VerifyAssumptionsOnFullPurge=0" -ExecCmds="stat unitgraph, stat fps" -LogCmds="LogGarbage verbose" -HandleEnsurePercent=0

6. Context Switch & Thread Scheduling

If you are investigating thread contention, core scheduling, or suspect that threads are blocking each other, you need to capture thread context switches at the OS level.

-trace=taskgraph,contextswitch -statnamedevents -NoVerifyGC -DPCvars="gc.VerifyAssumptionsOnFullPurge=0"

-trace=taskgraph,contextswitch
- Captures high-frequency scheduling events, letting you visualize when and why threads are being swapped out on CPU cores.
Context Switch Administrator Requirement:
- The channel lets you see when a thread is not getting CPU cycles. To capture context switches on Windows you must run the UE application as administrator. Otherwise, leave the contextswitch channel disabled to prevent log spam.

7. File I/O & Loading Times

When profiling level transition hiccups, asset loading, or initial startup bottlenecks, use these trace channels to monitor disk activity and serialization.

-trace=cpu,file,assetloadtime,loadtimes,iostore,contextswitch -statnamedevents -NoVerifyGC -DPCvars="gc.VerifyAssumptionsOnFullPurge=0"

-trace=cpu,file,assetloadtime,loadtimes,iostore,contextswitch
- Enables detailed tracking of:
  - cpu: Main CPU thread timelines.
  - file: Standard file read/write calls.
  - assetloadtime: High-level asset loading metrics.
  - loadtimes: Detailed package serialization and loading stages.
  - iostore: Zen/I/O Store requests for packaged builds.
  - contextswitch: Context switching to see load-thread wakeups.

8. Slate UI Profiling

To profile UI performance and analyze widget tick, layout, and paint evaluation timelines in Unreal Insights, pass the slate trace channel to the -trace argument.

-trace=default,task,slate -statnamedevents -NoVerifyGC -DPCvars="gc.VerifyAssumptionsOnFullPurge=0"

slate Trace Channel (-trace=...,slate)
- Enables the slate trace channel to record UI widget timing, layout, tick, and paint event timelines in Unreal Insights.
WITH_VERY_VERBOSE_SLATE_STATS Macro
- To record complete, granular per-widget telemetry and detailed Slate hierarchy breakdowns in Insights, compile the engine or project with the WITH_VERY_VERBOSE_SLATE_STATS preprocessor macro enabled (#define WITH_VERY_VERBOSE_SLATE_STATS 1).

9. World Streaming & World Partition Profiling

When diagnosing streaming hitches, level streaming stalls, or World Partition cell loading/unloading bottlenecks, you need simultaneous visibility across disk I/O, asset serialization, async worker tasks, physics lock contention, and thread scheduling.

-trace=default,counter,stats,file,loadtime,assetloadtime,task,chaoslocks,contextswitch -statnamedevents -NoVerifyGC -DPCvars="gc.VerifyAssumptionsOnFullPurge=0"

-trace=default,counter,stats,file,loadtime,assetloadtime,task,chaoslocks,contextswitch
- Enables telemetry across the core world streaming pipelines:
  - default: Standard baseline engine timeline events (CPU frames, bookmarks).
  - counter: Tracks numeric metrics and telemetry values over time (e.g., streaming pool budgets, resident cell counts).
  - stats: Emits STAT system stats and cycle counters into the trace.
  - file: Low-level file system activity (file opens, async reads, seeks).
  - loadtime: Package loading, serialization stages, and linker phases.
  - assetloadtime: High-level asset instantiation and registration timing.
  - task: Task Graph and Task System execution across worker threads.
  - chaoslocks: Chaos physics lock contention, scene sync points, and mutex wait times when generating collision for newly streamed actors/cells.
  - contextswitch: OS-level thread scheduling to spot core migration, thread preemption, or streaming worker starvation.
-statnamedevents
- Converts cycle counters and stat scopes into named event markers on the Unreal Insights timeline, ensuring you can clearly correlate custom streaming scopes and subsystem events alongside disk and task activity.
Context Switch Administrator Requirement:
- The channel lets you see when a thread is not getting CPU cycles. To capture context switches on Windows you must run the UE application as administrator. Otherwise, leave the contextswitch channel disabled to prevent log spam.

My List of Useful Console Commands

Mon, 25 May 2026 00:00:00 +0000

A reference sheet of Unreal Engine console commands I frequently use for debugging, profiling, rendering, and runtime inspection, organized by category.

Misc / Execution

Commands for general utility, time manipulation, and calling functions.

Slomo <multiplier>
- Changes the game speed (e.g., Slomo 0.5 for slow motion, Slomo 1 for normal speed, Slomo 2 for fast forward).
t.MaxFps <value>
- Caps the maximum framerate (e.g., t.MaxFps 60 or t.MaxFps 0 to uncap).
dumpticks
- Dumps a list of all currently ticking actors and components to the log, which is extremely useful for identifying tick-heavy performance bottlenecks.
tick.AllowBatchedTicks <0 or 1>
- Enables or disables native actor and component tick batching (introduced in UE 5.5). Groups tick execution to significantly reduce TaskGraph dispatch overhead and improve CPU cache coherency when dealing with high counts of ticking objects.
ToggleDebugCamera
- Toggles the debug camera, allowing you to fly around freely and inspect actor bounds and world layouts.
ce <ufunction name which has exec>
- Calls an exec function by name on the local Player Controller or cheat manager.
ke <instance name or *> <ufunction name>
- Triggers a function on all or specific instances of an object/actor in the level (e.g., ke * ActivateTrap).
teleport
- Teleports the player character to whatever surface the camera is currently looking at.
BugIt
- Creates a screenshot and metadata file containing camera coordinates, rotation, and current level, useful for reporting bugs with exact placement context.
ButItGo
- (Often written as BugItGo / BugIt Go) Teleports to the coordinates specified by a BugIt screenshot/log entry.
log <category> <verbosity>
- Dynamically sets log verbosity for a specific category (e.g., log LogTemp Verbose).

Stats & Profiling

Use these commands to get real-time telemetry on system performance.

stat none
- Clears all active stat displays from the screen.
stat unit
- Shows the time spent on the main Game thread, Render thread, GPU, and RHI thread, along with overall frame time.
stat UnitMax
- Displays the maximum (peak) values for frame metrics (like Game, Draw, GPU, RHI) over a recent window of frames, helping debug spikes and performance hitches.
stat detailed
- Displays a detailed combination of performance metrics, including FPS, unit times, and peak frame time stats.
stat unitGraph
- Toggles a scrolling graphical representation of the stat unit times.
stat game
- Displays general game thread statistics, including tick times, blueprint times, and gameplay system overhead.
stat Engine
- General engine statistics. Useful for triangle count of static and skeletal meshes.
stat gpu
- Displays a detailed breakdown of GPU render time across different rendering passes (shadows, base pass, lighting, post-processing).
stat RHI
- Displays low-level rendering statistics, such as memory usage, render targets, textures, and GPU (pair with rhi.ResourceMemory or rhi.DumpMemory for dumped allocation breakdowns).
stat SceneRendering
- Displays detailed rendering statistics, including draw calls, decals, lights, ray tracing, and CPU rendering costs.
stat DrawCount
- Detailed draw call data.
stat RenderThreadCommands
- Displays real-time statistics and counter metrics for commands enqueued and executed on the Render Thread (such as commands dispatched via ENQUEUE_RENDER_COMMAND). Essential for diagnosing render thread command queue saturation and high command submission overhead from the game thread.
stat initviews
- Displays information about visibility culling performance (how many primitives were processed, occluded, or visible).
stat Foliage
- Displays the number of instanced static meshes and their triangle count (not just foliage).
stat Landscape
- Displays performance metrics, draw calls, render stats, and component patch count for landscape and terrain.
stat Niagara
- Detailed view of Niagara systems costs. (We’ll cover this in a future post)
stat NiagaraSystemCounts
- Shows the number of Niagara particle systems active, ticking, and rendering in the scene.
stat memory
- Displays current memory usage breakdowns across different allocation categories.
stat navigation
- Shows navigation mesh statistics, including build times and memory footprint.
stat net
- Displays real-time multiplayer network statistics including ping, incoming/outgoing bandwidth, packet counts, and loss rate.
stat Slate
- Displays real-time performance telemetry for the Slate UI framework, including widget tick, layout, and paint evaluation times.
stat streaming
- Displays real-time texture and asset streaming telemetry, including memory pool usage, pool budget, wanted vs. resident mips, and pending streaming requests. (Also see stat StreamingDetails for a deeper breakdown).

Show Commands

Toggle rendering flags to visualize colliders and debugging layouts.

show DebugAnimation
- Visualizes animation debug data, skeletal structures, and bone transforms.
show Collision
- Toggles the visibility of collision geometry (colliders, triggers, simple physics shapes) in the viewport.
show Splines
- Toggles the visibility of spline components and curves in the viewport.
showflags.bounds <0 or 1> (or show Bounds)
- Toggles the visibility of actor/primitive bounding boxes in the viewport, essential for diagnosing frustum culling and inflated bounds issues.
show Fog (or showflags.fog <0 or 1>)
- Toggles the visibility and rendering of fog (including Exponential Height Fog and atmospheric fog) in the viewport, useful for isolating lighting and inspecting geometry without fog obstruction.

Slate & UI

Slate.EnableGlobalInvalidation <0 or 1>
- Enables or disables Slate’s global invalidation system, caching unchanged UI widgets to significantly reduce CPU thread overhead.
Slate.AllowToolTips <0 or 1>
- Enables or disables Slate tooltips globally across the editor and UI elements. Commonly set to 0 (or added to ConsoleVariables.ini as Slate.AllowToolTips=0) to prevent intrusive tooltips and hover hitches during debugging and profiling.
slate.EnableTooltips <0 or 1>
- Enables or disables Slate tooltips globally across the editor and UI elements (used interchangeably with or superseding Slate.AllowToolTips in modern engine versions).
SlateDebugger.Invalidate.Start
- Highlights widgets when they invalidate. Good for a gut check, though often too loud to be useful. (Can be stopped with SlateDebugger.Invalidate.Stop).
SlateDebugger.bCaptureRootInvalidationCallstacks <0 or 1>
- Pushes invalidation callstack to Slate Insights trace. Mouse over widget in Frame View to inspect.
SlateDebugger.Break
- Breaks on widget events:
  - OnWidgetBeginPaint
  - OnWidgetEndPaint
  - OnWidgetInvalidation (Widget ID, Reason).

Ensures & Asserts

core.ResetEnsureState
- Resets the ensure state counter, allowing the engine to fire ensures that have already been triggered and suppressed.
core.Ensure
- Provides configuration options for how ensures behave (e.g., whether they should break into the debugger, write to the log, or crash).

Garbage Collection

obj gc
- Forces an immediate garbage collection pass.
gc.CollectGarbageEveryFrame <0 or 1>
- Forces the engine to collect garbage on every single frame. Useful for detecting memory leaks and validating reference integrity under stress, but will severely impact framerate.

Memory Inspection

list obj class=<name> -resourcesizesort -countsort
- Lists all instantiated objects of a specific class. Sorting flags prioritize resource size (-resourcesizesort) or count (-countsort), making it highly effective for finding memory hogs.
obj refs shortest name=<object_path>
- Finds and displays the shortest path of references from a root object to the specified object. Extremely useful for identifying memory leaks and figuring out why a specific asset or object remains loaded in memory.
obj.tracesnapshot
- Captures a snapshot of all active UObjects into the trace. Useful for comparing UObject memory states at different points in time during a profiling session (requires the object trace channel to be enabled).
rhi.ResourceMemory
- Dumps a comprehensive breakdown of low-level GPU/RHI resource allocations (vertex buffers, index buffers, textures, render targets, and structured buffers) to the log, making it indispensable for tracking down VRAM usage at the hardware abstraction level.
rhi.DumpMemory
- Dumps overall RHI memory tracking and GPU memory statistics to the log, providing a high-level summary of allocated video memory, pool sizes, and driver-level overhead.

Rendering & Quality

r.DistanceFieldShadowing <0 or 1>
- Toggles Ray Traced Distance Field Shadows.
r.MeshDrawCommands.DynamicInstancing <0 or 1>
- Enables or disables dynamic auto-instancing for mesh draw commands on the GPU Scene pipeline (default is 1). Turning this off (0) disables runtime instancing, which is useful for checking draw call batching efficiency or debugging stale cached mesh draw commands and visual artifacts on duplicate meshes.
r.RayTracing.NormalBias <value>
- Offsets the origin of secondary ray-traced rays outward along the surface normal (default is 0.1). Increasing this (e.g., r.RayTracing.NormalBias 5.0) prevents ray self-intersection, shadow acne, and dark noisy splotches on complex geometry or Nanite foliage, though setting it too high can cause light leaking or detached shadows (“peter-panning”).
r.DetailMode <0, 1, 2>
- Controls the detail mode of components (0 = Low, 1 = Medium, 2 = High). Useful for profiling how different detail tiers impact visual performance.
r.LightMaxDrawDistanceScale <multiplier>
- Applies a global multiplier to the Max Draw Distance and fade range of all lights (e.g., r.LightMaxDrawDistanceScale 1 for default, < 1 to cull distant lights sooner for performance, > 1 to extend draw distances, or 0 to disable distance culling).
r.ScreenPercentage <value>
- Sets the render resolution percentage of the viewport (e.g., r.ScreenPercentage 50 for half-res upscaled, r.ScreenPercentage 100 for native).
r.VSync <0 or 1>
- Toggles VSync on or off.

Texture Streaming

r.Streaming.DropMips <0, 1, 2>
- Controls whether the texture streamer drops mips to save texture memory (0 = don’t drop, 1 = drop mips under memory pressure, 2 = force drop mips even if memory is not low). Can also be supplied at launch via -DPCvars="r.Streaming.DropMips=1".
r.TextureStreaming <0 or 1>
- Globally enables or disables the texture streaming system.
r.Streaming.PoolSize <value in MB>
- Overrides the texture streaming pool size in megabytes (e.g., r.Streaming.PoolSize 3000, or 0 for unlimited).

Nanite

r.nanite.maxpixelsperedge <value>
- Controls the level of detail (LOD) metric for Nanite meshes. Higher numbers reduce detail by allowing larger polygons per edge, which improves rendering performance.
r.nanite.showstats <0 or 1>
- Displays real-time on-screen statistics and telemetry for Nanite, including rendered triangle counts, cluster counts, instances, and streaming/culling performance metrics. (Note: Requires r.ShaderPrint.Enable 1 to render the debug text on screen.)
r.ShaderPrint.Enable <0 or 1>
- Enables or disables the GPU Shader Print debugging system, allowing compute and graphics shaders to draw debug text directly in the viewport (required for commands like r.nanite.showstats 1 to display).
r.Nanite.Streaming.StreamingPoolSize <value in MB>
- Sets the dedicated memory pool size in megabytes for Nanite geometry streaming (e.g., r.Nanite.Streaming.StreamingPoolSize 1024). Increasing this helps prevent geometry popping, thrashing, and streaming stalls in complex scenes with dense Nanite assets.
showflag.nanitemeshes <0 or 1>
- Toggles whether Nanite geometry is rendered as Nanite or falls back to traditional fallback meshes.
r.Nanite.Visualize.PixelProgrammableVisMode
- Visualizes pixel-programmable operations (like masked materials and world position offset) on Nanite meshes, which can cause significant performance overhead.

Materials

r.showmaterialdrawevents <0 or 1>
- Toggles the display of material draw events in profiling tools, making it easier to see which specific materials are costing the most draw calls.

Megalights

r.MegaLights.DownsampleMode
- Configures downsampling modes for Megalights to balance lighting quality against GPU rendering cost.

Lumen

r.Lumen.DiffuseIndirect.Allow <0 or 1>
- Toggles diffuse indirect lighting evaluation for Lumen. Disabling this (0) stops indirect bounces and emissive materials from projecting light onto nearby surfaces, which is often one of the heaviest GPU costs in Lumen scenes.
r.Lumen.ScreenProbeGather <0 or 1>
- Master toggle for screen probe gather, which computes diffuse global illumination by integrating incoming radiance across screen-space probes.
r.Lumen.ScreenProbeGather.StochasticInterpolation <0 or 1>
- Enables stochastic sampling when interpolating between screen probes (e.g., r.Lumen.ScreenProbeGather.StochasticInterpolation 1), improving GI detail and sharpness in probe reconstruction with reduced overhead.
r.Lumen.ScreenProbeGather.SpatialFilterNumPasses <value>
- Controls the number of spatial filter passes applied to screen probe gather results (e.g., r.Lumen.ScreenProbeGather.SpatialFilterNumPasses 2), balancing high-frequency noise suppression against over-blurring.
r.Lumen.ScreenProbeGather.DownsampleFactor <value>
- Sets the downsample factor for screen probe gather (e.g., 8 or 16). Higher values reduce probe density and drastically cut GPU frame times at the expense of lower GI resolution.
r.Lumen.ScreenProbeGather.ScreenTraces <0 or 1>
- Enables or disables screen-space ray tracing before falling back to mesh distance fields or surface cache cards. Disabling skips tracing against the screen depth buffer.
r.Lumen.ScreenProbeGather.ScreenTraces.HZBTraversal.MaxIterations <value>
- Sets the maximum number of Hierarchical Z-Buffer (HZB) traversal iterations during screen-trace ray marching. Lowering this caps ray step cost in complex scenes.
r.Lumen.ScreenProbeGather.Temporal <0 or 1>
- Toggles temporal accumulation and filtering for screen probe gathering.
r.Lumen.ScreenProbeGather.Temporal.MaxFramesAccumulated <value>
- Limits the maximum number of history frames used for temporal accumulation in screen probe gathering. Lower values reduce ghosting artifacts behind moving objects, while higher values provide cleaner noise-free convergence.
r.Lumen.ScreenProbeGather.Temporal.DistanceThreshold <value>
- Sets the relative distance/depth threshold for discarding historical probe data during temporal filtering (e.g., r.Lumen.ScreenProbeGather.Temporal.DistanceThreshold 1.65). Tuning this helps eliminate ghosting and dark trailing artifacts behind moving geometry without introducing excessive GI noise or foliage flickering.
r.Lumen.ScreenProbeGather.MaxRayIntensity <value>
- Clamps the maximum radiance/intensity of individual rays gathered during screen probe integration (e.g., r.Lumen.ScreenProbeGather.MaxRayIntensity 10). Tames bright “firefly” noise, specular hot spots, and harsh light bleed from intensely bright emissive materials.
r.Lumen.Reflections.DownsampleFactor <value>
- Sets the internal resolution downsample factor for Lumen reflections (e.g., 1 for full resolution, 2 or 1.85 for reduced internal resolution). Higher values significantly cut GPU rendering cost on reflective surfaces with minimal sharpness loss after temporal upscaling.
r.Lumen.Reflections.HierarchicalScreenTraces.MaxIterations <value>
- Sets the maximum ray-marching traversal iterations for Hierarchical Screen Traces (HZB) in Lumen reflections (e.g., r.Lumen.Reflections.HierarchicalScreenTraces.MaxIterations 4). Lowering this caps the trace cost of screen-space reflection passes in complex scenes.
r.Lumen.ScreenProbeGather.RadianceCache.GridResolution <value>
- Sets the grid probe resolution for the world-space Radiance Cache used to accelerate probe traces, balancing spatial fidelity against cache memory and update overhead.
r.Lumen.ScreenProbeGather.VisualizeTraces <0 or 1>
- Visualizes screen probe gather ray traces directly in the viewport for debugging trace distribution and surface hit coverage.
r.Lumen.DiffuseIndirect.CardTraceEndDistanceFromCamera <value>
- Maximum camera distance in unreal units where Lumen traces against surface cache cards. Geometry beyond this distance skips card tracing, saving substantial GPU time in open worlds.
r.Lumen.DiffuseIndirect.CullGridPixelSize <value>
- Sets the 2D tile/pixel size for the light and surface card culling grid used during diffuse indirect calculations.
r.Lumen.DiffuseIndirect.MinTraceDistance <value>
- Specifies the minimum world-space distance before rays evaluate against surface cards or distance fields, preventing near-field self-intersections and reducing trace cost.
r.Lumen.IrradianceFieldGather.NumProbesToTraceBudget <value>
- Sets the maximum per-frame budget for tracing irradiance field probes, preventing performance spikes when lighting updates across large scene areas.
r.Lumen.ProbeHierarchy.SamplePerPixel <value>
- Controls the probe hierarchy sampling density per pixel for lighting evaluation and probe interpolation.

Shadows & Virtual Shadow Maps (VSM)

r.Shadow.Virtual.Enable <0 or 1>
- Enables or disables Virtual Shadow Maps (VSM). Disabling (0) falls back to traditional Cascaded Shadow Maps (CSM).
r.Shadow.RadiusThreshold <value>
- Controls the screen-size threshold below which objects stop casting dynamic shadows (default is 0.03). Increasing this (e.g., r.Shadow.RadiusThreshold 0.06) aggressively culls shadows from small or distant objects to improve framerates, while lowering it prevents shadow popping in open-world views.
r.Shadow.Virtual.ResolutionLodBiasDirectional <value>
- Biases the resolution mip/LOD level specifically for directional light Virtual Shadow Maps (e.g., 0 for default, positive values like 1 reduce page resolution to boost performance and cut VRAM footprint, while negative values like -1.1 increase shadow detail over distance).
r.Shadow.Virtual.Clipmap.LastLevel <value>
- Sets the coarsest (outermost) shell level for directional light Virtual Shadow Map clipmaps (default is 22, covering ~40 km). Lowering this (e.g., 15 or 20) drops distant cascade shells to save substantial GPU time and VRAM in contained maps, while raising it extends shadow reach for planetary or flight-scale worlds.
r.Shadow.Virtual.Clipmap.UseConservativeCulling <0 or 1>
- Toggles conservative culling for directional light VSM clipmaps. Enabling this (1) removes the frustum-clipped culling volume for non-Nanite meshes, submitting more geometry to help isolate and debug shadow clipping or missing shadow bugs (default is 0).
r.Shadow.Virtual.Cache.MaxMaterialPositionInvalidationRange <value> (or r.Shadow.Virtual.Cache.MaxMaterialPositionInvalidationRadius)
- Sets the maximum world-space distance from the camera where material-driven vertex deformation (such as World Position Offset / wind on foliage) can invalidate cached VSM pages (e.g., 3600). Prevents distant animated foliage from continuously dirtying the shadow cache and causing heavy GPU spikes. (Note: Often referenced as ...InvalidationRadius or ...InvalidationRange across engine revisions).
r.Shadow.Virtual.NonNanite.IncludeInCoarsePages <0 or 1>
- Controls whether non-Nanite geometry (standard static meshes, skeletal meshes, non-Nanite foliage) is rendered into coarse, lower-resolution hierarchical MIP pages of Virtual Shadow Maps. Disabling this (0) provides a major performance boost in open-world scenes with dense non-Nanite assets.
r.Shadow.Virtual.ForceOnlyVirtualShadowMaps <0 or 1>
- Forces lights using Virtual Shadow Maps to strictly use the VSM pipeline without creating conventional fallback shadow maps (e.g., CSM), eliminating redundant shadow passes and reducing memory overhead.
r.Shadow.Virtual.UseFarShadowCulling <value or 0/1>
- Controls far-shadow culling for Virtual Shadow Maps. Enabling it culls distant shadows past a set range to preserve performance, while disabling or lowering the threshold (0 or 0.1) forces distant objects to keep casting virtual shadows, eliminating abrupt shadow popping at long distances.
sg.ShadowQuality <0, 1, 2, 3, 4>
- Scalability group setting for shadows (0 = Low, 1 = Medium, 2 = High, 3 = Epic, 4 = Cinematic).
r.ShadowQuality <0, 1, 2, 3, 4, 5>
- Directly overrides shadow quality level, controlling filter kernel quality, sample counts, and shadow map resolutions.
r.Shadow.MaxResolution <value>
- Sets the maximum texture resolution for conventional shadow depth maps (e.g., r.Shadow.MaxResolution 2048 or 1024).

Foliage

sg.FoliageQuality <0, 1, 2, 3, 4>
- Sets foliage quality group settings (Low, Medium, High, Epic, Cinematic).
Foliage.DensityScale <multiplier>
- Scales the density of rendered foliage dynamically (e.g., Foliage.DensityScale 0.5 reduces rendering to 50% density).

Decals

r.Decal.FadeScreenSizeMult <value>
- Multiplier for decal fading based on screen size, controlling how early decals fade out as they get further from the camera.

Animation & Skeletal Meshes

a.ParallelAnimEvaluation <0 or 1>
- Toggles parallel animation evaluation on worker threads. Disabling this (0) forces animation evaluation to run synchronously on the game thread, which is useful for isolating thread-safety bugs and race conditions.
a.StripFramesOnCompression <0 or 1> & a.StripOddFramesWhenFrameStripping <0 or 1>
- Strips alternate frames during animation compression. Can result in an approximate memory saving of around 20–30% on animation data, which is particularly useful for lower-end and memory-constrained platforms.
r.FreeSkeletalMeshBuffers <0 or 1>
- Controls whether mesh geometry buffers are retained CPU-side after upload. If your project is not using CPU-dependent features like runtime Mesh Merging, enable this (1) to save memory.
Controlrig.EnableAnimNodePerformanceOptimizations <0 or 1>
- Enables Control Rig anim node performance optimizations, allowing Control Rigs to share the AnimGraph’s transform buffer, reducing memory footprint and improving performance (enabled by default in UE 5.6+).
a.AnimNode.FootPlacement.Debug <0 or 1>
- Enables debug visualizations for the foot placement node, showing trace lines, target offsets, and IK status.
a.DebugAnimNotify <0 or 1>
- Enables debug messages for AnimNotifies as they trigger on actors.
a.VisualizeLODs <0 or 1>
- Enables debug visualization for skeletal mesh Animation LODs in the viewport, displaying which LOD level animated characters are using.

MetaHuman & Crowds

mh.Crowds.DebugISKMs <0 or 1>
- Toggles debug visualization and rendering status for Instanced Skeletal Mesh Managers (ISKMs) used in MetaHuman crowd systems.

Physics

p.Chaos.Collision.MarginMax <value>
- Sets the maximum collision margin distance for shapes in Chaos physics collision detection. Useful for tuning collision precision or diagnosing floating and clipping artifacts caused by overly large shape margins.
p.Chaos.DebugDraw.Enabled <0 or 1>
- Master switch to enable or disable Chaos physics debug drawing in the viewport.
p.Chaos.ImmPhys.DebugDrawCollisions <0 or 1>
- Enables debug visualization of collision contacts, manifolds, and contact points for Immediate Physics simulations.
p.Chaos.ImmPhys.DebugDrawShapes <0 or 1>
- Enables debug visualization of simulation and collision shapes for Immediate Physics (e.g., AnimNode_RigidBody).
p.RigidBodyNodeWithControl.DebugDraw <0 or 1>
- Enables debug draw visualizations for RigidBody with Control animation nodes in the viewport.
p.RigidBodyNodeWithControl.EnableSimulation <0 or 1>
- Toggles simulation for RigidBody with Control animation nodes. Setting this to 0 disables physics simulation, which is useful for debugging physics-driven skeletal mesh issues or isolating performance bottlenecks.
p.VisualizeMovement <0 or 1> (or p.VisualizeMovement 1)
- Visualizes velocity and acceleration vectors for character movement components (e.g., p.VisualizeMovement 1 to enable, 0 to disable).

Networking

p.NetShowCorrections <0 or 1>
- Toggles visual debugging for network position corrections, displaying red and green collision shapes to represent server corrections and client state.
p.NetEnableMoveCombining <0 or 1>
- Enables or disables combining client moves before sending them to the server. Disabling this (0) is useful for testing raw client input replication and debugging tick-by-tick prediction issues.
NetEmulation.PktLag <value in ms>
- Simulates outbound network latency/lag in milliseconds (e.g., NetEmulation.PktLag 150 for 150ms).
NetEmulation.PktLagVariance <value in ms>
- Adds random variance to the packet lag (e.g., NetEmulation.PktLagVariance 20 with PktLag 150 randomizes lag between 130ms and 170ms).
NetEmulation.PktLagMin <value> & NetEmulation.PktLagMax <value>
- Specifies a minimum and maximum range for simulated latency in milliseconds.
NetEmulation.PktLoss <percentage>
- Simulates outbound packet loss percentage (e.g., NetEmulation.PktLoss 10 for 10% packet loss).
NetEmulation.PktOrder <0 or 1>
- Simulates network packets being received out of order.

Water System

r.Water.SingleLayer.DepthPrepass <0 or 1>
- Enables or disables depth prepass for single-layer water shaders.
r.Water.SingleLayer.DistanceFieldShadow <0 or 1>
- Toggles distance field shadowing for single-layer water.
r.Water.SingleLayer.ShadersSupportDistanceFieldShadows <0 or 1>
- Configures whether water shaders compile and support distance field shadows.
r.Water.SingleLayer.Reflection <0 or 1>
- Toggles reflections on single-layer water.
r.Water.SingleLayer.DownSampleFactor <value>
- Configures the resolution downsample factor for water reflection/translucency render targets.

Volumetric Fog

r.VolumetricFog.GridPixelSize <value>
- Controls the screen grid tile size in pixels for volumetric fog voxel calculation (default is typically 8 or 16). Larger values (e.g., 16) drastically reduce compute shader cost while still maintaining solid visual fidelity when temporally accumulated.
r.VolumetricFog.TemporalReprojection <0 or 1>
- Toggles temporal reprojection for volumetric fog. Enabling this accumulates samples across frames to produce smooth, high-quality volumetric lighting at lower base grid resolutions.
r.VolumetricFog.UpsampleJitterMultiplier <value>
- Controls jittering during volumetric fog upsampling to reduce banding artifacts.
r.VolumetricFog.HistoryMissSupersampleCount <value>
- Configures the number of supersamples taken when history reprojection misses, sharpening the fog buffer at the cost of performance.

Launch / Command Line Arguments (EZ Args)

Pass these parameters directly to the executable or in the Editor’s executable arguments for quick setup:

-Log
- Opens a separate output log window in standard Windows CMD format when running standalone games.
-NewConsole
- Launches standalone games using a separate console window for cleaner stdout tracking.
-StompMalloc
- Enables the stomp memory allocator, which places pages in a way that immediately crashes the application when a memory overrun or read-after-free occurs (crucial for hunting memory corruption bugs).

Blueprint Compiler Extensions

Sat, 28 Feb 2026 00:00:00 +0000

Standard Delay nodes in Unreal Engine don’t respect the Gameplay Ability lifecycle. In the Gameplay Ability System (GAS), abilities should use the Wait Delay task node (UAbilityTask_WaitDelay) instead of standard latent delays.

To enforce this automatically, we can create a Blueprint Compiler Extension (UBlueprintCompilerExtension). By hooking directly into the Blueprint compilation process, we can check node graphs during compilation and fail the build if a forbidden node is used.

How Blueprint Compiler Extensions Work

Unreal Engine provides the UBlueprintCompilerExtension class (in the BlueprintCompiler module) to run custom validation rules during Blueprint compilation.

When a developer compiles a Blueprint:

The compiler instantiates all loaded subclasses of UBlueprintCompilerExtension.
It calls ProcessBlueprintCompiled() on each extension.
The extension inspects the Blueprint’s graphs, nodes, and variables.
If an invalid pattern is found, errors are pushed directly to the Compiler Results log, aborting compilation.

Setting Up Your Editor Module

Because compiler extensions rely on editor-only modules like BlueprintCompiler, KismetCompiler, and UnrealEd, this code must live in an Editor Module (e.g., MyProjectEditor). Placing editor dependencies inside a primary game module will break standalone builds.

Step 1: Update the `.uproject` File

Add the editor module configuration to your project’s .uproject file under "Modules":

MyProject.uproject
 {
 "Name": "MyProjectEditor",
 "Type": "Editor",
 "LoadingPhase": "PostEngineInit",
 "AdditionalDependencies": [
 "MyProject"
 ]
 }

Step 2: Update Target Files

In your project’s MyProjectEditor.Target.cs, add the editor module to ExtraModuleNames:

Source/MyProjectEditor.Target.cs
 ExtraModuleNames.AddRange(new string[] { "MyProject", "MyProjectEditor" });

Step 3: Create the Editor Module Build.cs

Create MyProjectEditor.Build.cs in your editor module directory:

Source/MyProjectEditor/MyProjectEditor.Build.cs
using UnrealBuildTool;

public class MyProjectEditor : ModuleRules
{
 public MyProjectEditor(ReadOnlyTargetRules Target) : base(Target)
 {
 PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;

 PublicDependencyModuleNames.AddRange(new string[] {
 "Core",
 "CoreUObject",
 "Engine",
 "MyProject"
 });

 PrivateDependencyModuleNames.AddRange(new string[] {
 "UnrealEd",
 "BlueprintGraph",
 "KismetCompiler",
 "Kismet",
 "GameplayAbilities"
 });
 }
}

Step 4: Create Module Header and Source Files

Initialize the editor module with main header and source files:

Source/MyProjectEditor/MyProjectEditor.h
#pragma once

#include "CoreMinimal.h"
#include "Modules/ModuleManager.h"

class FMyProjectEditorModule : public IModuleInterface {
public:
 virtual void StartupModule() override;
 virtual void ShutdownModule() override;
};

Source/MyProjectEditor/MyProjectEditor.cpp
#include "MyProjectEditor.h"
#include "Modules/ModuleManager.h"
#include "BlueprintCompilationManager.h"
#include "BPCE_Ability_Delay.h"

static UBPCE_Ability_Delay* AbilityDelayCheckExtension = nullptr;

void FMyProjectEditorModule::StartupModule() {
 AbilityDelayCheckExtension = NewObject<UBPCE_Ability_Delay>();
 AbilityDelayCheckExtension->AddToRoot();
 FBlueprintCompilationManager::RegisterCompilerExtension(UBlueprint::StaticClass(), AbilityDelayCheckExtension);
}

void FMyProjectEditorModule::ShutdownModule() {
 if (AbilityDelayCheckExtension) {
 AbilityDelayCheckExtension->RemoveFromRoot();
 AbilityDelayCheckExtension = nullptr;
 }
}

IMPLEMENT_MODULE(FMyProjectEditorModule, MyProjectEditor);

Implementing the Compiler Extension

Implement the validator class inside the editor module:

C++ Header File

Source/MyProjectEditor/BPCE_Ability_Delay.h
#pragma once

#include "CoreMinimal.h"
#include "BlueprintCompilerExtension.h"
#include "BPCE_Ability_Delay.generated.h"

UCLASS()
class MYPROJECTEDITOR_API UBPCE_Ability_Delay : public UBlueprintCompilerExtension {
 GENERATED_BODY()

public:
 virtual void ProcessBlueprintCompiled(const FKismetCompilerContext& CompilationContext, const FBlueprintCompiledData& Data) override;
};

C++ Source File

Source/MyProjectEditor/BPCE_Ability_Delay.cpp
#include "BPCE_Ability_Delay.h"
#include "K2Node_CallFunction.h"
#include "KismetCompiler.h"
#include "Abilities/GameplayAbility.h"
#include "EdGraph/EdGraph.h"
#include "Kismet/KismetSystemLibrary.h"

void UBPCE_Ability_Delay::ProcessBlueprintCompiled(const FKismetCompilerContext& CompilationContext, const FBlueprintCompiledData& Data) {
 const UBlueprint* Blueprint = CompilationContext.Blueprint;
 if (!Blueprint || !Blueprint->ParentClass) {
 return;
 }

 // Check if the blueprint is a Gameplay Ability
 if (!Blueprint->ParentClass->IsChildOf(UGameplayAbility::StaticClass())) {
 return;
 }

 TArray<UEdGraph*> AllGraphs;
 Blueprint->GetAllGraphs(AllGraphs);

 // Change the Blacklisted Function here
 const UClass* LibraryClass = UKismetSystemLibrary::StaticClass();
 static UFunction* DelayFunc = LibraryClass->FindFunctionByName(GET_FUNCTION_NAME_CHECKED(UKismetSystemLibrary, Delay));

 for (UEdGraph* Graph : AllGraphs) {
 if (!Graph) {
 continue;
 }

 for (UEdGraphNode* Node : Graph->Nodes) {
 if (const UK2Node_CallFunction* FuncNode = Cast<UK2Node_CallFunction>(Node)) {
 const UFunction* Func = FuncNode->GetTargetFunction();

 if (Func == DelayFunc) {
 UE_LOG(LogTemp, Error, TEXT("Critical: Blueprint '%s' contains a forbidden Delay node in graph '%s'!"), *Blueprint->GetName(), *Graph->GetName());

 FText ErrorMessage = FText::FromString(TEXT("Delay nodes are forbidden in Gameplay Abilities. Use 'Wait Delay' node or other latent ability tasks instead (Error in @@)"));
 CompilationContext.MessageLog.Error(*ErrorMessage.ToString(), Node);
 }
 }
 }
 }
}

How It Works

Graph and Node Traversal

Blueprint->GetAllGraphs(AllGraphs) collects all graphs within the Blueprint (event graph, custom functions, macro graphs, interfaces). Inside each graph, we iterate through Graph->Nodes and cast to UK2Node_CallFunction to inspect target function calls.

Function Signature Matching

Instead of string comparisons on function names every compile pass, we cache the target UFunction pointer using FindFunctionByName and match against the node’s target function:

const UClass* LibraryClass = UKismetSystemLibrary::StaticClass();
static UFunction* DelayFunc = LibraryClass->FindFunctionByName(GET_FUNCTION_NAME_CHECKED(UKismetSystemLibrary, Delay));

Formatting Compilation Errors and Hyperlinks

Unreal Engine’s compiler log parser supports the @@ token. When included in the error message, the compiler results window replaces @@ with a clickable hyperlink pointing to the node passed as the second parameter:

FText ErrorMessage = FText::FromString(TEXT("... Error in @@ ..."));

When pushed with CompilationContext.MessageLog.Error(Message, Node), double-clicking the compiler error jumps directly to the problematic node in the graph editor.

Validating Existing Gameplay Abilities

To run validation on all existing Gameplay Ability assets at once:

Filter for GameplayAbility assets in the Content Browser.
Select all matching assets, right-click, and click Validate Assets.

This executes compiler validation across every selected ability and outputs errors for any forbidden Delay nodes directly to the log.

Once UBlueprintCompilerExtension is registered, you can expand it to enforce additional node blacklists or architectural constraints across your Blueprints.