Debugging
Suite
CPU flame graphs, GPU frame captures, memory snapshots, and network timelines in one window. Attach over the wire to any running build on any platform.
One session, every timeline
The Debugging Suite is a single client that attaches to a running build and exposes every performance surface you care about in the same session. CPU samples, GPU frames, memory allocations, network traffic, physics islands, and audio voices all share one clock so you can cross reference without exporting anything.
Attach is over the network. A console dev kit, a mobile device on the local Wi Fi, or a cloud hosted dedicated server all expose the same wire protocol. The client does not care where the target runs.
Sessions can be saved and replayed. A one minute capture on a tester machine is small enough to check into a ticket and large enough to diagnose most shipped regressions without a repro.
What the suite shows you
Sampler and flame graphs
A low overhead sampler that runs in production builds, per thread flame graphs, and a call tree view that aggregates across a window. The instrumented path adds markers without recompilation when you need finer grain.
- Sampling profiler with less than 2 percent overhead
- Per thread flame graphs
- Aggregated call tree with hot path ranking
- Runtime marker injection
Frame capture with shader step
Capture a single frame, inspect every pass, and step through any shader invocation. Render target previews at each stage and cost per draw call in nanoseconds.
- Pass by pass render target preview
- Shader debugger with variable inspection
- Per draw nanosecond timing
- Pipeline state diff between draws
Heap snapshots and retention
Take a heap snapshot before and after a suspect scene transition. The diff view shows what stayed alive, which category grew, and which pointer chain holds the reference. This is usually enough to close a leak in ten minutes.
- Heap diff with retention graphs
- Allocation bucket breakdown per system
- Leak detector with source stacks
- Large allocation alerts in production
Transport timeline
A packet level timeline that lines up with the CPU and GPU timelines above it. See a snapshot arrive, the tick it feeds, and the frame it influences in one glance. Replays include the wire traffic.
- Packet level decoding for the transport
- Snapshot to tick to frame correlation
- Loss and reorder visualization
- Replay works offline without the server
How teams use it in practice
Hitch chase
Capture a ten second window with the sampler running. Flame graph points to the thread, the call tree points to the function, fix lands in a branch within the hour.
GPU cost audit
Frame capture, sort passes by duration, find the outlier. The pipeline state diff tells you why this draw is paying a full state change when the one next to it did not.
Console regression
QA attaches to a dev kit, captures a session, and drops the file in the ticket. Engineering replays it locally on a workstation and never touches the hardware.
Works with
Attach to a build
The SDK ships with a stress scene that intentionally spikes the CPU, GPU, and network. Attach to it and explore every timeline in under five minutes.