Skip to content
| Marketplace
Sign in
Visual Studio Code>Debuggers>WinDBG for VS CodeNew to Visual Studio Code? Get it now.
WinDBG for VS Code

WinDBG for VS Code

Preview

tmidorikawa

|
120 installs
| (0) | Free
Read-only Windows crash dump analysis and experimental TTD trace, memory and PE/PDB inspection. WinDBG-compatible commands on macOS and Windows without DbgEng.
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

windbg-vscode

A VS Code extension for analyzing Windows crash dumps (.dmp), with experimental static inspection of TTD trace containers, recorded thread identities, memory pages and PE image metadata (.run), plus explicitly selected, verified initial GPR snapshots and bounded, event-local debug-text reconstruction. General TTD replay is not implemented.

It runs on macOS and Windows. There is no dependency on DbgEng.dll or dbghelp: the dump is parsed from scratch, and symbol resolution, disassembly and type information are provided by the LLVM tools installed on your machine.

Budget policy: GitHub Actions is permanently prohibited, including Actions-backed Copilot PR reviews. Verification runs locally; see Development Workflow. The interactive VS Code Copilot tools are unaffected.

Table of Contents

  • windbg-vscode
    • Table of Contents
    • Features
    • Requirements
    • Getting Started
    • Usage
      • Open a capture and see what it is
      • Find out why it crashed
      • Work through the threads
      • Inspect memory and disassembly
      • WinDBG views
      • Inspect a TTD trace (experimental)
      • Keep notes beside a capture
    • Commands
    • MEX commands
      • MEX commands that cannot run here
      • Differences from MEX
    • GitHub Copilot
    • Claude Code
    • Settings
    • Supported Files
    • Limitations
    • Roadmap
    • Privacy
    • License

Features

  • WinDBG-compatible experience
    • A classic WinDBG-style command window
    • Clickable command-output links for module details, thread selection, disassembly and memory inspection
    • A detachable, read-only memory and disassembly window for crash dumps and TTD traces at a Time Travel position, with byte, integer, floating-point and pointer views and optional thread IP/SP following
    • Compatibility with the debugger commands
    • Analysis of .dmp crash dumps
    • Experimental .run container, thread-ID, lifetime-bound, initial GPR snapshot, recorded-memory, PE/PDB identity and eligible debug-output inspection, without a Windows replay runtime
  • Symbol resolution through symbol servers
  • Invocation from GitHub Copilot for VS Code through eight bounded analysis tools
  • The same tools for Claude Code through a local MCP server, off by default

Requirements

Tool Version Purpose
Visual Studio Code 1.129.0 or later Runs the extension
LLVM 22 or later Symbol resolution, disassembly and type information
Azure CLI Current Optional authentication for runtime-configured private symbol servers

Install LLVM with brew install llvm on macOS, or use an official LLVM release on Windows. The extension discovers llvm-symbolizer, llvm-pdbutil and llvm-mc from PATH, from the standard Homebrew location, and from the standard Windows install locations. You can also point windbg.llvm.toolPath at the directory that contains them.

Symbols and type information need only llvm-symbolizer and llvm-pdbutil. llvm-mc is needed only for disassembly (u, uf, ub, #) and assembly (a); without it those commands report that llvm-mc was not found. The official Windows installer (LLVM-<version>-win64.exe) does not include llvm-mc.exe: to get disassembly there, extract the full clang+llvm-<version>-x86_64-pc-windows-msvc.tar.xz archive from the LLVM releases page and point windbg.llvm.toolPath at its bin directory.

Without LLVM you can still open a dump and inspect its structure; commands that need symbols, disassembly or type information report that the tools are unavailable. Static TTD inspection does not need LLVM, WinDbg or an .idx file and never downloads symbols.

Symbol downloads use VS Code's network settings (http.proxy, http.systemCertificates, http.fetchAdditionalSupport).

In Remote-SSH, WSL and Dev Containers, the extension runs where the file lives and needs LLVM there; only macOS and Windows hosts are supported.

The symbol path you already use with WinDbg is honoured. _NT_SYMBOL_PATH and then _NT_ALT_SYMBOL_PATH are read, and the forms srv*<cache>*https://<server>, symsrv*symsrv.dll*<cache>*https://<server>, cache*<directory> and a bare local directory are recognized. Each https:// server is queried after the entries of windbg.symbols.servers, the first cache directory the path names is used when windbg.symbols.cachePath is empty, and its local directories (a bare one, or a directory in the server position of a srv* element) are searched after those of windbg.symbols.localPaths. The cache and local directories are fixed when a dump opens; the servers are read again for every request. An element the extension cannot use, such as an http:// server, is skipped; WinDBG: Show Symbol Diagnostics reports how many were skipped, never the elements themselves. Turn off windbg.symbols.useEnvironmentPath to ignore both variables.

Private symbol server addresses and token audiences are never embedded in the repository or VSIX. Set endpoints through the machine-scoped windbg.symbols.servers setting or WINDBG_VSCODE_SYMBOL_SERVERS, then give each private endpoint a profile in the machine-scoped windbg.symbols.authentication setting (or WINDBG_VSCODE_SYMBOL_AUTHENTICATION at runtime). Two schemes are supported.

Personal access token, the scheme Azure DevOps symbol servers document:

{ "endpoint": "https://artifacts.dev.azure.com/<organization>/_apis/symbol/symsrv", "kind": "personalAccessToken" }

Create a token with the Symbols (read) scope, then run WinDBG: Set Symbol Server Credential and paste it. It is held in the operating system keychain through VS Code's secret storage, never in a setting or a synced file, and is sent as HTTP Basic with an empty user name. WinDBG: Clear Symbol Server Credential removes it.

Azure CLI, for endpoints that accept a Microsoft Entra token:

{ "endpoint": "https://symbols.example.test/store", "kind": "azureCli", "argument": "scope", "audience": "api://symbols.example.test/.default" }

argument is resource or scope. Sign in with az login first.

az login alone does not authenticate a symbol endpoint: the extension still needs one windbg.symbols.authentication profile per private endpoint to select the token resource or scope.

In both cases the credential is attached only when the normalized request endpoint exactly matches its profile, and is never forwarded to the signed blob URL the server redirects to.

Requests to an endpoint without a matching authentication profile are unauthenticated. Public servers may accept them; private servers may return a sign-in page or a refusal instead of an artifact. Sign-in pages and refusals are reported rather than retried: run WinDBG: Show Symbol Diagnostics to see what each endpoint answered, by position and HTTP status. A connection that fails before the server starts to answer, and HTTP 408, 425, 429, 500, 502, 503 and 504 responses, are tried up to three times with a short delay (500 ms, then 1.5 s, or the server's Retry-After up to 10 seconds). 404, 401 and 403 are final answers.

Private builds and local symbol files. To analyze a crash of a build that is on no symbol server, list the directories that hold its images and PDBs (for example the build output folder) in the machine-scoped windbg.symbols.localPaths setting. They are searched before any server and also work with windbg.symbols.offline. In each directory the extension looks for <dir>\<name>\<key>\<name> (the layout of a symbol store and of the extension's own cache), <dir>\symbols\<ext>\<name>, <dir>\<ext>\<name> and <dir>\<name>, where <ext> is the module's extension (dll, exe, sys). A file is used only when it is the exact build recorded in the dump: an image needs the recorded timestamp and size, a PDB the recorded signature and an age that is not older. A file that merely shares a name is never used, and .reload reports how many such files were skipped. A matching file is copied into the symbol cache, so rebuilding it in place later does not change what the cache verified, and the directory itself is never modified. When the symbol cache cannot be written (a full disk, for example), .reload reports how many matching files could not be imported, with the error code. At most 8 directories are used and entries must be absolute paths. The list is read when a dump is opened, so close and reopen a dump after changing it; .reload then picks up files added since. Paths are never printed. A directory on a network share that is unavailable delays opening the dump until the operating system gives up.

The extension imposes no artifact-size limit. Large product PDBs can exceed 5 GB, so automatic resolution may use substantial network bandwidth, disk space and time. An individual artifact transfer times out after nine hours. Large downloads are split into resumable parts (always for authenticated servers, and for artifacts of 64 MiB or more from servers that accept byte ranges) and transient failures are retried while data continues arriving. Assembling the parts needs free space for a second copy of the artifact. If a server sends no data for 60 seconds, its transfer is stopped and the next configured server is tried. Run the command again to continue from saved parts after a timeout or stalled transfer. Every requested artifact is queued with at most four active acquisitions, and simultaneous requests for the same cache entry share its in-flight work. Closing the panel cancels the downloads it started. Press Escape or click Cancel next to the command input to stop the downloads of the running command without closing the panel: the command still finishes with the symbols it already has, reports how many artifacts remain unavailable and keeps the session and its output, and running it again downloads the rest. The status line shows completed artifacts out of the batch total and names an artifact still being processed. When its transfer size is known, it also shows the actual downloaded percentage and byte counts, for example Downloading (7/8): large.pdb - 50% (3.0 GiB / 6.0 GiB). Resumed parts are included without counting retries twice; unknown sizes show downloaded bytes without a percentage. The percentage describes the transferred file (the compressed form when applicable), not the whole batch. Assembly, expansion, validation and retries have distinct status labels. Commands entered in the meantime wait until the batch and command finish, and stopping the downloads skips them; incomplete acquisition and stalled transfers are reported per endpoint in WinDBG: Show Symbol Diagnostics.

Getting Started

  1. Install the extension.
  2. Open a .dmp or .run file. It opens in the WinDBG Dump Analyzer editor.
  3. Type a command in the command window at the bottom and press Enter.

If the file opens as text instead, right-click it and choose Open With… → WinDBG Dump Analyzer.

The command input becomes available after the capture loads successfully. Unsupported files and failed loads keep it disabled with an explanation; after a failed load, run WinDBG: Restart Analyzer Session or close and reopen the capture to retry.

Usage

Command results contain WinDBG-style links. Click a module name to show its details (lmv a ...), a thread number to switch threads (~<n>s), a stack frame number to select that frame (.frame 0n<n>), a stack call site to disassemble it (u ...), or a memory address to inspect bytes or pointers (db ... / dps ...). Hover over a link to see its command, or use Tab and Enter to activate it from the keyboard. Linked commands use the same history and execution path as typed commands, leave unfinished input intact, and are disabled while a command or symbol download is running. Output layout and copied plain text are unchanged.

Right-click a link for Copy Command, which copies the command the link runs, and Copy Link Text, which copies the text of the link, such as a module name or an address. The extension host puts it on the clipboard, and nothing runs. Ctrl+Shift+click (Cmd+Shift+click on macOS) on a link, or Ctrl+Shift+Enter on a focused one, copies its text instead of running it.

Select output text with the mouse or the keyboard and press Ctrl+C (Cmd+C on macOS) to copy it as plain text with one output line per line. Ctrl+A followed by Ctrl+C copies every retained output line, including the lines that are scrolled out of view (up to windbg.output.scrollbackLines), exactly like WinDBG: Copy Command Output. Text selected in the command input is copied as usual.

Press Escape while a command is running to stop it. A symbol download is cancelled and the command finishes with the symbols it already has. A scan of a TTD trace stops without a restart. Any other command runs on the analyzer's single worker thread, which cannot be interrupted, so the analyzer asks for confirmation and then restarts that worker and parses the capture again: aliases, breakpoints, memory edits and the thread selection are discarded, while the output log and the command history are kept. A GitHub Copilot tool session on the same capture ends when the analyzer is restarted; the tools then say to call windbg_openDump again.

WinDBG: Restart Analyzer Session restarts the analyzer of the active capture: its worker parses the capture again, aliases, breakpoints, memory edits and the thread selection are discarded, and the output log and the command history are kept. It is also the way back after the worker stopped unexpectedly, and opening the same capture in another editor does the same for every editor that holds it.

Press Ctrl+F (Cmd+F on macOS) to search the output. The find bar looks through everything the log still retains, not only the rows on screen, ignores case and shows which match is current (3 of 12, or 12 件中 3 件 when the controls are in Japanese; at most 10,000 matching rows are counted, then the count is shown as 10000+). Enter and Shift+Enter (or F3 and Shift+F3) move to the next and previous match, and Escape closes the bar and returns to the command input. An Escape in the find bar only closes the bar; it never stops a running command.

Paste several lines into the command input to run each line as its own command, in order. Every command is echoed and added to the history like a typed one, empty lines are skipped, and text after the last line break stays in the input as a draft, so a script pasted without a trailing line break does not run its last line by accident. A line runs exactly as typed, so a line that holds several ;-separated commands is still one command line. At most 32 lines can be pasted at once. Escape skips the pasted commands that have not started yet and then stops the running one as described above; restarting the analyzer, or a capture that changed on disk, also skips the rest. A screen reader hears a pasted script once, when its last command finishes.

To run the same commands every time you open a dump, list them in windbg.command.startupCommands, for example ["!analyze -v", "k"]. Once a crash dump is ready, its command window runs them in order exactly like pasted lines: each is echoed and added to the history, the status line shows how many are left, and Escape skips the ones that have not started. They run again after WinDBG: Restart Analyzer Session. An entry that is not one command line of 1 to 2048 characters is skipped, and the command window says how many were skipped; a list of more than 32 entries runs nothing and says so. The list is read when the dump opens, and TTD traces and the GitHub Copilot tools never run it.

Press Tab with the cursor at the end of the first word in the command input to complete it to a debugger command name, as in WinDBG. A single match is completed and its syntax is shown in the status line (vert becomes vertarget ). With several matches the first one is put in place, each further Tab puts the next one and Shift+Tab the previous one, and the status line shows the syntax of the one selected and its place in the list (Syntax: version (2 of 3), or 構文: version(3 個中 2 個目) when the controls are in Japanese; when more than 64 names match, the first 64 are offered and counted as 64+). Case is ignored only when no name matches as typed (LM completes to lm). The name is followed by a space with the cursor after it, and any arguments after the first word are kept. Escape ends the stepping without changing the text, and typing or moving the cursor ends it too. Everywhere else Tab moves keyboard focus as usual: in an empty input, away from the end of a word that can be completed, with Shift held and no list being stepped through, and on the second press after a word that matches nothing.

Tab at the end of a later word completes it as an argument, in the same way: a register name after @ (? @ri becomes ? @rip , from the registers of the current thread's context), a pseudo-register after $ or @$ ($t1, $ip, $exentry, ...), module!prefix from the public symbols of that module that are already in the local symbol cache (completion never downloads symbols, so a (deferred) module offers nothing; run .reload first), and a module name as the first argument of lm m, lmv m and .reload. Case is ignored, and the status line shows the kind and the name (Register: @rip, Pseudo-register: $t10 (2 of 11), or レジスタ: @rip when the controls are in Japanese). Other arguments, such as addresses, are not completed, and a TTD trace completes command names only.

Press Up and Down in the command input to step through the commands entered so far, newest first; Down past the newest one brings back what you had typed. As in WinDBG, a command entered again moves to the newest place in the history instead of being listed twice (only an identical command line moves, so lm and LM stay two entries). Shift+Up and Shift+Down step only through the commands that start with what the input held when the browsing began, ignoring case: type lm and press Shift+Up to recall the newest command that starts with lm. When no command in that direction matches, the input stays as it is, and changing the recalled text starts over from the newest command. Escape empties the command input and ends the browsing, except while a command runs (it then stops the command, as described above), while Tab completion steps through names (it then ends the stepping) and while the find bar is open.

Each command starts a block in the output log: its echo line and everything it printed. Every other block has a faint background, so you can see where the output of one command ends. Press Ctrl+[ and Ctrl+] (Ctrl, not Cmd, on macOS too) to select the previous and the next block, as in WinDBG; from the command input either key selects the newest block. The block is scrolled into view, with its first line at the top of the log when the log scrolls that far, and the cursor moves into the log, where Ctrl+C (Cmd+C on macOS) copies the whole block, the rows scrolled out of view included. A click in the log ends the block selection; scrolling, with the scrollbar too, does not. The keys are the ones labelled [ and ], wherever the keyboard layout puts them. On a layout that types the brackets with AltGr, such as German, the shortcut is not available.

Select 1 to 256 characters on one line of the output, such as a module name or an address, and press Ctrl+Alt+H to highlight every occurrence of that text in the log, ignoring case, as in WinDBG. Whitespace at either end of the selection, such as the spaces a double-click on Windows takes in after a word, is left out. Up to eight texts are highlighted at once, each in a colour of its own; a ninth replaces the oldest, and Ctrl+Alt+H on a text that is highlighted already takes its highlight off. Ctrl+Alt+Shift+H clears every highlight. Highlights cover everything the log retains, the output that arrives later included, and leave links, the selection, the find bar's marks and copied text as they are. While no command runs, the status line says what changed. The keys work in the output log, not in the command input, and highlights last as long as the analyzer is open. As with the block keys, H is the key labelled H, and on a layout that types a character with AltGr+H the shortcut is not available.

While a command runs, the command input stays available, as in WinDBG: type the next command and press Enter to queue it. The input is emptied and the status line counts the commands that wait (Queued: 2, or 予約: 2 when the controls are in Japanese), and lines pasted while a command runs join the same queue. Once the running command has finished, the queued commands run one after the other in the order they were entered, the way pasted lines do: each is echoed and added to the history when its turn comes, and a command that fails does not stop the ones after it. At most 32 commands can wait: a typed command that does not fit stays in the input, and a paste that does not fit queues none of its lines. Escape, or Cancel during a symbol download, stops the running command as described above and skips every queued command.

To run debugger commands that you keep in a text editor, such as the notes of an investigation, select the lines and choose WinDBG: Run Selection in WinDBG Analyzer from the editor's context menu or the Command Palette; with nothing selected, the whole document runs. Each line that the selection touches runs whole, as its own command, in the active analyzer or else the one that was active last, exactly like pasted lines: the whitespace around it is dropped, empty lines are skipped, each command is echoed and added to the history, and Escape in the command window skips the ones that have not started. The analyzer comes to the front of its editor group without taking the focus, so an editor in another group, such as the notes that WinDBG: Open Notes opens beside the analyzer, stays in view and keeps the focus; an editor in the same group is hidden behind the analyzer. At most 32 commands of at most 2,048 characters each run at once, and a line may hold no control character other than a tab; a selection that breaks one of these rules runs nothing and says why. While a command runs, the commands are queued as pasted lines are then, and a run that does not fit in the queue is refused whole. A run that reaches the command window while it is still opening the capture runs nothing and says so there; one made before the analyzer has finished loading its window runs nothing and says so in a warning. The command is offered while a crash dump or TTD trace is open and has no default keyboard shortcut.

Open a capture and see what it is

The dump is parsed on a worker thread, so the editor stays responsive even for a capture of several hundred megabytes. The banner reports the architecture, the module and thread counts, and the recorded exception. vertarget describes the machine that produced the capture (the Windows version, service pack, CPU, build lab, when the capture was taken and how long the process had been running, as far as the capture records them), and lm lists the loaded modules with the symbol state of each one.

The command window after opening a capture, showing vertarget and lm output

Find out why it crashed

!analyze -v classifies the fault, names the faulting module and thread, and prints the stack. It reports what the capture actually supports: frames recovered by scanning are labelled as such, and the output says when function names would need symbols. When the process has loaded a .NET runtime (coreclr.dll, clr.dll, mscorwks.dll or mscorsvr.dll, or libcoreclr.so / libcoreclr.dylib in a Linux or macOS minidump), the report names it and notes that managed frames are not decoded; !sos explains why.

!analyze -v output, showing the failure bucket, the faulting instruction and the stack

For a kernel crash dump (a blue screen), the banner names the bug check code, .bugcheck shows the code and its four parameters, vertarget describes the dump (its type, the processor count, when it was taken and the system uptime) and !analyze repeats the bug check. They do not classify the fault or walk a stack: that needs symbols.

In a kernel crash dump the kernel image is the module nt, as in WinDbg. A kernel module's image and PDB are fetched like those of a user-mode module, by the identity its PE headers in the dump carry, so x nt!*, ln, ? nt!Symbol and dt nt!_TYPE work once they are cached.

.process <EPROCESS> makes that process the implicit process, as in WinDbg: memory commands then translate addresses through its page tables, so its user-mode memory can be read (db, dq, dt), and .process alone returns to the process that was running when the dump was written. /p and /P are accepted, /r does not reload user-mode symbols (the module list of a kernel dump holds only kernel-mode modules), and /i needs a live target.

.thread <ETHREAD> makes that thread's registers the register context, so r and k show any kernel thread: a running thread has its processor's registers, and a waiting thread the instruction, stack and frame pointers its last context switch saved (the other registers show 0, as in WinDbg). .thread /p also makes the thread's process the implicit process, and .thread alone returns to the dump's own register context. A thread whose kernel stack was paged out cannot be shown.

Work through the threads

~ lists the threads with their names, and k walks the current one. Switch threads with ~<n>s and walk again. A command that needs symbols fetches them for the modules it touched and then runs again, so names resolve on the first attempt; .reload loads every module at once, .reload <module> (a name or a wildcard such as ntdll or nt*) only the modules it matches, and windbg.symbols.autoLoad turns the automatic behaviour off.

!uniqstack prints each distinct stack once and lists the threads that repeat it. On a capture with thousands of threads it stops after walking 65,536 stack frames, or when the stacks it shows fill the output limit, and then says how many threads it compared; ~<n>k walks a thread it did not reach.

The frame numbers in a stack are links that select the frame (.frame 0n<n>), in every form of k that prints them and in the row .frame, .f+ and .f- print. Only the stack of the current thread gets them: a stack printed for another thread (by ~1k, ~*k or !uniqstack) or walked from k = ... is not the one .frame selects from, so its frame numbers stay plain text.

The thread list and a stack walk

GitHub Copilot can perform the same triage through the language model tools, without changing the command window's current thread or starting an unapproved symbol download.

Automatic symbol retry freezes aliases and ENTER history before a download. Only replay-safe commands are rerun. Commands or chains that change session state or advance display positions run once, retain their output and show a warning instead; run .reload first when they need symbols. An explicit .reload, including an alias, ENTER repeat or command chain, acquires symbols before the prepared command executes.

.reload [/f] [Module] follows the WinDBG syntax (.reload (Reload Module)) as far as a read-only capture allows. /f asks the symbol servers again for every artifact the selected modules are missing, even one that an earlier request found absent. /d, /s, /v and /w have no effect on a capture and are accepted with a notice. /i, /l, /n, /o, /u, /unl and /user are refused with the reason, because the analyzer only loads symbol files that match the capture and neither unloads symbols nor lists modules with this command (use lm to list them).

A symbol file that every configured server (and Microsoft Public Symbols, when it is on) answered with "not found" is not requested again for one hour, so repeated commands on a module nobody has symbols for stay fast. The answer is remembered next to the symbol cache and holds only the module's name and key, a digest of the server list and a time, never a server address or a path. .reload /f asks the servers again at once, and a changed server list, WinDBG: Clear Symbol Cache and offline mode bypass or reset it. Only a definite "not found" is remembered: network errors, throttling, refusals and sign-in pages are always retried.

ThreadEx lists and captured thread stacks are also used when a separate memory stream is absent. Adjacent captured ranges can be read together, with deterministic handling of overlaps. Context flags determine which registers are available: CONTROL-only contexts remain usable, while an uncaptured frame pointer is reported as unavailable rather than zero.

Inspect memory and disassembly

With a crash dump or a TTD trace open, run WinDBG: Open Memory and Disassembly Window from the Command Palette. The separate read-only window shows bytes, ASCII, pointer targets and nearby instructions. Use the follow selector to keep the view fixed or follow the current thread's instruction or stack pointer. The unit selector shows memory as bytes, words, doublewords, quadwords, floats, doubles or pointers, the number format selector writes the integer units in hex, signed decimal or unsigned decimal, and the text column selector shows the bytes beside them as ASCII, as UTF-16 or not at all; the window remembers these choices with its address. Cells in a module image, in a thread's stack and in other captured memory are tinted, and a cell's tooltip names its module or stack thread and, when the dump records memory information, its protection, state and type as !address names them. After every command the window reads the page on screen again, also at a fixed address, and shows the bytes that changed since the previous read in a distinct colour until the next read. After a command that can change the instructions, such as an edit, a .reload that finds other symbol files or a !tt to another position, the disassembly pane reads them again too, where it is unless it follows the instruction pointer, so the change shows at once; other commands leave the pane as it is. The window shares the open dump session and does not save memory contents or register state. For a TTD trace the window reads the selected thread's Time Travel position and follows it after each !tt: the replayed bytes, ?? for every byte the replay does not know there, and instructions only where the code bytes are known. The thread status shows the thread and the position, such as Thread 0 at 1A:2F; until !tt sets a position, and again after a command such as ~0s leaves it, the window shows no bytes or instructions and says that it needs one. The trace's static recorded pages are not shown there, because they are not recorded for a thread and position. A !tt to another position marks the bytes that differ between the two positions, including the bytes the replay knows at only one of them.

In the disassembly pane, a direct branch or call shows its target after the instruction (the owning symbol and the address). Click it, or press Ctrl+Enter on the selected instruction, to move the pane and the grid there. An operand that names an address by itself (RIP-relative or absolute on x86 and x64, a literal load or adr on ARM64) shows that address instead, and following it moves only the grid. Back (or Alt+Left) returns; after a branch it takes the pane back to the instruction too. Hover a hexadecimal number in an instruction to see it in hexadecimal and as a signed and an unsigned 64-bit decimal.

Select Show source lines in the toolbar to show, above the instructions of each source line, the file name, the line number and the text of that line (demo.cpp(12): return 42;). The text appears when the source file can be read on this machine, after the windbg.source.pathMappings setting is applied; otherwise only the file name and the line number appear. On a TTD trace the lines come from the symbols of the modules open at the Time Travel position. The switch is off when a window opens and is remembered only for that window.

Each mnemonic in the pane takes a theme colour for how the instruction transfers control: calls, returns, conditional branches and unconditional branches each have their own, and other instructions keep the text colour.

WinDBG views

While a crash dump is open, the Run and Debug side bar shows WinDBG views next to VS Code's own debugging views. They show the active analyzer, or the crash dump analyzer that was active last while another editor is in front. A view that reads the dump reads it again after every command, and only while the view is expanded. Nothing a view shows is saved. A TTD trace has one view of its own, WinDBG TTD Timeline, described below.

WinDBG Threads lists the threads as ~ does: the thread number and ID, the thread's name beside them, and a mark on the current thread. Click a thread to make it current: the command window runs ~<n>s exactly as if you had clicked a link in its output, so the command is echoed and kept in the input history. While a command is running, a click runs nothing and the status line says so.

WinDBG Call Stack lists the current thread's frames as k walks them: the frame number and call site as k prints them, and the source file name and line beside a frame that has one. The frame that .frame selected is marked, and frame 0 keeps a mark of its own while another frame is selected. Click a frame to select it: the command window runs .frame 0n<n> as it would for a link in its output. The mark follows every command that moves the frame, such as .frame, ~<n>s, .cxr and .ecxr. At most 1,024 frames are listed, and the view says so when the stack is longer.

WinDBG Modules lists the loaded modules in the order lm lists them: the module name, and its address range beside it as lm prints it. The tooltip adds the symbol state lm shows, such as (deferred) or (export symbols), which follows .reload and every other command. Click a module to show its details: the command window runs lmv a <start>, the command the links of lm run. Unloaded modules are not listed, and when the capture's module list was cut, the view says so.

WinDBG Locals lists the parameters and local variables of the current frame as dv does, the parameters first: each one's name and value, with its type and location in the tooltip. It needs the module's private PDB. For a frame dv cannot list, for example without private symbols, for a frame other than the top one or in a kernel dump, the view shows the sentence dv prints instead.

WinDBG Command Tree shows the command tree that .cmdtree last loaded in the analyzer, named after the title the file gives it, or Command Tree when it gives none. Expand a node to see the nodes under it, and click a node that has a command to run it in the command window, as a click on a thread does. Each analyzer keeps its own tree, only in memory: a new .cmdtree replaces it, a restart of the session keeps it, and closing the analyzer drops it. Until a tree is loaded, the view says how to load one.

WinDBG Registers lists the registers r prints, in its order and as it prints them: those of the current thread at the frame .frame selected, in the register groups rm selected. A register whose value differs from the one the view showed the previous time it read the same analyzer is marked with a red dot, and its tooltip ends with "(changed)". That holds after you switch to another thread or frame too, because the view compares what it reads with what it showed just before. Nothing is marked when the views start showing an analyzer, including when you come back to one they showed before, and after the analyzer is restarted. Right-click a register and choose Copy Value to copy its value as shown. The command, WinDBG: Copy Value, is only on that menu, not in the Command Palette.

Whenever the current frame changes, for example after .frame, .f+, .f- or ~<n>s, or a click on a frame in WinDBG Call Stack or on a frame number in the output of k, the frame's source file opens beside the analyzer as a preview that does not take the focus, with the line in the middle and marked as VS Code marks the current stack frame's line. The mark moves with the frame and goes when the frame has no source or the analyzer closes. This works with the WinDBG views hidden too, but a file opens only while the analyzer is the active editor, so a command that runs in the background never brings up an editor. The file is found as ls . finds it, windbg.source.pathMappings included, and only a file that exists on this machine is opened. Turn this off with windbg.source.followFrame. WinDBG: Show Source of Current Frame opens the source once whatever the setting says, and tells you when the current frame has none.

WinDBG Parallel Stacks shows the stacks of all threads at once, each walked as ~*k walks it and merged from the innermost frame out. The items at the top are the innermost frames, and the frames that called a frame are under it: threads whose stacks start with the same frames share those items, and the tree branches where their callers differ. Each item says how many threads pass through it and lists their numbers, at most 32, in its tooltip, and the current thread's innermost frame is marked. Click an item that only one thread passes through to make that thread current and select that frame: the command window runs ~<n>s; .frame 0n<depth>. At most 256 frames of each thread and 8,192 items are shown, and the view says so when a stack is cut.

WinDBG Watch evaluates the expressions you add with the C++ evaluator of ??, and shows each value, or the error, as ?? prints it. Add one with the + button on the view's title bar or with WinDBG: Add Watch Expression in the Command Palette; right-click an expression to edit or remove it, and the title bar's Remove All Watch Expressions button empties the list. The list holds at most 32 expressions of at most 256 characters each. It belongs to the VS Code window, not to one dump, and is not saved. The view evaluates it against the analyzer it shows each time it reads again and right after the list changes. Evaluating runs no command and never downloads symbols: an expression that needs symbols that are not cached shows the message ?? prints for it, with an error icon. A value that differs from the one the view showed the previous time it read the same analyzer is marked with a red dot, and its tooltip ends with "(changed)". Nothing is marked when the views start showing an analyzer, including when you come back to one they showed before, and after the analyzer is restarted.

WinDBG TTD Timeline is the view of a TTD trace. While a trace is open it shows the active TTD analyzer, or the one that was active last. It lists, in position order, the recorded exceptions and custom events, where each thread's recorded activity begins and ends, the keyframes replay starts from, and the selected thread's Time Travel position, which moves after every command. Click an item to travel there: the command window runs ~<display-index>s; !tt <sequence>:<steps> as if you had clicked a link in its output. Items that replay cannot travel to, on a layout replay does not model or of the process rather than a thread, run nothing. The first reading scans the trace and can take time; if Escape cancels that scan, hide the view and show it again to read the timeline. At most 4,096 items are listed: when there are more, those around the Time Travel position.

Inspect a TTD trace (experimental)

Open a .run file directly, or use WinDBG: Open Crash Dump or TTD Trace. The worker validates the known x86/x64 TTDLog 1.9 and 1.11 layouts and reports the architecture, format and recorded-page count. Unknown versions, architectures and malformed structures are rejected rather than guessed. Storage pages use the verified 64 KiB selective, 256 KiB or 1 MiB layout selected by the header, rather than assuming every trace uses 1 MiB pages. Supported format, architecture and header-field combinations are listed in the development guide; unknown combinations are rejected, and the error names the rejected header values (format, variant, header field, architecture code and page exponent) so they can be compared with that list. Opening scans the container with bounded reads; a large trace can take time. Press Escape or select Cancel to stop a long TTD scan. Closing the editor releases its worker. An existing .idx file is neither required, read nor modified. Incomplete record headers are rejected, including after a storage-page boundary; they are not treated as a successful end of the stream. Record limits exclude zero padding and the terminator. The file has one container root. Header-shaped bytes in recorded memory are data, not extra sub-logs. The root directory's used size includes its eight-byte count/size header; records are variable-length, not a fixed-width table. Invalid counts, unknown record layouts, inconsistent page references and broken storage-stream links fail explicitly. !ttdinfo distinguishes process and thread storage streams, not active processes or threads. Recorded-memory traversal starts at each Page's first packet; no presumed 4 KiB prefix is discarded. Storage headers and packet-area counts/extents are validated separately. Packet-area sizes must be four-byte aligned. Opening a container does not certify that all packet types are decoded; unknown layouts and scan-limit stops are not a complete stream inventory. The bounded structural reader also validates extended packet-length fields, including module names and opaque execution records. No compression codec is guessed or enabled.

~ lists decimal display indexes, unique trace IDs and Windows (OS) thread IDs for verified 1.9 x86/x64, 256 KiB 1.11 x86/x64 and 1 MiB size-field-52/60 1.11 x64 layouts. These are identities recorded across the trace, not threads active at a particular position. Reused Windows thread IDs remain separate records. The list is limited to 4,096 identities; other thread-identity layouts are reported as unverified. A display index is neither a unique trace ID nor an OS ID.

No thread is selected when a trace opens. Click a display index or use ~<display-index>s (for example, ~0s) to restore that thread's initial GPR snapshot on demand. Selection moves to the thread's recorded initial point, reported as hexadecimal sequence:steps; it does not preserve a shared replay position. Only a complete, verified initial range and supported register-update prefix are accepted. Unsupported or incomplete state reports an error and retains the previous verified selection. Recorded-memory literals that wrap the unsigned address range within the required initial range are also rejected, even though memory at that point is not restored.

After successful selection, r lists the recorded full-width general-purpose registers, including the instruction pointer, and r rax (x64) or r eax (x86) reads a named register. Comma-separated names and an optional @ are accepted. Flags, SIMD, segments, register aliases, unknown or missing registers, assignments and stack views are not supplied or guessed. This is GPR-only: static recorded-memory reads do not become memory at the selected point.

TTD command Scope
~ Trace-wide identities, available lifetime bounds and decimal display indexes, not current threads
~<display-index>s Explicitly select that thread's verified initial GPR snapshot
r [Gpr[,Gpr...]] Read the selected initial GPRs, or the replayed registers at a Time Travel position; no assignments
!tt Sequence:Steps Replay the selected thread to a position (see Time Travel positions below)
!positions Show the selected thread's Time Travel position
t [Count] Replay Count instructions forward from the Time Travel position, into calls
p [Count] Replay forward from the Time Travel position, stepping over calls
t- [Count] / p- [Count] Go back Count instructions, into calls or over them (see Stepping back below)
g- Go back to the previous breakpoint hit, or to the keyframe that starts the replayable range
g Replay forward to the next breakpoint the selected thread hits (see Breakpoints below)
bp Address / ba Access Size Address Set an execute breakpoint, or an execute, read-or-write or write breakpoint on a range
bl / bc / bd / be List, clear, disable and enable the breakpoints by decimal ID or *
k, u, dps, ln, ?, dt, .reload Only at a Time Travel position; see Commands at a Time Travel position below
!ttdevents [StartIndex] Up to 256 verified metadata events, including profile-limited selective controls; not current state
.lastevent Latest recorded exception sequence, including all ties; does not select a position

Supported metadata subset: 1 MiB, size-field-52 traces in 1.9 x86/x64 and size-field-52/60 in 1.11 x64 provide recorded PID, OS version/build/platform and processor count through vertarget / !ttdinfo. For the size-field-52 profiles, lmv reads PE/PDB identity from the recorded image batch immediately preceding each load, including later loads and same-base reloads. Only bytes from that occurrence are combined; missing or conflicting bytes remain unavailable. The original static-memory window and memory commands are unchanged, and these are load-image metadata, not a claim about memory at an arbitrary execution position. ~ adds each thread's declared lifetime start, not its active start. Size-field-60 support is metadata-only: it does not enable initial GPR snapshots. This metadata subset does not extend to size-field-60 x86 or 256 KiB traces, including size-field 48. Their previously supported static inspection and initial-GPR features are unchanged. If lifetime metadata is unavailable, ~ retains verified identities and reports the reason.

For the metadata profiles above, including size-field-52 1.9 x86/x64 and 1.11 x64, ~ also reports finite exclusive thread lifetime ends or explicitly open ends, plus inclusive recorded active bounds. vertarget / !ttdinfo report the trace's aggregate active bounds, not a range filled with valid or replayable positions. Empty or unsupported accounting cannot create a zero-based range or a finite end. Unverified layouts still report lifetime ends as unavailable. These bounds do not restore registers, memory, a current thread or an exception state.

!ttdevents lists verified exception/custom records at their recorded sequence:0 positions. It preserves equal-position occurrences; displayed tie ordering is not execution ordering. Use the next-page link or a hexadecimal start index. .lastevent shows all exceptions at the latest recorded exception sequence, with flags, program counter, record address and up to 15 64-bit parameters. Neither command selects a thread or reports current exception state. The Windows ANSI/wide debug-print exception codes are identified in both commands. Text is available only for the bounded selective-profile cold windows described below; other paths report a reason. For 1 MiB, size-field-52 TTDLog 1.9 x86/x64, a two-parameter record also shows the recorded descriptor operands: address and element bound (bytes for ANSI, UTF-16 code units for wide). Both retain all 64 recorded bits, including zeros; they are not a validated pointer, readable range or restored text length. Unverified profiles and parameter counts report the descriptor unavailable while preserving the exception and raw parameters. This does not establish native operand narrowing, a general TTD event kind, encoding conversion or memory at the event position; neither parameters nor static memory are decoded as text. Other exception kinds/chance and unverified event families remain unavailable. The first lifetime or event request scans thread streams with bounded reads and may take time; later requests share the completed inventory. Closing the editor releases the worker. Events are limited to 4,096 records, 16 MiB of retained packet data and 250 million visited packets. Missing markers/clients, unknown framing and limits fail explicitly.

Selective metadata slice: TTDLog 1.11 x64 with variant 3, raw header field 308 and 64 KiB Pages exposes recorded process/module/client/exception metadata and the thread identities that own recorded Pages. Empty storage declarations are not counted as recorded threads. Verified counter layouts also supply finite/open thread lifetimes and inclusive thread/trace active bounds; unsupported accounting reports its reason rather than fabricating an endpoint. !ttdevents also shows process-stream custom events without inventing a thread, client-close data sizes, island starts and guarded replacement endpoints, and the observed pause/stop/throttle control gaps. A maximum native island endpoint is not a finite execution end or proof that recording continues. The verified island/gap patterns follow logical thread streams across storage Pages, including empty Pages. Reused activity pairs retain separate island occurrences, even after intervening activities. Unsupported prefixes or replacements still report the entire affected slice unavailable, not a successful partial inventory. These are selected metadata rules, not general gap/replay semantics. lmv also decodes each recorded load-image PE/PDB batch; an absent CodeView identity is distinguished from unavailable bytes. General memory and initial GPR selection remain disabled for this profile. Its verified ANSI descriptors have two parameters. Wide descriptors have four: the UTF-16 request and a separate ANSI fallback request, both displayed as raw operands. Fallback bytes are not substituted for Unicode text. Eligible events can reconstruct text from a complete recorded GPR/flags checkpoint, timed inputs and independently decoded guest instructions, without LLVM or a Windows runtime. Results are labeled reconstructed text and belong only to that event. Within the same cold sequence, a verified recorded RDSSPQ operation may supply its explicit destination update. It does not read the host shadow stack or assume CET is disabled; unverified fallback effects and sequence transitions remain unavailable. The bounded instruction subset includes verified XMM checkpoints, aligned and scalar vector moves, integer bit/multiply/sign-extension operations, selector/x87-control/MXCSR saves, division and bit scans, BMI1/BMI2, XCHG/XADD, bit-test-and-modify, packed-integer SSE2/AVX2 operations, REP STOS/REP MOVS, fences, GS-relative TEB operands, SSE2 scalar double-precision arithmetic, conversions and comparisons (all four MXCSR rounding modes, MXCSR exception flags tracked), PCMPISTRI, AESKEYGENASSIST, PEXTRW and memory-form MOVSS, and PUSHFQ only with known flags. Active instruction bytes can supply data reads, but conflicting views fail and process literals are not substituted; this does not add register groups to r. The AES rounds (AESENC, AESENCLAST, AESDEC, AESDECLAST, AESIMC), CRC32 and the SHA extensions follow their published definitions (FIPS-197, CRC-32C, FIPS 180-4); an unknown operand gives an unknown result. CMPXCHG16B, PMOVMSKB with REX.W and VEX VMOVQ between a 64-bit register and an XMM register follow the SDM; RDRAND and RDSEED take their value only from a recorded update and stop without one. Bounded FXSAVE preserves known saved fields, including a verified x87 tag and MXCSR mask; unknown FPU bytes remain unreadable rather than appearing as zero or earlier memory. Only a matching source-verified save image can supply bounded FXRSTOR fields; LDMXCSR checks the recorded mask. This does not enable general position navigation or interrupt returns. An x87 subset (loads, stores, arithmetic, compares, FXCH, FLDCW, FNSTSW, FNINIT, FNCLEX, WAIT) tracks the register stack, tag and status word under the default control word; unknown values, other control words, NaNs, stack faults, overflow and underflow stop instead of being approximated. The path must have the verified preserving exception boundary; unknown effects, warm-cache dependencies, missing bytes and unknown ANSI code pages remain explicitly unavailable. When non-ASCII ANSI bytes are fully reconstructed, they are shown as reconstructed ANSI bytes in hex, including the NUL terminator, while text remains unavailable until its code page is verified. No host code page or Unicode encoding is guessed. ASCII ANSI and valid UTF-16LE text are supported, including empty strings and surrogate pairs; wide output is never replaced by its separate ANSI fallback. The limits are 4,096 instructions, 4,096 combined cache/recorded-read inputs and 4,096 string bytes per event, one million scanned packets per thread per command, and 64 KiB of quoted text or hex-byte output per command. Only displayed events are reconstructed in one pass over each thread's stream. Neither initial-GPR selection nor static memory changes.

Use !ttdinfo (or vertarget) for container details and !ttdpages for up to 256 recorded pages at a time. Click an address to inspect its bytes, or the next-page link to continue the list. !ttdpages 100 starts at hexadecimal page index 100. For memory, use db Address [LCount], dw, dd or dq; for example, db 0x2000 L10 reads 16 bytes if that range is present. Addresses and counts are hexadecimal literals, and LCount counts items of the selected width. The default is 128 bytes; each request is limited to 64 KiB and must be fully and uniquely covered. Missing or overlapping ranges fail explicitly; an unsupported record disables memory reads. These commands retain the static recorded-page window following a uniquely framed, matching header-copy literal, through contiguous Pages of that process stream. The copy does not supply container structure, and this window is neither all recorded memory nor a position-specific snapshot. Missing or ambiguous copies and selection-budget limits leave the window unavailable. Memory-display switches, symbolic expressions, implicit addresses and mutations are not supported. .help lists this subset, ; chains commands, and empty ENTER repeats the last command.

On the verified metadata subset, lm lists every recorded module-load occurrence, not modules active at a selected position. lmv / lmv a Address add load positions, the recorded unload for each occurrence, image size, timestamp and checksum. Recorded unloads close the previously open load at the same base, including an unload followed by a reload at the same sequence. Load endpoints are inclusive and unload endpoints exclusive. An occurrence without a recorded unload remains open; it is not assigned a finite trace-end or process-exit position. Overlapping loads and unmatched unloads make metadata unavailable rather than inventing a pairing. Static PE/PDB details are associated only when base, size, timestamp and checksum match uniquely, and still do not establish memory at that point. Failures in that optional PE/PDB inspection are reported, not hidden as an ordinary missing match. Module names and PDB names are reduced to safe basenames; no symbols are downloaded. Process metadata uses at most one million packets, 4,096 entries per collection and 16 MiB total.

When module-event metadata is unavailable, lm retains the explicitly labeled static PE view and reports its metadata limitation. It lists PE headers recovered from recorded pages, not a loaded-module inventory. lmv or lmv a Address shows the recorded and preferred image bases separately, image size, COFF timestamp, entry-point RVA, section count and available PE/PDB symbol keys. Click an address to inspect its header bytes or a PDB basename for image details. Missing debug pages preserve the validated PE headers but report the PDB identity as unavailable; full PDB paths are never shown. Finding no PE headers does not establish that no modules were loaded. The image scan is limited to 4,096 candidates and 16 MiB of metadata, with at most 96 sections per mapped image. Page locations are indexed lazily for repeated reads; page bodies are not retained.

Time Travel positions. On the TTDLog 1.11, variant 3, header field 52, x64, 1 MiB layout, !tt Sequence:Steps moves the thread selected with ~<display-index>s to a Time Travel position, written as WinDbg prints one: hexadecimal sequence:steps without 0x, such as !tt 1A:0. A 0x prefix, as ~ and !ttdevents print positions, is accepted, and omitted steps are 0 (!tt 1A:). Replay starts from the thread's latest keyframe position at or before the position, a recorded entry-group register checkpoint (the thread's recorded initial point is usually one), and runs forward to it: at most 1,000,000 instructions per command, and Escape stops it. When the replay cannot continue first, for example at an instruction or record the extension does not model, at memory or registers it does not know, at the step limit or on Escape, the thread stays at the last verified position and the reason is printed before it. A position outside the thread's replayable activity (before its first keyframe, the closing step of a sequence, or after its recorded end) leaves the thread where it was and names up to 16 other threads whose recorded activity includes that sequence. Moving prints Time Travel Position: <sequence>:<steps> and the registers, as WinDbg does, and the prompt becomes 0:<display index>>, such as 0:000>. A position belongs to the selected thread only: this is the extension's own rule, not a claim that it matches WinDbg's process-wide position, and other threads are not placed at it. !positions (also !position) shows the thread and its position. At a position, r prints the replayed general-purpose registers, WinDbg's iopl= flags line, the segment selectors and efl, and r Register[,Register...] also reads mxcsr and xmm0–xmm15. A value the replay does not know prints ? for each digit, and an unknown flag prints ??. db / dw / dd / dq read the replayed memory at the position and print ?? for each byte the replay does not know there: what the trace did not record, and the replayed instructions did not write, by that point. ~<display-index>s returns to the thread's recorded initial point and leaves Time Travel, and the prompt returns to ttd:static>. Other layouts are refused with a message that names the layout.

Commands at a Time Travel position. At a position, k, u, dps (and dds, dqs), ln, ?, dt and .reload run as the dump analyzer runs them, over the replayed state: the selected thread's replayed registers, the replayed memory, and the modules that the recorded load events have loaded by that position, with the symbols of each module whose recorded load image names its PDB. This is the position's capability contract:

Command Reads at the position What stays unknown
k The replayed RIP and RSP Callers whose unwind data or stack memory the replay does not know; the walk ends there and says so
u The replayed code bytes (needs llvm-mc) Bytes the replay has not observed: Memory read error
dps / dds / dqs The replayed memory, and the module each value points into Unknown words print ?
ln The loaded modules and their symbols The function names of a module without symbols: module+0x…
? The replayed registers and memory An expression that reads an undefined flag or unknown memory is refused
dt Types from the module's private PDB, over the replayed memory A field over memory the replay does not know prints (not captured)
.reload The images and PDBs of the modules open at the position —

Symbols work as they do for a crash dump. Each module's image and PDB are named by the CodeView record of its recorded load image. They come from the symbol cache, the local symbol directories (windbg.symbols.localPaths) and, with .reload or when windbg.symbols.autoLoad is on, the symbol servers your settings allow. Addresses are named module!symbol+0x…; a module without symbols falls back to module+0x…, and an address in no module stays bare. Each position gets its own analyzer state: what these commands remember, for example where dps continues, and the module list are rebuilt when the position changes, and the loaded symbols stay while the same modules are open. Without a position these commands say that they need one.

Stepping. At a Time Travel position, t [Count] replays Count instructions of the selected thread forward, into calls, and p [Count] steps over calls: a call and everything up to the return that brings the call depth back count as one step (the extension counts the depth from the call and return instructions it replays). Count is hexadecimal, 1 through F4240 (1,000,000), and one command replays at most 1,000,000 instructions; Escape stops it. Both print the Time Travel Position and the registers once, where they end, while WinDbg displays each step of a count. When the replay cannot continue first, the thread stays at the last verified position and the reason is printed before it. t and p need a position set with !tt; crash dumps still refuse them.

Stepping back. t- [Count] goes back Count instructions, into calls, and p- [Count] steps back over calls: when the instruction before the position returned from a call, p- goes back to the call that made it. g- goes back to the start of the replayable range. Nothing runs in reverse: the extension replays the thread forward again, from a replay cursor it kept on the way or from the keyframe. It keeps one cursor every 10,000 steps of a keyframe's replay, at most 128 of them (the least recently used is dropped first), so a step back usually replays at most 10,000 instructions; one command replays at most 1,000,000, and Escape stops it and keeps the position. As the extension's own rule, a replayable range starts at the keyframe the position was replayed from: replay from one keyframe never runs into the next, so backward commands stop at that keyframe and say so, and !tt reaches earlier positions. WinDbg's g- goes back to the start of the trace instead. With breakpoints set, g- stops at the latest earlier position where one hits (see Breakpoints below).

Breakpoints. At a Time Travel position, bp Address sets a breakpoint where the selected thread's replay is about to execute that address, and ba Access Size Address sets one on a range: e (execute, size 1), r (read or write) or w (write), size 1, 2, 4 or 8, with the address a multiple of the size, such as ba w4 2000. g replays forward to the next position where an enabled breakpoint hits and g- back to the latest earlier one; each prints Breakpoint <id> hit, the Time Travel Position and the registers. An access breakpoint hits at the position just after the instruction that read or wrote the range, in both directions. Only the thread's own instructions count, as the extension's CPU model performs them, including an instruction the recorder replays from its recorded result: memory a system call writes does not. Without a hit, g stops where the replay stops, for example at the end of the thread's recorded activity, and g- at the keyframe that starts the replayable range, each with the reason; one command replays at most 1,000,000 instructions, and Escape stops it. bl lists the breakpoints, and bc, bd and be clear, disable and enable them by decimal ID or *. At most 32 breakpoints can be set, and they are kept for this session only. Only the selected thread is replayed, so breakpoints that other threads would hit, and the order between threads, are out of scope. bu and bm need symbols, which a trace does not load. p and p- stop at a breakpoint inside a call they step over, as WinDbg's p does, and print Breakpoint <id> hit; t and t- do not stop at breakpoints.

Travel links. On the layout that Time Travel positions support, the position that !ttdevents and .lastevent print for an event of a thread, and the active bounds that ~ prints for each thread, are links. A link runs ~<display-index>s; !tt <sequence>:<steps>: it selects the thread first, because !tt moves the selected thread, then replays there as !tt does, and prints the reason when the replay stops first. A declared lifetime start, an exclusive lifetime end and a process-stream row have no link, and other layouts get none.

Static inspection is not time-travel replay. The ttd:static> prompt remains until !tt sets a position, including after GPR selection, and static memory output labels bytes as static recorded pages, not memory at that initial point. Unverified lifetime layouts, position-specific thread and event state, stacks without a position, crash analysis and symbols are unavailable. No default thread, lifetime or exception state is fabricated.

Keep notes beside a capture

Run WinDBG: Open Notes to keep your own notes on a crash dump or TTD trace in a Markdown file next to it: the notes of C:\logs\foo.dmp are C:\logs\foo.dmp.notes.md. The Command Palette offers the command while an analyzer is open, and the … (More Actions) menu of the analyzer's title bar has it too. The notes open in a text editor beside the analyzer, or in the editor that already shows them. The first time, the file is created holding only the heading # Notes: foo.dmp, with the cursor below it. From then on the file is yours: the extension opens it as it is and never reads, changes or deletes it, so save it as you would any other file. Run while another editor is in front, the command opens the notes of the analyzer that was active last. When the file cannot be created, for example in a read-only folder, the error message names the file but not its folder.

Commands

The full command reference below describes dump analysis, plus the TTD-only commands !ttdinfo, !ttdpages, !ttdevents, !tt, !positions, t-, p- and g-. .run files accept only the static inspection, initial GPR snapshot and Time Travel position subset described above.

Use WinDBG: Open Memory and Disassembly Window to open the detachable read-only memory view for the active crash dump, or for a TTD trace at its Time Travel position.

The command window implements the commands below. Every command in the debugger's command reference is recognized. Implemented commands check their switches against the reference, and unavailable execution, port and MSR commands validate their full operand grammar before reporting what they need. A mistyped switch is therefore a syntax error rather than a silently ignored argument. Breakpoint and event-filter commands retain non-firing session setup state. Type .help for the whole set grouped by category, or .help memory for one group. The 100-entry Microsoft Learn table and the extension-command table are generated directly from the command registry, so their syntax and availability columns are the same data .help and command dispatch use.

.hh opens the debugger documentation on Microsoft Learn in your browser, and .hh <text> opens a Microsoft Learn search for <text> debugger command.

Microsoft Learn entry Registered syntax Availability in this analyzer
ENTER (Repeat Last Command) ENTER Implemented; capture-specific limits apply
$<, $><, $$<, $$><, $$>a< (Run Script File) $<File | $><File | $$<File | $$><File | $$>a<File [Args] Implemented; capture-specific limits apply
? (Command Help) ? [Expression] Implemented; capture-specific limits apply
? (Evaluate Expression) ? [Expression] Implemented; capture-specific limits apply
?? (Evaluate C++ Expression) ?? Expression Implemented; capture-specific limits apply
# (Search for Disassembly Pattern) # [Pattern] [Address [L Size]] Implemented; capture-specific limits apply
|| (System Status) || [SystemNumber] Implemented; capture-specific limits apply
||s (Set Current System) ||SystemNumber s Implemented; capture-specific limits apply
| (Process Status) | [ProcessNumber] Implemented; capture-specific limits apply
|s (Set Current Process) |ProcessNumber s Implemented; capture-specific limits apply
~ (Thread Status) ~ [ThreadNumber] Implemented; capture-specific limits apply
~e (Thread-Specific Command) ~Thread e Command Implemented; capture-specific limits apply
~f (Freeze Thread) ~Thread f Implemented; capture-specific limits apply
~u (Unfreeze Thread) ~Thread u Implemented; capture-specific limits apply
~n (Suspend Thread) ~Thread n Implemented; capture-specific limits apply
~m (Resume Thread) ~Thread m Implemented; capture-specific limits apply
~s (Set Current Thread) ~Thread s Implemented; capture-specific limits apply
~s (Change Current Processor) ~Thread s Implemented; capture-specific limits apply
a (Assemble) a Address Instruction Implemented; capture-specific limits apply
ad (Delete Alias) ad [/q] Name Implemented; capture-specific limits apply
ah (Assertion Handling) ah | ah{b|i|d} [Address] | ahc Implemented; capture-specific limits apply
al (List Aliases) al Implemented; capture-specific limits apply
as, aS (Set Alias) as [Options] Name Value Implemented; capture-specific limits apply
ba (Break on Access) ba[ID] Access Size [Options] [Address [Passes]] ["CommandString"] Implemented; capture-specific limits apply
bc (Breakpoint Clear) bc Breakpoints Implemented; capture-specific limits apply
bd (Breakpoint Disable) bd Breakpoints Implemented; capture-specific limits apply
be (Breakpoint Enable) be Breakpoints Implemented; capture-specific limits apply
bl (Breakpoint List) bl [/L] [Breakpoints] Implemented; capture-specific limits apply
bp, bu, bm (Set Breakpoint) bp[ID] [Options] [Address [Passes]] ["CommandString"] Implemented; capture-specific limits apply
br (Breakpoint Renumber) br OldID NewID [OldID2 NewID2 ...] Implemented; capture-specific limits apply
bs (Update Breakpoint Command) bs ID ["CommandString"] Implemented; capture-specific limits apply
bsc (Update Conditional Breakpoint) bsc ID Condition ["CommandString"] Implemented; capture-specific limits apply
c (Compare Memory) c Range Address Implemented; capture-specific limits apply
d, da, db, dc, dd, dD, df, dp, dq, du, dw, dW, dyb, dyd (Display Memory) d [Options] [Range]
da [Options] [Range]
db [Options] [Range]
dc [Options] [Range]
dd [Options] [Range]
dD [Options] [Range]
df [Options] [Range]
dp [Options] [Range]
dq [Options] [Range]
du [Options] [Range]
dw [Options] [Range]
dW [Options] [Range]
dyb [Options] [Range]
dyd [Options] [Range]
Implemented; capture-specific limits apply
dda, ddp, ddu, dpa, dpp, dpu, dqa, dqp, dqu (Display Referenced Memory) dda [Options] [Range]
ddp [Options] [Range]
ddu [Options] [Range]
dpa [Options] [Range]
dpp [Options] [Range]
dpu [Options] [Range]
dqa [Options] [Range]
dqp [Options] [Range]
dqu [Options] [Range]
Implemented; capture-specific limits apply
dds, dps, dqs (Display Words and Symbols) dps [Options] [Range] Implemented; capture-specific limits apply
dg (Display Selector) dg FirstSelector [LastSelector] Unavailable; the command reports the specific reason
dl (Display Linked List) dl [Options] ListAddress MaxCount Size Implemented; capture-specific limits apply
ds, dS (Display String) ds [/c Width] Address Implemented; capture-specific limits apply
dt (Display Type) dt [Options] [Type] [Address] Implemented; capture-specific limits apply
dtx (Display Type - Extended Debugger Object Model Information) dtx [-h] [-a] [-r[n]] [Module!]Name Address Implemented; capture-specific limits apply
dv (Display Local Variables) dv [Options] [Pattern] Implemented; capture-specific limits apply
dx (Display Debugger Object Model Expression) dx [Options] Expression Implemented; capture-specific limits apply
e, ea, eb, ed, eD, ef, ep, eq, eu, ew, eza, ezu (Enter Values) e Address Values
ea Address "String"
eb Address Values
ed Address Values
eD Address Values
ef Address Values
ep Address Values
eq Address Values
eu Address "String"
ew Address Values
eza Address "String"
ezu Address "String"
Implemented; capture-specific limits apply
f, fp (Fill Memory) f Range Pattern
fp Range Pattern
Implemented; capture-specific limits apply
Syntax validated; requires physical memory
g (Go) g[a] [= StartAddress] [BreakAddress ... [; BreakCommands]] Syntax validated; requires a live target
gc (Go from Conditional Breakpoint) gc Syntax validated; requires a live target
gh (Go with Exception Handled) gh[a] [= StartAddress] [BreakAddress ...] Syntax validated; requires a live target
gn, gN (Go with Exception Not Handled) gn[a] [= StartAddress] [BreakAddress ...] Syntax validated; requires a live target
gu (Go Up) gu Syntax validated; requires a live target
ib, iw, id (Input from Port) ib Port Syntax validated; requires a kernel target
j (Execute If - Else) j Expression Command1 ; Command2 Implemented; capture-specific limits apply
k, kb, kc, kd, kp, kP, kv (Display Stack Backtrace) k [Options] [FrameCount] Implemented; capture-specific limits apply
l+, l- (Set Source Options) l{+|-}[Option] Unavailable; the command reports the specific reason
ld (Load Symbols) ld Module [/f Filename] Implemented; capture-specific limits apply
lm (List Loaded Modules) lm [Options] [a Address] [m Pattern] Implemented; capture-specific limits apply
ln (List Nearest Symbols) ln [/D] Address Implemented; capture-specific limits apply
ls, lsa (List Source Lines) ls [.] [First] [, Count]
lsa [.] Address [, First [, Count]]
Implemented; capture-specific limits apply
lsc (List Current Source) lsc Implemented; capture-specific limits apply
lse (Launch Source Editor) lse Implemented; capture-specific limits apply
lsf, lsf- (Load or Unload Source File) lsf File
lsf- File
Implemented; capture-specific limits apply
lsp (Set Number of Source Lines) lsp [-a] [LeadingLines [TrailingLines]] Implemented; capture-specific limits apply
m (Move Memory) m Range Address Implemented; capture-specific limits apply
n (Set Number Base) n [Radix] Implemented; capture-specific limits apply
ob, ow, od (Output to Port) ob Port Value Syntax validated; requires a kernel target
p (Step) p[r] [= StartAddress] [Count] ["Command"] Syntax validated; requires a live target
pa (Step to Address) pa [r] [= StartAddress] StopAddress ["Command"] Syntax validated; requires a live target
pc (Step to Next Call) pc [r] [= StartAddress] [Count] Syntax validated; requires a live target
pct (Step to Next Call or Return) pct [r] [= StartAddress] [Count] Syntax validated; requires a live target
ph (Step to Next Branching Instruction) ph [r] [= StartAddress] [Count] Syntax validated; requires a live target
pt (Step to Next Return) pt [r] [= StartAddress] [Count] ["Command"] Syntax validated; requires a live target
q, qq (Quit) q
qq
Implemented; capture-specific limits apply
qd (Quit and Detach) qd Implemented; capture-specific limits apply
r (Registers) r [Options] [Register[=Value]] Implemented; capture-specific limits apply
rdmsr (Read MSR) rdmsr MSR Syntax validated; requires a kernel target
rm (Register Mask) rm [Mask] Implemented; capture-specific limits apply
s (Search Memory) s [Options] Range Pattern Implemented; capture-specific limits apply
so (Set Kernel Debugging Options) so [NOEXTWARNING] [NOVERSIONCHECK] Implemented; capture-specific limits apply
sq (Set Quiet Mode) sq | sq{e|d} Implemented; capture-specific limits apply
ss (Set Symbol Suffix) ss {a|w|n} Implemented; capture-specific limits apply
sx, sxd, sxe, sxi, sxn, sxr, sx- (Set Exceptions) sx
sxd [-c Cmd1] [-c2 Cmd2] [-h] Event
sxe [-c Cmd1] [-c2 Cmd2] [-h] Event
sxi [-c Cmd1] [-c2 Cmd2] [-h] Event
sxn [-c Cmd1] [-c2 Cmd2] [-h] Event
sxr
sx- [-c Cmd1] [-c2 Cmd2] Event
Implemented; capture-specific limits apply
t (Trace) t [r] [= StartAddress] [Count] ["Command"] Syntax validated; requires a live target
ta (Trace to Address) ta [r] [= StartAddress] StopAddress Syntax validated; requires a live target
tb (Trace to Next Branch) tb [r] [= StartAddress] [Count] Syntax validated; requires a live target
tc (Trace to Next Call) tc [r] [= StartAddress] [Count] Syntax validated; requires a live target
tct (Trace to Next Call or Return) tct [r] [= StartAddress] [Count] Syntax validated; requires a live target
th (Trace to Next Branching Instruction) th [r] [= StartAddress] [Count] Syntax validated; requires a live target
tt (Trace to Next Return) tt [r] [= StartAddress] [Count] Syntax validated; requires a live target
u (Unassemble) u [Range]
ub [Range]
uu [Range]
Implemented; capture-specific limits apply
uf (Unassemble Function) uf [Options] Address Implemented; capture-specific limits apply
up (Unassemble from Physical Memory) up Range Syntax validated; requires physical memory
ur (Unassemble Real Mode BIOS) ur Range Unavailable; the command reports the specific reason
ux (Unassemble x86 BIOS) ux Range Unavailable; the command reports the specific reason
vercommand (Show Debugger Command Line) vercommand Implemented; capture-specific limits apply
version (Show Debugger Version) version Implemented; capture-specific limits apply
vertarget (Show Target Computer Version) vertarget Implemented; capture-specific limits apply
wrmsr (Write MSR) wrmsr MSR Value Syntax validated; requires a kernel target
wt (Trace and Watch Data) wt [WatchOptions] [= StartAddress] [EndAddress] Syntax validated; requires a live target
x (Examine Symbols) x [Options] Module!Symbol Implemented; capture-specific limits apply
z (Execute While) Command ; [Processor] z(Expression) Implemented; capture-specific limits apply

Extension commands

Extension command Registered syntax Availability in this analyzer
.reload (Reload Symbols) .reload [/f] [Module] Implemented; capture-specific limits apply
.ecxr, .excr (Display Exception Context) .ecxr Implemented; capture-specific limits apply
.exr (Display Exception Record) .exr [Address | -1] Implemented; capture-specific limits apply
.cxr (Display Context Record) .cxr [Address | -1] Implemented; capture-specific limits apply
.lastevent (Display Last Event) .lastevent Implemented; capture-specific limits apply
.time (Display System Time) .time [-h Hours] Implemented; capture-specific limits apply
.bugcheck (Display Bug Check Data) .bugcheck Implemented; capture-specific limits apply
.dumpdebug (Display Dump Stream Directory) .dumpdebug Implemented; capture-specific limits apply
.cls (Clear Screen) .cls Implemented; capture-specific limits apply
.cmdtree (Display Command Tree) .cmdtree File Implemented; capture-specific limits apply
.help, help (Command Help) .help [Category] Implemented; capture-specific limits apply
.hh (Open HTML Help File) .hh [Text] Implemented; capture-specific limits apply
$$ (Comment Specifier) $$ [any text] Implemented; capture-specific limits apply
* (Comment Line Specifier) * [any text] Implemented; capture-specific limits apply
.block (Command Block) .block { Commands } Implemented; capture-specific limits apply
.echo (Echo Comment) .echo String Implemented; capture-specific limits apply
.if (Conditional Execution) .if (Expression) { Commands } [.elsif (Expression) { Commands }] [.else { Commands }] Implemented; capture-specific limits apply
.while (While Loop) .while (Expression) { Commands } Implemented; capture-specific limits apply
.do (Do Loop) .do { Commands } (Expression) Implemented; capture-specific limits apply
.for (For Loop) .for (Initial ; Expression ; Increment) { Commands } Implemented; capture-specific limits apply
.break (Break Out of a Loop) .break Implemented; capture-specific limits apply
.continue (Continue a Loop) .continue Implemented; capture-specific limits apply
.foreach (For Each Token) .foreach [Options] (Variable { InCommands }) { OutCommands } Implemented; capture-specific limits apply
.catch (Catch Command Errors) .catch { Commands } Implemented; capture-specific limits apply
!for_each_module (For Each Module) !for_each_module [CommandString] Implemented; capture-specific limits apply
!for_each_frame (For Each Frame) !for_each_frame [CommandString] Implemented; capture-specific limits apply
!for_each_local (For Each Local Variable) !for_each_local [CommandString] Unavailable; the command reports the specific reason
!ttdinfo (Inspect TTD Container (Static Only)) !ttdinfo Implemented; capture-specific limits apply
!ttdpages (List Recorded TTD Pages (Static Only)) !ttdpages [StartIndex] Implemented; capture-specific limits apply
!ttdevents (List Recorded TTD Event Metadata) !ttdevents [StartIndex] Implemented; capture-specific limits apply
!tt (Time Travel to a Position) !tt Sequence:Steps Implemented; capture-specific limits apply
!positions, !position (Display the Time Travel Position) !positions Implemented; capture-specific limits apply
t- (Trace Back) t- [Count] Implemented; capture-specific limits apply
p- (Step Back) p- [Count] Implemented; capture-specific limits apply
g- (Go Back) g- Implemented; capture-specific limits apply
!teb (Display the TEB) !teb [TEB-Address] Implemented; capture-specific limits apply
!peb (Display the PEB) !peb Implemented; capture-specific limits apply
!process (Display the Process) !process Implemented; capture-specific limits apply
!thread (Display the Current Thread) !thread Implemented; capture-specific limits apply
!handle (Display Handles) !handle [Handle [UMFlags [TypeName]]] Implemented; capture-specific limits apply
!bpmd, !clrstack, !comstate, !dumparray, !dumpasync, !dumpassembly, !dumpclass, !dumpdomain, !dumpheap, !dumpil, !dumplog, !dumpmd, !dumpmodule, !dumpmt, !dumpobj, !do, !dumpruntimetypes, !dumpsig, !dumpsigelem, !dumpstack, !dumpstackobjects, !dso, !dumpvc, !eeheap, !eestack, !eeversion, !ehinfo, !finalizequeue, !findappdomain, !findroots, !gchandleleaks, !gchandles, !gcinfo, !gcroot, !gcwhere, !heapstat, !histclear, !histinit, !histobj, !histobjfind, !histroot, !ip2md, !listnearobj, !name2ee, !objsize, !printexception, !pe, !procinfo, !rcwcleanuplist, !savemodule, !sosflush, !sosstatus, !stoponexception, !syncblk, !threadpool, !threads, !clrthreads, !threadstate, !token2ee, !verifyheap, !sos (SOS Managed (.NET) Commands) !clrstack | !dumpheap | !dumpobj | !pe | ... Unavailable; the command reports the specific reason
.formats (Show Number Formats) .formats Expression Implemented; capture-specific limits apply
.printf (Formatted Output) .printf [/D] [Option] "FormatString" [, Argument ...] Implemented; capture-specific limits apply
!address (Display Memory Regions) !address [Address] Implemented; capture-specific limits apply
!vprot (Display Virtual Memory Protection) !vprot Address Implemented; capture-specific limits apply
!gle (Display Last Error) !gle [-all] Implemented; capture-specific limits apply
!runaway (Display Thread Times) !runaway [Flags] Implemented; capture-specific limits apply
!error (Decode Error Value) !error Value [Flags] Implemented; capture-specific limits apply
.expr (Choose Expression Evaluator) .expr [/s Evaluator] [/q] Implemented; capture-specific limits apply
!analyze (Analyze the Recorded Fault) !analyze [-v] Implemented; capture-specific limits apply
!uniqstack (Display Unique Stacks) !uniqstack [-b | -v | -p] [-n] Implemented; capture-specific limits apply
.frame (Set Local Context) .frame [/c] [/r] [FrameNumber] Implemented; capture-specific limits apply
.f+, .f- (Shift Local Context) .f+ | .f- Implemented; capture-specific limits apply
.sympath (Set Symbol Path) .sympath [Path [; ...]] Unavailable; the command reports the specific reason
.sympath+ (Append to Symbol Path) .sympath+ [Path [; ...]] Unavailable; the command reports the specific reason
.symfix (Set Symbol Store Path) .symfix [LocalSymbolCache] Unavailable; the command reports the specific reason
.symfix+ (Append Symbol Store Path) .symfix+ [LocalSymbolCache] Unavailable; the command reports the specific reason
.symopt (Set Symbol Options) .symopt [Flags] Unavailable; the command reports the specific reason
.symopt+ (Add Symbol Options) .symopt+ Flags Unavailable; the command reports the specific reason
.symopt- (Clear Symbol Options) .symopt- Flags Unavailable; the command reports the specific reason
.exepath (Set Executable Path) .exepath [Directory [; ...]] Unavailable; the command reports the specific reason
.exepath+ (Append to Executable Path) .exepath+ [Directory [; ...]] Unavailable; the command reports the specific reason
.srcpath (Set Source Path) .srcpath [Directory [; ...]] Unavailable; the command reports the specific reason
.srcpath+ (Append to Source Path) .srcpath+ [Directory [; ...]] Unavailable; the command reports the specific reason
!sym (Noisy Symbol Loading and Prompts) !sym [noisy | quiet | prompts [off]] Unavailable; the command reports the specific reason
.cache (Set Cache Size) .cache [Size | Option] Unavailable; the command reports the specific reason
!lmi (Display Module Information) !lmi Module Implemented; capture-specific limits apply
!dh (Display Image Headers) !dh [-f | -s | -a] Address Implemented; capture-specific limits apply
!exchain (Display Exception Handler Chain) !exchain [/c | /C | /f] Implemented; capture-specific limits apply
.process (Set Process Context) .process [/i] [/p [/r]] [/P] [Process] Implemented; capture-specific limits apply
.thread (Set Register Context) .thread [/p [/r]] [/P] [/w] [Thread] Implemented; capture-specific limits apply
.load (Load Extension DLL) .load DLLName Implemented; capture-specific limits apply
.loadby (Load Extension DLL by Module) .loadby DLLName ModuleName Implemented; capture-specific limits apply
.unload (Unload Extension DLL) .unload [DLLName] Implemented; capture-specific limits apply
.unloadall (Unload All Extension DLLs) .unloadall Implemented; capture-specific limits apply
.chain (List Debugger Extensions) .chain [/D] Implemented; capture-specific limits apply
.extmatch (Display All Matching Extensions) .extmatch [/e ExtDLLPattern] [/n] [/D] Pattern Implemented; capture-specific limits apply
.setdll (Set Default Extension DLL) .setdll DLLName Implemented; capture-specific limits apply
.extpath, .extpath+ (Set Extension Path) .extpath[+] [Directory[;...]] Unavailable; the command reports the specific reason
!mex (Run a MEX Command) !mex [Name [Arguments]] Implemented; capture-specific limits apply
!mex.help (List the MEX Commands) !mex.help [-all] [Keywords] Implemented; capture-specific limits apply
!mex.grep, !grep (Filter the Output of a Command) !grep [-cs] [-v] [-A n] [-B n] [-C n] [-until Regex | -untilFinal Regex] Regex Command Implemented; capture-specific limits apply
!mex.count, !count (Count the Output of a Command) !count [-q | -qn] [-c] [-time] Command | -s String Implemented; capture-specific limits apply
!mex.head, !head (Display the First Lines of a Command's Output) !head [-s] [Lines] Command Implemented; capture-specific limits apply
!mex.tail, !tail (Display the Last Lines of a Command's Output) !tail [-l] [-s] Lines Command Implemented; capture-specific limits apply
!mex.tac, !tac (Display a Command's Output in Reverse) !tac Command Implemented; capture-specific limits apply
!mex.sort, !sort (Sort the Output of a Command) !sort [-f List [-d Delimiters] | -c List] [-ai | -ax] Command Implemented; capture-specific limits apply
!mex.foreachline, !foreachline, !mex.fel, !fel (Run Commands for Each Line of Output) !foreachline [-f Regex | -fs Regex] [-t] [-n Name] [-v] -x Command [-x Command ...] Command Implemented; capture-specific limits apply
!mex.foreachregex, !foreachregex, !mex.fer, !fer (Run Commands for Each Regex Match) !foreachregex -f Regex [-n Name] [-v] -x Command [-x Command ...] Command Implemented; capture-specific limits apply
!mex.exec, !exec (Run a Series of Commands) !exec [-x Command | -xs Command] ... Implemented; capture-specific limits apply
!mex.if, !if, !mex.mif, !mif (Run Commands Depending on Output) !if [-co | -nco] [-MinLines n] [-MaxLines n] [-cr Regex | -ncr Regex] [-x Command ...] [-else Command ...] Command Implemented; capture-specific limits apply
!mex.uniquestacks, !uniquestacks, !mex.us, !us, !mex.usk, !usk (Display Each Unique Stack Once) !uniquestacks [Options] [FILTER] Implemented; capture-specific limits apply
!mex.findcrash, !findcrash, !mex.fc, !fc (Find the Crashing Threads) !findcrash [-u] [-k] [-p Process] [-a] Implemented; capture-specific limits apply
!mex.foreachmatchingstack, !foreachmatchingstack, !mex.fems, !fems (Run a Command on Each Matching Stack) !foreachmatchingstack [Options] (ThreadId | -s Regex | -e Regex | -guid Hash) Command Implemented; capture-specific limits apply
!mex.t, !t, !mex.tc, !tc, !mex.tv, !tv, !mex.ta, !ta, !mex.tf, !tf, !mex.tk, !tk, !mex.tid, !tid (Display a Thread) !t [Options] [ThreadId] Implemented; capture-specific limits apply
!mex.listthreads, !listthreads, !mex.lt, !lt, !mex.ltv, !ltv (List the Threads and What They Wait On) !listthreads [-v] [Options] [Process] Implemented; capture-specific limits apply
!mex.runaway2, !runaway2 (Display the Threads That Used the Most CPU Time) !runaway2 [-u | -k | -t] [-a] [-q] [-v] [Count] Implemented; capture-specific limits apply
!mex.foreachthread, !foreachthread, !mex.fet, !fet (Run a Command for Each Thread) !foreachthread [-q] [-ns] [-t] Command Implemented; capture-specific limits apply
!mex.foreachframe, !foreachframe, !mex.fef, !fef (Run a Command for Each Frame) !foreachframe [-q] [-f Filter] [-l Limit] [-m Max] [-s Skip] Command Implemented; capture-specific limits apply
!mex.foreachmodule, !foreachmodule, !mex.fem, !fem, !mex.thirdpartymods, !thirdpartymods, !mex.managedmods, !managedmods (Run a Command for Each Module) !foreachmodule [-q] [-U] [-u | -k] [-f Filter [-ff Field]] [Command] Implemented; capture-specific limits apply
!mex.frame, !frame, !mex.f, !f, !mex.fx, !fx (Select a Frame of a Thread) !frame [-t ThreadId | -d DebuggerThreadId] [-r] [-x] [Frame] Implemented; capture-specific limits apply
!mex.context, !context, !mex.w, !w, !mex.whereami, !whereami (Display the Current Process, Thread and Frame) !context [-s | -r] Implemented; capture-specific limits apply
!mex.dr, !dr (Display the Registers with the Volatile Ones Marked) !dr Implemented; capture-specific limits apply
!mex.stackinfo, !stackinfo, !mex.si, !si (Display the Bounds of a Thread's Stack) !stackinfo [-u] [Thread] Implemented; capture-specific limits apply
!mex.addstack, !addstack, !mex.as, !as (Collect Thread Stacks and List the Distinct Ones) !addstack [-u [Filter]] [-c] [Thread] Implemented; capture-specific limits apply
!mex.p, !p, !mex.pid, !pid (Display the Process) !p [-pid PID] [-min] [-v] [-z] [-i] [Process] Implemented; capture-specific limits apply
!mex.commandline, !commandline, !mex.cl, !cl (Display the Process Command Line) !commandline [-a] [-v] [Process] Implemented; capture-specific limits apply
!mex.path, !path (Display the PATH Entries) !path Implemented; capture-specific limits apply
!mex.computername, !computername, !mex.cn, !cn, !mex.hostname, !hostname (Display the Computer Name) !computername Implemented; capture-specific limits apply
!mex.mods, !mods, !mex.m, !m, !mex.mu, !mu, !mex.mk, !mk, !mex.mut, !mut (Display the Loaded Modules) !mods [-q] [-l] [-k | -u] [-i] [-info] [-v] [-3] [-n] [-s SortString] [-r] [-clr] [Filter] Implemented; capture-specific limits apply
!mex.imports, !imports (Display the Import Table of a Module) !imports [-u | -k] [-a] [-i] [-iat] [-m] [-f Filter] [-3] [Module] Implemented; capture-specific limits apply
!mex.imgscan, !imgscan (Scan Memory for PE Images) !imgscan [Process] Implemented; capture-specific limits apply
!mex.diffimg, !diffimg (Compare the Module List with Memory) !diffimg Implemented; capture-specific limits apply
!mex.criticalsection, !criticalsection, !mex.cs, !cs (Display the Critical Sections) !criticalsection [-a] [-v] [Address] Implemented; capture-specific limits apply
!mex.rtlresource, !rtlresource, !mex.res, !res (Display the RTL Resources) !rtlresource [-a] [-v] [Address] Implemented; capture-specific limits apply
!mex.loaderlock, !loaderlock, !mex.ll, !ll (Display the Loader Lock) !loaderlock [-a] [-v] Implemented; capture-specific limits apply
!mex.loader, !loader, !mex.ldr, !ldr (Display the Loader State) !loader [-d] [-f] Implemented; capture-specific limits apply
!mex.tasklist, !tasklist, !mex.tl, !tl, !mex.z, !z, !mex.tlz, !tlz, !mex.tlt, !tlt, !mex.tltu, !tltu, !mex.tlp, !tlp, !mex.tlc, !tlc, !mex.tlm, !tlm (List the Processes of a Kernel Dump) !tasklist [-n Name] [-z | -Z] [-s [SessionNumber]] [-u [UserName]] [-j [JobAddress]] [-pid PID] [-parentpid PID] [-exit] [-crash] [-prot] [-proc] [-gflag] [-cl] [-cpu] [-mem] [-memCommit] [-memShared] [-memVirtual] [-memTotal] [-awe] [-t | -tu] [-stat] [-sort Column [-top [Count]]] [-tree] [Filter] Implemented; capture-specific limits apply
!mex.running, !running (Display the Thread Running on Each Processor) !running [-dpc] Implemented; capture-specific limits apply
!mex.ready, !ready, !mex.rdy, !rdy (Display the Ready Threads) !ready [-cpu CPU] Implemented; capture-specific limits apply
!mex.readyish, !readyish, !mex.ry, !ry (Display the Threads That Neither Wait nor Run) !readyish [-cpu CPU] Implemented; capture-specific limits apply
!mex.deferredready, !deferredready, !mex.dfr, !dfr (Display the Deferred Ready Threads) !deferredready Implemented; capture-specific limits apply
!mex.standby, !standby, !mex.sby, !sby (Display the Standby Threads) !standby Implemented; capture-specific limits apply
!mex.transition, !transition, !mex.trans, !trans (Display the Threads in Transition) !transition Implemented; capture-specific limits apply
!mex.initialized, !initialized, !mex.init, !init (Display the Initialized Threads) !initialized Implemented; capture-specific limits apply
!mex.gatewait, !gatewait (Display the Threads in the GateWait State) !gatewait Implemented; capture-specific limits apply
!mex.waiting, !waiting (Count the Waiting Threads by Wait Reason) !waiting Implemented; capture-specific limits apply
!mex.err, !err, !mex.errn, !errn (Look Up an Error Code) !err [-d] Error | -n Name [-x] Implemented; capture-specific limits apply
!mex.cut, !cut (Display Parts of Each Line of a Command's Output) !cut (-f [-d Delimiters] | -c | -l) List Command Implemented; capture-specific limits apply
!mex.uniqlines, !uniqlines, !mex.ul, !ul (Count the Distinct Lines of a Command's Output) !uniqlines [-q] [-c] [-b] [-i] [-t Count] Command Implemented; capture-specific limits apply
!mex.tr, !tr, !mex.replace, !replace (Replace Text in a Command's Output) !tr Set1 Set2 Command | -d Set1 Command Implemented; capture-specific limits apply
!mex.sum, !sum (Add Up the Numbers in a Command's Output) !sum [-q] [-n] [-dec] Command Implemented; capture-specific limits apply
!mex.dumpinfo, !dumpinfo, !mex.di, !di (Display Capture Information) !dumpinfo [-v] Implemented; capture-specific limits apply
!mex.comment, !comment (Display the Capture Comment) !comment [-v] Implemented; capture-specific limits apply
!mex.dumptime, !dumptime (Display the Capture Times) !dumptime [-v | -c] [-f Value] Implemented; capture-specific limits apply
!mex.tx, !tx (Convert Tick Counts) !tx [-s | -v] [Ticks1 [Ticks2]] Implemented; capture-specific limits apply
!mex.shareduserdata, !shareduserdata, !mex.sud, !sud (Display KUSER_SHARED_DATA) !shareduserdata Implemented; capture-specific limits apply
!mex.showextraprocessstream, !showextraprocessstream (Display the Extra Process Stream) !showextraprocessstream Implemented; capture-specific limits apply
!mex.exceptionrecords, !exceptionrecords, !mex.mexr, !mexr (Display the Exception Records on the Stack) !exceptionrecords [-l | -p Address | Address] Implemented; capture-specific limits apply
!mex.dumpstowedexception, !dumpstowedexception (Display the Stowed Exceptions) !dumpstowedexception Implemented; capture-specific limits apply
!mex.a, !a (Run the MEX Analysis of the Dump) !a Implemented; capture-specific limits apply
!mex.crash, !crash (Run the First Steps of a Crash Analysis) !crash [-v] [-c] Implemented; capture-specific limits apply
!mex.da, !da (Display an ANSI String on One Line) !da [-a | -v | -s Size] Address Implemented; capture-specific limits apply
!mex.du, !du (Display a Unicode String on One Line) !du [-a | -v | -s Size] Address Implemented; capture-specific limits apply
!mex.strings, !strings (Display the Strings in a Memory Range) !strings [-s] [-f] [-l Length] [-min Min] [-max Max] (Start [End | LCount] | -m Module) Implemented; capture-specific limits apply
!mex.dumpstackstrings, !dumpstackstrings, !mex.dss, !dss (Display the Strings on the Current Stack) !dumpstackstrings Implemented; capture-specific limits apply
!mex.bin, !bin (Display Bytes as Hex Digits and Text) !bin [-b] [-t] [-f] Count Address Implemented; capture-specific limits apply
!mex.dps, !dps (Display Pointers with Their Stack Offsets) !dps [-offset sp | bp | both] Range Implemented; capture-specific limits apply
!mex.dqs, !dqs (Display Quadwords with Their Stack Offsets) !dqs Range Implemented; capture-specific limits apply
!mex.interpretrawstack, !interpretrawstack, !mex.irs, !irs (Interpret the Raw Stack Frame by Frame) !interpretrawstack Implemented; capture-specific limits apply
!mex.parsemem, !parsemem (Count the Distinct Values in a Memory Range) !parsemem (-q | -d) Start End Implemented; capture-specific limits apply
!mex.findstack, !findstack (Find a Stack That Leads to a Thread Start) !findstack [-t ThreadId | -b StackBase] [-cxr] Address Implemented; capture-specific limits apply
!mex.fnent, !fnent (Display the Function Table Entry of an Address) !fnent Address Implemented; capture-specific limits apply
!mex.formats, !formats, !mex.fb, !fb, !mex.fd, !fd (Display Chosen Number Formats) !formats [-x] [-d] [-o] [-b] [-c] [-t] [-f] [-u] Number Implemented; capture-specific limits apply
!mex.filetime, !filetime, !mex.ft, !ft (Display a FILETIME) !filetime Address | -t Value Implemented; capture-specific limits apply
!mex.datetime, !datetime (Display a .NET DateTime) !datetime Address | -t Value Implemented; capture-specific limits apply
!mex.rollup, !rollup, !mex.ru, !ru (Roll Up a Byte Count) !rollup [-b | -kb | -mb | -gb | -tb | -pb | -eb | -zb | -yb] (Bytes | -fel Command [-t]) Implemented; capture-specific limits apply
!mex.eflags, !eflags (Decode the Flags Register) !eflags [-v [-r] [-x]] Implemented; capture-specific limits apply
!mex.mrmsg, !mrmsg, !mex.msg, !msg (Name a Window Message) !mrmsg Message | -d Implemented; capture-specific limits apply
!mex.ioctl, !ioctl (Decode an I/O Control Code) !ioctl Code Implemented; capture-specific limits apply
!mex.loop, !loop (Run a Command for Each Value of a Count) !loop [-q] (Start End Increment | -c Count [-s Start] [-i Increment]) Command Implemented; capture-specific limits apply
!mex.bits2, !bits2, !mex.b2, !b2 (Run a Command for Each One-Bit Change of an Address) !bits2 -m Address Command Implemented; capture-specific limits apply
!mex.time, !time (Time a Command) !time [-q] [-t Seconds] Command Implemented; capture-specific limits apply
!mex.line, !line, !mex.l, !l, !mex.lh, !lh (Print a Separator Line) !line [-e] [-h] Implemented; capture-specific limits apply
!mex.foreachitem, !foreachitem, !mex.fei, !fei (Run Commands for Each Item of a List) !foreachitem Address [-o Offset] [-nohead] [-x Command ...] [-q] [-c] [-m Count] Implemented; capture-specific limits apply
!mex.foreacharrayitem, !foreacharrayitem, !mex.feai, !feai (Run Commands for Each Item of an Array) !foreacharrayitem Address (-m Count | -end Address) [-t Type] [-x Command ...] [-c] Implemented; capture-specific limits apply
!mex.dumpnativearray, !dumpnativearray, !mex.dna, !dna (Display Each Structure of an Array) !dumpnativearray -t Type -c Count Address Implemented; capture-specific limits apply
!mex.foreachavlentry, !foreachavlentry, !mex.fea, !fea (Run Commands for Each AVL Table Entry) !foreachavlentry Address [-x Command ...] [-q] [-c] [-m Count] Implemented; capture-specific limits apply
!mex.foreachhashentry, !foreachhashentry, !mex.feh, !feh (Run Commands for Each Hash Table Entry) !foreachhashentry Address [-x Command ...] [-q] [-c] [-m Count] Implemented; capture-specific limits apply
!mex.rbtree, !rbtree, !mex.rb, !rb (Display the Nodes of a Red-Black Tree) !rbtree Address [-q] Implemented; capture-specific limits apply
!mex.btree, !btree (Display the Structures of a Binary Tree) !btree (-e Address NodeType LinksField | -n Address NodeType LinksType) Implemented; capture-specific limits apply
!mex.ip, !ip (Display an IPv4 Address) !ip [-r] [-n] Value Implemented; capture-specific limits apply
!mex.byteorder, !byteorder, !mex.ntoh, !ntoh, !mex.hton, !hton (Swap the Byte Order) !byteorder [-n | -h] Value Implemented; capture-specific limits apply
!mex.base64, !base64, !mex.b64, !b64 (Decode Base64 Text) !base64 [-u] [-x] Address | -s Text [-x] Implemented; capture-specific limits apply
!mex.asn, !asn, !mex.der, !der (Decode ASN.1 Data) !asn -p Address [-l Length] [-b | -d] Implemented; capture-specific limits apply
!mex.ndso, !ndso (Display the C++ Objects on the Stack) !ndso [-a] [-l Count] [-so] [-to] Implemented; capture-specific limits apply
!mex.ndro, !ndro (Display the C++ Objects in the Registers) !ndro Implemented; capture-specific limits apply
!mex.ndto, !ndto (Display the C++ Objects in the TLS Slots) !ndto Implemented; capture-specific limits apply
!mex.classtype, !classtype, !mex.ct, !ct (Display the Classes of an Object) !classtype Address Implemented; capture-specific limits apply
!mex.dumpvtable, !dumpvtable, !mex.vt, !vt (Display a Virtual Function Table) !dumpvtable [-t Type | -o Object | Address] Implemented; capture-specific limits apply
!mex.ndao, !ndao (Display the C++ Objects in Memory) !ndao [-s | -a] [Start [End]] Implemented; capture-specific limits apply
!mex.searchobjs, !searchobjs, !mex._so, !_so (Run a Command for Each Object of a Class) !searchobjs [-c Command] [-p Suffix] Symbol Implemented; capture-specific limits apply
!mex.searchpointers, !searchpointers, !mex._selmtp, !_selmtp (Find the Pointers to an Address) !searchpointers Address Implemented; capture-specific limits apply
!mex.findobj, !findobj (List the Objects of a Class) !findobj Type Implemented; capture-specific limits apply
!mex.gflag, !gflag, !mex.gflags, !gflags (Display the Global Flags) !gflag [-u] [-k] Implemented; capture-specific limits apply
!mex.ver, !ver (Display the Windows Version) !ver Implemented; capture-specific limits apply
!mex.impersonation, !impersonation, !mex.imp, !imp (Display Whether the Thread Impersonates) !impersonation Implemented; capture-specific limits apply
!mex.publicsymbolcreep, !publicsymbolcreep (List Modules with Public Symbols Only) !publicsymbolcreep Implemented; capture-specific limits apply
!mex.threadpool, !mex.tp, !tp (Display the NT Thread Pools) !mex.threadpool [-tp] [-v] [-wt Pool] [Pool] Implemented; capture-specific limits apply
!mex.chk, !chk, !mex.chkall, !chkall (Compare Module Code with the Image Files) !chk [-as] [-u | -k] [-b] [Module] Implemented; capture-specific limits apply
!mex.unassemble, !unassemble, !mex.u, !u, !mex.ub, !ub, !mex.uf, !uf, !mex.ufc, !ufc, !mex.un, !un (Unassemble Code with Branch Targets) !unassemble [-b | -f | -fc | -n] Address [Length] Implemented; capture-specific limits apply
!mex.outline, !outline, !mex.ol, !ol (Outline the Calls of a Function) !outline Function Implemented; capture-specific limits apply
!mex.x, !x, !mex.xv, !xv, !mex.xx, !xx (Examine Symbols Without Funclets) !x [-function] [-v] [-x] [Arguments] Implemented; capture-specific limits apply
!mex.ddt, !ddt (Display a Type with Links) !ddt [-r | -r1 | -r2] [-address] [-table] [-x Command] Arguments Implemented; capture-specific limits apply
!mex.delayexecution, !delayexecution (Display the Threads Waiting with DelayExecution) !delayexecution [-p] Implemented; capture-specific limits apply
!mex.executive, !executive (Display the Threads Waiting with Executive) !executive [-p] Implemented; capture-specific limits apply
!mex.maximumwaitreason, !maximumwaitreason (Display the Threads Waiting with MaximumWaitReason) !maximumwaitreason [-p] Implemented; capture-specific limits apply
!mex.suspended, !suspended (Display the Threads Waiting with Suspended) !suspended [-p] Implemented; capture-specific limits apply
!mex.userrequest, !userrequest (Display the Threads Waiting with UserRequest) !userrequest [-p] Implemented; capture-specific limits apply
!mex.wralertbythreadid, !wralertbythreadid (Display the Threads Waiting with WrAlertByThreadId) !wralertbythreadid [-p] Implemented; capture-specific limits apply
!mex.wrcpuratecontrol, !wrcpuratecontrol (Display the Threads Waiting with WrCpuRateControl) !wrcpuratecontrol [-p] Implemented; capture-specific limits apply
!mex.wrexecutive, !wrexecutive (Display the Threads Waiting with WrExecutive) !wrexecutive [-p] Implemented; capture-specific limits apply
!mex.wrfastmutex, !wrfastmutex (Display the Threads Waiting with WrFastMutex) !wrfastmutex [-p] Implemented; capture-specific limits apply
!mex.wrfreepage, !wrfreepage (Display the Threads Waiting with WrFreePage) !wrfreepage [-p] Implemented; capture-specific limits apply
!mex.wrkernel, !wrkernel (Display the Threads Waiting with WrKernel) !wrkernel [-p] Implemented; capture-specific limits apply
!mex.wrkeyedevent, !wrkeyedevent, !mex.wrke, !wrke (Display the Threads Waiting with WrKeyedEvent) !wrkeyedevent [-p] Implemented; capture-specific limits apply
!mex.wrlpcreceive, !wrlpcreceive, !mex.lpcs, !lpcs (Display the Threads Waiting with WrLpcReceive) !wrlpcreceive [-p] Implemented; capture-specific limits apply
!mex.wrlpcreply, !wrlpcreply, !mex.lpcw, !lpcw, !mex.lpcc, !lpcc (Display the Threads Waiting with WrLpcReply) !wrlpcreply [-p] Implemented; capture-specific limits apply
!mex.wrpagein, !wrpagein (Display the Threads Waiting with WrPageIn) !wrpagein [-p] Implemented; capture-specific limits apply
!mex.wrpageout, !wrpageout (Display the Threads Waiting with WrPageOut) !wrpageout [-p] Implemented; capture-specific limits apply
!mex.wrpushlock, !wrpushlock (Display the Threads Waiting with WrPushLock) !wrpushlock [-p] Implemented; capture-specific limits apply
!mex.wrqueue, !wrqueue (Display the Threads Waiting with WrQueue) !wrqueue [-p] Implemented; capture-specific limits apply
!mex.wrresource, !wrresource (Display the Threads Waiting with WrResource) !wrresource [-p] Implemented; capture-specific limits apply
!mex.wruserrequest, !wruserrequest (Display the Threads Waiting with WrUserRequest) !wruserrequest [-p] Implemented; capture-specific limits apply
!mex.wrvirtualmemory, !wrvirtualmemory (Display the Threads Waiting with WrVirtualMemory) !wrvirtualmemory [-p] Implemented; capture-specific limits apply
!mex.cpu, !cpu (Display the State of the Processors) !cpu [CpuNumber] Implemented; capture-specific limits apply
!mex.dpcstack, !dpcstack, !mex.dpcq, !dpcq (Find the Call Stack on a DPC Stack) !dpcstack [-n CpuNumber] Implemented; capture-specific limits apply
!mex.evt, !evt (Display a Kernel Event) !evt Address Implemented; capture-specific limits apply
!mex.mutant, !mutant, !mex.mutex, !mutex (Display a Kernel Mutant) !mutant Address Implemented; capture-specific limits apply
!mex.semaphore, !semaphore, !mex.sem, !sem (Display a Kernel Semaphore) !semaphore Address Implemented; capture-specific limits apply
!mex.fastmutex, !fastmutex, !mex.fm, !fm (Display a Fast Mutex) !fastmutex Address Implemented; capture-specific limits apply
!mex.timers, !timers, !mex.timer, !timer (Display System Timers) !timers [TimerAddress] Implemented; capture-specific limits apply
!mex.wq, !wq (Display Executive Work Queues) !wq [-s] [-w [Routine]] [-t] [-p Priority] [-q Queue] [Partition] Implemented; capture-specific limits apply
!mex.kqueue, !kqueue, !mex.kq, !kq (Display a Kernel Queue) !kqueue [-w] Address Implemented; capture-specific limits apply
!mex.eresource, !eresource, !mex.eres, !eres (Display the Executive Resources) !eresource [-v] [-mv] [-nw] [-a] [Address] Implemented; capture-specific limits apply
!mex.fasteresource, !fasteresource, !mex.fasteres, !fasteres (Display a Fast Executive Resource) !fasteresource Address Implemented; capture-specific limits apply
!mex.pushlock, !pushlock, !mex.pl, !pl (Find the Owner of a Push Lock) !pushlock Thread [PushLock] Implemented; capture-specific limits apply
!mex.deadlocks, !deadlocks, !mex.dls, !dls, !mex.waittree, !waittree (Find the Deadlocked Kernel Threads) !deadlocks [-a] Implemented; capture-specific limits apply
!mex.hang, !hang, !mex.hw, !hw, !mex.hc, !hc (Analyze a Kernel Hang) !hang [-c] [-w [-a] [-fast] [-s SessionNumber] [-p ProcessAddr]] Implemented; capture-specific limits apply
!mex.mheap, !mheap (Display the NT Heaps) !mheap [-flt Size] [-pa] [Address] Implemented; capture-specific limits apply
!mex.deviceobject, !deviceobject, !mex.devo, !devo, !mex.deo, !deo (Display a Device Object) !deviceobject [-q] Address Implemented; capture-specific limits apply
!mex.driverobject, !driverobject, !mex.drvo, !drvo, !mex.dro, !dro (Display a Driver Object) !driverobject [-v] Address Implemented; capture-specific limits apply
!mex.fileobject, !fileobject, !mex.fo, !fo (Display a File Object) !fileobject [-q] Address Implemented; capture-specific limits apply
!mex.poolsearch, !poolsearch (Search Pool Pages for the Blocks of a Tag) !poolsearch Start End Tag Implemented; capture-specific limits apply
!mex.tag, !tag (Find Where Kernel Modules Use a Pool Tag) !tag [-v] [-a] [-m Module] Tag Implemented; capture-specific limits apply
!mex.dtpool, !dtpool, !mex.dtp, !dtp (Display a Pool Allocation as Its Structure) !dtpool [-f] [-v] Address Implemented; capture-specific limits apply
!mex.mem, !mem (Display Memory Usage Information) !mem [-npp] [-pp] [-commit] Implemented; capture-specific limits apply
!mex.memreport, !memreport (Display Process Memory by Image Name) !memreport Implemented; capture-specific limits apply
!mex.job, !job, !mex.ejob, !ejob (Display a Job Object) !job [-q] JobAddress Implemented; capture-specific limits apply
!mex.session, !session, !mex.sessions, !sessions, !mex.sess, !sess (Display the Sessions) !session [-s Session | -q Session] [SessionId] Implemented; capture-specific limits apply
!mex.trustlets, !trustlets, !mex.trustlet, !trustlet (List the Trustlets) !trustlets Implemented; capture-specific limits apply
!mex.werfault, !werfault, !mex.wer, !wer (List the WerFault Processes) !werfault Implemented; capture-specific limits apply
!mex.minws, !minws (List Large Minimum Working Sets) !minws [-v] Implemented; capture-specific limits apply
!mex.obj, !obj, !mex.winobj, !winobj (Browse the Kernel Object Namespace) !obj [-t [Type]] [-p Path] [Object] Implemented; capture-specific limits apply
!mex.objectsd, !objectsd, !mex.objsd, !objsd (Display the Security Descriptor of a Kernel Object) !objectsd Address Implemented; capture-specific limits apply
!mex.vad, !vad, !mex.vadtree, !vadtree (Display the VAD Tree of a Process) !vad [-t Type] [-prot Protection] [VadAddress] Implemented; capture-specific limits apply
!mex.vadmodules, !vadmodules, !mex.vadm, !vadm (List the Image VADs of a Process) !vadmodules Process Implemented; capture-specific limits apply
!mex.addr, !addr (Display the Region an Address Lies In) !addr Address Implemented; capture-specific limits apply
!mex.meminfo, !meminfo, !mex.mi, !mi (Classify a Memory Address) !meminfo Address Implemented; capture-specific limits apply
!mex.foreachprocess, !foreachprocess, !mex.fep, !fep (Run a Command for Each Process) !foreachprocess [-q] [-unsafe] [-nosym] [-f Filter] [-m Filter] [-s Session] [-z | -Z] Command Implemented; capture-specific limits apply
!mex.foreachcpu, !foreachcpu, !mex.fec, !fec (Run a Command for Each Processor) !foreachcpu [-q] Command Implemented; capture-specific limits apply
!mex.nativeheapleak, !nativeheapleak, !mex.nhl, !nhl (Display the Native Heap Consumers) !nativeheapleak [-a] [-p] Implemented; capture-specific limits apply
!mex.heapleakanalyzer, !heapleakanalyzer, !mex.hla, !hla (Analyze the Native Heap Stacks) !heapleakanalyzer [-n Count] [-a] Implemented; capture-specific limits apply
!mex.handletype, !handletype (Count the Handles by Process and Object Type) !handletype [-a] [-g] [Process [Type [Command]]] Implemented; capture-specific limits apply
!mex.findhandle, !findhandle (Find the Handles to a Kernel Object) !findhandle Object [Process] Implemented; capture-specific limits apply
!mex.handlefind, !handlefind, !mex.hf, !hf (List the Handles to a Kernel Object with Their Access) !handlefind Address Implemented; capture-specific limits apply
!mex.filehandles, !filehandles (Find the Handles to Files by Name) !filehandles File Implemented; capture-specific limits apply
!mex.searchthreadstacks, !searchthreadstacks, !mex.sts, !sts (Search the Kernel Stacks of Threads) !searchthreadstacks [-t Thread | -p Process | -a] [-c] [-s] [-k] Value Implemented; capture-specific limits apply
!mex.attachedthreads, !attachedthreads, !mex.athreads, !athreads (Display the Threads Attached to Another Process) !attachedthreads [-p Process] [-a] Implemented; capture-specific limits apply
!mex.listticks, !listticks, !mex.lticks, !lticks (Display the Tick Counts of the Threads) !listticks Implemented; capture-specific limits apply
!mex.ssdt, !ssdt (Display the System Service Table) !ssdt [-v] Implemented; capture-specific limits apply
!mex.callbacks, !callbacks, !mex.cb, !cb, !mex.cbr, !cbr, !mex.cbo, !cbo, !mex.cbp, !cbp, !mex.cbt, !cbt, !mex.cbi, !cbi (Display Kernel Callbacks) !callbacks [-p] [-t] [-i] [-r] [-o] [-a] Implemented; capture-specific limits apply
!mex.regflt, !regflt (Display Registry Callbacks) !regflt Implemented; capture-specific limits apply
!mex.mreg, !mreg, !mex.hivelist, !hivelist (Display Registry Keys and Hives) !mreg [-p Path | -hivelist [-h [HiveAddress]] | -c | -f] Implemented; capture-specific limits apply
!mex.currentversion, !currentversion, !mex.cv, !cv (Display the Windows Version Values) !currentversion Implemented; capture-specific limits apply
!mex.svcreg, !svcreg (Display a Service Registry Key) !svcreg [Filter] Implemented; capture-specific limits apply
!mex.envvars, !envvars (Display the System Environment Variables) !envvars [Name] Implemented; capture-specific limits apply
!mex.timezone, !timezone, !mex.tz, !tz (Display Time Zone Settings) !timezone [-a | TimeZone] Implemented; capture-specific limits apply
!mex.pendingfiles, !pendingfiles, !mex.pf, !pf (Display File Operations Pending a Reboot) !pendingfiles Implemented; capture-specific limits apply
!mex.safemode, !safemode (Display the Safe Mode Components) !safemode [-net | -min] [Component] Implemented; capture-specific limits apply
!mex.apps, !apps (Display the Installed Applications) !apps [App] Implemented; capture-specific limits apply
!mex.qfe, !qfe, !mex.hotfix, !hotfix (Display the Installed Updates) !qfe Implemented; capture-specific limits apply
!mex.users, !users (Display the Users of the Machine) !users Implemented; capture-specific limits apply
!mex.regbloat, !regbloat (Find Registry Keys with Many Subkeys or Values) !regbloat Implemented; capture-specific limits apply
!mex.mirp, !mirp (Display an IRP) !mirp [-f] [-v] Address Implemented; capture-specific limits apply
!mex.deadirps, !deadirps (Display the Dead IRPs) !deadirps Implemented; capture-specific limits apply
!mex.mirpfind, !mirpfind (Find the IRPs) !mirpfind [-c] [-d DriverName] [-f FileObject] [-t ThreadAddress] [-u UserEvent] Implemented; capture-specific limits apply
!mex.irpbyfilename, !irpbyfilename, !mex.ibfn, !ibfn (List the IRPs of a File Name) !irpbyfilename [-f] [-a] [Text] Implemented; capture-specific limits apply

.ecxr (synonym .excr) prints the recorded exception context and makes it the register context, so r, k, u, ln and expressions follow it. It lasts until you select a thread, process or system again (~Ns, |Ns, ||Ns); register edits made with r name=value stay applied on top of it. Commands scoped to another thread, such as ~1k, keep using that thread's own context.

.exr Address displays the exception record stored at an address (for example the ExceptionRecord of an EXCEPTION_POINTERS argument); .exr and .exr -1 display the one recorded in the capture.

.cxr Address makes the CONTEXT record at an address the register context, like .ecxr does for the recorded one (.cxr -1 is .ecxr). .cxr alone returns the current thread to its own context. The /f and /w options are not supported.

.frame [/c] [/r] [FrameNumber] selects a frame of the stack that k shows and prints its row. The selected frame becomes the local context: r, dx @$curframe and expressions (@rip, @rsp, $ra) read its instruction and stack pointers, and $frame holds its number, while k keeps walking from the register context, so frame numbers do not change. The other registers keep the values of the register context, because the unwinder does not recover non-volatile registers, and dv refuses to show the locals of a frame other than 0. /c is accepted and implied; /r also prints the registers. Each thread keeps its own selection, so ~1 .frame 2 leaves the current thread's frame alone. Every selection ends when you select a thread, process or system again (~Ns, |Ns, ||Ns) or restart the analyzer, and .ecxr, .cxr and a register edit (r name=value) return the thread whose register context they change to frame 0. The .frame = BasePtr form is not supported.

.f+ and .f- select the next and the previous frame. They are .frame @$frame + 1 and .frame @$frame - 1, so they print the same row, and past either end of the stack the same error, which leaves the selected frame as it was. In the command input, Ctrl+ArrowDown runs .f+ and Ctrl+ArrowUp runs .f-, as typed commands that are echoed and added to the history; the text in the input stays, and while a command runs the keys do nothing.

dx browses a small object model built from the capture: Debugger (with Sessions), @$cursession, @$curprocess (Name, Id, Threads, Modules) and @$curthread, with the Threads[n], Modules[n] and Processes[id] items under them and .Count() on any list. -r[n] expands n levels (one by default); -n and -v are accepted and ignored, while -g, -gc, -c, LINQ methods and ,<format> specifiers are not supported. Keys and numbers are shown in hexadecimal ([0x0], 0x1a4); Threads and Modules are keyed by the numbers ~ and lm show. In a kernel crash dump the process and thread lists are not available, so @$curprocess and @$curthread report that. Any other expression is evaluated as ? does.

In dx output, a child that has children of its own but is not expanded at the depth shown (Threads, Modules, Sessions, [0x0]) is a link that runs dx -r1 on its full path, such as dx -r1 @$curprocess.Threads, so one click shows the next level.

Expressions are hexadecimal by default; n changes that, and 0x, 0n, 0t and 0y override it for a single number. The MASM operator set is supported with its documented precedence — * / mod, + -, << >> >>>, the comparisons, and, xor and or — together with not, hi, low, the poi, by, wo, dwo and qwo dereferences, and $vvalid, $iment, $scmp, $sicmp and $spat. Registers are reached with @rip (the x64 parts such as @eax, @ax, @al and @r8d included) and pseudo-registers such as $ip, $teb, $peb, $ra, $exr_code and $t0 with or without the at sign; one a capture cannot answer for reports what it needs. ? sign-extends a 32-bit x86 or x64 register (? @eax) as the debugger does, and a division by zero is an Operand error. A range is written as <address> L<count> or <address> <end address>. A loaded module's name evaluates to its base address (? ntdll+0x1000, db demo L4); a number or a register name wins over a module of the same name.

.formats <expression> shows one value in hexadecimal, decimal, octal, binary, ASCII, time-stamp and single/double floating-point forms at once. Captures with 64-bit pointers use the 64-bit layout, and so does any value that does not fit in 32 bits. A value that fits in 32 bits is read as a CRT time stamp and a larger one as a FILETIME; both are shown in UTC, not in the local time zone.

.printf follows the C printf conversions (%d %i %u %x %X %o %c %e %E %f %g %G, with flags, width, precision and the h, l, ll and I64 modifiers) and adds the debugger's own: %p (a target address), %N, %ma and %mu (NUL-terminated ANSI and UTF-16 strings), %msa and %msu (ANSI_STRING and UNICODE_STRING), and %y / %ly (a symbol name; no source line is added). An integer argument is 32-bit unless I64 or ll is given, and a floating-point argument is read as a 32-bit float unless l is given. Arguments are expressions and all of them are evaluated before anything is printed. Output always ends at the end of the command, so \n starts a new line but a later command does not continue the line. /D is not supported; /oe and /ow show the output as an error or a warning.

!gle reads LastErrorValue and LastStatusValue from the current thread's captured TEB and decodes them as a Win32 error and an NTSTATUS; !gle -all covers every thread in the capture. A field that was not captured is shown as (not captured). Only a bounded table of common Win32 errors and NTSTATUS values is built in, so any other value is shown as <Unable to get error code text>. A kernel dump records no TEB for its thread, so there !gle says so instead of reading one.

!error Value [Flags] decodes an error code: a Win32 error by default, or an NTSTATUS when Flags is 1 (for example !error 2 and !error c0000005 1). Both operands are expressions, and a value that contains spaces goes in parentheses. The message tables are bounded to the codes crash triage meets most; any other value is shown as <Unable to get error code text>.

.expr shows the default expression evaluator, which is always MASM here: .expr /s masm is accepted and changes nothing, and .expr /q lists the evaluators. The C++ evaluator cannot become the default, so .expr /s c++ is refused; evaluate one C++ expression with ?? or @@c++(...) instead.

Thread selectors accept an index (~1), raw TID (~~[1a4]) or expression (~[@$tid]); process selectors likewise accept an index, |~[PID] or |[Expression]. rm defaults to the basic integer registers. It can enable the segment, floating-point, MMX, debug and SIMD groups when the selected thread's saved CONTEXT contains them; rM, rF and rX override the mask for one display without changing that default. r reads or assigns comma-separated named registers, including x86/x64 subregisters, efl and the individual flag fields (zf, iopl, ...), pseudo-registers (r $teb, r $t0) and vector formats; rF st0=1.5 stores a floating-point value in an x87 register; assignments are isolated per thread in the analyzer session. r. shows the registers referenced by the current decoded instruction. r fpcw, r fpsw, r fptw and r mxcsr (x86/x64) and r fpcr and r fpsr (ARM64) read the floating-point control and status registers when the saved CONTEXT holds floating-point state (on x86, mxcsr needs the extended registers); the rF and rX groups do not list them. ~f / ~u and ~n / ~m retain synthetic freeze and suspend state for one or all threads. This state is inspectable but cannot stop or resume the captured process.

lm implements the reference filters, columns and 1m/sm forms. x implements its address/name columns, quoting, public code/data classification, wildcard filtering and sort modes; type and size fields that are absent from the public-symbol index are shown as unknown. The k variants retain their distinct clean/raw/argument/parameter/FPO presentations without inventing private parameter names. u defaults to eight instructions, uu continues across uncaptured gaps (up to 256 separately captured ranges, decoded in one LLVM invocation), ub reconstructs the preceding instruction boundary in one batched LLVM invocation, and uf supports call-only and instruction-count output. ARM64 encoding lengths are read from LLVM's architecture-specific output.

A module whose image is cached but whose PDB is not ((export symbols) in lm) still has names: its exports stand in for public symbols. x, ln, ? and u accept module!ExportedName, and k, ln, dps and the other commands that label an address name it after the nearest export below it in the same section (demo!Alpha+0x4). Forwarders and exports by ordinal only have no address of their own and are skipped. A function that is not exported is labelled with a neighbour's name, so read these names as where to look rather than proof of which function ran; a cached PDB replaces them.

dt fully parses its documented options and supports the built-in _TEB / _PEB prefixes plus arbitrary structures from a cached private PDB. Array expansion, field filters, values and recursive nested pointer or structure views use llvm-pdbutil dump --types; dtx uses the same typed records. dv reads parameters and locals from dump --symbols, with its documented filters, location display and sorting options. A record's offset is measured from the register it names, or from the frame register its procedure declares; when a record declares neither, the location is reported as unavailable instead of being guessed from another register. Missing or optimized-away records are reported rather than fabricated.

dt accepts the address after the field names or immediately after the type name (dt nt!_EPROCESS 0x<address> Protection). A word naming a field stays a field even when named Cb or Rip; use 0x for an ambiguous numeric address and @ for a register address (dt _CONTEXT @rsp Rip).

MASM remains the default expression syntax. ??, @@c++( ) and @@( ) implement decimal C++ precedence, casts, sizeof, logical and bitwise operators, typed pointer arithmetic, dereference, indexing and built-in or private-PDB structure members. Short-circuited and sizeof operands are parsed without being evaluated. @@masm( ) selects MASM explicitly.

An alias defined with as or aS is substituted into a later command line wherever its name stands alone, and ${Alias}, ${/v:Alias}, ${/d:Alias}, ${/f:Alias} and ${/n:Alias} behave as documented. as /ma, /mu, /msa and /msu set an alias to a string read from the capture: a NUL-terminated ASCII or Unicode string, or an ANSI_STRING or UNICODE_STRING structure, up to 2,048 characters. A string that is not fully captured is a memory error and defines nothing. Aliases belong to the command window: the language model tools run the text they were given, so an alias cannot change what a command does there.

bp/bu/bm/ba retain IDs, enabled state, pass counts, commands, conditions and documented restrictions. bl supports ID lists, ranges and quoted symbolic wildcards; bc/bd/be, br, bs and bsc update that table. Address expressions may contain spaces; a trailing pass count is separated only after a complete address expression. Processor breakpoints reject duplicates whose only difference is the command string. bs clears a condition created by bsc, while a /w condition remains independent. The sx family starts from the documented exception/event defaults and retains break/handling status plus first- and second-chance commands; sxr restores the defaults. ah, so and sq retain their corresponding setup. All of this state belongs only to the open analyzer session: a post-mortem capture cannot execute, hit a breakpoint, decrement a pass counter or receive an event, and every relevant display says so.

lsf explicitly loads a local UTF-8 source file into the analyzer session; ls, lsa, lsc and lsp navigate or configure the bounded source view, lsf- unloads it, and lse opens the current line in VS Code. A session accepts at most 64 source files, 4 MiB each, and displays at most 1,000 source lines per command. Address-to-source lookup uses available symbol line records and reports when no mapping exists. l+ and l- are recognized, but their source-mode stepping and display options are not applied; this analyzer uses lsf and lsp for its source view.

The live execution families (g*, p*, t*, wt) and port/MSR commands parse their documented flags and expressions before returning the live-target or kernel-target limitation. It does not resume the captured process.

.echo prints a line of text, and .if / .elsif / .else, .block, .catch, j, .while, .do, .for, .foreach, .break and .continue run the commands in their braces or quoted strings one at a time, through the same handling as typed commands. A condition is a numeric expression (nonzero is true), and a failing command does not stop the commands after it, except inside .catch { Commands }: there the first command that prints an error ends the block, with its output kept, and the commands after the closing brace still run. A warning does not end the block, and neither does an error that a nested .catch already caught. In .for (Initial ; Condition ; Increment) the increment may hold several commands separated by semicolons, and an empty condition is always true. A command that starts with $$ is a comment up to the next ;, and one that starts with * is a comment to the end of the line, semicolons included; in braces, a comment ends with the block at the latest. A command starts at the start of the line, after a ;, after the { of a block, behind a thread, process or system prefix (~1 $$ text) and at the start of a ~e, !for_each_module or !for_each_frame command string. Quotes in a comment are plain text, so they never carry it past its end, while braces in it pair up ($$ ${Name}). Neither prints anything. .foreach runs its commands once for each token of a string (/s) or of the output of its input commands, which is not shown, so a .cls among them clears nothing; tokens are separated by spaces, tabs and line breaks. The variable is replaced where it stands alone as a word or is written ${Variable}; /pS N skips the first N tokens and /ps N skips N tokens after each one used. Reading tokens from a file (/f) is not supported. Command ; z(Expression) runs every command in front of z once, and again for as long as the expression is nonzero: the expression is first tested after the first pass, and the commands after z run once when the loop ends. This works on a command line and inside any block; inside .catch the commands in front of z are commands of the block, so their first error also ends the loop. A command line or block may hold one z, and a processor selector ([Processor] z(Expression)) is checked but not run. ~e runs its commands once for each selected thread, !for_each_module once for each loaded module in the order the capture lists them, and !for_each_frame once for each of the first 256 frames of the current thread; the last two take several commands only enclosed in quotation marks, while the commands of ~e are the rest of the line after the e (~*e r; k runs both for each thread). !for_each_module replaces @#ModuleIndex, @#ModuleName, @#Base, @#End, @#Size, @#TimeDateStamp and @#Checksum (numbers in hexadecimal) where they stand alone as a word or are written ${@#Alias}, and without commands lists each module's index, start, end and name. Each ;, {, }, ", ' and \ of a module name becomes _ in @#ModuleName, and a warning says how many names were changed, so a name read from the capture cannot add commands; .foreach puts its tokens in as they are, as WinDbg does, since they come from commands the user wrote. !for_each_frame prints each frame's row before its commands and makes the frame the local context while they run, as .frame does, so @$frame and the instruction and stack pointers read that frame; without commands it lists the frames. The current thread and frame are restored afterwards, and .break and .continue work in all three. !for_each_local reports that this analyzer does not collect frame-local variables. One command line may nest these statements at most 16 levels deep and run at most 10,000 program commands, and each loop pass, including each .foreach token and each thread, module or frame, counts as one of them; the program also stops after 5 seconds. Either way it stops with a message. Program commands are not repeated by the automatic symbol retry. .reload cannot run inside a program, ~e included, because symbols are downloaded before a command line runs; run it as its own command first (.reload /f ntdll; .block { k }).

$<, $><, $$<, $$>< and $$>a< run the debugger commands of a UTF-8 script file from the command window. $< and $$< show each line of the file and run it as a command line of its own. $><, $$>< and $$>a< turn the line breaks into ; and run the whole file as one block, so a block may span several lines; that block holds at most 32 commands. $>< and $$>< show each command before its output, while $$>a< shows only the output and replaces ${$arg1}, ${$arg2} and so on with its arguments: an argument with spaces is quoted, and a placeholder with no argument stays as written. $< and $>< take the rest of the line as the file name, semicolons included; the $$ forms end at ;, so more commands may follow. Comments work in a script file as on the command line, but in a file that runs as one block a * comment makes the rest of the file a comment, so use $$ there, as the reference advises. A relative name is read from the folder of the open dump, and on Windows only paths on a local drive are read. The extension host reads every file a command line names, nested ones included, before any command of the line runs: at most 1 MiB per file and 64 files per command line. A name that only the running program can know, such as a .foreach token, is refused. Script files nest at most 8 levels deep, their commands count against the program limits above, and no message names a script file or its path. The GitHub Copilot tools cannot run script files.

.cmdtree <File> reads a command tree file, which WinDbg uses to list the commands you run often, by the same rules as a script file: a relative name is read from the folder of the open dump, on Windows only a path on a local drive is read, and the file is UTF-8 text of at most 1 MiB. The file starts with the line windbg ANSI Command Tree 1.0, may give a title with title {"Text"}, and after a line body holds one node per line, {"Label"} or {"Label"} {"Command"}. Each space or tab in front of a node is one level of nesting: the first node is not indented, and a node is at most one level deeper than the one above it. Blank lines are skipped, and a node may have both a command and nodes under it. A tree holds at most 4,096 nodes in at most 64 levels, and a label or command is at most 2,048 characters long. .cmdtree prints how many nodes it read, or the first problem it found with its line number; no message names the file. The GitHub Copilot tools cannot run .cmdtree.

A display command with no range continues from where the last one stopped, and starts at the instruction pointer when there has been none; /c8 and /c 8 both set how many items go on a row. A range is <address> <end address>, where the end address is part of the range, or <address> L<count>, with L-<count> ending at the address and L?<count> lifting the debugger's own guard. The count is read in the current radix; for du it counts UTF-16 characters. A minidump holds only part of the address space, so bytes it does not contain are shown as question marks rather than as zeroes or as a refusal of the whole request, and c treats a byte it cannot read as a difference rather than a match. s and c cover the whole range they are given, however long, reading the capture in bounded windows instead of only its first 64 KiB: a search finds a match that crosses a window boundary exactly once, skips memory the capture does not hold, and says No matches were found in the captured part of the range. when part of the range was not captured. A search refuses a range that holds more than 1 GiB of captured bytes and a compare refuses more than 64 MiB, asking you to narrow the range, so a result is never silently incomplete; c stops listing differences after 10,000 rows. A kernel dump does not list its captured ranges, so a search there counts the bytes as it reads them and is refused once they pass 1 GiB, or once passing the range's unmapped parts takes more than 262,144 page-table steps. STRING and UNICODE_STRING output follows the structure's length, so an embedded NUL is invisible without ending the value and valid surrogate pairs remain Unicode. e*, f and m write to a bounded copy-on-write memory overlay, and a assembles one instruction with llvm-mc into that overlay. Expressions, dumps, disassembly, stack walking and typed views all read the overlaid bytes. The source dump file is never modified, and closing the analyzer discards the overlay.

Commands can be chained with ;, and a z in the chain repeats the commands in front of it, as described above. Editor actions from a chain are applied in order. Pressing ENTER on an empty line reissues the previous command line, except while a command runs, when it does nothing. A thread selector binds to the command that follows it, so ~0 shows a single thread, ~1k walks thread 1 without making it current, and ~*k walks the stack of every thread.

Command echoes use the current thread's prompt. ENTER repeat also works with history disabled; IME confirmation does not submit a command. Input exceeding 2,048 characters is reported and kept for correction; a line queued while another command runs is reported when its turn comes instead, and is not kept. Clipboard failures are reported instead of claiming that copying succeeded. Large outputs trim scrollback once per received chunk while retaining the windbg.output.scrollbackLines limit.

WinDBG: Save Command Output... writes everything the output log still retains to a text file you choose (.txt or .log, UTF-8, at most 16,777,216 characters), and WinDBG: Copy Last Command Output copies only what the most recent command printed, without its prompt line. The extension host writes the file after you pick a path; the Webview itself never writes to disk.

Command history file. Each command the command window of a crash dump or TTD trace runs is also appended to a text file next to the capture, named after it with .history added: the history of C:\logs\foo.dmp is C:\logs\foo.dmp.history. An entry is an empty line, a header with the local time, the prompt and the command ([2026-11-02T19:15:30+09:00] 0:000> k), and the output lines exactly as the window showed them, a link as its text. An output line that would read as such a header gets one more space in front. Typed, pasted and clicked commands are written, and a command that failed or was stopped with what the window showed for it; a command the window refused, because another one was running or the capture was not ready, is not. When you open the capture again, the command input starts with the commands of the file, the most recent last and each command line once, at most windbg.command.historySize of them; their output is not shown again. WinDBG: Open Command History File opens the file beside the analyzer. The Command Palette offers it while an analyzer is open, and the … (More Actions) menu of the analyzer's title bar has it too. Turn off windbg.history.saveToFile to write and restore nothing. Privacy says what the file holds.

The VS Code command palette also offers:

Command Description
WinDBG: Open Crash Dump or TTD Trace Pick a dump or trace file and open it in the analyzer
WinDBG: Open With WinDBG Dump Analyzer Open the selected dump or trace in the analyzer
WinDBG: Run Debugger Command Focus the command window of the active analyzer
WinDBG: Clear Command Output Clear the output log from the analyzer toolbar or Command Palette
WinDBG: Copy Command Output Copy the output log to the clipboard
WinDBG: Open Memory and Disassembly Window Open the read-only memory and disassembly window for the active crash dump or TTD trace, beside the analyzer
WinDBG: Clear Symbol Cache Delete cached artifacts, their staging files and the remembered "not found" answers, preserving unrelated neighboring files and folders. When the cache is the one _NT_SYMBOL_PATH names, which WinDbg shares, it asks for confirmation first and Cancel deletes nothing
WinDBG: Show Symbol Diagnostics Show the detected LLVM tools and symbol server status
WinDBG: Set Symbol Server Credential Store the access token for a symbol server in the operating system keychain
WinDBG: Clear Symbol Server Credential Remove a stored symbol server access token
WinDBG: Restart Analyzer Session Restart the analyzer of the active capture: the worker parses it again, and aliases, breakpoints, memory edits and the thread selection are discarded; the output log is kept
WinDBG: Save Command Output... Save the whole output log to a text file you choose
WinDBG: Copy Last Command Output Copy only the output of the most recent command to the clipboard
WinDBG: Open Notes Open the notes of the active crash dump or TTD trace, <capture>.notes.md next to it, in a text editor beside the analyzer, creating the file with a heading the first time
WinDBG: Copy Value Copy the value of a register in the WinDBG Registers view; only on the menu of a register
WinDBG: Open Command History File Open the command history file of the active crash dump or TTD trace, <capture>.history next to it, in a text editor beside the analyzer
WinDBG: Show Source of Current Frame Open the source file of the current frame of the crash dump the WinDBG views show, beside the analyzer, and mark its line
WinDBG: Add Watch Expression Add an expression to the WinDBG Watch view; also on the view's title bar
WinDBG: Edit Watch Expression Edit an expression of the WinDBG Watch view; only on the menu of an expression
WinDBG: Remove Watch Expression Remove an expression from the WinDBG Watch view; only on the menu of an expression
WinDBG: Remove All Watch Expressions Remove every expression from the WinDBG Watch view; only on the view's title bar
WinDBG: Set Up Claude Code Access Let Claude Code use the WinDBG tools through a local MCP server: turn the server on, create the access token and copy the claude mcp add command line (see Claude Code)
WinDBG: Reset Claude Code Access Token Replace the access token of the server for Claude Code and copy the new claude mcp add command line
WinDBG: Copy Command Copy the command a command link of the command window runs, without running it; only on the menu of a command link
WinDBG: Copy Link Text Copy the text of a command link of the command window, such as a module name or an address; only on the menu of a command link
WinDBG: Run Selection in WinDBG Analyzer Run the lines selected in a text editor, or the whole document, in the active analyzer as pasted lines; also in the editor context menu, while an analyzer is open

WinDBG: Open With WinDBG Dump Analyzer is not in the command palette: it appears when you right-click a .dmp, .mdmp, .hdmp or .run file (in any letter case) in the Explorer, not a folder. Run without a file, from a keybinding for example, it asks for one the way WinDBG: Open Crash Dump or TTD Trace does. Run Debugger Command, Clear Command Output, Copy Command Output, Save Command Output... and Copy Last Command Output appear in the command palette only while an analyzer is the active editor. The analyzer toolbar, in the editor title bar, shows Clear Command Output and then Copy Command Output as icon buttons; hover over one for its name. They run the same commands, and Clear empties the window as .cls does. In a command line such as .cls; k, .cls clears only what was shown before it, so the output of k stays. The output limit of a command (windbg.output.maxLines) counts only the lines after its last .cls: output that reached the limit before it is cleared like any other, without a truncation notice. WinDBG: Copy Command and WinDBG: Copy Link Text are not in the command palette either: they are the items of the menu that opens when you right-click a command link in the analyzer.

When switching editors, palette commands use the currently active analyzer even before its view-state notification arrives. Resource-specific title buttons still act on their own analyzer.

The extension's name and description, its command titles and setting descriptions, the names, descriptions and argument descriptions of its Copilot tools, and the command-window and memory-window controls use Japanese when VS Code's display language is Japanese; otherwise they use English. This README names the commands by their English titles. Debugger output remains in English, and so does the description from which Copilot decides when to use each tool.

MEX commands

MEX is a WinDbg debugger extension (mex.dll) whose commands help with everyday crash analysis: filtering the output of another command, folding identical stacks, listing threads, processes, modules and locks, and more. This analyzer re-implements MEX commands itself: they read the capture as the other commands here do, without DbgEng and without mex.dll. The ones it implements are in the extension-command table above and in the list !mex.help prints.

Run a MEX command as !mex.<name>, as !<name> unless another command already uses that verb, or as !mex <name> [arguments]. !mex alone and !mex.help list the MEX commands this analyzer implements, !mex.help <keywords> lists those whose names or description contain every keyword, and !mex.<name> -? shows the usage of one. !mex takes the rest of its line as its arguments, ; included. A name that no MEX command has gives No export <name> found for !mex.<name> and Could not find a Mex Extension named <name> for !mex <name>, as in WinDbg. The Copilot tools cannot run MEX commands.

There is no mex.dll to load: .load mex (or any path that ends in mex.dll) and .loadby mex <module> only say that the MEX commands are built in, .setdll mex says that MEX is already the default extension, and .unload mex says that the MEX commands cannot be unloaded. Other extension DLLs cannot be loaded, because this analyzer runs no native extension code; .load sos points to dotnet-dump and SOS. .chain lists the built-in mex and the recognized sos, and .extmatch [/e ExtDLLPattern] [/n] Pattern lists the MEX commands this analyzer implements as the exports of mex (.extmatch * lists all of them).

MEX commands that cannot run here

MEX has many more commands than this analyzer implements. For each of the others, !mex.<name>, !mex <name> and !<name> print why it cannot run here instead of an unknown-command error, and !mex.help -all [keywords] lists them with the reason in short. Where another command already has the verb, such as SOS's !syncblk or the built-in !gle, !<name> runs that command and !mex.<name> gives the reason. The commands fall into these groups:

  • Managed (.NET) code, such as !mex.dumpheap2, !mex.clrstack2 and the ASP.NET, WCF and PowerShell commands. They need the CLR data access component (mscordaccore); use dotnet-dump, or WinDBG with the SOS extension.
  • The internal data of one Windows, Office or server component, such as Outlook, Internet Explorer, Edge, LSASS, DNS or Hyper-V (!lsass, !olanalyze), which needs that component's private symbols.
  • Private kernel and driver structures: win32k windows and desktops, file systems, storage and network drivers (!win32k, !minifilters).
  • A live target: breakpoints, stepping and writing memory (!bp, !breakon).
  • Time travel replay (!idna, !tm): this analyzer reads TTD traces (.run) statically.
  • The debugger host or MEX itself: files, the clipboard, other programs, mail, web services, and MEX's settings, updates and tests (!mex.update, !rlm).
  • The rest, which this analyzer does not implement (!mex.gle, !syschk).

Differences from MEX

  • Options start with -; /? is the only option that starts with /. An option written twice is an error, also in another letter case (-v -V).

  • A command line that does not fit the command reports only its first mistake, as ERROR! <message> followed by the usage. The messages leave out MEX's internal names.

  • -?, -help and /? show the usage wherever they stand among the options, also after a mistake.

  • 0n (decimal) and 0x (hexadecimal), in either letter case, set the base of a number only at its start (0n10, 0X1f).

  • An argument that takes an address is read as an expression, as ? reads it (@$teb, demo+0x10).

  • !mex <name> runs the command exactly as !mex.<name> does, so an alias such as !mex tc also gets the options it stands for.

  • !mex.help <keywords> lists the commands that contain every keyword, sorted by name. MEX ranks its matches by a search score, and without keywords it shows categories.

  • A MEX command that filters, counts or reorders the output of another command prints that command's error lines first, as they are, and works only on its other lines.

  • !grep uses JavaScript regular expressions (Unicode mode) instead of .NET ones. \< and \> still stand for the start or the end of the line or a non-word character, and a backslash before a punctuation mark or a space still stands for that character, also in -until and -untilFinal. .NET-only syntax such as (?i), \A or (?>...) gives ERROR! Regex Failure '<message>' with JavaScript's message.

  • !grep -until and -untilFinal can not be used together, and -A or -B given with -C wins over it.

  • !count -qn prints no progress dots and is the same as -q; -q and -qn also hide the lines with -c, and -s can not be combined with a command or another option.

  • !tail 0 <command> prints no line, as !head 0 does (MEX's !tail 0 prints every line), and !tail -l numbers the printed lines from 1, also with -s.

  • !sort compares the keys ignoring the letter case and then by character code, so the order is the same on every machine; MEX uses the comparison rules of the machine's culture.

  • !sort -f with several fields compares them one after another (MEX joins them into one key and warns that this is untested), -d also works without -f, and -c can not be combined with -f or -d, nor -ai with -ax.

  • !sort -ai and -ax read the keys by the number rules of the MEX commands (-ai also after a leading -), and -ax reads 64-bit values without a sign, so ffffffff`ffffffff sorts last; keys that are no numbers come after all the numbers.

  • MEX's @#Name placeholders (such as @#Line) are replaced in any letter case and wherever they stand, also inside a word or an expression (poi(@#Item+8)), and ${@#Name} works too; in MEX they are debugger aliases.

  • !foreachline, !foreachregex and !if read their patterns as JavaScript regular expressions and ignore case. A group that takes no part in a match is empty, and a line break inside a !foreachregex match becomes a space.

  • !if runs its -x commands only when every condition given holds; MEX decides by the last kind of condition given. @#Output holds the output's lines joined by spaces, up to 2048 characters.

  • !exec -xs hides the output of its command but still shows its errors.

  • The commands that !foreachline, !foreachregex, !exec and !if run count against the limits of the command line, as those of .foreach do (10000 commands, 16 nesting levels, 5 seconds), and .break and .continue act on the lines or matches of !foreachline and !foreachregex.

  • !fc and !fems read the threads of a user-mode dump; in a kernel-mode dump they say that they need a user-mode target. In a user-mode dump the kernel-only options of !us, !fc and !fems (such as !usk, !us -k and !us -cpu) are refused instead of ignored.

  • The FILTER of !us -r (also with -m, -w, -nw and -crash) and the patterns of !fems -s and -e are JavaScript regular expressions that ignore letter case, in which . also matches a line end.

  • !us -3 (the stacks that contain third-party modules) is not available; !mods -3 lists the third-party modules.

  • !us -max <count> looks at exactly <count> threads.

  • !fems -stat prints the creation time of a thread in UTC, as MM/dd/yyyy hh:mm:ss.fff AM.

  • !t runs no thread analysis: the Info column (trap frames, rule matches) and the notes under the stack are left out, and -na changes nothing.

  • The COM-Initialized column of !t says Unknown when the thread has COM data: telling the apartment apart needs the private types of combase.

  • !t -cxr and -ecxr walk the stack from that context record without making it the register context (.cxr and .ecxr do that).

  • !t adds the note of k when frames were recovered by scanning the captured stack.

  • !t -raw and -rawall read the stack the dump captured for the thread, up to 16 MiB.

  • !listthreads (!lt) shows the Create Time in UTC, and a user-mode capture refuses the options that filter a kernel-mode thread list, which MEX ignores there. Waiting On names the critical section and its owner only for an x86 capture; on x64 and ARM64 it says CritSec alone, because the stack walk does not recover the register that holds the critical section.

  • !runaway2 -v divides the thread times by the process run time (from the process creation time the capture records) instead of the system uptime, which a minidump does not record, and leaves the shares empty when that time is not known.

  • !foreachthread (!fet) also sets @#TID (0x<id>) in a user-mode capture, takes @#StackBase and @#StackLimit from the captured stack memory when the TEB is not captured, and refuses the options that pick kernel-mode threads.

  • The -f filters of !foreachframe (!fef) and !foreachmodule (!fem) are JavaScript regular expressions, matched in any letter case.

  • !foreachmodule refuses -clr, -i, -3 and -1, and with them !thirdpartymods and !managedmods, with the reason: it does not pick out the .NET, interesting, third-party or first-party modules (!mods -clr, !mods -i and !mods -3 list the first three). @#CompanyName, @#ProductName and @#Description are empty, @#Base and @#End have no grave accent, and an unknown -ff field or -u with -k is an error.

  • In the values that !foreachmodule (!fem) and !foreachframe (!fef) read from the capture or the symbols (@#Module, @#ModuleName, @#ModuleNameWithExtension, @#Path, @#StackLine, @#SymbolName, @#SymbolNameRaw, @#SymbolDisplacement and @#SourceFile), each ;, {, }, " and ' becomes _, as do each \ of a name and each \ that ends a path or a stack line, and a warning says how many values were changed: a name read from the capture cannot end the command or start another one. MEX puts the values in as they are.

  • !frame -x (!fx) runs dv for the parameters and locals.

  • !dr also shows ARM64 registers (x0-x17 and lr are marked volatile), and for a frame other than 0 it says that only the instruction and stack pointers are recovered.

  • !stackinfo (!si) takes a debugger thread number in a user-mode capture too, refuses -k there, and reports a TEB that the capture does not hold instead of printing nothing.

  • !addstack (!as) says what it added or cleared, sorts the stacks by their number of threads, matches a plain filter in any letter case and a -r filter as a JavaScript regular expression, and refuses the time travel options -t and -x.

  • !p in a user-mode capture shows the process table, the command line and the last event; its links run lmvm, !peb, lm, !handle 0 0, ~, !uniqstack and ~*kv. It does not add MEX's helper commands for particular processes (such as conhost or svchost).

  • !mods reads the company, product, description and version strings from the version resource of the image in the capture, or of the cached image file once .reload has fetched it; without either, those columns are empty and Version shows the binary file version. A module is third-party (-3, !mut) when no company name with "Microsoft" in it was read and no PDB is cached for it. -i leaves out MEX's rules about the module's age. The column headers are not links; sort with -s.

  • !mods in a kernel-mode capture lists the kernel's loaded modules only, so -u and !mu find none. The CLR column comes from the image's .NET header, and -net is not available.

  • !imports reads the import table from the image in the capture, or from the cached image file when the capture does not hold it; -a and -iat show the captured slots of the import address table with dps. -f looks for plain text, not a regular expression, and without a module it searches only the import lines, not the module names.

  • !imgscan and !diffimg work in user-mode captures only and check the captured memory at 64 KiB boundaries. !diffimg compares the images it finds with the capture's module list, not with the loader list in the PEB (In module list only, In memory only), and counts the listed modules whose header page is not captured instead of comparing them.

  • !loader (!ldr) prints its summary without MEX's table of the loaded modules (lm lists them), and !ldr -d lists each DLL notification callback without the company and description of its module. !loaderlock -v (!ll) shows the stack of the thread that holds the loader lock, as ~~[<tid>]k prints it; MEX analyzes its wait chain.

  • !tasklist shows times in UTC (2026-11-02 08:00:00.000 UTC), and its footer repeats the header without column sums. The PID runs !mex.p on the process and the address runs dt nt!_EPROCESS. -stat adds the columns of -cpu, -mem and -proc but the parent, and -z leaves out the handle and pointer reference counts.

  • !tasklist -tree takes no other option or filter. It draws each process once, under the process that has its parent PID unless that one was created later, and marks a process without active threads with (zombie). Processes that are each other's parent, or that are more than 100 levels deep, start trees of their own.

  • !tasklist refuses -top without -sort and an option it does not know, and its filter matches an _EPROCESS address only when it is written as a number. A value of -n, -u, -j, -pid or -parentpid that starts with -, or a filter starting with -, is quoted ("-setup", -n "-setup.exe"); unquoted, it is read as an option.

  • !p in a kernel-mode capture shows the process table, the command line and the memory and CPU details, without MEX's helper commands for particular processes, its process state line and its loader shutdown line. User Name is the SID of the token's user (the token's address when the SID cannot be read), the times are UTC, the memory details leave out the AWE size and the pool quotas, and the CPU times are the process's own counters. -i prints the initial thread as a link to !mex.t instead of running it, and -a is refused.

  • !cl in a kernel-mode capture says when a process has no PEB, and !cl -a reports each process whose command line cannot be read; MEX prints nothing for them.

  • !w in a kernel-mode capture names the processor that bugchecked and always shows the frame.

  • !lt in a kernel-mode capture lists a thread once when several options pick it, says No matching threads found when the options pick none, and reads -rc as the threads that wait with WrCpuRateControl (MEX lists every thread for -rc). -cs, -sl, -re and -ll are refused, because they need the threads' user-mode stacks. It reads at most 65,536 threads in all, also across processes with -a, and reports when there are more. Process/thread walk warnings survive the 10,000-line output limit; at most 5,000 thread-list warnings are shown, followed by one line counting the rest.

  • The Waiting On column of the kernel-mode !lt names the mutant, process or thread a user request waits on and the fast mutex of a WrFastMutex or WrGuardedMutex wait, not LPC replies. Its wait function is the first frame of the kernel stack that is not one of nt's Ki and Ke functions or a lock function, and the State column does not mark a thread that runs a DPC.

  • !running, !ready, !readyish, !deferredready, !standby, !transition, !initialized, !gatewait and !waiting need a kernel-mode capture; in a user-mode one, !running does not list the threads that are not waiting instead.

  • Their thread tables leave out MEX's Ideal CPU and Waiting On columns, show the affinity in hexadecimal, and name states and wait reasons as the nt PDB does (GateWaitObsolete for state 8). !running marks a thread that a DPC interrupted as Running(DPC) or Running(Threaded DPC), never as Running(long DPC); -dpc adds no DPC time columns, and -r and -ndisrwlock are not available.

  • !waiting counts the waiting threads by wait reason without a sum row, and says No waiting threads found. when there are none.

  • In a kernel-mode dump, !t leaves out the names and pool tags of the objects a thread waits on, pending APCs, LPC messages, windows (-w is not available) and the file, driver and process of each IRP. Its priority table has the current and base priorities only, and -v shows the processor the thread runs on next instead of its ideal processor, and no up time.

  • !t -a and -av follow the wait chain one level: the object the thread waits on and the thread that owns it (a mutant's or a fast mutex's owner); -av adds the thread table of each. Deadlocks are not detected.

  • In a kernel-mode dump, !t <thread> makes the thread's registers the register context as .thread does (-d keeps the current one), but leaves the implicit process as it is.

  • In a kernel-mode dump, !us reads -p (an _EPROCESS address or part of a process name) and -s in every mode but -waitobj, without changing the implicit process, and -wr, -ewr, -state and -estate in every mode; MEX reads some of them only in some modes.

  • The kernel stacks of !us end at the last kernel-mode frame, so !usk (-k) takes the threads of every process but compares the same frames, and it does not print the time it took.

  • !us -cpu writes (CPU:<n>) after each thread without a link: ~<n>s does not select a processor here.

  • !err looks codes up in the Win32 and NTSTATUS tables that !error uses (the codes crash analysis meets most), not in MEX's error database or with err.exe, so it has no -e, -o, -t, -h, -list or -default and !kerberr is not available. A value that no entry has is also looked up as the code that an HRESULT_FROM_WIN32 or HRESULT_FROM_NT value wraps; -d always does that. A value above 0xffffffff is accepted only when it is a correctly sign-extended negative 32-bit code. 0x80070000 is not decoded as success: HRESULT_FROM_WIN32(0) is zero, not that failing value.

  • !cut takes exactly one of -f, -c and -l, and -d only with -f. A list it can not read gives ERROR! Invalid field list: <list> (char with -c, line with -l) and the usage, as for !sort, also when the list ends with a comma, which MEX accepts; MEX names each kind of mistake instead.

  • !uniqlines and !sum print no progress dots, so !uniqlines -q changes nothing and !sum -q is the same as -n.

  • !tr reads only the escapes \\, \n, \r, \t, \xHH and \uHHHH in its sets, a backslash before another character that is no letter or digit stands for that character, and any other backslash is an error (MEX reads the escapes of .NET regular expressions). It works on each line without its line break, so a \n in Set1 matches nothing, it leaves out a line that becomes empty, and it makes at most 4,194,304 characters of text.

  • !dumpinfo does not show the file name, path, size or date of the dump, which the analyzer session does not know (the editor tab shows the name), nor the machine, processor and boot rows that MEX reads through kernel debugger extensions; -v adds the computer name and the tables of !dumptime. It and !comment report malformed Unicode comments, including an incomplete final UTF-16 code unit.

  • !dumptime shows the times in UTC (2021-01-14 08:25:36.000) and the durations as .time does; -m (the debugger's own clock) and -t (ticks, which !tx converts) are not available.

  • !shareduserdata shows the documented fields of KUSER_SHARED_DATA from a built-in layout, without symbols; MEX displays the type from the symbols.

  • !showextraprocessstream stops at 9,998 records or 4,194,304 process-name characters and reports the omitted records. Malformed or incomplete records are errors; captured comment thread links accept numeric IDs only.

  • !exceptionrecords (!mexr) finds the exception records of an x64 stack through its ntdll!KiUserExceptionDispatcher frames (the CONTEXT at the frame's stack pointer and the EXCEPTION_RECORD 0x4f0 bytes above it) instead of the local variables that private symbols name, and lists the capture's own record (.exr -1) for the thread it was recorded on; on x86 and ARM64 it lists only that record. !mexr -p <address> shows the record as .exr does.

  • !dumpstowedexception reads the published Windows Error Reporting layout without combase symbols and shows the address of error text for a record without a stack trace. Invalid structure sizes and stack word sizes are errors.

  • !crash leaves out the Insights section (MEX's rule engine and !syschk). In a kernel-mode dump it shows the bug check thread with k (kc for -c) and explains bug checks 0xe2 and 0x7e itself; other bug checks show !analyze. The bug check stack uses the captured header context, not a later .thread or .cxr selection, and does not change that selection or offer frame-selection links. -v changes nothing.

  • !a runs !crash for every kernel-mode dump; MEX runs a hang analysis for a dump taken by hand.

  • !da and !du print the string on one line, also when it holds line breaks: a carriage return, line feed or tab shows as \r, \n or \t, any other control character (and in !da a byte above 0x7e) as .. -a and -v read at most 65,536 bytes and say when the string goes on; a string that runs into memory the capture does not hold ends with a warning that names the address.

  • !strings prints each string on one line in the same way, leaves out the strings of blanks only, also takes L<count> as the end of the range, and finds a string whole where MEX's 64 KiB reads would cut it. It scans as much captured memory as one s search (1 GiB) and stops after 9,999 strings, a string longer than 1,048,576 characters, or 4,194,304 displayed string characters, with a warning rather than a partial string. With -f it offers no link to read on.

  • !dumpstackstrings (!dss) reads up to the TEB's stack base, else to the end of the thread's captured stack; when neither is recorded, it uses the selected kernel thread's PDB-backed stack bounds when available. Otherwise it reads the memory captured above the stack pointer, at most 64 KiB, and says so.

  • !bin takes only the form !bin Count Address: MEX's form for the address of a MAPI SBinary is left out (for an x64 SBinary at <a>, type !bin dwo(<a>) poi(<a>+8)). The text shows . for every byte outside 0x20–0x7e, and -full displays at most 1 MiB.

  • !dps and !dqs tag each line by the slot address the built-in display gives it, so a line that is no slot keeps no tag (MEX's !dqs counts on from the first line). !dqs names the stack pointer of the target (ESP on x86), and !dps says in a line when the frame pointer is not plausible and the offsets count from the stack pointer instead.

  • !interpretrawstack (!irs) takes its frames from this analyzer's stack walk (as k shows them) and reads the last frame up to the stack base as !dumpstackstrings finds it, ignoring recovered frames past that base. It shows at most 8,192 rows, and at a slot that the capture does not hold it stops with Memory read error at <address>. after the rows it has; MEX shows no table then. Its strings follow the rules of !da and !du.

  • !parsemem takes exactly one of -q and -d (MEX counts QWORDs when both are given), reads at most 32 KiB, lists the values of equal count in the order they first occur, and ends with Memory read error at <address>. when it stops at a value that the capture does not hold.

  • !findstack tries each slot as the return address of a frame that has just returned (with -cxr, as a context record), searches at most 128 KiB, stops at the first slot the capture does not hold, and takes a thread ID for -t in a user-mode capture. Its links walk the stack it found with k = <stack> <instruction> 0x40 (on x86 k = <frame> <stack> <instruction>). It does not change the current context or offer frame-selection links for the recovered stack.

  • !fnent reads the function table from the module's image in the symbol cache, lists the unwind codes in a table with the stack bytes each accounts for (a machine frame counts 40 or 48 bytes, already including RIP), and says why on x86 and ARM64. It reads v1/v2 metadata, including one-slot v2 epilogue descriptors, and reports unsupported versions or malformed codes instead of inventing a frame size. Chains stop at 16 total entries; cycles are errors.

  • !formats without a format option shows every line of .formats but the first; MEX shows nothing then. -d shows the one Decimal line that .formats prints here.

  • !filetime and !datetime show the date and time as yyyy-mm-dd hh:mm:ss.mmm in every locale, and !filetime adds UTC. !datetime reads the DateTime at the address, or takes the value with -t (MEX reads its argument as the value), and shows its kind (Utc, Local or Unspecified) and its ticks.

  • !rollup shows 0 B for zero, where MEX shows nothing, and -fel rolls up each line of the output that is a number. !sum and !rollup -t keep their totals, and !time its timing, even when windbg.output.maxLines is reduced to 100 or another command precedes them; omitted rows are marked as truncated. Errors omitted from inner output are reported with their count, even when retained rows are all errors, not treated as success. Marked omitted-error diagnostics reserve space before ordinary summaries. If nested summaries alone exceed the remaining limit, the latest closing summaries take precedence, so the enclosing command's timing or total is retained; earlier rows remain marked as truncated.

  • !eflags names the bits as the Intel and AMD manuals do, so bits 15, 30 and 31 are reserved (MEX calls them MD, AES and AI). -r and -x need -v.

  • !mrmsg knows the window messages of winuser.h (WM_*), and names a number in the WM_USER or WM_APP range WM_USER+0x<n> or WM_APP+0x<n>; MEX's list also holds private messages of many applications. -d lists the table.

  • !ioctl takes a code apart into its fields, with the FILE_DEVICE_*, METHOD_* and access names of the public headers. It has no database of IOCTL names, so it neither shows the name of a code nor accepts one. Device names include FILE_DEVICE_MULTITIER_MEMORY and FILE_DEVICE_CXL_TYPE3 from the current public header.

  • !loop reads a hexadecimal value from 8000000000000000 up as a positive number, as an address (MEX makes it negative), and stops before a value would leave the 64-bit range. With a negative -i, -c Count runs the command exactly Count times (MEX runs it more often), and -c, -s or -i together with Start, End and Increment is an error. Negative @#CounterInt values use -0n10 syntax so expressions stay decimal at every radix. The shared MEX numeric parser stops at 64-bit overflow rather than constructing an unbounded bigint; leading zeros remain valid. The same guard covers !rollup -fel input and !time -t.

  • !loop and !bits2 run their commands as !foreachline does: they count against the limits of the command line, and .break and .continue act on their passes. Each pass is expanded only after its budget check; a break stops later expansion, including for large scripts.

  • !time -t is accepted but has no effect, as a command can not be stopped here (the limits of the command line still apply), and !time -q hides the output of the command but still shows its errors. The execution time and truncation warning remain visible even when the displayed body reaches the output limit.

  • !foreachitem and !foreacharrayitem replace @#Item with 0x<address> (MEX puts the hexadecimal digits alone), so the address reads the same in any radix.

  • !foreacharrayitem -end is the address of the last item of the array, and -t takes any type that sizeof knows here (built-in scalar types, pointers and the types of cached private PDBs), not only module!type.

  • !foreachitem, !foreacharrayitem and !dumpnativearray visit at most 10000 items: a longer list stops there with a warning, and a longer array is refused. A list walk also stops, with an error, at a loop or at memory the capture does not hold.

  • !foreachavlentry and !btree visit the entries of an RTL_AVL_TABLE in order, without the table's own BalancedRoot; MEX lists the nodes level by level, starting with that root. !foreachavlentry shows in Item #n the address of the entry's data, which its commands get, and without -x it lists the entries.

  • !foreachhashentry walks the buckets of the hash table itself, with the bucket layout of Windows 10 version 1607 and later, and refuses a table of more than 65536 buckets; MEX has another debugger extension list the entries.

  • !rbtree prints each node's address as 00000000`50006100 rather than as bare hexadecimal digits.

  • !btree takes -e or -n as options of one command and shows each structure with dt (MEX uses !ddt); the field of -e comes from a cached private PDB or a built-in layout.

  • !foreachavlentry, !foreachhashentry, !rbtree and !btree stop after 10000 items with a warning, and at a loop or at memory the capture does not hold with an error.

  • !byteorder swaps 16 bits for a value up to 0xFFFF and 32 bits up to 0xFFFFFFFF (MEX switches at 0x7FFF and 0x7FFFFFFF), and also swaps without -n or -h, where MEX shows nothing.

  • !base64 reads the decoded bytes as UTF-16 after a byte order mark or when every second byte is 0, and as UTF-8 otherwise; bytes that are not text are shown as a hex dump, which -x asks for. -f, which saves the data to a file, is not available.

  • !asn decodes DER unless -b asks for BER, which also allows indefinite lengths (MEX needs one of them and decodes only DER). It shows the class, form, tag and length of each element and the value of the common universal types, decodes more than the first element when -l says how many bytes, and stops at 32 levels of nesting.

  • !ndso, !ndro, !ndto, !classtype and !dumpvtable know a vftable by the public symbol at its address, in the modules whose symbols are cached. They read the MSVC-decorated names of classes and namespaces, with the base classes of a subobject's table ({for ...}); a name of another form (a template class) is shown as the PDB stores it. An object's address links to dt <module>!<class> (MEX links !mex.ddt), for a subobject's table to dt of its base class.

  • !ndso ends with a line that says which range it scanned and how many objects it found, or where -l stopped it. Where the capture records no stack base (a kernel dump), it scans the memory captured above the stack pointer, at most 64 KiB, and says so. !ndro checks the integer registers of the current frame, !ndto reads the TLS slots of the TEB itself and runs on user-mode captures only, and both print a line when they find nothing.

  • !dumpvtable counts a table's slots from memory: the slots that hold executable code in any loaded module, up to the next public symbol, at most 1,024. -t takes the class name whole, in any letter case, and the RTTI is unknown when the slot in front of the table is not in the capture.

  • !ndao without a range scans all captured memory, at most 64 MiB at once (MEX scans the process heaps; -h for one heap is not offered). It lists at most 4,096 objects and ends with a line that says what it scanned. -s counts the objects of each vftable, smallest count first, and links each count to !mex.searchpointers; MEX's cache of the last summary is left out. Summaries stop at 65,536 unique objects with an incomplete-summary warning. A kernel capture needs a range.

  • !searchobjs, !searchpointers and !findobj search all captured memory, as much as one s (1 GiB), for pointer-sized values at pointer-aligned places (MEX's !searchpointers looks for 32-bit values), stop after 4,096 hits and run on user-mode captures only. !searchobjs searches for every vftable of the class and prints each object's address and class before the command's output; its default command dt <Symbol> needs the private symbols of the module. !findobj lists the object, its number and its class, without -v.

  • !gflag names the flags by the abbreviations of the GFlags flag table on Microsoft Learn and shows a bit without one in hexadecimal; in a user-mode capture, -k alone says that the kernel's flags need a kernel-mode capture.

  • !ver prints the version, the build number and the release lines from WinXP to Win11_22H2OrNewer, without Win2k3SP1OrNewer; in a kernel-mode capture it reads the version from KUSER_SHARED_DATA. These are legacy compatibility predicates, not a complete release name: the exact captured version is retained, including newer Windows 11 builds such as 26H2 (26300) and hardware-scoped 26H1 (28000).

  • !publicsymbolcreep checks the modules whose recorded path is in the Windows directory, and counts a cached PDB without local symbols as public, as Microsoft's public PDBs are.

  • !tp lists the thread pools of a user-mode dump and the stacks of their workers (-wt) only: -m, -t, -tq, -taskqueue and -tpinfo say that they are not available, and the kernel-only -p, -e and -wf are refused.

  • !tp reads the pools with the thread pool types (_TP_POOL, _TPP_WORKER_TCB) and TppPoolpList from the PDB of ntdll; without them it says which one is missing.

  • The US column of !tp links every pool to the stacks of its workers, and there is no Info column; MEX shows both only for a pool whose worker factory is exhausted.

  • !chk compares the code sections of each module in memory (every section with -as) with the module's cached image file itself, after applying the image's base relocations for the load address, instead of running !chkimg; a module without a cached image file is listed as No image, so run .reload first. It follows a patched jmp or call (E9, E8, EB, FF 25, FF 15, mov rax, imm64; jmp rax, push imm32; ret) through at most four jumps to name the detour target. Without -u or -k it checks the user-mode modules of a user-mode capture and the kernel's modules of a kernel-mode capture. The comparison stops after 256 MiB and retains at most 1,000 differing ranges, with explicit limit warnings. Relocated images with incomplete, malformed or unsupported relocation data are not compared as if clean. Relocation reads are at most 64 KiB each and 4 MiB total per image.

  • !unassemble (!u) prints what uu, ub (-b) or uf (-f) prints and appends -> <target> to each call and jump, conditional jumps included: the target of a direct branch, the pointer that a memory operand reads ((not captured) when the capture lacks it), and the value of a register, or of a memory operand built on one, only at the instruction the current context stops at in the top frame. It reads the Intel syntax of x86 and x64; in the AT&T syntax and on ARM64 the lines stay as they are. Length is passed on as the L of uu and ub, and only one of -b, -f, -fc and -n may be given.

  • !outline (!ol, !ufc) lists the calls of the function that uf disassembles: one row per target with the number of calls and the first call site, and the operand itself for a call it cannot follow.

  • !x <arguments> prints what x <arguments> prints without the funclets (::dtor$, ::catch$, ::fin$ and ::filt$, also in their decorated form ?dtor$…) unless the pattern names their kind, and notes how many it left out. Public symbols carry no type, so no line links to dt -a, and -function keeps the symbols that lie in an executable section of the image. The x options that change the form of the lines (/0, /1, /v, /t, /f, /d) leave every line as it is. More than 30 symbols get links that sort them by address or name.

  • !x without arguments (also !xx) shows the locals that dv /i /t /v lists as a table of their location, name and value, with their scope and type for -v (!xv).

  • !ddt runs dt and keeps its lines. It links a pointer to a structure the module defines to !mex.ddt <type> <pointer>, and shows a _LIST_ENTRY field as [ <Flink> - <Blink> ], linked to dl (dl b for the Blink) from the field, with (empty) or (invalid) after it. -r, -r1 and -r2 go to dt as they are. -table makes one row per object and one column per field (parent.child for a nested field). -x Command (also -fel) takes the objects from the lines of the command's output that start with an address, and the first object that dt fails on stops the walk. MEX's -report, -v, -l, -n and --z and its handlers for particular types are not available.

  • The wait reason commands (!wrresource, !wrqueue, !executive, !userrequest, !lpcs, !lpcw and the others named after a wait reason) all show the same columns: process, PID, TID, thread and wait time. MEX varies them by command and adds a Waiting On column. Every one takes -p, which lists the same waiting threads grouped by process.

  • They say No threads found in waiting state (<reason>) when no thread waits with the reason, and they take the reason's value from the nt PDB, so !maximumwaitreason lists the threads whose wait reason is the PDB's MaximumWaitReason.

  • !cpu counts as ready threads (Rdy) the threads in the processor's ready lists, where MEX counts the ready threads whose next processor it is. It does not read the IRQL of an interrupt object, and it leaves out MEX's long-DPC and efficiency-class columns.

  • !dpcstack (!dpcq) shows, for each processor or for the one -n names, the stack from the first return address on the DPC stack whose unwind reaches nt!KiRetireDpcList, nt!KiInterruptDispatch or nt!KeBugCheckEx. MEX shows the stack of the first return address without -n, and asks for all three functions with it.

  • !timers reads _KTIMER.Dpc as it is stored. On recent x64 Windows that pointer is obfuscated, so this analyzer does not resolve the DPC of those timers; the thread timers and the due times are still shown.

  • !wq shows the executive work queues of the system partition (nt!PspSystemPartition). It implements the queue table, -t, -s, -w, -p and -q; the Windows 8 queue options (-c, -d, -y, -su, -b, -n, -realtime, -a) are refused, and the driver-specific work item decodes (fltmgr, ndis, rdbss) are left out.

  • !evt, !mutant (!mutex), !semaphore (!sem) and !fastmutex (!fm) print the object's state as Name: value lines under a <type> @ <address> line whose address runs dt, instead of MEX's !ddt dump, and list the threads that wait on the object in a table (process, PID, TID, thread, wait type, wait time and wait reason) instead of a link to !obj -waiters. They do not show the object's name.

  • !evt, !mutant and !semaphore refuse an object whose _DISPATCHER_HEADER.Type is of another kind, and !mutant also shows how many times the owner holds the mutant (Recursion count).

  • !eresource (!eres) -nw lists the held resources with and without waiters, -mv prints the kernel stack of every thread listed instead of a Wait Function column, and -a or -nw with an address is an error. The waiting threads are listed only when ExclusiveWaiters points at an event and SharedWaiters at a semaphore; the wait chains of newer Windows versions are not walked, and their waiter counts are still shown. There is no !locks link.

  • !fasteresource (!fasteres) shows the fields of nt!_FAST_ERESOURCE_INTERNAL as dt shows them when the nt PDB has that type, and says that the type is not available otherwise. It does not list owners and waiters, and it takes no -v or -mv.

  • !pushlock (!pl) also takes the address of the push lock and shows its state, and it lists every thread of the process that owns the process's address space, exclusively or shared, with its kernel stack, where MEX names one exclusive owner.

  • !deadlocks (!dls, !waittree) and !hang need a kernel-mode capture. A wait chain goes from a waiting thread to the owner of the mutant, fast mutex or guarded mutex it waits for, or to the exclusive owner of the executive resource it waits for (found through nt!ExpSystemResourcesList), for at most 32 threads. It ends at any other wait: resources held shared, push locks, ALPC and LPC, thread and process objects, and user-mode locks are not followed.

  • !deadlocks prints no progress bar, and counts as affected only the threads whose wait chain runs into a cycle of two or more threads.

  • !hang -c and !hang -w do not print the time they took. !hang -w counts each waiting thread of the analyzed processes under the thread its wait chain ends at (never a process or a service), lists the first 5 waiters without links, and then prints the !deadlocks summary of every waiting thread. -fast keeps the threads that two or more threads wait for, -s needs a session number, and -v is not available.

  • !mheap walks the NT heaps itself and prints its own tables (every heap, the busy blocks of one heap by user size, the busy blocks of one size, the block that holds an address) instead of the output of !heap. It reads the heap layouts from ntdll's PDB, and does not walk segment heaps, page heap or the blocks inside low-fragmentation heap subsegments.

  • !deviceobject, !driverobject and !fileobject check the object's Type (IO_TYPE_DEVICE, IO_TYPE_DRIVER, IO_TYPE_FILE) rather than its pool tag, and print the pool tag of the allocation when the address holds something else. Their links open dt nt!<type> for a structure that no MEX command here shows.

  • !deviceobject also shows the device stack (the devices attached above and below), the device queue and the device's name, and decodes the flags and characteristics; !driverobject adds the driver's start, size and service key and the name and type of each device, and does not list the client driver extensions.

  • !fileobject shows its values as Name : value lines with the flags decoded and the byte offset in hexadecimal, names the driver of each queued IRP from the IRP's current stack location, and does not show the process that owns a named pipe.

  • !tasklist leaves out a CPU time, a size or a VAD count of 0, so a column whose values are all 0 is left out (MEX shows 0 B in some of them), and rounds sizes to two decimals (1.35 MB). Its CPU times add up the process's own time and that of its threads that have not terminated, and it reads the command line and the global flags (-cl, -g, -proc) through each process's page tables.

  • !tasklist -u shows the account name of a well-known SID (NT AUTHORITY\SYSTEM) and any other user as its SID (S-1-5-21-...); MEX shows the account of the token's logon session.

  • !tasklist -t (!tlt) counts a thread as running by its state alone, and leaves out of the IO column only the System thread that starts at nt!MiModifiedPageWriter; MEX also checks each processor's current thread and the threads' stacks. -tu (!tltu) shows the same counts and says that the user-mode lock counts (Cs, Ll, Sl, Re) are not available.

  • !tasklist says under the table how many processes a filter (-s, -j, -u, -g, -t) left out because the value it checks could not be read (a PEB or a token that the dump does not hold), and says so when -crash cannot tell which processes are crashing (a PDB without _EPROCESS.Crashed). Its CPU times and thread counts read at most 65,536 threads over all processes; past them, it leaves them out and says for how many processes. When the rows, or the processes of -tree, do not fit in the 10,000-line output limit beside its notes and summary, it shows the first ones and says how many it left out.

  • !poolsearch follows the chain of _POOL_HEADERs from Start, which should be the start of a pool page, and lists the busy blocks that have the tag rather than every place its bytes appear; a tag of 1 to 4 characters is padded with spaces, a . in it matches only a real . (not a byte that is not printable, which the pool commands show as .), and a segment-heap pool is not searched.

  • !tag searches the code sections of the module images in the symbol cache, not the dump's memory, shows at most 10000 hits (fewer when they do not fit in the 10,000-line output limit, and then says how many it shows), and -v adds the nearest symbol of each hit; MEX shows the source lines.

  • !dtpool knows the tags Proc, Thre, File and Irp and shows them with dt; for any other tag it shows the pool block and a link to !mex.tag instead of running !pool and !mex.tag. Like the links in the Tag column of !mem, that link is left out for a tag with a byte that is not printable (shown as .) or a character that would split the command.

  • !mem shows only -npp, -pp and -commit; its other views are refused. !memreport adds up the commit, the shared commit and the working set; MEX's total also counts the pool quota.

  • !job (!ejob) shows its rows as Name : Value, adds the parent job and the process and job memory limits, shows a limit whose JOB_OBJECT_LIMIT_* bit is not set as Not configured, and lists the members with their PID and address. -q also leaves out the rows that are 0 or not configured.

  • !session (!sessions, !sess) lists the sessions that the processes have, with their process count and session space, without MEX's state, protocol, attach count and pool columns. -s, -q and a session ID make the session's csrss.exe (or its first process) the implicit process and say so, without the win32k information; -statetable, -w and -fw are not available.

  • !werfault (!wer) finds WerFault.exe and WerFaultSecure.exe in any letter case and needs a kernel-mode capture.

  • !minws -v adds each listed process's maximum working set and working set; MEX accepts -v and prints the same.

  • In a kernel-mode capture, !gflag shows the flags of the current process's PEB (the process .process chose, or the one that was running when the dump was written) as <process>: <flags>, and those of nt!NtGlobalFlag, both by the same abbreviations; MEX names the kernel's flags by their FLG_ names.

  • !obj lists directories first, then by name, with the columns Path, Name, Type, Info, HandleCount, PointerCount, Object and Header. It has no -w (waiters) and no -trace, and no RealPointerCount or Waiters column. The address of an object prints its details as name and value lines; the address of a directory prints its full name and its entries. In the tables of -t and of a name search, an object in a directory whose full name cannot be read shows that directory's address as its Path. The address of a directory reads its full name from the headers of the directory and of the directories above it, so in a capture that contradicts itself it can print a full name those tables could not build; when that full name cannot be read either, it prints the address in its place, and the entries without a Path column.

  • !objectsd prints the security descriptor as WinDbg's !sd <address> 1 does, but it names only the well-known SIDs (S-1-5-18 (NT AUTHORITY\SYSTEM)), without their account type, and it lists the names of the ACE flags that are set.

  • !vad shows no tree-level column and no line of totals per type, and a value it cannot read shows ?.

  • !vadmodules lists the files of the image VADs only; MEX also lists the data files a process maps.

  • !addr names the kernel module, kernel stack, pool block or VAD an address lies in; MEX prints the matching line of !address.

  • !addr and !meminfo need a kernel-mode target, and a user-mode address is described by the VAD of the current process that holds it (a thread's user-mode stack is not named as such); MEX's !meminfo also runs in a user-mode capture.

  • !addr and !meminfo do not decode a segment-heap pool (nt!ExPoolState): on such a dump they say that an address outside the modules, the kernel stacks and the big pool allocations may still be in a pool allocation.

  • !foreachthread (!fet) in a kernel-mode capture also sets @#SystemThreadID, @#Process, @#ProcessName and @#ProcessPid, makes the -p process the implicit process while the commands run, and skips a thread whose registers are not known with the reason. Its -ps also counts a stack that ends in nt!KiSystemServiceCopyEnd or nt!KiSystemServiceExit as whole, because the kernel stack walk stops where a thread entered the kernel from user mode.

  • !foreachprocess (!fep) refuses -m: the module list of a kernel dump holds only kernel-mode modules, and this analyzer does not read the user-mode modules of a process. -nosym changes nothing, because symbols are not reloaded for each process, and -f is a JavaScript regular expression. In @#ProcessName (also that of !fet in a kernel-mode capture), each ;, {, }, ", ' and \ of the process name becomes _, and a warning says so: a name read from the capture cannot end the command or start another one. MEX puts the name in as it is.

  • !foreachcpu (!fec) does not switch processors as ~<n>s does in WinDbg: it makes the registers of the thread each processor runs the register context, as .thread does, and the process that thread runs in the implicit process. @#THREAD is that thread's _ETHREAD.

  • !nativeheapleak (!nhl) and !heapleakanalyzer (!hla) read the stack trace database of a process that ran with +ust, with the layouts of ntdll's PDB; without +ust they say so instead of counting every block as <unknown>, and !nhl -p (page heap) is not available. !hla reads the first 500 blocks of the size it picks, in address order, and says so when the size has more, where MEX picks 500 at random. The allocator frames before the module that !nhl names also include HeapAlloc, kernel32!LocalAlloc and ucrtbase!malloc. When the stacks fill the output limit, both stop at the last stack that fits and say how many they show, and the notes on heaps that were not walked still follow.

  • A MEX table pads a column to at most 256 characters. A longer text, such as a long command line in !tasklist -proc (!tlp) or a long object name in !obj, is printed whole but does not widen its column: the rest of its row moves right, and the other rows keep their width.

  • Kernel handle commands require nt symbols and count actual handle-table entries, without a cache option. Object details are tables rather than nested !object output. -g groups full names; file searches compare FileName only and display named devices in braces. Whole-dump walks share work/entry budgets and reuse repeated tables; incomplete traversal diagnostics survive output truncation.

  • !mirp reads stack locations after _IRP, marks the current location with ->, and decodes I/O, power and PnP parameters. Only completion contexts receive pool tags; issuing process, APC, completion key, storage queues and minifilter searches are omitted. Unreadable frame fields stay unknown with retained diagnostics. !deadirps uses the current stack location and excludes non-IRP entries.

  • !mirpfind searches thread IRP lists, busy Irp big allocations and neighboring small-pool pages, not the entire nonpaged pool; segment-heap small allocations are unsupported. Value filters combine and affect counts and address-sorted details; -c includes completed IRPs. Unsafe driver names receive no executable count link. !irpbyfilename includes completed IRPs, searches afresh, and accepts -f without changing behavior.

  • Stack searches inspect kernel stacks only (-k changes nothing); -s searches ASCII/UTF-16LE. Attached-thread output omits Waiting On; tick times use short notation. Kernel runaway percentages use dump-header uptime; current functions skip context-switch/wait wrappers. Whole-command searching is bounded to 10,000,000 bytes and 262,144 steps, including failed read attempts; missing and unsearched ranges retain warnings.

  • SSDT inspection excludes win32k shadow tables and flags routines outside nt. Minifilter, power and system-time callbacks are unavailable. Missing private registry layouts show raw list nodes without guessed offsets.

  • !mreg shows structured metadata, linked subkeys and bounded value data. Paths above loaded hives list mount locations, not the master hive. -f offers default favorites only; favorite changes and notifications are refused, -c links to !mex.regflt, and -v is unsupported. CurrentControlSet requires a readable Select\Current. !svcreg prefers exact service names, then case-insensitive substrings, not regular expressions.

  • !apps includes WOW6432Node applications, normalizes install dates and reads user applications only from loaded hives. !qfe derives KB numbers only from servicing-package names, displays UTC times and links package keys. !regbloat ranks open keys in the five largest readable hives using key-node counts. Incomplete reads retain warnings; unavailable or incomplete SAM names produce N/A, not inferred user types.

GitHub Copilot

The extension contributes eight language model tools, so Copilot can analyze a dump directly: windbg_openDump, windbg_analyze, windbg_stack, windbg_modules, windbg_threads, windbg_runCommand, windbg_symbolStatus and windbg_readView. Reference them in a prompt with #windbgOpen, #windbgAnalyze, #windbgStack, #windbgModules, #windbgThreads, #windbgCommand, #windbgSymbols and #windbgView.

The tools share the same worker as the editor, so a dump opened in both is parsed once. They are read-only and bounded. windbg_openDump requires an absolute path to a .dmp, .mdmp or .hdmp file. On Windows only drive paths such as C:\dumps\app.dmp are accepted: UNC (\server\share), device (\.\) and extended-length (\?\) paths are refused for the model, so open a file on a share yourself in the editor. Concurrent opens wait for the actual capture result, and a failed open can be retried. A supplied windbg_stack thread index must be an integer from 0 to 4,095. The dedicated stack tool returns at most 40 frames. Tool output is bounded to 128 KiB of UTF-8, including its truncation notice, without splitting Unicode characters. Cancelled tool invocations stop waiting and release their pending results without closing the user's shared editor. TTD .run files are explicitly unavailable to the tool layer; trace inspection stays local to the editor.

windbg_runCommand accepts only these analysis commands: lm (names only), lm m <pattern>, ~, r, rF, rM <n>, k, kn, kf, kc, k <n>, x <module>!<pattern>, x /s <n> <module>!<pattern>, !analyze -v, .exr, .exr -1, .lastevent, .bugcheck, .time, .dumpdebug, vertarget, version, vercommand, !teb, !peb, !process, !thread, !uniqstack [-n], !gle [-all], !runaway [<n>], !error <n> [<n>], .echo <text> and .help. Each <n> must be a literal number, because a numeric expression can dereference any address with poi. An allowed command may take a ~<n> or ~* thread prefix, and ; separates several allowed commands; every command on the line is checked. A refusal repeats this list. The SOS commands (!clrstack, !dumpheap and the others) run as well, but as in the command window they only report that they need the CLR data access component. The tool refuses every other command, for example:

  • process memory contents and disassembly: db, dq, dps, s, u, uf, !teb 0x1000
  • the stack displays that print stack memory, its raw words or the argument slots: kd, kb, kv, kp, kP, !uniqstack -b, and !exchain, which prints the words of the exception handler records as they are stored
  • expressions, which can dereference any address with poi: ?, dx, dt, ln, .formats, .expr, !address, !vprot, lm a 0x1000, k = 0x1000, ~[1]k
  • the file and object paths recorded in the capture: lm v, lm f, lm p, !handle, !lmi
  • symbol downloads and the user's symbol, image and source paths: .reload, ld, .sympath, .symfix, .symopt, .exepath, .srcpath, !sym, .cache
  • session state that belongs to the user's command window: breakpoints and event filters (bp, sxe), assertion handling (ah), aliases (as), the register and frame context (.ecxr, .cxr, .frame, .f+, .f-), thread selection, freeze and suspend (~1s, ~0f, ~0n), options and masks (so, sq, ss, rm) and ending the session (q)
  • commands that run other commands: ~e, .if, .foreach, .catch, j, z, !for_each_module, !for_each_frame
  • TTD inspection and replay navigation: !ttdinfo, !ttdpages, !ttdevents, !tt, !positions, t, p, t-, p-, g, g-
  • the MEX commands, which run other commands and read memory: !mex, !mex.help, !mex grep error k; lm

The stacks the tools read (k and kc with any of their options, ~*k, windbg_stack and !uniqstack) leave out the source file and line, as kL does, because a private PDB records them as paths on the build machine; the command window still shows them. Likewise vertarget and version leave out the service pack, the CPU vendor and the build lab for the tools: they are free text from whatever wrote the dump and can name a machine, a user or a path. The allowlist reads the command as it was written, and the tools run without alias substitution, so an alias defined in the command window cannot change what a command does for the model. The dedicated stack tool scopes a requested thread to one stack walk and restores the user's current thread.

windbg_readView reads what one of the WinDBG views shows: threads, callStack, modules, registers, watch, locals, commandTree or parallelStacks. It reads the dump open in your analyzer, the active one or else the one you used last, not the dump the other tools opened, so it needs no windbg_openDump, and it reads afresh whether or not the view is visible. The text starts with the view's name and the dump's file name, never its folder, followed by one line per item: the label and the description the view shows (for a frame, its source file name and line, never the folder), (current) on the current thread or frame, (changed) on a register or watch value that differs from what the view showed when it last read, (error) on a watch expression that could not be evaluated, the kind, type and location of a local, the nodes of a command tree indented by depth with their commands, and the frames of the parallel stacks, each indented two spaces further than the frame it called, with how many threads pass through it and (current) on the current thread's innermost frame. A view without items gives the view's message instead. At most 1,024 items and 64 KiB of text are returned, and a last line says when items were left out. The watch view evaluates only the expressions you added; the tool cannot add, change or evaluate any other. Reading a view runs no command, starts no download and changes nothing in the session or in the views, and the text, in English like every tool result, names no path: the source file of the current frame stays with VS Code.

The WinDBG Analyst agent is contributed by the extension; pick it in the Chat agent picker. It ships as agents/windbg-analyst.agent.md. If you copied that file into your workspace's .github/agents/ folder earlier, delete the copy so the picker does not list the agent twice. A VS Code version that does not know the chatAgents contribution point ignores the contribution; there, copy agents/windbg-analyst.agent.md from the installed extension's folder into your workspace's .github/agents/ folder as before.

Claude Code

Claude Code connects only to the MCP servers in its own configuration; it does not use the VS Code language model tools. The extension can therefore serve the same eight tools to Claude Code through a local MCP server, off by default. Their names, inputs, checks and texts are those of the GitHub Copilot tools, and the two share the dump windbg_openDump opened: an open from one replaces the dump of the other.

To set it up:

  1. Run WinDBG: Set Up Claude Code Access and confirm. It turns on windbg.assistantServer.enabled in your user settings, creates an access token, starts the server on 127.0.0.1 at port windbg.assistantServer.port (47110 unless you change it) and copies a command line such as claude mcp add --transport http --scope user windbg http://127.0.0.1:47110/mcp --header "Authorization: Bearer <token>" to the clipboard, with your port and token.
  2. Run the copied command line in a terminal. When Claude Code already has a server named windbg, run claude mcp remove windbg first.
  3. Run /mcp in Claude Code to check that windbg is connected. The tools are listed as mcp__windbg__windbg_readView and so on.

The server runs in a VS Code window once the extension is active there, that is after you open a dump or run a WinDBG command in it, and it reads the dumps open in that window. Only one window can listen on a port: when another window or another program already uses it, the extension says so in a warning that names the port, and Claude Code reaches whatever holds the port. To use a second window, set another windbg.assistantServer.port there and add it to Claude Code under another name.

Security:

  • The server listens on 127.0.0.1 only. It answers only POST requests to /mcp that are addressed to 127.0.0.1 or localhost at its port and carry the access token, and it refuses any request with an Origin header other than null, so neither another machine nor a web page, also through DNS rebinding, can reach it.
  • The access token is 32 random bytes kept in the operating system keychain (VS Code's secret storage). The extension never writes it to a setting, a log or a file; Claude Code keeps it in its own configuration (~/.claude.json) once you add the server. WinDBG: Reset Claude Code Access Token replaces it at once and copies the new command line: run claude mcp remove windbg and then that command line.
  • A request body is at most 1 MiB, at most 4 requests are answered at once, and a tool result is at most 24 KiB of text, well below the 25,000 tokens Claude Code keeps of a tool result by default. A longer result keeps its first whole lines and ends with a line that says how many were left out; GitHub Copilot still gets up to 128 KiB.
  • The server speaks MCP revision 2025-11-25 (and 2025-06-18) over streamable HTTP, with one JSON answer per request and no sessions.

To remove the server, run claude mcp remove windbg and turn off windbg.assistantServer.enabled, which stops the server at once. Run WinDBG: Reset Claude Code Access Token as well when the old token must stop working.

Settings

Setting Default Description
windbg.symbols.servers [] Ordered symbol server endpoints. Each entry must be an absolute https:// URL without credentials, query or fragment. Microsoft Public Symbols is appended last unless windbg.symbols.microsoftPublicSymbols is off. Endpoints named in an authentication profile use its selected authentication method. At most 16 entries; an entry that is not used (not an https:// URL, a duplicate or over the limit) is listed by WinDBG: Show Symbol Diagnostics
windbg.symbols.useEnvironmentPath true Read _NT_SYMBOL_PATH and _NT_ALT_SYMBOL_PATH (srv*, symsrv* and cache* entries). Their https:// servers are queried after windbg.symbols.servers, the first cache directory they name is used when windbg.symbols.cachePath is empty, and their local directories are searched after those of windbg.symbols.localPaths. WinDBG: Clear Symbol Cache asks before it clears a cache they name. Turn off to ignore both variables
windbg.symbols.authentication [] Authentication profiles for private symbol servers, each { endpoint, kind, argument, audience }. kind is azureCli (default) or personalAccessToken. A credential is attached only when the request endpoint matches a profile exactly, and never reaches the signed blob URL. No credential is stored here
windbg.symbols.cachePath "" Directory used to cache downloaded PE and PDB artifacts, for example C:\symbols to share the cache with WinDBG. Must be an absolute path below the filesystem root (on macOS, at least two levels below it). Empty uses the cache directory named by _NT_SYMBOL_PATH (see windbg.symbols.useEnvironmentPath) or, without one, the extension's global storage, which is also used when the value is rejected; a rejected value is reported once per window and in WinDBG: Show Symbol Diagnostics
windbg.symbols.microsoftPublicSymbols true Query Microsoft Public Symbols after the configured servers. Turn off to use only your own servers, local directories and the cache. An entry that names Microsoft Public Symbols is controlled by this setting alone
windbg.symbols.offline false Resolve symbols only from the verified local cache and never start a network request
windbg.symbols.autoLoad true Fetch symbols for replay-safe commands automatically. Stateful and continuation-dependent commands are not rerun; use .reload first
windbg.llvm.toolPath "" Directory containing llvm-symbolizer, llvm-pdbutil and llvm-mc. Empty auto-detects
windbg.command.historySize 200 Number of entered commands kept in the session-only history. Zero disables recall, not ENTER repeat
windbg.command.startupCommands [] Debugger commands the command window runs in order, exactly like pasted lines, each time a crash dump becomes ready, including after WinDBG: Restart Analyzer Session. At most 32 entries, each one command line of at most 2048 characters; an invalid entry is skipped and reported in the command window, and a longer list runs nothing. Only user settings can hold it, never a workspace. Not run for TTD traces or the GitHub Copilot tools. Applies to dumps opened after the change
windbg.output.maxLines 10000 Maximum output lines retained for each command; independent of command-window scrollback
windbg.disassembly.syntax intel Assembly syntax used by the disassembly commands
windbg.symbols.localPaths [] Directories searched for images and PDBs before any symbol server is asked. Each entry must be an absolute path; at most 8 are used. A file is used only when it is the exact build the dump recorded, and is then linked or copied into the symbol cache; the directories are never modified. Applies to dumps opened after the change
windbg.source.pathMappings [] Maps the source paths recorded in symbols (for example D:\a\_work\1\s from a CI build) to directories on this machine, each { from, to }. The first entry whose from is a path prefix wins, / and \ are interchangeable, case is ignored, and to must be an absolute path. At most 16 entries. Applies to dumps opened after the change
windbg.output.scrollbackLines 50000 Maximum number of output lines kept in the command window. Older lines are discarded first.
windbg.history.saveToFile true Append each command run in the command window of a crash dump or TTD trace, with its output, to the history file next to the capture (foo.dmp.history for foo.dmp), and start the command history of an analyzer with the commands of that file. Off writes and restores nothing. Read for each command, and for restoring when an analyzer opens
windbg.source.followFrame true Open the source file of the current frame beside the analyzer, with its line marked, whenever the frame changes. A file opens only while the analyzer is the active editor, also with the WinDBG views hidden. A change applies at once
windbg.assistantServer.enabled false Serve the WinDBG tools to Claude Code through a local MCP server on 127.0.0.1 (see Claude Code). Turning it off stops the server. It can be set in the user or machine settings only, never by a workspace
windbg.assistantServer.port 47110 The port on 127.0.0.1 that the server for Claude Code listens on, from 1024 to 65535. A change moves the server at once

A dump keeps the settings it was opened with: windbg.symbols.cachePath, windbg.symbols.localPaths, windbg.symbols.useEnvironmentPath, windbg.llvm.toolPath, windbg.disassembly.syntax, windbg.output.maxLines, windbg.output.scrollbackLines, windbg.source.pathMappings and windbg.command.startupCommands apply to dumps opened afterwards, and the extension asks you to close and reopen an open dump when one of them changes. The symbol server, authentication, offline and auto-load settings take effect on the next request.

Supported Files

Extension Status
.dmp, .mdmp, .hdmp User-mode minidump. Supported
.dmp (kernel) x64 Windows kernel crash dump: complete (type 1) and bitmap (types 5 and 6) memory dumps. Supported with limits; see Limitations
.run Experimental inspection of known x86/x64 TTDLog 1.9/1.11 containers, thread identities, verified initial GPR snapshots, static recorded pages, PE/PDB identities, recorded metadata events and eligible event-local debug-output text; no general replay

File associations accept every casing of these extensions, including .DMP, .MDMP, .HDMP and .RuN.

Limitations

  • Read-only capture file. The extension never writes to the dump and does not support live debugging. For dumps, memory and register edits, thread freeze/suspend state, breakpoints and event filters exist only in the analyzer session; they never change or resume the captured process. TTD inspection does not allow these mutations.
  • Kernel crash dumps are partly supported. x64 complete (type 1) and bitmap (types 5 and 6) kernel dumps open with virtual memory reads (db, dq, dps), the bugcheck processor's registers (r, .ecxr) and exception record (.exr -1), the kernel module list (lm) and the bug check summary (.bugcheck, vertarget, !analyze). k shows only the frame in the bugcheck processor's context; the kernel stack is not walked. Kernel processes and threads need symbols and are not decoded, and paged-out and transition pages read as unavailable. Small memory (type 4) and kernel summary (type 2) dumps, .dump /k, /ka and /f dumps (types 8, 9 and 0xA), and 32-bit or non-x64 kernel dumps are not supported; opening one says what the file is and why it cannot be opened. A file that does not exist, a directory, and a file that is locked by another process or cannot be read also say why they cannot be opened, without showing the path.
  • A running dump command can only be stopped by restarting the analyzer. Commands run on one worker thread that cannot be interrupted. Escape cancels a symbol download or stops a TTD scan or replay; for any other command it offers to restart the worker, which discards the session-only state (aliases, breakpoints, memory edits and the thread selection). A command that is blocked in an external LLVM tool can keep the old worker thread busy until that call ends, but the new worker is not affected.
  • Very large capture lists are truncated. Only the first 4,096 modules, 4,096 threads and 65,536 handles of a capture are loaded. The open banner and the commands that list them (~, lm, !handle, !analyze) say how many entries were left out.
  • TTD replay is limited, and its results are not yet compared with WinDbg's. !tt, t, p, g, t-, p- and g- replay one selected thread forward from a keyframe on the TTDLog 1.11, variant 3, header field 52, x64, 1 MiB layout, through the instructions and recorded transitions the extension models, and otherwise stop at the last verified position. Other .run inspection is limited to validated container fields, trace-wide thread identities, verified per-thread initial GPR snapshots, static recorded pages, recoverable PE/PDB identities and eligible event-local debug text. Selecting an initial GPR snapshot does not restore memory, stacks, other register state or thread/module/event lifetimes at that point. Full independent replay and its parity validation remain future work. Contributors can generate bounded, hash-only metadata comparison artifacts with the development-only producer; generation alone is not oracle parity. Separate comparisons include process/OS fields, module identities, thread active bounds, record clients and recorded exception/custom payloads, plus explicitly scoped island-start and control-gap comparisons, but not complete island/gap semantics. A separate debug-output query compares one eligible event's exact thread/position, full descriptor and complete string-byte digest, including its NUL terminator. registers and memory queries replay the thread to an exact position and compare its scalar registers and thread-local replayed bytes; unknown state is unavailable, never zero. Unsupported paths, missing state, corrupt strings and exceeded budgets never count as parity. Recorded PE fields can also be compared separately without asserting exact module-name spelling. Explicit comparisons also preserve global custom-event scope and recorded client closes, including empty payloads. Native descriptor-name reuse has a separate comparison; original recorded module names are never rewritten to force a match.
  • No managed (.NET) analysis. SOS commands (!clrstack, !dumpheap, !dumpobj, ..., also in the !sos.clrstack form) are recognized but report that they need the CLR data access component, which this analyzer cannot load. Use dotnet-dump, or WinDBG with the SOS extension, for managed analysis. SOS-style analysis is planned for a later release.
  • Debugger command programs run only in part. .echo, .if / .elsif / .else, .block, .catch, j, .while, .do, .for, .foreach, z, .break and .continue run their commands against the capture; .foreach /f, z with a processor selector, a second z on one command line or block, !for_each_local, and the !for_each_module aliases for versions, image names and symbol files are not available yet. Script files ($< and its other forms) run only from the command window, and a script file whose name is known only while the program runs (a .foreach token, or ${$argN} with no argument) is refused.
  • ARM64 stack unwinding is derived from the specification and is still waiting for verification against a real ARM64 capture. Results are labelled accordingly.
  • Stack frames recovered by scanning the captured stack are labelled as such. A minidump normally captures thread stacks but not the module images. Once .reload has fetched an image, frames inside it are unwound exactly from its exception directory; everything past that is recovered by scanning and is marked so the two are never confused. Scanning stays within the selected thread's stack. x64 prologue, epilogue and saved-frame-register recovery uses only captured data; unsupported unwind forms retain the scan label. Cached image payloads have a 128 MiB budget per worker. Larger images still provide bounded metadata and symbol lookup, but unwinding that needs unretained image bytes falls back to labelled scanning.
  • Private typed views depend on PDB records. _TEB and _PEB have stable built-in prefixes; other dt / dtx types and dv locals require a cached private PDB. A local whose record names no base register, and one the compiler optimized away, are reported as unavailable.
  • A capture file must not change while it is open. The analyzer reads the file as it needs it and keeps no copy. If another process rewrites, extends, replaces or removes the file after it was opened, every later command stops with "The capture file changed on disk after it was opened. Close and reopen it." instead of answering from a mixture of old and new bytes, or from a file the path no longer names. The memory window stops the same way. Opening the capture again, or WinDBG: Restart Analyzer Session, reads the file as it is at that moment, and that content is the capture from then on. Before each request the analyzer compares the open file's size, modification time and file ID, and checks that the path still names that file, so only a change in place that restores all three is not detected.
  • Source files are opened from the path recorded in the symbols, or the one you map. CI-built binaries record paths that do not exist on your machine; map them with windbg.source.pathMappings. SRCSRV and SourceLink are not supported, so source files are never downloaded.

Roadmap

  • [x] Read-only custom editor and command window shell
  • [x] Minidump stream parsing and the lm / ~ / r / d* command family
  • [x] Stack walking (k), ln and expression evaluation
  • [x] Symbol server configuration, LLVM tool discovery and .reload
  • [x] Disassembly (u) and symbol-annotated pointer dumps (dps)
  • [x] Type-aware commands (dt, dx, !peb, !teb, !process, !thread, !handle)
  • [x] !analyze -v
  • [x] Session-only breakpoint, assertion and exception-filter setup
  • [x] Session source-file loading and opening the current line in VS Code
  • [x] GitHub Copilot integration
  • [x] A detachable memory and disassembly window
  • [x] Experimental TTD .run container, recorded-page and PE/PDB identity inspection
  • [x] Explicit per-thread initial GPR snapshots for verified prefixes, without restored memory
  • [x] Trace-wide thread and module lifetimes, recorded metadata events and eligible event-local debug-output text for verified TTD profiles
  • [ ] TTD arbitrary-position state and general replay
  • [x] Kernel crash dump: x64 complete/bitmap memory, modules, bugcheck
  • [ ] Kernel processes, threads, stack walks and the remaining dump types
  • [ ] SOS-style managed .NET analysis

Privacy

The capture file is strictly read-only. Symbol loading is automatic by default when a command needs it; enable windbg.symbols.offline to prevent network requests. Language model tools never start symbol downloads. windbg_readView gives GitHub Copilot what a WinDBG view shows, the values of registers, watch expressions and locals included, and the dump's file name, but no path. With windbg.assistantServer.enabled on, Claude Code gets the same tool results through the local server, and nothing else (see Claude Code). Full file paths, memory contents, command lines, symbol paths and LLVM tool paths are never written to logs, to persistent state, or to test and benchmark output. Symbol downloads use configured endpoints followed by Microsoft Public Symbols, and each request carries the module's file name and identity key (turn off windbg.symbols.microsoftPublicSymbols to keep them off Microsoft's servers). A downloaded image or PDB is cached only when its own identity matches the one recorded in the capture. Direct responses must deliver their declared byte count, and a PDB must contain every block its MSF superblock declares before its GUID is accepted. Cache hits are revalidated; unreadable or inconclusive entries are not reported as verified. Symbols that no server had are not requested again for one hour: only the module's name and key, a digest of the server list and a timestamp are kept, in a small file next to the cache. Resumable parts are tied to the source and representation rather than reused by length alone, and compressed artifacts are expanded with bounded reads instead of loading the whole archive. Local LLVM symbolization explicitly disables debuginfod downloads.

.hh opens Microsoft Learn in your browser only when you run it. With a topic, the topic is part of the search address the browser opens; nothing else about the capture is sent. windbg.symbols.offline does not apply to it, because the browser, not the extension, opens the page.

WinDBG: Open Notes writes a file only when you run it and the capture's notes file does not exist yet: it creates <capture file name>.notes.md in the capture's folder, holding only the heading # Notes: <capture file name>. Everything else in that file is what you type and save. The extension never reads, changes or deletes the notes afterwards, and its messages name the notes file without its folder.

The other file the extension writes beside a capture is its command history file, and only while windbg.history.saveToFile is on, which it is by default. It is in the folder of the capture and is named after it with .history added (C:\logs\foo.dmp.history for C:\logs\foo.dmp). After each command the command window runs, the analyzer appends the local time, the prompt, the command and every line the window showed for it, as plain UTF-8 text. That output can hold memory contents, symbol names, file paths and anything else a command prints, so treat the file like the capture itself. A file that would grow past 32 MiB is first renamed to <capture file name>.history.1, replacing an older one, so at most two such files are kept. Nothing the GitHub Copilot tools run is written there. When the file cannot be written (a read-only folder, a share without write access), the command window says so once, naming the file but not its folder, and that analyzer writes nothing more. Turning the setting off writes nothing from the next command on; the files already written stay until you delete them.

License

MIT

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft