My List of Useful Console Commands

May 25, 2026
17 min read

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).