Version v1.5

Version v1.5

Another release is ready! This is a further incremental advance with optimisations, quality of life improvements, and of course plenty of bug fixes.

For anyone running v1.3 still, please see the previous release notes for v1.4 to ensure you kill any runaway crash handler processes before upgrading.

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. Note that linux binary releases no longer static link libstdc++ due to incompatibilities on some distros, so you will need to have libstdc++ from GCC 5.x or newer available on your system. If you get errors about missing GLIBCXX then you need a newer libstdc++. In general it is strongly recommended that you prefer distribution packages where possible, or compiling RenderDoc from source yourself, to ensure a stable build - the binary builds cannot be guaranteed to be perfectly compatible with all distributions on linux.

I'd also like to take this opportunity to remind everyone that RenderDoc is only intended for debugging your own programs. Use of RenderDoc for injecting into copyrighted programs which you do not own the copyright to is not supported or endorsed and I will not help with any problems as a result. In particular this means injecting into Google Chrome to capture WebGL webpages, which is being used regularly for extracting copyrighted content.

Main highlights

• The replay of a capture can now be configured, both on a one-off basis and globally. In the file menu there's a new option to open a capture with options, which apply only for that session. In the settings window there is a replay section.
  These options allow overriding the default GPU selection where possible (every API except OpenGL) to force the use of a particular GPU. This could be useful to open the same capture on different drivers, or to force WARP on D3D. Note that not all captures may be cross-GPU compatible.
  You can also force on the use of API validation layers at replay time, to validate the commands even if they weren't validated at capture time. Due to changes in the replay between capture and replay these may include false positives and you will incur the penalty for API validation while active, so it's still recommended to capture validation layer messages at capture time.
  
• The SPIR-V reflection and disassembly has been refactored to be more reliable and is based on the publicly available grammar json. This means SPIR-V up to the latest 1.5 version is supported with all instructions having basic disassembly support. The disassembly is more literal now, so if a 'high-level language' style disassembly is desired then it's recommended to use SPIRV-Cross.
  In addition the reflection now accounts for the same shader being compiled with different specialization constants, so that things like array sizes in constant buffers are correctly sized for the pipeline's specialization constants.
• Vulkan has a new replay-time optimisation which takes advantage of the above replay options dialog. Resources which are not modified in a frame are no longer redundantly reset when a new event is selected. Also on higher optimisation levels the reset will become more streamlined, e.g. resetting resources with a clear when the previous contents are completely overwritten or cleared again within the frame.
• OpenGL has a low-memory optimisation to defer copying initial contents of textures and buffers that are rarely modified. This should reduce the memory spike overhead at capture time which is particularly useful for Android devices.
• Optimisations to the program startup, replay of captures with large numbers of events, and of construction and passing around serialised strings. In particular compile-time strings like member, enum value, and type names are now moved around as static pointers instead of having storage allocated. In captures with huge number of serialised resources (typically descriptors in Vulkan/D3D12) this vastly improves capture load and close time.

Python breaking changes

• ReplayOutput.AddThumbnail now takes two new parameters int mip and int slice to control the mip and slice being displayed in the thumbnail.
• PipeState.GetShaderExtension has been removed and ReplayController.BuildCustomShader now accepts a ShaderEncoding and bytes instead of just source text. This previously returned glsl for OpenGL and Vulkan, and hlsl for D3D. It's now recommended to check GetCustomShaderEncodings() and allow any high level language that can be compiled to a supported encoding.
• The port parameter on CreateRemoteServerConnection and BecomeRemoteServer has been removed, as has GetDefaultRemoteServerPort. Only the default connection port is supported.
• ReplayController.GetShader and ReplayController.GetCBufferVariableContents now take a pipeline parameter. This may be empty/Null on APIs without pipeline state objects.
• RemoteServer.OpenCapture, CaptureFile.OpenCapture, and CaptureContext.LoadCapture now take a ReplayOptions parameter to control the replay. You can construct a default instance of ReplayOptions and the behaviour will be as it was before.
• SaveCallback used in EditShader has a new signature, to allow for different file encoding.
• The access to RemoteHosts in the UI has changed - there is now a function GetRemoteHosts() in PersistantConfig that returns the current list, and GetRemoteHost() takes a hostname, to look up a host by name if it exists - if it doesn't an invalid RemoteHost will be returned. Access to RemoteHost properties is now via member functions rather than direct member data access.

Features/Improvements

• Add support for a number of Vulkan extensions:
  • VK_KHR_imageless_framebuffer
  • VK_KHR_pipeline_executable_properties
  • VK_KHR_shader_subgroup_extended_types
  • VK_KHR_surface_protected_capabilities
  • VK_KHR_uniform_buffer_standard_layout
  • VK_EXT_filter_cubic
  • VK_EXT_fragment_shader_interlock
  • VK_EXT_full_screen_exclusive
  • VK_EXT_hdr_metadata
  • VK_EXT_headless_surface
  • VK_EXT_index_type_uint8
  • VK_EXT_line_rasterization
  • VK_EXT_metal_surface
  • VK_EXT_shader_demote_to_helper_invocation
  • VK_EXT_subgroup_size_control
  • VK_EXT_texel_buffer_alignment
  • VK_AMD_device_coherent_memory
  • VK_AMD_display_native
  • VK_IMG_filter_cubic
  • VK_GOOGLE_display_timing
  • VK_GOOGLE_user_type
• Add support for some OpenGL extensions and whitelist GLES extensions that were already supported:
  • GL_ARB_ES3_2_compatibility
  • GL_EXT_texture_compression_s3tc_srgb
  • GL_EXT_polygon_offset
  • GL_EXT_draw_instanced
  • GL_EXT_multi_draw_arrays
  • GL_EXT_polygon_offset_clamp
  • GL_EXT_post_depth_coverage
  • GL_EXT_raster_multisample
  • GL_EXT_semaphore
  • GL_EXT_texture_compression_bptc
  • GL_EXT_texture_compression_rgtc
  • GL_EXT_texture_lod_bias
  • GL_EXT_win32_keyed_mutex
  • GL_KHR_parallel_shader_compile
  • GL_KHR_robustness
• Add support for D3D12.6 (???) - ID3D12GraphicsCommandList5 and ID3D12Device6.
• Add support for D3D12On7, both for capture and replay.
• Linux builds no longer static link libstdc++ due to incompatibilities on some distributions. As above this may mean added incompatibilities on other distributions - distro packages or building from source is still recommended on linux.
• Added software emulation of KHR_debug extension so that it can be used for labelling objects and adding debug markers even if the driver doesn't support the extension for reporting errors.
• Thumbnails in the texture viewer now use the first mip/slice bound to the view to determine which mip and slice to show, instead of always showing the top mip of the first slice.
• Add support for shader processing tools within custom visualisation shaders. This also fixes an issue with Vulkan custom shaders not compiling as they expected SPIR-V directly instead of GLSL.
• Add detection of invalid shader code being passed to CreatePipelineState on D3D12, if an application doesn't correclty check for DXIL support and tries to upload it anyway without it being supported.
• Use KHR_driver_properties and versions to better match physical devices on Vulkan.
• In GL the texture binding state is per-type as well as per-slot, so slot 0 TEXTURE_2D isn't the same as slot 0 TEXTURE_3D. This is now handled when multiple textures are bound to the same slot and the implicit texture referred to isn't the most recent one bound to that slot.
• If the user updates a RenderDoc install outside of the normal updater, the update check will now clear the pending update on start of a new version.
• Add support for serialised function calls with more than 4GB of data.
• Add support for stencil-only backbuffers in OpenGL.
• The 'show disabled' button has been renamed to 'show unused' to better convey what's actually being shown or hidden.
• Show texture wrapping modes using GL-style terminology on GL captures. This means e.g. "Repeat" instead of "Wrap".
• Improved the handling of SPIR-V on GL to fix several features and not rely on driver reflection which may not be valid or may have been stripped away from the SPIR-V.
• Show the object in GL's sampler state view in the pipeline state viewer.
• Add support for new layering system in Android 10, to allow Android apps to be captured without using the JDWP debugger to inject code.
• Handle shader debugging when one source line maps to many instructions (i.e. inlining).
• Mark RenderDoc's internal book-keeping calls explicitly as internal in the API/resource inspector.
• When viewing mesh attributes a...

Version v1.4

Version v1.4

This release fixes a bug in v1.3 which could cause runaway internal processes on Windows 10 due to slow process startup.

If you use the built-in updater to update from v1.3 to this version, you will need to manually terminate these runaway processes or else the update will fail due to a file being in use. Unfortunately this can't be done automatically - so either use task manager to kill all renderdoccmd.exe processes, or run the command taskkill /f /im renderdoccmd.exe as administrator, before clicking install on the update dialog.

You can also uninstall completely and install v1.4 freshly, the windows installer will kill terminate the runaway processes for you.

There are no other changes in this version, so for the remainder of the changes since v1.2 please see the v1.3 release notes

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...