All 906 console variables the engine and editor register, with type, default and help text.
Last updated Nov 5, 2026Version 1.0.0
Every console variable registered in the engine, the editor and the first-party plugins: 906 in total, grouped by prefix. Set one from the console (r.VSM 1), the command line (-r.VSM=1) or the [ConsoleVariables] section of a config file.
Flags: Cheat variables are refused from the console and the command line when cheats are off (the Shipping default). ReadOnly variables are set by code and config only.
a
Name
Type
Default
Description
a.BudgetMaxDeferFrames
int
8
Frames in a row the budget may defer one animator before it must evaluate Game
a.BudgetMs
float
0.0f
Evaluation budget in ms per frame; the lowest-priority animators are deferred with their dt banked. 0 = no budget (UE AnimationBudgetAllocator) Game
a.EvalDuringPhysics
int
1
Evaluate the animators nothing reads before the physics step (no root motion consumed by movement, no morph channels) beside that step, when the scene overlaps it (p.OverlapDuringPhysics); foot IK raycasts run after the step against the stepped world. 0 = every animator evaluates ahead of the step Game
a.LOD
int
-1
Animator update-rate LOD around the focus: -1=on while a focus is set, 0=off, 1=on Game
a.LODBoneMask
int
1
Apply the skeleton's per-LOD required-bone sets (Skeleton::SetLodBonesToRemove); 0 animates every bone at every LOD Game
Animators beyond this sample every a.LODFarInterval frames Game
a.LODNearInterval
int
4
Frame interval between the near and far radius Game
a.LODNearRadius
float
30.0f
Full-rate radius; animators beyond it sample every a.LODNearInterval frames Game
a.OffscreenInterval
int
0
Frame interval for an animator the scene has not drawn inside the camera frustum for two updates; 0 = visibility does not throttle (UE VisibilityBasedAnimTickOption) Game
ai
Name
Type
Default
Description
ai.AutoBodyFound
int
1
Raise a dormant BodyFound situation when a crowd member or perceivable entity dies AINavigation
Crowd members instantiated per spawner per frame (streaming-friendly ramp-up) AINavigation
ai.Crowd.TierDwell
float
1.0f
Seconds a member must stay in its tier before it can be promoted (hysteresis; demotions to respect caps are immediate) AINavigation
ai.Crowd.TierStickiness
float
0.05f
Score bonus incumbents get when ranked against challengers at a tier boundary; a challenger must beat an incumbent by this margin to swap tiers AINavigation
ai.FootstepNoise
int
1
Footsteps report AI perception noise events, scaled louder when sprinting and quieter when crouching (0 = off) Game
ai.NoiseMap
int
1
Spread every sound and scan the AI hears over a decaying noise map the director reads; 0 = no map AINavigation
ai.NoiseMap.CellSize
float
4.0f
Edge of one noise map cell, in metres AINavigation
ai.NoiseMap.HalfLife
float
6.0f
Seconds for the noise map to fall to half AINavigation
ai.NoiseMap.Reach
float
24.0f
How far one unit of loudness spreads over the noise map before walls and doors take their share, in metres AINavigation
ai.PerceptionMaxRaysPerFrame
int
64
Maximum sight line-of-sight raycasts per frame across all AI perceivers; nearest candidates win, the rest coast on their last visibility AINavigation
ai.ScanFlashReach
float
30.0f
How far a LiDAR scan's flash is seen by AI facing it with a clear line of sight, in metres; 0 = scans are invisible to AI AINavigation
ai.ScanPulseReach
float
20.0f
How far in metres a scan pulse carries to AI hearing before walls and portals take their share; 0 = scans are silent to AI Game
Reaction radius of an auto-raised BodyFound situation AINavigation
ai.Situation.ConversationRange
float
4.0f
Distance in meters within which two full AI agents can exchange situation knowledge AINavigation
ai.Situation.ConversationTime
float
1.5f
Seconds two agents must stay within earshot (conversation range scaled by the walls and portals between them) before situation knowledge propagates AINavigation
ai.Situation.Debug
int
0
Log situation raises, discoveries, propagation and decay AINavigation
ai.Situation.DormantChecksPerFrame
int
8
Dormant-situation sight tests per frame (BodyFound discovery), round-robin over perceivers AINavigation
ai.Situation.ExplosionLifetime
float
45.0f
Seconds before an Explosion situation decays AINavigation
ai.Situation.GunshotLifetime
float
30.0f
Seconds before a Gunshot situation decays AINavigation
ai.Situation.PropagationAgentsPerFrame
int
8
Agents whose conversation pairs are checked per frame (round-robin stagger, never N^2) AINavigation
ai.Situation.Raise
string
std::string()
Debug raise consumed on the next situation tick: 'Type x y z radius severity' (e.g. 'Gunshot 0 0 0 25 1') AINavigation
ai.Situation.SuspiciousLifetime
float
20.0f
Seconds before a Suspicious (or Custom) situation decays AINavigation
ai.Situation.TrespassLifetime
float
30.0f
Seconds before a Trespass situation decays AINavigation
ai.Situation.VandalismLifetime
float
60.0f
Seconds before a Vandalism situation decays AINavigation
arc
Name
Type
Default
Description
arc.DeferredPopupRelease
bool
true
Free a closed menu's popup window once the GPU has retired its frames instead of tearing its swapchain down on the spot, which waits for the whole device several times per close. 0 = the old immediate teardown (for measuring it). Read once at Arc startup. Arc
arc.Density
int
1
UI density: 0 = Compact, 1 = Default, 2 = Comfortable (Preferences > Appearance > Density). Applies live: every measure is dropped and the UI re-lays out. Arc
arc.OSPopups
bool
true
Host menus and tooltips in their own topmost OS windows (overhang the owning window like native apps). 0 = legacy in-window overlays. Read once at Arc startup. Arc
arc.PopupsInWindow
bool
true
Paint a menu or tooltip that fits inside its owning window there, and give an OS window only to one that must overhang it. 0 = every menu and tooltip in its own OS window. Read once at Arc startup. Arc
arc.RetainedPaint
bool
true
Replay retained draw slices for opted-in widget subtrees on clean frames. 0 = paint every widget every frame, the ground truth a suspected stale-pixel bug is compared against. Arc
arc.Shaping
bool
true
HarfBuzz text shaping for Arc UI text (GPOS kerning, ligatures, mark placement). 0 = legacy FreeType kern-table path. Arc
arc.SkipUnchangedWindows
int
1
Skip a window's layout, paint and buffer upload on frames where nothing in it changed (every window still records over its scene and presents). 2 = an owned window that samples nothing live also skips its record and present. 0 = paint every window every frame. Arc
arc.SkipUnchangedWindows.LogFrames
int
0
Every this many frames, log the main window's average produce time (layout, paint, snapshot) and how many window paints and presents the skip saved over them. 0 = off. Arc
arc.SkipUnchangedWindows.VerifyFrames
int
8
A window that skips its paint paints anyway after this many skipped frames and compares the result with the frame it was replaying; a difference makes it paint every frame for a while. Arc
arc.TextContrast
float
CArcTextContrast::DEFAULT_CONTRAST
Contrast added to text coverage before the gamma blend (0 to 1), strongest for dark text. Arc
arc.TextFloatingContrast
float
CArcTextContrast::DEFAULT_FLOATING_CONTRAST
arc.TextContrast for text inside a floating surface (0 to 1). Arc
arc.TextFloatingGamma
float
CArcTextContrast::DEFAULT_FLOATING_GAMMA
arc.TextGamma for text inside a floating surface (a popover, a confirm), which the design's browser draws on its own layer with less of the lift. Arc
arc.TextGamma
float
CArcTextContrast::DEFAULT_GAMMA
Gamma text coverage is blended in, as a browser blends it (1 = the target's sRGB-encoded space, up to 3). Light text on a dark ground gains weight, dark text on a light ground loses some. Arc
arc.TextStemDarkening
float
CArcFontManager::TEXT_STEM_DARKEN_EM
Stem darkening of the design faces below 14 device px, as a fraction of the em. Read once when the fonts load. Arc
arc.ThemeRemap
bool
true
After a live theme switch, repaint colours that widgets copied from the previous theme's tokens in the new theme's values. 0 = only widgets built after the switch take the new theme. Arc
arc.UIScale
float
-1.0f
Override the DPI-derived UI scale (1.0 = 96 DPI, 2.0 = 192 DPI). Negative keeps the auto-detected value. Read once at Arc startup. Arc
asset
Name
Type
Default
Description
asset.MemoryBudgetMB
int
0
Resident asset budget in MB the LRU eviction keeps under; 0 = the manager's own (4 GB). The runtime and the editor claim it from the device's VRAM at startup unless config or the command line set it AssetSystem
asset.UploadMBPerFrame
int
32
Max megabytes of whole-asset GPU uploads (CreateGPU) an AssetManager drains per frame, on top of asset.UploadsPerFrame; the first upload of a frame always lands; <= 0 = unbounded AssetSystem
asset.UploadsPerFrame
int
8
Max GPU asset uploads (CreateGPU) an AssetManager drains per frame; <= 0 = unbounded AssetSystem
au
Name
Type
Default
Description
au.Debug.Attenuation
bool
false
Draw every playing spatial voice's min and max distance in the viewport (Audio debug-draw category) Audio
audio
Name
Type
Default
Description
audio.Acoustics
int
1
Geometric acoustics: occlusion through the scan hierarchy, reverb and early reflections traced from the level, echolocation; 0 = the physics material trace and the scanner's echo tail only Audio
audio.Acoustics.EchoClip
string
""
Clip each returning echo plays from where it bounced; empty = echoes are computed but not voiced Audio
audio.Acoustics.EchoConeDegrees
float
70.0f
Full cone angle of an echolocation click, in degrees Audio
audio.Acoustics.EchoNoise
float
0.6f
Loudness the AI hears an echolocation click at; 0 = clicks are silent to AI Audio
audio.Acoustics.EchoRange
float
40.0f
How far an echolocation click reaches, in metres Audio
What sound is traced against: 0 = the scan hierarchy when its plugin is loaded, else physics; 1 = scan hierarchy only; 2 = physics only Audio
audio.Acoustics.MaxDistance
float
80.0f
Longest leg any acoustic ray follows, in metres Audio
audio.Acoustics.MaxReflections
int
16
Early reflections kept per update, earliest first Audio
audio.Acoustics.ReflectionOrder
int
2
Highest early-reflection order (surfaces per path, 1-3) Audio
audio.Acoustics.ReverbBounces
int
4
Bounces each reverb ray follows before it is retired Audio
audio.Acoustics.ReverbRays
int
256
Rays traced from the listener to measure the room's decay Audio
audio.Acoustics.UpdateHz
float
4.0f
How often per second the listener's reverb and early reflections are re-traced Audio
audio.AutoSubtitles
int
0
Subtitle speech nobody captioned — proximity voice and audio games push in — with the on-device speech recognizer; nothing leaves the machine Accessibility
audio.AutoSubtitles.Available
int
0
Project option read by mbt package: ship the speech recognizer (ONNX Runtime, this module, the 95 MB model) so players can turn auto-subtitles on Accessibility
audio.AutoSubtitles.MinConfidence
float
0.55f
Lines the recognizer is less sure of than this are not shown, 0..1 Accessibility
Prefix each subtitle line with the speaker's name Narrative
cam
Name
Type
Default
Description
cam.FOV
int
0
Accessibility: the player's vertical field of view in degrees for the gameplay camera, 0 = each camera's authored value; a sequencer cut camera always keeps its own Camera
cam.ShakeScale
float
1.0f
Accessibility: multiplier on every camera shake, trauma-driven and modifier-driven alike, 0 = still camera, 1 = as authored Camera
carry
Name
Type
Default
Description
carry.BreakDistance
float
1.75f
Constraint stretch (m) between hold point and carried object beyond which the carry breaks and the object drops Plugins.Combat
Spring frequency (Hz) of the carry hold motor that drags a carried object toward the hold point Plugins.Combat
carry.MotorMaxForce
float
900.0f
Per-axis force limit (N) of the carry hold motor; heavy objects lag behind the hold point instead of snapping Plugins.Combat
carry.PerCarrierMaxForce
float
350.0f
Hold-motor force limit (N) of ONE carrier on a Heavy object. About what a person can lift one-handed-and-a-half: one carrier drags an 80 kg crate, two lift it. Plugins.Combat
carry.PlaceSnapMaxAngleDeg
float
45.0f
Maximum surface slope (degrees from up) a place-snap drop aligns to; steeper surfaces leave the dropped pose untouched Plugins.Combat
carry.PlaceSnapRayDist
float
2.5f
Downward raycast distance (m) used by place-snap to find the surface under a dropped object Plugins.Combat
Debug-draw layer: AI perception (sight cones, LOS rays, hearing radii, last-known-position markers) DebugDraw
ddc
Name
Type
Default
Description
ddc.AudioCook
int
-1
Cache decoded audio as .maudio blobs in the DDC: -1=code default (ON), 0=off, 1=on AssetFormats
ddc.MaxSizeMB
int
4096
Size cap on the project's derived data cache in MB; least recently used entries are evicted past it. 0 = uncapped Filesystem
ddc.MeshCook
int
-1
Keep models built from source in the DDC, so a warm load skips the translation and the build: -1=code default (ON), 0=off, 1=on AssetSystem
ddc.TextureCook
int
-1
Cache stb-decoded sources as cooked .mtex mip chains in the DDC so the editor shows the cooked texture: -1=code default (on), 0=off, 1=on AssetSystem
discord
Name
Type
Default
Description
discord.ProvisionalAuthType
int
0
How the game's identity token is presented for a provisional Discord account: 0 OIDC, 1 EOS access token, 2 EOS id token, 3 Steam session ticket, 4 Unity id token, 5 bot-issued access token, 6 Apple id token, 7 PlayStation id token Plugins.DiscordPlatform
discord.Social
bool
false
Ask Discord for the communication scopes at sign-in so the friends list and join invites work; off keeps the smaller presence-only consent screen. Read when the player signs in Plugins.DiscordPlatform
discord.Voice.AutoJoinCall
bool
true
Start the lobby's Discord call when a Discord lobby is created or joined Networking
discord.Voice.AutomaticGain
bool
true
Automatic gain control on the Discord call microphone Networking
discord.Voice.EchoCancellation
bool
true
Echo cancellation on the Discord call microphone Networking
discord.Voice.InputDevice
string
std::string()
Discord call microphone device id; empty or a device that is gone uses the system default Networking
discord.Voice.InputVolume
float
1.0f
Microphone volume for Discord calls, 0 to 1 Networking
discord.Voice.Mode
int
0
Discord call input mode: 0 voice activity, 1 push to talk (the game calls SetDiscordPushToTalk from its keybind) Networking
discord.Voice.NoiseSuppression
bool
true
Noise suppression on the Discord call microphone Networking
discord.Voice.OutputDevice
string
std::string()
Discord call speaker device id; empty or a device that is gone uses the system default Networking
discord.Voice.OutputVolume
float
1.0f
Speaker volume for Discord calls, 0 to 2 (1 is the device level) Networking
discord.Voice.PttReleaseMs
int
20
Milliseconds a Discord call keeps transmitting after the push-to-talk key is released Networking
discord.Voice.VadAutomatic
bool
true
Let Discord pick the voice-activity threshold; off uses discord.Voice.VadThreshold Networking
discord.Voice.VadThreshold
float
-60.0f
Manual voice-activity threshold in dB, -100 to 0 Networking
ed
Name
Type
Default
Description
ed.TickBudgetMs
float
4.0f
Milliseconds per editor frame the edit world spends in AActor::TickInEditor (0 = unlimited); actors left over run first next frame Game
editor
Name
Type
Default
Description
editor.AsyncImportGpuWorkPerFrame
int
24
Max GPU work units (submesh meshes / materials) built per frame while draining async model imports; <= 0 = unbounded AssetSystem
editor.AsyncImportThreads
int
0
Editor async import loader threads; 0 = a quarter of the cores, between 2 and 4 AssetSystem
editor.AutosaveIntervalSeconds
int
300
How often (seconds) the editor writes a crash-recovery autosave of the active dirty scene into Saved/Autosaves. 0 disables autosave. MowoEditor
editor.ContentWatchDebounceMs
int
400
Quiet time after the last content-tree change before the registry reconciles; <= 0 disables the watcher AssetSystem
editor.ContentWatchMinIntervalMs
int
2000
Shortest gap between two watcher-triggered registry reconciles AssetSystem
editor.DeferPaintUploads
bool
true
While the UI paints ahead of the render thread, queue the texture uploads the paint asks for (glyph atlas bands, lazily created images) and run them on the render thread before it records the UI. 0 = upload from the paint, which lost the D3D12 device in most Release runs. MowoEditor
editor.Details.LogRefresh
int
0
Log each Details refresh: rows handed to the list, rows rebuilt, the row model's build time, and the time the list spent building row widgets. MowoEditor
editor.Details.PartialRefresh
int
1
A property edit rebuilds only the Details rows whose content changed. 0 = every refresh rebuilds every row. MowoEditor
editor.IdleSceneSettleFrames
int
72
Idle frames the viewports keep rendering after the last change before they hold their image, so TAA, GI and exposure converge first (72 = 3 s at the 24 Hz idle cap). MowoEditor
editor.IdleSkipSceneRender
bool
true
While the editor sits idle (the idle frame cap applies) and no camera, pane, entity or selection changed, stop rendering the level viewports once the temporal passes settled; the last image stays up. 0 = render every frame, idle or not. MowoEditor
editor.ImportAsPackages
int
1
1 = a texture imports into a Texture package (.tex) and a sound into a Sound package (.sound) built from the source where it lies; 0 = the legacy copy into Content/ with a .mdfmeta sidecar. A texture asking for AI enhancement always takes the legacy path MowoEditor
editor.ImportModelsAsPackages
int
1
1 = a model imports into SkeletalMesh/StaticMesh, Skeleton, AnimSequence and Texture packages built from the source where it lies; 0 = the legacy copy into Content/ with a .mdfmeta sidecar MowoEditor
editor.mcp.enabled
bool
false
Serve the editor's tools over MCP on a loopback HTTP port (Editor Preferences > MCP Server). MowoEditor
editor.mcp.port
int
52801
Loopback port of the editor's MCP server; 0 takes any free port. MowoEditor
editor.MessageLog.OpenOnNewError
int
1
Bring the Message Log to the front when a new error arrives. 0 leaves the panel where it is and raises a toast instead. MowoEditor
editor.OverlapStartupLoads
bool
true
Read and parse the start scene and index the Visual Script classes on their own threads while the project's asset registry loads or rebuilds. 0 = one after another on the editor thread, for comparing startup times MowoEditor
editor.SyncImport
int
0
Editor model import: 0 = async (CPU on loader thread, GPU drained on the main thread), 1 = synchronous (blocking, legacy) AssetSystem
editor.Thumbnails.AsyncReadback
int
1
Read a rendered thumbnail back for the disk cache a few frames after its blit, polling a fence, instead of a synchronous readback that drains the GPU queue inside the editor frame: 1=on, 0=synchronous (A/B) MowoEditor
editor.UIPaintAhead
bool
true
Paint the editor UI for frame N+1 while the render thread still records frame N (double-buffered Arc batch); the uploads the paint asks for run on the record side (editor.DeferPaintUploads). 0 = paint only after the render thread drained. MowoEditor
editor.Undo.IncrementalRefresh
int
1
An Undo or Redo that only changed property values refreshes the Details rows of the actors it touched instead of rebuilding the Outliner and Details. 0 = every step refreshes everything. MowoEditor
editor.Undo.LogRefresh
int
0
Log how long the editor spent refreshing after each Undo or Redo, and whether the step took the incremental path. MowoEditor
editor.Viewport.RenderResolution
string
std::string()
Render the level viewport at a fixed WxH (e.g. 1920x1080) and stretch it into the panel; empty = the panel's own size MowoEditor
eqs
Name
Type
Default
Description
eqs.ItemBudget
int
512
Environment-query item measurements EnvQuerySystem spends per frame across every queued query; a query that runs out resumes next frame where it stopped. <= 0 finishes the whole queue in one frame AINavigation
fx
Name
Type
Default
Description
fx.Particles.Parallel
int
1
Simulate CPU emitter trees and build their billboards on worker threads, one task per emitter: 0 = all on the calling thread Particles
game
Name
Type
Default
Description
game.Rewind
int
0
Time rewind: keep the last seconds of play and let gameplay (the Visual Script Rewind node) return to any of them Game
game.Rewind.BudgetMB
int
64
Memory time rewind may hold; past it the oldest moments go first Game
game.Rewind.CaptureHz
float
10.0f
Moments time rewind captures per second; a rewind lands on one of them Game
Override how the cursor is confined to the window: -1 = whatever game code asked for, 0 = never, 1 = only while the game holds the cursor lock, 2 = always while focused. The lock takes the cursor into relative mode and confines it as a side effect, so only a game with a VISIBLE cursor needs 2 — without it that cursor walks onto the second monitor and the next click lands in another application. Focus gates every mode Input
i.DebugOverlay
int
0
Draw the per-action input debug overlay (context, action, phase, value, trigger events, suppression) in the viewport Input
i.Gamepad0.StickDeadzone
float
-1.0f
Stick deadzone for slot 0; -1 = use i.StickDeadzone Input
i.Gamepad0.TriggerDeadzone
float
-1.0f
Trigger deadzone for slot 0; -1 = use i.TriggerDeadzone Input
i.Gamepad1.StickDeadzone
float
-1.0f
Stick deadzone for slot 1; -1 = use i.StickDeadzone Input
i.Gamepad1.TriggerDeadzone
float
-1.0f
Trigger deadzone for slot 1; -1 = use i.TriggerDeadzone Input
i.Gamepad2.StickDeadzone
float
-1.0f
Stick deadzone for slot 2; -1 = use i.StickDeadzone Input
i.Gamepad2.TriggerDeadzone
float
-1.0f
Trigger deadzone for slot 2; -1 = use i.TriggerDeadzone Input
i.Gamepad3.StickDeadzone
float
-1.0f
Stick deadzone for slot 3; -1 = use i.StickDeadzone Input
i.Gamepad3.TriggerDeadzone
float
-1.0f
Trigger deadzone for slot 3; -1 = use i.TriggerDeadzone Input
i.GamepadMotion
bool
true
Gamepad gyro and accelerometer: 0 keeps the sensors off and every motion read returns nothing Input
i.HoldToToggle
int
0
Accessibility: a Hold trigger marked allow_toggle latches on its first press and releases on the next, instead of needing the key held down Input
Multiplier applied to both mouse-delta axes before any binding modifier (0.05..10) Input
i.RumbleScale
float
1.0f
Accessibility: multiplier on every gamepad rumble and trigger-haptic request, 0 = off, 1 = as authored Input
i.StickDeadzone
float
GamepadInput::DefaultDeadzone
Stick deadzone applied to every gamepad slot (0..1); the live range remaps to the full -1..1 Input
i.TriggerDeadzone
float
GamepadInput::DefaultTriggerDeadzone
Analog trigger deadzone applied to every gamepad slot (0..1); the live range remaps to the full 0..1 Input
i18n
Name
Type
Default
Description
i18n.Locale
string
"en"
Active UI locale — tables load from <root>/<locale>/*.txt on change Filesystem
i18n.PseudoLocalize
bool
false
Pseudo-localize every localized string (accented, a third longer, bracketed) to find text that was never localized and labels that will not fit a longer language Filesystem
import
Name
Type
Default
Description
import.AutoCutoutAlpha
int
1
Classify a material as alpha-masked when its base-colour alpha reads as authored cut-out coverage, for sources that declare no alphaMode and ship no opacity slot (ORCA/Falcor, DCC FBX foliage): 0=off, 1=on AssetSystem
import.ForceUpAxis
int
-1
Rotate a source up-axis into engine +Y at import: -1=auto/off, 0=source X-up, 1=Y-up (no-op), 2=Z-up AssetSystem
import.UniformScale
float
-1.0f
Extra uniform scale baked into every imported model's node transform: <=0 = off (use per-import), >0 = force this factor AssetSystem
interact
Name
Type
Default
Description
interact.ConeDeg
float
35.0f
Half-angle (degrees) of the view cone interactables must fall inside to be focusable Plugins.Combat
interact.Range
float
3.0f
Default interaction reach (m) used when an Interactable leaves its own range at zero Plugins.Combat
interact.ScreenCenterWeight
float
1.5f
Focus scoring weight of the angle to screen center relative to plain distance; higher favors what the camera looks at over what is merely close Plugins.Combat
job
Name
Type
Default
Description
job.BackgroundWorkerReserve
int
3
Workers kept free of Low-priority (background) jobs: they may hold at most workers minus this many at once, so High and Normal work always finds a worker. 0 = no cap Threading
lidar
Name
Type
Default
Description
lidar.CatchupShotsPerTick
int
64
Shots of history the host sends a late joiner per tick. Networking
lidar.HistoryMaxShots
int
50000
Shots the host keeps to replay to a late joiner; the oldest go first. 0 = unbounded. Networking
lidar.MaxOriginDistance
float
4.0f
How far (metres) a shot's origin may be from the shooter's pawn on the host. 0 = unchecked. Networking
lidar.MaxRaysPerSecond
float
60000.0f
Host token bucket of LiDAR rays per player per second — what every peer pays to re-trace. 0 = unlimited. Networking
lidar.MaxRaysPerShot
int
16384
Host cap on one replicated LiDAR shot's ray count; a larger shot is refused and not relayed. Networking
lidar.MaxShotRange
float
120.0f
Host cap on a replicated LiDAR shot's range (metres). Networking
lidar.MaxShotsPerSecond
float
30.0f
Host token bucket of LiDAR shots per player per second. 0 = unlimited. Networking
liveops
Name
Type
Default
Description
liveops.ConfigUrl
string
""
Where the game fetches its signed remote config at start; empty = defaults and the cache only Game
Keep opted-in telemetry in Saved/Telemetry/events.jsonl as well, the file mbt liveops report reads Game
liveops.TimeoutSeconds
int
5
How long a remote-config fetch or a telemetry upload may take Game
mdf
Name
Type
Default
Description
mdf.Validate
int
-1
MDF document validation on load. -1 = app default (editors on, runtime off), 0 = force off, 1 = force on. Reflection
meaf
Name
Type
Default
Description
meaf.Verify
int
-1
MEAF payload verification: -1 = auto (2 when signed, else 1), 0 = off, 1 = per-entry CRC32 on load, 2 = also hash the data section at mount Filesystem
ml
Name
Type
Default
Description
ml.ExecutionProvider
string
"auto"
Where on-device inference (AI texture enhancement, auto-subtitles) runs: auto takes the GPU through the WebGPU execution provider for texture enhancement and keeps the speech recognizer on the CPU (on the GPU it measured no faster and would share the game's frame), gpu puts every model on the GPU and warns when it has to fall back, cpu never touches the GPU. Applies to models loaded from then on ML
mods
Name
Type
Default
Description
mods.Enabled
int
1
Load mods from <package>/Mods, Saved/Mods and the providers (Steam Workshop) at start Game
mods.EnableNew
int
0
A mod the enable list has never seen starts enabled; off, the player turns each new mod on Game
Comma-separated hex public keys trusted to sign any mod Game
mods.TrustedOnly
int
0
Accept only mods signed by mods.TrustedKeys or the game's own key, not by their author's Game
mowo
Name
Type
Default
Description
mowo.GC.Incremental
bool
true
Spread the periodic GC across frames: the mark runs in mowo.GC.StepBudgetMs slices behind the TObjectPtr write barrier, then the sweep deletes at most mowo.GC.SweepBudget objects per frame. 0 = the old synchronous pass that marks AND deletes everything in one frame. EngineLoop
mowo.GC.IntervalSeconds
float
5.0f
How often (seconds) the GC fires. Set to 0 to disable periodic GC; manual Force Garbage Collect from the editor still works. EngineLoop
mowo.GC.StepBudgetMs
float
1.0f
Per-frame marking budget (milliseconds) for the incremental GC. <= 0 = the mark completes atomically in one step (the old stop-the-world hitch). Budgeted marking became the DEFAULT once every engine MPROPERTY object ref went barriered (R5.1): TObjectPtr<T> fields barrier every store, the three raw-pointer MPROPERTY containers (world actors, actor components, attach children) shade their stores at the insertion sites, and SetOuter / actor spawn/attach call NotifyReferenceWrite. A game-module class that adds a plain T* MPROPERTY re-opens the hole — use TObjectPtr. EngineLoop
mowo.GC.SweepBudget
int
128
Max objects deleted per frame during the incremental GC sweep. <= 0 = unbounded (sweep completes in one step). EngineLoop
mowo.Profiler.Capture
int
0
Retain the last N profiler frames (CPU scopes, GPU passes, memory tags) so they can be scrubbed and exported. Off by default - the ring copies every scope sample each frame. Core
mowo.Trace.File
string
std::string()
Stream every profiled frame to this .mtrace file (open it in MowoInsights). Empty stops the trace. --trace=<file> sets it at startup. Core
mowo.Trace.MaxSizeMB
int
2048
Size of one .mtrace part in MB; past it the trace continues in <name>_001.mtrace, <name>_002.mtrace, ... 0 = one unbounded file. Core
nav
Name
Type
Default
Description
nav.ParallelTileBake
int
1
Bake the tiles of a tiled nav mesh on the job pool (1) or one after another (0); the result is the same either way AINavigation
nav.PathQueryBudget
int
2048
Detour search iterations NavAgentSystem spends per frame on queued gameplay path requests (RequestPathAsync); a request that runs out resumes next frame. <= 0 finishes the whole queue in one frame AINavigation
nav.Rebuild
int
1
Rebuild tiled navmeshes at runtime where nav-relevant geometry moved, appeared or disappeared; 0 = the baked mesh stays as baked AINavigation
nav.Rebuild.MaxDelay
float
2.0f
Seconds after which dirty navmesh areas rebuild even while geometry keeps moving AINavigation
nav.Rebuild.MaxTiles
int
16
Most navmesh tiles one runtime rebuild pass bakes; further dirty areas wait for the next pass AINavigation
nav.Rebuild.SettleTime
float
0.3f
Seconds the dirty navmesh areas must stay unchanged before their tiles rebuild, so a door swinging shut rebuilds once AINavigation
nav.StreamBySector
int
1
Keep only the navmesh tiles whose world-streaming sector is loaded in the live mesh: a tile leaves with its sector and comes back with it. Tiled, obstacle-free meshes only; a world with no streaming sectors keeps every tile AINavigation
nav.StreamTilesPerFrame
int
8
Navmesh tiles NavAgentSystem adds or removes per lane per frame while streaming by sector. <= 0 = no limit AINavigation
nav.UseCrowd
int
1
Steer agents through dtCrowd when it is up. 0 = single-agent path following on the budgeted path queue (the fallback a failed crowd init takes) AINavigation
net
Name
Type
Default
Description
net.ack_probe_interval
int
16
Snapshot ticks between keep-alive probes sent to an ack-stalled peer. The probe is an empty header, so its cost does not scale with object count. Networking
net.AllowDirectHost
int
0
Listen server with Steam up: 1 = also open the direct ENet UDP listener beside the Steam relay (LAN and --connect ip:port joins work; every peer sees the host's IP). 0 = relay only, unless the project's Network Privacy setting or the session asks for direct hosting. Dedicated servers always listen directly. Networking
net.BlobBytesPerSecond
int
32768
Bytes per second the blob lane sends to one peer. 0 = unlimited (the window still bounds what is in flight). Networking
net.BlobBytesPerTick
int
0
Most blob bytes one replication tick sends across all peers, so a burst of joiners cannot spend a whole frame's link budget. 0 = no cap. Networking
net.BlobChunkBytes
int
1024
Payload bytes per blob chunk (256 to 16384). Keep chunk plus the 40 bytes of headers under the transport MTU; a larger chunk is fragmented by the transport and a single lost fragment resends all of it. Networking
net.BlobMaxQueuedBytes
int
16 * 1024 * 1024
Payload bytes the blob lane queues for one peer before it refuses more: a slow or stalled client costs the host this much memory, not the whole world. 0 = no cap. Networking
net.BlobWindowChunks
int
32
Blob chunks (1 KiB each) a sender may have unacknowledged per peer before it waits for the receiver. Networking
net.BlobZstdLevel
int
3
zstd level for blobs queued from now on (RPCs of 64 KiB and up, bulk data). 0 sends them uncompressed; a blob that does not shrink by 5% is sent as it is anyway. Networking
net.CharacterPrediction
bool
true
Client-side character prediction with server reconcile through the real Jolt character step. 0 = interpolation-only ghosts, no input receiver. Networking
net.CorrectionSmoothTime
float
0.1f
Time constant (seconds) of the visual offset that hides a prediction correction on the local pawn. 0 = snap. Networking
net.CorrectionSnapDistance
float
2.0f
A correction larger than this (meters) is a teleport and snaps instead of smoothing. Networking
net.cull_distance
float
100.0f
Default distance-relevancy radius (world units) for NetworkObjects that don't set net_cull_distance. Networking
net.encrypt
string
"on"
ENet session encryption: on (every link, LAN included) | auto (non-private addresses only) | off Networking
net.gns.MaxSendRate
int
4096
GameNetworkingSockets transport: the most a connection may send, in KB per second. GNS starts each connection at a rate derived from its round trip and never above this; 256 is the floor. Applies to connections opened after the change. Networking
net.graph
int
0
The netgraph overlay: 0 off, 1 frame rate, ping, jitter, loss, bandwidth and server tick, 2 adds their graphs, 3 adds CPU/GPU temperature and load. Off by default in a packaged game; a project sets it in its INI, a player in the options menu. ArcUI
net.input_rate_limit
int
120
Max client->server Input packets accepted per peer per second. 0 = unlimited. Networking
net.MaxBlobBytes
int
4 * 1024 * 1024
Largest RPC (bytes) the blob lane sends, and the largest a client accepts from the host. Networking
net.MaxClientBlobBytes
int
256 * 1024
Largest blob (bytes) a host reassembles from one client; a client that announces more is refused before any memory is reserved. Networking
net.MaxMoveDeltaTime
float
0.125f
Longest time (seconds) the server steps for one client move; a longer claimed delta is clamped, as UE's MaxMoveDeltaTime. Networking
net.MaxQueuedMoves
int
64
Moves the server holds per player before it drops the oldest. Networking
net.max_snapshot_bytes
int
1200
Max snapshot packet bytes per client per tick. 0 = unlimited. Networking
net.max_unacked_sends
int
64
Snapshot packets a peer may go without acking before the server stops sweeping objects for it and falls back to a keep-alive probe. 0 = never stall (unbounded resend). Networking
net.max_updates_per_tick
int
64
Max snapshot entries per client per tick. 0 = unlimited. Overflow is deferred, not dropped — staleness raises priority. Networking
net.MoveCombineSeconds
float
1.0f / 30.0f
Longest time (seconds) one combined move may cover before it is sent; capped by net.MaxMoveDeltaTime. UE's ClientNetSendMoveDeltaTime. Networking
net.MoveCombining
bool
true
Hold a client move back and merge the next one into it when both carry the same input, no jump press and no root motion, as UE's pending-move combining. Halves the moves sent while input is steady. Networking
net.MoveTimeBudget
float
0.25f
How far (seconds) a client's moves may run ahead of the server's clock before the server makes them wait. Bounds speed hacks that claim more time than passed; UE's movement time discrepancy. Networking
net.OwnerPriorityBoost
float
4.0f
Priority multiplier for an object the peer owns (its pawn, its carried prop) within the object's tier. UE's sphere-with-owner-boost prioritizer. 1 = no boost. Networking
net.peer_byte_budget
int
6000
Outgoing bytes per second the server will spend on one peer. Reliable traffic is charged but never dropped; the unreliable snapshot sweep is capped by what remains. 6000 B/s = 48 kbit/s, the per-client target. 0 = unlimited. Networking
net.peer_in_byte_budget
int
8192
Incoming bytes per second the server will accept from one peer, charged before the packet is decoded. The RPC and input limits count packets, not bytes, so without this one peer can hand the host megabytes a second inside a legal packet rate. 0 = unlimited. Networking
net.PredictionSendHz
int
60
Client input command send rate. Frames between sends accumulate into the command's dt so replay integrates the same time span. Networking
net.PredictionTolerance
float
0.25f
Positional divergence (meters) between the predicted pawn and the server's authoritative pose that triggers a rewind + replay correction. Networking
net.psk
string
""
Pre-shared key mixed into the ENet handshake KDF; a peer without it fails key confirmation. Empty = the host makes up a join key per session, which every peer from off this machine must present (host:port#KEY) Networking
net.QuantizeMoves
bool
true
Snap a move's input axes to the grid the server simulates with (1/127 for movement, 1/100 for look) on both ends, so the client predicts with the exact values the server steps, as UE's acceleration quantization. Networking
net.rejoin_grace_seconds
float
60.0f
Seconds the host holds a dropped player's slot, pawn and NetworkIds so the same identity can re-bind to them. 0 = a disconnect is a leave. Networking
net.relevancy
bool
true
Per-client relevancy filtering, priority and the per-peer byte budget on the server. 0 = every peer sees every replicated object (legacy), still capped per packet by net.max_snapshot_bytes and the byte budget. Networking
Frames the net rewind ring keeps per peer (1800 = a minute at 30 Hz). Networking
net.rewind.record
bool
false
Keep a ring of every replicated frame on this peer and write it to Saved/NetRecordings when the session ends, for the Net Rewind panel. Networking
net.Rollback
int
0
Rollback netcode for the play session: the ECS world runs as a deterministic fixed-step simulation, inputs are exchanged and predicted, mispredictions are rolled back and resimulated Game
net.Rollback.ChecksumInterval
int
10
Frames between desync checks (checksums of fully confirmed frames) Game
net.Rollback.InputDelay
int
2
Frames a local input waits before it is simulated; each one is a frame of latency the remote input can hide in Game
net.Rollback.MaxPrediction
int
8
Frames the simulation may run ahead of a peer's last input before it stalls Game
net.Rollback.OnDesync
int
0
What a desync does: 0 logs it and plays on, 1 logs it and ends the rollback session (net.Rollback off) so the machines stop simulating different worlds Game
An RPC packet larger than this (bytes) goes through the blob lane: chunked on the reliable unordered channel under net.BlobBytesPerSecond and net.BlobWindowChunks, so it neither stalls the ordered reliable channel nor floods the link, but it is no longer ordered against the rest of the reliable stream. Arguments of 64 KiB or more, which the Rpc body cannot carry, always take it. 0 = only those. Networking
net.rpc_rate_limit
int
32
Max client->server RPCs accepted per peer per second. 0 = unlimited (ENet applies no bandwidth limit of its own). Networking
net.rpc_rate_limit_high
int
200
Max client->server RPCs per peer per second on methods registered as the HighRate channel class (a continuously-swept sensor, a held-trigger weapon). Separate bucket from net.rpc_rate_limit. 0 = unlimited. Networking
net.ServerForceMoveSeconds
float
0.5f
A remote pawn that sends no move for this long is stepped by the server with no input, so it still falls and gets pushed. 0 = never. Networking
Simulated jitter in milliseconds, uniform noise on top of net.sim.latency. 0 = off. Networking
net.sim.latency
int
0
Simulated one-way latency in milliseconds, added to every frame on send and on receive. 0 = off. Networking
net.sim.loss
float
0.0f
Simulated packet loss, percent of frames dropped on send and on receive. 0 = off. Networking
net.sim.reorder
float
0.0f
Simulated reordering, percent of frames held back so a later frame overtakes them. 0 = off. Networking
net.starvation_ticks
int
32
A relevant object this many snapshot ticks stale outranks priority entirely. 0 = pure priority ordering (can starve). Networking
net.Transport
string
"composite"
Wire transport for sessions: composite (ENet, plus the platform relay for SteamID64 targets and dual-listen hosting) | enet | gns (GameNetworkingSockets over IP) | steam (platform relay only). Followed until a session hosts or joins, so a project config applied after startup still counts; an option this build cannot honour falls back to composite. Networking
net.ViewConeDegrees
float
60.0f
Half-angle (degrees) of the view cone net.ViewConePriorityBoost applies inside. Networking
net.ViewConePriorityBoost
float
2.0f
Priority multiplier for an object inside the peer's view cone, fading to 1 at the cone's edge. UE's field-of-view prioritizer. 1 = off. Networking
net.voice_budget_share
float
0.5f
Largest share (0..1) of net.peer_byte_budget that voice relayed to a peer may spend; replication keeps the remainder. 0 = voice is not charged. Networking
p
Name
Type
Default
Description
p.AsyncTick
bool
false
Step Jolt on a worker between this frame's submit and the next frame's join; poses land one frame late and any call that reaches Jolt in between waits for the step Physics
p.CharacterEdgeRemoval
bool
false
Character controllers spend extra effort removing ghost contacts on the internal edges of a triangle mesh, so a capsule slides smoothly over mesh seams and convex edges instead of catching; costs more per character step, read when a controller is created Physics
p.Debug
bool
false
Master switch for the physics debug visualizer Cheat.Physics
p.DebugAABB
bool
false
Draw world-space bounding boxes when p.Debug is on Physics
p.DebugBroadPhase
bool
false
Draw body bounds tinted by object layer, dimmer for the non-moving broad phase layer, when p.Debug is on Physics
p.DebugCOM
bool
false
Draw centre-of-mass crosses when p.Debug is on Physics
p.DebugConstraints
bool
true
Draw constraint anchors when p.Debug is on Physics
Reproducible physics: Jolt's jobs run single-threaded in a fixed order and contact events are dispatched sorted by body pair, so the same inputs replay bit-identically on the same binary and CPU Physics
p.LOD
int
-1
Distance simulation LOD around the focus: -1=on while a focus is set, 0=off, 1=on Physics
p.LODSleepRadius
float
150.0f
Dynamic bodies farther than this from the focus are force-deactivated Physics
p.LODWakeRadius
float
120.0f
LOD-frozen bodies wake when the focus comes back within this radius Physics
p.MaxSubsteps
int
8
Upper bound on fixed-timestep substeps per frame; time beyond this is discarded rather than banked Physics
p.OverlapDuringPhysics
bool
true
Kick the frame's physics steps onto a worker after the PrePhysics tick group and join after DuringPhysics, so those actor ticks overlap the solver; the world systems ordered ahead of physics still run before the kick, and what a DuringPhysics tick moves is seen by the next step, as in UE Physics
p.PositionSteps
int
2
Solver position iterations per physics step (Jolt default 2): how hard penetrations are pushed apart; read when the world comes up Physics
p.SnapshotFrames
int
128
Whole-world physics snapshots the rollback ring keeps (0 turns capturing off). Only ticks gameplay captures are stored, each a full copy of the simulation state; read when the ring is first used Physics
p.Stats
int
0
Log the physics stats snapshot every N frames (0=off) Physics
p.Threads
int
-1
Upper bound on the workers Jolt splits a step across (-1 = the whole engine pool); ignored under p.Deterministic Physics
p.VelocitySteps
int
10
Solver velocity iterations per physics step (Jolt default 10). Raise to settle tall stacks and piles harder, lower to trade stability for step time; read when the world comes up Physics
pcg
Name
Type
Default
Description
pcg.NodeCache
int
1
Reuse a PCG node's points when its inputs, parameters, seed, bounds, landscape and splines hash to a result already computed, so a regeneration only reruns the nodes downstream of what changed. 0 = recompute every node PCG
pcg.NodeCacheEntries
int
512
Node results the PCG cache keeps across every volume before it drops the least recently used PCG
phys
Name
Type
Default
Description
phys.Debris.MaxCount
int
256
Destruction debris budget per scene: the oldest shard is recycled when a break would exceed it. Destruction
phys.Debris.MaxLifetime
float
20.0f
Seconds a destruction shard may exist before it is recycled, whatever its component asks for (0 on the component means this cap). Destruction
phys.Debris.MaxSpawnPerFrame
int
64
Destruction shards one frame may spawn across every break; a break past it produces fewer pieces instead of a hitch. Destruction
r
Name
Type
Default
Description
r.AO.Divisor
int
-1
Resolution divisor for the AO trace and its horizontal blur; the vertical blur stays full-res and doubles as the bilateral upsample: -1=tier value, 1=full res, 2=half SceneRenderer
r.AsyncCompute.AvoidAluOverlap
int
1
Join an async-compute lane before the first ALU-heavy pass (GTAO, RT sun shadow, MegaLights) instead of at its first consumer: 1 = join early (the lane only overlaps raster-bound work), 0 = overlap until the consumer SceneRenderer
r.Atmosphere.SunTransmittance
int
1
Modulate the directional light by the atmospheric transmittance along the sun ray (reddens + dims the sun toward the horizon; the authored light color stays the artist's base): 0=off, 1=on SceneRenderer
r.AutoExposure.EV
float
0.0f
EV compensation added on top of the scene's auto-exposure EV (photographic stops); 0 keeps scene authority SceneRenderer
r.AutoExposure.HighPercent
float
-1.0f
Percentile metering (mode 3): where the metered window closes, in percent of the pixels ordered by luminance. -1 = the scene's own value SceneRenderer
r.AutoExposure.LowPercent
float
-1.0f
Percentile metering (mode 3): where the metered window opens, in percent of the pixels ordered by luminance. -1 = the scene's own value SceneRenderer
r.AutoExposure.MaxEV
float
999.0f
Brightest adapted exposure the eye adaptation may settle at, in stops (multiplier = 2^EV). Lower it to stop a dark scene being lifted to grey. 999 = the scene's own value SceneRenderer
Darkest adapted exposure the eye adaptation may settle at, in stops (multiplier = 2^EV). 999 = the scene's own value SceneRenderer
r.AutoExposure.SpeedDown
float
-1.0f
Adaptation rate toward darker scenes (exposure rising), 1/s — dark adaptation is slower. -1 = the scene's own value SceneRenderer
r.AutoExposure.SpeedUp
float
-1.0f
Adaptation rate toward brighter scenes (exposure falling), 1/s — eyes adapt to light fast. -1 = the scene's own value SceneRenderer
r.AutoInstancing
int
-1
Collapse identical (mesh, material, LOD) static draws into instanced draws: -1=code default, 0=off, 1=on SceneRenderer
r.AutoQuality.ForceCores
int
-1
GPU auto-tier: simulate this logical core count (-1 = real machine) SceneRenderer
r.AutoQuality.ForceDeviceId
int
-1
Device profiles: simulate this PCI device id (-1 = real device) SceneRenderer
r.AutoQuality.ForceDriver
string
""
Device profiles and the driver blocklist: simulate this driver version (empty = real driver) SceneRenderer
r.AutoQuality.ForceIntegrated
int
-1
GPU auto-tier: simulate device type — 0=discrete 1=integrated (-1 = real device) SceneRenderer
r.AutoQuality.ForceName
string
""
GPU auto-tier: simulate this device name (empty = real device) SceneRenderer
r.AutoQuality.ForceRamMB
int
-1
GPU auto-tier: simulate this system RAM size in MB (-1 = real machine) SceneRenderer
r.AutoQuality.ForceVendor
string
""
Upscaler auto-pick: simulate this GPU vendor string (empty = real device) SceneRenderer
r.AutoQuality.ForceVendorId
int
-1
Device profiles: simulate this PCI vendor id (-1 = real device) SceneRenderer
r.AutoQuality.ForceVRAMMB
int
-1
GPU auto-tier: simulate this VRAM size in MB (-1 = real device) SceneRenderer
r.AutoQuality.VendorUpscalers
int
0
Let the upscaler auto-pick choose a vendor scaler (DLSS/FSR/XeSS) instead of the engine's own TSR. Off by default: the vendor SDKs interpose the graphics API and their process-exit handlers have already proved fragile. SceneRenderer
r.Bake.MeshCards
int
1
Cluster mesh surfaces into GI surface-cache card sets in cooked .mmodel (v11): 0=off (the runtime fits one box per instance), 1=on AssetFormats
r.Bake.MeshSdf
int
1
Bake a per-mesh signed distance field into cooked .mmodel (v6): 0=off, 1=on AssetFormats
r.Bake.MeshSdf.LiveMaxTriangles
int
250000
Triangle budget for baking a mesh SDF during a live (non-cooked) import; 0 = never bake live, cooked .mmodel only AssetSystem
r.Bake.MeshSdfThreads
int
0
Threads baking mesh SDFs for one model: 0 = every hardware thread, 1 = serial AssetFormats
r.BcHdrTextures
int
1
Block-compress HDR texture sources to BC6H at texture cook (DDC-cached, mips end-to-end): 0=off (raw RGBA16F), 1=on AssetSystem
r.BcModelTextures
int
1
Block-compress decoded model textures at import (albedo/data BC7, normals BC5; DDC-cached): 0=off, 1=on AssetSystem
r.BcModelTexturesBC1
int
0
Fast-path fully-opaque sRGB model textures (albedo/emissive) to BC1 instead of BC7 — half the VRAM of BC7, much faster encode, 565 endpoint quality: 0=off, 1=on AssetSystem
Bloom mip chain length processed (1..6): -1=tier value SceneRenderer
r.CapsuleShadows
int
1
Capsule shadows from skinned meshes with Capsule Shadows on: 0 = off, 1 = on SceneRenderer
r.CapsuleShadows.DirectStrength
float
0.85f
How much a capsule shadows the sun (0..1) SceneRenderer
r.CapsuleShadows.IndirectStrength
float
0.8f
How much a capsule occludes the sky / indirect light (0..1) SceneRenderer
r.CapsuleShadows.MaxDistance
float
4.0f
World distance along the sun ray over which a capsule shadow fades out SceneRenderer
r.CapsuleShadows.SoftnessAngle
float
12.0f
Half-angle in degrees of the sun cone a capsule shadow is traced with: wider = softer, further-reaching penumbra SceneRenderer
r.Clouds.ShadowFootprint
float
4000.0f
World size of the sun-aligned cloud shadow footprint around the camera, snap-stabilized like CSM SceneRenderer
r.Clouds.ShadowMapSize
int
512
Cloud shadow map resolution in texels (per side) SceneRenderer
r.Clouds.Shadows
int
-1
Sun-space cloud transmittance map multiplied into the deferred sun term + froxel fog in-scatter (raymarched clouds only): -1=scalability tier default (High+), 0=off, 1=on SceneRenderer
r.Clouds.ShadowSamples
int
4
Density samples of the vertical transmittance integral through the cloud slab (2..8) SceneRenderer
r.Clouds.ShadowStrength
float
1.0f
Blend of the cloud transmittance into the sun visibility (0 = no darkening, 1 = full) SceneRenderer
r.Color.Temperature
float
-1000.0f
White-balance override in [-1,1] (cool..warm); < -900 uses the scene's own value SceneRenderer
r.Color.Tint
float
-1000.0f
White-balance tint override in [-1,1] (green..magenta); < -900 uses the scene's own value SceneRenderer
r.ColorBlind.Mode
int
0
Accessibility: colour-vision correction after the tonemap, 0 = off, 1 = protanopia, 2 = deuteranopia, 3 = tritanopia (Machado 2009 simulation, the lost difference folded into the channels the viewer keeps) SceneRenderer
r.ColorBlind.Simulate
int
0
Accessibility preview: show the frame as a viewer with a colour-vision deficiency sees it, after any correction; 0 = off, 1 = protanopia, 2 = deuteranopia, 3 = tritanopia SceneRenderer
r.ColorBlind.Strength
float
1.0f
Accessibility: how much of the colour-vision correction is applied, 0..1 SceneRenderer
r.ColorGradingLUT
string
""
Color-grading .cube 3D LUT path override: empty=scene setting SceneRenderer
r.ContactShadowSteps
int
-1
Screen-space contact shadow march steps: -1=tier value SceneRenderer
r.D3D11.RenderThread
int
1
D3D11 with the render and RHI threads: 1 = the render thread owns the immediate context and records frame N-1 while the game thread produces N, other threads' buffer/texture writes queue for the next frame's start (FD3D11UploadQueue), 0 = D3D11 runs the frame on the game thread as before. Read when the host starts RHI
r.D3D12.AsyncCompute
int
1
Enable the D3D12 async-compute lane (latched at first use). On by default; 0 records every r.AsyncCompute candidate inline on the direct queue (the escape hatch for a driver whose compute queue is slower than its graphics queue): 0=off, 1=on D3D12RHI
r.D3D12.AsyncCompute.SyncSubmit
int
0
1 = issue the async-compute fork, hand-off and join splits through FRHIThread::ExecuteSync (the render thread waits for the whole RHI queue each time, the pre-2026-10-19 path), 0 = record the split on the render thread and queue only the execute/signal/wait D3D12RHI
r.D3D12.AsyncUploads
int
1
Create-with-data uploads on D3D12 (static buffers, texture data) submit their single-time list and return without waiting for the GPU; the staging is released once the list's fence passes. 0 = wait for every upload (the old blocking path) D3D12RHI
r.D3D12.CopyQueueUploads
int
1
Create-with-data uploads on D3D12 (fresh static buffers and textures) copy on the COPY queue, and the direct queue waits for them on the GPU instead of running the copies itself. 0 = copy on the direct queue (requires r.D3D12.AsyncUploads to stay non-blocking) D3D12RHI
r.D3D12.FrameLatencyWaitable
int
1
Create the D3D12 swapchain with a frame-latency waitable object and block BeginFrame on it, as D3D11 does. Without it the only throttle is the frame fence, which lets DXGI queue its default three presents ahead of the display: 0=off, 1=on (not with a frame-generation proxy swapchain, which owns pacing) D3D12RHI
r.D3D12.MaxFrameLatency
int
2
Presents the D3D12 swapchain may queue ahead of the display when r.D3D12.FrameLatencyWaitable is on: 1 = lowest latency, risks a GPU bubble when the CPU frame is long; 0 = FramesInFlight; clamped to FramesInFlight D3D12RHI
r.DDGI
int
-1
GI DDGI probe-field indirect diffuse (needs the world SDF it traces): -1=tier value, 0=off, 1=on SceneRenderer
r.DDGI.ProbesPerAxis
int
-1
DDGI probes along each grid axis (8..16, bounds-fit so more = denser): -1=tier value. Applied at startup; a change takes effect on the next launch SceneRenderer
r.DDGI.RaysPerProbe
int
-1
DDGI rays traced per probe per frame: -1=tier value (live buffer recreate, GI history reset) SceneRenderer
r.DepthPrepass
int
-1
Depth prepass before the G-buffer (eligible opaque static draws; the G-buffer then shades each visible pixel once): -1=tier value (High+), 0=off, 1=on SceneRenderer
r.DeviceProfile.Enable
int
1
Match the GPU against DeviceProfiles.ini and apply the winning profile's tier cap and cvars (1). 0 = no device profile. SceneRenderer
r.DeviceProfile.Force
string
""
Use this [DeviceProfile <Name>] whatever the GPU is (empty = match the device). SceneRenderer
r.DisplayGamma
float
2.2f
Accessibility: the gamma the player's panel is assumed to have, 1.8..2.6; the SDR image is re-encoded from 2.2 so a darker panel gets its shadows back SceneRenderer
r.DisplayLUT
string
""
OCIO-style display-transform .cube LUT for tonemap operator 5, indexed by the engine's log2 shaper (log2(x / 0.18) from -10 to +6.5 stops): empty=scene setting SceneRenderer
r.DLSS.Preset
int
0
DLSS Super Resolution network preset: 0 = driver default, 1 = J (least ghosting, more flicker), 2 = K (transformer, DLAA/Quality/Balanced default), 3 = L (Ultra Performance default, most expensive), 4 = M (Performance default) SceneRenderer
r.DLSS.RayReconstruction
int
0
DLSS Ray Reconstruction: while DLSS is the upscaler and the GPU supports it, one NVIDIA model denoises every ray-traced signal (RT reflections, RT/GI, RT shadows, RTAO, MegaLights) and upscales in the same pass; the engine's own denoisers are skipped. 0=off (engine denoisers), 1=on RHI
r.DoF.Bokeh
int
-1
DoF blur kernel: -1=scalability tier (Epic+ take the disk), 0=separable gaussian, 1=circular bokeh disk gather + fill SceneRenderer
r.DriverBlocklist.Prompt
int
1
Tell the player when their graphics driver is on the driver blocklist (1). 0 = log only. SceneRenderer
r.DynamicRes
int
-1
Dynamic resolution: -1=auto (the shipped runtime turns it on, the editor viewport leaves it off), 1=drive the render scale toward r.DynamicRes.TargetMs from the measured GPU frame time, 0=off (static scale) SceneRenderer
Dynamic resolution lower render-scale bound (0.25..1.0). 0.6 rather than 0.5: below about 60% the drop stops being something the upscaler can hide, and a visibly soft frame reads as a broken game rather than a busy one. SceneRenderer
r.DynamicRes.TargetMs
float
16.6f
Dynamic resolution GPU frame-time target in milliseconds SceneRenderer
r.Effects.CullDistanceScale
float
-1.0f
Multiplier on every emitter's authored cull distance: -1=tier value SceneRenderer
r.Effects.LogStats
int
0
Log particle submission, fill-budget and collision counters every N views (0 = off) SceneRenderer
r.Effects.MaxActiveEmitters
int
-1
Emitters submitted per view, nearest first: -1=tier value, 0=unlimited SceneRenderer
r.Effects.MaxParticleScale
float
-1.0f
Multiplier on every emitter's authored pool size: -1=tier value SceneRenderer
r.Effects.OverdrawBudget
float
-1.0f
Screens of particle fill admitted per view: -1=tier value, 0=unlimited SceneRenderer
r.Effects.SpawnRateScale
float
-1.0f
Multiplier on every emitter's authored spawn rate and burst: -1=tier value SceneRenderer
r.Foliage.DensityScale
float
1.0f
Foliage scatter density multiplier (scalability tier hook, rebuilds foliage on change) SceneTypes
Max grass draw distance in world units; blades shrink-fade over the last 25% SceneRenderer
r.Foliage.ImpostorDistance
float
90.0f
Distance at which foliage tree meshes hand off to camera-facing impostor cards SceneTypes
r.Foliage.LocalShadows
int
1
GPU grass casts into point/spot shadow atlas tiles whose frustum reaches the field (0 = off; also off when foliage shadow cascades resolve to 0) SceneRenderer
r.Foliage.ShadowCascades
int
-1
CSM cascades GPU grass casts into (0 = grass shadows off, -1 = scalability tier default; grass sits inside r.Foliage.GrassDistance so the near cascades cover it) SceneRenderer
r.FrameGeneration
int
0
Frame generation: 0=off 1=on (swapchain recreates on change) RHI
r.FrameGeneration.AutoHold
int
1
1 = under VSync, hold frame generation off while the scene already renders at the display refresh (generated frames could not be presented), 0 = engage whenever r.FrameGeneration is on RHI
r.FrameGeneration.AutoHold.EngageRatio
float
1.15f
Frame generation engages once the measured base frame interval exceeds the refresh period times this ratio RHI
DLSS-G dynamic multi frame generation: 1 = vary the multiplier to hold r.FrameGeneration.TargetFps (needs driver support), 0 = fixed multiplier RHI
r.FrameGeneration.EnableForProject
int
0
Project switch: 1 = this project offers frame generation (DLSS-G, FSR3, XeSS-FG, MetalFX). 0 = r.FrameGeneration is ignored and the player's options hide it RHI
r.FrameGeneration.Multiplier
int
2
Frame generation output multiplier, 2-6 (presented frames per rendered frame). Clamped to what the backend reports for this GPU: DLSS 4 MFG reaches 4x, DLSS 4.5 6x, FSR3 and MetalFX stay at 2x RHI
r.FrameGeneration.TargetFps
float
0.0f
Target presented frame rate for dynamic frame generation, 0 = the display refresh rate RHI
r.FSR1.Sharpness
float
0.25f
FSR1 spatial upscaler RCAS sharpening applied after EASU: 0 = off, 1 = full lobe RHI
r.GaussianSplat.MaxPerInstance
int
1 << 20
Most splats one Gaussian splat instance sorts and draws; the LOD chain steps coarser until a level fits (power of two padding, so 1M sorts as 1M) SceneRenderer
r.GI.AlphaTested
int
1
Alpha-masked (cutout) geometry in GI/RT. 1 (default) = coverage-aware: the SDF voxelizer dithers a masked draw's occupancy+albedo splat by the albedo texture's average alpha (a 30%-coverage fence registers ~30% of its voxels — occlusion AND bounce scale together), masks sparser than 0.15 skip the distance/albedo splat entirely, and TLAS instances are marked non-opaque so RT reflection/AO ray queries stochastically accept candidates with probability = coverage; 2 = same but very sparse masks (<0.15) still dither instead of skipping (A/B for the sparse verdict); 0 = legacy fully-opaque bias. Flipping forces the next SDF rebuild SceneRenderer
r.GI.AOWeight
float
1.0f
How strongly the screen-space AO term (GTAO/RTAO) occludes the DDGI indirect at composite (0=unoccluded probe fill, 1=fully AO-modulated) SceneRenderer
r.GI.AsyncCompute
int
1
Record the GI volume update (SDF build, radiance cascades, DDGI probe trace + integrate) on the async-compute lane: forked before the shadow depths, overlapping the raster-bound passes, joined before the first ALU-heavy pass (GTAO, RT sun shadow, MegaLights) or its first consumer (lighting), whichever comes first. 0 = inline, 1 = lane when r.RDG.AsyncCompute allows and the backend has a real second queue SceneRenderer
r.GI.AsyncCompute.MaxMarchMillions
float
32.0f
...and at most this: longer than the raster-bound window it overlaps, the lane makes the first ALU-heavy pass wait for it and the frame loses; 0 = no upper limit SceneRenderer
r.GI.AsyncCompute.MinMarchMillions
float
0.25f
The GI update opts into the async lane only while its per-frame probe march (probes x rays per probe x trace steps / radiance-cascade interval, in millions) is at least this: less work than this cannot hide the cross-queue sync it costs SceneRenderer
r.GI.AsyncGather
int
1
Run the SDF triangle gather (mesh iteration + soup-cache lookups + shell AABB filter + upload-buffer assembly) on an FTaskGraph worker instead of the render thread. 1=async — submit on the scroll/rebuild/cascade event frame, consume the finished soup when the job lands (the 8-cell scroll dead band absorbs the ~1-frame latency); 0=synchronous (A/B + debugging). The FIRST SDF build always gathers synchronously (startup/PIE/scene-switch correctness over latency) SceneRenderer
r.GI.Baked
int
1
Sample the scene's baked GI field (<scene>.mgi) on a tier with live DDGI off: 1 = when present, 0 = never (flat sky ambient, the old Low look) SceneRenderer
r.GI.BakedSdf.DetailTrace
int
1
Two-level near detail trace: when the baked composite is active, upload the resident per-mesh baked fields to a GPU atlas + instance table and, in the screen-probe gather and SDF reflections, march the nearby instance fields at their baked resolution BEFORE the 0.25 m global clipmap (per-ray instance list cull). Resolves thin features (wires, fences, mullions, grates) the clipmap fattens or drops. 1=on (default); 0=clipmap-only (A/B). Inert unless the baked composite ran this frame SceneRenderer
r.GI.BentNormal.Divisor
int
-1
Resolution divisor for the bent-normal filter (floored at r.AO.Divisor); below full res the GI composite upsamples it with a 4-tap depth bilateral: -1=tier value, 1=full res, 2=half SceneRenderer
r.GI.BentNormalAO
float
1.0f
Directional bent-normal cone occlusion of the GI gather. 0 = scalar AO multiply (the r.GI.AOWeight fallback), >0 = strength of the extra geometry-directed occlusion where the bent normal (average unoccluded dir from GTAO/RTAO) tilts away from the surface normal in creases/contacts. 1 = full SceneRenderer
r.GI.DDGI.ColdStartEase
int
1
With the static SDF no longer scrolling (baked composite), ease the residual DDGI probe cold-start — a freshly-exposed/scrolled probe seeds its irradiance+depth history from the average of its nearest CONVERGED (non-fresh) physical neighbours and eases in (hysteresis 0.75) instead of restarting from 0, so indirect light does not visibly fade in behind camera motion. 1=on (default); 0=legacy cold restart (A/B) SceneRenderer
r.GI.DDGI.ConvergedFrames
int
150
Frames with an unchanged light set, SDF and probe grid before the DDGI update is spread across frames (~2x the 0.96 hysteresis' 95 % convergence) SceneRenderer
r.GI.DDGI.ConvergedInterval
int
4
Once the DDGI inputs have been static for r.GI.DDGI.ConvergedFrames, each frame traces one probe in this many (each probe updates one frame in this many, at most 15); 1 = every probe every frame SceneRenderer
r.GI.DDGI.Hysteresis
float
-1.0f
Steady-state temporal blend weight of the DDGI probe atlas, in the perceptual space the blend runs in. Lower converges faster and traces noisier; -1 = the 0.96 default (~73 frames to 95% on its own). r.GI.DDGI.React is what shortens it while a change is actually happening SceneRenderer
r.GI.DDGI.React
float
-1.0f
How sharply a DDGI probe texel shortens its temporal blend when the radiance arriving at it actually changes (per unit relative luma delta above the noise floor of the per-texel change tracker). Without it the blend is a fixed time constant, so a light switching on takes as long to arrive as a 1% drift. 0 = fixed hysteresis (legacy A/B), -1 = tier default SceneRenderer
r.GI.DDGI.Relocate
int
1
Nudge each DDGI probe out of geometry along the SDF gradient before it traces: 1=on (default), 0=probes stay on the lattice (A/B — a probe sitting in a wall poisons its whole interpolation cell) SceneRenderer
Taps of the filtering GI composite (the full-resolution upsample into the HDR): 5 = 5x5, 3 = 3x3 a-trous over the same footprint SceneRenderer
r.GI.DenoiseHalfRes
int
1
1 = run the SVGF temporal and a-trous passes at half resolution and upsample in the filtering composite (r.GI.DenoiseIterations 2 only), 0 = full resolution (A/B) SceneRenderer
r.GI.DenoiseIterations
int
2
SVGF a-trous iteration count including the filtering composite (2 or 3). Default 2: measured pixel-equal to 3 on the DDGI room once the variance-guided kernel runs AFTER temporal accumulation, and it keeps the SVGF chain at legacy cost; 3 = the wider (1,2,4) kernel for content that needs it SceneRenderer
r.GI.EmissiveLights
int
1
Inject emissive meshes as analytic lights into the DDGI/radiance-cache light list so small/thin emitters that the 0.25 m voxel albedo quantizes away still contribute bounce light. 1=on (default), 0=voxel-emissive only (A/B) SceneRenderer
r.GI.EmissiveLights.RangeScale
float
3.0f
Attenuation range of an injected emissive light as a multiple of the mesh bounds radius (clamped to bounds+1 m minimum). SceneRenderer
r.GI.EmissiveLights.Scale
float
1.0f
Radiance scale on injected emissive-mesh lights (emissiveColor * emissiveStrength * scale). Tune down if large emitters over-brighten against their voxel-baked emissive term. SceneRenderer
r.GI.FarCascadeScale
int
4
Cell of the far GI cascade relative to the near one: 2 = a window twice the near one (64-cell grid at 0.25 m: 32 m), 4 = four times (64 m) at a coarser far field. The near window stays as it is; rays past it march the far field instead of returning sky SceneRenderer
r.GI.FinalGather
int
-1
GI final gather architecture: -1=tier value (Low/Medium=legacy, High/Epic=screen probes), 0=legacy per-pixel world-probe sampling (DdgiSample), 1=screen-space probe gather (16px tiles + adaptive 8px, SDF-traced, filtered between probes — no probe lattice) SceneRenderer
r.GI.FoliageMinHeight
float
1.0f
Shortest foliage (unscaled mesh height, metres) that enters the GI distance field. Grass clumps stay out: a field of them would fill the cells above the ground with solid SceneRenderer
r.GI.HWRTGather
int
-1
Hardware ray-traced screen-probe final gather — a ray-query variant of the screen-probe trace casts each gather ray at the resident scene TLAS instead of sphere-marching the SDF cascade, then shades the hit from the SAME radiance cache (incl. the r.GI.NearCascade fine cascade), falling back to the flat instance record where the cache is invalid and to sky x SkyScale on miss. Removes SDF quantization from the near-field gather. Importance sampling + MIS integrate + SVGF are unchanged (only the trace backend differs). The Epic and Cinematic rows enable Options.GiHwrtGather; needs the TLAS and falls back to the SDF screen-probe trace (logged once with the reason) when ray query is unavailable. -1=tier value (default), 0=SDF trace, 1=HWRT gather on any tier that runs the screen probes SceneRenderer
r.GI.ImportanceSample
int
1
Steer each screen probe's gather rays toward the previous frame's bright octahedral irradiance (the IrrHist guide, already SVGF/temporally smoothed) instead of the uniform octahedral texel set. Each anchor ray inverts the guide's luminance CDF (+ a uniform floor so newly-lit directions are never starved) at a stratified R2 position; the sampled direction + a uniform-relative MIS weight are stored per ray and the integrate pass reconstructs an unbiased cosine-weighted mean — concentrating rays where light is drops variance at equal ray count. Adaptive probes (unstable slots) always sample uniformly. 1=on (default); 0=uniform octahedral (A/B). Requires GiFinalGather; inert on the first frames until the guide history is valid SceneRenderer
r.GI.ImportanceSample.Floor
float
0.5f
Uniform floor fraction folded into the importance guide pdf (per-cell luminance floor = Floor x mean guide luminance). ~Floor/(1+Floor) of the probability mass stays uniform so freshly-lit directions the guide has not seen yet are still sampled and can enter the temporal history. 0 = pure luminance-proportional (starves new lights), higher = closer to uniform SceneRenderer
An optional FINER near radiance cascade for reflection HITS — a second RGBA16F 64^3 cache re-lighting the coarse SDF/albedo at half the near cell (r.GI.NearCascade.Cell, default 0.125 m) over a dim*cell (8 m) window centered on the camera. SdfReflect + RTReflections sample it first at the hit, so near mirror/glossy reflections read the lit surface at 2x the 0.25 m voxel resolution, falling back to the existing cascades outward. Epic-only (the preset row enables Options.GiNearCascade; this cvar gates it within Epic). 1=on (default at Epic); 0=off (A/B). ~2 MB at Epic, zero elsewhere SceneRenderer
r.GI.NearCascade.Cell
float
0.125f
The finer near radiance cascade's cell size in world units (default 0.125 m = half the 0.25 m near clipmap). The window extent is dim*cell (8 m at 64^3), so a smaller cell sharpens reflections over a smaller near volume. Clamped to [0.03125, 0.25] SceneRenderer
r.GI.NeuralCache
int
0
Neural irradiance cache: 1 = the GI buffer's indirect diffuse comes from a hash-grid + MLP trained online from one-bounce rays traced off the G-Buffer every frame (NRC-style), instead of the DDGI field / screen-probe gather; 0 = off SceneRenderer
r.GI.NeuralCache.Ema
float
0.9f
Decay of the exponential moving average of the weights the per-pixel query reads (0 = the raw weights; higher is steadier and slower to follow a change) SceneRenderer
r.GI.NeuralCache.GridLearningRate
float
0.02f
Adam learning rate of the neural cache's hash-grid features SceneRenderer
r.GI.NeuralCache.LearningRate
float
0.003f
Adam learning rate of the neural cache's MLP weights SceneRenderer
r.GI.NeuralCache.Samples
int
8192
Training rays a frame for the neural irradiance cache (1024..65536) SceneRenderer
r.GI.ProbeTraceSteps
int
-1
Sphere-march step cap for DDGI world-probe rays (far cascade adds +1/3): -1=tier value SceneRenderer
r.GI.RadianceBlend
float
0.5f
Fraction of the PREVIOUS radiance-cache bake a cadence bake keeps while the lighting is still converging. The cache is a step input to reflections and the screen-probe gather, so a bake that lands the whole change at once pops; keeping part of it turns the cadence into a geometric ramp. 0 = legacy hard replace, 0.5 (default) = halve every tick. The first bake, a geometry edit and the idle refresh always replace SceneRenderer
r.GI.RadianceDirty
int
1
Dirty-region radiance-cache rebake: 1 = light-hash gated (full bakes only during the post-change convergence window + a slow heartbeat; toroidal scrolls re-bake just the exposed slabs), 0 = legacy full-volume bake every GiRadianceInterval frames (A/B) SceneRenderer
r.GI.RadianceHeartbeatSlices
int
4
How many interleaved phases the idle radiance-cache refresh is split into. Outside the convergence window the cache drifts against the probe field; refreshing the whole volume in one dispatch is a hard discontinuity roughly once a second. Each slice re-bakes 1/N of the voxels on a diagonal phase pattern, N times as often, so a trilinear fetch always mixes refreshed and retained voxels. 1 = legacy single full refresh SceneRenderer
r.GI.RadianceInterval
int
-1
Frames between surface radiance-cache rebuilds: -1=tier value, 1=every frame SceneRenderer
r.GI.RayTerminateCache
int
1
A screen-probe ray with no NEAR hit inside a small fine-march budget terminates into the far-cascade world radiance cache — a bounded coarse march of the far SDF, shaded from the far radiance cascade (which already carries multibounce via the DDGI probe feedback) — instead of fine-marching the full clipmap chain. Bounds the fine-step cost AND gives cache-fed near-infinite bounce. The far cache is coarse: an accepted bias for the far/indirect tail. 1=on (default); 0=full-chain march (A/B). Only active when a far cascade exists (fitting scenes run a single cascade in either SDF mode; non-fitting baked scenes composite a far cascade too, so this is live on cooked content) SceneRenderer
r.GI.ReflectTraceSteps
int
-1
Sphere-march step cap for the SDF reflection leg (far cascade adds +2/5): -1=tier value SceneRenderer
r.GI.ScreenProbes.Budget
int
8192
Adaptive screen-probe budget on top of the per-16px-tile anchors (~8k anchors at 1080p): extra 8px probes allocated where a tile spans a depth/normal discontinuity; 0 disables adaptive subdivision SceneRenderer
r.GI.ScreenProbes.HalfRateConverged
int
1
Trace converged anchor probes on alternate frames in a tile checkerboard, carrying their history forward in between: 0 = every probe every frame SceneRenderer
r.GI.ScreenProbes.HalfRateMinFrames
int
8
History length (frames) an anchor probe needs before the half-rate update may rest it SceneRenderer
r.GI.ScreenProbes.IndirectLaunch
int
1
Launch the screen-probe trace/filter/guide/integrate passes from the live probe count (1) instead of the full probe capacity (0, the A/B reference) SceneRenderer
r.GI.ScreenProbes.Rays
int
-1
Rays traced per screen probe per frame (upper hemisphere of the octahedral set): -1=tier value, else 16..256 (rounded to the octahedral resolution) SceneRenderer
r.GI.ScreenProbes.TemporalAccum
int
1
Per-probe irradiance temporal accumulation: 1 = each anchor screen probe converges to a multi-frame average (kills the tile-coherent Monte-Carlo flicker the downstream full-res SVGF cannot remove — a static floor probe reaches a fixed value), 0 = fresh single-frame integrate (legacy A/B). Anchors only; adaptive probes always integrate fresh SceneRenderer
r.GI.ScreenProbes.TemporalAlphaMin
float
0.01f
Floor on a screen probe's per-frame blend weight — the accumulated average never fully freezes, so a slow real change still creeps in even at the history cap SceneRenderer
r.GI.ScreenProbes.TemporalMaxFrames
float
32.0f
Cap on a screen probe's effective history length (frames). A converged static probe averages this many frames; a radiance-reactive rate shortens it where the traced radiance actually changed so movers do not ghost SceneRenderer
r.GI.ScreenProbes.TemporalReact
float
5.0f
How sharply a screen probe drops its history when the traced radiance changes (per unit relative luma delta above r.GI.ScreenProbes.TemporalReactFloor). Higher = snappier moving-bleed response, lower = smoother SceneRenderer
r.GI.ScreenProbes.TemporalReactFloor
float
0.08f
Relative luma change |new - history| / (new + history) a screen probe must see before it shortens its history. Below it the change is treated as ray noise and averaged. At the old 0.2 a light had to change a probe by about 1.5x before the history reacted at all SceneRenderer
r.GI.ScreenProbes.TraceSteps
int
-1
Sphere-march step cap for screen-probe rays (far cascade adds +1/2): -1=tier value SceneRenderer
r.GI.ScreenTraces
int
1
Screen-space first trace leg of the screen-probe gather (the Lumen model): each probe ray FIRST marches the GBuffer depth buffer and shades a hit from the current frame's lit HDR scene color (pre-exposure divided out); only rays that miss, leave the screen or pass behind known geometry continue into the SDF cascade march / HWRT ray query from where the screen march ended. Gives real contact GI and makes dynamic/skinned geometry — present in the depth buffer, absent from the static SDF — occlude and bounce in the gather. 1=on (default at every tier the screen probes run); 0=world-only trace (A/B) SceneRenderer
r.GI.ScreenTraces.Steps
int
16
Linear depth-march step count of the screen-trace leg (plus a 5-iteration bisection refine on the first crossing). More steps catch thinner on-screen blockers at higher cost; clamped 4..64 SceneRenderer
r.GI.ScreenTraces.Thickness
float
0.3f
Depth-band thickness (world units) a screen-trace crossing must land inside to count as a hit; deeper crossings are treated as silhouette jumps and hand the ray to the world leg. Larger accepts more grazing hits (and more silhouette leaks) SceneRenderer
r.GI.SDFResolution
int
-1
World-SDF clipmap dimension (cubed): -1 = tier/Options value (Cinematic 128, else 64), else 32..256 (snapped even). Higher = a larger, higher-fidelity GI field at Cinematic cost. Applied live — the field, the radiance cache and the DDGI history rebuild over the following frames. SceneRenderer
r.GI.SkinnedSdf
int
1
Skinned meshes in the GI distance field: 1 = a posed character occludes and bounces light — the runtime voxelizer re-voxelizes the cells around each moved pose, the baked composite places one rigid field per bone; 0 = skinned meshes are left out of the field (the old behaviour) SceneRenderer
r.GI.SkinnedSdfInterval
int
2
Frames between skinned-mesh updates of the GI distance field (1 = every frame). A pose change waits at most this long to reach the field SceneRenderer
r.GI.SkyScale
float
1.0f
Scale on probe-miss sky radiance in the DDGI trace — art-directable control over how much sky colour fills shadows outdoors SceneRenderer
r.GI.SurfaceCache
int
1
GI surface cache (the Lumen mesh-card analogue): 0=off — ray hits shade the flat per-draw voxel albedo; 1=on — static opaque mesh instances are captured into an albedo/normal/emissive/depth card atlas, relit on a budget, and sampled at ray hits with the voxel field as the fallback. The atlas is allocated on the first resident card, so a scene with nothing to card pays nothing; every consumer is bit-identical to the voxel path when it is off SceneRenderer
r.GI.SurfaceCache.AtlasSize
int
-1
Card-atlas edge in texels (256..4096, snapped down to a power of two); -1 = tier value (1024 up to High, 2048 at Epic+). Three RGBA16F capture targets, one RGBA16F lit target and a D32F depth target are allocated at this size — 1024 costs about 36 MB, 2048 about 144 MB SceneRenderer
r.GI.SurfaceCache.CaptureBudget
int
8
Card slots re-rasterized per capture event (0 = no limit). This is what bounds the raster spike: a scene that invalidates every slot at once refills over several capture events instead of one, and every slot not yet captured simply has no card, which every consumer already handles SceneRenderer
r.GI.SurfaceCache.CaptureInterval
int
8
Minimum frames between two card captures. A capture re-rasterizes only the card slots whose content hash moved (resident draw, its transform, its material texture version, the atlas tiles it holds), so a still scene captures once and never again and one moving object costs one instance, not the whole set SceneRenderer
r.GI.SurfaceCache.CardResolution
int
-1
MAXIMUM texels per card edge (8..256, snapped down to a power of two); -1 = tier value (64 Low/Medium, 128 High, 256 Epic+). A card is sized from its own screen coverage between MinCardResolution and this; the ceiling is what stops one wall the camera stands against from consuming the whole atlas SceneRenderer
r.GI.SurfaceCache.CardsPerInstance
int
4
Cards one instance may take from its mesh's offline set (1..32). A mesh cooked with a card set covers a concave shape with several oriented boxes instead of one; each card costs a record and up to six atlas tiles, so this is the ceiling that stops one L-shaped building consuming the budget. 1 = the single fitted box the cache used before card sets SceneRenderer
r.GI.SurfaceCache.CoverageStats
int
0
Card-coverage census: 0 = off, N = sample every Nth pixel of the GBuffer and run the consumers' own card lookup over it, reporting the covered fraction through GetGiCardCoverage(). Debug only — it costs a dispatch and a GPU->CPU readback, and the readback is a few frames latent SceneRenderer
r.GI.SurfaceCache.Instances
int
64
Maximum mesh instances resident in the card atlas, clamped by the atlas tile count and by the shader's GI_CARD_MAX_INSTANCES ceiling of 256. The resident set is the highest-scoring draws by apparent size, so the cards follow the camera SceneRenderer
r.GI.SurfaceCache.LightSlices
int
4
Interleaved phases the card relight is spread over (1..16). Each frame relights 1/N of the atlas texels, so a moving light reaches the cache continuously instead of landing as one full-atlas step every N frames. Freshly captured tiles ignore the phase and relight whole, because their texels still hold the previous occupant's radiance SceneRenderer
r.GI.SurfaceCache.MinCardResolution
int
16
MINIMUM texels per card edge (8..64, snapped down to a power of two, clamped below CardResolution). Also the block edge the relight work list is built in, so lowering it makes that list finer and larger SceneRenderer
r.GI.SurfaceCache.TexelDensity
float
0.0625f
Card texels per screen pixel of the card's own world edge. A card is a GI bounce source, not a visible surface, so one texel per sixteen pixels is already finer than the probe grid that reads it — raise it only when card-lit detail is visibly blocky in a mirror SceneRenderer
r.GI.TemporalClampFloor
float
0.15f
SVGF temporal variance-clip floor as a fraction of the local mean. The clip half-width never drops below floor*mean, so locally-flat GI/reflection regions keep integrating the designed per-frame jitter instead of the history being crushed to the current frame (visible as shaking). 0 = legacy tight clip SceneRenderer
r.GI.TemporalMaxFrames
float
20.0f
SVGF temporal history cap for the GI chain (frames). It stacks on the screen-probe history (r.GI.ScreenProbes.TemporalMaxFrames), so a lighting change has to drain through both; the old fixed 32 on top of 64 there took over 160 frames to reach 90% of a lamp switch SceneRenderer
r.GI.TemporalMinHistory
float
4.0f
SVGF temporal floor on the effective history length for reprojected pixels — movers ease over at least this many frames instead of snapping to the current frame. Disocclusions still restart at 1 SceneRenderer
r.GI.TemporalVelocityScale
float
0.1f
SVGF temporal history shortening per pixel of reprojection speed (Neff = N / (1 + scale*velPix)). Lower = smoother motion response, higher = more reactive/raw. Was hardcoded 0.25 SceneRenderer
r.GI.TerrainFoliage
int
1
Terrain and foliage in the GI distance field: 1 = every field window takes the min with the CDLOD terrain's heightfield and with a capsule per tall foliage instance, so both occlude and bounce light; 0 = both are invisible to GI (the old behaviour) SceneRenderer
r.GI.TextureTint
int
1
Multiply the SDF voxelizer's flat per-draw albedo by the material's average albedo-texture color (linear, baked at texture cook / computed at load) so GI bounce, the radiance cache, SDF/RT reflections and screen-probe hits carry the texture's actual tint. 1=on (default), 0=flat legacy base color (A/B). Flipping forces the next SDF rebuild SceneRenderer
r.GI.Translucency
int
1
Translucency GI: 1=forward transparents (glass/water) sample the DDGI probe field per pixel as their ambient term when DDGI is active (default), 0=flat ambient (A/B) SceneRenderer
r.GiCascades
int
2
GI clipmap cascades: 2=near window + far cascade, 3=+a third, wider cascade; the far ones are only active when the scene outgrows cascade 0's window. Applies to BOTH SDF builds — the runtime voxelize scroll chain and the baked composite (which fills the coarse window from the same resident baked fields) SceneRenderer
r.GlobalIllumination.EnableForProject
int
0
Project switch: 1 = this project uses dynamic global illumination (DDGI, screen probes, the GI scene SDF, SSGI, the neural cache). 0 = no scalability tier, device profile or r.* cvar turns it on, and its targets and pipelines are never built RHI
r.GpuCull.ClassicDirect
int
-1
How the classic (non-meshlet) GBuffer path draws GPU-culled candidates: 0 = one indirect draw per candidate off the cull's argument buffer (GPU occlusion decides), 1 = directly from the CPU frustum test (the cull still runs for meshlets), -1 = the backend's RendererCapabilities::CheapPerDrawIndirect decides SceneRenderer
Name every GPU scope for capture tools (PIX / RenderDoc / Nsight / Xcode events): 0=off, 1=on. Independent of r.GpuTimings RHI
r.GpuScene.ClassicSlots
int
1
Give every non-instanced static draw a stable GPU-scene slot and have the classic G-Buffer, CSM and local-shadow vertex stages read its matrix from the GPU scene instead of the push block: 1 = on, 0 = push the model per draw (A/B) SceneRenderer
r.GpuScene.CompactRuns
int
1
1 = pack each live-MDI run's surviving instanced-group commands on the GPU and draw them with one DrawIndexedIndirectCount; 0 = the MultiDraw over every command of the run (A/B) SceneRenderer
r.GpuScene.DirtyUpload
int
1
Write only the changed ranges of the per-frame instance-transform and previous-model pools (each frame-in-flight buffer keeps a CPU copy of what it holds): 1=on, 0=write every buffer whole (A/B) SceneRenderer
r.GpuScene.GeometryPoolBudgetMB
int
0
VRAM the GPU scene's geometry pools may take in total, in MB; they hold a second copy of every bucketed mesh's vertices and indices. 0 = an eighth of the GPU's dedicated memory, clamped to 256..2048 MB SceneRenderer
r.GpuScene.GeometryPoolGrowth
int
1
GPU-scene geometry pools: 1 = add a pool when no existing one fits a mesh, sized for what the current instancing plan still has to admit, within r.GpuScene.GeometryPoolBudgetMB; 0 = one fixed 512K-vertex pool per index width and every mesh past it on per-group draws (A/B) SceneRenderer
r.GpuScene.PlanCache
int
1
Keep the G-Buffer plan's material/mesh decisions (bindless residency of the material maps, resolved graph pipelines) across frames per primitive and rebuild them only when the material snapshot, the mesh's meshlet state, a plan-wide setting or the bindless table changes: 1 = on, 0 = resolve every draw every frame (A/B) SceneRenderer
r.GpuScene.PrevBySlot
int
1
Keep a previous-frame matrix per GPU-scene slot and have the instanced velocity draw read it through each member's slot: 1 = on, 0 = repack the previous models in member order every frame (A/B) SceneRenderer
r.GpuScene.ShadowRuns
int
1
CSM casters through the GPU scene's buckets: 1 = opaque pool-resident instanced groups (lone draws included under r.GpuScene.SingleDraws) are culled per cascade on the GPU and each run of them draws with one DrawIndexedIndirectCount per cascade; 0 = one instanced draw per group per cascade with every member in it (A/B) SceneRenderer
r.GpuScene.SingleDraws
int
1
With GPU-driven culling on: 1 = every eligible static draw joins the GPU scene's instanced buckets, a lone draw as a group of one, and the groups are ordered by material so a whole bucket is one count-compacted indirect draw; 0 = only meshes repeated AutoInstancingMinCount times are grouped and lone draws push their model (A/B) SceneRenderer
r.GpuTimings
int
skGpuTimingsDefault
Record per-pass GPU timestamps: 0=off (a scope costs nothing and the per-frame resolve, which blocks on Vulkan, never runs), 1=on. Default on in debug/dev/debuggame, off in profile/release RHI
r.Grid.Spacing
float
0.0f
Viewport grid minor cell size in world units, overriding Options::GridSpacing. 0 = use the scene/editor value SceneRenderer
r.GTAO
int
-1
Ground-truth ambient occlusion slice: -1=tier value (Medium+ on, Low hard-off), 0=off, 1=on. Scene PostFX settings act within this. SceneRenderer
r.GTAO.Slices
int
-1
GTAO horizon slices per pixel: -1=tier value SceneRenderer
r.HairStrands
int
1
Draw hair strands (Hair Strands components) into the G-buffer: 0 = off, 1 = on SceneRenderer
r.HairStrands.Density
float
1.0f
Fraction of each groom's render strands drawn (0.05..1): the guides always simulate, fewer children are interpolated and drawn SceneRenderer
r.HDRMaxNits
int
1000
HDR output: peak luminance in nits used for the highlight rolloff. RHI
r.HDROutput
int
0
HDR display output: 0=SDR, 1=scRGB (RGBA16F linear), 2=HDR10 (RGB10A2 PQ), 3=auto (prefer scRGB). Falls back to SDR when the surface offers no HDR formats. RHI
r.HDRPaperWhiteNits
int
200
HDR output: luminance in nits that scene value 1.0 (SDR white) maps to. RHI
r.HeightFog
int
1
Exponential height fog from an ExponentialHeightFog actor: 0=off, 1=on SceneRenderer
r.HiZ.LogOcclusion
int
0
Read the GPU occlusion counters back and log, every 300 frames, how many classic draws and instances the Hi-Z pyramid rejected — the measure r.HiZ.Size is judged by. 0=off, 1=on SceneRenderer
r.HiZ.Size
int
256
Side of the Hi-Z max-depth pyramid the occlusion culls test against, in texels (128..1024, rounded up to a power of two; read when a renderer initializes) SceneRenderer
r.InstancingPlan.Cache
int
1
Reuse last frame's instancing groups (which draw joined which group, bucket order) while every draw's key, the moving-body and meshlet flags, the plan switches and the geometry-pool residency are unchanged: 1=on, 0=rebuild every frame SceneRenderer
r.Lighting.Classify
int
1
Let the GPU pick the deferred-lighting variant per frame from the G-Buffer: 1 = the variant without the extended lobes (anisotropy, clear coat, Substrate, hair, subsurface, cloth, foliage, eye, iridescence) whenever no pixel takes one; 0 = always the full shader; 2 = always the simple one (diagnostic: extended surfaces lose their lobes) SceneRenderer
r.LocalExposure
int
-1
Local exposure override: -1 = use the scene setting, 0 = off, 1 = on SceneRenderer
r.LOD.ErrorPixels
float
1.0f
Screen-space error budget, in pixels, a mesh's coarser LOD may show before the finer one takes over; a mesh whose simplifier recorded its error gets its own coverage boundaries from this, others keep r.LOD1/LOD2 coverage. 0 = always use the global boundaries SceneRenderer
r.LOD1Coverage
float
-1.0f
Screen-coverage threshold below which a static mesh drops to LOD1: -1=tier value SceneRenderer
r.LOD1TriangleRatio
float
0.35f
Target triangle ratio for generated LOD1 (fraction of the source mesh, 0..1) AssetSystem
r.LOD2Coverage
float
-1.0f
Screen-coverage threshold below which a static mesh drops to LOD2: -1=tier value SceneRenderer
r.LOD2TriangleRatio
float
0.12f
Target triangle ratio for generated LOD2 (fraction of the source mesh, 0..1) AssetSystem
r.LODCrossfadeTime
float
0.2f
Dithered LOD crossfade window in seconds: during a switch both levels draw with complementary screen-door masks; 0 = instant switch SceneRenderer
r.LogGpuScopes
int
0
Log per-scope GPU averages (all nesting depths, amortized per frame) every N frames (0=off) — per-pass GPU budget evidence GameHost
r.LogGpuTimings
int
0
Log resolved GPU pass timings every N frames (0=off) — headless perf profiling until Snowcap lands GameHost
r.LowLatency
int
0
Low latency: 0=off, 1=on, 2=on+boost. Drives NVIDIA Reflex, AMD Anti-Lag 2 or Intel XeLL, whichever this GPU runs (see r.LowLatency.Backend); a live DLSS-G or XeSS-FG keeps it on RHI
r.LowLatency.Backend
int
0
Low-latency runtime: 0=auto (whichever this GPU runs), 1=NVIDIA Reflex, 2=AMD Anti-Lag 2, 3=Intel XeLL; an unsupported pick falls back to auto RHI
r.Material.ClearCoat
int
1
Clear-coat second specular lobe (opaque deferred + forward translucent). 0=off (bit-identical to a coatless material), 1=on SceneRenderer
r.Material.MaxStaticPermutations
int
32
Most shader permutations one material's static switches may produce (2^switches). A graph past it fails to compile with the switch named. AssetSystem
r.MaterialMipBias.Auto
int
1
Bias every material texture sample by log2(render/output) while a temporal upscaler reconstructs the output grid (one level more for FSR/DLSS/XeSS, per their SDKs): 0=off, 1=on SceneRenderer
r.MaterialMipBias.Min
float
-2.0f
Floor of the automatic material mip bias: past -2 the texture cache thrashes for detail the resolve cannot hold SceneRenderer
r.MaterialMipBias.Offset
float
0.0f
Extra material texture LOD bias in mip levels, added on top of the automatic one: negative = sharper SceneRenderer
r.MaterialProxyReuse
int
1
1 = reuse a material's render snapshot while its state version is unchanged; 0 = copy every material every frame (A/B) SceneRenderer
r.MaxAnisotropy
float
-1.0f
Sampler max anisotropy ceiling for newly created samplers: -1=tier value SceneRenderer
r.MaxImportTextureSize
int
0
Default cap for model-import textures larger than this (power-of-two box filter); 0 = unlimited. A texture's own Max Size in its .mdfmeta overrides it AssetSystem
r.MegaLights
int
-1
MegaLights-style stochastic many-shadowed-light sampling for the local shadow-casters past the atlas budget (needs clustered lighting): -1=tier value (Epic+), 0=off, 1=on SceneRenderer
r.MegaLights.CheapMode
int
-1
Cheap screen-space fallback shadow for shadow-casting local lights denied an atlas tile while MegaLights is off (a short contact-style depth march toward the light): -1=tier value (High/Medium on), 0=off, 1=on SceneRenderer
Project switch: 1 = this project uses MegaLights stochastic many-light shadows. 0 = shadowed local lights past the atlas take the cheap screen-space march RHI
r.MegaLights.FireflyClamp
float
8.0f
MegaLights per-sample luminance clamp bounding one ray's contribution before the denoiser; higher admits brighter spikes SceneRenderer
r.MegaLights.Samples
int
-1
Local lights importance-sampled + shadow-traced per pixel per frame (1..4): -1=tier value SceneRenderer
r.Mesh.CompactIndices
int
1
Upload a mesh's indices at 16 bits when it addresses at most 65 536 vertices: 1 = on (half the index memory and bandwidth), 0 = always 32-bit Renderer
r.Mesh.DynamicPoolBudgetMB
int
0
VRAM the dynamic mesh pool may take in total, in MB; a mesh past it is created with private buffers instead. 0 = a quarter of the GPU's dedicated memory, clamped to 256..3072 MB Renderer
r.Mesh.UploadBudgetKB
int
4096
Bytes of dynamic-mesh geometry (GPUMesh::CreateLitPooled) the frame's single upload batch may carry, in KB; what does not fit stays queued and goes out first next frame. A 32-voxel chunk remesh is a few hundred KB, so the default carries well over a hundred a second at 60 fps. 0 = unlimited Renderer
r.Mesh.UploadMaxInFlight
int
3
Upload batches the dynamic mesh pool keeps in flight before it holds the queue: the RHI's async-upload slots are shared with texture streaming, and a request past them would degrade to a blocking submit Renderer
r.MeshDrawCommands.Cache
int
1
Persistent static draw commands per primitive (entity, submesh): built once and reused while mesh, material, transform and flags are unchanged, with the material snapshot revalidated instead of looked up and the LOD state reached without a lookup; LOD and visibility stay per frame. 1 = on, 0 = rebuild every command every frame (A/B) SceneRenderer
r.MeshDrawCommands.Stats
int
0
Log [MeshDrawCommands] built/reused/re-snapshotted static draw commands every N scenes: 0 = off SceneRenderer
r.Meshlet.AsyncLayouts
int
1
Build a mesh's meshlet page layout on a job worker the first time the pool is asked for it, drawing the mesh through the classic path until it is ready (1); 0 builds it inside the request on the render thread (A/B). SceneRenderer
r.Meshlet.ComputeFallback
int
0
Meshlet compute fallback for GPUs without mesh shaders: the batched material runs are culled per cluster by compute into one triangle list and drawn with one indexed-indirect draw each, the vertex stage pulling from the meshlet pool. 0 = off (no mesh shaders keeps the classic raster path), 1 = on where mesh shaders are missing, 2 = forced on every GPU (A/B against the mesh-shading path) SceneRenderer
r.Meshlet.Displacement
int
1
Nanite-style displacement: a static uber material with a Height Map and Displacement > 0 moves its meshlet-path vertices along their normals in the mesh stage: 0 = off, 1 = on SceneRenderer
r.Meshlet.GBufferBatch
int
1
Draw every static meshlet GBuffer draw that shares a material in ONE dispatch over a flattened task-group list (per-draw transforms, cluster ranges and visibility slots in a record buffer): 1 = on, 0 = one push + dispatch per draw SceneRenderer
Target size in KB of one meshlet streaming page (its vertex slice + remap + packed triangles; cluster records stay reserved). SceneRenderer
r.Meshlet.PageOpsPerFrame
int
40
Ceiling on meshlet page uploads/releases per frame. SceneRenderer
r.Meshlet.Paging
int
1
Cluster paging for the meshlet pool: keep only the pages the DAG cut can reach resident (1) or hold every mesh whole (0). SceneRenderer
r.Meshlet.PoolBudgetMB
int
0
VRAM the meshlet cluster pool may grow to, in MB: it starts at about 63 MB and doubles the arena a level ran short of whenever it is full of meshes still on screen, and never grows into the last tenth of the GPU's memory budget; 0 = a sixteenth of the GPU's dedicated memory, 64 to 1024 MB; 64 or less keeps the starting pool (A/B). SceneRenderer
r.Meshlet.ShadowBatch
int
1
Draw every static meshlet CSM caster of a cascade in ONE mesh-shading dispatch over a flattened task-group list (1, default) instead of one dispatch per caster per cascade (0). Skinned casters keep their own dispatch either way SceneRenderer
r.Meshlet.ShadowLodError
float
-1.0f
Cluster-DAG cut budget for meshlet CSM casters, in SHADOW-MAP TEXELS of allowed projected error (a cascade's projection is orthographic, so this does not vary with distance). -1 = use r.MeshletLodError; larger = coarser casters SceneRenderer
r.Meshlet.Shadows
int
-1
Render meshlet-eligible CSM casters (static + skinned) through the depth-only mesh-shading path with a per-cascade cluster-DAG LOD cut + per-cluster light-frustum culling: 0=off, 1=on, -1 = follow r.MeshletGBuffer. Requires VK_EXT_mesh_shader; casters fall back to the raster shadow path otherwise SceneRenderer
r.Meshlet.Skinned
int
-1
Route skeletal meshes through the mesh-shading GBuffer path (compute pre-skin into a per-instance vertex buffer + per-cluster bounds refit each frame): 0=off, 1=on, -1 = follow r.MeshletGBuffer. Requires VK_EXT_mesh_shader; skinned draws stay on the GPU-skinned raster path otherwise SceneRenderer
r.Meshlet.SwRaster
int
0
Software-rasterize sub-pixel meshlet clusters in compute into a visibility buffer, resolved back into the GBuffer by one screen pass for every table-resident material plus one per material that needs its own descriptor set, instead of emitting them as mesh workgroups: 0=off, 1=on. Needs the meshlet path (VK_EXT_mesh_shader / SM6.5) and both MeshletSwRaster + MeshletSwResolve shipped SceneRenderer
r.Meshlet.SwRaster.IndirectLaunch
int
1
Size the software rasterizer's depth and payload launches to the clusters the task stages appended (an indirect dispatch the GPU fills) instead of to every cluster they tested: 1 = indirect, 0 = the tested-count upper bound SceneRenderer
Per-DRAW ceiling on the software path: a draw whose whole bounding sphere projects wider than this keeps every cluster on hardware. Clusters never project larger than the draw holding them, so a big draw would buy a resolve screen pass for a handful of software pixels. 0 = no ceiling SceneRenderer
The hardware/software split: a surviving cluster whose projected screen diameter is at or under this many pixels goes to the compute rasterizer (its ~124 triangles are then at or under a pixel each). Clamped to 1..127 — the threshold rides 7 free bits of the meshlet push block's CullFlags SceneRenderer
r.MeshletGBuffer
int
-1
Mesh-shading GBuffer path for meshes with import-built cluster DAGs (screen-space-error LOD cut + per-meshlet frustum/cone/Hi-Z cull + residency streaming): 0=off, 1=on, -1 = scalability tier default (Epic+). Requires VK_EXT_mesh_shader; without it every draw keeps the raster path and the fallback reason is logged once SceneRenderer
r.MeshletIdleFrames
int
600
Evict resident clusters whose mesh has not drawn for this many frames, so a scene change or a walked-away region releases pool space and its mesh. 0 = keep until the budget forces it out SceneRenderer
r.MeshletLodError
float
1.0f
Cluster-DAG LOD cut threshold in screen pixels: a meshlet renders when its projected simplification error is under this while its parent's is not; 0 = full detail (leaves only) SceneRenderer
r.MeshletOcclusionCull
int
1
Per-meshlet Hi-Z occlusion in the task shader (two-phase, needs r.GpuDrivenCull occlusion feeding the pyramid): 0=off, 1=on SceneRenderer
r.MeshletPoolBudget
int
0
Resident cluster budget in meshlets; meshes past it evict the least-recently-drawn and stream back in on demand. 0 = the pool's full capacity SceneRenderer
r.MeshletResidencyStats
int
0
Log [MeshletResidency] admissions/evictions/rejections and resident bytes every N frames: 0=off SceneRenderer
r.Meshlets
int
-1
Build meshlet clusters at import for the mesh-shading path: -1=code default (ON when the GPU has mesh shaders), 0=off, 1=on AssetSystem
r.MeshletStats
int
0
Log [Meshlet] task-cull telemetry (tested/drawn/killed per test) every N frames: 0=off SceneRenderer
LOD bias in levels: every LOD boundary moves this many levels closer to the camera (coverage is scaled by the LOD1->LOD2 ratio per level), so coarser LODs come sooner while a close object keeps LOD0: -1 = use the active scalability tier, >=0 = explicit bias SceneRenderer
r.MeshRenderProxies
int
1
Mesh gather walks the persistent render proxies, rebuilt only on a structural ECS change (1, default), or looks every entity's components up again each view (0, for A/B) SceneRenderer
r.MeshStreaming
int
1
Stream static-mesh LOD residency: 1 = register LOD-carrying meshes with the streaming manager in a host that drives it (evict/restore per level, default), 0 = everything stays resident AssetSystem
r.MeshStreaming.PoolSizeMB
int
0
Streaming mesh residency budget in MB (0 = unlimited). The least-recently-drawn meshes coarsen first when the resident pool exceeds it. GameHost
r.Metal.CaptureFrame
int
0
Capture the next GPU frame to a .gputrace under <cwd>/Captures (open in Xcode). Needs MTL_CAPTURE_ENABLED=1. Resets to 0 after the capture MetalRHI
r.Metal.MeshShaders
int
0
Metal mesh shaders from Metal Shader Converter metallib blobs: 1=report SupportsMeshShaders when the device has mesh support, 0=vertex fallback. Experimental — Mac-unverified MetalRHI
r.Metal.MTL4
int
0
Metal 4 command model: 1=MTL4 command queue + per-slot command allocators + argument-table binding when the runtime supports it (macOS 26), 0=classic MTLCommandBuffer path. Mac-unverified dual path — see Documentation/ROADMAP.md §12.7 (was plan item 12) MetalRHI
r.MetalFX.Denoised
int
1
MetalFX resolve variant when the renderer supplies the GBuffer aux inputs (diffuse albedo / normals / roughness): 1=MTLFXTemporalDenoisedScaler when the device supports it (denoise + upscale in one pass — the RT-effects path), 0=always the plain MTLFXTemporalScaler MetalRHI
r.MetalFX.Subsume
int
0
When the MetalFX denoised resolve runs, let it own denoising: skip the per-effect stochastic temporal filters (RTAO/RT-shadow accumulation, MegaLights denoise, GI SVGF) and feed the raw signal. 0=keep the engine's filters (default), 1=hand denoising to MetalFX SceneRenderer
r.MinScreenCoverage
float
-1.0f
Small-object cull: a static mesh whose world sphere covers less than this fraction of the vertical FOV is dropped from every pass: -1=tier value, 0=off SceneRenderer
r.MotionBlurObject
int
1
Per-object motion blur: 1=sample the velocity prepass in the MB pass when available (default), 0=camera reprojection only SceneRenderer
r.OcclusionCull
int
-1
Hi-Z occlusion cull of main-view static meshes against last frame's depth pyramid: -1=tier value, 0=off, 1=on SceneRenderer
r.OIT
int
0
Weighted-blended order-independent transparency for the standard translucent path (water keeps the sorted pass). 0=off (sorted alpha), 1=on. SceneRenderer
Minimum draw count before parallel recording engages: -1=code default (64), N=override (0 forces it on tiny scenes — debug) SceneRenderer
r.ParallelSubmit
int
1
Parallel static-mesh visibility/LOD resolve at EndScene (bounds + frustum + coverage fan out to workers, LOD hysteresis stays serial in submit order): 0=legacy per-submit path, 1=on SceneRenderer
r.PathTracer.Denoise
int
1
Edge-avoiding a-trous denoiser over the path-tracer accumulation: 1=on (default — a restarted accumulation is 1 spp and reads as noise without it), 0=off (raw reference, byte-identical, for comparisons). SceneRenderer
r.PathTracer.Enable
int
0
Progressive path-traced reference render: 0=off, 1=on. Forces the tracer on regardless of the editor view mode (offline/screenshot capture); the 'Path Tracing' view mode enables it in the editor without this flag. Session only: no config file applies it. Transient.SceneRenderer
r.PathTracer.FireflyClamp
float
256.0f
Per-sample radiance clamp before accumulation, in exposed units (the clamp scales by 1/pre-exposure like every other radiance ceiling); 0 = unbounded SceneRenderer
r.PathTracer.FurnaceSky
float
0.0f
White-furnace check: > 0 replaces the scene's sky with a uniform one of this radiance and drops the sun and the local lights, so a convex object of albedo a must converge to a times it and never above it (energy conservation); 0 = the scene's own lighting SceneRenderer
r.PathTracer.MaxBounces
int
8
Maximum path bounces per camera ray (1..32). More bounces resolve deeper indirect light. SceneRenderer
r.PathTracer.MaxSamples
int
4096
Samples per pixel after which accumulation stops and the converged image is held (0 = never stop). Without a limit the tracer kept spending the GPU on an image that had stopped changing. SceneRenderer
r.PathTracer.SamplesPerFrame
int
1
Camera path samples accumulated per pixel each frame (1..16). Higher converges faster but costs more per frame. SceneRenderer
r.PathTracer.Textures
int
1
Path tracer hits sample the material's albedo, normal and metallic-roughness maps at the hit UV (needs the bindless table and 64-bit shader integers): 1 = on, 0 = each instance's average colour, vertex normal and scalar roughness/metallic, the old flat shading (A/B) SceneRenderer
r.Physics.AutoCollider
int
1
Give a freshly placed mesh the collider its mesh asks for — the authored .mmeshmeta setup, else a primitive fitted to the mesh bounds. 0 places meshes with no collider at all Game
r.PipelineCacheSaveInterval
int
60
Seconds of pipeline-creation quiet before the VkPipelineCache is flushed to disk mid-session (crash-safe persistence): 0 = only on clean shutdown VulkanRHI
r.PointCloud.ComputeRaster
int
1
Rasterise the scan layer in compute (one thread a point, GPU LOD, a 64-bit atomic min per pixel) where the device has 64-bit buffer atomics: 0 = always the splat draw SceneRenderer
r.PointCloud.Density
float
1.0f
Player scan density, 0.5..1.5: below 1 the renderer draws a stable thinned subset, above 1 the scan loop fires more rays per shot SceneTypes
r.PointCloud.EDL
int
1
Eye-dome lighting on the scan layer: darkens a splat by how far its neighbours sit in front of it, so edges and creases read without any light SceneRenderer
r.PointCloud.EDLRadius
float
1.4f
Eye-dome lighting sample radius in layer pixels SceneRenderer
r.PointCloud.EDLStrength
float
0.7f
Eye-dome lighting strength (Boucheny scale; 1 is a visible edge, 0 off) SceneRenderer
r.PointCloud.Ephemeral.Capacity
int
-1
Points the decaying half of a scanned cloud may hold before the oldest is evicted; -1 = the cloud's own value, 0 = drop dynamic hits entirely Game
r.PointCloud.Ephemeral.Lifetime
int
-1
How long an ephemeral point lives, in ephemeral ticks (60/s); -1 = the cloud's own value Game
r.PointCloud.FlashLimit
int
1
Limit how fast the scan layer's mean luminance may rise (photosensitivity); 0 composites every reveal at once SceneRenderer
r.PointCloud.FlashRiseSeconds
float
0.15f
Shortest time over which the scan layer may rise by r.PointCloud.FlashStep; never below 0.1 s, the minimum a reveal may take SceneRenderer
r.PointCloud.FlashStep
float
0.1f
Largest rise of the scan layer's mean linear luminance (0..1 of the screen at full white) allowed per r.PointCloud.FlashRiseSeconds SceneRenderer
r.PointCloud.GpuStore
int
0
Keep the persistent scan cloud in a GPU hash table (insert, dedup and scan-memory fade on the GPU, drawn by the compute rasteriser) instead of the CPU accumulator chunks; needs 64-bit buffer atomics. A save reads the store back and writes it with the CPU chunks. Off by default SceneRenderer
r.PointCloud.GpuStoreCull
int
1
GPU point store: compact the live, in-view slots and rasterise only those through an indirect launch, instead of walking every slot of the table. 0 = walk the whole table. SceneRenderer
r.PointCloud.GrowSplats
int
0
Grow Gaussian splats from the accumulated scan on every point cloud (project option, off by default); a cloud's own Grow Splats turns them on for that cloud alone SceneRenderer
r.PointCloud.HoleFill
int
1
Fill a scan-layer pixel no splat covered when its neighbours on opposite sides were covered on two axes (a gap inside a surface, never its outline) SceneRenderer
r.PointCloud.LodDistance
float
24.0f
Compute rasteriser LOD: past this view distance (m) a page keeps only the (distance ratio)^2 prefix of its rank-ordered points; 0 keeps every point SceneRenderer
r.PointCloud.LodMinFraction
float
0.15f
Compute rasteriser LOD: the smallest share of a page's points kept at any distance (0.01..1) SceneRenderer
r.PointCloud.MaxPointSize
float
12.0f
Largest splat diameter in output pixels whatever the component asks for; the scan's photosensitivity ceiling SceneRenderer
r.PointCloud.Palette
int
0
Scan palette: 0 authored, 1 red-green safe, 2 blue-yellow safe, 3 monochrome with a splat shape per material family SceneRenderer
r.PointCloud.SizeScale
float
1.0f
Player scale on every splat's size, 0.75..2; still capped by r.PointCloud.MaxPointSize SceneRenderer
r.PointCloud.Splats
int
1
Draw the Gaussian splats grown from scans on clouds with Grow Splats on: 0 = points only SceneRenderer
r.PointCloud.Splats.Max
int
65536
Most splats one cloud draws a frame (the nearest are kept); the back-to-front sort runs on the CPU each frame SceneRenderer
r.PointCloud.StreamMode
int
0
Streamer mode: splats x1.75, density x0.75, no shrink-on-fade, and half the flash limiter's rise step, so a compressed video stream keeps the scan readable SceneTypes
r.PostProcessMaterial
string
""
Path of a PostProcess-domain .mat material evaluated as a fullscreen pass after tonemapping (empty = the scene/volume setting). SceneRenderer
r.PreExposure
int
1
Pre-expose scene color: HDR targets store radiance scaled by the previous frame's exposure (clamped), tonemap divides it back out — keeps RGBA16F in range when physical light intensities (a 100k-lux sun) exist: 0=off, 1=on SceneRenderer
r.PSOCache.Prewarm
int
1
Prewarm pipelines from the bundled PSO cache at game startup (populates the driver and backend pipeline caches before the first frame) RHI
r.PSOCache.Record
int
-1
Record created pipelines into <project>/Saved/PsoCache/PsoCache.mdfb: -1=auto (project open, non-shipping), 0=off, 1=on RHI
r.PSOPrecache.AsyncGraph
int
1
Compile material-graph pipelines on job workers: 1 = the draw keeps the material's uber (fallback) pipeline until its own PSO is built, 0 = compile synchronously on first use (the old first-sight hitch) SceneRenderer
r.Quality
int
-1
Scalability preset: -1=code default, 0=Low, 1=Medium, 2=High, 3=Epic, 4=Cinematic (flips the render-feature Options bundle + the FScalabilityTiers numeric row) SceneRenderer
r.RayTracing.EnableForProject
int
0
Project switch: 1 = this project uses hardware ray tracing (RT reflections, RT shadows, RTAO, the HWRT GI gather, the path tracer, DLSS Ray Reconstruction). 0 = no TLAS is built and no RT pipeline compiles RHI
r.RDG.AsyncCompute
int
1
Global async-compute switch: 0 = everything inline; 1 = passes and features that opt in (r.GI.AsyncCompute, ...) run on the async-compute lane where the backend has a real second queue (D3D12, Vulkan), forked as early and joined as late as their dependencies allow, and never beside an ALU-heavy pass; 2 = additionally force every compute-shaped graph pass onto the lane (testing; read when a graph compiles). D3D11 and Metal-without-lane record inline whatever this says RHI
r.RDG.BatchBarriers
int
1
Issue each render-graph pass's image transitions as one barrier call (D3D12 one ResourceBarrier, Vulkan one vkCmdPipelineBarrier2, split where an image repeats) instead of one call per resource: 0=off, 1=on RHI
r.RDG.PlacedAliasing
int
0
Back render-graph transients with placed images packed into shared heaps, so resources of different formats and sizes with disjoint lifetimes share memory (D3D12 and Vulkan; other backends keep the exact-match alias groups): 0=off, 1=on RHI
r.RDG.PostChain
int
1
Record the head and tail of the post chain on the frame graph: the reactive masks, the temporal upscaler hand-off, the post-process material and the Final blit, with their barriers derived from declared reads and writes. 0 = the old path, each pass outside the graph with hand-placed transitions. Takes effect at the next graph rebuild SceneRenderer
r.RDG.SplitBarriers
int
0
Split render-graph transitions of transients: begin right after the last pass that used the resource, end right before the next, so the GPU retires the transition behind the passes in between (D3D12 BEGIN_ONLY/END_ONLY, Vulkan events; other backends issue the whole transition at the end): 0=off, 1=on RHI
r.RDG.TransientViewTargets
int
1
Allocate the frame-local post targets (depth-of-field CoC, motion-blur velocity and tile maps, the bloom chain and, with r.RDG.PostChain, the reactive-mask pair) as frame-graph transients that alias with other scratch of the same shape, instead of persistent per-view images. 0 = persistent images imported into the graph. Takes effect at the next graph rebuild SceneRenderer
r.ReflectionProbes.Bake
int
1
Bake captured reflection probes to the DerivedDataCache and reload them on scene open instead of re-capturing (mbt cook packages them so shipped games skip runtime capture). 1=on (default), 0=always capture at runtime SceneRenderer
r.Reflections.Continuation
int
1
Screen-trace-first reflections: 1=one ray per pixel — screen march, then the SAME ray continues into the SDF/RT world trace where the screen leg is inconclusive (default), 0=legacy independent traces blended by confidence (A/B) SceneRenderer
r.Reflections.MirrorReproject
float
0.0f
Roughness ceiling for mirrored-point temporal reprojection: at or below it a screen-leg hit fetches its reflection history from where the REFLECTED point was last frame instead of where the surface was, which is what the reflected image actually tracks. OFF by default: the history's depth/normal validity is keyed to the SURFACE, so a mirrored colour fetch is validated against the wrong pixel, accumulation never converges and the per-frame trace noise shows through as speckle — worse than the lag it removes. Keyed validity needs a reflection hit-distance channel in the moments history. 0 = surface reprojection only SceneRenderer
Confidence the SDF world leg reports at mirror roughness, relative to the screen leg (ramps to 1 at the roughness cutoff). The world leg returns cell-quantised cache radiance where the screen leg returns real scene colour; below 1 the resolve leans back on env specular across the handover instead of cutting to a blurrier source at full strength. 1 = legacy equal confidence SceneRenderer
r.Renderer.DeferredRelease
int
1
Create, destroy and resize scene views, resize the primary view's output and reallocate the volumetric fog grid and cloud targets without draining the GPU: what they drop goes through the backends' deferred-delete queues (or SubmitDeferredRelease) once the frames that read it have retired. 1=on, 0=WaitIdle first (A/B) SceneRenderer
r.RenderScale
float
-1.0f
Internal render resolution scale (0.25..1.0): -1=tier value (upscaler policy may also drive it) SceneRenderer
r.RT.BLASCompaction
int
1
Copy each freshly built BLAS into a right-sized allocation using the driver's post-build compacted size: 0=off 1=on RHI
r.RT.BLASCompaction.Budget
int
8
Maximum BLAS compaction copies per frame — each is a separate GPU submit, so this is what keeps a build burst from hitching RHI
r.RT.BLASCompaction.MinSaving
int
5
Skip the copy when the compacted structure would reclaim less than this percentage of the built size RHI
r.RT.Foliage
int
1
Put GPU-instanced foliage clumps near the camera in the scene TLAS (one instance per clump, sharing the clump mesh's BLAS), so RT shadows, reflections, AO and the hardware GI gather see grass: 0 = leave it out, 1 = include SceneRenderer
r.RT.Foliage.Distance
float
40.0f
World radius around the camera inside which foliage clumps join the TLAS SceneRenderer
r.RT.Foliage.MaxInstances
int
8192
Most foliage clumps placed in the TLAS per frame SceneRenderer
r.RT.InFrameBuilds
int
1
Record BLAS/TLAS builds made while a frame records into that frame's command list instead of a single-time submit and fence wait: 1=on (those builds are not compacted), 0=synchronous builds with compaction RHI
r.RT.Terrain
int
1
Put CDLOD terrain in the scene TLAS as tiles of real triangles generated from the height texture (up to 256 quads a side, one updatable BLAS per 64x64 tile, refit where a sculpt touched): 0 = leave it out, so RT shadows, reflections, AO and the hardware GI gather see no ground, 1 = include SceneRenderer
r.RT.Translucent
int
1
Put alpha-blended geometry in the scene TLAS, masked so only reflection rays (and shadow rays under r.RT.TranslucentShadows) see it, accepted stochastically by its opacity: 0 = leave it out (the old behaviour), 1 = include SceneRenderer
r.RT.TranslucentShadows
int
1
Alpha-blended shadow casters occlude ray-traced shadow rays by their opacity (needs r.RT.Translucent): 0 = off, 1 = on SceneRenderer
r.RTAO
int
-1
Hardware ray-traced ambient occlusion instead of GTAO (needs ray query; implies the ray scene): -1=tier value, 0=off, 1=on SceneRenderer
r.RTAO.Calibration
float
1.32f
Gain applied to ray-traced occlusion so its mean matches the screen-space integrator this pass replaces behind the AO slot. GTAO's raised horizon blocks the whole arc beneath it where a ray counts only geometry it meets, so a true trace reports less; the art is tuned on GTAO, and a gain moves the mean at constant signal-to-noise where a longer ray would not. Fitted on the gi-spatial-noise scene; 1 = raw traced occlusion SceneRenderer
r.RTAO.Radius
float
-1.0f
World-space occlusion ray length for RTAO, overriding the shared ssaoRadius setting (-1 = that setting times r.RTAO.RadiusScale). The two implementations behind the AO slot read that scalar differently — GTAO as a screen march it clamps to a 3-pixel floor, RTAO as a hard world TMax — so the shared 0.5 default is a real half-metre ray here and occludes a twentieth of what GTAO does; the fitted scale puts the two within a twentieth of each other and this knob overrides the product outright SceneRenderer
r.RTAO.RadiusScale
float
4.2f
What the shared ssaoRadius setting is multiplied by before RTAO uses it as a world-space ray length. It exists because the two integrators behind the AO slot read that scalar differently, so the tier boundary that swaps them would otherwise change scene brightness. Reach buys mean occlusion at a steep price in variance — two stochastic rays a pixel cannot support a long one — so this stays short enough for gi-static-flicker and r.RTAO.Calibration closes the rest. r.RTAO.Radius overrides the product outright SceneRenderer
r.RTAO.Rays
int
-1
RT AO occlusion rays per pixel: -1=tier value SceneRenderer
r.RTAO.TemporalAlpha
float
0.96f
History weight of the RTAO temporal accumulation on a still pixel (0.96 = ~25 frames). Two rays a frame need far more than the ten frames 0.9 gave them, and the short window was what left blurred noise crawling on a still camera: widening it took the crawling-pixel count at Epic from 4.89% to 3.09% and at Cinematic from 5.95% to 2.11%, which is the headroom the AO calibration gain spends. Safe by construction because motion still opens the weight toward 0.5 and depth rejection still drops a disoccluded history, so only a STILL pixel integrates this long SceneRenderer
r.RTAO.TemporalClamp
float
4.0f
Width of the RTAO history clamp box as a multiple of the shared default. The box is centred on THIS frame's two-ray AO, whose centre jumps about as far as the box is wide, so the default clamp drags the history to a new edge every frame and the average never forms SceneRenderer
r.RTReflections
int
-1
Hardware ray-traced reflections through the scene TLAS instead of the SSR ray march (needs ray query; implies the ray scene): -1=tier value, 0=off, 1=on SceneRenderer
r.RTReflections.HitLighting
int
1
RT reflection hit shading: 0=flat per-instance records (legacy), 1=GI radiance cache with near-hit blend toward the records (default; falls back to the records where the cache is absent/unbaked), 2=pure cache (A/B, no near blend) SceneRenderer
r.RTReflections.Pipeline
int
0
Trace the RT reflection world leg through a real ray-tracing pipeline (raygen + miss + a per-material closest-hit table) instead of the inline ray query: 1=on where the backend and device allow it, 0=inline pass (default). Read once when the post graph is built, because the pass it adds changes the trace target's usage flags. Off by default while the legacy-blend interaction below is open — see mowoengine.com/docs/rendering/ray-tracing/ SceneRenderer
r.RTReflections.RoughnessCutoff
float
-1.0f
RT reflections roughness cutoff — rougher surfaces fall back to SDF/env: -1=tier value SceneRenderer
r.RTReflections.SecondBounce
int
1
Let a smooth metallic reflection HIT trace one more reflection ray, shaded by whatever material that ray lands on (pipeline path only — an inline query cannot recurse). 1=on (default), 0=one bounce SceneRenderer
r.RTScene
int
0
Maintain BLAS/TLAS over static scene geometry for ray-traced passes: 0=off, 1=on SceneRenderer
r.RTScene.BlasBudget
int
8
New BLAS builds per frame (each is a synchronous single-time submit) — residency amortizes across frames, the resident set itself is unbounded SceneRenderer
r.RTShadows
int
-1
Ray-traced sun shadows through the scene TLAS on top of CSM/VSM (implies r.RTScene): -1=scalability tier (Cinematic), 0=off, 1=on SceneRenderer
r.RTShadows.Samples
int
-1
RT sun shadow cone samples per pixel (jittered in the sun disc, temporally accumulated): -1=tier value, else 1..8 SceneRenderer
r.RTShadows.Spatial
int
1
Depth-aware separable blur over the temporally accumulated RT sun shadow before the lighting reads it: 1 = on, 0 = the accumulation alone SceneRenderer
r.Shadow.BlockerSamples
int
-1
PCSS blocker-search taps per pixel: -1=tier value SceneRenderer
r.Shadow.Cascades
int
-1
Directional shadow cascades rendered (1..4): -1=tier value SceneRenderer
r.Shadow.CsmStaticCache
int
1
Static CSM cache: 1 = each cascade keeps its static casters in a second atlas and re-renders them only when the cascade's matrix or a static caster it reaches changes; a frame restores the cascade from it and draws only skinned, moving and WPO casters, terrain and foliage. 0 = every caster every frame SceneRenderer
r.Shadow.CsmStaticCache.MaxRestoreFraction
float
0.5f
A cached cascade whose restore and dynamic layer both cover more than this fraction of its tile (terrain, foliage, a skinned crowd) draws every caster into its own cleared tile instead and keeps the cache for later: a full-tile depth copy from the pixel shader costs more GPU time than the static casters it saves, which is why UE caches only cascades movables do not cover SceneRenderer
r.Shadow.CsmStaticCache.Scroll
int
1
Static CSM cache while the camera moves: 1 = a cascade the camera slid by whole texels restores its cached static layer at that offset and draws only the static casters of the uncovered strips (re-anchoring past an eighth of the tile); 0 = a moving cascade redraws every caster SceneRenderer
r.Shadow.CsmStaticCache.Scroll.MinCascade
int
2
First cascade a sliding camera scrolls instead of redrawing. A scroll is a full-tile shifted depth copy from the pixel shader; on the near cascades, which slide almost every frame of a moving camera, it cost more GPU time than the static casters it saved (csm-static-cache: 1.74 against 0.40 ms of Shadow scope), so they redraw and only the far cascades scroll SceneRenderer
r.Shadow.FilterSamples
int
-1
PCSS penumbra filter taps per pixel: -1=tier value SceneRenderer
r.Shadow.Local.Virtual
int
-1
Local-light shadows as paged virtual shadow maps: 1 = every shadow view a sparse map of up to r.Shadow.Local.VirtualMaxPages^2 pages of 128 texels, only the pages the camera can reach resident in the atlas and kept across frames until their light or casters change; 0 = one packed atlas tile per view; -1 = the scalability tier (High and up page, Medium and below use the atlas) SceneRenderer
r.Shadow.Local.Virtual.DepthMarks
int
1
Local virtual shadow pages are mapped only where a visible receiver in the scene depth projects into them (read back a few frames late; while the camera or a light moves the camera-frustum reach decides): 1 = on, 0 = every page the camera frustum can reach SceneRenderer
r.Shadow.Local.Virtual.MarkStride
int
4
Screen-pixel stride of the local virtual shadow depth-marking pass (1-16); a page is 128 shadow texels, so a coarse stride still finds every receiver of any size that matters SceneRenderer
r.Shadow.Local.Virtual.TwoLayer
int
1
Two-layer local virtual shadow pages: 1 = a second atlas keeps each resident page's static depth, so a page under a moving dynamic caster (skinned mesh, moving body, animated foliage) copies its static depth back and redraws only the dynamic casters; 0 = such a page redraws every caster under it SceneRenderer
r.Shadow.Local.VirtualMaxPages
int
16
Pages per side of the largest local virtual shadow map (16 = 2048 texels); when the visible pages outgrow the atlas the largest maps give up a level first SceneRenderer
r.Shadow.LocalCache
int
1
Cached local shadow-atlas tiles: 1=re-render only tiles whose light or intersecting caster set changed (static tiles cost zero draws), 0=legacy full atlas clear + re-render every frame SceneRenderer
r.Shadow.LocalMinTile
int
-1
Smallest local shadow atlas tile in px (a light that cannot get one goes unshadowed): -1=tier value SceneRenderer
r.Shadow.LocalTileSize
int
-1
Largest local shadow atlas tile in px (the most important light gets one): -1=tier value SceneRenderer
r.Shadow.MaxDistance
float
150.0f
Directional (CSM) shadow range in world units; the sun shadow fades to unshadowed over the last 15% of it. A scene's World Settings shadow max distance (> 0) overrides this SceneRenderer
r.Shadow.MaxLocalViews
int
-1
Local shadow atlas view budget (1 view per shadowed spot/rect, 6 per point): -1=tier value SceneRenderer
r.Shadow.MaxPenumbraTexels
float
-1.0f
PCSS penumbra ceiling in shadow-map texels: -1=tier value SceneRenderer
SDF far sun shadows: past r.Shadow.MaxDistance the sun cone-traces the GI global SDF for soft distant occlusion instead of going unshadowed (needs the SDF, Medium+): -1=tier value, 0=off, 1=on SceneRenderer
r.Shadow.SdfFarSteps
int
-1
SDF far sun shadow trace step cap: -1=tier value, else 8..128 SceneRenderer
r.Shadow.Soft
int
-1
Soft shadows: 0=fixed PCF kernel, 1=PCSS (blocker search + variable-radius filter, penumbra from the light's source size): -1=tier value (High+) SceneRenderer
r.Shadow.StableFit
int
1
CSM cascade fit: 1=constant-radius world-sphere extent + texel-snapped ortho origin (world-locked, no edge crawl under camera motion), 0=legacy tight per-frame light-space AABB with no snap (extent pumps + grid crawls = shadow-edge swim) SceneRenderer
r.Shadow.Translucent
int
1
Alpha-blended meshes with Cast Shadows cast a partial shadow into the cascades and the local atlas: each texel is kept with the material's opacity as its probability (dithered, then softened by the shadow filter), so a 30%-opaque pane casts a 30% shadow instead of none or a black one. 0 = translucent meshes cast no raster shadow SceneRenderer
r.Sharpness
int
-1
Post-AA CAS sharpening override in percent: -1=scene setting, 0=off, 1-100=strength SceneRenderer
r.Sky.CoupleAmbient
int
1
L3 sky<->ambient coupling: 1=the GI probe-miss sky is derived from the sky actually on screen, 0=legacy flat ambientColor*ambientIntensity (the pre-fix 4-17x mismatch — A/B only) SceneRenderer
r.Sky.MoonIntensity
float
1.0f
Moon disc intensity at night (0 = off); rides anti-sun with a crescent phase from the sun/moon geometry SceneRenderer
r.Sky.Rotation
float
0.0f
Degrees of extra sky yaw about world up, ADDED to the sky light's authored Sky Rotation. Turns the cubemap sky and every lobe derived from it (irradiance, prefilter, forward sky miss, reflection captures) together; a procedural atmosphere ignores it SceneRenderer
r.Sky.Stars
float
1.0f
Procedural star field intensity at night (0 = off); fades in below the horizon, fully visible once the sun is 12 degrees under SceneRenderer
r.SkyAtmosphere.AerialPerspective
int
1
Tint distant geometry with the atmosphere's in-scattering and transmittance (the froxel volume the sky LUTs feed): 0=off, 1=on SceneRenderer
r.SkyAtmosphere.Translucency
int
1
Sky atmosphere on translucents and particles: 1=they take the aerial perspective and height fog the atmosphere composite gives the opaque pixel behind them (default), 0=none (A/B) SceneRenderer
r.SkyIBL.CrossfadeSeconds
float
1.0f
Crossfade between sky-IBL generations when the time-of-day rebake fires: seconds to blend the previous irradiance/prefilter into the new one, 0 = discrete swap (old behavior) SceneRenderer
r.SkyLight.CaptureClouds
int
1
Include the cloud layer in the sky light capture, so clouds shade the ambient and appear in reflections: 0=off, 1=on SceneRenderer
r.SkyLight.CaptureSize
int
128
Face size of the sky light capture cubemap the irradiance and reflection maps are convolved from (32..512) SceneRenderer
r.SkyLight.CloudRecaptureSeconds
float
0.5f
Shortest time between real-time sky light captures that only drifting clouds asked for (the sun, intensity or atmosphere changing still re-captures on the sky light's interval); the IBL crossfades between captures SceneRenderer
SSGI hemisphere rays per pixel: -1=tier value SceneRenderer
r.SSGI.Steps
int
-1
SSGI depth-march steps per ray: -1=tier value SceneRenderer
r.SSR
int
-1
Screen-space reflections (the whole trace/temporal/resolve slice): -1=tier value (Medium+ on, Low hard-off), 0=off, 1=on. Scene PostFX settings act within this. SceneRenderer
r.SSR.FilterTaps
int
3
Reflection spatial filter kernel: 5 = 5x5 taps, 3 = 3x3 a-trous over the same footprint (a third of the cost) SceneRenderer
r.SSR.MaxSteps
int
-1
Cap on the scene's SSR raymarch step count: -1=tier value, 0=uncapped SceneRenderer
r.SSR.TraceDivisor
int
-1
Resolution divisor of the screen-leg reflection trace: -1=tier value, 1=full res, 2=half (a quarter of the pixels traced per frame, rotating over a 2x2 block; SSRUpsample rebuilds the rest and the temporal pass integrates them) SceneRenderer
r.SSS.Width
float
24.0f
Subsurface blur radius in pixels at full strength (the profile shapes the falloff inside it) SceneRenderer
r.Substrate
int
0
Substrate layered-BSDF slabs on compiled material graphs: 0=off (the Output node's Substrate slot is ignored and every graph emits byte-identical source), 1=on (a slab compiles into the two-slab G-Buffer encode). Materials must be recompiled after changing this. AssetSystem
r.Terrain.CDLOD
int
1
Terrain render path: 1=CDLOD (quadtree-selected instanced patches displaced by a height texture, continuous morph LOD), 0=legacy per-chunk meshes with discrete LOD chains Game
r.Terrain.ErrorPixels
float
3.0f
CDLOD terrain screen-space error tolerance in pixels — lower = denser node selection (more draws, finer far detail) SceneRenderer
r.Terrain.MorphZone
float
0.30f
Fraction of each CDLOD node's range spent morphing to the coarser grid (0.05-0.95) SceneRenderer
r.Terrain.RVT
int
-1
Terrain runtime virtual texture — bake the splat blend into feedback-streamed VT pages and sample the composite per pixel: -1=tier value (High+ on), 0=off, 1=on SceneRenderer
r.Terrain.RVTVirtualPages
int
64
Terrain RVT virtual size in 128-texel pages per axis (64 = 8192 virtual texels across the terrain); applies to caches created after the change SceneRenderer
r.Terrain.Wireframe
int
0
Draw CDLOD terrain with a wireframe fill pipeline (shows the live LOD density): 0=off, 1=on Cheat.SceneRenderer
r.Texture.KeepCpuCopy
int
0
Keep every texture's decoded / cooked CPU pixels after the GPU upload: 0 = free them (a texture that needs them opts in with TextureAsset::SetKeepCpuCopy), 1 = keep all (A/B) AssetSystem
r.Texture.PackageNativeBc
int
1
Upload a Texture package as its block-compressed chain (the package's cooked render data, else its source cooked through the DDC with its import settings): 1 = on, 0 = decode it to RGBA8 and build the mips on the GPU, as before (A/B). Read when a texture loads AssetSystem
r.TextureStreaming
int
1
Camera-driven texture mip streaming (1 = on). Off keeps every scene texture fully resident. GameHost
r.TextureStreaming.ForceBudgetMB
int
0
Treat the OS's VRAM budget as this many MB (0 = the driver's real budget), so the VRAM-pressure path drops mips on a card that has room: the small-card test on any machine. GameHost
r.TextureStreaming.MaxUploadBytesPerFrame
int
16 * 1024 * 1024
Byte budget for texture mip uploads SUBMITTED per frame (the disk portion; GPU-copied resident tails are free). Uploads are asynchronous — the visible swap lands when the GPU finishes — so this bounds per-frame transfer bandwidth, not a stall. <= 0 = unbounded. Game
r.TextureStreaming.PoolSizeMB
int
0
Streaming texture residency budget in MB (0 = unlimited). The farthest textures coarsen first when the desired set exceeds it. GameHost
r.TextureStreaming.VramPressure
int
1
Shrink the texture and mesh LOD streaming pools (splitting the overshoot by what each holds) while the driver reports device-local usage over 95% of the VRAM budget the OS grants (relaxes under 85%): 1 = on, 0 = the configured pool only. GameHost
r.Tonemap
int
-1
Tonemap operator override: -1=scene setting, 0=ACES (fit), 1=AgX, 2=Reinhard, 3=clamp, 4=ACES RRT+ODT (sRGB 100-nit ODT, 1000-nit under HDR output), 5=display LUT (r.DisplayLUT / the scene's; ACES RRT+ODT while none) SceneRenderer
r.TSR.AntiFlicker
float
2.0f
TSR anti-flicker: damping applied to the current frame where its raw luma oscillates beyond the variance box between frames (0 = off) RHI
r.TSR.ClampGamma
float
1.0f
TSR history rectification: width of the YCoCg variance box in standard deviations (lower = less ghosting, more flicker; < 0 disables clipping) RHI
r.TSR.Debug
int
0
TSR debug view written in place of the resolved image: 0 = off, 1 = history weight (sample count / MaxSamples), 2 = rejection (R = depth/off-screen reject, G = clip amount, B = reactive mask), 3 = velocity (RG = signed output pixels/frame, B = velocity clamp ramp) RHI
r.TSR.MaxSamples
float
32.0f
TSR temporal accumulation cap — the per-pixel sample count saturates here (alpha floor = 1/N) RHI
r.TSR.Sharpness
float
0.4f
TSR output sharpening (RCAS lobe): 0 = off, 1 = full RHI
r.TSR.Velocity.WeightClampingPixelSpeed
float
1.0f
TSR: output-pixel speed per frame at which the history clamp reaches WeightClampingSampleCount RHI
r.TSR.Velocity.WeightClampingSampleCount
float
4.0f
TSR: sample count the history is clamped to at r.TSR.Velocity.WeightClampingPixelSpeed (lower = crisper motion, more flicker; >= MaxSamples disables) RHI
r.Upscale.ReactiveMask
int
1
Derive a reactive mask from the pre/post-translucency scene diff and feed it to the temporal upscaler (0 = off) SceneRenderer
r.Upscaler
int
-1
Active upscaler: -1=auto (picked from the device at startup), 0=None 1=TAA 2=Spatial 3=FSR 4=DLSS 5=TSR 6=XeSS 7=MetalFX (runtime-toggleable). ApplyUpscalerCVars ignores -1, so the auto slot never overrides the renderer before FQualityAutoTier fills it. SceneRenderer
r.Upscaler.AutoQuality
int
-1
Auto upscaling: pick the upscaler quality mode from the output resolution (<=900p Native, 1080p Quality, 1440p Balanced, 4K Performance, above Ultra Performance; lower tiers shift toward Performance). -1 = follow the tier (on at High and below), 0 = off (r.UpscalerQuality decides), 1 = on. SceneRenderer
r.Upscaler.DeferredRelease
int
1
Reallocate upscaler history and intermediates (TSR, FSR 1, the FSR 3 context) on a resize without draining the GPU: the old images and contexts are released once the frames that read them have retired. 1=on, 0=WaitIdle first (A/B) RHI
Samples of the self-shadow march toward the sun at each view sample; 0 = unshadowed SceneRenderer
r.VdbVolumes.Steps
int
64
View-ray samples through each VDB volume's box SceneRenderer
r.Velocity.MoversOnly
int
1
Velocity pass: 1 = a fullscreen compose writes every pixel's camera-motion velocity from the GBuffer depth and only movers (skinned, WPO, transform changed since last frame) are rasterised on top; 0 = redraw the whole opaque list (the pre-2026-09-28 pass, A/B) SceneRenderer
r.ViewDistanceScale
float
-1.0f
Global multiplier on every object's authored maxDrawDistance at cull time: -1=tier value SceneRenderer
Raymarched cloud extinction per world unit at full coverage SceneRenderer
r.VolumetricClouds.Detail
float
0.4f
Silhouette erosion strength from the detail noise volume (0 = smooth blobs) SceneRenderer
r.VolumetricClouds.EnableForProject
int
0
Project switch: 1 = this project may raymarch the volumetric cloud volume. 0 = a cloud actor draws the flat cloud layer and the cloud noise volumes are never built RHI
r.VolumetricClouds.Height
float
400.0f
Cloud plane height in world units above the camera SceneRenderer
r.VolumetricClouds.Intensity
float
1.0f
Multiplier on the composited cloud radiance SceneRenderer
r.VolumetricClouds.LightSteps
int
-1
Sun light-march taps per lit sample: -1 = scalability tier default SceneRenderer
r.VolumetricClouds.MaxDistance
float
60000.0f
Longest raymarch segment through the cloud layer, in world units SceneRenderer
Raymarched cloud wind speed in world units per second SceneRenderer
r.VolumetricFog
int
-1
Froxel volumetric fog (3D light grid: height fog + fog volumes, sun-scattered with per-froxel CSM shadow, temporally reprojected, composited before transparency): -1=code default, 0=off, 1=on SceneRenderer
r.VolumetricFog.Anisotropy
float
0.6f
Henyey-Greenstein phase g for the sun in-scatter (>0 = forward, sharper god rays) SceneRenderer
r.VolumetricFog.EnableForProject
int
0
Project switch: 1 = this project uses froxel volumetric fog. 0 = height fog stays analytic and the froxel volumes are never built RHI
r.VolumetricFog.GiAmbient
int
1
Froxel fog ambient: 1 = each froxel takes the mean radiance the DDGI probe field gives its position (sealed rooms stay dark, fog by a lit wall picks up its bounce) whenever the field is live, 0 = one constant ambient from the scene's ambient colour everywhere (A/B) SceneRenderer
r.VolumetricFog.HeightFalloff
float
0.02f
Exponential height-fog falloff per world unit above the base plane SceneRenderer
r.VolumetricFog.MaxLocalLights
int
32
Point/spot lights injected into the froxel fog, nearest-first (0 = sun/ambient only). Per light, LightComponent volumetricScattering scales or disables its contribution SceneRenderer
r.VolumetricFog.Temporal
float
0.9f
Temporal reprojection blend for the froxel injection (0 = no history, 0.9 = heavy) SceneRenderer
r.VolumetricFog.Translucency
int
1
Froxel fog on translucents: 1=forward transparents (glass, water, the OIT path) take the integrated froxel volume at their own depth, the haze the opaque composite gives the pixel behind them (default), 0=analytic fog only (A/B) SceneRenderer
r.Voxel.BlockLightEmission
float
1.5f
Voxel chunk block light as emission: albedo times the squared block light times this SceneRenderer
r.Voxel.PoolBudgetMB
int
1024
VRAM the voxel vertex pool may grow to, in MB (32 MB blocks); a chunk mesh that does not fit is refused Renderer
r.Voxel.UploadBudgetKB
int
4096
Voxel chunk mesh bytes sent to the GPU per frame in one batch; the rest of the queue waits for the next frame. 0 = no limit Renderer
r.Voxel.UploadMaxInFlight
int
2
Voxel upload batches kept in flight before the queue is held; the RHI async upload slots are shared with texture streaming and the dynamic mesh pool Renderer
r.VRS
int
0
Variable-rate shading of the G-buffer from a per-tile rate image (D3D12 VRS Tier 2 / Vulkan fragment shading rate): 0 = off, 1 = on. No effect where the device has no image-based VRS SceneRenderer
r.VRS.ContrastThreshold
float
0.03f
Mean perceptual luminance step between neighbouring samples of a tile below which it shades coarser along that axis SceneRenderer
r.VRS.MotionThreshold
float
6.0f
Screen motion in pixels per frame above which a tile shades at 2x2 whatever its contrast SceneRenderer
VSM caster runs: 1=consecutive static casters on one mesh and LOD draw their dirty pages with one indirect call per run (page lists packed on the GPU), 0=one indirect call per caster SceneRenderer
r.VSM.Clipmap.FirstExtent
float
2.0f
Half-extent in world units of the finest VSM clipmap level; each further level doubles it. 96x96 pages of 64 texels over this extent sets the finest texel a receiver can ask for (2 = 0.65 mm); receivers take the coarsest level their pixel footprint still resolves, so a small first level costs pages only where the camera is close enough to use it SceneRenderer
r.VSM.Clipmap.Levels
int
-1
VSM clipmap level count (1..16); -1 = the fewest levels whose coarsest extent still covers r.Shadow.MaxDistance. Receivers past the coarsest level fall back to the CSM SceneRenderer
r.VSM.Clipmap.LodBias
float
0.0f
VSM clipmap level bias against the receiver's pixel footprint: 0 = one shadow texel per screen pixel, -1 = two per pixel (4x the page demand; UE's default sits near -1.5 on a pool four times this one), +1 = half SceneRenderer
r.VSM.CsmCasters
int
-1
Mesh casters in the CSM cascades while the virtual shadow map is on: -1 = only until the VSM resolved with a steady page cache (no flood, no deferred pages), then the cascades carry terrain and GPU foliage alone and every sun-shadow reader samples the VSM pages; 1 = always draw them (the pre-2026-09-28 double raster, A/B); 0 = never draw them under VSM SceneRenderer
r.VSM.PageBudget
int
256
Max VSM pages re-rasterized per frame; stale pages past the budget keep waiting and the CSM serves their pixels, so a sun move or mass invalidation never hitches. Capped at 1024 (the per-frame page list); 0 = that cap SceneRenderer
r.VSM.SmrtRayLength
float
0.0f
SMRT occluder search distance toward the sun in world units; 0 = 16 SceneRenderer
r.VSM.SmrtRays
int
6
Shadow-map ray-tracing rays per pixel in the VSM resolve (jittered across the sun's angular extent) SceneRenderer
r.VSM.SmrtSamples
int
4
Depth samples marched along each SMRT ray SceneRenderer
r.VSM.StableFit
int
1
VSM camera-decoupled light space: 1=toroidal clipmap scroll (a camera step invalidates the row/column that wrapped in, the rest of the page cache survives), 0=legacy behaviour where any window scroll floods the whole clipmap stale SceneRenderer
r.VSync
int
-1
Vertical sync. 1 = on, 0 = off, -1 = follow the window config (default). EngineLoop
r.Vulkan.AsyncCompute.SyncSubmit
int
0
1 = submit the async-compute fork, hand-off and join through FRHIThread::ExecuteSync (the render thread waits for the whole RHI queue each time), 0 = enqueue the submit and keep recording VulkanRHI
r.Vulkan.AsyncUploads
int
1
Create-with-data uploads on Vulkan (static buffers, texture data, IBL bakes, upload batches) submit their single-time command buffer and return without waiting for the GPU; the staging is released once the submit's fence signals. 0 = wait for every upload (the old blocking path) VulkanRHI
r.Vulkan.PipelineReuse
int
1
Share one VkPipeline between pipelines created from an identical spec (shader content + full state hash): 0=every creation compiles its own, 1=dedupe VulkanRHI
r.Vulkan.ValidationRepeat
int
0
Log every occurrence of a validation message instead of only the first: 0=dedupe, 1=repeat VulkanRHI
r.WarmPipelinesOnStartup
int
1
Pre-compile the lazy feature pipeline groups (MegaLights/fog/clouds/screen probes/path trace/VT/...) at startup so first feature use never hitches on a PSO compile: 0=off, 1=on SceneRenderer
r.Water.Caustics
int
1
Underwater caustics: an animated cellular light pattern projected onto submerged geometry, faded by the water column above it. Needs the water info texture for the surface height. SceneRenderer
r.Water.CausticStrength
float
0.35f
Brightness of the underwater caustic pattern. SceneRenderer
r.Water.Foam
int
1
Water foam: shore band where water meets geometry + Gerstner crest foam. SceneTypes
r.Water.InfoResolution
int
256
Water info texture resolution per side (clamped 32-1024). Higher resolves a narrower river channel; the raster is CPU-side and only re-runs when a body changes. SceneTypes
r.Water.InfoTexture
int
1
Water info texture: a top-down raster of depth-to-bottom, flow and surface height over every water body, read by the water shader for bathymetric colour, shoreline foam and flow-advected foam UVs. 0 = the pre-texture look, pixel for pixel. SceneTypes
r.Water.Reflections
int
1
Fresnel-weighted environment reflection on water surfaces: a screen-space march over the opaque scene first (with r.Water.Refraction), then the translucent reflection ray through the SDF radiance cache where r.Reflections.Translucent and a built cache allow it, then the sky. SceneTypes
r.Water.Refraction
int
1
Water refraction: sample the opaque scene color behind the surface with a normal-perturbed, depth-scaled offset. Latched at renderer init (selects the WATER+REFRACTION shader variant). SceneTypes
r.Water.Underwater
int
1
Fullscreen tint + distance fog when the camera is below a water surface. SceneTypes
r.Water.Wetness
int
1
Shoreline wetness: geometry in a band just above the waterline is darkened and smoothed in the deferred lighting pass, so its specular sharpens as well. Needs the water info texture for the per-pixel waterline. SceneTypes
r.Water.WetnessBand
float
0.6f
Metres above the waterline the shoreline wetness band reaches. SceneTypes
r.Water.WetnessStrength
float
0.45f
How wet the shoreline band gets at the waterline: 0 disables the lane, 1 is a fully soaked surface. SceneTypes
r.Wind.Flutter
float
0.15f
High-frequency tip/edge flutter amount, weighted by the vertex-color bend mask SceneRenderer
r.Wind.Gust
float
0.35f
Gust amount — 2-octave time noise modulating the sway amplitude (0 = steady wind) SceneRenderer
r.Wind.Speed
float
1.0f
Global wind speed multiplier on top of per-foliage windSpeed SceneRenderer
r.Wind.Strength
float
1.0f
Global wind strength multiplier on top of per-foliage windStrength SceneRenderer
r.WorldGrid
int
1
Procedural world grid on grid materials and on every mesh with no material. 0=flat base colour (a material-less mesh then reads as the old flat grey), 1=grid SceneRenderer
save
Name
Type
Default
Description
save.AutosaveInterval
float
300.0f
Seconds between runtime autosaves into the dedicated autosave slot (0 = off) Game
save.AutosaveOnTravel
int
1
Flush the outgoing scene's world state into the autosave slot before a map travel, so returning later via load restores it (0 = off) Game
Toggle the FPS overlay in the editor / game view. EngineLoop
stat.FrameStats
int
0
Headless frame-stage profiler dump. 0 = off (default); N > 0 enables the in-process profiler and logs averaged CPU stage times plus the resolved GPU frame total to the log every N frames. EngineLoop
stat.FrameStatsCount
int
30
How many scopes stat.FrameStats lists, ranked by total time. The default of 10 hid the whole gameplay breakdown behind the render stages. EngineLoop
stat.FrameStatsFilter
string
""
Case-insensitive substring; when set, stat.FrameStats lists only scopes whose name contains it (e.g. System for the ECS breakdown). EngineLoop
t
Name
Type
Default
Description
t.BatterySaverFPS
int
0
Frame rate cap while running on battery power. 0 = off (default). M2.5: on phones a card game at 30/60 stretches battery dramatically; high-refresh panels (ProMotion / 120 Hz Android) fall back to this only while unplugged and return to full rate on charger. EngineLoop
t.HitchLogMs
int
kDefaultHitchLogMs
Log [Hitch] with the frame's phases for any frame longer than this many milliseconds but under t.StallLogMs, at most once a second. 0 = off. EngineLoop
Log [Stall] with the phases of any frame whose own work (pacing excluded) runs longer than this many milliseconds; with the profiler on, its slowest scopes too. 0 = off. EngineLoop
telemetry
Name
Type
Default
Description
telemetry.Alert.CpuTempC
float
95.0f
CPU package temperature that raises the CPU-hot alert, in °C. Telemetry
telemetry.Alert.CpuTempClearC
float
88.0f
CPU package temperature the CPU-hot alert clears under, in °C. Telemetry
telemetry.Alert.Enable
int
1
Watch for a hot or thermally throttling GPU/CPU and VRAM near its budget, and raise telemetry alerts (1). Telemetry
telemetry.Alert.GpuHotspotC
float
105.0f
GPU hotspot (junction) temperature that raises the GPU-hot alert where the GPU reports one, in °C. Telemetry
telemetry.Alert.GpuTempC
float
87.0f
GPU temperature (edge/core sensor) that raises the GPU-hot alert, in °C. Telemetry
telemetry.Alert.GpuTempClearC
float
80.0f
GPU temperature the GPU-hot alert clears under, in °C. Telemetry
telemetry.Alert.HoldSeconds
float
3.0f
How long a reading must stay past an alert threshold (or back under its clear threshold) before the alert raises (or clears). Telemetry
telemetry.Alert.SampleHz
float
1.0f
Telemetry sample rate while nothing reads it but alerts are on, 0.2-4 Hz. Telemetry
telemetry.Alert.Throttling
int
1
Raise the GPU and CPU throttling alerts (1). A GPU held at its power limit under load is normal and never alerts; only thermal throttling does. Telemetry
telemetry.Alert.VramClearFraction
float
0.88f
VRAM used over budget the VRAM alert clears under. Telemetry
telemetry.Alert.VramFraction
float
0.95f
VRAM used over the budget the OS grants that raises the VRAM alert (0.95 = 95 %). Telemetry
telemetry.Enable
int
1
Run the hardware and performance telemetry service (1). 0 = no sampling thread, every metric reads as unavailable. Telemetry
telemetry.SampleHz
float
4.0f
Telemetry sample rate while something reads it (a script getter, the netgraph, an ArcUI binding, stat hardware/net), 1-10 Hz. Telemetry
telemetry.ShowPlayerWarnings
int
0
Show players a one-line warning while a telemetry alert is raised (the GPU or CPU is hot or throttling, VRAM is near its budget). Off by default: the project decides (Project Settings > Performance). ArcUI
ui
Name
Type
Default
Description
ui.HighContrast
int
0
Accessibility: draw Arc menus and HUD in the high-contrast theme ArcUI
ui.ReducedMotion
int
0
Accessibility: skip Arc's decorative transitions and motion ArcUI
vfs
Name
Type
Default
Description
vfs.LogMisses
bool
false
Log every failed VFS Open with the path and the mounts that were tried Filesystem
vfs.PackagedLooseFiles
int
kPackagedLooseFilesDefault
A packaged run with content paks: 1 keeps the working directory mounted as the lowest-priority VFS fallback, 0 reads relative keys only from the paks (release and profile default) so a loose file beside the package can never stand in for content the cook missed. Absolute paths always pass through. GameHost
voice
Name
Type
Default
Description
voice.AutoGain
bool
true
Level a quiet or a loud microphone toward one speaking level VoiceChat
Speaking level automatic gain aims for, as a fraction of full scale VoiceChat
voice.BytesPerSecond
int
12000
Hard per-client outgoing voice bandwidth cap in bytes/second; frames over budget are dropped VoiceChat
voice.Codec
string
"auto"
Voice codec: auto (Opus where its binaries are vendored, otherwise ADPCM), opus, or adpcm VoiceChat
voice.DistanceLowPassFar
float
3500.0f
Low-pass cutoff (Hz) a proximity voice plays through at the edge of voice.HearingRange; 20000 switches the distance low-pass off VoiceChat
voice.DistanceLowPassNear
float
20000.0f
Low-pass cutoff (Hz) a proximity voice plays through at voice.NearRange; 20000 = full band VoiceChat
voice.EchoCancellation
bool
true
Cancel other players' voices coming back in through the microphone from open speakers (SpeexDSP echo canceller) VoiceChat
voice.EchoTailMs
int
200
Longest echo the canceller models, in milliseconds: speaker-to-microphone path plus device buffers VoiceChat
voice.Enabled
bool
true
Master switch for proximity voice chat capture and playback VoiceChat
voice.FollowPlatformMute
bool
true
Mute the microphone while the player is muted or deafened in their platform voice client (Discord), and silence incoming voice while deafened VoiceChat
voice.GateCloseRms
float
0.02f
Capture RMS below which the noise gate closes again after its hold expires VoiceChat
voice.GateHoldSeconds
float
0.35f
Seconds the noise gate stays open after the signal drops, so a pause mid-sentence does not clip the tail VoiceChat
voice.GateOpenRms
float
0.035f
Capture RMS a frame must reach to open the noise gate and start transmitting VoiceChat
voice.GrainMax
float
0.6f
How broken up a proximity voice is at the edge of hearing range, 0..1; 0 switches the grain layer off VoiceChat
voice.GrainStart
float
0.5f
Fraction of voice.HearingRange past which a proximity voice starts to break up VoiceChat
voice.HearingRange
float
22.0f
Distance (m) past which a proximity voice speaker is inaudible and no longer relayed VoiceChat
voice.InputDevice
string
""
Capture device id; empty means the system default VoiceChat
voice.InputDeviceList
string
""
Capture devices the plugin found, one id|name row per line - published by the voice plugin, read by the settings screen VoiceChat
voice.InputGain
float
1.0f
Linear gain applied to captured samples before the noise gate reads their energy VoiceChat
voice.MimicryCapture
bool
false
Keep short in-memory fragments of consenting, unmuted players' voices for a mimic (host side; never written to disk) VoiceChat
voice.MimicryConsent
bool
true
Allow the host to keep short fragments of your voice in memory for creatures that mimic players; off = nothing of your voice is kept VoiceChat
voice.Mode
int
0
Transmit mode: 0 = push-to-talk, 1 = open mic (the activation threshold is voice.GateOpenRms) VoiceChat
voice.MuteDuringPlatformCall
bool
true
Keep the in-game microphone off while the player is in a platform voice call (a Discord lobby call), so one voice is not sent twice VoiceChat
voice.NearRange
float
3.0f
Distance (m) within which a proximity speaker plays at full volume before rolloff begins VoiceChat
voice.NoiseSuppressDb
int
-25
How far noise suppression pushes noise down, in dB (negative) VoiceChat
voice.NoiseSuppression
bool
true
Learn and subtract stationary microphone noise (fans, hum, hiss) before the gate and the encoder VoiceChat
voice.Occlusion
bool
true
Muffle a speaker the local player has no line of sight to VoiceChat
voice.OpusBitrate
int
32000
Target bitrate in bits/second for the Opus VBR encoder VoiceChat
voice.OpusDtx
bool
true
Let Opus emit nothing at all through silence instead of a packet per 20 ms VoiceChat
voice.OpusFec
bool
true
Carry a coarse copy of the previous frame in each Opus packet so one lost frame is rebuilt rather than concealed. Only while voice.OpusRedundancyMs is 0: deep redundancy replaces it VoiceChat
voice.OpusRedundancyMs
int
500
Milliseconds of past speech carried as deep redundancy (Opus DRED) in every packet, so a burst of loss is rebuilt instead of concealed. 0 turns it off and inband FEC back on VoiceChat
voice.OutputVolume
float
1.0f
Master playback volume for every incoming voice, on top of the Voice bus VoiceChat
voice.RadioAINoise
float
0.6f
Loudness of the noise AI hears from a radio playing a transmission (host only); 0 = radios are silent to AI VoiceChat
voice.RadioBandPass
bool
true
Play radio transmissions through the 300-3400 Hz telephone band instead of full range VoiceChat
voice.RadioHeight
float
1.2f
Height (m) above a pawn's origin its radio hangs at, where incoming transmissions play from VoiceChat
voice.RadioSpeakerRange
float
12.0f
Distance (m) out to which another player's radio is heard playing a transmission; your own radio is always heard VoiceChat
voice.RadioVolume
float
1.0f
Playback volume of radio transmissions, on top of the voice volume VoiceChat
voice.Rolloff
float
1.0f
Proximity attenuation curve exponent: 1 = linear, higher falls off faster near the edge of hearing range VoiceChat
weapon
Name
Type
Default
Description
weapon.DecalPoolCapacity
int
64
Maximum live runtime-spawned impact decals; the oldest is recycled past this Game
weapon.ServerRateSlack
float
0.85f
Fraction of the fire interval the server tolerates between client fire requests before rejecting Plugins.Combat
wolang
Name
Type
Default
Description
wolang.CallBudget
int
20000000
Ticks one call into a script may spend (one per script function entry or backward jump, in the interpreter and the compiled tier alike) before it stops with an error in the Message Log and the frame goes on. 0 = no limit. Read when a world's script machine is created. Scripting
wolang.DebugPort
int
4711
TCP port on 127.0.0.1 a Wolang vm opens for the debugger (VS Code's Wolang extension, attach) in builds with the editor. 0 = any free port, -1 = no debugger. A second vm in the same process takes a free port; each logs its own. Scripting
wolang.HotReload
int
1
In builds with the editor: 1 = a saved script reloads in the playing world the next frame, keeping its state; 0 = scripts change only when play starts again. Scripting
wolang.RpcMaxBytes
int
1024
Largest script RPC or replicated field batch in bytes, in either direction. A larger inbound one is dropped and counted; a script cannot send one. Scripting
wolang.RpcRate
int
30
Calls per second one script actor accepts of each @Server method from its owning client (a burst of this many, then the rate). Beyond it the call is dropped and counted. 0 = no limit. Scripting
world
Name
Type
Default
Description
world.Persistence
int
1
World-state journal: capture destroyed/modified/runtime-spawned persistent entities across sector streaming and saves (0 = off) Game
wp
Name
Type
Default
Description
wp.CollisionProxy
int
1
World-partition collision proxies: keep a coarse static collider for every streamed-out sector so long traces still hit (1 = on, 0 = off). Game
wp.CollisionProxy.MaxResident
int
64
How many streamed-out sectors keep a collision proxy at once; the oldest is dropped past this. Game
wp.CollisionProxy.MaxTriangles
int
2000
Triangle budget of one sector's collision proxy; geometry over it is simplified, then boxed. Game
wp.HLOD
int
1
World-partition HLOD: draw a low-poly proxy mesh for streamed-out sectors (1 = on, 0 = off). SceneRenderer
wp.HLOD.Atlas
int
1
Draw an HLOD proxy with its baked albedo/normal atlas when the cook gave it one (1 = on, 0 = per-object vertex colours only). Read when a sector's proxy is first drawn. SceneRenderer
wp.HLOD.AtlasSize
int
256
Texel edge of the albedo/normal atlas baked into every HLOD proxy at cook (rounded up to a power of two, 16-2048; 0 = no atlas, the proxy keeps per-object vertex colours only). Game
wp.HLOD.FarRadius
float
6000.0f
Maximum distance in metres at which a streamed-out sector still draws its HLOD proxy; beyond this nothing is drawn. SceneRenderer
wp.HLOD.ResidentDistance
float
1000.0f
Distance in metres past which a RESIDENT sector draws its HLOD proxy in place of its live entities (their meshes stop submitting; gameplay, physics and streaming are untouched). 0 = resident sectors always draw their entities. SceneRenderer
wp.RebaseDistance
float
8192.0f
Rebase the world origin when the main camera drifts this far from it (0 = off) Game
wp.RebaseGrid
float
1024.0f
Origin shifts snap to this grid so rebased coordinates stay round Game