vulkan bindings update with bit_set/bit_field handling changes

vendor/vulkan/_gen/create_vulkan_odin_wrapper.py

@@ -338,7 +338,6 @@ def parse_enums(f):
             generated_flags.add(flags_name)
             f.write("{} :: distinct bit_set[{}; Flags]\n".format(flags_name, enum_name))
 
-
         if is_flag_bit:
             f.write("{} :: enum Flags {{\n".format(name.replace("FlagBits", "Flag")))
         else:
@@ -537,80 +536,164 @@ def parse_fake_enums(f):
 
         f.write("}\n\n")
 
+class BitfieldError(ValueError):
+    pass
+
+def bitfield_type_to_size(type_):
+    if type_ == 'u8':
+        return 8
+    if type_ == 'u16':
+        return 16
+    if type_ == 'u32':
+        return 32
+    if type_ == 'u64':
+        return 64
+    if 'Flags' in type_:
+        return 32
+    else:
+        raise BitfieldError(f"Invalid type for bitfield: {type_}")
+
+def bitfield_size_to_type(size):
+    if size == 8:
+        return 'u8'
+    if size == 16:
+        return 'u16'
+    if size == 32:
+        return 'u32'
+    if size == 64:
+        return 'u64'
+    else:
+        raise BitfieldError(f"Invalid size for bitfield: {size}")
+
+
+class Bitfield:
+    class Field:
+        def __init__(self, name, type_, bitsize):
+            self.name = name
+            self.type = type_
+            self.bitsize = bitsize
+            
+    def __init__(self, type_):
+        self.bitsize = bitfield_type_to_size(type_)
+        self.type = bitfield_size_to_type(self.bitsize)
+        self.fields_bitsize = 0
+        self.fields = []
+
+    def add_field(self, name, type_, bitsize):
+        self.fields.append(Bitfield.Field(name, type_, bitsize))
+        self.fields_bitsize += bitsize
+        
+    def write(self, f, name=None, indent=0, justify=True):
+        max_name = 1 if not justify else max([len(f.name) for f in self.fields], default=0)
+        max_type = 1 if not justify else max([len(f.type) for f in self.fields], default=0)
+        is_bit_set = all([f.bitsize == 1 or f.name == "reserved" for f in self.fields])
+        if is_bit_set and name is None:
+            raise BitfieldError(f"bit_set can not be anonymous")
+            
+        if is_bit_set:
+            if not name.endswith("Flags"):
+                raise BitfieldError(f"bit_set name should end with 'Flags': {name}")
+            enum_name = re.sub('Flags$', 'Flag', name)
+            f.write("{}{} :: distinct bit_set[{}; {}]\n".format('\t' * indent, name, enum_name, self.type))
+            f.write("{}{} :: enum {} {{\n".format('\t' * indent, enum_name, self.type))
+            for field in self.fields:
+                if field.name != "reserved":
+                    f.write("{}{},\n".format('\t' * (indent + 1), field.name))
+            f.write(('\t' * indent) + "}\n")
+                
+        else:
+            f.write("{}{} bit_field {} {{\n".format('\t' * indent, name + ' ::' if name else 'using _:', self.type))
+            for field in self.fields:
+                type_ = field.type.replace("Flags", "Flag")
+                f.write("{}{} {} | {},\n".format(
+                    '\t' * (indent + 1),
+                    (field.name + ":").ljust(max_name + 1),
+                    type_.ljust(max_type),
+                    field.bitsize))
+            f.write(('\t' * indent) + "}" + ("," if name is None else "") + "\n")
+
 def parse_structs(f):
     data = re.findall(r"typedef (struct|union) Vk(\w+?) {(.+?)} \w+?;", src, re.S)
     data += re.findall(r"typedef (struct|union) Std(\w+?) {(.+?)} \w+?;", src, re.S)
 
-    for _type, name, fields in data:
+    for _type, struct_name, fields in data:
         fields = re.findall(r"\s+(.+?)[\s:]+([_a-zA-Z0-9[\]]+);", fields)
-        f.write("{} :: struct ".format(name))
-        if _type == "union":
-            f.write("#raw_union ")
-        f.write("{\n")
-
 
         prev_name = ""
         ffields = []
+        bitfield = None
         for type_, fname in fields:
-
             # If the field name only has a number in it, then it is a C bit field.
+            # We will collect all the bit fields and then create either a bit_field or a bit_set.
             if is_int(fname):
-                comment = None
+                bf_field = type_.split(' ')
-                bit_field = type_.split(' ')
                 # Get rid of empty spaces
-                bit_field = list(filter(bool, bit_field))
+                bf_field = list(filter(bool, bf_field))
                 # [type, fieldname]
-                assert len(bit_field) == 2, "Failed to parse the bit field!"
+                assert len(bf_field) == 2, "Failed to parse the bit field!"
+                field_type = do_type(bf_field[0])
+                bitsize = int(fname)
 
+                # Close the set because the field size is greater than the bitfield type
+                if bitfield and (bitfield.fields_bitsize + bitsize) > bitfield_type_to_size(field_type):
+                    ffields.append(tuple([None, bitfield]))
+                    bitfield = None
 
-                bit_field_type = ""
+                # Raise an error if the field type size is greater than the bitfield type size
-                # Right now there are only two ways that C bit fields exist in
+                if bitfield is not None and bitfield_type_to_size(bitfield.type) < bitfield_type_to_size(field_type):
-                # the header files.
+                    raise BitfieldError(f"field will not fit in the bitfield: {bitfield.type} < {field_type}")
 
-                # First one uses the 8 MOST significant bits for one field, and
+                # Create a new bitfield if we don't have one
-                # 24 bits for the other field.
+                if not bitfield:
-                # In the bindings these two fields are merged into one u32.
+                    bitfield = Bitfield(field_type)
-                if int(fname) == 24:
-                    prev_name = bit_field[1]
-                    continue
-
-                elif prev_name:
-                    bit_field_type = do_type("uint32_t")
-                    bit_field_name = prev_name + "And" + bit_field[1].capitalize()
-                    comment = " // Most significant byte is {}".format(bit_field[1])
-                    ffields.append(tuple([bit_field_name, bit_field_type, comment]))
-                    prev_name = ""
-                    continue
-
-                # The second way has many fields that are each 1 bit
-                elif int(fname) == 1:
-                    bit_field_type = do_type(bit_field[0], prev_name, fname)
-                    ffields.append(tuple(["bitfield", bit_field_type, comment]))
-                    break
 
+                    # Add the field to the bitfield
+                bitfield.add_field(bf_field[1], 'bool' if bitsize == 1 else field_type, bitsize)
+                continue
 
+            # Close the bitfield because this is not a field
+            elif bitfield:
+                ffields.append(tuple([None, bitfield]))
+                bitfield = None
 
             if '[' in fname:
                 fname, type_ = parse_array(fname, type_)
-            comment = None
             n = fix_arg(fname)
             if "Flag_Bits" in type_:
-                comment = " // only single bit set"
+                # comment = " // only single bit set"
+                raise BitfieldError("only single bit set")
             t = do_type(type_, prev_name, fname)
             if n == "matrix":
                 n = "mat"
 
-            ffields.append(tuple([n, t, comment]))
+            ffields.append(tuple([n, t]))
             prev_name = fname
 
-        max_len = max([len(n) for n, _, _ in ffields], default=0)
+        # Close the bitfield because we have no more fields
+        if bitfield:
+            ffields.append(tuple([None, bitfield]))
 
-        for n, t, comment in ffields:
+        # Write the struct as a bitfield if it only has bit fields
-            k = max_len-len(n)+len(t)
+        if len(ffields) == 1 and ffields[0][0] is None:
-            f.write("\t{}: {},{}\n".format(n, t.rjust(k), comment or ""))
+            ffields[0][1].write(f, struct_name, 0, True)
+            f.write("\n")
 
-
+        # Write as a normal struct (or union) if it has other fields
-        f.write("}\n\n")
+        # and inject anonymous bitfields into the struct if there are any
+        else:
+            has_anon_bitfield = any(name is None for name, _ in ffields)
+            max_len = 1 if has_anon_bitfield else max([len(n) for n, _ in ffields], default=0)
+            f.write("{} :: struct ".format(struct_name))
+            if _type == "union":
+                f.write("#raw_union ")
+            f.write("{\n")
+            for name, type_ in ffields:
+                if name is None:
+                    # Inject an anonymous bitfield into the struct
+                    type_.write(f, None, indent=1, justify=True)
+                else:
+                    f.write("\t{} {},\n".format((name + ":").ljust(max_len + 1), type_))
+            f.write("}\n\n")
 
     f.write("// Opaque structs\n")
     f.write(OPAQUE_STRUCTS)

vendor/vulkan/_gen/vk_platform.h

@@ -2,7 +2,7 @@
 // File: vk_platform.h
 //
 /*
-** Copyright 2014-2024 The Khronos Group Inc.
+** Copyright 2014-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_core.h

@@ -2,7 +2,7 @@
 #define VULKAN_CORE_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -69,7 +69,7 @@ extern "C" {
 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 303
+#define VK_HEADER_VERSION 309
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@@ -1008,7 +1008,6 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = 1000421000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM = 1000424000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM = 1000424001,
@@ -1025,6 +1024,9 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV = 1000428000,
     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001,
     VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV = 1000429008,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV = 1000429009,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV = 1000429010,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR = 1000434000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000,
@@ -1082,6 +1084,10 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV = 1000491000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV = 1000491001,
+    VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV = 1000491002,
+    VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV = 1000491004,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV = 1000492000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV = 1000492001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000,
@@ -1171,6 +1177,20 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = 1000564000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV = 1000569000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV = 1000569001,
+    VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV = 1000569002,
+    VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV = 1000569003,
+    VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV = 1000569004,
+    VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV = 1000569005,
+    VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV = 1000569006,
+    VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000569007,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV = 1000570000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV = 1000570001,
+    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570002,
+    VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV = 1000570003,
+    VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV = 1000570004,
+    VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV = 1000570005,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT = 1000572000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT = 1000572001,
     VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT = 1000572002,
@@ -1185,17 +1205,34 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT = 1000572012,
     VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT = 1000572013,
     VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT = 1000572014,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR = 1000574000,
+    VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR = 1000574002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001,
     VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000,
     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR = 1000586000,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586001,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586002,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586003,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI = 1000590000,
     VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI = 1000590001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV = 1000593000,
     VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV = 1000593001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV = 1000593002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM = 1000596000,
+    VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT = 1000602000,
+    VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT = 1000602001,
+    VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR = 1000421000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV = 1000613000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV = 1000613001,
+#endif
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
   // VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a deprecated alias
@@ -1405,6 +1442,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS,
     VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES,
@@ -2260,6 +2298,7 @@ typedef enum VkDescriptorType {
     VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000,
     VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001,
     VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000,
+    VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570000,
     VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK,
     VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = VK_DESCRIPTOR_TYPE_MUTABLE_EXT,
     VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
@@ -2716,6 +2755,7 @@ typedef VkFlags VkShaderModuleCreateFlags;
 
 typedef enum VkPipelineCacheCreateFlagBits {
     VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
+    VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR = 0x00000008,
     VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT,
     VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkPipelineCacheCreateFlagBits;
@@ -2906,6 +2946,7 @@ typedef enum VkDependencyFlagBits {
     VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004,
     VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002,
     VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 0x00000008,
+    VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR = 0x00000020,
     VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT,
     VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
     VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
@@ -5171,6 +5212,9 @@ typedef enum VkExternalMemoryHandleTypeFlagBits {
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX = 0x00004000,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT = 0x00010000,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT = 0x00020000,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT = 0x00040000,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
@@ -5954,7 +5998,7 @@ typedef enum VkDriverId {
     VK_DRIVER_ID_MESA_NVK = 24,
     VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25,
     VK_DRIVER_ID_MESA_HONEYKRISP = 26,
-    VK_DRIVER_ID_RESERVED_27 = 27,
+    VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN = 27,
     VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY,
     VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE,
     VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV,
@@ -6795,6 +6839,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT = 0x40000000ULL;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0x20000000000ULL;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 0x20000000ULL;
+static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV = 0x100000000000ULL;
 
 typedef VkFlags64 VkAccessFlags2;
 
@@ -6958,6 +7003,7 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 0x200000000ULL;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000ULL;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000ULL;
+static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV = 0x8000000000000ULL;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 0x400000000ULL;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 0x800000000ULL;
@@ -7805,6 +7851,8 @@ static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONL
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX = 0x100000000ULL;
 #endif
+static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR = 0x00001000ULL;
+static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV = 0x200000000ULL;
 static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ULL;
 static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL;
 static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR = 0x00000002ULL;
@@ -7837,6 +7885,7 @@ static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_
 static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ULL;
 static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000ULL;
 static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000ULL;
+static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM = 0x2000000000ULL;
 static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ULL;
 static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ULL;
 
@@ -8941,6 +8990,7 @@ typedef enum VkVideoSessionCreateFlagBitsKHR {
     VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR = 0x00000004,
     VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000008,
     VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x00000010,
+    VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR = 0x00000020,
     VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
 } VkVideoSessionCreateFlagBitsKHR;
 typedef VkFlags VkVideoSessionCreateFlagsKHR;
@@ -12127,6 +12177,10 @@ typedef enum VkComponentTypeKHR {
     VK_COMPONENT_TYPE_UINT16_KHR = 8,
     VK_COMPONENT_TYPE_UINT32_KHR = 9,
     VK_COMPONENT_TYPE_UINT64_KHR = 10,
+    VK_COMPONENT_TYPE_SINT8_PACKED_NV = 1000491000,
+    VK_COMPONENT_TYPE_UINT8_PACKED_NV = 1000491001,
+    VK_COMPONENT_TYPE_FLOAT_E4M3_NV = 1000491002,
+    VK_COMPONENT_TYPE_FLOAT_E5M2_NV = 1000491003,
     VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR,
     VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR,
     VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR,
@@ -12782,6 +12836,76 @@ typedef struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR {
 
 
 
+// VK_KHR_maintenance8 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_maintenance8 1
+#define VK_KHR_MAINTENANCE_8_SPEC_VERSION 1
+#define VK_KHR_MAINTENANCE_8_EXTENSION_NAME "VK_KHR_maintenance8"
+typedef VkFlags64 VkAccessFlags3KHR;
+
+// Flag bits for VkAccessFlagBits3KHR
+typedef VkFlags64 VkAccessFlagBits3KHR;
+static const VkAccessFlagBits3KHR VK_ACCESS_3_NONE_KHR = 0ULL;
+
+typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           maintenance8;
+} VkPhysicalDeviceMaintenance8FeaturesKHR;
+
+typedef struct VkMemoryBarrierAccessFlags3KHR {
+    VkStructureType      sType;
+    const void*          pNext;
+    VkAccessFlags3KHR    srcAccessMask3;
+    VkAccessFlags3KHR    dstAccessMask3;
+} VkMemoryBarrierAccessFlags3KHR;
+
+
+
+// VK_KHR_video_maintenance2 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_video_maintenance2 1
+#define VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION 1
+#define VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_video_maintenance2"
+typedef struct VkPhysicalDeviceVideoMaintenance2FeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           videoMaintenance2;
+} VkPhysicalDeviceVideoMaintenance2FeaturesKHR;
+
+typedef struct VkVideoDecodeH264InlineSessionParametersInfoKHR {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    const StdVideoH264SequenceParameterSet*    pStdSPS;
+    const StdVideoH264PictureParameterSet*     pStdPPS;
+} VkVideoDecodeH264InlineSessionParametersInfoKHR;
+
+typedef struct VkVideoDecodeH265InlineSessionParametersInfoKHR {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    const StdVideoH265VideoParameterSet*       pStdVPS;
+    const StdVideoH265SequenceParameterSet*    pStdSPS;
+    const StdVideoH265PictureParameterSet*     pStdPPS;
+} VkVideoDecodeH265InlineSessionParametersInfoKHR;
+
+typedef struct VkVideoDecodeAV1InlineSessionParametersInfoKHR {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    const StdVideoAV1SequenceHeader*    pStdSequenceHeader;
+} VkVideoDecodeAV1InlineSessionParametersInfoKHR;
+
+
+
+// VK_KHR_depth_clamp_zero_one is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_depth_clamp_zero_one 1
+#define VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION 1
+#define VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME "VK_KHR_depth_clamp_zero_one"
+typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           depthClampZeroOne;
+} VkPhysicalDeviceDepthClampZeroOneFeaturesKHR;
+
+
+
 // VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls.
 #define VK_EXT_debug_report 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
@@ -14644,6 +14768,8 @@ typedef enum VkGeometryTypeKHR {
     VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0,
     VK_GEOMETRY_TYPE_AABBS_KHR = 1,
     VK_GEOMETRY_TYPE_INSTANCES_KHR = 2,
+    VK_GEOMETRY_TYPE_SPHERES_NV = 1000429004,
+    VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV = 1000429005,
     VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
     VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR,
     VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
@@ -18253,6 +18379,7 @@ typedef enum VkOpacityMicromapSpecialIndexEXT {
     VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2,
     VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3,
     VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4,
+    VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV = -5,
     VK_OPACITY_MICROMAP_SPECIAL_INDEX_MAX_ENUM_EXT = 0x7FFFFFFF
 } VkOpacityMicromapSpecialIndexEXT;
 
@@ -18684,11 +18811,7 @@ VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE(
 #define VK_EXT_depth_clamp_zero_one 1
 #define VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION 1
 #define VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME "VK_EXT_depth_clamp_zero_one"
-typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT {
+typedef VkPhysicalDeviceDepthClampZeroOneFeaturesKHR VkPhysicalDeviceDepthClampZeroOneFeaturesEXT;
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           depthClampZeroOne;
-} VkPhysicalDeviceDepthClampZeroOneFeaturesEXT;
 
 
 
@@ -18920,6 +19043,61 @@ VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetPipelineIndirectDeviceAddressNV(
 #endif
 
 
+// VK_NV_ray_tracing_linear_swept_spheres is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_ray_tracing_linear_swept_spheres 1
+#define VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION 1
+#define VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_EXTENSION_NAME "VK_NV_ray_tracing_linear_swept_spheres"
+
+typedef enum VkRayTracingLssIndexingModeNV {
+    VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV = 0,
+    VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV = 1,
+    VK_RAY_TRACING_LSS_INDEXING_MODE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkRayTracingLssIndexingModeNV;
+
+typedef enum VkRayTracingLssPrimitiveEndCapsModeNV {
+    VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV = 0,
+    VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV = 1,
+    VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkRayTracingLssPrimitiveEndCapsModeNV;
+typedef struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           spheres;
+    VkBool32           linearSweptSpheres;
+} VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV;
+
+typedef struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkFormat                                 vertexFormat;
+    VkDeviceOrHostAddressConstKHR            vertexData;
+    VkDeviceSize                             vertexStride;
+    VkFormat                                 radiusFormat;
+    VkDeviceOrHostAddressConstKHR            radiusData;
+    VkDeviceSize                             radiusStride;
+    VkIndexType                              indexType;
+    VkDeviceOrHostAddressConstKHR            indexData;
+    VkDeviceSize                             indexStride;
+    VkRayTracingLssIndexingModeNV            indexingMode;
+    VkRayTracingLssPrimitiveEndCapsModeNV    endCapsMode;
+} VkAccelerationStructureGeometryLinearSweptSpheresDataNV;
+
+typedef struct VkAccelerationStructureGeometrySpheresDataNV {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkFormat                         vertexFormat;
+    VkDeviceOrHostAddressConstKHR    vertexData;
+    VkDeviceSize                     vertexStride;
+    VkFormat                         radiusFormat;
+    VkDeviceOrHostAddressConstKHR    radiusData;
+    VkDeviceSize                     radiusStride;
+    VkIndexType                      indexType;
+    VkDeviceOrHostAddressConstKHR    indexData;
+    VkDeviceSize                     indexStride;
+} VkAccelerationStructureGeometrySpheresDataNV;
+
+
+
 // VK_NV_linear_color_attachment is a preprocessor guard. Do not pass it to API calls.
 #define VK_NV_linear_color_attachment 1
 #define VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION 1
@@ -19816,6 +19994,83 @@ typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV {
 
 
 
+// VK_NV_cooperative_vector is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_cooperative_vector 1
+#define VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION 4
+#define VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME "VK_NV_cooperative_vector"
+
+typedef enum VkCooperativeVectorMatrixLayoutNV {
+    VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV = 0,
+    VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV = 1,
+    VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV = 2,
+    VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV = 3,
+    VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_MAX_ENUM_NV = 0x7FFFFFFF
+} VkCooperativeVectorMatrixLayoutNV;
+typedef struct VkPhysicalDeviceCooperativeVectorPropertiesNV {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkShaderStageFlags    cooperativeVectorSupportedStages;
+    VkBool32              cooperativeVectorTrainingFloat16Accumulation;
+    VkBool32              cooperativeVectorTrainingFloat32Accumulation;
+    uint32_t              maxCooperativeVectorComponents;
+} VkPhysicalDeviceCooperativeVectorPropertiesNV;
+
+typedef struct VkPhysicalDeviceCooperativeVectorFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           cooperativeVector;
+    VkBool32           cooperativeVectorTraining;
+} VkPhysicalDeviceCooperativeVectorFeaturesNV;
+
+typedef struct VkCooperativeVectorPropertiesNV {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkComponentTypeKHR    inputType;
+    VkComponentTypeKHR    inputInterpretation;
+    VkComponentTypeKHR    matrixInterpretation;
+    VkComponentTypeKHR    biasInterpretation;
+    VkComponentTypeKHR    resultType;
+    VkBool32              transpose;
+} VkCooperativeVectorPropertiesNV;
+
+typedef struct VkConvertCooperativeVectorMatrixInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    size_t                               srcSize;
+    VkDeviceOrHostAddressConstKHR        srcData;
+    size_t*                              pDstSize;
+    VkDeviceOrHostAddressKHR             dstData;
+    VkComponentTypeKHR                   srcComponentType;
+    VkComponentTypeKHR                   dstComponentType;
+    uint32_t                             numRows;
+    uint32_t                             numColumns;
+    VkCooperativeVectorMatrixLayoutNV    srcLayout;
+    size_t                               srcStride;
+    VkCooperativeVectorMatrixLayoutNV    dstLayout;
+    size_t                               dstStride;
+} VkConvertCooperativeVectorMatrixInfoNV;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkConvertCooperativeVectorMatrixNV)(VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV* pInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdConvertCooperativeVectorMatrixNV)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeVectorPropertiesNV(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkCooperativeVectorPropertiesNV*            pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkConvertCooperativeVectorMatrixNV(
+    VkDevice                                    device,
+    const VkConvertCooperativeVectorMatrixInfoNV* pInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdConvertCooperativeVectorMatrixNV(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    infoCount,
+    const VkConvertCooperativeVectorMatrixInfoNV* pInfos);
+#endif
+
+
 // VK_NV_extended_sparse_address_space is a preprocessor guard. Do not pass it to API calls.
 #define VK_NV_extended_sparse_address_space 1
 #define VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION 1
@@ -20330,6 +20585,359 @@ typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV {
 
 
 
+// VK_NV_cluster_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_cluster_acceleration_structure 1
+#define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION 2
+#define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_NV_cluster_acceleration_structure"
+
+typedef enum VkClusterAccelerationStructureTypeNV {
+    VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV = 0,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV = 1,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV = 2,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkClusterAccelerationStructureTypeNV;
+
+typedef enum VkClusterAccelerationStructureOpTypeNV {
+    VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV = 0,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV = 1,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV = 2,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV = 3,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV = 4,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkClusterAccelerationStructureOpTypeNV;
+
+typedef enum VkClusterAccelerationStructureOpModeNV {
+    VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV = 0,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV = 1,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV = 2,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkClusterAccelerationStructureOpModeNV;
+
+typedef enum VkClusterAccelerationStructureAddressResolutionFlagBitsNV {
+    VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV = 0x00000001,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV = 0x00000002,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV = 0x00000004,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV = 0x00000008,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV = 0x00000010,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV = 0x00000020,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkClusterAccelerationStructureAddressResolutionFlagBitsNV;
+typedef VkFlags VkClusterAccelerationStructureAddressResolutionFlagsNV;
+
+typedef enum VkClusterAccelerationStructureClusterFlagBitsNV {
+    VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV = 0x00000001,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkClusterAccelerationStructureClusterFlagBitsNV;
+typedef VkFlags VkClusterAccelerationStructureClusterFlagsNV;
+
+typedef enum VkClusterAccelerationStructureGeometryFlagBitsNV {
+    VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV = 0x00000001,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV = 0x00000002,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV = 0x00000004,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkClusterAccelerationStructureGeometryFlagBitsNV;
+typedef VkFlags VkClusterAccelerationStructureGeometryFlagsNV;
+
+typedef enum VkClusterAccelerationStructureIndexFormatFlagBitsNV {
+    VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV = 0x00000001,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV = 0x00000002,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV = 0x00000004,
+    VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkClusterAccelerationStructureIndexFormatFlagBitsNV;
+typedef VkFlags VkClusterAccelerationStructureIndexFormatFlagsNV;
+typedef struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           clusterAccelerationStructure;
+} VkPhysicalDeviceClusterAccelerationStructureFeaturesNV;
+
+typedef struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxVerticesPerCluster;
+    uint32_t           maxTrianglesPerCluster;
+    uint32_t           clusterScratchByteAlignment;
+    uint32_t           clusterByteAlignment;
+    uint32_t           clusterTemplateByteAlignment;
+    uint32_t           clusterBottomLevelByteAlignment;
+    uint32_t           clusterTemplateBoundsByteAlignment;
+    uint32_t           maxClusterGeometryIndex;
+} VkPhysicalDeviceClusterAccelerationStructurePropertiesNV;
+
+typedef struct VkClusterAccelerationStructureClustersBottomLevelInputNV {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxTotalClusterCount;
+    uint32_t           maxClusterCountPerAccelerationStructure;
+} VkClusterAccelerationStructureClustersBottomLevelInputNV;
+
+typedef struct VkClusterAccelerationStructureTriangleClusterInputNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkFormat           vertexFormat;
+    uint32_t           maxGeometryIndexValue;
+    uint32_t           maxClusterUniqueGeometryCount;
+    uint32_t           maxClusterTriangleCount;
+    uint32_t           maxClusterVertexCount;
+    uint32_t           maxTotalTriangleCount;
+    uint32_t           maxTotalVertexCount;
+    uint32_t           minPositionTruncateBitCount;
+} VkClusterAccelerationStructureTriangleClusterInputNV;
+
+typedef struct VkClusterAccelerationStructureMoveObjectsInputNV {
+    VkStructureType                         sType;
+    void*                                   pNext;
+    VkClusterAccelerationStructureTypeNV    type;
+    VkBool32                                noMoveOverlap;
+    VkDeviceSize                            maxMovedBytes;
+} VkClusterAccelerationStructureMoveObjectsInputNV;
+
+typedef union VkClusterAccelerationStructureOpInputNV {
+    VkClusterAccelerationStructureClustersBottomLevelInputNV*    pClustersBottomLevel;
+    VkClusterAccelerationStructureTriangleClusterInputNV*        pTriangleClusters;
+    VkClusterAccelerationStructureMoveObjectsInputNV*            pMoveObjects;
+} VkClusterAccelerationStructureOpInputNV;
+
+typedef struct VkClusterAccelerationStructureInputInfoNV {
+    VkStructureType                            sType;
+    void*                                      pNext;
+    uint32_t                                   maxAccelerationStructureCount;
+    VkBuildAccelerationStructureFlagsKHR       flags;
+    VkClusterAccelerationStructureOpTypeNV     opType;
+    VkClusterAccelerationStructureOpModeNV     opMode;
+    VkClusterAccelerationStructureOpInputNV    opInput;
+} VkClusterAccelerationStructureInputInfoNV;
+
+typedef struct VkStridedDeviceAddressRegionKHR {
+    VkDeviceAddress    deviceAddress;
+    VkDeviceSize       stride;
+    VkDeviceSize       size;
+} VkStridedDeviceAddressRegionKHR;
+
+typedef struct VkClusterAccelerationStructureCommandsInfoNV {
+    VkStructureType                                           sType;
+    void*                                                     pNext;
+    VkClusterAccelerationStructureInputInfoNV                 input;
+    VkDeviceAddress                                           dstImplicitData;
+    VkDeviceAddress                                           scratchData;
+    VkStridedDeviceAddressRegionKHR                           dstAddressesArray;
+    VkStridedDeviceAddressRegionKHR                           dstSizesArray;
+    VkStridedDeviceAddressRegionKHR                           srcInfosArray;
+    VkDeviceAddress                                           srcInfosCount;
+    VkClusterAccelerationStructureAddressResolutionFlagsNV    addressResolutionFlags;
+} VkClusterAccelerationStructureCommandsInfoNV;
+
+typedef struct VkStridedDeviceAddressNV {
+    VkDeviceAddress    startAddress;
+    VkDeviceSize       strideInBytes;
+} VkStridedDeviceAddressNV;
+
+typedef struct VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV {
+    uint32_t    geometryIndex:24;
+    uint32_t    reserved:5;
+    uint32_t    geometryFlags:3;
+} VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV;
+
+typedef struct VkClusterAccelerationStructureMoveObjectsInfoNV {
+    VkDeviceAddress    srcAccelerationStructure;
+} VkClusterAccelerationStructureMoveObjectsInfoNV;
+
+typedef struct VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV {
+    uint32_t           clusterReferencesCount;
+    uint32_t           clusterReferencesStride;
+    VkDeviceAddress    clusterReferences;
+} VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV;
+
+typedef struct VkClusterAccelerationStructureBuildTriangleClusterInfoNV {
+    uint32_t                                                         clusterID;
+    VkClusterAccelerationStructureClusterFlagsNV                     clusterFlags;
+    uint32_t                                                         triangleCount:9;
+    uint32_t                                                         vertexCount:9;
+    uint32_t                                                         positionTruncateBitCount:6;
+    uint32_t                                                         indexType:4;
+    uint32_t                                                         opacityMicromapIndexType:4;
+    VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV    baseGeometryIndexAndGeometryFlags;
+    uint16_t                                                         indexBufferStride;
+    uint16_t                                                         vertexBufferStride;
+    uint16_t                                                         geometryIndexAndFlagsBufferStride;
+    uint16_t                                                         opacityMicromapIndexBufferStride;
+    VkDeviceAddress                                                  indexBuffer;
+    VkDeviceAddress                                                  vertexBuffer;
+    VkDeviceAddress                                                  geometryIndexAndFlagsBuffer;
+    VkDeviceAddress                                                  opacityMicromapArray;
+    VkDeviceAddress                                                  opacityMicromapIndexBuffer;
+} VkClusterAccelerationStructureBuildTriangleClusterInfoNV;
+
+typedef struct VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV {
+    uint32_t                                                         clusterID;
+    VkClusterAccelerationStructureClusterFlagsNV                     clusterFlags;
+    uint32_t                                                         triangleCount:9;
+    uint32_t                                                         vertexCount:9;
+    uint32_t                                                         positionTruncateBitCount:6;
+    uint32_t                                                         indexType:4;
+    uint32_t                                                         opacityMicromapIndexType:4;
+    VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV    baseGeometryIndexAndGeometryFlags;
+    uint16_t                                                         indexBufferStride;
+    uint16_t                                                         vertexBufferStride;
+    uint16_t                                                         geometryIndexAndFlagsBufferStride;
+    uint16_t                                                         opacityMicromapIndexBufferStride;
+    VkDeviceAddress                                                  indexBuffer;
+    VkDeviceAddress                                                  vertexBuffer;
+    VkDeviceAddress                                                  geometryIndexAndFlagsBuffer;
+    VkDeviceAddress                                                  opacityMicromapArray;
+    VkDeviceAddress                                                  opacityMicromapIndexBuffer;
+    VkDeviceAddress                                                  instantiationBoundingBoxLimit;
+} VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV;
+
+typedef struct VkClusterAccelerationStructureInstantiateClusterInfoNV {
+    uint32_t                    clusterIdOffset;
+    uint32_t                    geometryIndexOffset:24;
+    uint32_t                    reserved:8;
+    VkDeviceAddress             clusterTemplateAddress;
+    VkStridedDeviceAddressNV    vertexBuffer;
+} VkClusterAccelerationStructureInstantiateClusterInfoNV;
+
+typedef struct VkAccelerationStructureBuildSizesInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceSize       accelerationStructureSize;
+    VkDeviceSize       updateScratchSize;
+    VkDeviceSize       buildScratchSize;
+} VkAccelerationStructureBuildSizesInfoKHR;
+
+typedef struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           allowClusterAccelerationStructure;
+} VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV;
+
+typedef void (VKAPI_PTR *PFN_vkGetClusterAccelerationStructureBuildSizesNV)(VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdBuildClusterAccelerationStructureIndirectNV)(VkCommandBuffer                     commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV*  pCommandInfos);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetClusterAccelerationStructureBuildSizesNV(
+    VkDevice                                    device,
+    const VkClusterAccelerationStructureInputInfoNV* pInfo,
+    VkAccelerationStructureBuildSizesInfoKHR*   pSizeInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBuildClusterAccelerationStructureIndirectNV(
+    VkCommandBuffer                             commandBuffer,
+    const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos);
+#endif
+
+
+// VK_NV_partitioned_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_partitioned_acceleration_structure 1
+#define VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION 1
+#define VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_NV_partitioned_acceleration_structure"
+#define VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV (~0U)
+
+typedef enum VkPartitionedAccelerationStructureOpTypeNV {
+    VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV = 0,
+    VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV = 1,
+    VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV = 2,
+    VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkPartitionedAccelerationStructureOpTypeNV;
+
+typedef enum VkPartitionedAccelerationStructureInstanceFlagBitsNV {
+    VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV = 0x00000001,
+    VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV = 0x00000002,
+    VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV = 0x00000004,
+    VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV = 0x00000008,
+    VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV = 0x00000010,
+    VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkPartitionedAccelerationStructureInstanceFlagBitsNV;
+typedef VkFlags VkPartitionedAccelerationStructureInstanceFlagsNV;
+typedef struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           partitionedAccelerationStructure;
+} VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV;
+
+typedef struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxPartitionCount;
+} VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV;
+
+typedef struct VkPartitionedAccelerationStructureFlagsNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           enablePartitionTranslation;
+} VkPartitionedAccelerationStructureFlagsNV;
+
+typedef struct VkBuildPartitionedAccelerationStructureIndirectCommandNV {
+    VkPartitionedAccelerationStructureOpTypeNV    opType;
+    uint32_t                                      argCount;
+    VkStridedDeviceAddressNV                      argData;
+} VkBuildPartitionedAccelerationStructureIndirectCommandNV;
+
+typedef struct VkPartitionedAccelerationStructureWriteInstanceDataNV {
+    VkTransformMatrixKHR                                 transform;
+    float                                                explicitAABB[6];
+    uint32_t                                             instanceID;
+    uint32_t                                             instanceMask;
+    uint32_t                                             instanceContributionToHitGroupIndex;
+    VkPartitionedAccelerationStructureInstanceFlagsNV    instanceFlags;
+    uint32_t                                             instanceIndex;
+    uint32_t                                             partitionIndex;
+    VkDeviceAddress                                      accelerationStructure;
+} VkPartitionedAccelerationStructureWriteInstanceDataNV;
+
+typedef struct VkPartitionedAccelerationStructureUpdateInstanceDataNV {
+    uint32_t           instanceIndex;
+    uint32_t           instanceContributionToHitGroupIndex;
+    VkDeviceAddress    accelerationStructure;
+} VkPartitionedAccelerationStructureUpdateInstanceDataNV;
+
+typedef struct VkPartitionedAccelerationStructureWritePartitionTranslationDataNV {
+    uint32_t    partitionIndex;
+    float       partitionTranslation[3];
+} VkPartitionedAccelerationStructureWritePartitionTranslationDataNV;
+
+typedef struct VkWriteDescriptorSetPartitionedAccelerationStructureNV {
+    VkStructureType           sType;
+    void*                     pNext;
+    uint32_t                  accelerationStructureCount;
+    const VkDeviceAddress*    pAccelerationStructures;
+} VkWriteDescriptorSetPartitionedAccelerationStructureNV;
+
+typedef struct VkPartitionedAccelerationStructureInstancesInputNV {
+    VkStructureType                         sType;
+    void*                                   pNext;
+    VkBuildAccelerationStructureFlagsKHR    flags;
+    uint32_t                                instanceCount;
+    uint32_t                                maxInstancePerPartitionCount;
+    uint32_t                                partitionCount;
+    uint32_t                                maxInstanceInGlobalPartitionCount;
+} VkPartitionedAccelerationStructureInstancesInputNV;
+
+typedef struct VkBuildPartitionedAccelerationStructureInfoNV {
+    VkStructureType                                       sType;
+    void*                                                 pNext;
+    VkPartitionedAccelerationStructureInstancesInputNV    input;
+    VkDeviceAddress                                       srcAccelerationStructureData;
+    VkDeviceAddress                                       dstAccelerationStructureData;
+    VkDeviceAddress                                       scratchData;
+    VkDeviceAddress                                       srcInfos;
+    VkDeviceAddress                                       srcInfosCount;
+} VkBuildPartitionedAccelerationStructureInfoNV;
+
+typedef void (VKAPI_PTR *PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV)(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR*                  pSizeInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdBuildPartitionedAccelerationStructuresNV)(VkCommandBuffer                     commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV*  pBuildInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetPartitionedAccelerationStructuresBuildSizesNV(
+    VkDevice                                    device,
+    const VkPartitionedAccelerationStructureInstancesInputNV* pInfo,
+    VkAccelerationStructureBuildSizesInfoKHR*   pSizeInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBuildPartitionedAccelerationStructuresNV(
+    VkCommandBuffer                             commandBuffer,
+    const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo);
+#endif
+
+
 // VK_EXT_device_generated_commands is a preprocessor guard. Do not pass it to API calls.
 #define VK_EXT_device_generated_commands 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectExecutionSetEXT)
@@ -20721,6 +21329,18 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixFlexibleDimen
 #endif
 
 
+// VK_ARM_pipeline_opacity_micromap is a preprocessor guard. Do not pass it to API calls.
+#define VK_ARM_pipeline_opacity_micromap 1
+#define VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION 1
+#define VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME "VK_ARM_pipeline_opacity_micromap"
+typedef struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           pipelineOpacityMicromap;
+} VkPhysicalDevicePipelineOpacityMicromapFeaturesARM;
+
+
+
 // VK_EXT_vertex_attribute_robustness is a preprocessor guard. Do not pass it to API calls.
 #define VK_EXT_vertex_attribute_robustness 1
 #define VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION 1
@@ -20733,6 +21353,25 @@ typedef struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
 
 
 
+// VK_NV_present_metering is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_present_metering 1
+#define VK_NV_PRESENT_METERING_SPEC_VERSION 1
+#define VK_NV_PRESENT_METERING_EXTENSION_NAME "VK_NV_present_metering"
+typedef struct VkSetPresentConfigNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           numFramesPerBatch;
+    uint32_t           presentConfigFeedback;
+} VkSetPresentConfigNV;
+
+typedef struct VkPhysicalDevicePresentMeteringFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           presentMetering;
+} VkPhysicalDevicePresentMeteringFeaturesNV;
+
+
+
 // VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_acceleration_structure 1
 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13
@@ -20889,14 +21528,6 @@ typedef struct VkCopyAccelerationStructureInfoKHR {
     VkCopyAccelerationStructureModeKHR    mode;
 } VkCopyAccelerationStructureInfoKHR;
 
-typedef struct VkAccelerationStructureBuildSizesInfoKHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkDeviceSize       accelerationStructureSize;
-    VkDeviceSize       updateScratchSize;
-    VkDeviceSize       buildScratchSize;
-} VkAccelerationStructureBuildSizesInfoKHR;
-
 typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDevice                                           device, const VkAccelerationStructureCreateInfoKHR*        pCreateInfo, const VkAllocationCallbacks*       pAllocator, VkAccelerationStructureKHR*                        pAccelerationStructure);
 typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator);
 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer                                    commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
@@ -21079,12 +21710,6 @@ typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR {
     uint32_t           maxRayHitAttributeSize;
 } VkPhysicalDeviceRayTracingPipelinePropertiesKHR;
 
-typedef struct VkStridedDeviceAddressRegionKHR {
-    VkDeviceAddress    deviceAddress;
-    VkDeviceSize       stride;
-    VkDeviceSize       size;
-} VkStridedDeviceAddressRegionKHR;
-
 typedef struct VkTraceRaysIndirectCommandKHR {
     uint32_t    width;
     uint32_t    height;

vendor/vulkan/_gen/vulkan_ios.h

@@ -2,7 +2,7 @@
 #define VULKAN_IOS_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_macos.h

@@ -2,7 +2,7 @@
 #define VULKAN_MACOS_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_metal.h

@@ -2,7 +2,7 @@
 #define VULKAN_METAL_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -188,6 +188,47 @@ VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(
     VkExportMetalObjectsInfoEXT*                pMetalObjectsInfo);
 #endif
 
+
+// VK_EXT_external_memory_metal is a preprocessor guard. Do not pass it to API calls.
+#define VK_EXT_external_memory_metal 1
+#define VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION 1
+#define VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME "VK_EXT_external_memory_metal"
+typedef struct VkImportMemoryMetalHandleInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    void*                                 handle;
+} VkImportMemoryMetalHandleInfoEXT;
+
+typedef struct VkMemoryMetalHandlePropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryMetalHandlePropertiesEXT;
+
+typedef struct VkMemoryGetMetalHandleInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetMetalHandleInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandleEXT)(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandlePropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT(
+    VkDevice                                    device,
+    const VkMemoryGetMetalHandleInfoEXT*        pGetMetalHandleInfo,
+    void**                                      pHandle);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    const void*                                 pHandle,
+    VkMemoryMetalHandlePropertiesEXT*           pMemoryMetalHandleProperties);
+#endif
+
 #ifdef __cplusplus
 }
 #endif

vendor/vulkan/_gen/vulkan_video_codec_av1std.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_AV1STD_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_video_codec_av1std_decode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_video_codec_av1std_encode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_video_codec_h264std.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H264STD_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_video_codec_h264std_decode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_video_codec_h264std_encode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_video_codec_h265std.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H265STD_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_video_codec_h265std_decode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_video_codec_h265std_encode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_wayland.h

@@ -2,7 +2,7 @@
 #define VULKAN_WAYLAND_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_win32.h

@@ -2,7 +2,7 @@
 #define VULKAN_WIN32_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_xcb.h

@@ -2,7 +2,7 @@
 #define VULKAN_XCB_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_xlib.h

@@ -2,7 +2,7 @@
 #define VULKAN_XLIB_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/core.odin

@@ -71,7 +71,7 @@ VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION :: VULKAN_VIDEO_CODEC_H265_ENCODE_AP
 MAKE_VIDEO_STD_VERSION :: MAKE_VERSION
 
 // General Constants
-HEADER_VERSION       :: 303
+HEADER_VERSION       :: 309
 MAX_DRIVER_NAME_SIZE :: 256
 MAX_DRIVER_INFO_SIZE :: 256
 
@@ -481,6 +481,15 @@ KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME    :: "VK_KHR_shader_rela
 KHR_maintenance7                                          :: 1
 KHR_MAINTENANCE_7_SPEC_VERSION                            :: 1
 KHR_MAINTENANCE_7_EXTENSION_NAME                          :: "VK_KHR_maintenance7"
+KHR_maintenance8                                          :: 1
+KHR_MAINTENANCE_8_SPEC_VERSION                            :: 1
+KHR_MAINTENANCE_8_EXTENSION_NAME                          :: "VK_KHR_maintenance8"
+KHR_video_maintenance2                                    :: 1
+KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION                      :: 1
+KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME                    :: "VK_KHR_video_maintenance2"
+KHR_depth_clamp_zero_one                                  :: 1
+KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION                     :: 1
+KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME                   :: "VK_KHR_depth_clamp_zero_one"
 EXT_debug_report                                          :: 1
 EXT_DEBUG_REPORT_SPEC_VERSION                             :: 10
 EXT_DEBUG_REPORT_EXTENSION_NAME                           :: "VK_EXT_debug_report"
@@ -1008,6 +1017,9 @@ NV_MEMORY_DECOMPRESSION_EXTENSION_NAME                    :: "VK_NV_memory_decom
 NV_device_generated_commands_compute                      :: 1
 NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION         :: 2
 NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME       :: "VK_NV_device_generated_commands_compute"
+NV_ray_tracing_linear_swept_spheres                       :: 1
+NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION          :: 1
+NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_EXTENSION_NAME        :: "VK_NV_ray_tracing_linear_swept_spheres"
 NV_linear_color_attachment                                :: 1
 NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION                   :: 1
 NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME                 :: "VK_NV_linear_color_attachment"
@@ -1053,6 +1065,9 @@ EXT_SHADER_OBJECT_EXTENSION_NAME                          :: "VK_EXT_shader_obje
 NV_ray_tracing_invocation_reorder                         :: 1
 NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION            :: 1
 NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME          :: "VK_NV_ray_tracing_invocation_reorder"
+NV_cooperative_vector                                     :: 1
+NV_COOPERATIVE_VECTOR_SPEC_VERSION                        :: 4
+NV_COOPERATIVE_VECTOR_EXTENSION_NAME                      :: "VK_NV_cooperative_vector"
 NV_extended_sparse_address_space                          :: 1
 NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION             :: 1
 NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME           :: "VK_NV_extended_sparse_address_space"
@@ -1101,6 +1116,12 @@ EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME           :: "VK_EXT_shader_repl
 NV_ray_tracing_validation                                 :: 1
 NV_RAY_TRACING_VALIDATION_SPEC_VERSION                    :: 1
 NV_RAY_TRACING_VALIDATION_EXTENSION_NAME                  :: "VK_NV_ray_tracing_validation"
+NV_cluster_acceleration_structure                         :: 1
+NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION            :: 2
+NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME          :: "VK_NV_cluster_acceleration_structure"
+NV_partitioned_acceleration_structure                     :: 1
+NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION        :: 1
+NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME      :: "VK_NV_partitioned_acceleration_structure"
 EXT_device_generated_commands                             :: 1
 EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION                :: 1
 EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME              :: "VK_EXT_device_generated_commands"
@@ -1113,6 +1134,9 @@ NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME                    :: "VK_NV_cooperative_
 EXT_vertex_attribute_robustness                           :: 1
 EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION              :: 1
 EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME            :: "VK_EXT_vertex_attribute_robustness"
+NV_present_metering                                       :: 1
+NV_PRESENT_METERING_SPEC_VERSION                          :: 1
+NV_PRESENT_METERING_EXTENSION_NAME                        :: "VK_NV_present_metering"
 KHR_acceleration_structure                                :: 1
 KHR_ACCELERATION_STRUCTURE_SPEC_VERSION                   :: 13
 KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME                 :: "VK_KHR_acceleration_structure"
@@ -1158,6 +1182,9 @@ EXT_METAL_SURFACE_EXTENSION_NAME                          :: "VK_EXT_metal_surfa
 EXT_metal_objects                                         :: 1
 EXT_METAL_OBJECTS_SPEC_VERSION                            :: 2
 EXT_METAL_OBJECTS_EXTENSION_NAME                          :: "VK_EXT_metal_objects"
+EXT_external_memory_metal                                 :: 1
+EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION                    :: 1
+EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME                  :: "VK_EXT_external_memory_metal"
 KHR_wayland_surface                                       :: 1
 KHR_WAYLAND_SURFACE_SPEC_VERSION                          :: 6
 KHR_WAYLAND_SURFACE_EXTENSION_NAME                        :: "VK_KHR_wayland_surface"

vendor/vulkan/enums.odin

@@ -304,6 +304,55 @@ ChromaLocation :: enum c.int {
 	MIDPOINT_KHR     = MIDPOINT,
 }
 
+ClusterAccelerationStructureAddressResolutionFlagsNV :: distinct bit_set[ClusterAccelerationStructureAddressResolutionFlagNV; Flags]
+ClusterAccelerationStructureAddressResolutionFlagNV :: enum Flags {
+	INDIRECTED_DST_IMPLICIT_DATA = 0,
+	INDIRECTED_SCRATCH_DATA      = 1,
+	INDIRECTED_DST_ADDRESS_ARRAY = 2,
+	INDIRECTED_DST_SIZES_ARRAY   = 3,
+	INDIRECTED_SRC_INFOS_ARRAY   = 4,
+	INDIRECTED_SRC_INFOS_COUNT   = 5,
+}
+
+ClusterAccelerationStructureClusterFlagsNV :: distinct bit_set[ClusterAccelerationStructureClusterFlagNV; Flags]
+ClusterAccelerationStructureClusterFlagNV :: enum Flags {
+	ALLOW_DISABLE_OPACITY_MICROMAPS = 0,
+}
+
+ClusterAccelerationStructureGeometryFlagsNV :: distinct bit_set[ClusterAccelerationStructureGeometryFlagNV; Flags]
+ClusterAccelerationStructureGeometryFlagNV :: enum Flags {
+	CULL_DISABLE                   = 0,
+	NO_DUPLICATE_ANYHIT_INVOCATION = 1,
+	OPAQUE                         = 2,
+}
+
+ClusterAccelerationStructureIndexFormatFlagsNV :: distinct bit_set[ClusterAccelerationStructureIndexFormatFlagNV; Flags]
+ClusterAccelerationStructureIndexFormatFlagNV :: enum Flags {
+	_8BIT  = 0,
+	_16BIT = 1,
+	_32BIT = 2,
+}
+
+ClusterAccelerationStructureOpModeNV :: enum c.int {
+	IMPLICIT_DESTINATIONS = 0,
+	EXPLICIT_DESTINATIONS = 1,
+	COMPUTE_SIZES         = 2,
+}
+
+ClusterAccelerationStructureOpTypeNV :: enum c.int {
+	MOVE_OBJECTS                    = 0,
+	BUILD_CLUSTERS_BOTTOM_LEVEL     = 1,
+	BUILD_TRIANGLE_CLUSTER          = 2,
+	BUILD_TRIANGLE_CLUSTER_TEMPLATE = 3,
+	INSTANTIATE_TRIANGLE_CLUSTER    = 4,
+}
+
+ClusterAccelerationStructureTypeNV :: enum c.int {
+	CLUSTERS_BOTTOM_LEVEL     = 0,
+	TRIANGLE_CLUSTER          = 1,
+	TRIANGLE_CLUSTER_TEMPLATE = 2,
+}
+
 CoarseSampleOrderTypeNV :: enum c.int {
 	DEFAULT      = 0,
 	CUSTOM       = 1,
@@ -391,28 +440,32 @@ ComponentSwizzle :: enum c.int {
 }
 
 ComponentTypeKHR :: enum c.int {
-	FLOAT16    = 0,
+	FLOAT16         = 0,
-	FLOAT32    = 1,
+	FLOAT32         = 1,
-	FLOAT64    = 2,
+	FLOAT64         = 2,
-	SINT8      = 3,
+	SINT8           = 3,
-	SINT16     = 4,
+	SINT16          = 4,
-	SINT32     = 5,
+	SINT32          = 5,
-	SINT64     = 6,
+	SINT64          = 6,
-	UINT8      = 7,
+	UINT8           = 7,
-	UINT16     = 8,
+	UINT16          = 8,
-	UINT32     = 9,
+	UINT32          = 9,
-	UINT64     = 10,
+	UINT64          = 10,
-	FLOAT16_NV = FLOAT16,
+	SINT8_PACKED_NV = 1000491000,
-	FLOAT32_NV = FLOAT32,
+	UINT8_PACKED_NV = 1000491001,
-	FLOAT64_NV = FLOAT64,
+	FLOAT_E4M3_NV   = 1000491002,
-	SINT8_NV   = SINT8,
+	FLOAT_E5M2_NV   = 1000491003,
-	SINT16_NV  = SINT16,
+	FLOAT16_NV      = FLOAT16,
-	SINT32_NV  = SINT32,
+	FLOAT32_NV      = FLOAT32,
-	SINT64_NV  = SINT64,
+	FLOAT64_NV      = FLOAT64,
-	UINT8_NV   = UINT8,
+	SINT8_NV        = SINT8,
-	UINT16_NV  = UINT16,
+	SINT16_NV       = SINT16,
-	UINT32_NV  = UINT32,
+	SINT32_NV       = SINT32,
-	UINT64_NV  = UINT64,
+	SINT64_NV       = SINT64,
+	UINT8_NV        = UINT8,
+	UINT16_NV       = UINT16,
+	UINT32_NV       = UINT32,
+	UINT64_NV       = UINT64,
 }
 
 CompositeAlphaFlagsKHR :: distinct bit_set[CompositeAlphaFlagKHR; Flags]
@@ -434,6 +487,13 @@ ConservativeRasterizationModeEXT :: enum c.int {
 	UNDERESTIMATE = 2,
 }
 
+CooperativeVectorMatrixLayoutNV :: enum c.int {
+	ROW_MAJOR           = 0,
+	COLUMN_MAJOR        = 1,
+	INFERENCING_OPTIMAL = 2,
+	TRAINING_OPTIMAL    = 3,
+}
+
 CopyAccelerationStructureModeKHR :: enum c.int {
 	CLONE       = 0,
 	COMPACT     = 1,
@@ -554,12 +614,13 @@ DebugUtilsMessageTypeFlagEXT :: enum Flags {
 
 DependencyFlags :: distinct bit_set[DependencyFlag; Flags]
 DependencyFlag :: enum Flags {
-	BY_REGION         = 0,
+	BY_REGION                                          = 0,
-	DEVICE_GROUP      = 2,
+	DEVICE_GROUP                                       = 2,
-	VIEW_LOCAL        = 1,
+	VIEW_LOCAL                                         = 1,
-	FEEDBACK_LOOP_EXT = 3,
+	FEEDBACK_LOOP_EXT                                  = 3,
-	VIEW_LOCAL_KHR    = VIEW_LOCAL,
+	QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_KHR = 5,
-	DEVICE_GROUP_KHR  = DEVICE_GROUP,
+	VIEW_LOCAL_KHR                                     = VIEW_LOCAL,
+	DEVICE_GROUP_KHR                                   = DEVICE_GROUP,
 }
 
 DepthBiasRepresentationEXT :: enum c.int {
@@ -611,25 +672,26 @@ DescriptorSetLayoutCreateFlag :: enum Flags {
 }
 
 DescriptorType :: enum c.int {
-	SAMPLER                    = 0,
+	SAMPLER                               = 0,
-	COMBINED_IMAGE_SAMPLER     = 1,
+	COMBINED_IMAGE_SAMPLER                = 1,
-	SAMPLED_IMAGE              = 2,
+	SAMPLED_IMAGE                         = 2,
-	STORAGE_IMAGE              = 3,
+	STORAGE_IMAGE                         = 3,
-	UNIFORM_TEXEL_BUFFER       = 4,
+	UNIFORM_TEXEL_BUFFER                  = 4,
-	STORAGE_TEXEL_BUFFER       = 5,
+	STORAGE_TEXEL_BUFFER                  = 5,
-	UNIFORM_BUFFER             = 6,
+	UNIFORM_BUFFER                        = 6,
-	STORAGE_BUFFER             = 7,
+	STORAGE_BUFFER                        = 7,
-	UNIFORM_BUFFER_DYNAMIC     = 8,
+	UNIFORM_BUFFER_DYNAMIC                = 8,
-	STORAGE_BUFFER_DYNAMIC     = 9,
+	STORAGE_BUFFER_DYNAMIC                = 9,
-	INPUT_ATTACHMENT           = 10,
+	INPUT_ATTACHMENT                      = 10,
-	INLINE_UNIFORM_BLOCK       = 1000138000,
+	INLINE_UNIFORM_BLOCK                  = 1000138000,
-	ACCELERATION_STRUCTURE_KHR = 1000150000,
+	ACCELERATION_STRUCTURE_KHR            = 1000150000,
-	ACCELERATION_STRUCTURE_NV  = 1000165000,
+	ACCELERATION_STRUCTURE_NV             = 1000165000,
-	SAMPLE_WEIGHT_IMAGE_QCOM   = 1000440000,
+	SAMPLE_WEIGHT_IMAGE_QCOM              = 1000440000,
-	BLOCK_MATCH_IMAGE_QCOM     = 1000440001,
+	BLOCK_MATCH_IMAGE_QCOM                = 1000440001,
-	MUTABLE_EXT                = 1000351000,
+	MUTABLE_EXT                           = 1000351000,
-	INLINE_UNIFORM_BLOCK_EXT   = INLINE_UNIFORM_BLOCK,
+	PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570000,
-	MUTABLE_VALVE              = MUTABLE_EXT,
+	INLINE_UNIFORM_BLOCK_EXT              = INLINE_UNIFORM_BLOCK,
+	MUTABLE_VALVE                         = MUTABLE_EXT,
 }
 
 DescriptorUpdateTemplateType :: enum c.int {
@@ -758,7 +820,7 @@ DriverId :: enum c.int {
 	MESA_NVK                      = 24,
 	IMAGINATION_OPEN_SOURCE_MESA  = 25,
 	MESA_HONEYKRISP               = 26,
-	RESERVED_27                   = 27,
+	VULKAN_SC_EMULATION_ON_VULKAN = 27,
 	AMD_PROPRIETARY_KHR           = AMD_PROPRIETARY,
 	AMD_OPEN_SOURCE_KHR           = AMD_OPEN_SOURCE,
 	MESA_RADV_KHR                 = MESA_RADV,
@@ -935,6 +997,9 @@ ExternalMemoryHandleTypeFlag :: enum Flags {
 	ZIRCON_VMO_FUCHSIA              = 11,
 	RDMA_ADDRESS_NV                 = 12,
 	SCREEN_BUFFER_QNX               = 14,
+	MTLBUFFER_EXT                   = 16,
+	MTLTEXTURE_EXT                  = 17,
+	MTLHEAP_EXT                     = 18,
 	OPAQUE_FD_KHR                   = OPAQUE_FD,
 	OPAQUE_WIN32_KHR                = OPAQUE_WIN32,
 	OPAQUE_WIN32_KMT_KHR            = OPAQUE_WIN32_KMT,
@@ -1425,11 +1490,13 @@ GeometryInstanceFlagKHR :: enum Flags {
 }
 
 GeometryTypeKHR :: enum c.int {
-	TRIANGLES    = 0,
+	TRIANGLES               = 0,
-	AABBS        = 1,
+	AABBS                   = 1,
-	INSTANCES    = 2,
+	INSTANCES               = 2,
-	TRIANGLES_NV = TRIANGLES,
+	SPHERES_NV              = 1000429004,
-	AABBS_NV     = AABBS,
+	LINEAR_SWEPT_SPHERES_NV = 1000429005,
+	TRIANGLES_NV            = TRIANGLES,
+	AABBS_NV                = AABBS,
 }
 
 GraphicsPipelineLibraryFlagsEXT :: distinct bit_set[GraphicsPipelineLibraryFlagEXT; Flags]
@@ -1906,10 +1973,11 @@ OpacityMicromapFormatEXT :: enum c.int {
 }
 
 OpacityMicromapSpecialIndexEXT :: enum c.int {
-	FULLY_TRANSPARENT         = -1,
+	FULLY_TRANSPARENT                            = -1,
-	FULLY_OPAQUE              = -2,
+	FULLY_OPAQUE                                 = -2,
-	FULLY_UNKNOWN_TRANSPARENT = -3,
+	FULLY_UNKNOWN_TRANSPARENT                    = -3,
-	FULLY_UNKNOWN_OPAQUE      = -4,
+	FULLY_UNKNOWN_OPAQUE                         = -4,
+	CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV = -5,
 }
 
 OpticalFlowExecuteFlagsNV :: distinct bit_set[OpticalFlowExecuteFlagNV; Flags]
@@ -1973,6 +2041,21 @@ OutOfBandQueueTypeNV :: enum c.int {
 	PRESENT = 1,
 }
 
+PartitionedAccelerationStructureInstanceFlagsNV :: distinct bit_set[PartitionedAccelerationStructureInstanceFlagNV; Flags]
+PartitionedAccelerationStructureInstanceFlagNV :: enum Flags {
+	FLAG_TRIANGLE_FACING_CULL_DISABLE = 0,
+	FLAG_TRIANGLE_FLIP_FACING         = 1,
+	FLAG_FORCE_OPAQUE                 = 2,
+	FLAG_FORCE_NO_OPAQUE              = 3,
+	FLAG_ENABLE_EXPLICIT_BOUNDING_BOX = 4,
+}
+
+PartitionedAccelerationStructureOpTypeNV :: enum c.int {
+	WRITE_INSTANCE              = 0,
+	UPDATE_INSTANCE             = 1,
+	WRITE_PARTITION_TRANSLATION = 2,
+}
+
 PeerMemoryFeatureFlags :: distinct bit_set[PeerMemoryFeatureFlag; Flags]
 PeerMemoryFeatureFlag :: enum Flags {
 	COPY_SRC        = 0,
@@ -2072,8 +2155,9 @@ PipelineBindPoint :: enum c.int {
 
 PipelineCacheCreateFlags :: distinct bit_set[PipelineCacheCreateFlag; Flags]
 PipelineCacheCreateFlag :: enum Flags {
-	EXTERNALLY_SYNCHRONIZED     = 0,
+	EXTERNALLY_SYNCHRONIZED           = 0,
-	EXTERNALLY_SYNCHRONIZED_EXT = EXTERNALLY_SYNCHRONIZED,
+	INTERNALLY_SYNCHRONIZED_MERGE_KHR = 3,
+	EXTERNALLY_SYNCHRONIZED_EXT       = EXTERNALLY_SYNCHRONIZED,
 }
 
 PipelineCacheHeaderVersion :: enum c.int {
@@ -2389,6 +2473,16 @@ RayTracingInvocationReorderModeNV :: enum c.int {
 	REORDER = 1,
 }
 
+RayTracingLssIndexingModeNV :: enum c.int {
+	LIST       = 0,
+	SUCCESSIVE = 1,
+}
+
+RayTracingLssPrimitiveEndCapsModeNV :: enum c.int {
+	NONE    = 0,
+	CHAINED = 1,
+}
+
 RayTracingShaderGroupTypeKHR :: enum c.int {
 	GENERAL                 = 0,
 	TRIANGLES_HIT_GROUP     = 1,
@@ -3498,7 +3592,6 @@ StructureType :: enum c.int {
 	PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE          = 1000420000,
 	DESCRIPTOR_SET_BINDING_REFERENCE_VALVE                              = 1000420001,
 	DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE                       = 1000420002,
-	PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT                   = 1000421000,
 	PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT                  = 1000422000,
 	PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM                    = 1000424000,
 	PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM                  = 1000424001,
@@ -3515,6 +3608,9 @@ StructureType :: enum c.int {
 	PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV       = 1000428000,
 	COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV                            = 1000428001,
 	PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV                            = 1000428002,
+	PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV        = 1000429008,
+	ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV        = 1000429009,
+	ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV                     = 1000429010,
 	PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV                 = 1000430000,
 	PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR           = 1000434000,
 	PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT    = 1000437000,
@@ -3572,6 +3668,10 @@ StructureType :: enum c.int {
 	PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM          = 1000488000,
 	PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV          = 1000490000,
 	PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV        = 1000490001,
+	PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV                      = 1000491000,
+	PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV                    = 1000491001,
+	COOPERATIVE_VECTOR_PROPERTIES_NV                                    = 1000491002,
+	CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV                           = 1000491004,
 	PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV           = 1000492000,
 	PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV         = 1000492001,
 	PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT                = 1000351000,
@@ -3661,6 +3761,20 @@ StructureType :: enum c.int {
 	PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV            = 1000563000,
 	PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT           = 1000564000,
 	PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV                  = 1000568000,
+	PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV          = 1000569000,
+	PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV        = 1000569001,
+	CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV       = 1000569002,
+	CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV            = 1000569003,
+	CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV                = 1000569004,
+	CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV                        = 1000569005,
+	CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV                     = 1000569006,
+	RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV  = 1000569007,
+	PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV      = 1000570000,
+	PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV    = 1000570001,
+	WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV          = 1000570002,
+	PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV               = 1000570003,
+	BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV                    = 1000570004,
+	PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV                         = 1000570005,
 	PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT              = 1000572000,
 	PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT            = 1000572001,
 	GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT                     = 1000572002,
@@ -3675,17 +3789,30 @@ StructureType :: enum c.int {
 	INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT                       = 1000572012,
 	GENERATED_COMMANDS_PIPELINE_INFO_EXT                                = 1000572013,
 	GENERATED_COMMANDS_SHADER_INFO_EXT                                  = 1000572014,
+	PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR                          = 1000574000,
+	MEMORY_BARRIER_ACCESS_FLAGS_3_KHR                                   = 1000574002,
 	PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA               = 1000575000,
 	PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA             = 1000575001,
 	IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA                            = 1000575002,
 	PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT                    = 1000582000,
 	PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT               = 1000582001,
+	PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR                    = 1000586000,
+	VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR                = 1000586001,
+	VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR                = 1000586002,
+	VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR                 = 1000586003,
 	PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI                           = 1000590000,
 	HDR_VIVID_DYNAMIC_METADATA_HUAWEI                                   = 1000590001,
 	PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV                    = 1000593000,
 	COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV                = 1000593001,
 	PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV                  = 1000593002,
+	PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM              = 1000596000,
+	IMPORT_MEMORY_METAL_HANDLE_INFO_EXT                                 = 1000602000,
+	MEMORY_METAL_HANDLE_PROPERTIES_EXT                                  = 1000602001,
+	MEMORY_GET_METAL_HANDLE_INFO_EXT                                    = 1000602002,
+	PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR                   = 1000421000,
 	PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT            = 1000608000,
+	SET_PRESENT_CONFIG_NV                                               = 1000613000,
+	PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV                        = 1000613001,
 	PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES                           = PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
 	PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES                      = PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
 	DEBUG_REPORT_CREATE_INFO_EXT                                        = DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
@@ -3892,6 +4019,7 @@ StructureType :: enum c.int {
 	DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR                               = DEVICE_BUFFER_MEMORY_REQUIREMENTS,
 	DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR                                = DEVICE_IMAGE_MEMORY_REQUIREMENTS,
 	PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR                 = PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES,
+	PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT                   = PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR,
 	PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT              = PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES,
 	PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR                          = PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES,
 	PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR                        = PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES,
@@ -4481,6 +4609,7 @@ VideoSessionCreateFlagKHR :: enum Flags {
 	INLINE_QUERIES                       = 2,
 	ALLOW_ENCODE_QUANTIZATION_DELTA_MAP  = 3,
 	ALLOW_ENCODE_EMPHASIS_MAP            = 4,
+	INLINE_SESSION_PARAMETERS            = 5,
 }
 
 VideoSessionParametersCreateFlagsKHR :: distinct bit_set[VideoSessionParametersCreateFlagKHR; Flags]
@@ -4767,6 +4896,7 @@ FormatFeatureFlag2 :: enum Flags64 {
 	SAMPLED_IMAGE_DEPTH_COMPARISON_KHR                                          = 33,
 	SAMPLED_IMAGE_FILTER_MINMAX_KHR                                             = 16,
 	SAMPLED_IMAGE_FILTER_CUBIC_EXT                                              = 13,
+	ACCELERATION_STRUCTURE_RADIUS_BUFFER_NV                                     = 51,
 	LINEAR_COLOR_ATTACHMENT_NV                                                  = 38,
 	WEIGHT_IMAGE_QCOM                                                           = 34,
 	WEIGHT_SAMPLED_IMAGE_QCOM                                                   = 35,
@@ -4781,50 +4911,53 @@ FormatFeatureFlag2 :: enum Flags64 {
 
 PipelineCreateFlags2 :: distinct bit_set[PipelineCreateFlag2; Flags64]
 PipelineCreateFlag2 :: enum Flags64 {
-	DISABLE_OPTIMIZATION                               = 0,
+	DISABLE_OPTIMIZATION                                  = 0,
-	ALLOW_DERIVATIVES                                  = 1,
+	ALLOW_DERIVATIVES                                     = 1,
-	DERIVATIVE                                         = 2,
+	DERIVATIVE                                            = 2,
-	VIEW_INDEX_FROM_DEVICE_INDEX                       = 3,
+	VIEW_INDEX_FROM_DEVICE_INDEX                          = 3,
-	DISPATCH_BASE                                      = 4,
+	DISPATCH_BASE                                         = 4,
-	FAIL_ON_PIPELINE_COMPILE_REQUIRED                  = 8,
+	FAIL_ON_PIPELINE_COMPILE_REQUIRED                     = 8,
-	EARLY_RETURN_ON_FAILURE                            = 9,
+	EARLY_RETURN_ON_FAILURE                               = 9,
-	NO_PROTECTED_ACCESS                                = 27,
+	NO_PROTECTED_ACCESS                                   = 27,
-	PROTECTED_ACCESS_ONLY                              = 30,
+	PROTECTED_ACCESS_ONLY                                 = 30,
-	EXECUTION_GRAPH_AMDX                               = 32,
+	EXECUTION_GRAPH_AMDX                                  = 32,
-	ENABLE_LEGACY_DITHERING_EXT                        = 34,
+	RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_KHR              = 12,
-	DISABLE_OPTIMIZATION_KHR                           = 0,
+	RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_NV = 33,
-	ALLOW_DERIVATIVES_KHR                              = 1,
+	ENABLE_LEGACY_DITHERING_EXT                           = 34,
-	DERIVATIVE_KHR                                     = 2,
+	DISABLE_OPTIMIZATION_KHR                              = 0,
-	VIEW_INDEX_FROM_DEVICE_INDEX_KHR                   = 3,
+	ALLOW_DERIVATIVES_KHR                                 = 1,
-	DISPATCH_BASE_KHR                                  = 4,
+	DERIVATIVE_KHR                                        = 2,
-	DEFER_COMPILE_NV                                   = 5,
+	VIEW_INDEX_FROM_DEVICE_INDEX_KHR                      = 3,
-	CAPTURE_STATISTICS_KHR                             = 6,
+	DISPATCH_BASE_KHR                                     = 4,
-	CAPTURE_INTERNAL_REPRESENTATIONS_KHR               = 7,
+	DEFER_COMPILE_NV                                      = 5,
-	FAIL_ON_PIPELINE_COMPILE_REQUIRED_KHR              = 8,
+	CAPTURE_STATISTICS_KHR                                = 6,
-	EARLY_RETURN_ON_FAILURE_KHR                        = 9,
+	CAPTURE_INTERNAL_REPRESENTATIONS_KHR                  = 7,
-	LINK_TIME_OPTIMIZATION_EXT                         = 10,
+	FAIL_ON_PIPELINE_COMPILE_REQUIRED_KHR                 = 8,
-	RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT             = 23,
+	EARLY_RETURN_ON_FAILURE_KHR                           = 9,
-	LIBRARY_KHR                                        = 11,
+	LINK_TIME_OPTIMIZATION_EXT                            = 10,
-	RAY_TRACING_SKIP_TRIANGLES_KHR                     = 12,
+	RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT                = 23,
-	RAY_TRACING_SKIP_AABBS_KHR                         = 13,
+	LIBRARY_KHR                                           = 11,
-	RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR            = 14,
+	RAY_TRACING_SKIP_TRIANGLES_KHR                        = 12,
-	RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR        = 15,
+	RAY_TRACING_SKIP_AABBS_KHR                            = 13,
-	RAY_TRACING_NO_NULL_MISS_SHADERS_KHR               = 16,
+	RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR               = 14,
-	RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR       = 17,
+	RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR           = 15,
-	RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR = 19,
+	RAY_TRACING_NO_NULL_MISS_SHADERS_KHR                  = 16,
-	INDIRECT_BINDABLE_NV                               = 18,
+	RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR          = 17,
-	RAY_TRACING_ALLOW_MOTION_NV                        = 20,
+	RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR    = 19,
-	RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR     = 21,
+	INDIRECT_BINDABLE_NV                                  = 18,
-	RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT      = 22,
+	RAY_TRACING_ALLOW_MOTION_NV                           = 20,
-	RAY_TRACING_OPACITY_MICROMAP_EXT                   = 24,
+	RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR        = 21,
-	COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT                 = 25,
+	RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT         = 22,
-	DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT         = 26,
+	RAY_TRACING_OPACITY_MICROMAP_EXT                      = 24,
-	NO_PROTECTED_ACCESS_EXT                            = 27,
+	COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT                    = 25,
-	PROTECTED_ACCESS_ONLY_EXT                          = 30,
+	DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT            = 26,
-	RAY_TRACING_DISPLACEMENT_MICROMAP_NV               = 28,
+	NO_PROTECTED_ACCESS_EXT                               = 27,
-	DESCRIPTOR_BUFFER_EXT                              = 29,
+	PROTECTED_ACCESS_ONLY_EXT                             = 30,
-	CAPTURE_DATA_KHR                                   = 31,
+	RAY_TRACING_DISPLACEMENT_MICROMAP_NV                  = 28,
-	INDIRECT_BINDABLE_EXT                              = 38,
+	DESCRIPTOR_BUFFER_EXT                                 = 29,
+	DISALLOW_OPACITY_MICROMAP_ARM                         = 37,
+	CAPTURE_DATA_KHR                                      = 31,
+	INDIRECT_BINDABLE_EXT                                 = 38,
 }
 
 PipelineStageFlags2 :: distinct bit_set[PipelineStageFlag2; Flags64]
@@ -4903,6 +5036,7 @@ PipelineStageFlag2 :: enum Flags64 {
 	MICROMAP_BUILD_EXT                   = 30,
 	CLUSTER_CULLING_SHADER_HUAWEI        = 41,
 	OPTICAL_FLOW_NV                      = 29,
+	CONVERT_COOPERATIVE_VECTOR_MATRIX_NV = 44,
 }
 
 

vendor/vulkan/procedures.odin

@@ -62,6 +62,7 @@ ProcGetPhysicalDeviceCalibrateableTimeDomainsKHR                     :: #type pr
 ProcGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV :: #type proc "system" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: [^]CooperativeMatrixFlexibleDimensionsPropertiesNV) -> Result
 ProcGetPhysicalDeviceCooperativeMatrixPropertiesKHR                  :: #type proc "system" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: [^]CooperativeMatrixPropertiesKHR) -> Result
 ProcGetPhysicalDeviceCooperativeMatrixPropertiesNV                   :: #type proc "system" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: [^]CooperativeMatrixPropertiesNV) -> Result
+ProcGetPhysicalDeviceCooperativeVectorPropertiesNV                   :: #type proc "system" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: [^]CooperativeVectorPropertiesNV) -> Result
 ProcGetPhysicalDeviceDisplayPlaneProperties2KHR                      :: #type proc "system" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: [^]DisplayPlaneProperties2KHR) -> Result
 ProcGetPhysicalDeviceDisplayPlanePropertiesKHR                       :: #type proc "system" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: [^]DisplayPlanePropertiesKHR) -> Result
 ProcGetPhysicalDeviceDisplayProperties2KHR                           :: #type proc "system" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: [^]DisplayProperties2KHR) -> Result
@@ -178,11 +179,14 @@ ProcCmdBlitImage2KHR                                       :: #type proc "system
 ProcCmdBuildAccelerationStructureNV                        :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^AccelerationStructureInfoNV, instanceData: Buffer, instanceOffset: DeviceSize, update: b32, dst: AccelerationStructureNV, src: AccelerationStructureNV, scratch: Buffer, scratchOffset: DeviceSize)
 ProcCmdBuildAccelerationStructuresIndirectKHR              :: #type proc "system" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: [^]AccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: [^]DeviceAddress, pIndirectStrides: [^]u32, ppMaxPrimitiveCounts: ^[^]u32)
 ProcCmdBuildAccelerationStructuresKHR                      :: #type proc "system" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: [^]AccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ^[^]AccelerationStructureBuildRangeInfoKHR)
+ProcCmdBuildClusterAccelerationStructureIndirectNV         :: #type proc "system" (commandBuffer: CommandBuffer, pCommandInfos: [^]ClusterAccelerationStructureCommandsInfoNV)
 ProcCmdBuildMicromapsEXT                                   :: #type proc "system" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: [^]MicromapBuildInfoEXT)
+ProcCmdBuildPartitionedAccelerationStructuresNV            :: #type proc "system" (commandBuffer: CommandBuffer, pBuildInfo: ^BuildPartitionedAccelerationStructureInfoNV)
 ProcCmdClearAttachments                                    :: #type proc "system" (commandBuffer: CommandBuffer, attachmentCount: u32, pAttachments: [^]ClearAttachment, rectCount: u32, pRects: [^]ClearRect)
 ProcCmdClearColorImage                                     :: #type proc "system" (commandBuffer: CommandBuffer, image: Image, imageLayout: ImageLayout, pColor: ^ClearColorValue, rangeCount: u32, pRanges: [^]ImageSubresourceRange)
 ProcCmdClearDepthStencilImage                              :: #type proc "system" (commandBuffer: CommandBuffer, image: Image, imageLayout: ImageLayout, pDepthStencil: ^ClearDepthStencilValue, rangeCount: u32, pRanges: [^]ImageSubresourceRange)
 ProcCmdControlVideoCodingKHR                               :: #type proc "system" (commandBuffer: CommandBuffer, pCodingControlInfo: ^VideoCodingControlInfoKHR)
+ProcCmdConvertCooperativeVectorMatrixNV                    :: #type proc "system" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: [^]ConvertCooperativeVectorMatrixInfoNV)
 ProcCmdCopyAccelerationStructureKHR                        :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^CopyAccelerationStructureInfoKHR)
 ProcCmdCopyAccelerationStructureNV                         :: #type proc "system" (commandBuffer: CommandBuffer, dst: AccelerationStructureNV, src: AccelerationStructureNV, mode: CopyAccelerationStructureModeKHR)
 ProcCmdCopyAccelerationStructureToMemoryKHR                :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^CopyAccelerationStructureToMemoryInfoKHR)
@@ -405,6 +409,7 @@ ProcCmdWriteTimestamp                                      :: #type proc "system
 ProcCmdWriteTimestamp2                                     :: #type proc "system" (commandBuffer: CommandBuffer, stage: PipelineStageFlags2, queryPool: QueryPool, query: u32)
 ProcCmdWriteTimestamp2KHR                                  :: #type proc "system" (commandBuffer: CommandBuffer, stage: PipelineStageFlags2, queryPool: QueryPool, query: u32)
 ProcCompileDeferredNV                                      :: #type proc "system" (device: Device, pipeline: Pipeline, shader: u32) -> Result
+ProcConvertCooperativeVectorMatrixNV                       :: #type proc "system" (device: Device, pInfo: ^ConvertCooperativeVectorMatrixInfoNV) -> Result
 ProcCopyAccelerationStructureKHR                           :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyAccelerationStructureInfoKHR) -> Result
 ProcCopyAccelerationStructureToMemoryKHR                   :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyAccelerationStructureToMemoryInfoKHR) -> Result
 ProcCopyImageToImage                                       :: #type proc "system" (device: Device, pCopyImageToImageInfo: ^CopyImageToImageInfo) -> Result
@@ -535,6 +540,7 @@ ProcGetBufferOpaqueCaptureAddressKHR                       :: #type proc "system
 ProcGetBufferOpaqueCaptureDescriptorDataEXT                :: #type proc "system" (device: Device, pInfo: ^BufferCaptureDescriptorDataInfoEXT, pData: rawptr) -> Result
 ProcGetCalibratedTimestampsEXT                             :: #type proc "system" (device: Device, timestampCount: u32, pTimestampInfos: [^]CalibratedTimestampInfoKHR, pTimestamps: [^]u64, pMaxDeviation: ^u64) -> Result
 ProcGetCalibratedTimestampsKHR                             :: #type proc "system" (device: Device, timestampCount: u32, pTimestampInfos: [^]CalibratedTimestampInfoKHR, pTimestamps: [^]u64, pMaxDeviation: ^u64) -> Result
+ProcGetClusterAccelerationStructureBuildSizesNV            :: #type proc "system" (device: Device, pInfo: ^ClusterAccelerationStructureInputInfoNV, pSizeInfo: ^AccelerationStructureBuildSizesInfoKHR)
 ProcGetCudaModuleCacheNV                                   :: #type proc "system" (device: Device, module: CudaModuleNV, pCacheSize: ^int, pCacheData: rawptr) -> Result
 ProcGetDeferredOperationMaxConcurrencyKHR                  :: #type proc "system" (device: Device, operation: DeferredOperationKHR) -> u32
 ProcGetDeferredOperationResultKHR                          :: #type proc "system" (device: Device, operation: DeferredOperationKHR) -> Result
@@ -597,11 +603,14 @@ ProcGetLatencyTimingsNV                                    :: #type proc "system
 ProcGetMemoryFdKHR                                         :: #type proc "system" (device: Device, pGetFdInfo: ^MemoryGetFdInfoKHR, pFd: ^c.int) -> Result
 ProcGetMemoryFdPropertiesKHR                               :: #type proc "system" (device: Device, handleType: ExternalMemoryHandleTypeFlags, fd: c.int, pMemoryFdProperties: [^]MemoryFdPropertiesKHR) -> Result
 ProcGetMemoryHostPointerPropertiesEXT                      :: #type proc "system" (device: Device, handleType: ExternalMemoryHandleTypeFlags, pHostPointer: rawptr, pMemoryHostPointerProperties: [^]MemoryHostPointerPropertiesEXT) -> Result
+ProcGetMemoryMetalHandleEXT                                :: #type proc "system" (device: Device, pGetMetalHandleInfo: ^MemoryGetMetalHandleInfoEXT, pHandle: ^rawptr) -> Result
+ProcGetMemoryMetalHandlePropertiesEXT                      :: #type proc "system" (device: Device, handleType: ExternalMemoryHandleTypeFlags, pHandle: rawptr, pMemoryMetalHandleProperties: [^]MemoryMetalHandlePropertiesEXT) -> Result
 ProcGetMemoryRemoteAddressNV                               :: #type proc "system" (device: Device, pMemoryGetRemoteAddressInfo: ^MemoryGetRemoteAddressInfoNV, pAddress: [^]RemoteAddressNV) -> Result
 ProcGetMemoryWin32HandleKHR                                :: #type proc "system" (device: Device, pGetWin32HandleInfo: ^MemoryGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result
 ProcGetMemoryWin32HandleNV                                 :: #type proc "system" (device: Device, memory: DeviceMemory, handleType: ExternalMemoryHandleTypeFlagsNV, pHandle: ^HANDLE) -> Result
 ProcGetMemoryWin32HandlePropertiesKHR                      :: #type proc "system" (device: Device, handleType: ExternalMemoryHandleTypeFlags, handle: HANDLE, pMemoryWin32HandleProperties: [^]MemoryWin32HandlePropertiesKHR) -> Result
 ProcGetMicromapBuildSizesEXT                               :: #type proc "system" (device: Device, buildType: AccelerationStructureBuildTypeKHR, pBuildInfo: ^MicromapBuildInfoEXT, pSizeInfo: ^MicromapBuildSizesInfoEXT)
+ProcGetPartitionedAccelerationStructuresBuildSizesNV       :: #type proc "system" (device: Device, pInfo: ^PartitionedAccelerationStructureInstancesInputNV, pSizeInfo: ^AccelerationStructureBuildSizesInfoKHR)
 ProcGetPastPresentationTimingGOOGLE                        :: #type proc "system" (device: Device, swapchain: SwapchainKHR, pPresentationTimingCount: ^u32, pPresentationTimings: [^]PastPresentationTimingGOOGLE) -> Result
 ProcGetPerformanceParameterINTEL                           :: #type proc "system" (device: Device, parameter: PerformanceParameterTypeINTEL, pValue: ^PerformanceValueINTEL) -> Result
 ProcGetPipelineBinaryDataKHR                               :: #type proc "system" (device: Device, pInfo: ^PipelineBinaryDataInfoKHR, pPipelineBinaryKey: ^PipelineBinaryKeyKHR, pPipelineBinaryDataSize: ^int, pPipelineBinaryData: rawptr) -> Result
@@ -759,6 +768,7 @@ GetPhysicalDeviceCalibrateableTimeDomainsKHR:                     ProcGetPhysica
 GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV: ProcGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV
 GetPhysicalDeviceCooperativeMatrixPropertiesKHR:                  ProcGetPhysicalDeviceCooperativeMatrixPropertiesKHR
 GetPhysicalDeviceCooperativeMatrixPropertiesNV:                   ProcGetPhysicalDeviceCooperativeMatrixPropertiesNV
+GetPhysicalDeviceCooperativeVectorPropertiesNV:                   ProcGetPhysicalDeviceCooperativeVectorPropertiesNV
 GetPhysicalDeviceDisplayPlaneProperties2KHR:                      ProcGetPhysicalDeviceDisplayPlaneProperties2KHR
 GetPhysicalDeviceDisplayPlanePropertiesKHR:                       ProcGetPhysicalDeviceDisplayPlanePropertiesKHR
 GetPhysicalDeviceDisplayProperties2KHR:                           ProcGetPhysicalDeviceDisplayProperties2KHR
@@ -875,11 +885,14 @@ CmdBlitImage2KHR:                                       ProcCmdBlitImage2KHR
 CmdBuildAccelerationStructureNV:                        ProcCmdBuildAccelerationStructureNV
 CmdBuildAccelerationStructuresIndirectKHR:              ProcCmdBuildAccelerationStructuresIndirectKHR
 CmdBuildAccelerationStructuresKHR:                      ProcCmdBuildAccelerationStructuresKHR
+CmdBuildClusterAccelerationStructureIndirectNV:         ProcCmdBuildClusterAccelerationStructureIndirectNV
 CmdBuildMicromapsEXT:                                   ProcCmdBuildMicromapsEXT
+CmdBuildPartitionedAccelerationStructuresNV:            ProcCmdBuildPartitionedAccelerationStructuresNV
 CmdClearAttachments:                                    ProcCmdClearAttachments
 CmdClearColorImage:                                     ProcCmdClearColorImage
 CmdClearDepthStencilImage:                              ProcCmdClearDepthStencilImage
 CmdControlVideoCodingKHR:                               ProcCmdControlVideoCodingKHR
+CmdConvertCooperativeVectorMatrixNV:                    ProcCmdConvertCooperativeVectorMatrixNV
 CmdCopyAccelerationStructureKHR:                        ProcCmdCopyAccelerationStructureKHR
 CmdCopyAccelerationStructureNV:                         ProcCmdCopyAccelerationStructureNV
 CmdCopyAccelerationStructureToMemoryKHR:                ProcCmdCopyAccelerationStructureToMemoryKHR
@@ -1102,6 +1115,7 @@ CmdWriteTimestamp:                                      ProcCmdWriteTimestamp
 CmdWriteTimestamp2:                                     ProcCmdWriteTimestamp2
 CmdWriteTimestamp2KHR:                                  ProcCmdWriteTimestamp2KHR
 CompileDeferredNV:                                      ProcCompileDeferredNV
+ConvertCooperativeVectorMatrixNV:                       ProcConvertCooperativeVectorMatrixNV
 CopyAccelerationStructureKHR:                           ProcCopyAccelerationStructureKHR
 CopyAccelerationStructureToMemoryKHR:                   ProcCopyAccelerationStructureToMemoryKHR
 CopyImageToImage:                                       ProcCopyImageToImage
@@ -1232,6 +1246,7 @@ GetBufferOpaqueCaptureAddressKHR:                       ProcGetBufferOpaqueCaptu
 GetBufferOpaqueCaptureDescriptorDataEXT:                ProcGetBufferOpaqueCaptureDescriptorDataEXT
 GetCalibratedTimestampsEXT:                             ProcGetCalibratedTimestampsEXT
 GetCalibratedTimestampsKHR:                             ProcGetCalibratedTimestampsKHR
+GetClusterAccelerationStructureBuildSizesNV:            ProcGetClusterAccelerationStructureBuildSizesNV
 GetCudaModuleCacheNV:                                   ProcGetCudaModuleCacheNV
 GetDeferredOperationMaxConcurrencyKHR:                  ProcGetDeferredOperationMaxConcurrencyKHR
 GetDeferredOperationResultKHR:                          ProcGetDeferredOperationResultKHR
@@ -1294,11 +1309,14 @@ GetLatencyTimingsNV:                                    ProcGetLatencyTimingsNV
 GetMemoryFdKHR:                                         ProcGetMemoryFdKHR
 GetMemoryFdPropertiesKHR:                               ProcGetMemoryFdPropertiesKHR
 GetMemoryHostPointerPropertiesEXT:                      ProcGetMemoryHostPointerPropertiesEXT
+GetMemoryMetalHandleEXT:                                ProcGetMemoryMetalHandleEXT
+GetMemoryMetalHandlePropertiesEXT:                      ProcGetMemoryMetalHandlePropertiesEXT
 GetMemoryRemoteAddressNV:                               ProcGetMemoryRemoteAddressNV
 GetMemoryWin32HandleKHR:                                ProcGetMemoryWin32HandleKHR
 GetMemoryWin32HandleNV:                                 ProcGetMemoryWin32HandleNV
 GetMemoryWin32HandlePropertiesKHR:                      ProcGetMemoryWin32HandlePropertiesKHR
 GetMicromapBuildSizesEXT:                               ProcGetMicromapBuildSizesEXT
+GetPartitionedAccelerationStructuresBuildSizesNV:       ProcGetPartitionedAccelerationStructuresBuildSizesNV
 GetPastPresentationTimingGOOGLE:                        ProcGetPastPresentationTimingGOOGLE
 GetPerformanceParameterINTEL:                           ProcGetPerformanceParameterINTEL
 GetPipelineBinaryDataKHR:                               ProcGetPipelineBinaryDataKHR
@@ -1456,6 +1474,7 @@ load_proc_addresses_custom :: proc(set_proc_address: SetProcAddressType) {
 	set_proc_address(&GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV")
 	set_proc_address(&GetPhysicalDeviceCooperativeMatrixPropertiesKHR,                  "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR")
 	set_proc_address(&GetPhysicalDeviceCooperativeMatrixPropertiesNV,                   "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")
+	set_proc_address(&GetPhysicalDeviceCooperativeVectorPropertiesNV,                   "vkGetPhysicalDeviceCooperativeVectorPropertiesNV")
 	set_proc_address(&GetPhysicalDeviceDisplayPlaneProperties2KHR,                      "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")
 	set_proc_address(&GetPhysicalDeviceDisplayPlanePropertiesKHR,                       "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")
 	set_proc_address(&GetPhysicalDeviceDisplayProperties2KHR,                           "vkGetPhysicalDeviceDisplayProperties2KHR")
@@ -1572,11 +1591,14 @@ load_proc_addresses_custom :: proc(set_proc_address: SetProcAddressType) {
 	set_proc_address(&CmdBuildAccelerationStructureNV,                        "vkCmdBuildAccelerationStructureNV")
 	set_proc_address(&CmdBuildAccelerationStructuresIndirectKHR,              "vkCmdBuildAccelerationStructuresIndirectKHR")
 	set_proc_address(&CmdBuildAccelerationStructuresKHR,                      "vkCmdBuildAccelerationStructuresKHR")
+	set_proc_address(&CmdBuildClusterAccelerationStructureIndirectNV,         "vkCmdBuildClusterAccelerationStructureIndirectNV")
 	set_proc_address(&CmdBuildMicromapsEXT,                                   "vkCmdBuildMicromapsEXT")
+	set_proc_address(&CmdBuildPartitionedAccelerationStructuresNV,            "vkCmdBuildPartitionedAccelerationStructuresNV")
 	set_proc_address(&CmdClearAttachments,                                    "vkCmdClearAttachments")
 	set_proc_address(&CmdClearColorImage,                                     "vkCmdClearColorImage")
 	set_proc_address(&CmdClearDepthStencilImage,                              "vkCmdClearDepthStencilImage")
 	set_proc_address(&CmdControlVideoCodingKHR,                               "vkCmdControlVideoCodingKHR")
+	set_proc_address(&CmdConvertCooperativeVectorMatrixNV,                    "vkCmdConvertCooperativeVectorMatrixNV")
 	set_proc_address(&CmdCopyAccelerationStructureKHR,                        "vkCmdCopyAccelerationStructureKHR")
 	set_proc_address(&CmdCopyAccelerationStructureNV,                         "vkCmdCopyAccelerationStructureNV")
 	set_proc_address(&CmdCopyAccelerationStructureToMemoryKHR,                "vkCmdCopyAccelerationStructureToMemoryKHR")
@@ -1799,6 +1821,7 @@ load_proc_addresses_custom :: proc(set_proc_address: SetProcAddressType) {
 	set_proc_address(&CmdWriteTimestamp2,                                     "vkCmdWriteTimestamp2")
 	set_proc_address(&CmdWriteTimestamp2KHR,                                  "vkCmdWriteTimestamp2KHR")
 	set_proc_address(&CompileDeferredNV,                                      "vkCompileDeferredNV")
+	set_proc_address(&ConvertCooperativeVectorMatrixNV,                       "vkConvertCooperativeVectorMatrixNV")
 	set_proc_address(&CopyAccelerationStructureKHR,                           "vkCopyAccelerationStructureKHR")
 	set_proc_address(&CopyAccelerationStructureToMemoryKHR,                   "vkCopyAccelerationStructureToMemoryKHR")
 	set_proc_address(&CopyImageToImage,                                       "vkCopyImageToImage")
@@ -1929,6 +1952,7 @@ load_proc_addresses_custom :: proc(set_proc_address: SetProcAddressType) {
 	set_proc_address(&GetBufferOpaqueCaptureDescriptorDataEXT,                "vkGetBufferOpaqueCaptureDescriptorDataEXT")
 	set_proc_address(&GetCalibratedTimestampsEXT,                             "vkGetCalibratedTimestampsEXT")
 	set_proc_address(&GetCalibratedTimestampsKHR,                             "vkGetCalibratedTimestampsKHR")
+	set_proc_address(&GetClusterAccelerationStructureBuildSizesNV,            "vkGetClusterAccelerationStructureBuildSizesNV")
 	set_proc_address(&GetCudaModuleCacheNV,                                   "vkGetCudaModuleCacheNV")
 	set_proc_address(&GetDeferredOperationMaxConcurrencyKHR,                  "vkGetDeferredOperationMaxConcurrencyKHR")
 	set_proc_address(&GetDeferredOperationResultKHR,                          "vkGetDeferredOperationResultKHR")
@@ -1991,11 +2015,14 @@ load_proc_addresses_custom :: proc(set_proc_address: SetProcAddressType) {
 	set_proc_address(&GetMemoryFdKHR,                                         "vkGetMemoryFdKHR")
 	set_proc_address(&GetMemoryFdPropertiesKHR,                               "vkGetMemoryFdPropertiesKHR")
 	set_proc_address(&GetMemoryHostPointerPropertiesEXT,                      "vkGetMemoryHostPointerPropertiesEXT")
+	set_proc_address(&GetMemoryMetalHandleEXT,                                "vkGetMemoryMetalHandleEXT")
+	set_proc_address(&GetMemoryMetalHandlePropertiesEXT,                      "vkGetMemoryMetalHandlePropertiesEXT")
 	set_proc_address(&GetMemoryRemoteAddressNV,                               "vkGetMemoryRemoteAddressNV")
 	set_proc_address(&GetMemoryWin32HandleKHR,                                "vkGetMemoryWin32HandleKHR")
 	set_proc_address(&GetMemoryWin32HandleNV,                                 "vkGetMemoryWin32HandleNV")
 	set_proc_address(&GetMemoryWin32HandlePropertiesKHR,                      "vkGetMemoryWin32HandlePropertiesKHR")
 	set_proc_address(&GetMicromapBuildSizesEXT,                               "vkGetMicromapBuildSizesEXT")
+	set_proc_address(&GetPartitionedAccelerationStructuresBuildSizesNV,       "vkGetPartitionedAccelerationStructuresBuildSizesNV")
 	set_proc_address(&GetPastPresentationTimingGOOGLE,                        "vkGetPastPresentationTimingGOOGLE")
 	set_proc_address(&GetPerformanceParameterINTEL,                           "vkGetPerformanceParameterINTEL")
 	set_proc_address(&GetPipelineBinaryDataKHR,                               "vkGetPipelineBinaryDataKHR")
@@ -2164,11 +2191,14 @@ Device_VTable :: struct {
 	CmdBuildAccelerationStructureNV:                        ProcCmdBuildAccelerationStructureNV,
 	CmdBuildAccelerationStructuresIndirectKHR:              ProcCmdBuildAccelerationStructuresIndirectKHR,
 	CmdBuildAccelerationStructuresKHR:                      ProcCmdBuildAccelerationStructuresKHR,
+	CmdBuildClusterAccelerationStructureIndirectNV:         ProcCmdBuildClusterAccelerationStructureIndirectNV,
 	CmdBuildMicromapsEXT:                                   ProcCmdBuildMicromapsEXT,
+	CmdBuildPartitionedAccelerationStructuresNV:            ProcCmdBuildPartitionedAccelerationStructuresNV,
 	CmdClearAttachments:                                    ProcCmdClearAttachments,
 	CmdClearColorImage:                                     ProcCmdClearColorImage,
 	CmdClearDepthStencilImage:                              ProcCmdClearDepthStencilImage,
 	CmdControlVideoCodingKHR:                               ProcCmdControlVideoCodingKHR,
+	CmdConvertCooperativeVectorMatrixNV:                    ProcCmdConvertCooperativeVectorMatrixNV,
 	CmdCopyAccelerationStructureKHR:                        ProcCmdCopyAccelerationStructureKHR,
 	CmdCopyAccelerationStructureNV:                         ProcCmdCopyAccelerationStructureNV,
 	CmdCopyAccelerationStructureToMemoryKHR:                ProcCmdCopyAccelerationStructureToMemoryKHR,
@@ -2391,6 +2421,7 @@ Device_VTable :: struct {
 	CmdWriteTimestamp2:                                     ProcCmdWriteTimestamp2,
 	CmdWriteTimestamp2KHR:                                  ProcCmdWriteTimestamp2KHR,
 	CompileDeferredNV:                                      ProcCompileDeferredNV,
+	ConvertCooperativeVectorMatrixNV:                       ProcConvertCooperativeVectorMatrixNV,
 	CopyAccelerationStructureKHR:                           ProcCopyAccelerationStructureKHR,
 	CopyAccelerationStructureToMemoryKHR:                   ProcCopyAccelerationStructureToMemoryKHR,
 	CopyImageToImage:                                       ProcCopyImageToImage,
@@ -2521,6 +2552,7 @@ Device_VTable :: struct {
 	GetBufferOpaqueCaptureDescriptorDataEXT:                ProcGetBufferOpaqueCaptureDescriptorDataEXT,
 	GetCalibratedTimestampsEXT:                             ProcGetCalibratedTimestampsEXT,
 	GetCalibratedTimestampsKHR:                             ProcGetCalibratedTimestampsKHR,
+	GetClusterAccelerationStructureBuildSizesNV:            ProcGetClusterAccelerationStructureBuildSizesNV,
 	GetCudaModuleCacheNV:                                   ProcGetCudaModuleCacheNV,
 	GetDeferredOperationMaxConcurrencyKHR:                  ProcGetDeferredOperationMaxConcurrencyKHR,
 	GetDeferredOperationResultKHR:                          ProcGetDeferredOperationResultKHR,
@@ -2583,11 +2615,14 @@ Device_VTable :: struct {
 	GetMemoryFdKHR:                                         ProcGetMemoryFdKHR,
 	GetMemoryFdPropertiesKHR:                               ProcGetMemoryFdPropertiesKHR,
 	GetMemoryHostPointerPropertiesEXT:                      ProcGetMemoryHostPointerPropertiesEXT,
+	GetMemoryMetalHandleEXT:                                ProcGetMemoryMetalHandleEXT,
+	GetMemoryMetalHandlePropertiesEXT:                      ProcGetMemoryMetalHandlePropertiesEXT,
 	GetMemoryRemoteAddressNV:                               ProcGetMemoryRemoteAddressNV,
 	GetMemoryWin32HandleKHR:                                ProcGetMemoryWin32HandleKHR,
 	GetMemoryWin32HandleNV:                                 ProcGetMemoryWin32HandleNV,
 	GetMemoryWin32HandlePropertiesKHR:                      ProcGetMemoryWin32HandlePropertiesKHR,
 	GetMicromapBuildSizesEXT:                               ProcGetMicromapBuildSizesEXT,
+	GetPartitionedAccelerationStructuresBuildSizesNV:       ProcGetPartitionedAccelerationStructuresBuildSizesNV,
 	GetPastPresentationTimingGOOGLE:                        ProcGetPastPresentationTimingGOOGLE,
 	GetPerformanceParameterINTEL:                           ProcGetPerformanceParameterINTEL,
 	GetPipelineBinaryDataKHR:                               ProcGetPipelineBinaryDataKHR,
@@ -2754,11 +2789,14 @@ load_proc_addresses_device_vtable :: proc(device: Device, vtable: ^Device_VTable
 	vtable.CmdBuildAccelerationStructureNV                        = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructureNV")
 	vtable.CmdBuildAccelerationStructuresIndirectKHR              = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresIndirectKHR")
 	vtable.CmdBuildAccelerationStructuresKHR                      = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresKHR")
+	vtable.CmdBuildClusterAccelerationStructureIndirectNV         = auto_cast GetDeviceProcAddr(device, "vkCmdBuildClusterAccelerationStructureIndirectNV")
 	vtable.CmdBuildMicromapsEXT                                   = auto_cast GetDeviceProcAddr(device, "vkCmdBuildMicromapsEXT")
+	vtable.CmdBuildPartitionedAccelerationStructuresNV            = auto_cast GetDeviceProcAddr(device, "vkCmdBuildPartitionedAccelerationStructuresNV")
 	vtable.CmdClearAttachments                                    = auto_cast GetDeviceProcAddr(device, "vkCmdClearAttachments")
 	vtable.CmdClearColorImage                                     = auto_cast GetDeviceProcAddr(device, "vkCmdClearColorImage")
 	vtable.CmdClearDepthStencilImage                              = auto_cast GetDeviceProcAddr(device, "vkCmdClearDepthStencilImage")
 	vtable.CmdControlVideoCodingKHR                               = auto_cast GetDeviceProcAddr(device, "vkCmdControlVideoCodingKHR")
+	vtable.CmdConvertCooperativeVectorMatrixNV                    = auto_cast GetDeviceProcAddr(device, "vkCmdConvertCooperativeVectorMatrixNV")
 	vtable.CmdCopyAccelerationStructureKHR                        = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureKHR")
 	vtable.CmdCopyAccelerationStructureNV                         = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureNV")
 	vtable.CmdCopyAccelerationStructureToMemoryKHR                = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureToMemoryKHR")
@@ -2981,6 +3019,7 @@ load_proc_addresses_device_vtable :: proc(device: Device, vtable: ^Device_VTable
 	vtable.CmdWriteTimestamp2                                     = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp2")
 	vtable.CmdWriteTimestamp2KHR                                  = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp2KHR")
 	vtable.CompileDeferredNV                                      = auto_cast GetDeviceProcAddr(device, "vkCompileDeferredNV")
+	vtable.ConvertCooperativeVectorMatrixNV                       = auto_cast GetDeviceProcAddr(device, "vkConvertCooperativeVectorMatrixNV")
 	vtable.CopyAccelerationStructureKHR                           = auto_cast GetDeviceProcAddr(device, "vkCopyAccelerationStructureKHR")
 	vtable.CopyAccelerationStructureToMemoryKHR                   = auto_cast GetDeviceProcAddr(device, "vkCopyAccelerationStructureToMemoryKHR")
 	vtable.CopyImageToImage                                       = auto_cast GetDeviceProcAddr(device, "vkCopyImageToImage")
@@ -3111,6 +3150,7 @@ load_proc_addresses_device_vtable :: proc(device: Device, vtable: ^Device_VTable
 	vtable.GetBufferOpaqueCaptureDescriptorDataEXT                = auto_cast GetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureDescriptorDataEXT")
 	vtable.GetCalibratedTimestampsEXT                             = auto_cast GetDeviceProcAddr(device, "vkGetCalibratedTimestampsEXT")
 	vtable.GetCalibratedTimestampsKHR                             = auto_cast GetDeviceProcAddr(device, "vkGetCalibratedTimestampsKHR")
+	vtable.GetClusterAccelerationStructureBuildSizesNV            = auto_cast GetDeviceProcAddr(device, "vkGetClusterAccelerationStructureBuildSizesNV")
 	vtable.GetCudaModuleCacheNV                                   = auto_cast GetDeviceProcAddr(device, "vkGetCudaModuleCacheNV")
 	vtable.GetDeferredOperationMaxConcurrencyKHR                  = auto_cast GetDeviceProcAddr(device, "vkGetDeferredOperationMaxConcurrencyKHR")
 	vtable.GetDeferredOperationResultKHR                          = auto_cast GetDeviceProcAddr(device, "vkGetDeferredOperationResultKHR")
@@ -3173,11 +3213,14 @@ load_proc_addresses_device_vtable :: proc(device: Device, vtable: ^Device_VTable
 	vtable.GetMemoryFdKHR                                         = auto_cast GetDeviceProcAddr(device, "vkGetMemoryFdKHR")
 	vtable.GetMemoryFdPropertiesKHR                               = auto_cast GetDeviceProcAddr(device, "vkGetMemoryFdPropertiesKHR")
 	vtable.GetMemoryHostPointerPropertiesEXT                      = auto_cast GetDeviceProcAddr(device, "vkGetMemoryHostPointerPropertiesEXT")
+	vtable.GetMemoryMetalHandleEXT                                = auto_cast GetDeviceProcAddr(device, "vkGetMemoryMetalHandleEXT")
+	vtable.GetMemoryMetalHandlePropertiesEXT                      = auto_cast GetDeviceProcAddr(device, "vkGetMemoryMetalHandlePropertiesEXT")
 	vtable.GetMemoryRemoteAddressNV                               = auto_cast GetDeviceProcAddr(device, "vkGetMemoryRemoteAddressNV")
 	vtable.GetMemoryWin32HandleKHR                                = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandleKHR")
 	vtable.GetMemoryWin32HandleNV                                 = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandleNV")
 	vtable.GetMemoryWin32HandlePropertiesKHR                      = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandlePropertiesKHR")
 	vtable.GetMicromapBuildSizesEXT                               = auto_cast GetDeviceProcAddr(device, "vkGetMicromapBuildSizesEXT")
+	vtable.GetPartitionedAccelerationStructuresBuildSizesNV       = auto_cast GetDeviceProcAddr(device, "vkGetPartitionedAccelerationStructuresBuildSizesNV")
 	vtable.GetPastPresentationTimingGOOGLE                        = auto_cast GetDeviceProcAddr(device, "vkGetPastPresentationTimingGOOGLE")
 	vtable.GetPerformanceParameterINTEL                           = auto_cast GetDeviceProcAddr(device, "vkGetPerformanceParameterINTEL")
 	vtable.GetPipelineBinaryDataKHR                               = auto_cast GetDeviceProcAddr(device, "vkGetPipelineBinaryDataKHR")
@@ -3344,11 +3387,14 @@ load_proc_addresses_device :: proc(device: Device) {
 	CmdBuildAccelerationStructureNV                        = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructureNV")
 	CmdBuildAccelerationStructuresIndirectKHR              = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresIndirectKHR")
 	CmdBuildAccelerationStructuresKHR                      = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresKHR")
+	CmdBuildClusterAccelerationStructureIndirectNV         = auto_cast GetDeviceProcAddr(device, "vkCmdBuildClusterAccelerationStructureIndirectNV")
 	CmdBuildMicromapsEXT                                   = auto_cast GetDeviceProcAddr(device, "vkCmdBuildMicromapsEXT")
+	CmdBuildPartitionedAccelerationStructuresNV            = auto_cast GetDeviceProcAddr(device, "vkCmdBuildPartitionedAccelerationStructuresNV")
 	CmdClearAttachments                                    = auto_cast GetDeviceProcAddr(device, "vkCmdClearAttachments")
 	CmdClearColorImage                                     = auto_cast GetDeviceProcAddr(device, "vkCmdClearColorImage")
 	CmdClearDepthStencilImage                              = auto_cast GetDeviceProcAddr(device, "vkCmdClearDepthStencilImage")
 	CmdControlVideoCodingKHR                               = auto_cast GetDeviceProcAddr(device, "vkCmdControlVideoCodingKHR")
+	CmdConvertCooperativeVectorMatrixNV                    = auto_cast GetDeviceProcAddr(device, "vkCmdConvertCooperativeVectorMatrixNV")
 	CmdCopyAccelerationStructureKHR                        = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureKHR")
 	CmdCopyAccelerationStructureNV                         = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureNV")
 	CmdCopyAccelerationStructureToMemoryKHR                = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureToMemoryKHR")
@@ -3571,6 +3617,7 @@ load_proc_addresses_device :: proc(device: Device) {
 	CmdWriteTimestamp2                                     = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp2")
 	CmdWriteTimestamp2KHR                                  = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp2KHR")
 	CompileDeferredNV                                      = auto_cast GetDeviceProcAddr(device, "vkCompileDeferredNV")
+	ConvertCooperativeVectorMatrixNV                       = auto_cast GetDeviceProcAddr(device, "vkConvertCooperativeVectorMatrixNV")
 	CopyAccelerationStructureKHR                           = auto_cast GetDeviceProcAddr(device, "vkCopyAccelerationStructureKHR")
 	CopyAccelerationStructureToMemoryKHR                   = auto_cast GetDeviceProcAddr(device, "vkCopyAccelerationStructureToMemoryKHR")
 	CopyImageToImage                                       = auto_cast GetDeviceProcAddr(device, "vkCopyImageToImage")
@@ -3701,6 +3748,7 @@ load_proc_addresses_device :: proc(device: Device) {
 	GetBufferOpaqueCaptureDescriptorDataEXT                = auto_cast GetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureDescriptorDataEXT")
 	GetCalibratedTimestampsEXT                             = auto_cast GetDeviceProcAddr(device, "vkGetCalibratedTimestampsEXT")
 	GetCalibratedTimestampsKHR                             = auto_cast GetDeviceProcAddr(device, "vkGetCalibratedTimestampsKHR")
+	GetClusterAccelerationStructureBuildSizesNV            = auto_cast GetDeviceProcAddr(device, "vkGetClusterAccelerationStructureBuildSizesNV")
 	GetCudaModuleCacheNV                                   = auto_cast GetDeviceProcAddr(device, "vkGetCudaModuleCacheNV")
 	GetDeferredOperationMaxConcurrencyKHR                  = auto_cast GetDeviceProcAddr(device, "vkGetDeferredOperationMaxConcurrencyKHR")
 	GetDeferredOperationResultKHR                          = auto_cast GetDeviceProcAddr(device, "vkGetDeferredOperationResultKHR")
@@ -3763,11 +3811,14 @@ load_proc_addresses_device :: proc(device: Device) {
 	GetMemoryFdKHR                                         = auto_cast GetDeviceProcAddr(device, "vkGetMemoryFdKHR")
 	GetMemoryFdPropertiesKHR                               = auto_cast GetDeviceProcAddr(device, "vkGetMemoryFdPropertiesKHR")
 	GetMemoryHostPointerPropertiesEXT                      = auto_cast GetDeviceProcAddr(device, "vkGetMemoryHostPointerPropertiesEXT")
+	GetMemoryMetalHandleEXT                                = auto_cast GetDeviceProcAddr(device, "vkGetMemoryMetalHandleEXT")
+	GetMemoryMetalHandlePropertiesEXT                      = auto_cast GetDeviceProcAddr(device, "vkGetMemoryMetalHandlePropertiesEXT")
 	GetMemoryRemoteAddressNV                               = auto_cast GetDeviceProcAddr(device, "vkGetMemoryRemoteAddressNV")
 	GetMemoryWin32HandleKHR                                = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandleKHR")
 	GetMemoryWin32HandleNV                                 = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandleNV")
 	GetMemoryWin32HandlePropertiesKHR                      = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandlePropertiesKHR")
 	GetMicromapBuildSizesEXT                               = auto_cast GetDeviceProcAddr(device, "vkGetMicromapBuildSizesEXT")
+	GetPartitionedAccelerationStructuresBuildSizesNV       = auto_cast GetDeviceProcAddr(device, "vkGetPartitionedAccelerationStructuresBuildSizesNV")
 	GetPastPresentationTimingGOOGLE                        = auto_cast GetDeviceProcAddr(device, "vkGetPastPresentationTimingGOOGLE")
 	GetPerformanceParameterINTEL                           = auto_cast GetDeviceProcAddr(device, "vkGetPerformanceParameterINTEL")
 	GetPipelineBinaryDataKHR                               = auto_cast GetDeviceProcAddr(device, "vkGetPipelineBinaryDataKHR")
@@ -3916,6 +3967,7 @@ load_proc_addresses_instance :: proc(instance: Instance) {
 	GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV")
 	GetPhysicalDeviceCooperativeMatrixPropertiesKHR                  = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR")
 	GetPhysicalDeviceCooperativeMatrixPropertiesNV                   = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")
+	GetPhysicalDeviceCooperativeVectorPropertiesNV                   = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV")
 	GetPhysicalDeviceDisplayPlaneProperties2KHR                      = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")
 	GetPhysicalDeviceDisplayPlanePropertiesKHR                       = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")
 	GetPhysicalDeviceDisplayProperties2KHR                           = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayProperties2KHR")
@@ -4032,11 +4084,14 @@ load_proc_addresses_instance :: proc(instance: Instance) {
 	CmdBuildAccelerationStructureNV                        = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructureNV")
 	CmdBuildAccelerationStructuresIndirectKHR              = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresIndirectKHR")
 	CmdBuildAccelerationStructuresKHR                      = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresKHR")
+	CmdBuildClusterAccelerationStructureIndirectNV         = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildClusterAccelerationStructureIndirectNV")
 	CmdBuildMicromapsEXT                                   = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildMicromapsEXT")
+	CmdBuildPartitionedAccelerationStructuresNV            = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildPartitionedAccelerationStructuresNV")
 	CmdClearAttachments                                    = auto_cast GetInstanceProcAddr(instance, "vkCmdClearAttachments")
 	CmdClearColorImage                                     = auto_cast GetInstanceProcAddr(instance, "vkCmdClearColorImage")
 	CmdClearDepthStencilImage                              = auto_cast GetInstanceProcAddr(instance, "vkCmdClearDepthStencilImage")
 	CmdControlVideoCodingKHR                               = auto_cast GetInstanceProcAddr(instance, "vkCmdControlVideoCodingKHR")
+	CmdConvertCooperativeVectorMatrixNV                    = auto_cast GetInstanceProcAddr(instance, "vkCmdConvertCooperativeVectorMatrixNV")
 	CmdCopyAccelerationStructureKHR                        = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureKHR")
 	CmdCopyAccelerationStructureNV                         = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureNV")
 	CmdCopyAccelerationStructureToMemoryKHR                = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureToMemoryKHR")
@@ -4259,6 +4314,7 @@ load_proc_addresses_instance :: proc(instance: Instance) {
 	CmdWriteTimestamp2                                     = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteTimestamp2")
 	CmdWriteTimestamp2KHR                                  = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteTimestamp2KHR")
 	CompileDeferredNV                                      = auto_cast GetInstanceProcAddr(instance, "vkCompileDeferredNV")
+	ConvertCooperativeVectorMatrixNV                       = auto_cast GetInstanceProcAddr(instance, "vkConvertCooperativeVectorMatrixNV")
 	CopyAccelerationStructureKHR                           = auto_cast GetInstanceProcAddr(instance, "vkCopyAccelerationStructureKHR")
 	CopyAccelerationStructureToMemoryKHR                   = auto_cast GetInstanceProcAddr(instance, "vkCopyAccelerationStructureToMemoryKHR")
 	CopyImageToImage                                       = auto_cast GetInstanceProcAddr(instance, "vkCopyImageToImage")
@@ -4389,6 +4445,7 @@ load_proc_addresses_instance :: proc(instance: Instance) {
 	GetBufferOpaqueCaptureDescriptorDataEXT                = auto_cast GetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureDescriptorDataEXT")
 	GetCalibratedTimestampsEXT                             = auto_cast GetInstanceProcAddr(instance, "vkGetCalibratedTimestampsEXT")
 	GetCalibratedTimestampsKHR                             = auto_cast GetInstanceProcAddr(instance, "vkGetCalibratedTimestampsKHR")
+	GetClusterAccelerationStructureBuildSizesNV            = auto_cast GetInstanceProcAddr(instance, "vkGetClusterAccelerationStructureBuildSizesNV")
 	GetCudaModuleCacheNV                                   = auto_cast GetInstanceProcAddr(instance, "vkGetCudaModuleCacheNV")
 	GetDeferredOperationMaxConcurrencyKHR                  = auto_cast GetInstanceProcAddr(instance, "vkGetDeferredOperationMaxConcurrencyKHR")
 	GetDeferredOperationResultKHR                          = auto_cast GetInstanceProcAddr(instance, "vkGetDeferredOperationResultKHR")
@@ -4451,11 +4508,14 @@ load_proc_addresses_instance :: proc(instance: Instance) {
 	GetMemoryFdKHR                                         = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryFdKHR")
 	GetMemoryFdPropertiesKHR                               = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryFdPropertiesKHR")
 	GetMemoryHostPointerPropertiesEXT                      = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryHostPointerPropertiesEXT")
+	GetMemoryMetalHandleEXT                                = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryMetalHandleEXT")
+	GetMemoryMetalHandlePropertiesEXT                      = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryMetalHandlePropertiesEXT")
 	GetMemoryRemoteAddressNV                               = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryRemoteAddressNV")
 	GetMemoryWin32HandleKHR                                = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryWin32HandleKHR")
 	GetMemoryWin32HandleNV                                 = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryWin32HandleNV")
 	GetMemoryWin32HandlePropertiesKHR                      = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryWin32HandlePropertiesKHR")
 	GetMicromapBuildSizesEXT                               = auto_cast GetInstanceProcAddr(instance, "vkGetMicromapBuildSizesEXT")
+	GetPartitionedAccelerationStructuresBuildSizesNV       = auto_cast GetInstanceProcAddr(instance, "vkGetPartitionedAccelerationStructuresBuildSizesNV")
 	GetPastPresentationTimingGOOGLE                        = auto_cast GetInstanceProcAddr(instance, "vkGetPastPresentationTimingGOOGLE")
 	GetPerformanceParameterINTEL                           = auto_cast GetInstanceProcAddr(instance, "vkGetPerformanceParameterINTEL")
 	GetPipelineBinaryDataKHR                               = auto_cast GetInstanceProcAddr(instance, "vkGetPipelineBinaryDataKHR")