Version v1.3

Version v1.3

Here we have a new stable version of RenderDoc! In this release primarily we have bugfixes and improvements to general quality-of-life, as well as incremental improved API support.

Thank you to everyone who took the survey with the previous release. You can read the write-up and analysed results of the survey over here. One thing to highlight - there was enough support that there is now a RenderDoc discord server for those who prefer discord to IRC.

As always binaries for this release are up on the downloads page for Windows as zip and installers, and x64 Linux as a binary tarball.

Enjoy, everyone!

Main highlights

• Add support for YUV/YCbCr textures on all APIs that support them natively. The texture viewer by default will show the raw pixel values, but can be switched to a mode that does a packing-aware default YCbCr decode.

  
  
  

  This also supports video decoding APIs on D3D11 which are the basis of higher level frameworks such as MediaFoundation.

• On OpenGL there are no longer any required extensions for replay, all remaining required extensions are emulated when needed. As long as an implementation supports OpenGL 3.2 or OpenGL ES 3.0 it should be able to replay - though with reduced functionality in some cases if extensions like compute shaders are missing.

  This is a step towards proper support of GL on macOS, which is not included with this release but is being developed.

• Added a one-click button to load the last run capture session which persists from run to run. This is in addition to the existing functionality to save and load capture settings to disk in a config file.

  

• OpenGL persistent buffer mapping has been refactored to behave more like Vulkan. Persistent buffer maps that are writeable will always have GL_READ added to their parameters, and the direct mapped memory will be returned to the application instead of a shadow buffer.

  This then means that there is minimal overhead while RenderDoc is idle in the background, and you only pay the cost of checking persistent buffer maps while actively capturing a frame (which will still be quite slow). Note that explicit flush buffer maps will still be vastly more performant in RenderDoc during capture.

• On vulkan shaders accessing descriptor arrays will have dynamic GPU feedback fetched to determine which particular indices are used, and only these array indices will be shown in the pipeline state view and the texture viewer thumbnails.

  
  

  Together with this, VK_EXT_descriptor_indexing is now supported.

Python breaking changes

Aside from some compatible changes adding new functionality and data, there are a few minor breaking or incompatible changes in the Python APIs:

• ResourceFormat no longer contains data members bgraOrder or srgbCorrected. These have been changed to functions BGRAOrder() and SRGBCorrected() along with setBGRAOrder() and setSRGBCorrected().
• firstSlice has been removed from GLPipeTexture, it is always considered 0.
• The ShaderRegister structure has been dropped, ShaderConstant now simply contains a byte offset instead of a legacy register/component location.
• VarType.Int has been renamed to VarType.SInt.

Features/Improvements

• Detect and suppress drawcalls on GL that have invalid vertex state and are likely to crash in the driver. The primary cause of this is deleting vertex buffers bound to a VAO before the draw.
• Android logging is now fetched and merged into the main PC logfile to aid in debugging issues without needing to run adb logcat separately.
• Skip installation of VS CRT if we detect it's already installed, since it likes to prompt for reboots. The RenderDoc installer should never need a reboot.
• Optimise some UI behaviour when large numbers or arrays of resources are bound to the pipeline.
• Optimise D3D12 replay to skip mapped buffer updates when serialising if we've cached the contents of the map update.
• Optimise D3D12 pipeline state view to skip work when many resources are bound but hidden (due to being unused or empty).
• The 'Mesh Output' panel has been renamed to the more accurate 'Mesh View' since it also shows inputs.
• For certain specific GL extension functions, check for their presence when replaying and abort replay if they aren't found. This isn't feasible to do in general for all GL functions, but there are some specific ones such as glFramebufferTexture2DMultisampleEXT and glFramebufferTextureMultiviewOVR which indicate replaying an Android capture on PC where it's not supported. The user must have clicked through a warning saying that this may not work but we shouldn't crash if at all possible.
• Culling mode affects other overlays such as depth/stencil failure (this is a revert of a change to have culling not affect other overlays in v1.2). This means a culling failure can show up as a 'false positive' depth/stencil failure.
• When opening the file browser on a remote host to select an application, and an application has already been selected, start at its location instead of the home folder.
• Allow nested structs and arrays-of-structs in buffer format specifier.
• When opening the find/replace dialog in a shader viewer, select the text in the popup so you can easily replace by typing or pasting.
• Custom display shaders can now be used in the image viewer mode when loading a single image file from disk.
• Partial OpenSharedHandle support in D3D12 for shared resources.
• Implement ID3D11Multithread interface for automatic locking.
• When launching a program the connection window will now be docked with the capture dialog if it's visible, instead of on the main dock area.
• Add support for GL_EXT_buffer_storage on OpenGL ES.
• Added support for global uniforms in SPIR-V and textures without explicit bindings, for the sake of OpenGL.
• With future validation layers any Vulkan objects referenced in captured debug messages will be replaced with resource links.
• Added support for wglShareLists, but only before wglMakeCurrent has been called.
• Added a new RenderDoc API function DiscardFrameCapture which will discard a frame capture currently in progress without saving it to disk, useful if you speculatively start a frame capture then later decide it is not needed and wish to skip the expense of ending the capture and saving it to disk only to delete the file.
• Add a warning when launching a new app to capture on Android if a capturing app is already running.
• A number of improvements to structured data, including better type names for flag/flagbits enums, fixed stringification for bitfield enums with duplicate bit values, and more.
• renderdoccmd is now a 'console' type program on windows, meaning its stdin/stdout handling is as expected for a command-line utility.
• Add an uncompressed thumbnail into .rdc capture files.
• Add support for displaying MSAA array textures on OpenGL and Vulkan.
• Add glBufferStorageEXT alias of glBufferStorage on OpenGL ES.
• The texture viewer interprets images based on the type from a current Vulkan image view instead of always using the underlying image type. This is similar to TYPELESS texture behaviour on D3D.
• Support using EGL with desktop GL.
• Try to handle applications that set GL_BASE_LEVEL and GL_MAX_LEVEL dynamically on textures. Not all possible uses of these will work, but as long as GL_MAX_LEVEL is set to the actual maximum mip level at the start of the frame, changes to it within the frame will be correctly handled (e.g. for mip-generation rendering from one mip to another).
• Clamp D3D12 pipeline state view descriptor arrays to the declared array sizes in the shader. This can be a lot smaller when the array declared in the root signature is unbounded.
• Update GPUPerfAPI to 3.3.
• On D3D12 and Vulkan start 'frame 0' captures immediately when the API is initialised, instead of waiting for swapchain creation. This is feasible because unlike D3D11 and OpenGL it is not expected that the API will be initialised many times for enumeration/bootstrapping reasons.
• Block DXGI requests for unsupported DWM interfaces IDXGIFactoryDWM and IDXGIFactoryDWM8.
• Explicitly skip system builtin inputs on GL even if driver reflection returns them.
• Add support for Intel GL performance counters on mesa.
• Add an option to make Y-Flipping a per-texture state instead of a global toggle. By default this is off but can be enabled in the settings window.
• On OpenGL the GREMEDY debug extensions are reported as supported even if the driver doesn't, so applications can call them.
• Add a qrenderdoc command-line parameter --replayhost to select a replay host at startup.
• Add an option in a connection window to save all selected captures at once to a directory, which will take the selected filename and append -frameXX to each.
• Add support for EGL_EXT/KHR_swap_buffers_with_damage.
• When selecting drawcalls try to preserve the current offset in a raw buffer viewer as much as possible.
• Implement support for D3D12.3/D3D12.4 interfaces.
• Don't use GPUCounter i...

Version v1.2

Version v1.2

Time again for a new stable version of RenderDoc. This release includes a number of useful quality-of-life improvements as well as improved API support and of course plenty of bugfixes.

NOTE: The RGP integration added in v1.1 is now opt-in, to enable it go to Core in the settings menu and select to enable it, next to where the RGP executable is entered. This option takes effect the next time you load a capture.

As always binaries for this release are up on the downloads page for Windows and x64 Linux as a binary tarball.

Also separately RenderDoc is now available on Nintendo Switch™ to authorized developers, distributed as part of the NintendoSDK! For more information, consult the Nintendo Developer Portal.

Survey

A couple of years ago way back in September 2016 I ran a survey to get an idea of what the user-base was interested in both currently and for future support. Two years later I'd like to see how things have changed, so please go if you have 5-10 minutes to spare please fill in the new survey.

Thanks!

Main highlights

• Shader edit & replace tooling has been significantly improved. Instead of each API either expecting HLSL or GLSL shaders to compile internally, APIs can accept the underlying bytecode (DXBC, SPIR-V) where supported. This means the compilation can happen in a custom fashion in the UI.

  Similarly decompilation from bytecode to high-level source (if the original source is not available) is fully customisable. RenderDoc ships with a number of default programs for handling SPIR-V, and they are autoconfigured either from system installs or from the shipped tool. You can add more custom tools in the options menu:
  
  When editing a shader, if multiple tools can decode the bytecode they will be available as a drop-down. Original source will be the preferred default item if the button is clicked, otherwise the first tool available will be used:
  
  Then if the shader debug information has compilation settings they will be pre-populated and the appropriate compilation tool can be selected:
  

• Implement geometry/tessellation output on Vulkan. This is only available on drivers that implement the VK_EXT_transform_feedback extension, there are no plans to expand it to other drivers without that extension.
  
  

• Added persistent python extensions. The existing python API grants access to all functionality that the UI provides, which means extensive customisability is possible. A system has now been added to allow users to have persistent extensions that are loaded at UI start-up by default without having to be explicitly run.

  Extensions can also add menu callbacks to the main menu as well as several of the common panels (buffer viewer, event browser, texture viewer) to add custom tools.
  

  Extensions are loaded as python modules in the user settings directory (either %APPDATA%\qrenderdoc\extensions on windows or ~/.local/share/qrenderdoc/extensions on Linux) and must be loaded explicitly after installation. After that the python script is loaded at UI startup and can register its callbacks as desired. The python modules are also available in the existing python shell panel via a normal import.
  

• Save expanded tree views in API inspector, constant buffer previewer and resource inspector, so that tree views stay expanded between items instead of completely collapsing.
  

Python changes

Aside from some compatible changes adding new functionality and data, there are a few minor breaking or incompatible changes in the Python APIs:

• ReplayOutput.BuildTargetShader now takes a bytes instead of a str for the source and a ShaderEncoding listing what the encoding of the source is, which may not be text.
• TargetControl.ReceiveMessage now takes a progress callback which may be None.
• PipeState.HasAlignedPostVSData now takes a MeshDataStage parameter as the alignment may vary by stage.
• The SaveCallback function expected by qrenderdoc.CaptureContext.EditShader now has a different signature, that takes the ShaderStage being edited as well as the ShaderEncoding of the input files and ShaderCompileFlags used to compile the shader originally.
• KnownSPIRVTool is now KnownShaderTool, and SPIRVDisassembler is replaced by ShaderProcessingTool.
• CaptureContext.CreateWindowingData takes a QWidget instead of an int window ID, and must be called on the main thread.
• CaptureOptions.verifyMapWrites is renamed to CaptureOptions.verifyBufferAccess.
• GetDefaultCaptureOptions now returns the CaptureOptions struct directly.

Features/Improvements

• Use a natural sort for resource names in resource inspector.
• Remap index buffer on Vulkan when calculating vertex output data. This allows indices that are very sparse and wide to not over-allocate space.
• Generate a reasonable buffer format string when opening raw buffer viewers based on the context where they're opened. E.g for vertex buffers it enumerates the types of all attributes referencing the buffer.
• Improve heat-map display for quad overdraw and triangle size overlays. In addition to now being saved to disk as grayscale images, the picked values for triangle size are precisely accurate instead of being rounded to the nearest heatmap bucket.
• Support display of MSAA textures over remote replay (primarily relevant for android).
• Initialise adb on a thread since the first invocation can be quite slow, and we don't want to delay program startup.
• When showing shader output value in pixel history, show all 4 components even if the output texture doesn't have 3 components.
• Add support for Oculus VR end of frame markers in Vulkan.
• In previous RenderDoc versions, for GL & D3D11 buffers that are created with 'undefined' initial contents were filled with a marker value like 0xfefefefe or 0xdddddddd. This behaviour is no longer the default, it is now enabled with the 'Verify buffer access' capture option (previously 'Verify Map() writes').
• Implement MSAA <-> 2D Array copies on D3D12. Used primarily for saving multisampled images to disk, but also useful for remote replaying D3D12 captures.
• Indirect calls on Vulkan now have their arguments read immediately next to the call (either immediately before for dispatches, or immediately after the renderpass for draws), instead of on the CPU. This ensure that even if the arguments are filled on the GPU the correct arguments are read back.
• Make sure that internal resources created don't show up in captures with 'Ref All Resources' enabled.
• Add a reminder message on the crash reporting dialog if the user has an old version installed.
• Handle callstack resolution on windows even if DIA COM dll isn't registered, as is the case on VS2017 and up.
• Add initialisation chunk markers to many missing GL functions, so they show up properly in the resource inspector.
• Update RGA to 2.0.1 backend and add support for gfx900/gfx902.
• Update GPUPerfAPI to 3.2.
• Add support for ARB variants of glUniform functions.
• Add support for GLVND with split libGLX/libOpenGL libraries.
• Add support for OpenGL external objects/memory extensions.
• Add support for a number of Vulkan extensions:
  • VK_AMD_gpu_shader_int16
  • VK_AMD_image_load_store_lod
  • VK_AMD_mixed_attachment_samples
  • VK_AMD_shader_core_properties
  • VK_AMD_shader_fragment_mask
  • VK_AMD_texture_gather_bias_lod
  • VK_EXT_astc_decode_mode
  • VK_EXT_external_memory_dma_buf
  • VK_EXT_pci_bus_info
  • VK_EXT_post_depth_coverage
  • VK_EXT_queue_family_foreign
  • VK_EXT_swapchain_colorspace
  • VK_EXT_transform_feedback
  • VK_EXT_validation_cache
  • VK_GOOGLE_decorate_string
  • VK_GOOGLE_hlsl_functionality1
  • VK_KHR_8bit_storage
  • VK_KHR_create_renderpass2
  • VK_KHR_draw_indirect_count
  • VK_KHR_driver_properties
  • VK_KHR_get_display_properties2
  • VK_KHR_incremental_present
  • VK_KHR_shader_atomic_int64
  • VK_KHR_shared_presentable_image
  • VK_KHR_vulkan_memory_model
  • VK_MVK_macos_surface
  • VK_NV_compute_shader_derivatives
  • VK_NV_fragment_shader_barycentric
  • VK_NV_geometry_shader_passthrough
  • VK_NV_sample_mask_override_coverage
  • VK_NV_shader_image_footprint
  • VK_NV_shader_subgroup_partitioned
  • VK_NV_viewport_array2
• Handle generic compressed formats in GL by just remapping to uncompressed formats as allowed by the spec.
• When creating a GLES3 replay context, retry without debug bit if it initially fails.
• Add a friendly error message if using an Android 5.0 device or earlier.
• Include resources referenced only in UpdateSubresource.
• Improve performance for wrapped pools with frequent allocation/deallocation of wrapped API objects.
• Improved replay of initial contents in D3D12 upload heaps.
• Make message about closing android studio due to incompatibility much more explicit.
• Reword buttons for capturing frames on capture connec...

Version v1.1

Version v1.1

It's been a quiet summer since v1.0 came out. This release focusses primarily on improving support across the board - newer versions of APIs, OS compatibility, and general bugfixes.

As always binaries for this release are up on the downloads page for Windows and x64 linux as a binary tarball.

Analytics

Just a reminder, the results of the analytics added in RenderDoc v1.0 are up for all to see publicly: https://renderdoc.org/analytics

If you're curious about how many people use RenderDoc or with what APIs and platforms, that's the place to check it out!

Main highlights

• Expanded API support:
  • Vulkan 1.1 including all extensions promoted to core, as well as a number of additional extensions. As always you should make sure to enumerate extensions properly before using them, as RenderDoc will hide any unsupported extensions.
  • Vulkan multi-queue. This means if your application wants to use async compute queues, or transfer queues, this should now be captured and replayed correctly.
  • OpenGL 4.6 - most of this was already present in extensions, the main new supported extension is GL_ARB_gl_spirv.
  • OpenGL non-sharing contexts. Specifically this means that contexts which don't share with each other won't cause aliasing and problems leading to crashes or bad replay. RenderDoc should now fully support several distinct context share-groups.
  • DXGI1.6, D3D11.4, and D3D12.3 - this includes new interfaces defined in newer versions of windows 10.
• Shaders in D3D11 can now be debugged at the HLSL level. Providing the shader was compiled with debug information embedded, you can switch to the HLSL view and step through and set breakpoints as normal in the HLSL code. Similarly, HLSL local variables will be shown while they are in scope as well as the register they map to and the value.
  • 
  • TIP: If you compile with D3DCOMPILE_SKIP_OPTIMIZATION RenderDoc will default to HLSL debugging, if any optimization was present it will still default to assembly debugging as in earlier versions. As long as the debug information is present though you can always toggle between assembly and HLSL debugging at any time.
• Added integration with AMD's Radeon GPU Profiler. This allows RGP profiles to be taken from AMD hardware, which will be embedded in the capture and can be opened later. When opened this way, RGP and RenderDoc synchronise and a drawcall can be selected in one tool from the other, and vice-versa.
  • 
• In the pipeline state window, each group can be collapsed to give more space to other groups.
  • 
• OpenGL ES is now supported on windows, either through extensions to the normal GL driver as well as with GLES emulators such as ANGLE. Note that with this release ANGLE doesn't currently implement enough of GLES 3 to support replay.
  • If you want to capture the underlying API use (D3D11, or GL if using a GLES-on-GL emulator) run the target program with the environment variable RENDERDOC_HOOK_EGL set to 0.

Python changes

Aside from some compatible changes adding new functionality and data, there are a few minor breaking or incompatible changes in the Python APIs:

• conservativeRasterization in D3D11 and D3D12 pipeline states is now an enum, not a bool. Check for ConservativeRaster.Disabled.
• CaptureOptions.saveAllInitials was removed, see below for a longer explanation.
• GPUCounter.SamplesWritten was renamed to GPUCounter.SamplesPassed.
• DrawFlags.UseIBuffer was renamed to DrawFlags.Indexed.
• qrenderdoc.CommonPipelineState moved into renderdoc.PipeState module.
• DrawcallDescription.parent, DrawcallDescription.previous, and DrawcallDescription.next are now references to the DrawcallDescription objects themselves similar to a linked-list, they don't contain the EID of those objects. This makes it easier to walk the draw tree.

Along with these changes are a number of other improvements, there are now some simple examples of using the Python APIs in the documentation pages which can provide a starting point to get to grips.

Features/Improvements

• The 'save all initials' capture option has been removed. This was an optimisation only applied on D3D11 which would skip the initial contents of any large texture that looked like it would be cleared and overwritten in the frame. Since the savings are lesser today with capture compression as well as the difficulty of diagnosing bugs caused by this, it's been removed.
• Add support with Android 6.0 devices
• Added support for VR end-of-frame markers that can be used to delineate frame boundaries when no explicit swapping is happening. Similarly use the markers to select which thread is rendering and ignore other threads doing compositor work.
• Handle None better in python scripting, so that e.g. many common python objects can be compared to None (they are never equal) and None can be passed similarly to NULL when a QWidget is expected.
• Support specifying 'intent arguments' when launching Android applications.
• Implement queue-level markers on D3D12.
• On D3D12 use driver disassembly to get hardware ISA, where a supported driver is present.
• The panels in the resource inspector can now be resized and docked within the window, as with other windows like the shader, buffer, or texture viewers.
• SPDB debug info parsing has been refactored to include recently released PDB information from Microsoft.
• Added support for nvidia NvPerfKit for counters. The library license forbids distribution, so you can have to download NvPerfKit yourself. To use it, put the NvPmApi.Core.dll in plugins/nv/counters/x64 for 64-bit RenderDoc builds and plugins/nv/counters/x86 for 32-bit RenderDoc builds.
• Add support for IDXGraphicsAnalysis query via DXGIGetDebugInterface1.
• Display format for Vulkan texel buffer views.
• Some performance improvements on D3D12 while in the background and not capturing.
• Include resource usage items in Vulkan for usage in secondary command buffers.
• Support double precision outputs in GL mesh output fetch.
• ResourceId is now hashable in Python scripting.
• Restore right-click menu on texture viewer tabs to quickly close other tabs.
• Add simple pass-through support for nvenc - ensuring it won't crash when RenderDoc is active.
• Improve python wrapping of WindowingData objects.
• Unsized formats in GL are now serialised as-is, without first converting to a sized format. It will still be displayed in the UI as the sized format the implementation chose.
• Enumerating the list of PIDs on the system has been optimised to be much faster when window titles are not needed.
• When launching a process on windows environment variable changes are applied before launching the process as well as on injection, to allow modifying variables such as PATH that must be changed before the process starts.
• Add support for selecting which multiview view to show mesh output for.
• Save the last directory chosen in file dialogs, to provide a reasonable default for new dialogs.
• Change pips in timeline bar to color-blind friendly palette.
• Buffer barriers are included in resource usage lists.
• Add support for EvaluateAttribute* intrinsics in shader debugging by caching all possible evaluations up front. This can be expensive if a dynamic offset is used.

Bugfixes

• Fix a crash on OpenGL if reflection data failed to generate for a shader.
• Fixed crashes on Vulkan if vertex buffers used formats that were not supported as texel buffers.
• Fix a crash if a refresh was ongoing in the remote manager when it was closed.
• On Android devices that don't support ps -A fall back to just ps.
• Try to better handle inconsistent error output from adb on Android devices.
• Fix a crash reflecting data out of DXBC shaders if the last binding is an array.
• Fix mixed-up display of logic/blend enabled state in D3D11 and D3D12 pipeline state viewers.
• Handle NULL being passed to SetPrivateData/SetName in D3D, instead of crashing it unsets any previous name.
• Fix some mistaken GL binding points after sorting for current binding information.
• Fix issues with renderdocui stub not launching correctly.
• Fix serialisation of data updates in WGL_NV_DX_interop.
• Fix some drawcall text in event browser being misformatted.
• Fix an issue with the crash reporter generating a 4GB logfile if it failed to read the log.
• Handle OMSetRenderTargetsAndUnorderedAccessViews being called with an overlap between the RTVs and UAVs when only binding one and preserving the other.
• Don't consume ctrl-left or ctrl-right as shortcuts to change event when in a text editing field.
• Fix an issue where widget painting could be requested faster than the paint happens, leading to laggy or locked-up UI.
• Handle 'slice' apks where many apks are present in the install on an Android device.
• Fix buffer readback on vulkan not advancing source offset for copies. Would break any display or save of buffer data over 16MB, including remote replay with the remote host running Vulkan.
• Fix exporting a single slice of a texture to DDS.
• Fix an inconsistent icon in the status bar when running on a high-DPI display.
• Fix a crash processing vertex buffers with an invalid byte stride.
• Fix compilation with non-ASCII system character sets, and with checkout paths containing spaces.
• Don't allow launching an application with the no executable specified.
• Remove a stale cache key wh...

Version v1.0

Version v1.0

For those keeping track, it's been a while since the last stable release of RenderDoc. Work has not been idle, as today marks a new milestone in RenderDoc's development: a mostly arbitrary version number has been reached!

It's been a bit over 4 years since RenderDoc was first launched and the project has grown significantly over that time. Even though this release hits the 1.0 mark, there is still a long road ahead and many improvements still to come. Stay tuned!

A list of improved features and changes are listed below, although there have been many more smaller and behind the scenes changes than are listed here. Thank you to everyone who has helped get RenderDoc to this point as well as everyone who continues to report bugs, contribute fixes and features or simply share the tool with others.

As always binaries for this release are up on the downloads page for Windows and x64 linux as a binary tarball.

Capture Compatibility

A quick note - captures made in v0.x builds of RenderDoc will not open in v1.0, and vice-versa.

I've created a standalone rdcconvert utility which can convert a v0.x capture into a v1.x compatible capture. Binaries are available here (Win x64 • Win x86 • Linux x64) or else you can build it yourself from that tree. To use, you can just run the rdcconvert executable and it will prompt you for the new 1.0 renderdoc.dll if it can't find it automatically, then prompt you for the .rdc to convert. The resulting file is output next to the rdcconvert executable. You can also specify the .rdc file on the command line: rdcconvert path/to/file.rdc and optionally append --silent as the last parameter to suppress any unnecessary dialog boxes.

The conversion is best-effort so may not be perfect, e.g. the capture will have no thumbnail and the swapcahin backbuffer will show up as a normal render target, but otherwise the capture will be usable on v1.0.

There is also a final v0.92 release which contains all the final bugfixes on the v0.x branch. This is the last release on the v0.x branch and all new development and bugfixes will happen on v1.0.

Analytics

From v1.0 the tool now contains some very limited and anonymous analytics. These analytics are optional, but I'd please request that if at all possible you leave them enabled. Having a better idea of how people use the tool will help me to prioritise work and decide what features, APIs and platforms should be worked on.

The analytics are completely anonymous and are sent once a month securely to https://renderdoc.org/analytics. You can see a list of the analytics being gathered in your build, and almost entirely these are simple true/false flags indicating which features have been used. No data is gathered at all during capture time, the analytics code only exists in the replay UI and doesn't store or transmit any frame-specific data.

For those who would like to compile the code to remove any possible trace of the analytics gathering, look in qrenderdoc/Code/Interface/Analytics.h and change the #define RENDERDOC_ANALYTICS_ENABLE 1 to #define RENDERDOC_ANALYTICS_ENABLE 0.

Main highlights

• The Qt RenderDoc UI is now shipping on Windows, the previous .NET winforms UI has been completely deprecated and removed. Aside from better consistency between platforms this comes with a number of benefits to Windows users.
  • •
  • •
  • Qt natively supports high-dpi displays, which should 'just work' including per-monitor DPI awareness.
  • The Qt UI doesn't require an interoperability copy-layer between C++ and C# so should be more efficient.
  • Likewise Qt's rendering and updating is generally faster and the UI should feel more responsive.
  • Qt being C++ greatly increases my abililty to diagnose crashes from crash dumps as I actually get a minidump, not just an exception callstack.
• RenderDoc now supports Android, with both OpenGL ES 2.0 - 3.2 and Vulkan 1.0, thanks to contributions from Samsung and Google.
  • 
  • 
  • Any android application is supported as long as it is built as debuggable, there is no patching or setup step needed, you just select your device and run the application. A step-by-step guide is available in the docs.
  • The workflow is deliberately almost identical to the familiar process on Desktop. Aside from selecting the Android device as the active replay context, you browse to the desired package, launch it, and when you open captures they appear to open locally even though the replay happens on the device.
  • All standard features for GL and Vulkan are supported on android, subject to hardware support for certain features.
  • This also comes with the same requirements as GL, such as all contexts being created as shared.
• The internal serialisation system used for saving captures has been completely rewritten to be much more flexible and future-proof. This enables a lot of nice features in this release and opens the door for some interesting features in future. This is the reason behind v1.0 not being able to open v0.x captures.
  • It's now possible to export capture files to another format, such as human readable xml. This XML lists all of the function calls recorded in the capture and all the parameters and structures. This XML can be edited, added to, changed, and then re-imported back into a capture file for replay. Future RenderDoc versions may include more formats.
  • 
  • Previously any GL calls that were serialised the same way - e.g. glTexImage2D, glTextureImage2D, glTextureImage2DEXT, glTextureImage2DARB were all serialised and displayed as one of these, regardless of which you called. Now gl functions correspond to the exact function called.
  • Errors that happen during loading of a capture can now in most cases be caught and gracefully propagated to the UI. This means instead of the whole program crashing, you at least get a message indicating that there's a problem replaying the capture.
  • RenderDoc now saves thread IDs, timestamps, and durations for every function call. This can be exported in chrome tracing format, and in future may be displayed in-UI.
• Resource Inspector
  • 
  • As a side bonus of the above serialisation refactor, there is a new centralised resource inspector panel. This panel contains a list of all resources available in the capture, and lists the details of the functions used to create and initialise them.
  • It also shows the links back and forth between related or dependent resources.
  • Resources with special viewers like buffers, textures and shaders have links from the resource inspector to go to those viewers.
  • Everywhere in the UI that resources are mentioned, they link back to the central resource inspector panel.
• The RenderDoc python API has been revamped to be an explicitly designed and carefully documented interface into RenderDoc's internals
  • 
  • The previous API was autogenerated from reflected C# internals, which meant that any internal warts were exposed and there was no documentation beyond code commenting.
  • The new API has been designed to be more naturally pythonic where possible and present a more consistent and unified interface.
  • Likewise all API endpoints and structures are documented with python docstrings for help(), as well as being generated into the sphinx documentation.
• RenderDoc now has features for annotating capture files
  • 
  • A general capture comments system now allows saving some arbitrary text with a capture, and it will be displayed first and foremost when opening a new capture. This could be used for storing a build date or version, some reproduction information, or other metadata that is useful to store embedded in the capture file.
  • Bookmarks can be saved with the capture, so that you can save an important event with the capture before sharing it, making it easier for someone else (or you in the future) to jump to the most useful event.
  • The resource inspector allows for renaming of any resource, which can be used both to give names to important resources that only have an autogenerated name, as well as renaming resources based on how they are used within the particular capture. If one buffer in particular is related to a bug, it can be renamed to ...

Version v0.92

Version v0.92

This release is a roll-up of all fixes to the v0.x branch since v0.91. Now that it has been fully retired, there will be no more changes on the v0.x branch. You are recommended to update to v1.0 as soon as possible, this is only here for any legacy reasons.

Binaries for this release are up on the downloads page for Windows and x64 linux as a binary tarball.

Smaller Features/Improvements

• Change home vulkan layer path to use $XDG_DATA_HOME if present.
• When editing a shader, the mesh output now updates correctly to reflect the changes.
• Added hooking for CreateProcessAsUser and CreateProcessWithLogon used by some browsers to change privileges in child processes.
• Speed up linux process connection to connect as soon as possible and apply any queued commands.

Bugfixes

• Add handling for min10float and min16float precision values in DXBC bytecode.
• Fix implementation of round_ne in D3D shader debugging
• When binding a buffer SRV with no format to a Buffer<float4> fetch type info from shader.
• Ensure texture overlay updates when selecting a different texture.
• Use glXGetProcAddress to fetch glXCreateContextAttribsARB, fixes problems on some linux systems.
• Only unwrap values in VkDescriptorImageInfo that are actually used - if sampler is unused, don't unwrap possible garbage.
• If we can't create a sRGB capable framebuffer config on GLX, fallback to non-SRGB and warn the user.
• Fix incorrect replay of Vulkan secondary command buffers that are executed in more than one primary command buffer.
• Add an equivalent framebuffer for every internal vulkan renderpass that requires strict compatibility.
• Fix vulkan crash when serialising changes to a map that was created with a memory offset, and was accidentally offset twice.
• Fix some cases where dangling references would be left on a D3D swapchain after use if it was still bound to the pipeline, and then couldn't be resized.
• Fix texture remapping on vulkan for saving 3D texture slices.
• Ensure we round upwards when selecting which event to replay from in an ambiguous situation, fixes a crash on Vulkan.
• Fix exponential slowdown when applying initial contents of a vulkan array image.
• Fetch dispatch thread dimension even if not disassembling, fixes a problem dispatching compute shaders claiming valid thread IDs are out of bounds.
• Correct VK_KHR_get_memory_requirements2 being marked mistakenly as an instance extension.
• Fix a problem on mesa copying between GL_RGBA and GL_RGBA8 textures.
• Fix a check for whether a drawcall was inside a renderpass that broke on secondary command buffers.
• Don't execute occlusion query or pipeline statistics queries on vulkan when not needed to fetch counters.
• Fix tracking of dynamic offsets when binding multiple descriptor sets
• Fix histogram/minmax calculation and mip-level display on 3D textures.
• Fix a problem opening captures over 2GB in size on windows.
• Don't display unused bindings in vulkan that overlap with used bindings.
• Fix a backwards comparison that would strip away device extensions on vulkan when replaying.
• Fix a potential crash in glVertexArrayVertexBuffers if an optional NULL array is passed.
• Fix some crashes around handling of D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL and D3D11_KEEP_UNORDERED_ACCESS_VIEWS.
• Align thumbnails to 4-pixel multiples to avoid corruption on GL.
• Don't multiply mesh output size required by number of instances twice on GL.
• Clear the D3D11 immediate context state immediately before executing a command list so that state doesn't leak in incorrectly.
• Fix calculation of mip data size when proxy-replaying for a remote context.
• Fix an unusual case where a dll filename containing the substring 'renderdoc.dll' could interfere with the injection process on windows.
• Fix as crash if a D3D12 descriptor that used a NULL description struct to initialise also ended up with a NULL resource on replay.
• Ensure multi-plane resource descriptors on D3D12 are valid on replay.
• Fixed some cases where remapping physical devices between capture and replay wouldn't match up if the number of devices changed.
• Handle vulkan base pipelines correctly by creating dependencies from the base to the created pipeline.
• Add a large padding to memory requirements on AMD as the memory requirements can change between capture and replay at random.
• Fix emulation of glMapNamedBuffer passing the wrong map flags.
• Fix crashes when using Intel's DX11 extensions
• Fix the sampler register use in gather4_po_c in D3D shader debugging.
• Check for ARB_texture_storage in CopyTex2DMSToArray as we need it for ARB_texture_view.
• Handle NULL being passed to glClear*Buffer and glClear*Tex meaning just zero values.
• Handle fetching mesh output data on GL if the application was already using transform feedback at the time of the draw.
• Fix some edge cases where different optimisation of GL programs could create incompatible uniform remapping tables.
• Account for UAV mip slice specified in descriptor when fetching 2D texture data for D3D shader debugging.
• Add an intermediate resolve to a temporary buffer to allow for format conversion, since technically resolve does not allow format conversion of any kind.
• Fix image viewing with GL as the local replay API on linux.
• Fix implementation of firstbit_(s)hi for D3D shader debugging.
• Fix GLSL shader editing with multiple shader sources.
• Handle negative viewport height when calculating aspect ratio in vulkan mesh viewer.
• Handle multi-dimensional arrays in input/output variables when disassembling SPIR-V.
• Ensure that D3D11 debug manager is available on capture even if running headless with no swapchains.
• When opening buffer viewers for index/vertex buffers bound to the pipeline, calculate the right byte offset for the index width.

Version v0.91

Version v0.91 - Bugfix release

As a follow up from v0.90, this includes an important bugfix that unfortunately wasn't caught in release testing.

It primarily affects D3D captures with shader source embedded (compiled with D3D11COMPILE_DEBUG or the appropriate fxc switch) although it could affect GL/Vulkan captures in some circumstances. When debugging or sometimes when opening the shader with source files available, there was a crash due to code not being updated for the UI layout changes to cope with the GCN disassembly feature that was added.

There are no other changes or bugfixes from v0.90, so you can refer to the v0.90 release notes for more information about the changes since v0.34.

Version v0.90

Note: v0.91 contains an important bugfix on top of v0.90

At the end of June, RenderDoc passed a milestone of 5 years of development since the very first commit.

Now this release marks another milestone, although in some respects it's arbitrary. The versions so far from v0.18 up to v0.34 have continued in the same family as the original internal builds marked alpha1 and alpha2 up to alpha17 right before the first public release of v0.18.

It's time to mark the end of the v0.x series of releases. v0.90 is the last planned release in this current v0.x series. The next planned release will at last be v1.0 and will bring with it a number of changes that have been discussed in release notes past.

With this comes a new approach to branching on the github repository. The master branch is being retired, and instead it will continue on as v0.x. This will continue to be a reliable branch to work from for anyone compiling from source themselves, and any bugs that are reported in the coming months will where possible be fixed on this branch. However it will see no new feature development and PRs will not be accepted against it, leaving it 'soft locked'. This branch will continue to exist until v1.0 is released, at which point it will also be retired.

At the same time there is a new branch v1.x where future looking development happens. Especially in the near future, expect this branch to change a lot as I start making large-scale changes for v1.0.

The nightly builds will be made from both branches, to serve both people who want to test new bugfixes on v0.x as well as anyone who is brave enough to try the new development in v1.x.

Any feedback as always can be sent to me via twitter, email or on #renderdoc on freenode.

With that said, let's get into what v0.90 brings!

Version v0.90

Binaries for this release are up on the downloads page for Windows and x64 linux as a binary tarball.

Qt UI improvements

Since the Qt UI is (currently) only used on linux, I'm separating it out from the other features/improvements so that those on windows can skip down to the relevant notes.

• A fairly large overhaul/customisation of the docking system leads to a much improve UI, with drop indicators and previous, as well as removing the timer-switching based targets. For more information see the fork at https://github.com/baldurk/toolwindowmanager.
• Improvements to theme handling in a few places in the UI, to better respect what the theme is rendering. E.g. this means light-on-dark themes should look much more natural.
• Switch to a new icon set that is high-dpi friendly.
• Initial implementation of the timeline bar available in the C# UI. This implementation doesn't heuristically try to scale to make all labels visible, instead it scales based purely on event IDs as a horizontal axis.
• Add default copy/paste handlers in most of the UI.
• Event browser columns are properly resizeable and re-orderable, and also configurable (so you can enable/disable draw ID or duration columns).
• Improved the sizing of sections in treeviews particularly in the pipeline state views, so that it's less extreme and balances free space more evenly between sections.
• Tooltips over resources in pipeline state views that show states now appear immediately.
• Add syntax highlighting for preprocessor commands in HLSL/GLSL
• Draw gridlines in treeviews.
• Implemented CSV export in constant buffer previewer.
• The mesh view's dock layout is persisted between sessions.
• When running python scripts from the command line, print output or exceptions to Qt's logger.
• Added purely opaque handling of QWidget pointers in the python scripting if pyside2 isn't available, so that you can still create and dock built-in windows.
• A custom tooltip displays for elided data in RDTreeViews to show the full data on hover.
• Fix a crash if the event browser is opened after capture is already open.
• Fixed duration summing incorrectly in the event browser.
• Fixed python handling for cross-thread operations to the render thread, around thread-safety and exception rethrowing.
• Fixed a Scintilla bug that caused mousetracking to be lost when an editor is hidden. See upstream bug.
• Fix an issue that menus could fail to appear if they aren't visible immediately after calling popup().

Features/Improvements

• Added GCN ISA decompilation and display. This is supported for all APIs but has some provisos. More information is available in the wiki.
• Add some optimisations to the D3D11 back-end that should improve the idle overhead (when renderdoc is injected but not actively capturing). See #660 for more discussion.
• Replay markers and object names in each API where possible, and add a new 'replay loop' mode to make it easier to trace renderdoc captures with RGP.
• Handle OpSource and OpSourceContinued instructions in SPIR-V, allowing embedded source to be properly displayed as with D3D bytecode blobs.
• Add support for capturing the first 'initial' frame in GL, from the start of the first attribs-based context create to the next present.
• Add support for fetching vulkan mesh output when the output variables are structures (potentially with nesting).
• Set original IDs in the per-drawcall output variables, for use in python scripting.
• Support buffers in the GL extensions providing interop with directx.
• When multiple captures are created manually in a single frame, prevent trampling over the first one with subsequent ones.
• Process filter for injecting into applications is now case insensitive.
• Add support for new Vulkan KHR external memory extensions, as well as VK_KHR_get_memory_requirements2 & dedicated_allocation.
• Don't look at IP address to see if a connection is local or not. This allows SSH port forwarding from local to remote machines and connecting to 'localhost' as a remote host.
• Backend support added for AMD performance counters. Although not exposed in the UI yet, these counters are available for query through the python API.
• Better handling for vulkan resolve attachments - displaying them in the UI properly as additional thumbnails, and fixing a few bugs with those attachments in render pass processing
• Add support for passing __uuidof(ID3D12Device1) when calling D3D12CreateDevice.
• Add some build-time cmake options for specifying the qmake command, and SWIG tarball location.
• When 'ref all resources' is enabled on D3D12, don't actively track descriptors. This can save potentially a lot of time.
• vkCmdWaitEvents is now treated properly as a GPU-side command and displayed in-line with other GPU commands.
• For clear calls the target of the clear is shown instead of the currently bound target, in cases where this might be different (ie. when the target is passed purely as a parameter to the clear call, not as implicit state).

Bugfixes

• Fix a known issue with v0.34 where on certain windows 10 versions a GL capture had a high chance to end up being empty.
• Fix a mismatch in enums between the C# UI and C++ core module, leading to some blend modes being incorrectly reported.
• Fix some cases where samplers could be mistaken for texture resources especially on D3D11, which could lead to mis-naming thumbnails.
• Fix a crash on intel mesa where calling XOpenDisplay multiple times would lead to driver issues. Thanks to @jljusten for tracking down this fix. For more information see this bug on freedesktop.org.
• Fix a crash on vulkan where more physical devices were available during capture than are available on replay.
• Fixed some refcount leaks that would cause some D3D11 captures to stay largely in memory when closed.
• Fix a potential divide by zero for 1-control point patchlist topologies.
• Fix the implementation of round_z in D3D - this needs to apply ceil if the input is negative, or floor if positive. Previously it was applying floor(x < 0.0f ? x + 0.5f : x).
• Fix some handling of slice offsets for 3D textures - in high slice count 3D textures there could be some sampling that would go between slices or end up off-by-one.
• Fix a double delete with descriptor set layouts when immutable samplers are used.
• Fix invalid memory index types being reported in memory requirements.
• Fix a case where GL programs using libepoxy would fail to hook because glXGetProcAddress wasn't reflexive (wouldn't return itself when queried for itself).
• When showing the whole pass in the mesh viewer, show the correct number of instances for each draw.
• Partly speculative bugfix for a pixel history crash when using deferred command lists.
• Fix problems where not enough data is passed to an indirect draw call and we read garbage on the CPU.
• Fix a crash when naming or tagging VkSurfaceKHR.
• Workaround to applications that use DXGI refcounts incorrectly, to leak objects instead of crashing.
• Export glXWaitX as a pass-through so that applications needing it can find it with dlsym.
• Fix a bug where buffer usage was based on the last binding, and could be broken if a buffer is temporarily bound to COPY_READ_BUFFER for DSA style access. Instead examine the use of the buffer across the capture and use this to calculate the usag...

Version v0.34

The past few months things have been quiet as I'm working towards the goal of a 1.0 version release. That means you shouldn't get your hopes up for anything shiny and new in this release! There has been work in the background doing refactoring and some under-the hood improvements, and this version still brings plenty of bugfixes.

Also as things converge towards a 1.0, please take a moment to read the following two documents if they are important to you:

• Analytics
• Revamped Crash Reporter

Since privacy is very important to me I want to make sure I hear any concerns anyone might have on these topics as soon as possible. A little while ago I gauged general reactions to these ideas in principle and they seemed positive - insomuch as very few people were starkly opposed to these changes happening - so now I've written details for everyone to check. For some people they will always want to opt-out of any such options which is perfectly fine.

Any feedback on these can be left as comments on those pages, or sent to me via twitter, email or on #renderdoc on freenode.

Version v0.34

Binaries for this release are up on the downloads page for Windows and x64 linux as a binary tarball.

For anyone building from source now, note that VS2015 is now required to build on windows. VS2010 was retired with a heavy heart a couple of months ago.

To anyone packaging renderdoc for linux, there have been some changes to the build requirements to support building python integration in. There have also been improvements to version tagging, so pay attention to the BUILD_VERSION_* cmake variables, and also take a look at renderdoc/api/replay/version.h.

Features/Improvements

• The Qt UI now supports full python integration, and there's a fully documented and deliberately designed python API available for the internals. Also if PySide2 is available at build-time, there's cross-integration with Qt so you can create new UI panels and widgets from python and have them integrate into the windowing system as well.
• Many other smaller incremental improvements to the Qt UI.
• Vulkan captures will now do simple remapping of physical devices. If the capture system and replay system both contain two physical devices (for example Intel IGPU and Nvidia DGPU) and the order changes between capture and replay, the closest matching device will be used for each. This also means if you capture on a system with only an NV card and replay on a system with AMD and NV cards, the NV card will be explicitly selected. This should reduce some annoying crashes between capture and replay on the same system, but vulkan captures are still not generally portable between differing systems unless the hardware and driver are similar enough.
• Further improvements to lower-end support on GL. In particular more code that was unnecessarily relying on EXT_dsa was removed or emulated.
• Add support for KHX experimental external sharing extensions KHX_external_memory*, VK_KHX_external_semaphore*.
• Add a potential workaround for slow-down or lockups in the UI. This wasn't seen consistently but it seems primarily on OpenGL captures the UI's mousemove events could come in faster than the underlying system could pick texture values for example. This lead to a backlog in queued events and lead to the UI being laggy - or locking up if a synchronous event happened like changing drawcall. Now high-frequency events like texture picks on mouse move are allowed to pre-empt and remove any queued events, so the queue will never be more than one event behind and can quickly catch up once the mouse stops moving.
• Changed version number tagging - particularly for linux build. Instead of packing an "-official" suffix onto the git hash, we now configure several variables independently to store the git commit hash, distribution name, distribution-specific version, and contact URL for the distribution package.
• Added vulkan hardware counters by @victor-moya.
• Improvements to handling of VS output/GS output. The output buffer is no longer a fixed size but now resizes up to whatever size is needed, and GS output is fetched individually for each instance. This fixes a couple of bugs where the VS/GS output would be corrupt for instances after 0 due to an incorrect per-instance stride calculation.
• Apply a fudge-factor to the non-contractual refcount on the D3D12 backbuffer, to try to match the runtime's behaviour.
• When launching a new process from the UI open a little infinite progress bar if it's going to take a while instead of locking up the program.
• Fetch the renderpass state in vulkan even if no pipeline is bound - this allows previewing a renderpass when the vkCmdBeginRenderPass event is selected.
• Unset the renderdoc vulkan capture layer when replaying. This prevents problem if the env var was accidentally left set when running the replay program.
• Added a floateleven specifier in the buffer viewer for unpacking R11G11B10 data.
• Improved copy-paste support from tree or list views. Ctrl-A will now 'select all', and the results will be sorted in-order before being copied.
• Added an option to completely disable the fake event markers that are added to captures with no markers.
• Added a --python command line option to renderdocui to run a python script from the command line completely automated.
• Add support for saving Depth24 textures in GL to HDR/EXR formats, and saving double formatted data.
• Add a python function to return the ID of the texture debug overlay's resource ID.
• On GL cache the results of fetching a particular mip level. Because all array slices are together in a mip level in GL, this could lead to extreme memory allocation overhead when fetching each slice individually.
• Add a call to XInitThreads on linux in replay applications to ensure nvidia driver optimisations can work without crashing, and a warning about the 378 series where these will crash unless disabled by an environment variable.
• When naming command buffers in vulkan, make sure to propagate the name to all baked command buffers.

Bugfixes

• Fix an regression on linux that could cause UI panels not to draw, due to a fix being lost in a bad merge.
• Update the windows hooking code to handle the same dll filename being loaded from multiple places, and so having unique module entries. This commonly manifested as any application using AMD's extensions crashing on replay - since the AMD extensions weren't properly force-disabled on capture as atidxx64.dll was loaded twice.
• Fix a crash on D3D12 if the program was captured as 32-bit and is then replayed in a 64-bit UI.
• Remove code that ignored SIGCHLD signals, since Qt needs them internally to function. This will cause every process launched by RenderDoc to become a zombie process until qrenderdoc closes.
• Add missing handling of VK_FORMAT_A8B8G8R8_*_PACK32.
• Remove direct-mode display vulkan extensions when replaying as they aren't used.
• Correct some parsing of /proc/self/maps - device numbers are in hex not decimal.
• Fetch pipeline state after replaying drawcall, not before, so we pick up the state consistently (mostly only applies to mutable data in the state like hidden atomic counter values).
• Handle disassembling unknown extension-set operations in SPIR-V without crashing. Also add support for AMD/NV extension operations.
• Only serialise Vulkan queue indices if the sharing mode is CONCURRENT.
• Fix calculation of compressed texture size per-mip to avoid over-allocation.
• Stopped the python shell incorrectly complaining about missing libraries.
• Experimental fix for an unknown crash disassembling SPDB chunks.
• Fix crash with coherent vulkan maps if a not-mapped memory handle was unmapped again.
• Fixes for handling use of VAO 0 (the default VAO).
• Handle errors in glCreateShaderProgramv by returning immediately instead of trying to wrap a '0' program.
• Fix off-by-one event IDs in runtime generated debug messages.
• Fix DrawInstanced setting baseVertex instead of vertexOffset property.
• When patching D3D12 pipeline state objects, ensure samplemask and sampledesc are initialised properly as they might not have been in the original.
• Fix an out-of-range error when picking vertices in the GS output which is expanded to more vertices than existed in VS input/VS output.
• Apply the correct image usage to vulkan swapchains instead of just our own, so that e.g. STORAGE_BIT is replayed correctly.
• Fix a mistaken output merger validation condition - depth-read-only DSVs where the texture only contains depth can be bound if an SRV is already bound. Previously we were only handling the case for textures with depth and stencil and depth-read-only.
• CUDA dlls are no longer hooked to allow capturing applications that use CUDA.
• On Vulkan when creating images during replay we add any usage bits we might have needed for the image on capture, to ensure memory requirements are compatible. We don't need to do this though for images that aren't part of the capture itself. This fixes an issue with the intel vulkan mesa driver where it doesn't support storage multisample images.
• SPIR-V reflection should list all outputs from pixel shaders as system values containing colour, even if they're not annotated explicitly.
• Fix the calculation of slices for displaying 3D textures on D3D12.
• Fix a copy-paste error that would replay vkCmdDrawIndexedIndirect as vkCmdDrawIndirect
• Fixed element size not being set for D3D11 structured buffer UAVs when bound to the OM instead of CS.
• Fixed a possible state-vector trash when resizing swapchains that could show up as incorr...

Version v0.33

Just in time for GDC, here's the latest RenderDoc release! The main focus in this release has been greatly improved support for linux and GL, but there's hopefully something here for everyone.

At the same time, I've made public a new homepage for RenderDoc with an easy to find link to the latest version, as well as news and any articles I write that might be interesting. If you're looking to link to RenderDoc, then that's the URL to use - https://renderdoc.org/

As always if you run into any problems or have suggestions then you can file an issue on github or contact me.

Version v0.33

Binaries for this release are up on the downloads page for Windows and x64 linux as a binary tarball.

The Qt UI on linux is missing python support as I'm planning to design & document a proper python API for interop with renderdoc, but otherwise everything should pretty much be working. There's an issue on github tracking remaining polish tasks and things like that.

Work will continue on the Qt UI to get this polish complete so that it's at the same level of quality as the windows UI, and once it's at that level then the Qt UI will be rolled out across all platforms.

Also on the GL front, RenderDoc no longer requires hardware GL 4.3 support and EXT_direct_state_access/ARB_buffer_storage to replay (although that does mean some features will be disabled if they rely on functionality that isn't available). Instead it requires just 3.2 and a handful of extensions:

• GL_ARB_vertex_attrib_binding
• GL_ARB_program_interface_query
• GL_ARB_shading_language_420pack
• GL_ARB_separate_shader_objects
• GL_ARB_explicit_attrib_location
• GL_ARB_sampler_objects

Largely these don't require actual hardware support, and any decent GL implementation will support them in software regardless of the hardware. This means you can use RenderDoc on the software mesa implementation without requiring the latest drivers:

Features/Improvements

• The Linux Qt UI is now comparable to the windows UI in feature set, and stable enough for everyday use.
• As mentioned above the GL support will now work correctly on any recent mesa (I tested against ~10.5 or 10.6). This means both fixing bugs in RenderDoc that mesa caught, as well as significantly lowering the requirements from 4.3 + EXT_direct_state_access + ARB_buffer_storage to 3.2 + a few non-hw extensions.
• Added support for VK_NV_external_memory* and VK_NV_dedicated_allocation Vulkan extensions, which are needed for VR rendering.
• New GPU counters are available on D3D11, D3D12 and GL - Primitives processed, shader invocations, rasterizer invocations. These counters are not currently exposed in the API but can be queried through the python shell. Thanks to @victor-moya for these.
• Add drawcall timings for copy/resolve/blit type operations in vulkan.
• When shader debugging add functions to run to the next texture operation, or run to the next floating point exception (instruction that generates a NaN/Inf). Thanks to @michaelkvance for this.
  
• Include the duration column when exporting data from the event browser.
• Add a warning for python if the libraries aren't loaded (only relevant for dev builds).
• When self-hosting RenderDoc (capturing it with itself) some new tool menu items appear in the UI to start/stop captures. There are also now some marker regions added during replay.
• Add some verification for GL buffers being bound, so that invalid buffer names won't crash immediately.
• Add support for the Vulkan extension VK_AMD_negative_viewport_height
• Add support for Vulkan extensions released in 1.0.39: VK_KHR_get_physical_device_properties2, VK_KHR_maintenance1, VK_EXT_direct_mode_display, VK_EXT_acquire_xlib_display, VK_EXT_display_surface_counter, VK_EXT_shader_subgroup_ballot, VK_EXT_shader_subgroup_vote, VK_EXT_swapchain_colorspace, and VK_KHR_shader_draw_parameters.
• When the global hook is active, prevent closing the program to avoid leaving a stale hook active.
• Add Map() buffer overwrite handling for OpenGL, using tinyfiledialogs for cross-platform messageboxes.
• When shader debugging, don't replay the capture commands at all. This means that when the shader debug happens it contains the same data as was visible in the capture before debugging, which can be different if there's non-deterministic behaviour like append/consume or atomics.
• Added a new option to hide any marker regions which only contain "API Calls" placeholders and not real drawcalls, for example if there are only queries inside the marker region.
• In the capture connection window, you can rename the label on captures.
  
• When a GL buffer contains padding, the struct definition reflected out will include dummy padding elements.
• When replaying D3D12 upload heap buffers, allocate them on a default heap instead if they're large. This prevents extreme slowdown when copying data to them as it must be memcpy'd instead of uploaded to the GPU and copied there.
• Added multi-instance picking, so if you are rendering multiple instances at once you can pick a vertex from any of them and the corresponding instance will be activated.
• Support for yet another new marker format for D3D, this time PIX3 for D3D12 only. Thanks to @tiago-rodrigues.
• Eliminate a performance cliff that could happen if a vulkan resource with a large number of subresources (e.g. a cubemap array with lots of mips) was split apart for the purposes of processing barriers, and then never recombined again during replay producing a lot of redundant barriers.
• When copy-pasting a quoted path into the capture dialog, the quotes are removed.
• Callstack entries that don't have any matching symbols will now be something like module.dll+0x0ff5 instead of 0x627ddff5.
• Added $ORIGIN/../lib/ to rpath for renderdoccmd and qrenderdoc, and similar change to setting LD_LIBRARY_PATH when capturing, so that the file structure in linux tarballs will work as-is.
• If we see SwapBuffers() being called a lot with no context active, add a log message about the problem.
• Added support for depth & stencil overlays on cubemap, array and renderbuffer targets.
• Add handling for InstanceStepRate values above 1 in vertex debugging.

Bugfixes

• Fix a bug that would cause an instant crash loading any D3D12 capture on nvidia, due to an API requirement that's undocumented, unexplained and not mentioned by validation checking.
• Fixed a long-standing edge-case refcounting bug that could lead to pure virtual function calls or other funkiness while binding resources due to D3D hazard tracking. The explanation for this bug and the fix is kind of interesting but too long, so you can read more details in the first commit that revealed the bug and the second commit that actually fixed it.
• Work around an nvidia driver bug where D3D11_USAGE_IMMUTABLE buffers wouldn't apply an offset properly when calling CopySubresourceRegion. This could manifest a few ways, most often by incorrect values fetched for shader debugging, but also in the buffer viewer if a byte/row offset was specified.
• Fix hooking child processes when CreateProcess was imported from an API set. This could affect functions like execve which did that internally.
• Fixed a case where you had a 64-bit RenderDoc that ran a 32-bit process which then launched a 64-bit process (e.g a 32-bit launcher for a 64-bit game). Only going from higher bitness to lower bitness was supported previously.
• Added a fallback case for if D3D12 versioned root signature functions aren't available, which can depend on your OS build version even if you have D3D12.
• Implement missing QueryInterface for IDXGISwapChain4.
• Fix capture on DirectComposition swapchains, by forcing a fake HWND value.
• Handle non-NULL terminated strings in D3D11's SetPrivateData.
• Implement a workaround for executing programs on apple where environ can't be modified, search PATH manually and call execve.
• Support re-compilation and re-linking of programs in GL during capture.
• Correct the value used for base vertex when fetching post-VS data on GL.
• Mark a couple of GL draws as instanced that weren't properly flagged.
• Ensure that GL persistent maps are always intercepted, and don't make GL maps persistent on replay.
• Check that programs exist in a GL capture when setting uniforms.
• Fix sRGB calculation when applying 'fake' gamma curve to texture data.
• glVertexArrayElementBuffer behaves weirdly with respect to GL_ELEMENT_ARRAY_BUFFER_BINDING, so we always emulate it with a non-DSA version
• Fix GLSL shader patching with comments on a preprocessor line.
• Fix a crash with Vulkan descriptors referring to deleted buffers with invalid IDs.
• Fix GL texture overlays rendering with multisampled textures.
• When copying attrib bindings between GL programs, re-link the program afterwards.
• Fix a crash trying to render the quad overdraw overlay on a 1x1 texture.
• Fix a crash with the options in the context menu on the pixel con...

Version v0.32

Time for another RenderDoc release! This time coming with support for D3D12.

With the survey a few months ago it was very clear that a lot of people were looking for D3D12 support, and the back-end in RenderDoc is now ready for prime-time. I've tested it on every D3D12 program I can lay hands on, so if you run into any issues then do file a bug about it.

Version v0.32

Binaries for this release are up on the downloads page for Windows and x64 linux as a binary tarball.

The D3D12 support comes with a few provisos - it currently doesn't support multiple GPUs (i.e. NodeMask must be 0 everywhere), and it doesn't support tiled/reserved resources. This functionality will be filled in in the future, but given the high complexity to relatively low usage, it's prioritised appropriately.

Likewise shader debugging and pixel history is currently not yet implemented for D3D12, but all other RenderDoc features should be working. Again file a bug with anything that seems broken!

Aside from D3D12 there are a bunch of bugfixes and a few cool new features like a triangle size overlay which you can use to diagnose missing LODs or other super dense meshes.

Looking ahead to future versions, there's a refactored serialisation system coming in the pipeline which will enable a bunch of really cool new features. The downside is that it will break capture backwards compatibility. I'll give more details in future, but it's possible that v0.33 may be the last version that supports captures made on current versions.

Also, the linux build this time comes with a very early preview of qrenderdoc, the Qt UI. It is very much work in progress, many things are not yet implemented or buggy, but if you feel like trying it out then it's there. This will be the UI on windows eventually too, but only once it has reached feature and quality parity with the existing winforms UI.

Features/Improvements

• Added beta D3D12 support! This should now be usable for day-to-day use, and has been tested on all the D3D12 things I could get my hands on, including a number of D3D12 games.

  It's listed as beta primarily because it hasn't yet had widespread testing. Note also that some features are not yet implemented on D3D12, notably shader debugging and pixel history.

• Vertex picking is improved, thanks to @Velro. The mesh viewer now does a ray-cast per triangle and picks the closest vertex to the cursor on the best matching triangle, instead of just picking the closest vertex anywhere.

• New triangle size overlay, showing a heat value for the size of a triangle. Any triangle above 4x4 pixels in area is the coolest value, and then 'heat' increases exponentially to triangles that are 1/16th a pixel in area.

  

• Improved the accuracy of shader debugging in a number of cases by running transcendental functions on the GPU to precisely emulate the floating point accuracy of the current GPU. sin, cos, and others should now match the results from the real GPU and avoid slight ULP variances which could be amplified (e.g. by multiplying the result with a huge number for a rand()).

• Early support for D3D9 overlay. Not all D3D9 programs will get an overlay yet, but where possible an overlay will display showing clearly that the API is unsupported. Work is ongoing in a separate fork.

• Improved the 'inject into process' UI. Added a window title column, column sorting, fixed the missing refresh button and added a find-as-you-type filter.

  

  I still strongly recommend using the normal launch-to-capture workflow wherever possible, as injecting only works when the process hasn't used any target APIs, and has other drawbacks. It is useful in a small minority of cases.

• Process injection now supports environment variable changes.

• Added some error messages and detection if an invalid object is passed into GL functions. In general renderdoc doesn't do API validation, but some slight bullet-proofing will catch low hanging fruit problems.

• If a launched process dies during startup, a more friendly/obvious error is printed to the logfile.

• The replay no longer creates a debug context when replaying a GL capture.

• Added support for an external SPIR-V disassembler tool, which can be configured to generate compilable glsl from SPIR-V directly, if the original source isn't available or isn't glsl.

• Some slight improvements to the enumeration of remote hosts.

• Implemented debug output muting on GL.

• Detect and suppress any drawcalls that happen outside of render passes in Vulkan. Previously this would crash the program, but now the drawcall is skipped and an error message is added.

• Display whether a DSV is depth or stencil read-only in D3D11 pipeline state.

• Added support for remapping texture formats across APIs. This is useful in particular for e.g. Android replay with an ASTC texture that can't be natively displayed on a Windows UI, so it needs to be internally remapped to a format that can be displayed.

• Added a tool menu option to start the Android remote server.

• Support hooking libraries loaded with RTLD_DEEPBIND on linux.

• Improved compression quality and size on capture thumbnails, and added a preview panel to the capture connection. E.g. this allows easy checking if the frame you just captured shows the bug you were after or not.

  

• Min/max and histogram calculation now use custom visualisation shaders as their inputs instead of the real texture values.

• Improved debug logging. All processes launched from a single instance of the UI now log to the same file - using appropriate OS mechanisms to ensure logs are distinct. This means the Help -> View Diagnostic Log File menu option is more useful.

• Temporary files are now stored in a subdirectory - $TEMP/RenderDoc instead of spraying out in the root $TEMP folder

• Added previous/next buttons to the event browser. These also have global shortcut keys ctrl-left/ctrl-right which work anywhere.

• Added experimental support for WGL_NV_dx_interop to use DX textures in GL.

• Exported the full GLX function set, to comply with ABI requirements for libGL.so.

• In addition, added exports for unsupported GL1.0-1.2 deprecated functions, to allow a program to query for them and receive a valid function pointer. Note they aren't implemented, so it would still not work to call them.

• Added wrapping for DXGI 1.5 and improved DXGI wrapping to have better compatibility with programs querying interfaces back and forward.

• Multiple fixes and improvements to support capturing Direct2D in all known cases. This one is a bit funky, and DXGI is a complete mess of an API, so if you find a case that breaks then please report it as it may still be possible to support it.

• Added easy support for self-hosting - ie. capturing RenderDoc's replay program with RenderDoc, and then debugging the replay.

• Added a hover popup over tree views (e.g. the event browser) to show the full text of a line that is truncated for space

  

• Added the ability to discard the alpha channel when saving to TGA/PNG, even though the format supports it.

• Added support for multisampled image initial states in Vulkan, so that the data from previous frames is saved and restored. This also allows the display of multisampled images over a remote host connection.

• Added a backdoor UUID - {3FC4E618-3F70-452A-8B8F-A73ACCB58E3D} - which returns the real unwrapped ID3D11InfoQueue from the D3D11 device. This allows custom filtering of messages, but you must be very careful not to use this to query for other interfaces as they will be returned unwrapped. Likewise any messages filtered out will not be retrieved or saved by RenderDoc's built-in API validation tracking. The debug layer must still be enabled via the capture options.

• When serialising GL memory barriers, display the bitfield values as strings instead of a hex number.

• Sort tree list values before copy-pasting, as the selection is stored by default in the order they were selected (possibly reversed).

• Don't accumulate ResolveSubresource calls over time if we can't deduplicate them, but instead just mark the resource as dirty.

Bugfixes

• Fixed a crash that could happen if GetProcAddress was called for either itself or LoadLibrary, commonly happening in .NET programs that used P/Invoke for either function.
• Fixes for the display and saving of 3D textures, in particular for at mip levels above 0.
• Allowed hooking of delay-loaded ordinal imports. Mostly applicable for delay-loaded d3d12.dll.
• Fixed the wrong operand being used in some sample operations - particularly comparison operations.
• The arrow key nudge-by-1-pixel in the texture viewer accounts for mip level instead of requiring 2^n presses to move a texel in a mip.
• Ampersands in event names no longer try to become shortcuts.
• Calculation of uniform buffer sizes is fixed for arrays/structs in SPIR-V.
• Fixed the RENDERDOC_TEMP override on linux not working properly.
• Fixed cases where a buffer that's modified mid-frame in GL would not correctly restore its contents at the start of the frame, or where it could have the incorrect contents at the start of the frame if it's not modified before use.
• Forced 'viewed' textures to have initial contents saved out, as there's no good way for the underlying texture to know if it was modified through a texture view or not.
• Fixed event IDs from error messages being incorrect.
• Fixed a case where interna...