diff --git a/.gitignore b/.gitignore
index cebf6775..4eb740d4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,5 @@ docs/traces/
 .vs/
 .cache
 .vimspector.json
+subprojects/.wraplock
+subprojects/pml.wrap
diff --git a/docs/env.md b/docs/env.md
index 874a77c2..df3c1955 100644
--- a/docs/env.md
+++ b/docs/env.md
@@ -46,6 +46,8 @@ Environment variables
   and counting the number of warnings errors. On windows, will allocate
   a console window to output to.
   Note that internal logs/asserts are disabled in release builds.
+- `VIL_LOG_FILE` can be set to a file path where vil will output its
+  log messages. By default, will simply output to stdout.
 
 - `VIL_WINDOW_MIN_FRAME_TIME=<time in ms>` when a window was created
   via `VIL_CREATE_WINDOW`, will throttle its framerate (if needed) to make
@@ -56,3 +58,10 @@ Environment variables
 - `VIL_WAIT_SURFACE={0, 1}`, default 0. Wait until the application has created
   a surface object until the window is initialized. Fixes window initialization
   for DXVK. If you have a compute-only application, this needs to be 0.
+
+- `VIL_ALLOW_UNSUPPORTED_EXTS={0, 1}`, default 0. When a vulkan instance/device
+  is created with an unsupported extension, vil will output and return an error
+  if this is not set to 1. If this is set to 1, vil still outputs an error
+  but does not fail device/instance creation.
+  Please note that running vil with unsupported extensions will likely
+  cause crashes and issues.
diff --git a/docs/features.md b/docs/features.md
index 733df59b..74027387 100644
--- a/docs/features.md
+++ b/docs/features.md
@@ -7,194 +7,7 @@ environment variable, it will significantly increase the chance that
 new extensions "just work", with a slight performance hit.
 See [env.md](env.md) for more details.
 
-## Vulkan 1.0
-
-Fully implemented.
-
-## Vulkan 1.1
-
-Implemented:
-- VK_KHR_descriptor_update_template
-  resources tab description is still TODO
-- VK_KHR_bind_memory2
-- vkCmdDispatchBase
-- VK_KHR_maintenance1 (e.g. vkTrimCommandPool)
-- VK_KHR_dedicated_allocation (not indicated in ui yet though)
-- VK_KHR_maintenance3 (nothing to do)
-
-Missing:
-- Anything with device masks is missing; using it will very likely crash.
-- no support for render pass multiview, VK_KHR_multiview
-- external memory, fences, semaphores
-- VK_KHR_maintenance2
-	- using the renderpass/imageView extensions might crash
-- ui: for YCbCr conversion handles not tracked/shown
-- ui: no support for variable pointers buffer
-
-## Vulkan 1.2
-
-Implemented:
-- VK_KHR_draw_indirect_count
-- VK_KHR_create_renderpass2
-- VK_KHR_buffer_device_address (introspection support WIP)
-	- known problem: synchronization problems when using the gui on
-	  commands/buffers using this feature. WIP
-- VK_KHR_imageless_framebuffer
-- VK_EXT_descriptor_indexing
-	- some edge cases with update_unused_while_pending are not properly
-	  tested yet, might need some changes.
-- VK_KHR_timeline_semaphore
-	- has some tricky edge cases (especially when application is really making
-	  use of out-of-order submission chaining), not yet tested a lot.
-
-missing:
-- extensions extending render passes (e.g. VK_KHR_depth_stencil_resolve)
-  using those might lead to crash.
-
-## Vulkan 1.3
-
-Implemented:
-- VK_KHR_copy_commands2
-- VK_EXT_extended_dynamic_state
-- VK_EXT_extended_dynamic_state2 (with extension-exclusive additions as well)
-- VK_KHR_dynamic_rendering (including hook/ui support)
-- VK_KHR_synchronization2
-
-Incomplete/missing:
-- VK_KHR_format_feature_flags2 (enum names)
-- VK_EXT_private_data
-- VK_EXT_subgroup_size_control (NOTE: might need changes to the way we
-  patch shaders, need to correctly forward pNext).
-- VK_EXT_texture_compression_astc_hdr (only enum names)
-- VK_EXT_4444_formats (only enum names)
-- VK_EXT_tooling_info (not sure if we should interact with it)
-
-no-op/shader exts that should be supported out of the box (as long
-as spirv-tools supports them):
-- VK_KHR_maintenance4 (no changes needed afaik)
-- VK_KHR_shader_subgroup_extended_types
-- VK_KHR_shader_non_semantic_info
-- VK_KHR_shader_terminate_invocation
-- VK_EXT_shader_demote_to_helper_invocation
-- VK_KHR_zero_initialize_workgroup_memory
-- VK_EXT_pipeline_creation_feedback
-- VK_EXT_image_robustness
-- VK_EXT_inline_uniform_block
-- VK_EXT_pipeline_creation_cache_control
-- VK_EXT_texel_buffer_alignment
-
-## Vulkan 1.4
-
-Implemented:
-- VK_KHR_map_memory2
-- VK_KHR_line_rasterization
-- VK_KHR_vertex_attribute_divisor
-
-Incomplete:
-- VK_KHR_maintenance5
-  allow to pass shader modules create info directly in pipeCreateInfo.pNext
-  missing UI support for new flags
-- VK_KHR_push_descriptor
-  No UI support, those descriptor won't show up, cannot be inspected
-- VK_EXT_vertex_attribute_divisor
-  need support in pipeline patch creation
-  probably an issue for many extensions that modify pipe creation
-- VK_KHR_maintenance6
-- VK_EXT_host_image_copy
-
-assumed no-op:
-- VK_KHR_shader_expect_assume
-- VK_KHR_shader_float_controls2
-- VK_KHR_shader_subgroup_rotate
-- VK_KHR_load_store_op_none
-
-## Non-core extensions
-
-Extensions promoted to core not explicitly mentioned here, see above.
-Supported extensions:
-
-- VK_KHR_surface, VK_KHR_swapchain
-- VK_EXT_debug_utils
-- VK_KHR_surface (tested overlay platforms: xlib, xcb, win32)
-	- other platforms should work without crash at least
-
-supported but no/incomplete gui interaction/information:
-- VK_KHR_acceleration_structure
-- VK_KHR_ray_tracing_pipeline
-- VK_EXT_extended_dynamic_state
-- VK_EXT_line_rasterization
-- VK_KHR_draw_indirect_count
-- VK_EXT_sample_locations
-- VK_EXT_discard_rectangles
-- VK_EXT_vertex_input_dynamic_state
-- VK_EXT_color_write_enable
-- VK_EXT_multi_draw
-
-Extensions that just add new features or flags shouldn't need any
-support by the layer but may have incomplete introspection. New functions
-on physical device are usually also not a problem.
-For instance:
-- VK_EXT_conservative_rasterization
-- VK_EXT_custom_border_color
-- VK_EXT_depth_clip_enable
-- VK_EXT_depth_range_unrestricted
-- VK_EXT_device_memory_report
-- VK_NV_cooperative_matrix
-
-Extensions that just add SPIR-V features shouldn't be a problem in general
-as long as SPIRV-Tools supports it.
-For instance:
-- VK_KHR_ray_query
-- VK_KHR_workgroup_memory_explicit_layout
-- VK_KHR_zero_initialize_workgroup_memory
-- VK_KHR_shader_clock
-- VK_KHR_vulkan_memory_model
-- VK_EXT_fragment_shader_interlock
-- VK_EXT_post_depth_coverage
-- VK_EXT_shader_atomic_float
-- VK_EXT_shader_demote_to_helper_invocation
-- VK_AMD_shader_fragment_mask
-- VK_AMD_texture_gather_bias_lod
-- VK_INTEL_shader_integer_functions2
-- 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_sm_builtins
-- VK_NV_viewport_array2
-- VK_KHR_16bit_storage
-- VK_KHR_8bit_storage
-- VK_KHR_shader_atomic_int64
-- VK_KHR_shader_float16_int8
-- VK_KHR_shader_subgroup_extended_types
-- VK_KHR_spirv_1_4
-- VK_KHR_storage_buffer_storage_class
-- VK_KHR_variable_pointers
-- VK_EXT_scalar_block_layout
-- VK_EXT_shader_subgroup_ballot
-
-The shader debugger does not work with most spirv extensions yet, though.
-
-## Missing extensions
-
-Using these extensions will likely cause a crash.
-
-- VK_EXT_transform_feedback
-- VK_AMD_buffer_marker
-- VK_NV_device_diagnostic_checkpoints
-- VK_NV_scissor_exclusive
-- VK_NV_mesh_shader
-- VK_INTEL_performance_query
-- VK_NV_shading_rate_image
-- VK_NV_fragment_shading_rate_enums
-- VK_NV_device_generated_commands
-- The old NV raytracing extensions. They also won't be supported in the future,
-  use the KHR extensions instead.
-- VK_EXT_descriptor_buffer
-
-- VK_EXT_extended_dynamic_state3
-- VK_EXT_shader_object (incomplete support)
+For a list of supported/unsupported extensions, see [exts.hpp](../src/exts.hpp).
 
 ## NOTES:
 - vendor-specific extensions are generally not a focus, unless someone
@@ -208,7 +21,6 @@ Using these extensions will likely cause a crash.
   layer itself is using it for the vertex viewer (which would conflict with
   an application-side use of it). It's only supposed to be used by tools/layers
   anyways.
-
 - Extensions that have significant changes to command recording (such as
   new pipeline bind points or new commands) will very likely always lead to
   significant problems. Implementing basic support for them isn't complicated
diff --git a/docs/own/workstack.md b/docs/own/workstack.md
index 065035f1..280175e4 100644
--- a/docs/own/workstack.md
+++ b/docs/own/workstack.md
@@ -1,5 +1,15 @@
+- [ ] try to enable bufferDeviceAddress
+- [ ] fix errors with validation tests
+	- [ ] document how to run validation tests
+- [ ] when VIL_SKIP_EXT_CHECK is set (or other env var?) override supported
+      extensions in that function. Investigate how to make this work.
+	  Can be provided in layer manifest or something?
+
+- [ ] implement VK_KHR_dynamic_rendering_local_read for core 1.4
+- [ ] impement VK_KHR_pipeline_executable_properties
 - [ ] fix invalid pipeline barrier with BeginRendering (test e.g. with iro gpuDebugDraw)
 - [ ] fix vulkan samples "Losing open cmd" with trianglevulkan13
+- [ ] copyChain: add functions for proper deep copying
 
 - [ ] Format weird for (RW)ByteAddressBuffers in hlsl/slang
 	- [ ] in that case, allow to explicitly specify the format to be printed.
diff --git a/docs/vulkan_tools_helper_file_generator.py b/docs/vulkan_tools_helper_file_generator.py
new file mode 100644
index 00000000..f04bdcef
--- /dev/null
+++ b/docs/vulkan_tools_helper_file_generator.py
@@ -0,0 +1,196 @@
+#!/usr/bin/python3 -i
+#
+# Copyright (c) 2015-2021 The Khronos Group Inc.
+# Copyright (c) 2015-2021 Valve Corporation
+# Copyright (c) 2015-2021 LunarG, Inc.
+# Copyright (c) 2015-2021 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Author: Mark Lobodzinski <mark@lunarg.com>
+# Author: Tobin Ehlis <tobine@google.com>
+# Author: John Zulauf <jzulauf@lunarg.com>
+#
+# NOTE: adjusted for vil, added dynamic dispatch overload at the bottom.
+# Just copy this into the Vulkan-Tools repository and generate the typemap_helper.h file
+
+from base_generator import BaseGenerator
+
+# HelperFileOutputGenerator - subclass of OutputGenerator. Outputs Vulkan helper files
+class HelperFileOutputGenerator(BaseGenerator):
+    def __init__(self):
+        BaseGenerator.__init__(self)
+
+
+    def generate(self):
+        out = []
+
+        # File Comment
+        out.append('// *** THIS FILE IS GENERATED - DO NOT EDIT ***\n')
+        out.append('// See vulkan_tools_helper_file_generator.py for modifications\n')
+
+        # Copyright Notice
+        out.append('''
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ * Copyright (c) 2015-2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ * Author: Courtney Goeltzenleuchter <courtneygo@google.com>
+ * Author: Tobin Ehlis <tobine@google.com>
+ * Author: Chris Forbes <chrisforbes@google.com>
+ * Author: John Zulauf<jzulauf@lunarg.com>
+ *
+ ****************************************************************************/
+                   ''')
+
+        # Generate header
+        out.append('''
+#pragma once
+#include <vulkan/vulkan.h>
+
+// These empty generic templates are specialized for each type with sType
+// members and for each sType -- providing a two way map between structure
+// types and sTypes
+
+template <VkStructureType id> struct LvlSTypeMap {};
+template <typename T> struct LvlTypeMap {};
+
+                   ''')
+
+        # Generate the specializations for each type and stype
+        for struct in self.vk.structs.values():
+            if struct.sType is None:
+                continue
+
+            if struct.protect is not None:
+                out.append(f'#ifdef {struct.protect}\n')
+
+            out.append(f'// Map type {struct.name} to id {struct.sType}\n')
+            out.append(f'template <> struct LvlTypeMap<{struct.name}> {{\n')
+            out.append(f'    static const VkStructureType kSType = {struct.sType};\n')
+            out.append('};\n\n')
+
+
+            out.append(f'template <> struct LvlSTypeMap<{struct.sType}> {{\n')
+            out.append(f'    typedef {struct.name} Type;\n')
+            out.append('};\n\n')
+
+            if struct.protect is not None:
+                out.append(f'#endif // {struct.protect}\n')
+
+ # Define the utilities (here so any renaming stays consistent), if this grows large, refactor to a fixed .h file
+
+        out.append('''// Header "base class" for pNext chain traversal
+struct LvlGenericHeader {
+   VkStructureType sType;
+   const LvlGenericHeader *pNext;
+};
+struct LvlGenericModHeader {
+   VkStructureType sType;
+   LvlGenericModHeader *pNext;
+};
+
+// Find an entry of the given type in the pNext chain
+template <typename T> const T *lvl_find_in_chain(const void *next) {
+    const LvlGenericHeader *current = reinterpret_cast<const LvlGenericHeader *>(next);
+    const T *found = nullptr;
+    while (current) {
+        if (LvlTypeMap<T>::kSType == current->sType) {
+            found = reinterpret_cast<const T*>(current);
+            current = nullptr;
+        } else {
+            current = current->pNext;
+        }
+    }
+    return found;
+}
+// Find an entry of the given type in the pNext chain
+template <typename T> T *lvl_find_mod_in_chain(void *next) {
+    LvlGenericModHeader *current = reinterpret_cast<LvlGenericModHeader *>(next);
+    T *found = nullptr;
+    while (current) {
+        if (LvlTypeMap<T>::kSType == current->sType) {
+            found = reinterpret_cast<T*>(current);
+            current = nullptr;
+        } else {
+            current = current->pNext;
+        }
+    }
+    return found;
+}
+
+// Init the header of an sType struct with pNext
+template <typename T> T lvl_init_struct(void *p_next) {
+    T out = {};
+    out.sType = LvlTypeMap<T>::kSType;
+    out.pNext = p_next;
+    return out;
+}
+
+// Init the header of an sType struct
+template <typename T> T lvl_init_struct() {
+    T out = {};
+    out.sType = LvlTypeMap<T>::kSType;
+    return out;
+}
+
+''')
+
+        # Large switch for dynamic dispatch
+
+        out.append('''
+// Switch statement
+template<typename F> bool castCall(const LvlGenericHeader& header, F&& f)
+{
+    switch(header.sType)
+    {
+           ''')
+
+        for struct in self.vk.structs.values():
+            if struct.sType is None:
+                continue
+
+            if struct.protect is not None:
+                out.append(f'#ifdef {struct.protect}\n')
+
+            out.append(f'\tcase {struct.sType}: f(reinterpret_cast<const {struct.name}&>(header)); return true;\n')
+
+            if struct.protect is not None:
+                out.append(f'#endif // {struct.protect}\n')
+
+        out.append('''
+    default: return false;
+    }
+}
+                   ''')
+
+
+        self.write(''.join(out))
+
diff --git a/meson.build b/meson.build
index af5bc475..b967a434 100644
--- a/meson.build
+++ b/meson.build
@@ -432,6 +432,7 @@ endif
 with_integration_tests = get_option('integration-tests')
 if with_integration_tests
 	src += files(
+		'src/test/bugged.cpp',
 		'src/test/integration/entry.cpp',
 		'src/test/integration/internal.cpp', # TODO: rename
 		'src/test/integration/gui.cpp',
diff --git a/src/buffer.cpp b/src/buffer.cpp
index 5b3635af..5ca3031a 100644
--- a/src/buffer.cpp
+++ b/src/buffer.cpp
@@ -60,8 +60,7 @@ void Buffer::onApiDestroy() {
 
 	std::lock_guard lock(dev->mutex);
 	if(ci.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
-		auto num = dev->bufferAddresses.erase(this);
-		dlg_assert(num == 1u);
+		dev->bufferAddresses.erase(this);
 	}
 
 	for(auto* view : this->views) {
@@ -106,12 +105,6 @@ void retrieveDeviceAddress(Buffer& buf) {
 	dev.bufferAddresses.insert(&buf);
 }
 
-void checkDeviceAddress(Buffer& buf) {
-	if(buf.ci.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
-		retrieveDeviceAddress(buf);
-	}
-}
-
 // API
 VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(
 		VkDevice                                    device,
@@ -158,11 +151,6 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(
 
 	if(buf.ci.flags & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) {
 		buf.memory = SparseMemoryState{};
-
-		// for non-sparse buffer, the device address can only be retrieved when
-		// its bound to memory, but for non-sparse buffers it can be retrieved
-		// immediately
-		checkDeviceAddress(buf);
 	}
 
 	constexpr auto sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
@@ -244,15 +232,15 @@ VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(
 		VkDeviceSize                                memoryOffset) {
 	auto& buf = get(device, buffer);
 	auto& mem = get(*buf.dev, memory);
-	bindBufferMemory(buf, mem, memoryOffset);
 
 	auto res = buf.dev->dispatch.BindBufferMemory(buf.dev->handle,
-		buf.handle, memory, memoryOffset);
+		buf.handle, mem.handle, memoryOffset);
 	if(res != VK_SUCCESS) {
 		return res;
 	}
 
-	checkDeviceAddress(buf);
+	bindBufferMemory(buf, mem, memoryOffset);
+
 	return VK_SUCCESS;
 }
 
@@ -276,9 +264,8 @@ VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(
 		// could be VK_NULL_HANDLE for extensions
 		// e.g. the case for BindImageMemory2, we add this branch
 		// here defensively
-		if(bind.memory) {
+		if (fwd[i].memory) {
 			auto& mem = get(dev, bind.memory);
-			bindBufferMemory(buf, mem, bind.memoryOffset);
 			fwd[i].memory = mem.handle;
 		}
 	}
@@ -291,7 +278,11 @@ VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(
 	for(auto i = 0u; i < bindInfoCount; ++i) {
 		auto& bind = pBindInfos[i];
 		auto& buf = get(dev, bind.buffer);
-		checkDeviceAddress(buf);
+
+		if(bind.memory) {
+			auto& mem = get(dev, bind.memory);
+			bindBufferMemory(buf, mem, bind.memoryOffset);
+		}
 	}
 
 	return VK_SUCCESS;
@@ -347,26 +338,20 @@ VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress(
 		VkDevice                                    device,
 		const VkBufferDeviceAddressInfo*            pInfo) {
 	auto& buf = get(device, pInfo->buffer);
-	dlg_assert(buf.ci.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT);
 
 	auto fwd = *pInfo;
 	fwd.buffer = buf.handle;
-	auto ret = buf.dev->dispatch.GetBufferDeviceAddressKHR(buf.dev->handle, &fwd);
+	auto ret = buf.dev->dispatch.GetBufferDeviceAddress(buf.dev->handle, &fwd);
 
-	// This is a sign of a serious problem, we might have missed to retrieve
-	// it at the right point. We try to insert it now, in the hope that
-	// this avoid further problems
 	if(ret != buf.deviceAddress) {
-		dlg_error("Inconsistent/Unknown device address retrieved");
-
-		if(buf.deviceAddress) {
-			// We already retrieved a (different) device addres?!
-			// This makes no sense at all, we can't even try to fix the
-			// issue in this case.
-			dlg_error("Different device address retrieved?!");
-		} else {
-			retrieveDeviceAddress(buf);
-			dlg_assert(ret == buf.deviceAddress);
+		// This is a sign of a serious problem.
+		dlg_assertm(!buf.deviceAddress, "Inconsistent/Unknown device address retrieved");
+
+		if (!buf.deviceAddress) {
+			auto& dev = *buf.dev;
+			std::lock_guard lock(dev.mutex);
+			buf.deviceAddress = ret;
+			dev.bufferAddresses.insert(&buf);
 		}
 	}
 
@@ -382,7 +367,7 @@ VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress(
 	auto& buf = get(device, pInfo->buffer);
 	auto fwd = *pInfo;
 	fwd.buffer = buf.handle;
-	return buf.dev->dispatch.GetBufferOpaqueCaptureAddressKHR(buf.dev->handle, &fwd);
+	return buf.dev->dispatch.GetBufferOpaqueCaptureAddress(buf.dev->handle, &fwd);
 }
 
 VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress(
@@ -391,7 +376,7 @@ VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress(
 	auto& mem = get(device, pInfo->memory);
 	auto fwd = *pInfo;
 	fwd.memory = mem.handle;
-	return mem.dev->dispatch.GetDeviceMemoryOpaqueCaptureAddressKHR(mem.dev->handle, &fwd);
+	return mem.dev->dispatch.GetDeviceMemoryOpaqueCaptureAddress(mem.dev->handle, &fwd);
 }
 
 } // namespace vil
diff --git a/src/buffer.hpp b/src/buffer.hpp
index 300afa3b..9024527c 100644
--- a/src/buffer.hpp
+++ b/src/buffer.hpp
@@ -16,7 +16,7 @@ struct Buffer : MemoryResource {
 	bool externalMemory {}; // whether it supports importing/exporting
 
 	std::vector<BufferView*> views;
-	VkDeviceAddress deviceAddress {}; // null if not available
+	VkDeviceAddress deviceAddress {}; // lazily retrieved when application does
 
 	~Buffer();
 	void onApiDestroy();
diff --git a/src/cb.cpp b/src/cb.cpp
index 92c90476..af2a4f5a 100644
--- a/src/cb.cpp
+++ b/src/cb.cpp
@@ -100,6 +100,17 @@ void DescriptorState::bind(CommandBuffer& cb, PipelineLayout& layout, u32 firstS
 
 	for(auto i = 0u; i < sets.size(); ++i) {
 		auto s = firstSet + i;
+		if (!sets[i]) {
+#ifdef DS_DISTURB_CHECKS
+			if(!descriptorSets[s].layout) {
+				followingDisturbed = true;
+			}
+#endif // DS_DISTURB_CHECKS
+
+			descriptorSets[i] = {};
+			continue;
+		}
+
 		auto& dsLayout = *layout.descriptors[s];
 
 #ifdef DS_DISTURB_CHECKS
@@ -1125,6 +1136,12 @@ VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(
 	ThreadMemScope memScope;
 	auto setHandles = memScope.allocUndef<VkDescriptorSet>(descriptorSetCount);
 	for(auto i = 0u; i < descriptorSetCount; ++i) {
+		if(!pDescriptorSets[i]) { // null handles are allowed
+			cmd.sets[i] = nullptr;
+			setHandles[i] = {};
+			continue;
+		}
+
 		auto& ds = get(*cb.dev, pDescriptorSets[i]);
 
 		cmd.sets[i] = &ds;
@@ -2520,10 +2537,10 @@ void handlePushDescriptor(CommandBuffer& cb, Command& cmd,
 				useHandle(cb, cmd, buf);
 
 				for(auto& dstState : descriptorStates) {
-					auto dstBuffers = buffers(dstState, write.dstBinding);
-					dstBuffers[write.dstArrayElement + i].buffer = &buf;
-					dstBuffers[write.dstArrayElement + i].offset = copies[i].offset;
-					dstBuffers[write.dstArrayElement + i].range = copies[i].range;
+					auto& dstBuffer = dsBuffer(dstState, write.dstBinding, write.dstArrayElement + i);
+					dstBuffer.buffer = &buf;
+					dstBuffer.offset = copies[i].offset;
+					dstBuffer.range = copies[i].range;
 				}
 			}
 			write.pBufferInfo = copies;
@@ -2549,10 +2566,10 @@ void handlePushDescriptor(CommandBuffer& cb, Command& cmd,
 				}
 
 				for(auto& dstState : descriptorStates) {
-					auto dstImages = images(dstState, write.dstBinding);
-					dstImages[write.dstArrayElement + i].imageView = iv;
-					dstImages[write.dstArrayElement + i].sampler = sampler;
-					dstImages[write.dstArrayElement + i].layout = copies[i].imageLayout;
+					auto& dstImage = dsImage(dstState, write.dstBinding, write.dstArrayElement + i);
+					dstImage.imageView = iv;
+					dstImage.sampler = sampler;
+					dstImage.layout = copies[i].imageLayout;
 				}
 			}
 			write.pImageInfo = copies;
@@ -2568,8 +2585,8 @@ void handlePushDescriptor(CommandBuffer& cb, Command& cmd,
 				useHandle(cb, cmd, bv);
 
 				for(auto& dstState : descriptorStates) {
-					auto dstBufViews = bufferViews(dstState, write.dstBinding);
-					dstBufViews[write.dstArrayElement + i].bufferView = &bv;
+					auto& dstBufViews = dsBufferView(dstState, write.dstBinding, write.dstArrayElement + i);
+					dstBufViews.bufferView = &bv;
 				}
 			}
 			write.pTexelBufferView = copies;
@@ -2590,8 +2607,8 @@ void handlePushDescriptor(CommandBuffer& cb, Command& cmd,
 				useHandle(cb, cmd, as);
 
 				for(auto& dstState : descriptorStates) {
-					auto dstAccelStructs = accelStructs(dstState, write.dstBinding);
-					dstAccelStructs[write.dstArrayElement + i].accelStruct = &as;
+					auto& dstAccelStruct = dsAccelStruct(dstState, write.dstBinding, write.dstArrayElement + i);
+					dstAccelStruct.accelStruct = &as;
 				}
 			}
 			accelStructWrite->pAccelerationStructures = copies;
@@ -4143,6 +4160,12 @@ VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT(
 		const VkBuffer*                             pBuffers,
 		const VkDeviceSize*                         pOffsets,
 		const VkDeviceSize*                         pSizes) {
+	(void) commandBuffer;
+	(void) firstBinding;
+	(void) bindingCount;
+	(void) pBuffers;
+	(void) pOffsets;
+	(void) pSizes;
 	dlg_error("unimplemented");
 }
 
@@ -4152,6 +4175,11 @@ VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT(
 		uint32_t                                    counterBufferCount,
 		const VkBuffer*                             pCounterBuffers,
 		const VkDeviceSize*                         pCounterBufferOffsets) {
+	(void) commandBuffer;
+	(void) firstCounterBuffer;
+	(void) counterBufferCount;
+	(void) pCounterBuffers;
+	(void) pCounterBufferOffsets;
 	dlg_error("unimplemented");
 }
 
@@ -4161,6 +4189,11 @@ VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT(
 		uint32_t                                    counterBufferCount,
 		const VkBuffer*                             pCounterBuffers,
 		const VkDeviceSize*                         pCounterBufferOffsets) {
+	(void) commandBuffer;
+	(void) firstCounterBuffer;
+	(void) counterBufferCount;
+	(void) pCounterBuffers;
+	(void) pCounterBufferOffsets;
 	dlg_error("unimplemented");
 }
 
@@ -4170,6 +4203,11 @@ VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT(
 		uint32_t                                    query,
 		VkQueryControlFlags                         flags,
 		uint32_t                                    index) {
+	(void) commandBuffer;
+	(void) queryPool;
+	(void) query;
+	(void) flags;
+	(void) index;
 	dlg_error("unimplemented");
 }
 
@@ -4178,6 +4216,10 @@ VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT(
 		VkQueryPool                                 queryPool,
 		uint32_t                                    query,
 		uint32_t                                    index) {
+	(void) commandBuffer;
+	(void) queryPool;
+	(void) query;
+	(void) index;
 	dlg_error("unimplemented");
 }
 
@@ -4189,6 +4231,13 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT(
 		VkDeviceSize                                counterBufferOffset,
 		uint32_t                                    counterOffset,
 		uint32_t                                    vertexStride) {
+	(void) commandBuffer;
+	(void) instanceCount;
+	(void) firstInstance;
+	(void) counterBuffer;
+	(void) counterBufferOffset;
+	(void) counterOffset;
+	(void) vertexStride;
 	dlg_error("unimplemented");
 }
 
diff --git a/src/command/match.cpp b/src/command/match.cpp
index 6a3b643a..18e162e1 100644
--- a/src/command/match.cpp
+++ b/src/command/match.cpp
@@ -662,37 +662,52 @@ MatchVal match(MatchType mt, const DescriptorStateRef& a, const DescriptorStateR
 		auto sizeA = descriptorCount(a, bindingID);
 		auto sizeB = descriptorCount(b, bindingID);
 
-		if(sizeA == 0u || sizeB == 0u) {
+		auto& layoutA = a.layout->bindings[bindingID];
+		auto& layoutB = b.layout->bindings[bindingID];
+
+		if(layoutA.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
+			sizeA = 1u;
+		}
+		if(layoutB.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
+			sizeB = 1u;
+		}
+
+		m.total += std::max(sizeA, sizeB);
+
+		if(layoutA.descriptorType != layoutB.descriptorType) {
 			continue;
 		}
 
-		// must have the same type
-		auto dsType = a.layout->bindings[bindingID].descriptorType;
-		dlg_assert_or(a.layout->bindings[bindingID].descriptorType ==
-			b.layout->bindings[bindingID].descriptorType, continue);
-
-		if(dsType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) {
-			// This might seem like a low weight but the bytewise
-			// comparison isn't the best anyways. Counting the number
-			// of equal bytes or weighing this by the block size
-			// would be bad.
-			m.total += 1;
-		} else {
-			// sizeA might not be the same as sizeB for variable descriptor counts
-			m.total += std::max(sizeA, sizeB);
+		if(layoutA.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
+			auto bytesA = inlineUniformBlock(a, bindingID);
+			auto bytesB = inlineUniformBlock(b, bindingID);
+			if(bytesA.size() == bytesB.size() &&
+					std::memcmp(bytesA.data(), bytesB.data(), bytesA.size()) == 0) {
+				++m.match;
+			}
+
+			continue;
 		}
 
-		// if samplers or image/buffers views are different we check them for
-		// semantic equality as well. Applications sometimes create
-		// them lazily/on-demand or stuff like that.
+		for(auto elemID = 0u; elemID < std::min(sizeA, sizeB); ++elemID) {
+			// check again for mutable descriptor type
+			auto typeA = descriptorType(a, bindingID, elemID);
+			auto typeB = descriptorType(b, bindingID, elemID);
+
+			if(typeA != typeB) {
+				continue;
+			}
+
+			auto dsType = typeA;
+
+			// if samplers or image/buffers views are different we check them for
+			// semantic equality as well. Applications sometimes create
+			// them lazily/on-demand or stuff like that.
 
-		auto dsCat = vil::category(dsType);
-		if(dsCat == DescriptorCategory::image) {
-			auto bindingsA = images(a, bindingID);
-			auto bindingsB = images(b, bindingID);
-			for(auto e = 0u; e < std::min(sizeA, sizeB); ++e) {
-				auto& bindA = bindingsA[e];
-				auto& bindB = bindingsB[e];
+			auto dsCat = vil::category(typeA);
+			if(dsCat == DescriptorCategory::image) {
+				auto& bindA = dsImage(a, bindingID, elemID);
+				auto& bindB = dsImage(b, bindingID, elemID);
 
 				MatchVal combined;
 
@@ -726,13 +741,9 @@ MatchVal match(MatchType mt, const DescriptorStateRef& a, const DescriptorStateR
 
 				// NOTE: consider image layout? not too relevant I guess
 				m.match += eval(combined);
-			}
-		} else if(dsCat == DescriptorCategory::buffer) {
-			auto bindingsA = buffers(a, bindingID);
-			auto bindingsB = buffers(b, bindingID);
-			for(auto e = 0u; e < std::min(sizeA, sizeB); ++e) {
-				auto& bindA = bindingsA[e];
-				auto& bindB = bindingsB[e];
+			} else if(dsCat == DescriptorCategory::buffer) {
+				auto& bindA = dsBuffer(a, bindingID, elemID);
+				auto& bindB = dsBuffer(b, bindingID, elemID);
 
 				auto bufMatch = match(mt, bindA.buffer, bindB.buffer);
 				if(!noMatch(bufMatch)) {
@@ -740,31 +751,23 @@ MatchVal match(MatchType mt, const DescriptorStateRef& a, const DescriptorStateR
 					add(bufMatch, bindA.range, bindB.range);
 					m.match += eval(bufMatch);
 				}
-			}
-		} else if(dsCat == DescriptorCategory::bufferView) {
-			auto bindingsA = bufferViews(a, bindingID);
-			auto bindingsB = bufferViews(b, bindingID);
-			for(auto e = 0u; e < std::min(sizeA, sizeB); ++e) {
-				auto bvMatch = match(mt, bindingsA[e].bufferView, bindingsB[e].bufferView);
+			} else if(dsCat == DescriptorCategory::bufferView) {
+				auto* handleA = dsBufferView(a, bindingID, elemID).bufferView;
+				auto* handleB = dsBufferView(b, bindingID, elemID).bufferView;
+				auto bvMatch = match(mt, handleA, handleB);
 				m.match += eval(bvMatch);
-			}
-		} else if(dsCat == DescriptorCategory::accelStruct) {
-			auto bindingsA = accelStructs(a, bindingID);
-			auto bindingsB = accelStructs(b, bindingID);
-			for(auto e = 0u; e < std::min(sizeA, sizeB); ++e) {
-				auto asMatch = match(mt, bindingsA[e].accelStruct, bindingsB[e].accelStruct);
+			} else if(dsCat == DescriptorCategory::accelStruct) {
+				auto* handleA = dsAccelStruct(a, bindingID, elemID).accelStruct;
+				auto* handleB = dsAccelStruct(b, bindingID, elemID).accelStruct;
+				auto asMatch = match(mt, handleA, handleB);
 				m.match += eval(asMatch);
+			} else if(dsCat == DescriptorCategory::inlineUniformBlock) {
+				dlg_error("unreahable!");
+			} else {
+				dlg_error("Unsupported descriptor type: {}", u32(dsType));
 			}
-		} else if(dsCat == DescriptorCategory::inlineUniformBlock) {
-			auto bytesA = inlineUniformBlock(a, bindingID);
-			auto bytesB = inlineUniformBlock(b, bindingID);
-			if(bytesA.size() == bytesB.size() &&
-					std::memcmp(bytesA.data(), bytesB.data(), bytesA.size()) == 0) {
-				++m.match;
-			}
-		} else {
-			dlg_error("Unsupported descriptor type: {}", u32(dsType));
 		}
+
 	}
 
 	// TODO: account in matcher for non-overlapping bindings?
diff --git a/src/command/record.cpp b/src/command/record.cpp
index b28b714f..22ae7bf3 100644
--- a/src/command/record.cpp
+++ b/src/command/record.cpp
@@ -105,43 +105,49 @@ void bindPushDescriptors(Device& dev, VkCommandBuffer cb, VkPipelineBindPoint bb
 
 	ThreadMemScope tms;
 	auto writes = tms.alloc<VkWriteDescriptorSet>(dsLayout->bindings.size());
-	for(auto [i, bindingLayout] : enumerate(dsLayout->bindings)) {
-		auto& dst = writes[i];
+	for(auto [b, bindingLayout] : enumerate(dsLayout->bindings)) {
+		// TODO FIXME: would require rewrite of code below: first iterate
+		// over elements, then switch over descriptor type.
+		dlg_assertm(!(bindingLayout.descriptorType & VK_DESCRIPTOR_TYPE_MUTABLE_EXT),
+			"Mutable push descriptors not supported at the moment");
+
+		auto& dst = writes[b];
 
 		dst = {};
 		dst.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 		dst.descriptorType = bindingLayout.descriptorType;
-		dst.dstBinding = i;
+		dst.dstBinding = b;
 		dst.descriptorCount = bindingLayout.descriptorCount;
 
 		switch(category(dst.descriptorType)) {
 			case DescriptorCategory::buffer: {
 				auto dstBufs = tms.alloc<VkDescriptorBufferInfo>(dst.descriptorCount);
-				auto srcBufs = buffers(dsData, i);
 				for(auto i = 0u; i < dst.descriptorCount; ++i) {
-					auto* buf = srcBufs[i].buffer; dstBufs[i].buffer = buf ? buf->handle : VK_NULL_HANDLE;
-					dstBufs[i].offset = srcBufs[i].offset;
-					dstBufs[i].range = srcBufs[i].range;
+					auto& srcBuf = dsBuffer(dsData, b, i);
+					auto* buf = srcBuf.buffer;
+					dstBufs[i].buffer = buf ? buf->handle : VK_NULL_HANDLE;
+					dstBufs[i].offset = srcBuf.offset;
+					dstBufs[i].range = srcBuf.range;
 				}
 				dst.pBufferInfo = dstBufs.data();
 				break;
 			} case DescriptorCategory::image: {
 				auto dstImages = tms.alloc<VkDescriptorImageInfo>(dst.descriptorCount);
-				auto srcImages = images(dsData, i);
 				for(auto i = 0u; i < dst.descriptorCount; ++i) {
-					auto* iv = srcImages[i].imageView;
-					auto* sampler = srcImages[i].sampler;
+					auto& srcImage = dsImage(dsData, b, i);
+					auto* iv = srcImage.imageView;
+					auto* sampler = srcImage.sampler;
 					dstImages[i].imageView = iv ? iv->handle : VK_NULL_HANDLE;
 					dstImages[i].sampler = sampler ? sampler->handle : VK_NULL_HANDLE;
-					dstImages[i].imageLayout = srcImages[i].layout;
+					dstImages[i].imageLayout = srcImage.layout;
 				}
 				dst.pImageInfo = dstImages.data();
 				break;
 			} case DescriptorCategory::bufferView: {
 				auto dstViews = tms.alloc<VkBufferView>(dst.descriptorCount);
-				auto srcViews = bufferViews(dsData, i);
 				for(auto i = 0u; i < dst.descriptorCount; ++i) {
-					auto* bv = srcViews[i].bufferView;
+					auto& srcView = dsBufferView(dsData, b, i);
+					auto* bv = srcView.bufferView;
 					dstViews[i] = bv ? bv->handle : VK_NULL_HANDLE;
 				}
 				dst.pTexelBufferView = dstViews.data();
@@ -151,9 +157,9 @@ void bindPushDescriptors(Device& dev, VkCommandBuffer cb, VkPipelineBindPoint bb
 				asWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR;
 
 				auto dstAS = tms.alloc<VkAccelerationStructureKHR>(dst.descriptorCount);
-				auto srcAS = accelStructs(dsData, i);
 				for(auto i = 0u; i < dst.descriptorCount; ++i) {
-					auto* as = srcAS[i].accelStruct;
+					auto& srcAS = dsAccelStruct(dsData, b, i);
+					auto* as = srcAS.accelStruct;
 					dstAS[i] = as ? as->handle : VK_NULL_HANDLE;
 				}
 
diff --git a/src/commandHook/hook.cpp b/src/commandHook/hook.cpp
index 0ddda1db..f890c9c4 100644
--- a/src/commandHook/hook.cpp
+++ b/src/commandHook/hook.cpp
@@ -86,14 +86,20 @@ bool copyableDescriptorSame(DescriptorStateRef a, DescriptorStateRef b,
 	dlg_assert(bindingID < a.layout->bindings.size());
 	dlg_assert(elemID < descriptorCount(a, bindingID));
 
-	auto& lbinding = a.layout->bindings[bindingID];
-	auto cat = category(lbinding.descriptorType);
+	auto aType = descriptorType(a, bindingID, elemID);
+	auto bType = descriptorType(b, bindingID, elemID);
+
+	if(aType != bType) {
+			return false;
+	}
+
+	auto cat = category(aType);
 	if(cat == DescriptorCategory::image) {
-		return images(a, bindingID)[elemID] == images(b, bindingID)[elemID];
+		return dsImage(a, bindingID, elemID) == dsImage(b, bindingID, elemID);
 	} else if(cat == DescriptorCategory::buffer) {
-		return buffers(a, bindingID)[elemID] == buffers(b, bindingID)[elemID];
+		return dsBuffer(a, bindingID, elemID) == dsBuffer(b, bindingID, elemID);
 	} else if(cat == DescriptorCategory::bufferView) {
-		return bufferViews(a, bindingID)[elemID] == bufferViews(b, bindingID)[elemID];
+		return dsBufferView(a, bindingID, elemID) == dsBufferView(b, bindingID, elemID);
 	} else if(cat == DescriptorCategory::accelStruct) {
 		// TODO: do we need to copy acceleration structues? Might be hard
 		// to do correctly; should use copy-on-write. Not sure if worth it at all.
@@ -142,13 +148,15 @@ CommandHook::CommandHook(Device& dev) {
 	}
 
 	// init capture
-	auto usage = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT |
-		VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
-		VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
-		VK_BUFFER_USAGE_TRANSFER_DST_BIT;
-	captureBuffer_.ensure(dev, shaderCaptureSize, usage, {},
-		"CaptureBuf", OwnBuffer::Type::deviceLocal);
-	captureAddress_ = captureBuffer_.queryAddress();
+	if (supportsShaderDebug(dev)) {
+		auto usage = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT |
+			VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
+			VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
+			VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+		captureBuffer_.ensure(dev, shaderCaptureSize, usage, {},
+			"CaptureBuf", OwnBuffer::Type::deviceLocal);
+		captureAddress_ = captureBuffer_.queryAddress();
+	}
 }
 
 CommandHook::~CommandHook() {
diff --git a/src/commandHook/record.cpp b/src/commandHook/record.cpp
index 9b86d6a6..0f1723d0 100644
--- a/src/commandHook/record.cpp
+++ b/src/commandHook/record.cpp
@@ -845,7 +845,7 @@ void CommandHookRecord::copyDs(Command& bcmd, RecordInfo& info,
 	dlg_assertl(dlg_level_warn, cat == DescriptorCategory::image || !imageAsBuffer);
 
 	if(cat == DescriptorCategory::image) {
-		auto& elem = images(descriptors, bindingID)[elemID];
+		auto& elem = dsImage(descriptors, bindingID, elemID);
 		if(needsImageView(bindingLayout.descriptorType)) {
 			auto& imgView = elem.imageView;
 			dlg_assert_or(imgView, return);
@@ -900,7 +900,7 @@ void CommandHookRecord::copyDs(Command& bcmd, RecordInfo& info,
 			dlg_error("Requested descriptor binding copy for sampler");
 		}
 	} else if(cat == DescriptorCategory::buffer) {
-		auto& elem = buffers(descriptors, bindingID)[elemID];
+		auto& elem = dsBuffer(descriptors, bindingID, elemID);
 		dlg_assert_or(elem.buffer, return);
 
 		usedHandles.push_back(elem.buffer);
@@ -927,7 +927,7 @@ void CommandHookRecord::copyDs(Command& bcmd, RecordInfo& info,
 		auto& dstBuf = dst.data.emplace<OwnBuffer>();
 		initAndCopy(dev, cb, dstBuf, 0u, *elem.buffer, off, size, {});
 	} else if(cat == DescriptorCategory::accelStruct) {
-		auto& elem = accelStructs(descriptors, bindingID)[elemID];
+		auto& elem = dsAccelStruct(descriptors, bindingID, elemID);
 		dlg_assert_or(elem.accelStruct, return);
 
 		using CapturedAccelStruct = CommandHookState::CapturedAccelStruct;
diff --git a/src/device.cpp b/src/device.cpp
index 2d884c84..032f73d0 100644
--- a/src/device.cpp
+++ b/src/device.cpp
@@ -17,6 +17,7 @@
 #include <gencmd.hpp>
 #include <threadContext.hpp>
 #include <fault.hpp>
+#include <exts.hpp>
 #include <util/util.hpp>
 #include <gui/gui.hpp>
 #include <commandHook/hook.hpp>
@@ -44,6 +45,10 @@ bool hasAppExt(Device& dev, const char* extName) {
 	return (it != dev.appExts.end());
 }
 
+bool supportsShaderDebug(Device& dev) {
+	return dev.bufferDeviceAddress;
+}
+
 VkResult VKAPI_PTR SetDeviceLoaderDataNOOP(VkDevice, void*) {
 	// noop
 	return VK_SUCCESS;
@@ -370,8 +375,7 @@ VkResult doCreateDevice(
 
 	// copy the pNext chain so we can modify it.
 	std::unique_ptr<std::byte[]> copiedChain;
-	auto* pNext = copyChain(nci.pNext, copiedChain);
-	nci.pNext = pNext;
+	auto* pNext = copyChainPatch(nci.pNext, copiedChain);
 
 	// = Queues =
 	// Make sure we get a graphics queue.
@@ -423,27 +427,22 @@ VkResult doCreateDevice(
 	auto extsEnd = ci->ppEnabledExtensionNames + ci->enabledExtensionCount;
 	std::vector<const char*> newExts = {extsBegin, extsEnd};
 
-	const auto unsupportedExts = std::set<std::string>{
-		// extensions that are not supported and will most likely cause crashes
-		"VK_NV_ray_tracing",
-		"VK_NV_shading_rate_image",
-		"VK_EXT_transform_feedback",
-		"VK_AMD_buffer_marker",
-		"VK_NV_device_diagnostic_checkpoints",
-		"VK_NV_scissor_exclusive",
-		"VK_NV_mesh_shader",
-		"VK_INTEL_performance_query",
-		"VK_NV_fragment_shading_rate_enums",
-		"VK_NV_device_generated_commands",
-	};
+	constexpr auto checkExts = true;
+	const auto allowUnsupported = checkEnvBinary("VIL_ALLOW_UNSUPPORTED_EXTS", false);
+	if(checkExts) {
+		for(std::string_view ext : newExts) {
+			if(contains(unsupportedDevExts, ext)) {
+				auto str = dlg::format("Application requested device extension '{}' that is "
+					"explicitly not supported by vil", ext);
+
+				if (!allowUnsupported) {
+					dlg_error("{}.\nYou can run again with env variable VIL_ALLOW_UNSUPPORTED_EXTS=1 to try anyways", str);
+					return VK_ERROR_EXTENSION_NOT_PRESENT;
+				}
 
-	constexpr auto checkForUnsupportedExts = true;
-	if(checkForUnsupportedExts && !checkEnvBinary("VIL_SKIP_EXT_CHECK", false)) {
-		for(auto& ext : newExts) {
-			if(unsupportedExts.find(ext) != unsupportedExts.end()) {
-				dlg_error("Application requested '{}' but extension is not supported by vil.\n"
-					"You can run again with env variable VIL_SKIP_EXT_CHECK=1 to try anyways", ext);
-				return VK_ERROR_EXTENSION_NOT_PRESENT;
+				dlg_error("{}", str);
+			} else if(!contains(supportedDevExts, ext)) {
+				dlg_error("Application requested unknown device extension '{}'", ext);
 			}
 		}
 	}
diff --git a/src/device.hpp b/src/device.hpp
index f120b65c..ccb38b4b 100644
--- a/src/device.hpp
+++ b/src/device.hpp
@@ -360,6 +360,7 @@ VkFormat findSupported(const Device& dev, span<const VkFormat> formats,
 VkFormat findDepthFormat(const Device& dev);
 
 bool hasAppExt(Device& dev, const char* extName);
+bool supportsShaderDebug(Device& dev);
 
 struct StandaloneDeviceInfo {
 	PFN_vkGetInstanceProcAddr getInstanceProcAddr;
diff --git a/src/ds.cpp b/src/ds.cpp
index 4f3b1085..190f12e1 100644
--- a/src/ds.cpp
+++ b/src/ds.cpp
@@ -30,8 +30,18 @@ constexpr auto refBindings = false;
 // even though the driver could do it.
 constexpr auto enableDsFragmentationPath = false;
 
+constexpr auto maxDescriptorSize = std::max({
+	sizeof(BufferDescriptor),
+	sizeof(ImageDescriptor),
+	sizeof(BufferViewDescriptor),
+	sizeof(AccelStructDescriptor)});
+
 // util
-size_t descriptorSize(VkDescriptorType dsType) {
+std::size_t descriptorSize(VkDescriptorType dsType) {
+	if(dsType == VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
+		return maxDescriptorSize;
+	}
+
 	switch(category(dsType)) {
 		case DescriptorCategory::buffer: return sizeof(BufferDescriptor);
 		case DescriptorCategory::image: return sizeof(ImageDescriptor);
@@ -53,6 +63,67 @@ std::byte* bindingData(const DescriptorSet& ds) {
 	return const_cast<std::byte*>(ptr) + sizeof(ds);
 }
 
+VkDescriptorType& mutableDescriptorType(DescriptorStateRef state, unsigned binding, unsigned elem) {
+	auto& layout = state.layout->bindings[binding];
+	dlg_assert(layout.descriptorType == VK_DESCRIPTOR_TYPE_MUTABLE_EXT);
+
+	auto count = layout.descriptorCount;
+	if(layout.flags & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT) {
+		count = layout.descriptorCount;
+	}
+	dlg_assert(elem < count);
+
+	auto ptr = state.data + layout.offset;
+	return std::launder(reinterpret_cast<VkDescriptorType*>(ptr))[elem];
+}
+
+VkDescriptorType descriptorType(DescriptorStateRef state, unsigned binding, unsigned elem) {
+	auto& layout = state.layout->bindings[binding];
+	if (layout.descriptorType == VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
+		return mutableDescriptorType(state, binding, elem);
+	} else {
+		return layout.descriptorType;
+	}
+}
+
+template<typename F>
+void callForEachDescriptor(DescriptorStateRef state, F&& f) {
+	for(auto i = 0u; i < state.layout->bindings.size(); ++i) {
+		for(auto j = 0u; j < descriptorCount(state, i); ++j) {
+			auto dsType = descriptorType(state, i, j);
+			if(dsType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
+				std::invoke(std::forward<F>(f), dsBufferView(state, i, j));
+				continue;
+			}
+
+			if(dsType == VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
+				// empty, not yet initialized
+				continue;
+			}
+
+			switch(category(dsType)) {
+				case DescriptorCategory::accelStruct: {
+					std::invoke(std::forward<F>(f), dsAccelStruct(state, i, j));
+					break;
+				} case DescriptorCategory::buffer: {
+					std::invoke(std::forward<F>(f), dsBuffer(state, i, j));
+					break;
+				} case DescriptorCategory::image: {
+					std::invoke(std::forward<F>(f), dsImage(state, i, j));
+					break;
+				} case DescriptorCategory::bufferView: {
+					std::invoke(std::forward<F>(f), dsBufferView(state, i, j));
+					break;
+				}
+				case DescriptorCategory::inlineUniformBlock:
+				case DescriptorCategory::none:
+					dlg_error("unreachable");
+					break;
+			}
+		}
+	}
+}
+
 DescriptorStateRef::DescriptorStateRef(const DescriptorSet& ds) :
 	layout(ds.layout.get()), data(bindingData(ds)), variableDescriptorCount(ds.variableDescriptorCount) {
 }
@@ -205,10 +276,13 @@ void initImmutableSamplers(DescriptorStateRef state) {
 		// every time we read a binding. Also needed for correct
 		// invalidation tracking.
 		if(state.layout->bindings[b].immutableSamplers.get()) {
+			// not allowed per spec
+			dlg_assert(state.layout->bindings[b].descriptorType !=
+				VK_DESCRIPTOR_TYPE_MUTABLE_EXT);
 			dlg_assert(needsSampler(state.layout->bindings[b].descriptorType));
-			auto binds = images(state, b);
 
-			for(auto e = 0u; e < binds.size(); ++e) {
+			for(auto e = 0u; e < descriptorCount(state, b); ++e) {
+				auto& bind = dsImage(state, b, e);
 				auto* sampler = state.layout->bindings[b].immutableSamplers[e].get();
 				dlg_assert(sampler);
 
@@ -217,7 +291,7 @@ void initImmutableSamplers(DescriptorStateRef state) {
 				// destroyed but we keep our object alive for the ui.
 				// dlg_assert(sampler->handle);
 
-				binds[e].sampler = sampler;
+				bind.sampler = sampler;
 				if(refBindings) {
 					incRefCount(*sampler);
 				}
@@ -226,25 +300,41 @@ void initImmutableSamplers(DescriptorStateRef state) {
 	}
 }
 
-void initDescriptorState(std::byte* data,
-		const DescriptorSetLayout& layout, u32 variableDescriptorCount) {
+void initDescriptorState(DescriptorStateRef state) {
 	// Possibly faster path but strictly speaking UB I guess?
 	// Compbilers should probably optimize it to this tho
-	auto bindingSize = totalDescriptorMemSize(layout, variableDescriptorCount);
-	std::memset(data, 0x0, bindingSize);
+	auto bindingSize = totalDescriptorMemSize(*state.layout, state.variableDescriptorCount);
+	std::memset(state.data, 0x0, bindingSize);
+
+	// initialize mutable descriptor types
+	for(auto [b, binding] : enumerate(state.layout->bindings)) {
+		if(binding.descriptorType != VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
+			continue;
+		}
+
+		for(auto e = 0u; e < descriptorCount(state, b); ++e) {
+			mutableDescriptorType(state, b, e) = VK_DESCRIPTOR_TYPE_MUTABLE_EXT;
+		}
+	}
 }
 
 void copy(DescriptorStateRef dst, unsigned dstBindID, unsigned dstElemID,
 		DescriptorStateRef src, unsigned srcBindID, unsigned srcElemID) {
-	auto& srcLayout = src.layout->bindings[srcBindID];
+	// auto& srcLayout = src.layout->bindings[srcBindID];
 	auto& dstLayout = dst.layout->bindings[dstBindID];
-	dlg_assert(srcLayout.descriptorType == dstLayout.descriptorType);
 
-	switch(category(dstLayout.descriptorType)) {
+	VkDescriptorType srcType = descriptorType(src, srcBindID, srcElemID);
+	if (dstLayout.descriptorType == VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
+		mutableDescriptorType(dst, dstBindID, dstElemID) = srcType;
+	} else {
+		dlg_assert(dstLayout.descriptorType == srcType);
+	}
+
+	switch(category(srcType)) {
 		case DescriptorCategory::image: {
 			auto immutSampler = !!dstLayout.immutableSamplers.get();
-			auto srcCopy = images(src, srcBindID)[srcElemID];
-			auto& dstBind = images(dst, dstBindID)[dstElemID];
+			auto srcCopy = dsImage(src, srcBindID, srcElemID);
+			auto& dstBind = dsImage(dst, dstBindID, dstElemID);
 
 			if(refBindings) {
 				if(dstBind.sampler && !immutSampler) decRefCount(*dstBind.sampler);
@@ -262,8 +352,8 @@ void copy(DescriptorStateRef dst, unsigned dstBindID, unsigned dstElemID,
 
 			break;
 		} case DescriptorCategory::buffer: {
-			auto& srcBuf = buffers(src, srcBindID)[srcElemID];
-			auto& dstBuf = buffers(dst, dstBindID)[dstElemID];
+			auto& srcBuf = dsBuffer(src, srcBindID, srcElemID);
+			auto& dstBuf = dsBuffer(dst, dstBindID, dstElemID);
 
 			if(refBindings) {
 				if(dstBuf.buffer) decRefCount(*dstBuf.buffer);
@@ -273,8 +363,8 @@ void copy(DescriptorStateRef dst, unsigned dstBindID, unsigned dstElemID,
 			dstBuf = srcBuf;
 			break;
 		} case DescriptorCategory::bufferView: {
-			auto& srcBuf = bufferViews(src, srcBindID)[srcElemID];;
-			auto& dstBuf = bufferViews(dst, dstBindID)[dstElemID];
+			auto& srcBuf = dsBufferView(src, srcBindID, srcElemID);
+			auto& dstBuf = dsBufferView(dst, dstBindID, dstElemID);
 
 			if(refBindings) {
 				if(dstBuf.bufferView) decRefCount(*dstBuf.bufferView);
@@ -295,8 +385,8 @@ void copy(DescriptorStateRef dst, unsigned dstBindID, unsigned dstElemID,
 			dstBuf[dstElemID] = srcBuf[srcElemID];
 			break;
 		} case DescriptorCategory::accelStruct: {
-			auto& srcAS = accelStructs(src, srcBindID)[srcElemID];
-			auto& dstAS = accelStructs(dst, dstBindID)[dstElemID];
+			auto& srcAS = dsAccelStruct(src, srcBindID, srcElemID);
+			auto& dstAS = dsAccelStruct(dst, dstBindID, dstElemID);
 
 			if(refBindings) {
 				if(dstAS.accelStruct) decRefCount(*dstAS.accelStruct);
@@ -366,42 +456,24 @@ static void doRefBindings(Device& dev, DescriptorStateRef state, bool checkIfVal
 	// ds/pool mutex is locked.
 	assertOwned(dev.mutex);
 
-	for(auto b = 0u; b < state.layout->bindings.size(); ++b) {
-		auto& binding = state.layout->bindings[b];
-		if(!descriptorCount(state, b)) {
-			continue;
+	auto visitor = Visitor(
+		[&](span<const std::byte>) {}, // inline uniform
+		[&](AccelStructDescriptor& as) {
+			validateIncRef(dev, dev.accelStructs, as.accelStruct, checkIfValid);
+		},
+		[&](BufferDescriptor& buf) {
+			validateIncRef(dev, dev.buffers, buf.buffer, checkIfValid);
+		},
+		[&](BufferViewDescriptor& bv) {
+			validateIncRef(dev, dev.bufferViews, bv.bufferView, checkIfValid);
+		},
+		[&](ImageDescriptor& id) {
+			validateIncRef(dev, dev.imageViews, id.imageView, checkIfValid);
+			validateIncRef(dev, dev.samplers, id.sampler, checkIfValid);
 		}
+	);
 
-		switch(category(binding.descriptorType)) {
-			case DescriptorCategory::buffer: {
-				for(auto& b : buffers(state, b)) {
-					validateIncRef(dev, dev.buffers, b.buffer, checkIfValid);
-				}
-				break;
-			} case DescriptorCategory::bufferView: {
-				for(auto& b : bufferViews(state, b)) {
-					validateIncRef(dev, dev.bufferViews, b.bufferView, checkIfValid);
-				}
-				break;
-			} case DescriptorCategory::image: {
-				for(auto& b : images(state, b)) {
-					validateIncRef(dev, dev.imageViews, b.imageView, checkIfValid);
-					validateIncRef(dev, dev.samplers, b.sampler, checkIfValid);
-				}
-				break;
-			} case DescriptorCategory::accelStruct: {
-				for(auto& b : accelStructs(state, b)) {
-					validateIncRef(dev, dev.accelStructs, b.accelStruct, checkIfValid);
-				}
-				break;
-			} case DescriptorCategory::inlineUniformBlock: {
-				// no-op, we just have raw bytes here
-				break;
-			} case DescriptorCategory::none:
-				dlg_error("unreachable: invalid descriptor type");
-				break;
-		}
-	}
+	callForEachDescriptor(state, visitor);
 }
 
 void unrefBindings(DescriptorStateRef state) {
@@ -410,52 +482,24 @@ void unrefBindings(DescriptorStateRef state) {
 	dlg_assert(state.layout);
 	assertNotOwned(state.layout->dev->mutex);
 
-	for(auto b = 0u; b < state.layout->bindings.size(); ++b) {
-		auto& binding = state.layout->bindings[b];
-		if(!descriptorCount(state, b)) {
-			continue;
+	auto visitor = Visitor(
+		[&](span<const std::byte>) {}, // inline uniform
+		[&](AccelStructDescriptor& as) {
+			if(as.accelStruct) decRefCount(*as.accelStruct);
+		},
+		[&](BufferDescriptor& buf) {
+			if(buf.buffer) decRefCount(*buf.buffer);
+		},
+		[&](BufferViewDescriptor& bv) {
+			if(bv.bufferView) decRefCount(*bv.bufferView);
+		},
+		[&](ImageDescriptor& id) {
+			if(id.sampler) decRefCount(*id.sampler);
+			if(id.imageView) decRefCount(*id.imageView);
 		}
+	);
 
-		switch(category(binding.descriptorType)) {
-			case DescriptorCategory::buffer: {
-				for(auto& b : buffers(state, b)) {
-					if(b.buffer) {
-						decRefCount(*b.buffer);
-					}
-				}
-				break;
-			} case DescriptorCategory::bufferView: {
-				for(auto& b : bufferViews(state, b)) {
-					if(b.bufferView) {
-						decRefCount(*b.bufferView);
-					}
-				}
-				break;
-			} case DescriptorCategory::image: {
-				for(auto& b : images(state, b)) {
-					if(b.imageView) {
-						decRefCount(*b.imageView);
-					}
-					if(b.sampler) {
-						decRefCount(*b.sampler);
-					}
-				}
-				break;
-			} case DescriptorCategory::accelStruct: {
-				for(auto& b : accelStructs(state, b)) {
-					if(b.accelStruct) {
-						decRefCount(*b.accelStruct);
-					}
-				}
-				break;
-			} case DescriptorCategory::inlineUniformBlock: {
-				// no-op, we just have raw bytes here
-				break;
-			} case DescriptorCategory::none:
-				dlg_error("unreachable: invalid descriptor type");
-				break;
-		}
-	}
+	callForEachDescriptor(state, visitor);
 }
 
 void DescriptorStateCopy::Deleter::operator()(DescriptorStateCopy* copy) const {
@@ -504,7 +548,7 @@ DescriptorStateCopyPtr DescriptorSet::copyLockedState() {
 	auto dstRef = srcRef;
 	dstRef.data = mem + sizeof(DescriptorStateCopy);
 
-	initDescriptorState(dstRef.data, *this->layout, this->variableDescriptorCount);
+	initDescriptorState(dstRef);
 	initImmutableSamplers(dstRef);
 
 	// copy descriptors
@@ -689,51 +733,50 @@ void destroy(DescriptorSet& ds, bool unlink) {
 	}
 }
 
-span<BufferDescriptor> buffers(DescriptorStateRef state, unsigned binding) {
+template<typename T>
+T& accessDescriptor(DescriptorStateRef state, unsigned binding, unsigned elem,
+		DescriptorCategory dsCat) {
+
 	dlg_assert(binding < state.layout->bindings.size());
 
 	auto& layout = state.layout->bindings[binding];
-	dlg_assert(category(layout.descriptorType) == DescriptorCategory::buffer);
-
-	auto count = layout.descriptorCount;
-	if(layout.flags & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT) {
-		count = state.variableDescriptorCount;
+	dlg_assert(elem < descriptorCount(state, binding));
+
+	auto offset = layout.offset;
+	if(layout.descriptorType == VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
+		// should be set before accessing (updating) this
+		dlg_assertm(category(mutableDescriptorType(state, binding, elem)) == dsCat,
+			"Mutable descriptor mismatch");
+		offset += sizeof(VkDescriptorType) * descriptorCount(state, binding);
+		offset = align(offset, sizeof(void*));
+		offset += elem * maxDescriptorSize;
+	} else {
+		dlg_assertm(category(layout.descriptorType) == dsCat,
+			"descriptorType {}, dsCat {}", layout.descriptorType, unsigned(dsCat));
+		offset += elem * sizeof(T);
 	}
 
-	auto ptr = state.data + layout.offset;
-	auto d = std::launder(reinterpret_cast<BufferDescriptor*>(ptr));
-	return {d, count};
+	auto ptr = state.data + offset;
+	auto* d = std::launder(reinterpret_cast<T*>(ptr));
+	return *d;
 }
-span<ImageDescriptor> images(DescriptorStateRef state, unsigned binding) {
-	dlg_assert(binding < state.layout->bindings.size());
-
-	auto& layout = state.layout->bindings[binding];
-	dlg_assert(category(layout.descriptorType) == DescriptorCategory::image);
-
-	auto count = layout.descriptorCount;
-	if(layout.flags & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT) {
-		count = state.variableDescriptorCount;
-	}
 
-	auto ptr = state.data + layout.offset;
-	auto d = std::launder(reinterpret_cast<ImageDescriptor*>(ptr));
-	return {d, count};
+BufferDescriptor& dsBuffer(DescriptorStateRef state, unsigned binding, unsigned elem) {
+	return accessDescriptor<BufferDescriptor>(state, binding, elem, DescriptorCategory::buffer);
 }
-span<BufferViewDescriptor> bufferViews(DescriptorStateRef state, unsigned binding) {
-	dlg_assert(binding < state.layout->bindings.size());
 
-	auto& layout = state.layout->bindings[binding];
-	dlg_assert(category(layout.descriptorType) == DescriptorCategory::bufferView);
+ImageDescriptor& dsImage(DescriptorStateRef state, unsigned binding, unsigned elem) {
+	return accessDescriptor<ImageDescriptor>(state, binding, elem, DescriptorCategory::image);
+}
 
-	auto count = layout.descriptorCount;
-	if(layout.flags & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT) {
-		count = state.variableDescriptorCount;
-	}
+BufferViewDescriptor& dsBufferView(DescriptorStateRef state, unsigned binding, unsigned elem) {
+	return accessDescriptor<BufferViewDescriptor>(state, binding, elem, DescriptorCategory::bufferView);
+}
 
-	auto ptr = state.data + layout.offset;
-	auto d = std::launder(reinterpret_cast<BufferViewDescriptor*>(ptr));
-	return {d, count};
+AccelStructDescriptor& dsAccelStruct(DescriptorStateRef state, unsigned binding, unsigned elem) {
+	return accessDescriptor<AccelStructDescriptor>(state, binding, elem, DescriptorCategory::accelStruct);
 }
+
 span<std::byte> inlineUniformBlock(DescriptorStateRef state, unsigned binding) {
 	dlg_assert(binding < state.layout->bindings.size());
 
@@ -748,21 +791,6 @@ span<std::byte> inlineUniformBlock(DescriptorStateRef state, unsigned binding) {
 	auto ptr = state.data + layout.offset;
 	return {ptr, count};
 }
-span<AccelStructDescriptor> accelStructs(DescriptorStateRef state, unsigned binding) {
-	dlg_assert(binding < state.layout->bindings.size());
-
-	auto& layout = state.layout->bindings[binding];
-	dlg_assert(category(layout.descriptorType) == DescriptorCategory::accelStruct);
-
-	auto count = layout.descriptorCount;
-	if(layout.flags & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT) {
-		count = state.variableDescriptorCount;
-	}
-
-	auto ptr = state.data + layout.offset;
-	auto d = std::launder(reinterpret_cast<AccelStructDescriptor*>(ptr));
-	return {d, count};
-}
 
 // DescriptorPool impl
 DescriptorPool::~DescriptorPool() {
@@ -970,6 +998,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(
 	// number offsets
 	auto off = 0u;
 	for(auto b = 0u; b < dsLayout.bindings.size(); ++b) {
+		off = align(off, alignof(void*));
 		auto& bind = dsLayout.bindings[b];
 		bind.offset = off;
 
@@ -977,6 +1006,11 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(
 			continue;
 		}
 
+		if(bind.descriptorType == VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
+			off += unsigned(bind.descriptorCount * sizeof(VkDescriptorType));
+			off = align(off, alignof(void*));
+		}
+
 		off += unsigned(bind.descriptorCount * descriptorSize(bind.descriptorType));
 
 		auto varCount = !!(bind.flags & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT);
@@ -1067,6 +1101,11 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(
 	dsPool.dataSize = dsPool.maxSets * sizeof(DescriptorSet);
 	for(auto& pool : dsPool.poolSizes) {
 		dsPool.dataSize += descriptorSize(pool.type) * pool.descriptorCount;
+		dlg_assert(descriptorSize(pool.type) % alignof(void*) == 0u);
+
+		if(pool.type == VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
+			dsPool.dataSize += align(sizeof(VkDescriptorType), alignof(void*)) * pool.descriptorCount;
+		}
 	}
 
 	// NOTE: no idea why this was needed for the nvidia rtxgi samples.
@@ -1292,7 +1331,7 @@ VkResult initDescriptorSet(Device& dev, DescriptorPool& pool, VkDescriptorSet& h
 	ds.id = ++pool.lastID;
 	setEntry->set = &ds;
 
-	initDescriptorState(bindingData(ds), *ds.layout, ds.variableDescriptorCount);
+	initDescriptorState(ds);
 	handle = castDispatch<VkDescriptorSet>(ds);
 
 	if(!HandleDesc<VkDescriptorSet>::wrap) {
@@ -1367,10 +1406,12 @@ VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(
 
 	if(res != VK_SUCCESS) {
 		for(auto j = 0u; j < i; ++j) {
-			destroy(*dss[i], true);
+			if(dss[i]) {
+				destroy(*dss[i], true);
+			}
 		}
-		dev.dispatch.FreeDescriptorSets(dev.handle, pool.handle,
-			count, pDescriptorSets);
+
+		dev.dispatch.FreeDescriptorSets(dev.handle, pool.handle, count, pDescriptorSets);
 		memset(pDescriptorSets, 0x0, sizeof(pDescriptorSets[0]) * count);
 		return res;
 	}
@@ -1411,7 +1452,7 @@ VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(
 
 void update(DescriptorSet& state, unsigned bind, unsigned elem,
 		VkBufferView& handle) {
-	auto& binding = bufferViews(state, bind)[elem];
+	auto& binding = dsBufferView(state, bind, elem);
 
 	BufferView* newView {};
 	if(handle) VIL_LIKELY {
@@ -1432,16 +1473,16 @@ void update(DescriptorSet& state, unsigned bind, unsigned elem,
 }
 
 void update(DescriptorSet& state, unsigned bind, unsigned elem,
-		VkDescriptorImageInfo& img) {
+		VkDescriptorImageInfo& img, VkDescriptorType dsType) {
 	auto& dev = *state.layout->dev;
 
-	auto& binding = images(state, bind)[elem];
+	auto& binding = dsImage(state, bind, elem);
 	binding.layout = img.imageLayout;
 
 	auto& layout = state.layout->bindings[bind];
 
 	// update imageView, if needed
-	if(needsImageView(layout.descriptorType)) {
+	if(needsImageView(dsType)) {
 		ImageView* newView {};
 		if(img.imageView) VIL_LIKELY { // can be VK_NULL_HANDLE
 			newView = &get(dev, img.imageView);
@@ -1461,7 +1502,7 @@ void update(DescriptorSet& state, unsigned bind, unsigned elem,
 	}
 
 	// update sampler, if needed
-	if(needsSampler(layout.descriptorType)) {
+	if(needsSampler(dsType)) {
 		if(layout.immutableSamplers) {
 			// immutable samplers are initialized at the beginning and
 			// never unset.
@@ -1490,7 +1531,7 @@ void update(DescriptorSet& state, unsigned bind, unsigned elem,
 
 void update(DescriptorSet& state, unsigned bind, unsigned elem,
 		VkDescriptorBufferInfo& info) {
-	auto& binding = buffers(state, bind)[elem];
+	auto& binding = dsBuffer(state, bind, elem);
 	Buffer* newBuffer {};
 
 	if(info.buffer) VIL_LIKELY { // can be VK_NULL_HANDLE
@@ -1519,7 +1560,7 @@ void update(DescriptorSet& state, unsigned bind, unsigned elem,
 
 void update(DescriptorSet& state, unsigned bind, unsigned elem,
 		VkAccelerationStructureKHR& handle) {
-	auto& binding = accelStructs(state, bind)[elem];
+	auto& binding = dsAccelStruct(state, bind, elem);
 	AccelStruct* newAS {};
 
 	if(handle) VIL_LIKELY { // can be VK_NULL_HANDLE
@@ -1627,14 +1668,19 @@ VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(
 			advanceUntilValid(ds, dstBinding, dstElem);
 			dlg_assert(dstBinding < ds.layout->bindings.size());
 			auto& layout = ds.layout->bindings[dstBinding];
-			dlg_assert(write.descriptorType == layout.descriptorType);
+
+			if(layout.descriptorType == VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
+				mutableDescriptorType(ds, dstBinding, dstElem) = write.descriptorType;
+			} else {
+				dlg_assert(write.descriptorType == layout.descriptorType);
+			}
 
 			switch(category(write.descriptorType)) {
 				case DescriptorCategory::image: {
 					dlg_assert(write.pImageInfo);
 					auto& info = imageInfos[writeOff + j];
 					info = write.pImageInfo[j];
-					update(ds, dstBinding, dstElem, info);
+					update(ds, dstBinding, dstElem, info, write.descriptorType);
 					break;
 				} case DescriptorCategory::buffer: {
 					dlg_assert(write.pBufferInfo);
@@ -1827,13 +1873,20 @@ VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(
 	for(auto& entry : dut.entries) {
 		auto dstBinding = entry.dstBinding;
 		auto dstElem = entry.dstArrayElement;
-		auto dsType = ds.layout->bindings[dstBinding].descriptorType;
+		auto dsType = entry.descriptorType;
 
 		for(auto j = 0u; j < entry.descriptorCount; ++j, ++dstElem) {
 			// PERF Could we maybe determine this statically
 			// in CreateDescriptorUpdateTemplate?
 			advanceUntilValid(ds, dstBinding, dstElem);
 
+			auto& layout = ds.layout->bindings[dstBinding];
+			if(layout.descriptorType == VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
+				mutableDescriptorType(ds, dstBinding, dstElem) = dsType;
+			} else {
+				dlg_assert(dsType == layout.descriptorType);
+			}
+
 			// TODO: such an assertion here would be nice. Track used
 			// layout in update?
 			// dlg_assert(write.descriptorType == type);
@@ -1848,7 +1901,7 @@ VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(
 			switch(category(dsType)) {
 				case DescriptorCategory::image: {
 					auto& img = *reinterpret_cast<VkDescriptorImageInfo*>(data);
-					update(ds, dstBinding, dstElem, img);
+					update(ds, dstBinding, dstElem, img, dsType);
 					break;
 				} case DescriptorCategory::buffer: {
 					auto& buf = *reinterpret_cast<VkDescriptorBufferInfo*>(data);
@@ -1951,46 +2004,24 @@ std::pair<DescriptorStateRef, std::unique_lock<DebugMutex>> access(DescriptorSet
 }
 
 bool hasBound(DescriptorStateRef state, const Handle& handle) {
-	for(auto i = 0u; i < state.layout->bindings.size(); ++i) {
-		switch(category(state.layout->bindings[i].descriptorType)) {
-			case DescriptorCategory::accelStruct:
-				for(auto& accelStruct : accelStructs(state, i)) {
-					if(accelStruct.accelStruct == &handle) {
-						return true;
-					}
-				}
-				break;
-			case DescriptorCategory::buffer:
-				for(auto& buffer : buffers(state, i)) {
-					if(buffer.buffer == &handle) {
-						return true;
-					}
-				}
-				break;
-			case DescriptorCategory::image:
-				for(auto& img : images(state, i)) {
-					if(img.imageView == &handle || (img.imageView && img.imageView->img == &handle)) {
-						return true;
-					}
-				}
-				break;
-			case DescriptorCategory::bufferView:
-				for(auto& bv : bufferViews(state, i)) {
-					if(bv.bufferView == &handle || (bv.bufferView && bv.bufferView->buffer == &handle)) {
-						return true;
-					}
-				}
-				break;
-			case DescriptorCategory::inlineUniformBlock:
-				// nope
-				break;
-			case DescriptorCategory::none:
-				dlg_error("unreachable");
-				break;
+	auto ret = false;
+	auto visitor = Visitor(
+		[&](span<const std::byte>) {}, // inline uniform
+		[&](const AccelStructDescriptor& as) { ret |= (as.accelStruct == &handle); },
+		[&](const BufferDescriptor& bv) { ret |= (bv.buffer == &handle); },
+		[&](const BufferViewDescriptor& bv) {
+			ret |= (bv.bufferView == &handle);
+			ret |= (bv.bufferView && bv.bufferView->buffer == &handle);
+		},
+		[&](const ImageDescriptor& bv) {
+			ret |= (bv.imageView == &handle);
+			ret |= (bv.sampler == &handle);  // TODO: immutable samplers?
+			ret |= (bv.imageView && bv.imageView->img == &handle);
 		}
-	}
+	);
 
-	return false;
+	callForEachDescriptor(state, visitor);
+	return ret;
 }
 
 // only implemented for sampler unwrapping
diff --git a/src/ds.hpp b/src/ds.hpp
index 9b6c8a9e..0333aa1a 100644
--- a/src/ds.hpp
+++ b/src/ds.hpp
@@ -207,15 +207,23 @@ struct DescriptorStateRef {
 u32 descriptorCount(DescriptorStateRef, unsigned binding);
 u32 totalDescriptorCount(DescriptorStateRef);
 
+// Needed due to mutable descriptor types.
+VkDescriptorType descriptorType(DescriptorStateRef state, unsigned binding, unsigned elem);
+
 // NOTE: retrieving the span itself does not need to lock the state's
 // mutex. The caller must manually synchronize access to the bindings by locking
 // the state's mutex.
-span<BufferDescriptor> buffers(DescriptorStateRef, unsigned binding);
-span<ImageDescriptor> images(DescriptorStateRef, unsigned binding);
-span<BufferViewDescriptor> bufferViews(DescriptorStateRef, unsigned binding);
-span<AccelStructDescriptor> accelStructs(DescriptorStateRef, unsigned binding);
+// span<BufferDescriptor> buffers(DescriptorStateRef, unsigned binding);
+// span<ImageDescriptor> images(DescriptorStateRef, unsigned binding);
+// span<BufferViewDescriptor> bufferViews(DescriptorStateRef, unsigned binding);
+// span<AccelStructDescriptor> accelStructs(DescriptorStateRef, unsigned binding);
 span<std::byte> inlineUniformBlock(DescriptorStateRef, unsigned binding);
 
+BufferDescriptor& dsBuffer(DescriptorStateRef, unsigned binding, unsigned elem);
+ImageDescriptor& dsImage(DescriptorStateRef, unsigned binding, unsigned elem);
+BufferViewDescriptor& dsBufferView(DescriptorStateRef, unsigned binding, unsigned elem);
+AccelStructDescriptor& dsAccelStruct(DescriptorStateRef, unsigned binding, unsigned elem);
+
 // Returns whether the given descriptor state has the given handle bound.
 // For Buffers and Images, also returns true when one of their bufferViews/
 // imageViews is bound.
diff --git a/src/exts.hpp b/src/exts.hpp
new file mode 100644
index 00000000..34db4d8c
--- /dev/null
+++ b/src/exts.hpp
@@ -0,0 +1,477 @@
+#pragma once
+
+#include <string_view>
+
+// Lists all supported/unsupported extensions.
+// Not every extension was tested, this might contain errors. Especially
+// for pure shader extensions or extensions just adding new enum values,
+// they were just treated as supported.
+//
+// There are also some extensions that are likely false negatives
+// - surface extensions for platforms we don't explicitly support/tested.
+//   If you create a vil overlay via the vil api, things will
+//   likely just work
+// - the KHR_display (and derivative) instance extensions. Might just work.
+
+namespace vil {
+
+constexpr std::string_view supportedInstanceExts[] = {
+	"VK_KHR_surface",
+	"VK_KHR_xlib_surface",
+	"VK_KHR_xcb_surface",
+	"VK_KHR_wayland_surface",
+	"VK_KHR_win32_surface",
+	"VK_KHR_get_physical_device_properties2",
+	"VK_EXT_validation_flags",
+	"VK_KHR_external_memory_capabilities",
+	"VK_KHR_external_semaphore_capabilities",
+	"VK_KHR_external_fence_capabilities",
+	"VK_KHR_get_surface_capabilities2",
+	"VK_KHR_get_display_properties2",
+	"VK_EXT_debug_utils",
+	"VK_KHR_surface_protected_capabilities",
+	"VK_EXT_headless_surface", // TODO: actively support!
+	"VK_EXT_surface_maintenance1", // nop
+	"VK_GOOGLE_surfaceless_query", // nop
+	"VK_EXT_application_parameters", // nop
+	"VK_LUNARG_direct_driver_loading", // nop
+	"VK_KHR_surface_maintenance1", // nop
+};
+
+constexpr std::string_view unsupportedInstanceExts[] = {
+	"VK_KHR_display",
+	"VK_KHR_mir_surface",
+	"VK_KHR_android_surface",
+	"VK_GGP_stream_descriptor_surface",
+	"VK_NN_vi_surface",
+	"VK_KHR_device_group_creation",
+	"VK_MVK_ios_surface",
+	"VK_MVK_macos_surface",
+	"VK_MVK_moltenvk",
+	"VK_FUCHSIA_imagepipe_surface",
+	"VK_EXT_metal_surface",
+	"VK_EXT_acquire_drm_display",
+	"VK_EXT_directfb_surface",
+	"VK_QNX_screen_surface",
+	"VK_NV_display_stereo",
+	"VK_OHOS_surface",
+
+	"VK_NV_external_memory_capabilities",
+	"VK_EXT_direct_mode_display",
+	"VK_EXT_acquire_xlib_display",
+	"VK_EXT_display_surface_counter",
+	"VK_KHR_portability_enumeration",
+
+	"VK_EXT_debug_report", // TODO: support this for legacy apps!
+};
+
+constexpr std::string_view supportedDevExts[] = {
+	// explicitly supported
+	"VK_KHR_swapchain",
+	"VK_KHR_dynamic_rendering",
+	"VK_KHR_push_descriptor",
+	"VK_EXT_conditional_rendering",
+	"VK_KHR_descriptor_update_template",
+	"VK_EXT_discard_rectangles",
+	"VK_KHR_imageless_framebuffer",
+	"VK_KHR_create_renderpass2",
+	"VK_EXT_inline_uniform_block",
+	"VK_EXT_sample_locations",
+	"VK_KHR_acceleration_structure",
+	"VK_KHR_ray_tracing_pipeline", // TODO vkCmdTraceRaysIndirectKHR support incomplete
+	"VK_KHR_bind_memory2",
+	"VK_EXT_image_drm_format_modifier",
+	"VK_EXT_descriptor_indexing",
+	"VK_KHR_maintenance3",
+	"VK_AMD_draw_indirect_count", // core now
+	"VK_KHR_draw_indirect_count",
+	"VK_KHR_timeline_semaphore",
+	"VK_KHR_fragment_shading_rate",
+	"VK_EXT_buffer_device_address",
+	"VK_KHR_present_wait",
+	"VK_KHR_buffer_device_address",
+	"VK_EXT_line_rasterization",
+	"VK_KHR_map_memory2",
+	"VK_EXT_map_memory_placed",
+	"VK_KHR_pipeline_library",
+	"VK_KHR_synchronization2",
+	"VK_EXT_graphics_pipeline_library",
+	"VK_EXT_mesh_shader",
+	"VK_KHR_copy_commands2",
+	"VK_EXT_vertex_input_dynamic_state",
+	"VK_EXT_color_write_enable",
+	"VK_EXT_multi_draw",
+	"VK_EXT_pageable_device_local_memory",
+	"VK_EXT_extended_dynamic_state",
+	"VK_EXT_extended_dynamic_state2",
+	"VK_EXT_extended_dynamic_state3",
+	"VK_KHR_maintenance5",
+	"VK_EXT_shader_object",
+	"VK_KHR_line_rasterization",
+	"VK_KHR_maintenance6",
+	"VK_EXT_depth_clamp_control",
+	"VK_KHR_maintenance9",
+
+	// likely supported, mostly no-ops for vil itself
+	"VK_EXT_depth_range_unrestricted",
+	"VK_KHR_sampler_mirror_clamp_to_edge",
+	"VK_IMG_filter_cubic",
+	"VK_AMD_rasterization_order",
+	"VK_AMD_shader_trinary_minmax",
+	"VK_AMD_shader_explicit_vertex_parameter",
+	"VK_AMD_gcn_shader",
+	"VK_AMD_negative_viewport_height",
+	"VK_AMD_gpu_shader_half_float",
+	"VK_AMD_shader_ballot",
+	"VK_AMD_texture_gather_bias_lod",
+	"VK_AMD_shader_image_load_store_lod",
+	"VK_NV_corner_sampled_image",
+	"VK_KHR_shader_draw_parameters",
+	"VK_EXT_shader_subgroup_ballot",
+	"VK_EXT_shader_subgroup_vote",
+	"VK_EXT_texture_compression_astc_hdr",
+	"VK_EXT_astc_decode_mode",
+	"VK_KHR_maintenance1",
+	"VK_KHR_external_memory",
+	"VK_KHR_external_memory_win32",
+	"VK_KHR_external_memory_fd",
+	"VK_KHR_win32_keyed_mutex",
+	"VK_KHR_external_semaphore",
+	"VK_KHR_external_semaphore_win32",
+	"VK_KHR_external_semaphore_fd",
+	"VK_KHR_shader_float16_int8",
+	"VK_KHR_16bit_storage",
+	"VK_KHR_incremental_present", // TODO: might make problems with overlay
+	"VK_NV_clip_space_w_scaling",
+	"VK_NV_sample_mask_override_coverage",
+	"VK_NV_geometry_shader_passthrough",
+	"VK_EXT_conservative_rasterization",
+	"VK_EXT_depth_clip_enable",
+	"VK_EXT_swapchain_colorspace",
+	"VK_EXT_hdr_metadata",
+	"VK_KHR_shared_presentable_image",
+	"VK_KHR_external_fence",
+	"VK_KHR_external_fence_win32",
+	"VK_KHR_external_fence_fd",
+	"VK_KHR_maintenance2",
+	"VK_KHR_variable_pointers",
+	"VK_EXT_external_memory_dma_buf",
+	"VK_EXT_queue_family_foreign", // TODO: might cause issues with our barrier insertion?
+	"VK_KHR_dedicated_allocation",
+	"VK_EXT_sampler_filter_minmax",
+	"VK_KHR_storage_buffer_storage_class",
+	"VK_AMD_gpu_shader_int16",
+	"VK_AMD_mixed_attachment_samples",
+	"VK_AMD_shader_fragment_mask",
+	"VK_EXT_shader_stencil_export",
+	"VK_KHR_relaxed_block_layout",
+	"VK_KHR_get_memory_requirements2",
+	"VK_KHR_image_format_list",
+	"VK_EXT_blend_operation_advanced",
+	"VK_NV_fragment_coverage_to_color",
+	"VK_KHR_ray_query",
+	"VK_NV_framebuffer_mixed_samples",
+	"VK_NV_fill_rectangle",
+	"VK_NV_shader_sm_builtins",
+	"VK_EXT_post_depth_coverage",
+	"VK_KHR_sampler_ycbcr_conversion",
+	"VK_EXT_validation_cache", // TODO: actively use!
+	"VK_EXT_shader_viewport_index_layer",
+	"VK_EXT_filter_cubic",
+	"VK_QCOM_render_pass_shader_resolve",
+	"VK_EXT_global_priority",
+	"VK_KHR_shader_subgroup_extended_types",
+	"VK_KHR_8bit_storage",
+	"VK_EXT_external_memory_host",
+	"VK_KHR_shader_atomic_int64",
+	"VK_KHR_shader_clock",
+	"VK_AMD_pipeline_compiler_control",
+	"VK_EXT_calibrated_timestamps",
+	"VK_AMD_shader_core_properties",
+	"VK_AMD_memory_overallocation_behavior",
+	"VK_EXT_pipeline_creation_feedback",
+	"VK_KHR_driver_properties",
+	"VK_KHR_shader_float_controls",
+	"VK_NV_shader_subgroup_partitioned",
+	"VK_KHR_swapchain_mutable_format",
+	"VK_NV_compute_shader_derivatives",
+	"VK_NV_fragment_shader_barycentric",
+	"VK_NV_shader_image_footprint",
+	"VK_EXT_present_timing", // TODO only when swapchain isn't wrapped.
+	"VK_INTEL_shader_integer_functions2",
+	"VK_KHR_vulkan_memory_model",
+	"VK_EXT_pci_bus_info",
+	"VK_AMD_display_native_hdr",
+	"VK_AMD_display_native_hdr", // only when swpachain isnt wrapped
+	"VK_KHR_shader_terminate_invocation",
+	"VK_EXT_fragment_density_map",
+	"VK_EXT_scalar_block_layout",
+	"VK_GOOGLE_hlsl_functionality1",
+	"VK_GOOGLE_decorate_string",
+	"VK_EXT_subgroup_size_control",
+	"VK_AMD_shader_core_properties2",
+	"VK_AMD_device_coherent_memory",
+	"VK_EXT_shader_image_atomic_int64",
+	"VK_KHR_shader_quad_control",
+	"VK_KHR_spirv_1_4",
+	"VK_EXT_memory_budget",
+	"VK_EXT_memory_priority",
+	"VK_NV_dedicated_allocation_image_aliasing",
+	"VK_KHR_separate_depth_stencil_layouts", // not 100% sure about rp splitting
+	"VK_EXT_tooling_info", // TODO: actively implement!
+	"VK_EXT_separate_stencil_usage",
+	"VK_EXT_validation_features",
+	"VK_NV_cooperative_matrix",
+	"VK_NV_coverage_reduction_mode",
+	"VK_EXT_fragment_shader_interlock",
+	"VK_EXT_ycbcr_image_arrays",
+	"VK_KHR_uniform_buffer_standard_layout",
+	"VK_EXT_provoking_vertex",
+	"VK_EXT_full_screen_exclusive",
+	"VK_EXT_shader_atomic_float",
+	"VK_EXT_host_query_reset", // TODO only when QueryPool not wrapped
+	"VK_EXT_index_type_uint8", // supported for all hooking/gui ops?
+	"VK_KHR_deferred_host_operations", // nop support
+	"VK_EXT_shader_atomic_float2",
+	"VK_EXT_swapchain_maintenance1", // TODO: only when swapchain not wrapped
+	"VK_EXT_shader_demote_to_helper_invocation",
+	"VK_NV_inherited_viewport_scissor",
+	"VK_KHR_shader_integer_dot_product",
+	"VK_EXT_texel_buffer_alignment",
+	"VK_QCOM_render_pass_transform",
+	"VK_EXT_depth_bias_control",
+	"VK_EXT_device_memory_report",
+	"VK_EXT_robustness2",
+	"VK_EXT_custom_border_color",
+	"VK_GOOGLE_user_type",
+	"VK_NV_present_barrier",
+	"VK_KHR_shader_non_semantic_info",
+	"VK_KHR_present_id",
+	"VK_EXT_pipeline_creation_cache_control",
+	"VK_NV_device_diagnostics_config",
+	"VK_QCOM_render_pass_store_ops",
+	"VK_NV_low_latency",
+	"VK_AMD_shader_early_and_late_fragment_tests",
+	"VK_KHR_fragment_shader_barycentric",
+	"VK_KHR_shader_subgroup_uniform_control_flow",
+	"VK_KHR_zero_initialize_workgroup_memory",
+	"VK_EXT_ycbcr_2plane_444_formats",
+	"VK_EXT_fragment_density_map2",
+	"VK_QCOM_rotated_copy_commands",
+	"VK_EXT_image_robustness",
+	"VK_KHR_workgroup_memory_explicit_layout",
+	"VK_EXT_attachment_feedback_loop_layout",
+	"VK_EXT_4444_formats", // no cpu formatting support
+	"VK_EXT_device_fault",
+	"VK_ARM_rasterization_order_attachment_access",
+	"VK_EXT_rgba10x6_formats", // no cpu formatting support
+	"VK_EXT_physical_device_drm",
+	"VK_EXT_device_address_binding_report",
+	"VK_EXT_depth_clip_control",
+	"VK_EXT_primitive_topology_list_restart",
+	"VK_KHR_format_feature_flags2",
+	"VK_EXT_present_mode_fifo_latest_ready",
+	"VK_EXT_primitives_generated_query",
+	"VK_KHR_ray_tracing_maintenance1",
+	"VK_KHR_shader_untyped_pointers",
+	"VK_EXT_global_priority_query",
+	"VK_EXT_image_view_min_lod",
+	"VK_EXT_image_2d_view_of_3d",
+	"VK_EXT_shader_tile_image",
+	"VK_EXT_load_store_op_none",
+	"VK_EXT_border_color_swizzle",
+	"VK_KHR_maintenance4",
+	"VK_ARM_shader_core_properties",
+	"VK_KHR_shader_subgroup_rotate",
+	"VK_ARM_scheduling_controls",
+	"VK_EXT_image_sliced_view_of_3d",
+	"VK_EXT_depth_clamp_zero_one",
+	"VK_EXT_non_seamless_cube_map",
+	"VK_QCOM_fragment_density_map_offset",
+	"VK_NV_linear_color_attachment",
+	"VK_KHR_shader_maximal_reconvergence",
+	"VK_EXT_image_compression_control_swapchain",
+	"VK_QCOM_image_processing",
+	"VK_EXT_nested_command_buffer",
+	"VK_EXT_external_memory_acquire_unmodified",
+	"VK_EXT_shader_module_identifier", // TODO: only when shaderModule not wrapped
+	"VK_EXT_rasterization_order_attachment_access",
+	"VK_EXT_legacy_dithering",
+	"VK_EXT_pipeline_protected_access",
+	"VK_AMD_anti_lag",
+	"VK_KHR_present_id2",
+	"VK_KHR_present_wait2", // TODO only when swapchain not wrapped
+	"VK_KHR_ray_tracing_position_fetch",
+	"VK_KHR_swapchain_maintenance1", // TODO: only when swapchain not wrapped
+	"VK_NV_ray_tracing_invocation_reorder",
+	"VK_NV_extended_sparse_address_space",
+	"VK_EXT_legacy_vertex_attributes",
+	"VK_EXT_layer_settings", // TODO actively use
+	"VK_ARM_shader_core_builtins",
+	"VK_EXT_pipeline_library_group_handles", // TODO: rt pipe patching still working?
+	"VK_EXT_dynamic_rendering_unused_attachments",
+	"VK_NV_low_latency2", // TODO not 100% sure
+	"VK_KHR_cooperative_matrix",
+	"VK_KHR_compute_shader_derivatives",
+	"VK_QCOM_image_processing2",
+	"VK_QCOM_filter_cubic_weights",
+	"VK_QCOM_ycbcr_degamma",
+	"VK_QCOM_filter_cubic_clamp",
+	"VK_KHR_load_store_op_none",
+	"VK_KHR_unified_image_layouts",
+	"VK_KHR_shader_float_controls2",
+	"VK_MSFT_layered_driver",
+	"VK_KHR_index_type_uint8",
+	"VK_KHR_calibrated_timestamps",
+	"VK_KHR_shader_expect_assume",
+	"VK_NV_descriptor_pool_overallocation",
+	"VK_NV_raw_access_chains",
+	"VK_KHR_shader_relaxed_extended_instruction",
+	"VK_KHR_maintenance7",
+	"VK_NV_shader_atomic_float16_vector",
+	"VK_EXT_shader_replicated_composites",
+	"VK_EXT_shader_float8",
+	"VK_NV_ray_tracing_validation",
+	"VK_EXT_device_generated_commands", // TODO incomplete, test and show in UI
+	"VK_KHR_maintenance8",
+	"VK_MESA_image_alignment_control",
+	"VK_KHR_shader_fma",
+	"VK_EXT_ray_tracing_invocation_reorder",
+	"VK_NV_cooperative_matrix2",
+	"VK_KHR_depth_clamp_zero_one",
+	"VK_EXT_vertex_attribute_robustness",
+	"VK_ARM_format_pack",
+	"VK_KHR_robustness2",
+	"VK_NV_present_metering",
+	"VK_EXT_zero_initialize_device_memory",
+	"VK_KHR_present_mode_fifo_latest_ready",
+	"VK_EXT_shader_64bit_indexing",
+	"VK_EXT_shader_uniform_buffer_unsized_array",
+	"VK_VALVE_mutable_descriptor_type",
+	"VK_EXT_mutable_descriptor_type", // TODO: push + mutable not supported right now
+};
+
+// Known/look like they might cause problems or crashes.
+constexpr std::string_view unsupportedDevExts[] = {
+	"VK_NVX_binary_import",
+	"VK_NVX_image_view_handle",
+	"VK_EXT_transform_feedback",
+	"VK_EXT_debug_marker",
+	"VK_ANDROID_native_buffer",
+	"VK_NV_glsl_shader",
+	"VK_KHR_video_queue",
+	"VK_KHR_video_decode_queue",
+	"VK_NV_dedicated_allocation",
+	"VK_EXT_video_encode_h264",
+	"VK_EXT_video_encode_h265",
+	"VK_EXT_video_decode_h264",
+	"VK_AMD_shader_info", // TODO: easy to support and useful!
+	"VK_KHR_multiview", // might need non-trivial RenderPass splitting changes
+	"VK_IMG_format_pvrtc",
+	"VK_NV_external_memory",
+	"VK_NV_external_memory_win32",
+	"VK_NV_win32_keyed_mutex",
+	"VK_KHR_device_group",
+	"VK_EXT_display_control",
+	"VK_GOOGLE_display_timing",
+	"VK_NV_viewport_array2",
+	"VK_NVX_multiview_per_view_attributes",
+	"VK_NV_viewport_swizzle",
+	"VK_KHR_performance_query", // TODO: would be nice to support and use!
+	"VK_ANDROID_external_memory_android_hardware_buffer",
+	"VK_KHR_portability_subset", // TODO: nice to have!
+	"VK_NV_ray_tracing", // only KHR ray tracing is supported
+	"VK_NV_shading_rate_image",
+	"VK_AMD_buffer_marker", // TODO: just new cmd command!
+	"VK_EXT_video_decode_h265",
+	"VK_GGP_frame_token",
+	"VK_NV_mesh_shader",
+	"VK_NV_scissor_exclusive", // new command
+	"VK_NV_device_diagnostic_checkpoints", // new command
+	"VK_INTEL_performance_query", // new command
+	"VK_KHR_dynamic_rendering_local_read", // TODO: 1.4 core
+	"VK_KHR_pipeline_executable_properties", // TODO: also show props in GUI
+	"VK_EXT_host_image_copy",
+	"VK_NV_device_generated_commands",
+	"VK_EXT_private_data", // TODO: will likely crash quickly
+	"VK_KHR_video_encode_queue",
+	"VK_NV_cuda_kernel_launch",
+	"VK_KHR_object_refresh", // commands
+	"VK_QCOM_tile_shading", // commands
+	"VK_EXT_metal_objects",
+	"VK_EXT_descriptor_buffer", // TODO!
+	"VK_NV_fragment_shading_rate_enums", // command
+	"VK_NV_ray_tracing_motion_blur", // might work as nop?
+	"VK_EXT_image_compression_control", // image wrapped
+	"VK_NV_acquire_winrt_display",
+	"VK_FUCHSIA_external_memory",
+	"VK_FUCHSIA_external_semaphore",
+	"VK_FUCHSIA_buffer_collection",
+	"VK_HUAWEI_subpass_shading", // command
+	"VK_HUAWEI_invocation_mask", // command
+	"VK_NV_external_memory_rdma",
+	"VK_EXT_pipeline_properties", // TODO
+	"VK_NV_external_sci_sync",
+	"VK_NV_external_memory_sci_buf",
+	"VK_EXT_frame_boundary", // handle unwrapping. TODO: use!
+	"VK_EXT_multisampled_render_to_single_sampled",
+	"VK_VALVE_video_encode_rgb_conversion",
+	"VK_EXT_opacity_micromap",
+	"VK_NV_displacement_micromap",
+	"VK_HUAWEI_cluster_culling_shader",
+	"VK_VALVE_descriptor_set_host_mapping", // TODO
+	"VK_ARM_render_pass_striped",
+	"VK_NV_copy_memory_indirect", // commands
+	"VK_NV_memory_decompression", // commands
+	"VK_NV_device_generated_commands_compute",
+	"VK_NV_ray_tracing_linear_swept_spheres",
+	"VK_OHOS_external_memory",
+	"VK_EXT_subpass_merge_feedback", // struct pointer patching
+	"VK_ARM_tensors",
+	"VK_NV_optical_flow", // command
+	"VK_ANDROID_external_format_resolve",
+	"VK_AMDX_dense_geometry_format",
+	"VK_KHR_pipeline_binary", // TODO
+	"VK_QCOM_tile_properties",
+	"VK_SEC_amigo_profiling",
+	"VK_QCOM_multiview_per_view_viewports",
+	"VK_NV_external_sci_sync2",
+	"VK_NV_cooperative_vector",
+	"VK_ARM_data_graph",
+	"VK_QCOM_multiview_per_view_render_areas",
+	"VK_KHR_video_decode_av1",
+	"VK_KHR_video_encode_av1",
+	"VK_KHR_video_decode_vp9",
+	"VK_KHR_video_maintenance1",
+	"VK_NV_per_stage_descriptor_set",
+	"VK_EXT_attachment_feedback_loop_dynamic_state", // TODO
+	"VK_EXT_vertex_attribute_divisor", // TODO: pNext pointer patching
+	"VK_KHR_vertex_attribute_divisor", // TODO: pNext pointer patching
+	"VK_QNX_external_memory_screen_buffer",
+	"VK_QCOM_tile_memory_heap",
+	"VK_KHR_copy_memory_indirect", // TODO commands
+	"VK_EXT_memory_decompression", // TODO commands
+	"VK_KHR_video_encode_intra_refresh",
+	"VK_KHR_video_encode_quantization_map",
+	"VK_NV_external_compute_queue",
+	"VK_NV_command_buffer_inheritance", // would need huge rework of cb state
+	"VK_NV_cluster_acceleration_structure",
+	"VK_NV_partitioned_acceleration_structure",
+	"VK_KHR_video_maintenance2",
+	"VK_OHOS_native_buffer",
+	"VK_HUAWEI_hdr_vivid",
+	"VK_ARM_pipeline_opacity_micromap",
+	"VK_EXT_external_memory_metal",
+	"VK_ARM_performance_counters_by_region",
+	"VK_VALVE_fragment_density_map_layered",
+	"VK_EXT_fragment_density_map_offset", // command
+	"VK_EXT_custom_resolve", // commands
+	"VK_QCOM_data_graph_model",
+	"VK_KHR_maintenance10", // TODO: CmdEndRendering2
+	"VK_SEC_pipeline_cache_incremental_mode",
+	"VK_KHR_depth_stencil_resolve", // TODO: pNext pointer patching
+};
+
+// last VK_EXT_image_compression_control
+
+} // namespace
diff --git a/src/gui/cb.cpp b/src/gui/cb.cpp
index c631e57e..1a5a9316 100644
--- a/src/gui/cb.cpp
+++ b/src/gui/cb.cpp
@@ -32,7 +32,6 @@
 #include <vk/format_utils.h>
 #include <imgui/imgui.h>
 #include <imgui/imgui_internal.h>
-#include <bitset>
 #include <filesystem>
 
 namespace fs = std::filesystem;
@@ -611,6 +610,8 @@ void CommandRecordGui::displaySubmission(FrameSubmission& batch, u32 subID) {
 }
 
 void CommandRecordGui::displayBatch(FrameSubmission& batch, u32 batchID) {
+	(void) batchID;
+
 	const auto id = dlg::format("submission:{}", batch.submissionID);
 	auto flags = int(ImGuiTreeNodeFlags_FramePadding | ImGuiTreeNodeFlags_SpanFullWidth);
 
diff --git a/src/gui/command.cpp b/src/gui/command.cpp
index e9eb2fd6..426d77b5 100644
--- a/src/gui/command.cpp
+++ b/src/gui/command.cpp
@@ -949,7 +949,7 @@ void CommandViewer::displayDs(Draw& draw) {
 		}
 
 		// general info
-		auto& elem = buffers(dsState, bindingID)[elemID];
+		auto& elem = dsBuffer(dsState, bindingID, elemID);
 		dlg_assert(elem.buffer);
 
 		ImGui::SameLine();
@@ -1007,7 +1007,7 @@ void CommandViewer::displayDs(Draw& draw) {
 			if(bindingLayout.immutableSamplers) {
 				refButtonExpect(gui, bindingLayout.immutableSamplers[elemID].get());
 			} else {
-				auto& elem = images(dsState, bindingID)[elemID];
+				auto& elem = dsImage(dsState, bindingID, elemID);
 				refButtonExpect(gui, elem.sampler);
 			}
 		}
@@ -1015,7 +1015,7 @@ void CommandViewer::displayDs(Draw& draw) {
 		// == Image ==
 		if(needsImageView(dsType)) {
 			// general info
-			auto& elem = images(dsState, bindingID)[elemID];
+			auto& elem = dsImage(dsState, bindingID, elemID);
 			dlg_assertm_or(elem.imageView, return, "dsType {}", vk::name(dsType));
 
 			// refButton(gui, imgView);
@@ -1072,7 +1072,7 @@ void CommandViewer::displayDs(Draw& draw) {
 	} else if(dsCat == DescriptorCategory::bufferView) {
 		imGuiText("TODO: bufferView viewer not implemented yet");
 	} else if(dsCat == DescriptorCategory::accelStruct) {
-		auto& elem = accelStructs(dsState, bindingID)[elemID];
+		auto& elem = dsAccelStruct(dsState, bindingID, elemID);
 		refButtonExpect(gui, elem.accelStruct);
 
 		// content
@@ -1595,7 +1595,7 @@ void CommandViewer::displayCommand() {
 		}
 	}
 
-	if(isStateCmd(*command_.back())) {
+	if(isStateCmd(*command_.back()) && supportsShaderDebug(dev())) {
 		auto* dcmd = deriveCast<const StateCmdBase*>(command_.back());
 		// NOTE: we do not support traceRaysIndirect as of now.
 		// This would make shader table hooking significantly more complicated.
diff --git a/src/gui/resources.cpp b/src/gui/resources.cpp
index 55d572fe..c4c33705 100644
--- a/src/gui/resources.cpp
+++ b/src/gui/resources.cpp
@@ -566,10 +566,11 @@ void ResourceGui::drawDesc(Draw&, DescriptorSet& ds) {
 	for(auto b = 0u; b < ds.layout->bindings.size(); ++b) {
 		auto& layout = ds.layout->bindings[b];
 
-		auto print = [&](VkDescriptorType type, unsigned b, unsigned e) {
+		auto print = [&](unsigned b, unsigned e) {
+			auto type = descriptorType(state, b, e);
 			switch(category(type)) {
 				case DescriptorCategory::image: {
-					auto& binding = images(state, b)[e];
+					auto& binding = dsImage(state, b, e);
 					bool append = false;
 					if(needsImageView(type)) {
 						if(append) {
@@ -594,17 +595,17 @@ void ResourceGui::drawDesc(Draw&, DescriptorSet& ds) {
 					}
 					break;
 				} case DescriptorCategory::buffer: {
-					auto& binding = buffers(state, b)[e];
+					auto& binding = dsBuffer(state, b, e);
 					refButtonD(*gui_, binding.buffer);
 					ImGui::SameLine();
 					drawOffsetSize(binding);
 					break;
 				} case DescriptorCategory::bufferView: {
-					auto& binding = bufferViews(state, b)[e];
+					auto& binding = dsBufferView(state, b, e);
 					refButtonD(*gui_, binding.bufferView);
 					break;
 				} case DescriptorCategory::accelStruct: {
-					auto& binding = accelStructs(state, b)[e];
+					auto& binding = dsAccelStruct(state, b, e);
 					refButtonD(*gui_, binding.accelStruct);
 					break;
 				} default:
@@ -623,7 +624,7 @@ void ResourceGui::drawDesc(Draw&, DescriptorSet& ds) {
 					imGuiText("{}: ", e);
 					ImGui::SameLine();
 
-					print(layout.descriptorType, b, e);
+					print(b, e);
 				}
 
 				ImGui::TreePop();
@@ -635,7 +636,7 @@ void ResourceGui::drawDesc(Draw&, DescriptorSet& ds) {
 			ImGui::Indent();
 			ImGui::Indent();
 
-			print(layout.descriptorType, b, 0);
+			print(b, 0);
 
 			ImGui::Unindent();
 			ImGui::Unindent();
diff --git a/src/image.cpp b/src/image.cpp
index 4d1cc19b..d5fe6acc 100644
--- a/src/image.cpp
+++ b/src/image.cpp
@@ -405,20 +405,35 @@ VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(
 	for(auto i = 0u; i < bindInfoCount; ++i) {
 		auto& bind = pBindInfos[i];
 		dlg_assert(bind.image);
+
 		auto& img = get(dev, bind.image);
 
 		fwd[i] = bind;
 		fwd[i].image = img.handle;
 
 		// can be VK_NULL_HANDLE, e.g. for VkBindImageMemorySwapchainInfoKHR
+		if(fwd[i].memory) {
+			auto& mem = get(dev, fwd[i].memory);
+			fwd[i].memory = mem.handle;
+		}
+	}
+
+	auto res = dev.dispatch.BindImageMemory2(dev.handle, u32(fwd.size()), fwd.data());
+	if(res != VK_SUCCESS) {
+		return res;
+	}
+
+	for(auto i = 0u; i < bindInfoCount; ++i) {
+		auto& bind = pBindInfos[i];
+		auto& img = get(dev, bind.image);
+
 		if(bind.memory) {
 			auto& mem = get(dev, bind.memory);
 			bindImageMemory(img, mem, bind.memoryOffset);
-			fwd[i].memory = mem.handle;
 		}
 	}
 
-	return dev.dispatch.BindImageMemory2(dev.handle, u32(fwd.size()), fwd.data());
+	return res;
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(
@@ -428,9 +443,14 @@ VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(
 		VkDeviceSize                                memoryOffset) {
 	auto& img = get(device, image);
 	auto& mem = get(device, memory);
-	bindImageMemory(img, mem, memoryOffset);
-	return img.dev->dispatch.BindImageMemory(img.dev->handle, img.handle,
+	auto res = img.dev->dispatch.BindImageMemory(img.dev->handle, img.handle,
 		mem.handle, memoryOffset);
+	if (res != VK_SUCCESS) {
+		return res;
+	}
+
+	bindImageMemory(img, mem, memoryOffset);
+	return res;
 }
 
 // ImageView
diff --git a/src/image.hpp b/src/image.hpp
index b0a849fc..1c1dd7a6 100644
--- a/src/image.hpp
+++ b/src/image.hpp
@@ -116,6 +116,7 @@ VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(
     uint32_t*                                   pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
 
+// VK_EXT_image_drm_format_modifier
 VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT(
     VkDevice                                    device,
     VkImage                                     image,
diff --git a/src/layer.cpp b/src/layer.cpp
index fb3c43a6..c9653b82 100644
--- a/src/layer.cpp
+++ b/src/layer.cpp
@@ -17,6 +17,7 @@
 #include <overlay.hpp>
 #include <accelStruct.hpp>
 #include <threadContext.hpp>
+#include <exts.hpp>
 #include <gencmd.hpp>
 #include <util/util.hpp>
 #include <util/export.hpp>
@@ -47,6 +48,7 @@ namespace vil {
 static auto dlgWarnErrorCount = 0u;
 static auto breakOnError = false;
 static auto dlgMinLevel = dlg_level_trace;
+static std::FILE* dlgLogFile {};
 
 // TODO: doesn't belong here
 std::mutex ThreadContext::mutex_;
@@ -62,7 +64,8 @@ void dlgHandler(const struct dlg_origin* origin, const char* string, void* data)
 		return;
 	}
 
-	dlg_default_output(origin, string, data);
+	(void) data;
+	dlg_default_output(origin, string, dlgLogFile);
 
 	if(origin->level >= dlg_level_warn) {
 		++dlgWarnErrorCount;
@@ -188,6 +191,15 @@ VkResult doCreateInstance(
 			else dlg_error("Invalid value for VIL_MIN_LOG_LEVEL: {}", minLevel);
 		}
 
+		if(const char* logFileStr = std::getenv("VIL_LOG_FILE"); logFileStr) {
+			if (dlgLogFile) {
+				std::fclose(dlgLogFile);
+			}
+
+			dlgLogFile = std::fopen(logFileStr, "w");
+			dlg_assert(dlgLogFile);
+		}
+
 		dlg_set_handler(dlgHandler, nullptr);
 		#ifdef _WIN32
 			AllocConsole();
@@ -314,6 +326,29 @@ VkResult doCreateInstance(
 	auto extsEnd = ci->ppEnabledExtensionNames + ci->enabledExtensionCount;
 	ini.extensions = {extsBegin, extsEnd};
 
+	constexpr auto checkExts = true;
+	const auto allowUnsupported = checkEnvBinary("VIL_ALLOW_UNSUPPORTED_EXTS", false);
+	if(checkExts) {
+		for(std::string_view ext : ini.extensions) {
+			if(contains(unsupportedInstanceExts, ext)) {
+				auto str = dlg::format("Application requested device extension '{}' that is "
+					"explicitly not supported by vil", ext);
+
+				if (!allowUnsupported) {
+					dlg_error("{}.\nYou can run again with env variable VIL_ALLOW_UNSUPPORTED_EXTS=1 to try anyways", str);
+					return VK_ERROR_EXTENSION_NOT_PRESENT;
+				}
+
+				dlg_error("{}", str);
+			}
+
+			if(!contains(supportedInstanceExts, ext)) {
+				dlg_error("Application requested unknown device extension '{}'", ext);
+			}
+		}
+	}
+
+
 	auto debugUtilsName = std::string_view(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
 	ini.debugUtilsEnabled = (std::find(extsBegin, extsEnd, debugUtilsName) != extsEnd);
 
@@ -628,6 +663,9 @@ static const std::unordered_map<std::string_view, HookedFunction> funcPtrTable {
 	VIL_DEV_HOOK_ALIAS_CORE(UnmapMemory2KHR, UnmapMemory2,
 		VK_KHR_MAP_MEMORY_2_EXTENSION_NAME),
 
+	VIL_DEV_HOOK_EXT(SetDeviceMemoryPriorityEXT,
+		VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME),
+
 	// shader.hpp
 	VIL_DEV_HOOK(CreateShaderModule, VK_API_VERSION_1_0),
 	VIL_DEV_HOOK(DestroyShaderModule, VK_API_VERSION_1_0),
diff --git a/src/memory.cpp b/src/memory.cpp
index 281a7468..c841ce9c 100644
--- a/src/memory.cpp
+++ b/src/memory.cpp
@@ -149,6 +149,24 @@ void DeviceMemory::onApiDestroy() {
 	allocations.clear();
 }
 
+// Calls the given callback for every resource overlapping the given
+// range of mem[off, off + size)
+template<typename F>
+void forEachOverlappingResourceLocked(const DeviceMemory& mem,
+		VkDeviceSize off, VkDeviceSize size, F&& callback) {
+	assertOwned(mem.dev->mutex);
+
+	MemoryBind tester {};
+	tester.memOffset = off;
+	tester.memory = const_cast<DeviceMemory*>(&mem);
+
+	auto end = off + size;
+	auto it = mem.allocations.lower_bound(&tester);
+	while(it != mem.allocations.end() && (*it)->memOffset < end) {
+		callback(**it);
+	}
+}
+
 // Memory
 VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(
 		VkDevice                                    device,
@@ -164,6 +182,10 @@ VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(
 	auto allocInfo = *pAllocateInfo;
 	allocInfo.pNext = chainCopy;
 
+	// TODO: track this
+	// Buffer* dedicatedBuffer {};
+	// Image* dedicatedImage {};
+
 	// unwrap handles in VkMemoryDedicatedAllocateInfo
 	auto* dedicatedv = findChainInfo2<VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO>(chainCopy);
 	if(dedicatedv) {
@@ -334,22 +356,13 @@ VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2(
 	return mem.dev->dispatch.UnmapMemory2(mem.dev->handle, &infoCopy);
 }
 
-// Calls the given callback for every resource overlapping the given
-// range of mem[off, off + size)
-template<typename F>
-void forEachOverlappingResourceLocked(const DeviceMemory& mem,
-		VkDeviceSize off, VkDeviceSize size, F&& callback) {
-	assertOwned(mem.dev->mutex);
-
-	MemoryBind tester {};
-	tester.memOffset = off;
-	tester.memory = const_cast<DeviceMemory*>(&mem);
-
-	auto end = off + size;
-	auto it = mem.allocations.lower_bound(&tester);
-	while(it != mem.allocations.end() && (*it)->memOffset < end) {
-		callback(**it);
-	}
+VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT(
+		VkDevice                                    device,
+		VkDeviceMemory                              memory,
+		float                                       priority) {
+	auto& mem = get(device, memory);
+	mem.priority = priority;
+	mem.dev->dispatch.SetDeviceMemoryPriorityEXT(mem.dev->handle, mem.handle, priority);
 }
 
 } // namespace vil
diff --git a/src/memory.hpp b/src/memory.hpp
index 24959cd1..937e8605 100644
--- a/src/memory.hpp
+++ b/src/memory.hpp
@@ -93,12 +93,17 @@ struct DeviceMemory : SharedDeviceHandle {
 
 	u32 typeIndex {};
 	VkDeviceSize size {};
+	float priority {}; // VK_EXT_pageable_device_local_memory
 
 	// Describes the current map state
 	void* map {}; // nullptr if not mapped
 	VkDeviceSize mapOffset {};
 	VkDeviceSize mapSize {};
 
+	// TODO: track this
+	// Image* dedicatedImage {};
+	// Image* dedicatedBuffer {};
+
 	// Sorted by memory offset. Keep in mind that allocations may alias. If
 	// multiple allocations have the same offset, the sorting between those
 	// is arbitrary.
@@ -155,4 +160,10 @@ VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2(
     VkDevice                                    device,
     const VkMemoryUnmapInfo*                    pMemoryUnmapInfo);
 
+// VK_EXT_pageable_device_local_memory
+VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    float                                       priority);
+
 } // namespace vil
diff --git a/src/pipe.cpp b/src/pipe.cpp
index 9fcd681c..0e6a2f2a 100644
--- a/src/pipe.cpp
+++ b/src/pipe.cpp
@@ -350,6 +350,10 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(
 		}
 
 		// extensions
+		// For the most part, we just hope the pNext chain does not need
+		// any patching.
+		pipe.exts = copyChain(pci.pNext);
+
 		auto* glibInfo = findChainInfo<VkGraphicsPipelineLibraryCreateInfoEXT,
 			VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT>(pci);
 		if(glibInfo) {
@@ -419,6 +423,8 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
 		pipe.layout = getPtr(dev, pCreateInfos[i].layout);
 		pipe.stage = PipelineShaderStage(dev, pCreateInfos[i].stage);
 		pipe.flags = pCreateInfos[i].flags;
+		pipe.exts = copyChain(pCreateInfos[i].pNext);
+
 		dlg_assert(pipe.stage.stage == VK_SHADER_STAGE_COMPUTE_BIT);
 
 		pPipelines[i] = castDispatch<VkPipeline>(static_cast<Pipeline&>(pipe));
@@ -736,6 +742,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR(
 		pipe.layout = getPtr(dev, ci.layout);
 		pipe.maxPipelineRayRecursionDepth = ci.maxPipelineRayRecursionDepth;
 		pipe.flags = ci.flags;
+		pipe.exts = copyChain(pCreateInfos[i].pNext);
 
 		// TODO: support, for shader patching
 		dlg_assertm(!ci.pLibraryInfo, "not supported");
diff --git a/src/pipe.hpp b/src/pipe.hpp
index 0fab3190..3bdaf7b8 100644
--- a/src/pipe.hpp
+++ b/src/pipe.hpp
@@ -96,6 +96,7 @@ struct GraphicsPipeline : Pipeline {
 	bool needsColorBlend : 1;
 
 	IntrusivePtr<XfbPatchDesc> xfbPatch; // valid when we injected xfb
+	std::unique_ptr<std::byte[]> exts; // copied pnext chain
 
 	VkGraphicsPipelineLibraryFlagsEXT libraryFlags {};
 
@@ -113,6 +114,7 @@ void fixPointers(GraphicsPipeline& pipe);
 
 struct ComputePipeline : Pipeline {
 	PipelineShaderStage stage;
+	std::unique_ptr<std::byte[]> exts; // copied pnext chain
 };
 
 struct RayTracingPipeline : Pipeline {
@@ -130,6 +132,8 @@ struct RayTracingPipeline : Pipeline {
 	std::unordered_set<VkDynamicState> dynamicState;
 	std::vector<std::byte> groupHandles;
 	u32 maxPipelineRayRecursionDepth;
+
+	std::unique_ptr<std::byte[]> exts; // copied pnext chain
 };
 
 // API
diff --git a/src/rp.cpp b/src/rp.cpp
index 20d44aa8..1ff38a0c 100644
--- a/src/rp.cpp
+++ b/src/rp.cpp
@@ -734,7 +734,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(
 
 	rp.desc.flags = pCreateInfo->flags;
 	rp.desc.pNext = pCreateInfo->pNext;
-	rp.desc.exts.push_back(copyChain(rp.desc.pNext));
+	rp.desc.exts.push_back(copyChainPatch(rp.desc.pNext));
 
 	// deep copy attachments & dependencies
 	upgrade(rp.desc.dependencies, pCreateInfo->pDependencies, pCreateInfo->dependencyCount);
@@ -834,18 +834,18 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2(
 	auto& rpi = *pCreateInfo;
 	rp.desc.flags = rpi.flags;
 	rp.desc.pNext = rpi.pNext;
-	rp.desc.exts.push_back(copyChain(rp.desc.pNext));
+	rp.desc.exts.push_back(copyChainPatch(rp.desc.pNext));
 
 	rp.desc.attachments = {rpi.pAttachments, rpi.pAttachments + rpi.attachmentCount};
 	rp.desc.subpasses = {rpi.pSubpasses, rpi.pSubpasses + rpi.subpassCount};
 	rp.desc.dependencies = {rpi.pDependencies, rpi.pDependencies + rpi.dependencyCount};
 
 	for(auto& att : rp.desc.attachments) {
-		copyChain(att.pNext, rp.desc.exts.emplace_back());
+		copyChainPatch(att.pNext, rp.desc.exts.emplace_back());
 	}
 
 	for(auto& dep : rp.desc.dependencies) {
-		copyChain(dep.pNext, rp.desc.exts.emplace_back());
+		copyChainPatch(dep.pNext, rp.desc.exts.emplace_back());
 	}
 
 	auto addAtts = [&](const VkAttachmentReference2* refs, std::size_t count) {
@@ -860,7 +860,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2(
 	};
 
 	for(auto& subp : rp.desc.subpasses) {
-		copyChain(subp.pNext, rp.desc.exts.emplace_back());
+		copyChainPatch(subp.pNext, rp.desc.exts.emplace_back());
 
 		auto& atts = rp.desc.attachmentRefs.emplace_back();
 		auto colorOff = addAtts(subp.pColorAttachments, subp.colorAttachmentCount);
diff --git a/src/rp.hpp b/src/rp.hpp
index 037fced5..7201d934 100644
--- a/src/rp.hpp
+++ b/src/rp.hpp
@@ -6,7 +6,6 @@
 #include <vk/vulkan.h>
 #include <vector>
 #include <memory>
-#include <atomic>
 
 namespace vil {
 
diff --git a/src/shader.hpp b/src/shader.hpp
index a757818b..6a802fea 100644
--- a/src/shader.hpp
+++ b/src/shader.hpp
@@ -167,4 +167,6 @@ VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT(
     size_t*                                     pDataSize,
     void*                                       pData);
 
+// VK_EXT_shader_module_identifier shouldn't need hooking (for now)
+
 } // namespace vil
diff --git a/src/swapchain.cpp b/src/swapchain.cpp
index 8fc609ac..576ad876 100644
--- a/src/swapchain.cpp
+++ b/src/swapchain.cpp
@@ -378,6 +378,8 @@ VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(
 		const auto supportedExts = {
 			VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT,
 			VK_STRUCTURE_TYPE_PRESENT_ID_KHR,
+			// NOTE: only works when fence is wrapped
+			VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR,
 		};
 		dlg_check({
 			auto it = static_cast<const VkBaseInStructure*>(pPresentInfo->pNext);
diff --git a/src/test/data/simple.comp b/src/test/data/simple.comp
index 55d45226..26cf0c7b 100644
--- a/src/test/data/simple.comp
+++ b/src/test/data/simple.comp
@@ -2,6 +2,8 @@
 
 #version 450
 
+layout(local_size_x = 4, local_size_y = 4) in;
+
 layout(set = 0, binding = 0) uniform sampler2D tex;
 layout(set = 0, binding = 1) buffer Buf {
 	vec4 val;
diff --git a/src/test/data/simple.comp.spv.h b/src/test/data/simple.comp.spv.h
index c523c007..e5288c29 100644
--- a/src/test/data/simple.comp.spv.h
+++ b/src/test/data/simple.comp.spv.h
@@ -1,10 +1,10 @@
 	// 1011.0.0
 	 #pragma once
 const uint32_t simple_comp_spv_data[] = {
-	0x07230203,0x00010000,0x0008000a,0x00000019,0x00000000,0x00020011,0x00000001,0x0006000b,
+	0x07230203,0x00010000,0x0008000a,0x0000001e,0x00000000,0x00020011,0x00000001,0x0006000b,
 	0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
 	0x0005000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x00060010,0x00000004,0x00000011,
-	0x00000001,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2,0x000a0004,0x475f4c47,
+	0x00000004,0x00000004,0x00000001,0x00030003,0x00000002,0x000001c2,0x000a0004,0x475f4c47,
 	0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x00006576,
 	0x00080004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x00657669,
 	0x00040005,0x00000004,0x6e69616d,0x00000000,0x00030005,0x00000008,0x00667542,0x00040006,
@@ -12,17 +12,20 @@ const uint32_t simple_comp_spv_data[] = {
 	0x00786574,0x00050048,0x00000008,0x00000000,0x00000023,0x00000000,0x00030047,0x00000008,
 	0x00000003,0x00040047,0x0000000a,0x00000022,0x00000000,0x00040047,0x0000000a,0x00000021,
 	0x00000001,0x00040047,0x00000010,0x00000022,0x00000000,0x00040047,0x00000010,0x00000021,
-	0x00000000,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,
-	0x00000020,0x00040017,0x00000007,0x00000006,0x00000004,0x0003001e,0x00000008,0x00000007,
-	0x00040020,0x00000009,0x00000002,0x00000008,0x0004003b,0x00000009,0x0000000a,0x00000002,
-	0x00040015,0x0000000b,0x00000020,0x00000001,0x0004002b,0x0000000b,0x0000000c,0x00000000,
-	0x00090019,0x0000000d,0x00000006,0x00000001,0x00000000,0x00000000,0x00000000,0x00000001,
-	0x00000000,0x0003001b,0x0000000e,0x0000000d,0x00040020,0x0000000f,0x00000000,0x0000000e,
-	0x0004003b,0x0000000f,0x00000010,0x00000000,0x00040017,0x00000012,0x00000006,0x00000002,
-	0x0004002b,0x00000006,0x00000013,0x3f000000,0x0005002c,0x00000012,0x00000014,0x00000013,
-	0x00000013,0x0004002b,0x00000006,0x00000015,0x00000000,0x00040020,0x00000017,0x00000002,
-	0x00000007,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,
-	0x0004003d,0x0000000e,0x00000011,0x00000010,0x00070058,0x00000007,0x00000016,0x00000011,
-	0x00000014,0x00000002,0x00000015,0x00050041,0x00000017,0x00000018,0x0000000a,0x0000000c,
-	0x0003003e,0x00000018,0x00000016,0x000100fd,0x00010038
+	0x00000000,0x00040047,0x0000001d,0x0000000b,0x00000019,0x00020013,0x00000002,0x00030021,
+	0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,0x00000006,
+	0x00000004,0x0003001e,0x00000008,0x00000007,0x00040020,0x00000009,0x00000002,0x00000008,
+	0x0004003b,0x00000009,0x0000000a,0x00000002,0x00040015,0x0000000b,0x00000020,0x00000001,
+	0x0004002b,0x0000000b,0x0000000c,0x00000000,0x00090019,0x0000000d,0x00000006,0x00000001,
+	0x00000000,0x00000000,0x00000000,0x00000001,0x00000000,0x0003001b,0x0000000e,0x0000000d,
+	0x00040020,0x0000000f,0x00000000,0x0000000e,0x0004003b,0x0000000f,0x00000010,0x00000000,
+	0x00040017,0x00000012,0x00000006,0x00000002,0x0004002b,0x00000006,0x00000013,0x3f000000,
+	0x0005002c,0x00000012,0x00000014,0x00000013,0x00000013,0x0004002b,0x00000006,0x00000015,
+	0x00000000,0x00040020,0x00000017,0x00000002,0x00000007,0x00040015,0x00000019,0x00000020,
+	0x00000000,0x00040017,0x0000001a,0x00000019,0x00000003,0x0004002b,0x00000019,0x0000001b,
+	0x00000004,0x0004002b,0x00000019,0x0000001c,0x00000001,0x0006002c,0x0000001a,0x0000001d,
+	0x0000001b,0x0000001b,0x0000001c,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,
+	0x000200f8,0x00000005,0x0004003d,0x0000000e,0x00000011,0x00000010,0x00070058,0x00000007,
+	0x00000016,0x00000011,0x00000014,0x00000002,0x00000015,0x00050041,0x00000017,0x00000018,
+	0x0000000a,0x0000000c,0x0003003e,0x00000018,0x00000016,0x000100fd,0x00010038
 };
diff --git a/src/test/integration/main.cpp b/src/test/integration/main.cpp
index 217bcb71..a61c54b3 100644
--- a/src/test/integration/main.cpp
+++ b/src/test/integration/main.cpp
@@ -449,8 +449,8 @@ int main() {
 	#define vilLoadSym(procName) *(void**) &(procName) = dlsym(handle, "vil_" #procName)
 #endif
 
-	PFN_vil_getErrorWarningCount getErrorWarningCount;
-	PFN_vil_runInternalIntegrationTets runInternalIntegrationTests;
+	PFN_vil_getErrorWarningCount getErrorWarningCount {};
+	PFN_vil_runInternalIntegrationTets runInternalIntegrationTests {};
 
 	vilLoadSym(getErrorWarningCount);
 	vilLoadSym(runInternalIntegrationTests);
diff --git a/src/util/ownbuf.cpp b/src/util/ownbuf.cpp
index 17c090ee..c27db566 100644
--- a/src/util/ownbuf.cpp
+++ b/src/util/ownbuf.cpp
@@ -71,6 +71,8 @@ void OwnBuffer::ensure(Device& dev, VkDeviceSize reqSize,
 
 	VkMemoryAllocateFlagsInfo flagsInfo {};
 	if(usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
+		dlg_assert(dev.bufferDeviceAddress);
+
 		flagsInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
 		flagsInfo.flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT;
 		allocInfo.pNext = &flagsInfo;
@@ -147,6 +149,8 @@ vku::BufferSpan OwnBuffer::asSpan(VkDeviceSize offset, VkDeviceSize size) const
 
 VkDeviceAddress OwnBuffer::queryAddress() const {
 	dlg_assert(dev && buf);
+	dlg_assert(dev->bufferDeviceAddress);
+
 	VkBufferDeviceAddressInfo info {};
 	info.sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
 	info.buffer = buf;
diff --git a/src/util/patch.cpp b/src/util/patch.cpp
index c36c9d31..1fe91117 100644
--- a/src/util/patch.cpp
+++ b/src/util/patch.cpp
@@ -1313,6 +1313,7 @@ vku::Pipeline createPatchCopy(const GraphicsPipeline& src,
 	gpi.pStages = patchedStages.stages.data();
 	gpi.renderPass = src.renderPass->handle; // TODO: can this be destroyed?
 	gpi.subpass = src.subpass;
+	gpi.pNext = src.exts.get();
 
 	return vku::Pipeline(dev, gpi);
 }
@@ -1326,6 +1327,7 @@ vku::Pipeline createPatchCopy(const RayTracingPipeline& src,
 	rti.sType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR;
 	rti.layout = src.layout->handle;
 	rti.maxPipelineRayRecursionDepth = src.maxPipelineRayRecursionDepth;
+	rti.pNext = src.exts.get();
 
 	// TODO DATA RACE!
 	/*
diff --git a/src/util/util.cpp b/src/util/util.cpp
index 98491e73..24da256b 100644
--- a/src/util/util.cpp
+++ b/src/util/util.cpp
@@ -105,7 +105,7 @@ std::size_t structSize(VkStructureType type) {
 	return size;
 }
 
-std::unique_ptr<std::byte[]> copyChain(const void*& pNext) {
+std::unique_ptr<std::byte[]> copyChain(const void* pNext) {
 	if(!pNext) {
 		return {};
 	}
@@ -154,12 +154,12 @@ std::unique_ptr<std::byte[]> copyChain(const void*& pNext) {
 	return buf;
 }
 
-void* copyChain(const void*& pNext, std::unique_ptr<std::byte[]>& buf) {
+void* copyChainPatch(const void*& pNext, std::unique_ptr<std::byte[]>& buf) {
 	if(!pNext) {
 		return nullptr;
 	}
 
-	buf = copyChain(pNext);
+	buf = copyChainPatch(pNext);
 	return static_cast<void*>(buf.get());
 }
 
diff --git a/src/util/util.hpp b/src/util/util.hpp
index 30f76168..f585e8af 100644
--- a/src/util/util.hpp
+++ b/src/util/util.hpp
@@ -98,7 +98,7 @@ auto find(C&& c, K&& k) {
 
 template<typename C, typename K>
 bool contains(C&& c, K&& k) {
-	return find(c, k) != c.end();
+	return find(c, k) != std::end(c);
 }
 
 template<typename C, typename F>
@@ -193,8 +193,14 @@ void* findChainInfo2(void* pNext) {
 	return nullptr;
 }
 
-std::unique_ptr<std::byte[]> copyChain(const void*& pNext);
-void* copyChain(const void*& pNext, std::unique_ptr<std::byte[]>& buf);
+std::unique_ptr<std::byte[]> copyChain(const void* pNext);
+inline std::unique_ptr<std::byte[]> copyChainPatch(const void*& pNext) {
+	auto ret = copyChain(pNext);
+	pNext = ret.get();
+	return ret;
+}
+
+void* copyChainPatch(const void*& pNext, std::unique_ptr<std::byte[]>& buf);
 
 void* copyChainLocal(ThreadMemScope&, const void* pNext);
 
diff --git a/src/vk/typemap_helper.h b/src/vk/typemap_helper.h
index 4b8ea8f7..a63568cb 100644
--- a/src/vk/typemap_helper.h
+++ b/src/vk/typemap_helper.h
@@ -30,7 +30,7 @@
  ****************************************************************************/
 
 #pragma once
-#include <vulkan/vulkan.h>
+#include <vk/vulkan.h>
 
 // These empty generic templates are specialized for each type with sType
 // members and for each sType -- providing a two way map between structure
diff --git a/src/vk/vk_video/vulkan_video_codec_av1std.h b/src/vk/vk_video/vulkan_video_codec_av1std.h
index 347e0d2a..59c2c8b2 100644
--- a/src/vk/vk_video/vulkan_video_codec_av1std.h
+++ b/src/vk/vk_video/vulkan_video_codec_av1std.h
@@ -22,27 +22,27 @@ extern "C" {
 // vulkan_video_codec_av1std is a preprocessor guard. Do not pass it to API calls.
 #define vulkan_video_codec_av1std 1
 #include "vulkan_video_codecs_common.h"
-#define STD_VIDEO_AV1_NUM_REF_FRAMES      8
-#define STD_VIDEO_AV1_REFS_PER_FRAME      7
-#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8
-#define STD_VIDEO_AV1_MAX_TILE_COLS       64
-#define STD_VIDEO_AV1_MAX_TILE_ROWS       64
-#define STD_VIDEO_AV1_MAX_SEGMENTS        8
-#define STD_VIDEO_AV1_SEG_LVL_MAX         8
-#define STD_VIDEO_AV1_PRIMARY_REF_NONE    7
-#define STD_VIDEO_AV1_SELECT_INTEGER_MV   2
-#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2
-#define STD_VIDEO_AV1_SKIP_MODE_FRAMES    2
-#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4
-#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2
-#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8
-#define STD_VIDEO_AV1_MAX_NUM_PLANES      3
-#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6
-#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS    14
-#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS   10
-#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS   10
-#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA    24
-#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA  25
+#define STD_VIDEO_AV1_NUM_REF_FRAMES      8U
+#define STD_VIDEO_AV1_REFS_PER_FRAME      7U
+#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8U
+#define STD_VIDEO_AV1_MAX_TILE_COLS       64U
+#define STD_VIDEO_AV1_MAX_TILE_ROWS       64U
+#define STD_VIDEO_AV1_MAX_SEGMENTS        8U
+#define STD_VIDEO_AV1_SEG_LVL_MAX         8U
+#define STD_VIDEO_AV1_PRIMARY_REF_NONE    7U
+#define STD_VIDEO_AV1_SELECT_INTEGER_MV   2U
+#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2U
+#define STD_VIDEO_AV1_SKIP_MODE_FRAMES    2U
+#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4U
+#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2U
+#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8U
+#define STD_VIDEO_AV1_MAX_NUM_PLANES      3U
+#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6U
+#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS    14U
+#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS   10U
+#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS   10U
+#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA    24U
+#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA  25U
 
 typedef enum StdVideoAV1Profile {
     STD_VIDEO_AV1_PROFILE_MAIN = 0,
diff --git a/src/vk/vk_video/vulkan_video_codec_h264std.h b/src/vk/vk_video/vulkan_video_codec_h264std.h
index 6fd38106..7e8da7d2 100644
--- a/src/vk/vk_video/vulkan_video_codec_h264std.h
+++ b/src/vk/vk_video/vulkan_video_codec_h264std.h
@@ -22,14 +22,14 @@ extern "C" {
 // vulkan_video_codec_h264std is a preprocessor guard. Do not pass it to API calls.
 #define vulkan_video_codec_h264std 1
 #include "vulkan_video_codecs_common.h"
-#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE  32
-#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6
-#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16
-#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 6
-#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64
-#define STD_VIDEO_H264_MAX_NUM_LIST_REF   32
-#define STD_VIDEO_H264_MAX_CHROMA_PLANES  2
-#define STD_VIDEO_H264_NO_REFERENCE_PICTURE 0xFF
+#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE  32U
+#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6U
+#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16U
+#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 6U
+#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64U
+#define STD_VIDEO_H264_MAX_NUM_LIST_REF   32U
+#define STD_VIDEO_H264_MAX_CHROMA_PLANES  2U
+#define STD_VIDEO_H264_NO_REFERENCE_PICTURE 0xFFU
 
 typedef enum StdVideoH264ChromaFormatIdc {
     STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0,
diff --git a/src/vk/vk_video/vulkan_video_codec_h264std_decode.h b/src/vk/vk_video/vulkan_video_codec_h264std_decode.h
index d6a90b49..01facd73 100644
--- a/src/vk/vk_video/vulkan_video_codec_h264std_decode.h
+++ b/src/vk/vk_video/vulkan_video_codec_h264std_decode.h
@@ -27,7 +27,7 @@ extern "C" {
 
 #define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0
 #define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_decode"
-#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2
+#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2U
 
 typedef enum StdVideoDecodeH264FieldOrderCount {
     STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0,
diff --git a/src/vk/vk_video/vulkan_video_codec_h265std.h b/src/vk/vk_video/vulkan_video_codec_h265std.h
index 3eecd601..20e97e39 100644
--- a/src/vk/vk_video/vulkan_video_codec_h265std.h
+++ b/src/vk/vk_video/vulkan_video_codec_h265std.h
@@ -22,29 +22,29 @@ extern "C" {
 // vulkan_video_codec_h265std is a preprocessor guard. Do not pass it to API calls.
 #define vulkan_video_codec_h265std 1
 #include "vulkan_video_codecs_common.h"
-#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE  32
-#define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7
-#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6
-#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16
-#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6
-#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS 64
-#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS 6
-#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64
-#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2
-#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64
-#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6
-#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19
-#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21
-#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3
-#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128
-#define STD_VIDEO_H265_MAX_NUM_LIST_REF   15
-#define STD_VIDEO_H265_MAX_CHROMA_PLANES  2
-#define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64
-#define STD_VIDEO_H265_MAX_DPB_SIZE       16
-#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32
-#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16
-#define STD_VIDEO_H265_MAX_DELTA_POC      48
-#define STD_VIDEO_H265_NO_REFERENCE_PICTURE 0xFF
+#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE  32U
+#define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7U
+#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6U
+#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16U
+#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6U
+#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS 64U
+#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS 6U
+#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64U
+#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2U
+#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64U
+#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6U
+#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19U
+#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21U
+#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3U
+#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128U
+#define STD_VIDEO_H265_MAX_NUM_LIST_REF   15U
+#define STD_VIDEO_H265_MAX_CHROMA_PLANES  2U
+#define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64U
+#define STD_VIDEO_H265_MAX_DPB_SIZE       16U
+#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32U
+#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16U
+#define STD_VIDEO_H265_MAX_DELTA_POC      48U
+#define STD_VIDEO_H265_NO_REFERENCE_PICTURE 0xFFU
 
 typedef enum StdVideoH265ChromaFormatIdc {
     STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0,
diff --git a/src/vk/vk_video/vulkan_video_codec_h265std_decode.h b/src/vk/vk_video/vulkan_video_codec_h265std_decode.h
index a9e1a096..a2ddcaa4 100644
--- a/src/vk/vk_video/vulkan_video_codec_h265std_decode.h
+++ b/src/vk/vk_video/vulkan_video_codec_h265std_decode.h
@@ -27,7 +27,7 @@ extern "C" {
 
 #define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0
 #define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_decode"
-#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8
+#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8U
 typedef struct StdVideoDecodeH265PictureInfoFlags {
     uint32_t    IrapPicFlag : 1;
     uint32_t    IdrPicFlag  : 1;
diff --git a/src/vk/vk_video/vulkan_video_codec_vp9std.h b/src/vk/vk_video/vulkan_video_codec_vp9std.h
new file mode 100644
index 00000000..3d10e39d
--- /dev/null
+++ b/src/vk/vk_video/vulkan_video_codec_vp9std.h
@@ -0,0 +1,151 @@
+#ifndef VULKAN_VIDEO_CODEC_VP9STD_H_
+#define VULKAN_VIDEO_CODEC_VP9STD_H_ 1
+
+/*
+** Copyright 2015-2025 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+// vulkan_video_codec_vp9std is a preprocessor guard. Do not pass it to API calls.
+#define vulkan_video_codec_vp9std 1
+#include "vulkan_video_codecs_common.h"
+#define STD_VIDEO_VP9_NUM_REF_FRAMES      8U
+#define STD_VIDEO_VP9_REFS_PER_FRAME      3U
+#define STD_VIDEO_VP9_MAX_REF_FRAMES      4U
+#define STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS 2U
+#define STD_VIDEO_VP9_MAX_SEGMENTS        8U
+#define STD_VIDEO_VP9_SEG_LVL_MAX         4U
+#define STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS 7U
+#define STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB 3U
+
+typedef enum StdVideoVP9Profile {
+    STD_VIDEO_VP9_PROFILE_0 = 0,
+    STD_VIDEO_VP9_PROFILE_1 = 1,
+    STD_VIDEO_VP9_PROFILE_2 = 2,
+    STD_VIDEO_VP9_PROFILE_3 = 3,
+    STD_VIDEO_VP9_PROFILE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_VP9_PROFILE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9Profile;
+
+typedef enum StdVideoVP9Level {
+    STD_VIDEO_VP9_LEVEL_1_0 = 0,
+    STD_VIDEO_VP9_LEVEL_1_1 = 1,
+    STD_VIDEO_VP9_LEVEL_2_0 = 2,
+    STD_VIDEO_VP9_LEVEL_2_1 = 3,
+    STD_VIDEO_VP9_LEVEL_3_0 = 4,
+    STD_VIDEO_VP9_LEVEL_3_1 = 5,
+    STD_VIDEO_VP9_LEVEL_4_0 = 6,
+    STD_VIDEO_VP9_LEVEL_4_1 = 7,
+    STD_VIDEO_VP9_LEVEL_5_0 = 8,
+    STD_VIDEO_VP9_LEVEL_5_1 = 9,
+    STD_VIDEO_VP9_LEVEL_5_2 = 10,
+    STD_VIDEO_VP9_LEVEL_6_0 = 11,
+    STD_VIDEO_VP9_LEVEL_6_1 = 12,
+    STD_VIDEO_VP9_LEVEL_6_2 = 13,
+    STD_VIDEO_VP9_LEVEL_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_VP9_LEVEL_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9Level;
+
+typedef enum StdVideoVP9FrameType {
+    STD_VIDEO_VP9_FRAME_TYPE_KEY = 0,
+    STD_VIDEO_VP9_FRAME_TYPE_NON_KEY = 1,
+    STD_VIDEO_VP9_FRAME_TYPE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_VP9_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9FrameType;
+
+typedef enum StdVideoVP9ReferenceName {
+    STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME = 0,
+    STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME = 1,
+    STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME = 2,
+    STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME = 3,
+    STD_VIDEO_VP9_REFERENCE_NAME_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_VP9_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9ReferenceName;
+
+typedef enum StdVideoVP9InterpolationFilter {
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP = 0,
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1,
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2,
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR = 3,
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE = 4,
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9InterpolationFilter;
+
+typedef enum StdVideoVP9ColorSpace {
+    STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN = 0,
+    STD_VIDEO_VP9_COLOR_SPACE_BT_601 = 1,
+    STD_VIDEO_VP9_COLOR_SPACE_BT_709 = 2,
+    STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170 = 3,
+    STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240 = 4,
+    STD_VIDEO_VP9_COLOR_SPACE_BT_2020 = 5,
+    STD_VIDEO_VP9_COLOR_SPACE_RESERVED = 6,
+    STD_VIDEO_VP9_COLOR_SPACE_RGB = 7,
+    STD_VIDEO_VP9_COLOR_SPACE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_VP9_COLOR_SPACE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9ColorSpace;
+typedef struct StdVideoVP9ColorConfigFlags {
+    uint32_t    color_range : 1;
+    uint32_t    reserved : 31;
+} StdVideoVP9ColorConfigFlags;
+
+typedef struct StdVideoVP9ColorConfig {
+    StdVideoVP9ColorConfigFlags    flags;
+    uint8_t                        BitDepth;
+    uint8_t                        subsampling_x;
+    uint8_t                        subsampling_y;
+    uint8_t                        reserved1;
+    StdVideoVP9ColorSpace          color_space;
+} StdVideoVP9ColorConfig;
+
+typedef struct StdVideoVP9LoopFilterFlags {
+    uint32_t    loop_filter_delta_enabled : 1;
+    uint32_t    loop_filter_delta_update : 1;
+    uint32_t    reserved : 30;
+} StdVideoVP9LoopFilterFlags;
+
+typedef struct StdVideoVP9LoopFilter {
+    StdVideoVP9LoopFilterFlags    flags;
+    uint8_t                       loop_filter_level;
+    uint8_t                       loop_filter_sharpness;
+    uint8_t                       update_ref_delta;
+    int8_t                        loop_filter_ref_deltas[STD_VIDEO_VP9_MAX_REF_FRAMES];
+    uint8_t                       update_mode_delta;
+    int8_t                        loop_filter_mode_deltas[STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS];
+} StdVideoVP9LoopFilter;
+
+typedef struct StdVideoVP9SegmentationFlags {
+    uint32_t    segmentation_update_map : 1;
+    uint32_t    segmentation_temporal_update : 1;
+    uint32_t    segmentation_update_data : 1;
+    uint32_t    segmentation_abs_or_delta_update : 1;
+    uint32_t    reserved : 28;
+} StdVideoVP9SegmentationFlags;
+
+typedef struct StdVideoVP9Segmentation {
+    StdVideoVP9SegmentationFlags    flags;
+    uint8_t                         segmentation_tree_probs[STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS];
+    uint8_t                         segmentation_pred_prob[STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB];
+    uint8_t                         FeatureEnabled[STD_VIDEO_VP9_MAX_SEGMENTS];
+    int16_t                         FeatureData[STD_VIDEO_VP9_MAX_SEGMENTS][STD_VIDEO_VP9_SEG_LVL_MAX];
+} StdVideoVP9Segmentation;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/vk/vk_video/vulkan_video_codec_vp9std_decode.h b/src/vk/vk_video/vulkan_video_codec_vp9std_decode.h
new file mode 100644
index 00000000..42b9bd3f
--- /dev/null
+++ b/src/vk/vk_video/vulkan_video_codec_vp9std_decode.h
@@ -0,0 +1,68 @@
+#ifndef VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_
+#define VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ 1
+
+/*
+** Copyright 2015-2025 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+// vulkan_video_codec_vp9std_decode is a preprocessor guard. Do not pass it to API calls.
+#define vulkan_video_codec_vp9std_decode 1
+#include "vulkan_video_codec_vp9std.h"
+
+#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
+
+#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0
+#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_vp9_decode"
+typedef struct StdVideoDecodeVP9PictureInfoFlags {
+    uint32_t    error_resilient_mode : 1;
+    uint32_t    intra_only : 1;
+    uint32_t    allow_high_precision_mv : 1;
+    uint32_t    refresh_frame_context : 1;
+    uint32_t    frame_parallel_decoding_mode : 1;
+    uint32_t    segmentation_enabled : 1;
+    uint32_t    show_frame : 1;
+    uint32_t    UsePrevFrameMvs : 1;
+    uint32_t    reserved : 24;
+} StdVideoDecodeVP9PictureInfoFlags;
+
+typedef struct StdVideoDecodeVP9PictureInfo {
+    StdVideoDecodeVP9PictureInfoFlags    flags;
+    StdVideoVP9Profile                   profile;
+    StdVideoVP9FrameType                 frame_type;
+    uint8_t                              frame_context_idx;
+    uint8_t                              reset_frame_context;
+    uint8_t                              refresh_frame_flags;
+    uint8_t                              ref_frame_sign_bias_mask;
+    StdVideoVP9InterpolationFilter       interpolation_filter;
+    uint8_t                              base_q_idx;
+    int8_t                               delta_q_y_dc;
+    int8_t                               delta_q_uv_dc;
+    int8_t                               delta_q_uv_ac;
+    uint8_t                              tile_cols_log2;
+    uint8_t                              tile_rows_log2;
+    uint16_t                             reserved1[3];
+    const StdVideoVP9ColorConfig*        pColorConfig;
+    const StdVideoVP9LoopFilter*         pLoopFilter;
+    const StdVideoVP9Segmentation*       pSegmentation;
+} StdVideoDecodeVP9PictureInfo;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif