Console Performance Considerations

Console targets are easier than the PC matrix in one important way: every player has the same silicon. You tune to one configuration, you measure on one configuration, you ship to one configuration. That's the discipline PC-only teams envy.

Where it ends: cert-required performance windows (no sustained dropped frames in mainline gameplay), TRC/XR rules around suspend/resume, controller disconnect handling, loading-screen timeouts, and the hard memory ceilings. The fixed hardware giveth and the cert process taketh away.

The TFLOP gap PS5 -> XSX is real but smaller than it looks — PS5 runs higher-clock, narrower-CU silicon that benefits more from sequential geometry and less from massively-parallel compute. XSX's wider CU count helps Lumen, Nanite culling, and ray tracing more than it helps fixed-function rasterization.

XSS is where projects fail cert. 4 TFLOPs and 7.5 GB of game-accessible memory is genuinely tight; many UE5 titles ship 60 fps mode on PS5/XSX and 30 fps on XSS as the only way to hit budget.

10 GB total GDDR6, ~8 GB game-accessible at 224 GB/s, plus 2 GB at 56 GB/s OS-shared. Effective working set is ~7.5 GB.

Mitigation patterns from shipped titles:

• Mip bias on textures. Set in [XSX_S DeviceProfile] a positive r.Streaming.MipBias (0.5–1.0) so XSS gets one mip level lower than XSX/PS5.
• Texture pool size. Cap at ~3.5 GB on XSS vs ~6 GB on XSX/PS5.
• Disable virtual textures if your project uses them — they're expensive on memory-constrained tiers.
• Per-platform LOD bias on skeletal meshes. XSS gets +1 LOD bias on background characters.
• Cap Niagara budget at <1 ms on XSS in r.EmitterSpawnRateScale via scalability tier.

Game Science (Black Myth Wukong) publicly identified XSS memory as a key reason for the title's later-than-PS5/XSX release on XSS — "10 GB of shared memory needs years of optimization" is a real shipped sentiment.

PS5 uses Sony's GNM (and the higher-level GNMX) graphics API; XSX uses a console-specific D3D12.X via the GDK. UE's RHI abstracts both, but leakage shows up in profiles:

• State changes are cheaper on GNM than D3D12 generally; XSX paths often need a deeper PSO cache to avoid state-change cost.
• Memory residency is exposed differently. XSX has placed-resource heaps; PS5 has direct VRAM-style allocation. RHI memory reports vary in how they account for each.
• Quick Resume on Xbox introduces a subtle "the game wakes up to a different state than it slept in" bug class. Cert tests for this; UE 5.x handles most of it but custom subsystems with cached state can break.

Each platform has its own first-party tool. Public guidance:

• PS5: Razor — Sony's first-party suite (timing, ISA, memory analysis equivalents to RGP/PIX). NDA-locked; this tutorial does not quote specific Razor counters or markers.
• XSX: PIX (via GDK) — same PIX as Windows D3D12, with platform-specific drivers and capture types. Set D3D12.EmitRgpFrameMarkers=1 for richer marker streams. See the dedicated PIX tutorial.
• AMD Radeon GPU Profiler (RGP) — Windows desktop tool, but the patterns it surfaces (wave occupancy, async overlap, BVH analysis on RDNA 2) translate directly to console silicon. See the AMD vendor tools tutorial.

The senior pattern: profile on PC RDNA 2 with RGP first to find the patterns, then verify on console with PIX (XSX) or Razor (PS5). PC RDNA 2 is the public scaffold for understanding console behavior.

RDNA 2 has dedicated async compute pipes. UE5 routes several passes onto them by default:

r.LumenScene.Lighting.AsyncCompute=1
r.Lumen.Reflections.AsyncCompute=1
r.Lumen.DiffuseIndirect.AsyncCompute=1
r.Lumen.HardwareRayTracing.AsyncCompute=1
r.TSR.AsyncCompute=2
r.Nanite.Streaming.AsyncCompute=1

Async overlap typically saves 1–3 ms on a Lumen-heavy frame on RDNA 2 console. Async compute jobs are invisible in PIX GPU captures — only timing captures show them. A common confusion when looking at "why is my GPU bound but graphics queue is empty."

UE 5.6 brought meaningful console-side wins:

• Lumen ShortRangeAO 2× faster on console via half-res + denoiser.
• Lumen Far Field 30% faster, ~50% with r.LumenScene.FarField.OcclusionOnly=1.
• SurfaceCache 2× faster via halved page-update frequency driven by camera distance.
• Reflections 32-bit format saves ~0.02 ms; water rendering saves ~0.03 ms at 900p.
• Nanite chunk-based instance culling on chunks of 64 instances saves ~100 µs in CitySample.

Default HWRT is off on most UE console projects — AMD RDNA 2's RT throughput is meaningfully below NVIDIA RTX, and Lumen SWRT delivers acceptable quality at much lower cost. Flipping r.Lumen.HardwareRayTracing=1 on console is a perf trap unless you've measured.

The shipped pattern on UE5 titles:

• Quality mode: 4K/30 fps — full Lumen + Nanite + VSM. Hellblade II shipped at this on Series X with no perf mode. Wukong Quality runs 4K/30 on PS5.
• Performance mode: 1440p/60 fps with DRS down to 1080p or 720p — reduced Lumen, sometimes no VSM, FSR/TSR upscale. Wukong Performance on PS5 floors at 720p with DRS up to 1080p.
• Balanced mode: 1800p/40 fps on 120 Hz displays — the increasingly common third option (PS5 Pro, XSX with VRR).

Dynamic resolution requires r.DynamicRes.OperationMode=1 (or 2 to force on) and r.DynamicRes.MinScreenPercentage / MaxScreenPercentage. Most shipped console titles also pin a hard floor (e.g., 720p min for Performance) so quality doesn't fall off a cliff.

• Long load screens are a top failing test case at Microsoft. Cert tests for boot-to-gameplay time; a 60-second loading screen will fail Xbox cert.
• Quick Resume save corruption — recurring fail; if your subsystem caches state in a way that doesn't survive a wake-from-sleep, you'll fail.
• Controller disconnect handling — the title must remain responsive when the controller goes idle/disconnects.
• HDR test cases — specific cert tests for HDR metadata; getting this wrong is a common late-stage rejection.
• Performance during streaming — cert tests for frame stability during install streaming on Xbox; a perf mode that drops frames during install fails.

Microsoft Learn maintains a public "top failing test cases" list — required reading before submission.

Skeletal recipes for the three current-gen consoles:

[PS5 DeviceProfile]
DeviceType=PS5
+CVars=r.Lumen.HardwareRayTracing=0
+CVars=r.Lumen.ScreenProbeGather.StochasticInterpolation=1
+CVars=r.Lumen.ScreenProbeGather.IntegrateDownsampleFactor=2
+CVars=r.LumenScene.FarField.OcclusionOnly=1
+CVars=r.TSR.AsyncCompute=2
+CVars=r.DynamicRes.OperationMode=1
+CVars=r.DynamicRes.MinScreenPercentage=70
+CVars=r.DynamicRes.MaxScreenPercentage=100

[XSX DeviceProfile]
DeviceType=XSX
+CVars=r.Lumen.HardwareRayTracing=0
+CVars=r.Lumen.ScreenProbeGather.StochasticInterpolation=1
+CVars=r.Lumen.ScreenProbeGather.IntegrateDownsampleFactor=2
+CVars=D3D12.EmitRgpFrameMarkers=1
+CVars=r.TSR.AsyncCompute=2
+CVars=r.DynamicRes.OperationMode=1
+CVars=r.DynamicRes.MinScreenPercentage=70
+CVars=r.DynamicRes.MaxScreenPercentage=100

[XSX_S DeviceProfile]
DeviceType=XSX
+CVars=r.Lumen.HardwareRayTracing=0
+CVars=r.Lumen.ScreenProbeGather.DownsampleFactor=32
+CVars=r.Lumen.ScreenProbeGather.IntegrateDownsampleFactor=2
+CVars=r.Lumen.Reflections.DownsampleFactor=2
+CVars=r.Streaming.MipBias=0.5
+CVars=r.Streaming.PoolSize=3500
+CVars=sg.ShadowQuality=1
+CVars=r.DynamicRes.MinScreenPercentage=50
+CVars=r.DynamicRes.MaxScreenPercentage=85

PerfGuard can ingest CSV/Insights traces from PS5/XSX/XSS dev kits and apply platform-aware regression budgets, treating each (scenario, platform, mode) tuple as its own baseline. The XSS budget is tight enough that catching a regression on XSX/PS5 alone misses the binding constraint.

• Upscaler Tuning — TSR vs FSR2/3 selection for console.
• Lumen Performance — the deep dive on the Lumen CVars above.
• AMD Vendor Tools — RGP for analyzing the RDNA 2 console silicon (proxy for PS5 / XSX).