Microsoft PIX Changelog

What's new in Microsoft PIX 2403.08

Mar 11, 2024

Support for new D3D12 Features:
Work Graphs:
This release includes PIX support for the final D3D12 Work Graphs API that was released today. PIX has full capture/replay support for the API, and it allows you to view event details, your local root arguments table (LRAT) layout, your node inputs, a detailed breakdown of your state objects, and hardware counter data/graphs for your DispatchGraph() calls.
These features were previously available in a preview version of PIX alongside the preview Work Graphs API. Please see this blog post for more information about the PIX features.
Image WorkGraphs:
GPU Upload Heaps:
GPU Upload Heaps are out of preview and can now be used in any D3D12 application that’s running on a supported GPU/driver with Windows 11 Insider Preview Build 26080 or later.
PIX has full support for GPU Upload Heaps. And good news: the OS performance issues that impacted PIX + GPU Upload Heaps in last year’s preview release have been resolved! This means that there is no need for an application to use PIX’s ID3D12ManualWriteTrackingResource APIs to avoid performance issues, although developers are still welcome to use these APIs if desired.
Generic Programs in State Objects, Shader Model 6.8, Incrementing Constants:
PIX includes support for all these additional D3D12 features released today. Support for Generic Programs is minimal though – PIX shouldn’t crash during capture/replay, but most a lot of features available when using traditional Pipeline State Objects will be unavailable when using generic programs. These features will become available in future versions of PIX.
Shader debugging speed and reliability improvements:
This release includes some significant performance improvements to shader debugging start times for some applications. For example, the time to start shader debugging on a famous sample from a famous DXR engine has reduced from over 5mins to 30secs. Other applications see more modest improvements.
We have also fixed a wide range of shader debugging bugs reported by our users. Please continue to contact us with issues you hit!
New texture visualizers:
We have added several new texture visualizers to this release, including:
Depth test visualizer: shows pixels that passed the depth test in green, and failed in red
Stencil test visualizer: shows pixels that passed the stencil test in green, and failed in red
Culling test visualizer: shows pixels that passed the culling test in green, and failed in red
Viewport visualizer: shows pixels outside the current viewport (viewport 0) in magenta
Scissor rect visualizer: shows pixels outside the current scissor rect (0) in magenta
The existing diff visualizers have been updated to support MSAA textures too. We plan to continue adding more visualizers in the future: next up is a NaN visualizer! If you have other ideas or suggestions for visualizers then please let us know.
Image ViewportVisualizer:
Misc UI performance improvements:
We have made many different performance improvements to the PIX UI in the past couple of months, including updating from .NET 6 to .NET 8. We hope that this will make the PIX UI feel snappier + more user friendly. More improvements will come during the rest of 2024!
The move to .NET 8 has also fixed some common .NET 6 bugs that our users hit, including this crash involving Logitech mice.
Support for gathering shader reflection data from PDBs:
In this release, PIX can gather shader reflection data from PDBs and use it to populate key information in the UI such as the Pipeline tab. This means that you can now compile your shaders with /Qstrip_reflect and still see reflection data in the Pipeline tab, assuming you have the external PDBs available.
Image StrippedPDBs:
Timing Captures:
Demoted Allocations and Allocation Migrations for GPU Resources:
In this release we’ve added tracking of demoted allocations and allocation migrations for GPU resources when the “GPU resources” timing capture option is enabled.
Demoted allocations occur when a GPU allocation is requested in VRAM but is instead placed in system RAM (often due to memory pressure and fragmentation) and show up as markers in the Residence Operations lane.
Allocation Migrations are an attempt to move a demoted allocation into VRAM. These migrations are scheduled by the kernel and are not guaranteed to succeed (see the bottom sublane in the image below. The red segments are failed migration attempts and the green is the successful one). Note that these migrations require suspending the GPU, so they have a large performance impact.
Thread and core usage data in the Timing Capture summary view:
The summary view in PIX Timing Captures now includes a table that shows the CPU utilization for all cores and for all threads in the game. Image ThreadAndCoreUsage
GPU consolidated events in the Metrics View:
The consolidated events feature in the Timing Capture metrics view now includes support for GPU PIX events in addition to CPU PIX events.
Additional metric statistics in the Metrics View:
The metrics details tab has also been enhanced to display an expanded set of statistics, including statistics for event trees.
Bug fixes and other improvements:
Added support for depth pixel history
Added ability to filter processes in the process “Attach” tab
Updated AMD plugin, with some updated counter descriptions + support for new GPU variants
Better handling of small panel sizes in the UI
More resilient handling of descriptor descs with implicit values (e.g. using -1 to specify all mips)
Add built-in “Copy” and “Copy Cell” to misc parts of the UI
Various dark mode fixes + improvements
Fix “no shader records” error when raygen doesn’t call TraceRay at all
API Objects view: show more information about some objects (e.g. command lists, metacommands)
Fix PixMarkers with default color being invisible
Misc acceleration structure camera improvements
Better error message when E_UNEXPECTED is thrown internally in PIX (not just “Catastrophic Error”!)

New in Microsoft PIX 2312.08 (Dec 8, 2023)

New in Microsoft PIX 2308.30 (Sep 2, 2023)

New in Microsoft PIX 2306.21 Preview (Jun 22, 2023)

New in Microsoft PIX 2305.10 (May 11, 2023)

New in Microsoft PIX 2303.30 (Mar 30, 2023)

New in Microsoft PIX 2303.02 (Mar 5, 2023)

New in Microsoft PIX 2210.10 Preview (Oct 13, 2022)

PIX on Windows has always been dedicated to keeping pace with the official releases of the Agility SDK. However, developers working with the Preview versions of the Agility SDK – which contain D3D12 features that are still in progress – are left without a meaningful graphics debugger. This can be especially frustrating, as these features are often nuanced and difficult to get right.
To address this, we’re excited to announce a series of PIX on Windows Preview releases. These versions of PIX on Windows are designed to work with the latest Preview Agility SDK (v706) and include our initial support for these in-progress features. Though if you are not using the Preview Agility SDK in your game/app, then we encourage you to keep using the non-preview PIX on Windows releases.
This first preview release contains support for all the new features in the Preview SDK, notably:
Enhanced Barriers
Independent Front/Back Stencil Refs and Masks
Triangle Fans
Though it’s important to note that some of these features in PIX on Windows are still in-progress themselves, which means you may experience problems or limitations with our support so far. We are actively working on these features and we plan to release new versions as we finalize support.
If you run into any issues with the current implementation, or if you have suggestions about how they could be better, please reach out and let us know! You can find us at discord.gg/directx. Alternatively, every email from when you hit the Send Feedback button goes straight to the entire PIX on Windows team.
Restrictions in the Preview Build:
Since these features in PIX on Windows are all in-progress, we wish to reserve the right to alter the in-progress file layout. As a result, capture files taken with the Preview builds will not be compatible with any other builds of PIX on Windows, including future official releases. To help with this distinction, captures will be saved with the “.wpix_preview” extension.
Additionally, Preview builds will not be included in the search path for WinPixEventRuntime’s function PIXLoadLatestWinPixGpuCapturerLibrary. Users will have to update the function to look in the “Microsoft PIX Preview” folder if they want it to use the Preview build’s version of PIX on Windows.
Known Limitations
Enhanced Barriers:
Render Passes or Video work using Enhanced Barriers are not yet supported.
PIX’s Warnings Analysis does not yet support Enhanced Barriers.

New in Microsoft PIX 2208.10 (Aug 11, 2022)

New in Microsoft PIX 2206.20 (Jun 21, 2022)

New in Microsoft PIX 2205.24 (May 25, 2022)

PIX now runs natively on Arm64:
With Arm-based Windows devices becoming more popular, we’ve heard from developers that they needed a better solution for debugging and profiling their apps on Arm64 machines.
We listened: with PIX being an essential part of game development, we built an Arm64 version of PIX. From this release onwards, PIX will ship an Arm64 version, letting developers run PIX on Windows run natively on Arm64 devices.
Qualcomm plugin rounds out Arm64 support
Native Arm64 support is one piece of today’s announcement: we’re also proud to announce that we’re shipping a Qualcomm plugin along with this release. This means that developers can now expect a similar debugging and profiling experience to what they’re used to on x64 machines.
x64 on Arm64:
Since Windows 11 supports running x64 applications on Arm64 devices, it is possible to run both the x64 and Arm64 versions of PIX on an Arm64 device. Both versions of PIX come with the binaries necessary to take GPU Captures of the other architecture. However, in general we recommend using the Arm64 version of PIX on Arm64 devices, since it will be faster than the x64 version and it supports the Qualcomm plugin.
Known issues:
This version of PIX calls SetStablePowerState() before collecting timing information. This means that PIX generates consistent timing information, but on some GPUs (especially mobile GPUs like Qualcomm) the stable power state may have significantly lower performance characteristics than your application might experience outside PIX. This may result in PIX showing slower performance information. We are working with Qualcomm and other IHVs to fully address this issue in a future version of PIX.
Feedback:
As always, please let us know if you have feedback about this or any other release: We look at and respond to every message we get on discord.gg/directx. And every email from when you hit the Send Feedback button goes straight to the entire PIX on Windows team.
Other smaller changes:
Fix crash when using Shader Model 6.6 on AMD GPUs
Update to D3D12 Agility SDK version 1.602.0
Fix document tab flow + potential waste of screen real estate
Fix accidental truncation of some D3D12 flags when using Export to C++
Fix incorrect BlendOpAlpha values in the D3D State view

New in Microsoft PIX 2203.30 (Mar 31, 2022)

New in Microsoft PIX 2203.07 (Mar 16, 2022)

New in Microsoft PIX 2201.24 (Jan 26, 2022)

Graphing of consolidated PIX events in the Timing Capture metrics view:
It is common practice to name the PIX events that represent a frame of CPU work (or any other repeated set of work) with a sequential number pattern such as “Frame 123″, Frame 124”, “Frame 125” and so on. PIX will now look for events whose names follow this pattern and group, or consolidate, them. The individual events that fit the patterns will be treated as the same event in the Metrics View for purposes of graphing and analysis.
Critical path analysis for a PIX event:
Timing Captures now include a feature that analyzes the context switch data collected during a capture to compute the critical path for a selected PIX event. The critical path is the series of PIX events and dependencies that, if shortened, would reduce the overall duration of the selected event. The critical path for the event is display in a new lane that fills in the stalled time with information about which PIX events, threads, and cores were executing during that time, thus contributing to the stall.
Improvements, Bug Fixes and Optimizations:
New NVIDIA plugin with support for additional NVIDIA Ampere Architecture GPUs
Support for edit-and-continue of HLSL 2021 features
Fix capture/replay of heaps created with NON_RESIDENT flag
Fix shader breakpoints when #line directives are present
Fix potential A/V at capture time inside SetSamplePositions()
Fix CopyBufferRegion error with tiled resources, causing replay to take a very long time
Improve source analysis custom search path handling for Timing Captures
Add copy for File Details View
Fix 2108.18 regression: two HLSL files might show up when you start debugging
Fix capture/replay of heaps created with NON_RESIDENT flag
Add save option for mesh viewer, shader output viewer, texture viewer
Make root constants show up in shader debugger’s constant view
Fix error dialog width on larger-dpi-than-primary monitors
Fix WinPixEventRuntime bugs
Shader debugging: Move breakpoints to next executable line
Fix shader output selection in the mesh viewer
Fix false-positive Agility SDK mismatch warning on Windows 11
Allow edit/copy/paste of event path in GPU capture event list
Fixing crash in metrics view due to min/max display adjustment causing reentr…
Ensure GPU disasm isn’t selected by default when moving through event list
Optimize descriptor heap serialization for low memory devices (e.g. HoloLens)
Fix Thread Affinity query bug
Add IsLoading progress bar to ActiveMetrics panel to make loading state clearer
Active metrics panel should now clamp min/max display for a metric so min <=…
Enable spectre mitigations
Remove viewport change when timeline is resized unless below a threshold
Fix mesh-shader output viewer for cases with actual amplification
Acceleration structure viewer – Add coloring options
[Resource History] Add next state buttons
Remove legacy timing captures from pixtool
Improve formatting for loading text with large numbers
Mesh Viewer – Properly center the camera and fix continuous rendering
Pixel History – better support for _TYPELESS formats
Add a vertical scrollbar for the buffer viewer
Fix type cast warnings in programmatic capture API

New in Microsoft PIX 2108.18 (Aug 20, 2021)

New in Microsoft PIX 2107.08 (Aug 20, 2021)

New in Microsoft PIX 2107.01 (Jul 6, 2021)

This release is mostly about servicing, including fixing some regressions in 2104.20 that several users hit:
Shader PDBs not loading
Missing macro definitions in a shader’s Compile Options view (also causing problems with edit-and-continue)
Discovery of accesses within dynamically-indexed unbound descriptor ranges (as shown in the pipeline view)
That said, we have a few new “quality-of-life” features in this release:
Buffer viewer enhancements, including:
New “globals” buffer, allows you to define structures that are available to all buffers
Import/export of buffer formats
Better layout of formats list and buttons, and a splitter for size control
Buffer format editor is now available in Settings tab
Show display mode option for GPU Signal/Wait arrows in timeline view
GPU event list navigation improvements:
user-curated filter mask
event path explorer
search
GPU event list column statistics
Quick-navigate drop-down for the event list
Added theme colors for EventColor indexed colors
A new Dr PIX experiment to vary MaxCommandCount usage with timing data
A new warning about invalid root descriptors
New Storage Device Bandwidth Counters
Added support for debugging x64 applications on ARM64 devices
The Metrics View in PIX Timing Captures now includes bandwidth counters for each storage device.
These new counters make it easier to optimize file io patterns.
User-Curated Filter Masks:
You can now focus on subsets of the GPU event list by using “filter masks”. Filter masks allow you to select and hide large or small sections of the event list, allowing for much easier navigation between distant events. Note that masked events still contribute to the playback, so expect no changes to any resources or timings etc., with the exception of column statistics discussed below.
Column Statistics:
You can now view a few simple stats about counters shown in the event list. If we collect timing data for a trace and turn on column statistics (the new button highlighted in red here), the new statistics (highlighted in yellow) panel will appear.
Any filter or mask setting will affect which events contribute to the stats. The stats will only reflect the unmasked events, whenever the “Exclude masked events” button (blue) is active. Anything you can’t see does not contribute to the stats.
Note that Wait events tend to dominate the timing statistics, but filtering is an ideal mechanism for excluding those waits if you so choose.
Event List Searching:
In addition to the existing filter edit-box, a new search edit-box has been added that lets you cycle through matches to your search string without hiding any other events.
Event Path Explorer:
The event list is typically a tree of PIX events and GPU activity, and it can be hard to navigate quickly. (If your event list isn’t a tree of PIX events, learn how to make it one here.) There is now a drop-down explorer that will show up whenever the top level of the event list tree has a manageable number of entries (fewer than around 200). At first, only the one drop-down will show, from which you can select any top-level event or event category. If you select such a category, a drop-down for the next level of events will appear.
Bug Fixes:
Fix graph bar legend sometimes being empty
Fix crash when viewing Vertex Buffers at the IA stage
Handle signed-int mesh shader output in pipeline view visualizer
Add support for HLSL macro definitions without values
Fix sizes of array resources, clarify that sizes are only estimates
Fix error message when trying to view GS/tessellation shader output
Fix capture/replay of apps that use >=2GB default heap buffer
Several dark theme fixes
Fix regressions with:
-Shader PDB path discovery
-Missing macro definitions in shader’s Compile Options view
-Discovery of dynamically-accessed resources for unbound descriptor ranges
Fix occupancy graph when timeline changes
Perf optimization for DXIL/DXBC colorizer
Fix handling of UpdateTileMappings when given null region sizes
Fix off-by-one in buffer viewer
Fix leaking of temporary files

New in Microsoft PIX 2103.20 (Apr 21, 2021)

Capture/Replay with the Agility SDK:
Today at Game Stack Live, Microsoft announced the new DirectX 12 Agility SDK. With the Agility SDK, gamers and game developers have access to the latest and greatest DirectX features even sooner. This PIX release fully supports the Agility SDK and its features on all versions of Windows 10 that support the Agility SDK. That means you can take a GPU capture of any application that uses the Agility SDK and play it back in PIX.
HLSL Shader Model 6.6:
Today’s Agility SDK release introduces HLSL Shader Model 6.6. Shader Model 6.6 introduces the ability to directly index into descriptor heaps from shaders without a root descriptor table, which PIX fully supports. PIX can even tell you which resources you accessed dynamically in your shaders:
PIX also supports other Shader Model 6.6 features, such as 64-bit integer and limited bitwise floating-point atomic operations – read more about the Shader Model 6.6 spec here.
Slim PDBs:
This version of PIX on Windows also adds support for the new DXCompiler feature Slim PDBs. These optimized PDB files contain only the compiler version, shader sources, compile options, and defines, resulting in a 30% decrease in compile time vs -Zi and PDBs that are 89% smaller on average.
To enable shader debugging and viewing HLSL inline with GPU instructions, PIX has a new “Generate full PDB” option in the Shader “Commands” panel. This uses Edit-and-Continue to generate the lower level debug information needed from the source code and compilation flags stored in the slim PDB. While this does take some time depending on the shader, we suspect the 30% decrease in shader cook time and the drastic decrease in PDB size is well worth it. PIX will report if the current compiler shipped with PIX does not match the one used to generate the shader and the matching compiler can be supplied if desired.
Occupancy Graphs:
We’ve added new occupancy graphs to PIX on Windows based on High Frequency Counter data. These are our long-term replacement for PIX’s existing Occupancy graph, which is being deprecated for several technical reasons.
The new graphs have two main features:
A Wave Distribution graph, which helps understand how many waves (or what percentage of possible waves) are active at any given point in time. On some hardware, this graph is broken down into per-shader stage numbers.
Additional graphs to help understand what’s limiting your GPU’s occupancy at any given point in time.
Which counters are collected varies by GPU manufacturer. Right now, the new Occupancy Graphs are supported for NVIDIA and Intel, with support for more manufacturers coming in a future release. Many thanks to our IHV partners for making this possible!
Attaching to Live Processes:
Some users requested a way to launch their game through Visual Studio or another program, and then attach PIX to that live process to take a GPU capture. This is now possible – you can attach PIX on Windows to an existing live process and take a GPU capture if that process loaded the matching version of WinPixGpuCapturer.dll before creating its D3D12 device. Additional documentation can be found here.
Buffer Viewer:
We’ve added some new buffer viewer enhancements, including
New “globals” buffer, allows you to define structures that are available to all buffers
Import/Export of buffer formats
Better layout of formats list and buttons, and a splitter for size control
Buffer format editor is now available in Settings tab
Auto-generate buffer viewer formatting for structured buffers
Other changes:
Add button to reload symbols to Timing Captures
Fix UI hang when opening Timing Capture with very many PIX events
Timing Captures: Add UI option to truncate module names in stack trees
Timing Captures: Add option to clamp memory stack tree depth

New in Microsoft PIX 2103.16 (Mar 19, 2021)

Launch History:
PIX saves the launch configuration options for your 10 most recently launched applications, saving you time when switching between multiple games under development. Access your history using the “Recent…” button in the Select Target Process box. Launch history persists even if you close PIX and open it later.
History is also saved for UWP applications.
Environment Variables:
You can now set environment variables to include when launching your applications. Environment variables are also included in the recently launched history.
We also added the —setenv parameter to pixtool that lets you provide environment variables in the form “VARNAME=VARVALUE”. You can include multiple environment variables in one command ex. –setenv=”VAR1=VALUE1” –setenv=”VAR2=VALUE2”.
Multiple Cameras in the Mesh Viewer:
This release adds the ability to create multiple cameras in the mesh viewer. When viewing large TLASes it’s useful to setup several cameras in the world and quickly move between them. Type a camera name into the combo box and press Enter to create a new camera. Camera locations are not saved when the capture file is saved. The camera options in the mesh viewer are a work in progress, expect some more improvements here in a future release. If you have any feedback on this functionality, get in touch!
Other Changes:
Timing Captures: Added more data from the two Stack Tree node selections to the Element Details view, including the counts, percentages, unfreed sizes, top callers/callees by inclusive count, and a list of the contributing threads.
Fixed UI crash with shader tables whose ShaderRecordStrideInBytes=0.
Fix for ID3D12Resource::Map() failing with E_NOTIMPL under GPU Capture for placed resources in heaps created via OpenExistingHeapFromAddress(). ID3D12Resrouce::Map() now succeeds, but with no CPU write tracking. If you make CPU writes to one of these heaps, then replay may be incorrect.
On hybrid devices, ignore DXGI’s internal iGPU D3D11 device when capturing pure D3D11 app via 11On12, fixing programmatic GPU capture issues for Hololens 2.
Capture and log more OS version information during GPU capture, visible in the System Info pane.
Allow setting breakpoints in included HLSL file in shader debugging.
Added support for new D3D12 features, ID3D12Device9::CreateCommandQueue1 and the new Shader Cache APIs.
Fix Pixel History for tiled resources.
Fix TLAS build capture/replay issue on COMPUTE queues, if instance buffer was created in DIRECT-only state.
Add support for ID3DDestructionNotifier.
Fix capture/replay of apps that use POSTBUILD_INFO_CURRENT_SIZE in BuildRaytracingAccelerationStructure.
Fix some state object capture/replay issues with large state objects.

New in Microsoft PIX 2101.27 (Jan 28, 2021)

New in Microsoft PIX 2010.26 (Oct 28, 2020)

Timing Captures Command List Execution Views:
In this release, timing captures have been updated with better visualizations of Command List executions. An execution contains one or more Command Lists sent to the GPU via a call to ExecuteCommandLists. The GPU work performed by each Command List is rendered directly below each green Command List bar drawn on the timeline.
Selecting an Execution block on the timeline draws an arrow indicating where the corresponding ExecuteCommandLists() call was made on the CPU timeline.
Command List CPU Timeline View:
Selecting a range of executions will show you the start/end/durations in the Range Details view.
Command List Range Details View:
Future releases will contain more updates to this view, including showing GPU operations in each Command List in the Event Details view, and better indications of when work was issued on the CPU timeline. As with any new feature, we welcome your feedback and suggestions for future development!
Descriptor Heap Viewer:
We’ve added a new view to GPU captures, which shows the contents of descriptor heaps, and links them to the resources they represent:
Descriptor Heap Viewer:
You can access the Descriptor Heap viewer through the Views button in the top right of your PIX window. Once done, simply select a descriptor heap from the combo-box (all heaps accessed through the capture will be shown), and the viewer will display the heap’s contents as of the current event. The contents will also update as you navigate through the different events in your capture.
Descriptor Heap Index:
Additionally, the Root Signature in the State view now link Descriptor Heap Table members to their corresponding descriptor.
We’d like to give a big shout-out to Amogh Subhedar, as this was his intern project while working (remotely) on the PIX on Windows team this summer 😊
Extended Buffer Formatter Syntax:
The buffer viewer format syntax has been extended slightly to cover some cases that the existing “pad (n)” syntax can’t express. By default, constant buffer packing rules allow subsequent items to pack into leftover storage at the end of an array. “Pad” allows the user to express unused memory in between array elements, but not the fact that the last element’s trailing unused space might actually contain the next variable. Most of the time, this syntax is pre-populated for you based on shader reflection information, but if you wish to modify the format yourself, see the buffer viewer’s “Syntax Help” page for details.
Increased GPU Compatibility:
This release includes new plugins from both AMD and NVIDIA. NVIDIA’s plugin adds support for Ampere GPUs, including the RTX 3080. AMD’s plugin includes a backwards compatible change to accommodate future driver changes. Many thanks to our IHV partners for their continued updates.
Other Improvements:
You can now view structures that have nested structures within them in table mode in the buffer viewer.
Added an option to display memory size values in the Allocation Stack Tree Timing Captures in either in KiB or MiB.
Removed the event count limit for Allocation Stack Tree in Timing Captures. The Allocation Stack Tree for large captures can now be displayed.
Pixel history is now available for all bindings except depth bindings.
Add confirmation dialog when you select Pixel Cost in Visualization mode. Pixel Cost requires counter data collection which can take some time, the added popup should prevent accidental selection.
Add support for mesh shader visualizers.
Support SetPrivateData(WKPDID_D3DDebugObjectName) with a nullptr name.
Sampler Feedback resources now show up properly in the API Object table.
Sampler Feedback resources are now determined by DXGI Format instead of a non-zero MIP Region.
ResourceMinLODClamp is now displayed inside Texture Properties of the
Pipeline View.
You can now copy/paste shader debugging call stack text.
Bugfixes:
Fixed an issue in which callstacks in Timing captures were showing incorrect frames, especially when processing the PDBs for Windows system binaries.
The label for the Readied Time value in the Element Details view of PIX Timing Captures included both “ns” and “ms” when a context switch was selected. The duplicate unit has now been removed. The label is now “ms”.
Pixel history view no longer scrolls to the bottom when first created.
Fixed an issue where after running 3 consecutive samples that include mesh shaders the debugger would forget to update stale shaders.
Improved remote deploy scenarios for ARM64.
Gracefully handle zero-sized vertex buffer in the IA output viewer
Fix heap corruption when using D3D12_SHADER_VISIBILITY_MESH/_AMPLIFICATION
Remove erroneous warning message declaring the app will terminate when a capture is opened. This behavior changed in the 2008.26 PIX on Windows release, but the error message was not updated at the time.
Fix misc issues capturing/replaying acceleration structures in placed resources
Fix issue capturing descriptor heaps that contain stale acceleration structure descriptors

New in Microsoft PIX 2007.29 (Jul 30, 2020)

New in Microsoft PIX 2006.26 (Jul 6, 2020)

Fence Signal-Wait arrows for GPU captures:
GPU captures now track and visualize fence signals and waits to help you understand synchronization issues. You can also use this feature to spot opportunities for async compute work, by finding work on the graphics queue that can’t overlap with any async compute work due to signals/wait patterns.
Buffer Viewer & Memory Viewer:
This release adds several improvements to the buffer viewer and memory viewer, including:
Support for int32_t and int64_t in buffer viewer format syntax.
Added option to display integer values with comma separation in the buffer viewer and memory viewer.
Display integer values with comma separation in the buffer viewer and memory viewer:
Added Table view to memory viewer.
Support for Home and End keys in the buffer viewer.
Added a syntax help window.
Syntax Help in the Buffer Formatter:
Fixed a crash during rendering if no structure type has been provided in the buffer formatter.
Improved performance for large buffers in tree mode.
Document Tabs:
This release adds a “Close all captures but this” option to the document tabs menu.
Right click the document tab to show the document tab menu
Additionally, a confirmation dialog popup will now appear when closing documents to prevent accidentally closing captures.
API Objects Table:
This release adds sorting to the API Objects table in the pipeline view. Additionally in this view, column widths now persist.
Timing Captures:
Improve rendering of small bricks in timing captures — when too small to warrant (side) borders, don’t draw them. This allows the stronger color of the bricks themselves to show through, instead of just the (barely visible) border color when events are densely packed.
Add support for reporting the process name when other threads are viewed during analysis.
Adds support for looking up, decoding and displaying operation start stacks.
Improve performance for building the stack tree and function list
Support extracting memory events from new timing captures when selecting a subsection to save out to a smaller capture.
Usability improvements for memory analysis.
We’ve made several fit-and-finish usability improvements to make analyzing memory captures more intuitive and effective.
Other Improvements:
Removed sysmon timing captures.
Added copy support in message dialog.
Improve handling of engine crashes. Now, on engine crash the user is presented with the opportunity to save before any temporary files are deleted.
Added an early preview of Dark Theme. Report any bugs or feedback using the Send Feedback button in PIX.
Bugfixes:
Fixed issue where timing captures would crash if the command queue was not found while processing GPU timing data.
Fixed issue where the ‘Flags’ field for a BuildRaytracingAccelerationStructure would show numbers instead of definitions.
Fix GPU timing data for ExecuteCommandLists when commandlist operations get reordered by the driver.
Fixed issue with inaccurate shader access tracking for adjacent finite-sized uav arrays.
Fixed “Unspecified Error” when debugging shaders caused by undetected instrumentation overrun.
Fixed a crash when starting analysis on an HLK test.
Fixed issue where timing data would be incorrect for the first event in a queue when work is submitted on two queues and one is not dependent on the other.
Fix missing events caused by overlapping command lists in timing captures.
Fixed a crash when using shaders with some amount of call depth when optimizations are disabled.

New in Microsoft PIX 2004.27 (May 5, 2020)

Improved struct support in the Buffer Viewer:
The format specification syntax used in the buffer viewer has been enhanced. It now supports true nesting of structures, as well as arrays. With these additions, the default format descriptions of constant buffers (for example) that contain arrays or nested structures are no longer “unrolled” into lengthy, repetitive descriptions.
To display such structures in the buffer viewer, the default display mode is now “tree” form. This mode is similar to the locals/watch windows in Visual Studio, where structures and arrays are shown as parent nodes, with their members/elements as children, and so on. Here’s an example:
Tree mode is required in order to display the arbitrarily complex structures that can be defined with the new syntax. However, if the structure is simple and can be displayed in tabular form, that option is still available using the “Table/Tree” toggle button. Here’s the result:
Other enhancements to the syntax include:
A new syntax for specifying padding, which is simply ‘pad n;’ where n = number of bytes.
Bitfield specification, which allows extraction of bit-packed values. For example, you might have a DWORD value that has a set of flags in the high bits and a count in the remaining bits. You could describe this with the following format:
struct
int count:29;
int flagA:1;
int flagB:1;
int flagC:1;
There is also a new “offset” value that you can specify as the start point for the buffer viewer to begin visualizing data. This is a byte-offset from the beginning of the actual buffer data selected in the pipeline view.
pixtool programmatic-capture --until-exit
New in pixtool this release is the --until-exit flag on programmatic-capture. Using this flag will cause pixtool to handle all the programmatic captures until the app exits. This may be useful to users who want to automate grabbing an unknown number of captures.
CPU Memory allocation data in Timing Captures
Timing Captures now include options to record information on the CPU memory allocations and frees made while the capture is running. This memory data is used to build an allocation stack tree focused on helping identify memory leaks.
File IO data in Timing Captures:
Timing Captures now include the option to collect data on file accesses made by your title using the Win32 APIs. PIX uses this data to display when each file i/o operation occurred, how long it took, how many bytes were read, and so on. Callstacks for each file access are displayed as well.
Other Changes:
Updated to the latest AMD Plugin which enables the following:
Support for upcoming AMD APU’s
Support for the upcoming 20.10 AMD driver in support of the Windows 10 May 2020 Update
Occupancy fixes
Full support for Sampler Feedback, including:
Added support for Sampler Feedback maps in Pixel History.
MIN_MIP feedback maps are now displayed correctly when accessing only one mip level.
Fixed issues when replaying MIN_MIP Sampler Feedback maps that would either cause StartAnalysis to fail or the feedback map to be in the incorrect resource state.
Fixed issues resolving MIP_REGION_USED feedback maps that had a full mip chain.
New Timing Capture Improvements
Minor performance improvements when opening new timing captures.
Update support for real-time sessions to dynamically choose the best ETW configuration.
Fixed issue where the end timestamp would sporadically occur before the start timestamp.
Apps containing old-style PIX events from <pix.h> will now capture successfully, but the events themselves will not appear in PIX.
Fixed issue where breakpoints wouldn’t bind when shaders mixed “” and “/” when specifying include paths.
Added support for Ctrl + Tab to switch between documents.
Middle-clicking on a tab will now close it.
Fixed timing data collection for DispatchRays inside ExecuteIndirect.
Improved performance of d3d state view when large numbers of descriptors are bound.
Fixed issue where the VSOutput table format could be incorrectly ordered and only displayed floats.
Updated all help links to point to devblogs.microsoft.com/pix instead of blogs.msdn.com/pix.

New in Microsoft PIX 2003.26 (Mar 28, 2020)

General:
Fix crash when there’s an empty PIXOptions node in the settings XML file
Output View: put the category combobox and the clear button in the top tool bar
Fix crash with old timing captures when the process exits before the capture starts
New Timing Captures:
Optimize handling of GPU API markers
Ensure capture directory created when starting capture
Improved error reporting when user does not have permission to start ETW logging
Improve UI performance when selecting a PIX event with a large number of stalls
Fix memory leak
Add support for capturing more than 255 cores
Fix stacks for fastlink pdb files
Add prompt to cancel symbols for save
Thread names now properly appear when a capture is taken for a title that was launched suspended.
GPU Captures:
Add support for ID3D12Device1::SetEventOnMultipleFenceCompletion
Fix crash due to invalid/missing timing data being reported
Updated formatter table with new DXGI formats added in Vibranium
Correctly handle D3D12_HIT_GROUP_DESCs whose constituent shaders are all NULL
Detect underflowed timing values and clamp to 0 This prevents the timeline from getting blown out to ulong.MaxValue visible time, which is less than useful.
Wait until document load is complete before setting enabling edit & continue
Texture Viewer: Reword multisample to sample count
Fix include path issues for shader edit & continue
High Frequency Counters: fix issue dropping samples when first EoP time equals BeginSubmission time
Fix various issues with VRS
Fix race conditions with Mesh Viewer
DXIL Shader debugging: various fixes involving inf/nans
Shader intellisense updates (highlighting, tooltips)
DXIL register formats: display integer (decimal) and hex when requested.
DXIL shader debugging: NRE possible if user passes a macro with embedded spaces but no surrounding quotes
Fix shader edit & continue: older compilers can use /D, and need to strip -Qstrip_debug
Fix open command list tracking when command lists are destroyed
Update to latest AMD plugin:
fix start analysis failure when using remote desktop
fix Invalid Counter Generation Error on Unsupported R9 290
fix collecting occupancy when there are PIX events around Present()
Update to latest NVIDIA plugin
Fix crash in shader access tracking in a trace containing a TDR
Skip capture of ID3D12CompatibilityQueue’s methods rather than fail capture
Add support for new D3D12_RESOURCE_STATEs
Wave Tracing: allow plugin to return waves associated with EventID = -1
Fix capture/replay support for apps using Shader Model 6_4+
Fix capture/replay of reserved non-power-of-two BC textures
DXR: Show BLAS build buffers (vertices, indices etc) in the Pipeline View
Added notification to PIX that the GPU disassembly may have changed after collecting counters for a GPU capture.
Switch to new GPU timeline
High Frequency Counters: enable perf optimization in NVIDIA plugin when possible
Minimal support for out-of-proc shared heaps+resources
Tiled Resources: Fix capture/replay of a tiled texture that’s mapped into a heap after another texture’s weirdly-sized packed mips
Mesh Viewer + PC Acceleration Structure Viewer: add checkbox to flip horizontally
Expression filtering fixes; nicknaming
Better column expression type defaults, and fix nicknaming when counter set (provider) changes
Resource Tracking: correctly handle SetRootSignature() call with root sig that’s already set on the command list
Show missing PDB names
Make missing PDB path copyable
Replace non-identifier characters in shader type names with underscores
Make “unsupported API” dialog say sensible things
Add new Object Name column for GPU Resource View
Fix crash when <del> is pressed in empty buffer formatter box
Fix capture of apps explicitly setting null global root signature in their DXR state objects
DXR Tier 1.1: Finish AddToStateObject support, + add basic inline raytracing support
Fix support for ResizeBuffers1

New in Microsoft PIX 1909.23 (Sep 24, 2019)

New in Microsoft PIX 1908.16 (Aug 23, 2019)

New in Microsoft PIX 1906.26 (Jul 1, 2019)

New in Microsoft PIX 1904.23 (Apr 25, 2019)

New in Microsoft PIX 1903.12 (Mar 14, 2019)

New in Microsoft PIX 1807.19 (Jul 25, 2018)

New in Microsoft PIX 1806.20 (Jun 26, 2018)

New in Microsoft PIX 1806.11 (Jun 13, 2018)

New in Microsoft PIX 1803.25 (Mar 28, 2018)

GPU Occupancy provides detailed insight into how shader workloads execute on the GPU. As announced at GDC we have collaborated with NVIDIA to bring console-level performance details about how shaders execute on the hardware to PIX on Windows. Many thanks to our partners at NVIDIA for helping us enable this great feature in PIX on Windows.
While the Execution Duration timeline lane shows the total execution time for draws and other rendering operations, the new Occupancy lane shows the associated work as it moves through the GPU’s rendering pipeline. You’ll see how work is broken into vertex shader work, pixel shader work, and so forth giving you a much more accurate view of how the hardware handles your rendering.
The Occupancy lane shows VS, HS, DS, GS, PS, and CS work corresponding to the different pipeline stages as well as a stage labeled Internal which allows GPU vendors to account for work that doesn’t map to any of the conventional pipeline stages.
To collect GPU occupancy data you have to Collect Timing Data first. Once the timing data is available, click the Enable button in the Occupancy lane to collect the data and populate the view.
This feature is currently only available on NVIDIA GPUs and it requires an updated driver. Please make sure to get version 391.35 or later to use this feature.
We’re working on surfacing this information for other GPUs as well, so stay tuned for updates.
Timing Captures now include an option to collect and analyze CPU samples.
PIX now includes a CPU sampling profiler that can optionally be run when taking a timing capture. Viewing CPU samples is useful for determining what code is running on a thread or core for portions of your title that either have been sparsely instrumented with PIX events or not instrumented at all. The integration of samples into timing captures improves the iteration time of your profiling tasks because you can now get a sense of what code is executing at any point in time without having to go back and add additional instrumentation to your title.
Timing captures now include the ability to visualize the execution times of individual functions in your title.
Timing captures now allow you to track the execution of your title’s functions. You can select which functions to track by viewing callstacks for samples, by analyzing an aggregate view of the samples, or by selecting functions from your title’s PDBs. Each call to the functions you track is displayed on an additional lane per thread (or core) in the capture. As with the ability to collect CPU samples, the ability to track functions improves your iteration time by drastically reducing the need to add instrumentation to your title, rebuild, and redeploy.
Automatic shader PDB resolution. We’ve improved how PIX resolves shader debug information (shader PDBs) and described the process for how you can set up your build system to support this. For more information see the documentation for this feature.
Your build system can use a suggested, unique name for each shader’s PDB data, and can then strip and store the debug information in a dedicated file. If you follow this process PIX can automatically discover and resolve your shader PDBs and thus provide much better support for inspecting, editing, and debugging shaders.
The GPU Memory Usage tab in timing captures now tracks Pipeline States, Command Allocators, and Descriptor Heaps as well.
Improved TDR debugging support.
We have fixed issues for titles using ExecuteIndirect.
Improvements to Pipeline view and resource history.
The Pipeline view is now much faster to use. PIX tracks resource access for the entire capture the first time you access the Pipeline or Resource History views. Once this is done these views update near-instantaneously when selecting a new event.
Resource history now accurately reflects which bound resources were accessed by shaders.
Shader access tracking now also supports DXIL shaders.
The Shader Debugger now supports debugging of geometry shaders.
Support for buffered IO in the File IO profiler
The file IO profiler now displays file accesses from your title even if they’ve been satisfied by the Windows disk cache. A new IO Event Type column in the event list lets you choose between viewing buffered events, non-buffered events or both.
DirectX Raytracing (DXR) support. This release also adds enhancements to the support for the new experimental DXR features we released to support the recent GDC announcement. Please make sure to check the dedicated release note and documentation for details. New features in this release:
You can now view samplers for DispatchRays calls.
Fixed global root parameters for DispatchRays calls when a graphics PSO is bound.
Fixed several bugs. Thanks to all of you out there who reported issues!

New in Microsoft PIX 1803.16 Experimental (Mar 19, 2018)

New in Microsoft PIX 1711.28 (Nov 30, 2017)

Timing captures now track GPU memory usage, and PIX can show how heaps and resources are created and managed with respect to the underlying GPU memory. This can be used to understand and optimize heap residency and troubleshoot performance issues caused by paging between local and non-local GPU memory. Note that PIX currently only tracks memory used by D3D12 heaps. Other types of GPU allocation (such as command allocators, pipeline state objects, and descriptor heaps) are on our backlog for a future release.
Experimental TDR debugging feature allows frames that cause a TDR to be captured, analyzed, and debugged using PIX GPU captures. Note that in order to take a GPU capture for debugging a TDR, you must be able to reproduce the TDR while a GPU capture is in progress. If the TDR is caused by a race condition or other rare, hard to repro problem, it may not be possible to capture it using PIX. Due to incompatibilities with current drivers, before using PIX to debug a TDR we recommend opening Settings and: unchecking Enable GPU Plugins, checking Disable PIX HUD in applications running under GPU capture
PIX now supports full shader debugging for DXIL (shader model 6.0). The only PIX feature still not enabled when using DXIL shaders is access tracking for bindless resources, which will be coming in a future update.
Child process GPU capture allows launching one process from PIX, which launches another, then taking a GPU capture from the child. This enables use of PIX with games that start up via a separate launcher executable or batch file. Note that PIX does not yet handle the case where both parent and child process render using D3D12 at the same time. We do not yet support 32 bit launchers, such as the Steam client.
File IO captures now let you specify a mapping file that describes the location and size of individual assets within archive files (such as ZIP or PAK files). PIX uses your mapping data to identify the individual asset for all reads within archives.
The Pipeline UI and access tracking for bindless resources are now much faster.
Tweaked behavior of the Pipeline UI to show all bound resources that are not part of large ranges, rather than only the ones that were accessed. The filtering that skips showing unused resources now only applies when a title is actually using bindless.
PC Connection Details and GPU capture File Details now display correct adapter information when PIX is run on a system with multiple GPUs.
Bugfixes.

New in Microsoft PIX 1709.18.004 Beta (Sep 20, 2017)

New in Microsoft PIX 1707.25 Beta (Jul 27, 2017)

New in Microsoft PIX 1706.25.002 Beta (Jun 28, 2017)

New in Microsoft PIX 1705.17 Beta (May 18, 2017)

New in Microsoft PIX 1705.16 Beta (May 17, 2017)

New in Microsoft PIX 1704.27 Beta (Apr 27, 2017)

New in Microsoft PIX 1704.14 Beta (Apr 18, 2017)

New in Microsoft PIX 1703.20.002 Beta (Mar 22, 2017)

New in Microsoft PIX 1702.23.002 Beta (Feb 24, 2017)

New in Microsoft PIX 1701.26 Beta (Jan 27, 2017)

New in this release:
All GPU counter values are now rolled up from individual draw calls to their parent marker regions, so you can easily see eg. how many PS Invocations were carried out within a region. Previously we only rolled up time data, but not other types of counter. Note we do not yet roll up counters other than time to ExecuteBundle or ExecuteIndirect calls (that’s on our list for later).
Timing captures now display thread names rather than just ID numbers. By default the thread name is taken from the root of the threadproc callstack. If you are running a recent Insiders build of Windows 10 Creators Update, aka RS2, you can also use the SetThreadDescription API to explicitly name your threads.
GPU capture crash resilience means that even if a game crashes during capture, we are still able to extract a .pix3 file containing all the events up to the point of the crash.
Better high DPI support in the PIX UI. This now automatically adjusts to match your monitor DPI, and the scale can be adjusted in Settings or using Ctrl+Alt+Wheel:
The WinPixEventRuntime instrumentation DLL can now load on Windows 7. PIX itself does not support Win7, but this can be useful if you have a game that supports both D3D11 and D3D12 rendering backends, and want to instrument it for use with PIX on Win10 while still being able to run the same binaries on older operating systems. Note that to load on Win7, WinPixEventRuntime has two dependencies:
Update for Universal C Runtime in Windows (this will be installed by default as long as the Win7 machine is current on Windows Updates)
Visual Studio 2015 C++ redist (this is chained from the PIX installer, and of course will already be there if you installed VS 2015 and/or your game is built with that compiler)
GPU capture changes:
Fixed a number of bugs in the Pipeline view.
Fixed a crash that could occur when capturing tiled textures with dimensions that aren’t whole multiples of the tile size, or which use MSAA.
Fixed issue due to stripping out the DENY_SHADER_RESOURCE flag during capture, but accidentally also returning this modified flag from ID3D12Resource::GetDesc, which could cause games to go down incorrect codepaths when running under GPU capture.
Fixed bug in capture of ExecuteIndirect argument buffers (we weren’t capturing buffer resources if they were only used by an ExecuteIndirect call, but not otherwise bound to the pipeline in any way).
Improved performance for games that use very large but not unbounded descriptor ranges. We now display descriptor ranges with more than 256 elements as a range rather than individual entries (an optimization that was previously only applied to unbounded descriptor ranges).
We now include resources in the Resource Table even if they were not actually bound to the pipeline at any point during the frame that was captured.
Fixed false positive warning where Run Debug Layer could erroneously complain about calls to Map, which actually came from PIX rather than the game itself.
Increased the maximum BufferFormatComplexityLimit setting from 128 to 256 (in PIX Settings).