Preflight: which apitrace builds are installed, where traces go, what is running.

Call this before anything else. Unlike the GUI-backed RE servers, apitrace needs no host application running -- but it does need the build whose bitness matches the game you intend to trace.

List trace files in the trace directory.

Inspect a game executable: bitness, graphics API, and how to trace it.

Reads the PE import table, so it answers "is this D3D8 or D3D9, and is it 32-bit" without launching anything. Delay-loaded imports are included -- older games often delay-load d3d9 behind a video-detection step.

Launch a game under apitrace and start capturing. Returns a session id.

This runs the game -- it does not block. Let the user play the part they want captured, then call trace_stop (ideally after they quit the game normally, so the trace is flushed cleanly).

api: gl, d3d7, d3d8, d3d9, or dxgi (D3D10/11). Empty auto-detects from the PE. method: 'iat' (default) or 'mhook'. Try mhook when a game loads the graphics DLL dynamically and IAT patching misses it.

Poll a trace or replay session: still running, trace size so far, log tail.

Stop a session and report the resulting trace.

Prefer quitting the game in-game first: a forced kill can lose the tail of the trace because apitrace never gets to flush.

All trace/replay sessions, including any still running from a previous server run.

Drop apitrace's wrapper DLL next to a game exe (the manual tracing route).

Use this when trace_launch produces nothing -- typically because the exe you launched is a launcher that spawns the real game, or the game re-launches itself for DRM. The wrapper then loads whenever the game starts, however it was started (including from Steam).

Any existing DLL of the same name -- ENB, ReShade, dgVoodoo, DXVK all use these filenames -- is backed up and restored by uninstall_wrapper. Always uninstall when you are done; a left-behind wrapper keeps tracing every run.

Remove wrapper DLLs installed by install_wrapper and restore any backups.

Summary of a trace file: API, call count, frame count (JSON from apitrace info).

Human-readable call dump, exactly as apitrace dump writes it. Good for eyeballing a stretch of a frame; use get_calls for numeric arguments. Calls: apitrace callset syntax: '42' one call, '0,2,4' a set, '100-2000' a range, '0-1000/2' every 2nd, '0-1000/draw' draw calls only, '0-1000/fbo' render-target changes, 'frame' the end-of-frame calls, '@file.txt' read from a file.

Structured calls with real argument values via apitrace pickle. Long arrays and blobs are summarized. Calls: apitrace callset syntax: '42' one call, '0,2,4' a set, '100-2000' a range, '0-1000/2' every 2nd, '0-1000/draw' draw calls only, '0-1000/fbo' render-target changes, 'frame' the end-of-frame calls, '@file.txt' read from a file.

Regex search over function names across the trace; returns counts and call numbers.

The cheapest way to find out whether a game uses fixed-function transforms or shader constants: search 'SetTransform|SetVertexShaderConstant'.

Function-frequency profile over a call range -- the fastest way to see what a game does.

Scanning the whole of a large trace is slow; limit caps how many calls are read (default 200k).

Break a frame down: draw calls, render-target switches, shader binds.

Pass a callset covering one frame, e.g. calls='120000-125000'. Use trace_info(per_frame=True) or list_frames to find the boundaries.

Frame boundaries as call numbers, so you can scope other queries to one frame.

Find and classify every 4x4 matrix the game sends to the driver.

This is the core VR/camera-hacking tool. It covers:

• fixed-function transforms -- SetTransform(D3DTS_VIEW/PROJECTION/WORLD), glLoadMatrixf/glMultMatrixf, glFrustum/glOrtho;

• shader constants -- SetVertexShaderConstantF and friends, tracked through a shadow register file so matrices uploaded piecemeal still resolve, and reported as the register range that holds them (e.g. vs_c[8..11]);

• uniform/constant buffer uploads -- glBufferData, UpdateSubresource and the memcpy calls apitrace records for writes to mapped memory, reported as a byte offset into the buffer (set scan_buffers=false to skip);

• both storage orders, since D3D9 shader constants usually hold the transpose.

Results are grouped by slot. Read them as: kind=projection -> the game's FOV, near and far planes kind=rigid + changes_per_frame -> camera candidate; confirm with track_camera kind=viewproj in vs_c[...] -> the register range a VR patch rewrites kind=viewproj at a buffer offset -> the bytes a VR patch rewrites kind=ortho -> HUD/UI or shadow pass

Scope with calls (a single frame is usually enough and far faster).

Decode 16 floats as a 4x4 matrix: FOV, near/far, handedness, camera position.

Accepts whitespace-, comma- or newline-separated numbers -- paste them straight out of a memory dump, a Cheat Engine watch, or a shader constant. Both storage orders are tried, so you do not need to know whether the source was row- or column-major.

Follow the camera across frames: world position, forward vector and FOV.

Picks the most view-like matrix slot automatically, or pass source with a slot name from find_matrices. If the eye position changes as the player moved during the capture, you have found the real view matrix -- that is the confirmation step before taking the offset into Ghidra or ReGenny.

List shader creation calls with a source preview or bytecode size.

Use extract_blobs to write D3D shader bytecode out for disassembly.

Write binary arguments (shader bytecode, vertex/index/constant buffers) to files.

Scope tightly with calls -- buffer uploads are large and there are many. The scan walks at most max(limit*500, 20000) calls of the callset, so blobs beyond that walk cap are not found; narrow calls if the result looks short.

Replay up to a call and dump the full pipeline/device state as JSON.

The apitrace equivalent of RenderDoc's pipeline view for OpenGL and D3D8/D3D9. DirectDraw and D3D7 traces are capture-only upstream and cannot be replayed for state inspection.

Replay has to run the trace on this machine's GPU up to that call, so it is slow and it can fail on very old games whose resources the driver no longer likes. If it fails, trim_trace to a short range first.

Replay the trace and write PNG images (per frame, or per specified call).

Useful for finding which draw call produces the HUD, the world, or the problem you are chasing -- dump images at every draw in a frame and look.

Make a raw call/frame slice of a trace.

A slice beginning at call/frame zero often remains replayable and makes every downstream tool faster. A mid-run OpenGL slice can omit setup/resources; use gltrim_trace when replayability matters.

OpenGL-specific frame trim that preserves replay setup state.

Run apitrace's object-leak checker against a trace.

Repack a trace with Snappy, Brotli, Zstandard, or zlib compression.

Compare two traces with apitrace's semantic call-stream differ.

Capture and compare complete retracer state at two calls.

Compare image sets and create an HTML report plus new diff/thumbnail sidecars.

Upstream writes sidecars beside the source prefixes. This wrapper refuses to run if any potential sidecar already exists and never enables --overwrite.

Stream-edit trace enum/string symbols or trace properties into a new trace.

Replay a trace in the background (session-based). Returns a session id.

profile: '', 'cpu', 'gpu', 'frames', 'pixels', 'memory', 'calls', 'frame_metrics', or 'draw_metrics'. Profiling output lands in the session log -- poll it with trace_status.