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

Version v0.31

The results from last month's survey are now up for anyone interested to see the aggregated results! There are definitely some interesting conclusions to be drawn, and the effects of any change in direction will start to appear in the coming months.

As a result of the survey responses, I will be creating a detailed proposal for both anonymous telemetry and an expanded crash reporter. These will be posted as a request for comments to allow for any tweaking and also a more concrete idea for people to raise specific objections against. As mentioned in the survey, these will still be easily opt-outable and respectful of user privacy.

Thank you once more to everyone who filled this out, I am very appreciative of the time taken to give so many responses, and I hope the results are interesting to you!

Version v0.31

The downloads of this release are now up on the builds page including new linux binaries. These are x64 and might not work for everyone, although hopefully they should have wide compatibility. Right now I've not set up .deb/.rpm packages although that might come in future.

The primary focus of this release is a stepping stone towards further platform compatibility. Although RenderDoc has technically had support for network capture and replay for a while, this release sees a significant polish and tweaking applied to make the process as smooth and easy as possible. While obviously not as powerful as a native UI on non-windows platforms, this will help those targeting those platforms from a windows development machine.

If you're interested in debugging on linux from windows, this release also comes with linux binaries (although of course you can build your own from source) and documentation/instructions on how to do that. As I mentioned, this is an intermediate step - the next being a native Qt UI for non-windows platforms.

There are a couple of small backwards-compatible breaking changes in this version. If you have captures made on older versions of RenderDoc that use deferred command lists in D3D11 and were using the RestoreDeferredContextState == TRUE parameter to ID3D11DeviceContext::FinishCommandList this will no longer replay correctly so results may diverge. You will have to capture again with v0.31 for it to work. Otherwise old captures should continue to work.

Also the python shell core object is now exposed as pyrenderdoc, to make room for renderdoc mapping as a python module to the internal renderdoc C# namespace, allowing creation and referencing of C# types much more easily.

If you run into any problems or have suggestions for improvements, please file an issue or contact me directly to let me know! I'm always happy to help out with whatever I can.

Features/Improvements

• Retooled the workflow and software support for network capture and replay. The documentation available gives all the details of how to set up and use this feature, and there's also a short video tutorial showing the simple steps visually.

  

  

• Captures now include a coarse machine identifier (such as operating system, CPU architecture and bitness). This is used to prompt users to replay remotely.

  

• Added a 'TDR' style timeout to shader debugging. After 100,000 cycles the debugging will prompt the user to abort as this is likely an infinite or very long running loop. If you hit this limit with working shaders, let me know!

• Heavily refactored handling of deferred contexts in D3D11. Previously there was a lot of ugly code to try and handle replaying separately on the immediate context and on a particular deferred context, now deferred commands are simply flattened into the immediate context at execute time.
  

  Please report any bugs you run into with handling of deferred contexts, as I have precious few real test cases to verify that everything is working.

• On vulkan, debug output is now muted by default to prevent applications from firing on false positive validation layer warnings or errors that are added by the capturing.

• Report only a single queue in the single family in Vulkan (previous releases would still report multiple queues available).

• Update notes for new versions are now formatted as RTF to allow links/bold/headers.

• When compiling for linux, support for xlib/xcb optional and can be compiled out to remove any reference to those libraries.

• Added the ability to specify environment variable modifications when launching a program - operations supported are 'set', 'append' and 'prepend', with append/prepend optionally supporting ; and : separators.

  

• Added VK_KHR_display support on Vulkan for direct framebuffer access.

• Added an option in the settings window to specify a default folder for saving captures.

• Improved proxying behaviour on GL, to handle BGRA and various some other non-uniform texture formats.

• On linux renderdoccmd version will print which windowing and rendering APIs were included at compile time.

• renderdoccmd on linux now will detect if the vulkan layer is registered properly and prompt the user to register it or fix the situation.

• Shaders can now be saved to disk from the pipeline state. This is most useful for retrieving binary shaders from D3D11/Vulkan for external examination, on OpenGL it concatenates all source files together.

• The drawcall column on the Event Browser now shows a range of drawcalls, the same as EID, for marker regions.

  

• Serialise and display parameters to IDXGISwapChain::Present.

• Add F3/shift-F3 for searching forward and backwards in event browser.

Bugfixes

• Fixed a bug that hit a number of people in v0.30 - if multiple mesh viewers were open in the default window layout, the docking toolkit I use would crash on opening.
• Fixed a common cause of crashes on AMD, if using the DX extensions this would cause a driver crash on replay. Now the DX extensions will be hooked and returned as unavailable/failing to initialise.
• Fix loading of EXR files, and improve error messages when failing to load images (don't refer to them confusingly as 'logfiles').
• Save EXR images in ABGR channel order which seems more compatible with viewers.
• Fix an incorrect saturate on D3D11's fake gamma curve, causing slight clamp of white pixels.
• Fix a potential crash if GetProcAddress failed on a function that we would in theory be able to hook.
• Fixed multisampled renderbuffers in GL not displaying correctly.
• Stopped a leaking capture where glBindSamplers would be recorded even when not mid-frame.
• Fixed a few cases of invalid GL use in edge-cases.
• Corrected recording of 'VAO 0' to properly reference the buffers bound to it.
• Fix pixel highlight boxes being off by one in the pixel context view.
• Fixed an odd interface-casting bug that lead to ID3D11DeviceContext::GetDevice returning an invalid pointer.
• Several improvements for control colours under high contrast themes.
• Fix potential crash if selecting a non-drawcall with empty items enabled in the pipeline state view.
• Make sure buffer view clamping to 200k max rows, even if a view specifies more than that.
• Fixed handling of matching source with blank lines when the shader was compiled with old (SPDB) D3D debug format.
• Speculative fixes for some crashes in texture viewer, by clamping previously selected mip/slice.
• Fix for reconstructing constant buffer sizes without reflection data.
• Fix an erroneous failure to capture if a GL frame contained no commands whatsoever.
• Fixed network capture/replay between mismatched 32-bit and 64-bit executables.
• Fix a crash when reading off the end of a buffer on D3D11, instead of clamping.
• Fixed incorrect socket error handling on linux not looking for EAGAIN and EINPROGRESS.
• Fix incorrect calls of select() on linux.
• Add a search for a matching X visual ID when creating GLX window.
• Fix a crash if a barrier event happens not within a drawcall.
• Fixed vulkan debug texture rendering (used for display or saving texture data) being clipped to 4k accidentally.
• Some fixes to handling of texture views without trying to copy or save their contents.
• Fix a crash with vulkan shader edit & replace.
• Fix a crash in vulkan pipeline state export to html.
• Fix a possible case where the GL in-application overlay wouldn't render text properly.
• Fixed inconsistent y-flipping of textures for GL. It's still an inevitable mess, but slightly less of one now.
• Handle SOSetTargets() being called with a NULL list of buffers and non-zero buffer count, which is apparently valid and means each buffer is NULL.
• Fixes to cubemap rendering on GL not properly restoring FBO attachments as the right face. Also at the same time fixed some issues with array slices being bound to FBO attachments.
• On D3D11 only include matching mip/slice events in pixel history, and get the right before and after pixel values.
• Fixed handling of byte address buffers - name them properly, and detect them when reconstructing stripped reflection info.
• Handle a crash if StaticExports.GetVersionString() is not present when detecti...

Version v0.30

NOTE: There's a crash with certain saved UI layouts, if you had multiple mesh views open at once. If v0.30 crashes whenever you open it, delete %APPDATA%\renderdoc\DefaultLayout.config

I started working on RenderDoc in 2012 as a hobby project just working in my spare time. Now since June this year I've been contracting with Valve to focus full-time on RenderDoc, allowing significantly more work and improvement on the tool. I'm thankful to everyone who has helped me get here as I'm very privileged to be in this position.

In order to make sure that I do the best work I can and focus on what is important to people using the tool, I have put together a short survey to find out who is using the tool and why, as well as gather opinion on ways I'd like to improve the tool with better crash reporting and anonymous telemetry.

Please take a few minutes to fill out this anonymous survey

The survey is now complete! The results are now available

It will make a big difference to understand the answers to these questions so please fill it out. There's no personal information or login required, and all of the questions are optional. If you have any questions or concerns about the survey or anything else RenderDoc related, feel free to email me at any time and I'll be glad to help.

Version v0.30

As always downloads of this release are now up on the builds page.

Note that I've decided to retire the beta builds, since for the last several versions they have simply been in lockstep with the stable builds. They may return in a different form in future, but for now I've removed them from the page as they have no historical interest (compared to nightly builds at least), and the <1% of users on beta versions will be automatically prompted to update to the latest stable version if they don't do so manually.

This release brings a bunch of improved functionality to Vulkan, as well as smaller features and bug-fixes across the board including something that's been on the backburner for a while - display of view formats of typeless resources and view parameters like a sub-range of mips or slices. I'm not entirely sure if this implementation is ideal, so please give me feedback on what you think of it!

The in-application API has been updated to v1.1.0. Following semantic versioning this adds new functionality in a backwards compatible way - specifically the returned pointer to a function table contains an extra entry on the end, and since it's not caller allocated it is safely backwards compatible with v1.0.x code.

If you run into any problems, please open an issue or contact me to let me know - I can't fix what I don't know about!

Features/Improvements

• When a bound resource doesn't just bind the whole resource but a sub-set, or if the resource is bound as a different type than it actually is (format casting, or if the resource itself is typeless and always cast), this is highlighted in the pipeline state and a tooltip shows the difference.
  
  
• The source code has now been formatted by a .clang-format file to make for easier contributions (ie. without me nitpicking style problems).
• Added Vulkan support for immutable samplers
• Added Vulkan support for stepping through both multidraw (drawindirect with drawcount > 1) and secondary command buffers.
• Implement saving multisampled textures to disk in Vulkan.
• Added support for SPIR-V specialization constants.
• Implemented mesh picking for Vulkan.
• Implemented custom display shaders, and shader edit-and-replace for Vulkan.
• On vulkan, image initial states are kept as buffers in CPU memory to reduce the device memory requirements and lessen the chances of out of memory errors (necessary for capturing DOOM).
• For the moment on Vulkan, pretend to report only the single most capable queue and suppress the others, so that applications don't use multiple queues (also necessary for DOOM).
• Added pipeline export to HTML for GL.
• "Create Debug Device" capture option has been renamed to "API Validation" since it makes more sense cross-API.
• Return dummy/stub interface for ID3D11Debug the same as for ID3D11InfoQueue
• Added a button to zoom to 100% so that pixels are 1:1.
• The 'attach to running instance' dialog now shows running programs much faster rather than checking and waiting on the timeout for all possible programs before showing anything.
• Dragging an executable into the window anywhere will now pop it into the capture dialog, instead of trying to open it and complaining it's not a recognised capture log.
• Supported marker colours in the UI, which is used by the D3D11 and Vulkan marker extensions. This can be disabled in the options if e.g. your code passes only one colour for all markers (opaque and transparent black are ignored if all markers have the same colour).
  
• Added a mode to show all instances in a draw in the mesh output. Also adjusted the colouring between current instance, other instances, and previous draws to make it clear which mesh is which and avoid changing colours when viewing a single draw or viewing multiple.
• Add copy-paste support from shader debugger registers.
• Added support (largely untested though due to lack of samples!) for newer D3D11 (11.3 and 11.4) and DXGI (1.4 and 1.5) versions. If you run into bugs with this please let me know as there is little code using it, but at least this should allow proper capturing without crashes.
• The buffer viewer should now save its internal layout, so if you rearrange the 3D preview or data panels, it will remember that.
• Marker regions in the event viewer are now display the range of events they cover, not just the last one.
  
• For the separate unstripped shader debug info feature added in v0.28, allow relative paths to be matched up to search paths in the UI.
• Likewise this feature now supports lz4 compressing blobs, since they are often primarily text (containing source code) so they compress well.
• The documentation is now generated through reStructuredText and sphinx - thanks @Anteru!
• Added text file export of the entire event tree, to more easily batch-process.
• Image barriers are now displayed in the timeline bar, as well as in the resource usage drop-downs. The current image state is shown in a tooltip in the pipeline state view.
• Show the required size of a constant buffer vs the provided size, and highlight any that don't provide enough data.
• Better display of multisample count, byte/structured buffer type, and image swizzles in pipeline state.
• SNORM textures now display in the range [-1, 1] instead of [0, 1] by default.
• Added support for importing by ordinal on windows, which is needed for D3D12 hooking.
• Add a menu item to jump from a given pixel history event directly to the matching primitive.
  
• The renderdoccmd command line program has been revamped to have a more friendly and intuitive interface, and more useful options for e.g. launching programs specifying capture options or a working directory.
• Improved underlying technical work behind remote replay and capture, and running on linux in general. The UX still needs work though.
• Tweaked logging output to stdout/stderr not to include such long line prefixes.
• Added a SIGINT handler to linux to shut down the remote replay host cleanly.
• Added a feature to capture N successive frames. This won't necessarily help in some cases where bugs are timing related, as the frames will run very slow during capture. However it can be useful if it's known that a bug happens every second frame or so.
• Improved float formatting when in exponential notation, as previously it could print a lot of unnecessary trailing 0s.
• Add a small popup in the TextureViewer to go to a particular pixel. It's accessible in the toolbar, or via CTRL-G
  
• The buffer viewer (mesh or raw buffer view) will now try to size columns to fit likely content.
• When using per-texture settings (the default option), then the visualisation type (RGBA vs RGBM vs custom) and selected custom shader is also saved per-texture.
• Custom visualisation shaders are provided the selected slice as well as the selected sample from the UI. On GL, they are now also provided with [0, 1] UVs for convenience.

Bugfixes

• Fix an error where an update could fail if the renderdoc.dll module was injected into a program while the update process is on-going. This would commonly happen if the UI was launched from a program like the Unity or Unreal editor, and then the update was found. It left the UI and core module on inconsistent versions, which lead to crashes/bad behaviour.
• Fixed a long-standing bug where a Win32Exception could be thrown creating some handles. I still don't know what the problem is or why the fix works, but this seems to be corrected now by simply forcing handles to create at creation time instead of lazily.
• Several fixes for pixel history on D3D11 - a bug causing all events after the first failed pixel to be dropped, s...

Version v0.29

Binary downloads of this release are now up on the builds page.

Version v0.29

Since v0.28 was released a couple of weeks ago, a bug or two cropped up that were just on the border of being serious enough to warrant an urgent bugfix release. To that end v0.29 is a small release primarily aimed at patching those up as a number of people were running into at least one on v0.28 - a fatal error that happened when inspecting a D3D11 compute dispatch that used a structured buffer UAV.

It also brings with it support for the newly release VK_EXT_debug_marker extension for Vulkan, which allows common API debug functionality like naming objects and marking off regions of commands for hierarchical browsing.

There are a few other changes, so even if you're not hitting bugs in v0.28 it's worth updating. As always please get in touch if you run into any problems or have comments or suggestions to improve the tool!

Features/Improvements

• Support for VK_EXT_debug_marker in Vulkan.
• Added support for the 'create debug device' capture option in Vulkan. This will force-enable the validation layers, and display any debug messages recorded for the events and API calls in a frame.
• Object labels in GL applied to shaders, programs and pipelines will be displayed in the pipeline state view.
• When saving textures, updating the file type dropdown will change the filename (if present) to match the extension, and vice-versa when editing the filename box if the extension is changed it will update the file type dropdown.
• Some improvements to the new statistics pane added in v0.28.

Bugfixes

• Fix a fatal error that happened when inspecting a D3D11 compute dispatch that used a structured buffer UAV.
• Fixed a bug where a failed call to wglCreateContextAttribs (e.g. if requesting a higher version than is supported) would cause subsequent calls not to be hooked.
• Fixed a mistaken offset calculation when fetching constant buffer data into shader debugging on D3D11.
• Fix a divide by zero error if average framerate isn't yet calculated by first Present().
• When capturing manually without a swapchain, ensure that each capture has a frame number incrementing from 1, instead of all being frame 0.
• Fix a case where the profile mask could be missed when parsing the attribs list when creating a context in GL.
• Fix input layouts not being marked referenced when bound to the render state - causes them not to be included if they are bound at the start of the frame, but not bound in the frame.
• Handle VK_WHOLE_SIZE being passed as the memory range size in vkFlushMappedMemoryRanges
• Filter out unsupported Vulkan extensions before the application sees them.
• Don't replay with the Vulkan validation layers enabled even if the application enabled them.
• Ensure the WSI extensions are requested when replaying a Vulkan log even if the application didn't use WSI.
• Fix some erroneous warnings about descriptor sets not being bound when referenced by a shader.