kk: Add KosmicKrisp

Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/37522>

130 files changed, 24271 insertions, 2 deletions

diff --git a/meson.build b/meson.build
index ec978d02cdd..80917def523 100644
--- a/meson.build
+++ b/meson.build
@@ -271,7 +271,7 @@ elif _vulkan_drivers.contains('all')
    _vulkan_drivers = ['amd', 'intel', 'intel_hasvk', 'swrast',
                       'freedreno', 'panfrost', 'virtio', 'broadcom',
                       'imagination', 'microsoft-experimental',
-                      'nouveau', 'asahi', 'gfxstream']
+                      'nouveau', 'asahi', 'gfxstream', 'kosmickrisp']
 endif
 
 with_intel_vk = _vulkan_drivers.contains('intel')
@@ -288,6 +288,7 @@ with_microsoft_vk = _vulkan_drivers.contains('microsoft-experimental')
 with_nouveau_vk = _vulkan_drivers.contains('nouveau')
 with_asahi_vk = _vulkan_drivers.contains('asahi')
 with_gfxstream_vk = _vulkan_drivers.contains('gfxstream')
+with_kosmickrisp_vk = _vulkan_drivers.contains('kosmickrisp')
 with_any_vk = _vulkan_drivers.length() != 0
 
 with_llvm = with_llvm \
@@ -829,6 +830,7 @@ with_driver_using_cl = [
   with_gallium_asahi, with_asahi_vk, with_tools.contains('asahi'),
   with_gallium_panfrost, with_panfrost_vk,
   with_nouveau_vk, with_imagination_vk,
+  with_kosmickrisp_vk,
 ].contains(true)
 
 if get_option('mesa-clc') == 'system'
diff --git a/meson.options b/meson.options
index b1f98d7452a..75731475c12 100644
--- a/meson.options
+++ b/meson.options
@@ -209,7 +209,7 @@ option(
   choices : ['auto', 'amd', 'broadcom', 'freedreno', 'intel', 'intel_hasvk',
              'panfrost', 'swrast', 'virtio', 'imagination',
              'microsoft-experimental', 'nouveau', 'asahi', 'gfxstream',
-             'all'],
+             'kosmickrisp', 'all'],
   description : 'List of vulkan drivers to build. If this is set to auto ' +
                 'all drivers applicable to the target OS/architecture ' +
                 'will be built'
diff --git a/src/kosmickrisp/.clang-format b/src/kosmickrisp/.clang-format
new file mode 100644
index 00000000000..91bc46f7dbf
--- /dev/null
+++ b/src/kosmickrisp/.clang-format
@@ -0,0 +1,7 @@
+BasedOnStyle: InheritParentConfig
+DisableFormat: false
+
+AlignConsecutiveBitFields: true
+ColumnLimit: 80
+BreakStringLiterals: false
+SpaceBeforeParens: ControlStatementsExceptControlMacros
diff --git a/src/kosmickrisp/bridge/meson.build b/src/kosmickrisp/bridge/meson.build
new file mode 100644
index 00000000000..b2f5306bd9b
--- /dev/null
+++ b/src/kosmickrisp/bridge/meson.build
@@ -0,0 +1,61 @@
+# Copyright 2025 LunarG, Inc.
+# Copyright 2025 Google LLC
+# SPDX-License-Identifier: MIT
+
+mtl_bridge_files = files(
+  'vk_to_mtl_map.h',
+  'vk_to_mtl_map.c',
+  'mtl_format.h',
+)
+
+if host_machine.system() == 'darwin'
+  mtl_bridge_files += files(
+    'mtl_bridge.m',
+    'mtl_buffer.m',
+    'mtl_command_buffer.m',
+    'mtl_command_queue.m',
+    'mtl_compute_state.m',
+    'mtl_device.m',
+    'mtl_encoder.m',
+    'mtl_heap.m',
+    'mtl_library.m',
+    'mtl_render_state.m',
+    'mtl_sampler.m',
+    'mtl_sync.m',
+    'mtl_texture.m',
+  )
+else
+  mtl_bridge_files += files(
+    'stubs/mtl_bridge.c',
+    'stubs/mtl_buffer.c',
+    'stubs/mtl_command_buffer.c',
+    'stubs/mtl_command_queue.c',
+    'stubs/mtl_compute_state.c',
+    'stubs/mtl_device.c',
+    'stubs/mtl_encoder.c',
+    'stubs/mtl_heap.c',
+    'stubs/mtl_library.c',
+    'stubs/mtl_render_state.c',
+    'stubs/mtl_sampler.c',
+    'stubs/mtl_sync.c',
+    'stubs/mtl_texture.c',
+  )
+endif
+
+mtl_bridge_dependencies = [
+  idep_vulkan_lite_runtime_headers,
+  idep_vulkan_util_headers
+]
+
+libmtl_bridge = static_library(
+  'mtl_bridge',
+  [mtl_bridge_files],
+  include_directories : [include_directories('../vulkan/'), inc_include, inc_src],
+  dependencies : mtl_bridge_dependencies,
+  gnu_symbol_visibility: 'hidden',
+  build_by_default: false,
+)
+
+idep_mtl_bridge = declare_dependency(
+  link_with : libmtl_bridge,
+)
diff --git a/src/kosmickrisp/bridge/mtl_bridge.h b/src/kosmickrisp/bridge/mtl_bridge.h
new file mode 100644
index 00000000000..bcb8245d42c
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_bridge.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_BRIDGE_H
+#define KK_BRIDGE_H 1
+
+/* C wrappers for Metal. May not be complete. If you find something you need
+ * feel free to add them where they belong. As a rule of thumb, member functions
+ * go in the objects' .h/.m/.c Naming convention for wrappers is:
+ * object_type* mtl_new_object_type(params...);
+ * void mtl_member_function(object_type* ptr, params...);
+ * void mtl_object_set_member(object_type* ptr, member_type value);
+ * member_type mtl_object_get_member(object_type* ptr);
+ *
+ * Functions that have new in the name require to release the returned object
+ * via mtl_release(object);
+ * */
+
+#include "mtl_types.h"
+
+#include "mtl_buffer.h"
+#include "mtl_command_buffer.h"
+#include "mtl_command_queue.h"
+#include "mtl_compute_state.h"
+#include "mtl_device.h"
+#include "mtl_encoder.h"
+#include "mtl_format.h"
+#include "mtl_heap.h"
+#include "mtl_library.h"
+#include "mtl_render_state.h"
+#include "mtl_sampler.h"
+#include "mtl_sync.h"
+#include "mtl_texture.h"
+
+mtl_texture *mtl_drawable_get_texture(void *drawable_ptr);
+
+void *mtl_retain(void *handle);
+void mtl_release(void *handle);
+
+#endif /* KK_BRIDGE_H */
diff --git a/src/kosmickrisp/bridge/mtl_bridge.m b/src/kosmickrisp/bridge/mtl_bridge.m
new file mode 100644
index 00000000000..a5ef514f630
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_bridge.m
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_bridge.h"
+
+// kk_image_layout.h should also includes "vulkan/vulkan.h", but just to be safe
+#include "vulkan/vulkan.h"
+#include "kk_image_layout.h"
+
+#include "util/macros.h"
+
+#include <Metal/MTLCommandBuffer.h>
+#include <Metal/MTLCommandQueue.h>
+#include <Metal/MTLDevice.h>
+#include <Metal/MTLHeap.h>
+#include <Metal/MTLEvent.h>
+
+#include <QuartzCore/CAMetalLayer.h>
+
+static_assert(sizeof(MTLResourceID) == sizeof(uint64_t), "Must match, otherwise descriptors are broken");
+
+mtl_texture *
+mtl_drawable_get_texture(void *drawable_ptr)
+{
+   @autoreleasepool {
+      id<CAMetalDrawable> drawable = (id<CAMetalDrawable>)drawable_ptr;
+      return drawable.texture;
+   }
+}
+
+void *
+mtl_retain(void *handle)
+{
+   @autoreleasepool {
+      NSObject *obj = (NSObject *)handle;
+      return [obj retain];
+   }
+}
+
+void
+mtl_release(void *handle)
+{
+   @autoreleasepool {
+      NSObject *obj = (NSObject *)handle;
+      [obj release];
+   }
+}
diff --git a/src/kosmickrisp/bridge/mtl_buffer.h b/src/kosmickrisp/bridge/mtl_buffer.h
new file mode 100644
index 00000000000..fc8cd21e5fa
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_buffer.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef MTL_BUFFER_H
+#define MTL_BUFFER_H 1
+
+#include "mtl_types.h"
+
+#include <inttypes.h>
+
+struct kk_image_layout;
+
+/* Utils */
+uint64_t mtl_buffer_get_length(mtl_buffer *buffer);
+uint64_t mtl_buffer_get_gpu_address(mtl_buffer *buffer);
+/* Gets CPU address */
+void *mtl_get_contents(mtl_buffer *buffer);
+
+/* Allocation from buffer */
+mtl_texture *mtl_new_texture_with_descriptor_linear(
+   mtl_buffer *buffer, const struct kk_image_layout *layout, uint64_t offset);
+
+#endif /* MTL_BUFFER_H */
\ No newline at end of file
diff --git a/src/kosmickrisp/bridge/mtl_buffer.m b/src/kosmickrisp/bridge/mtl_buffer.m
new file mode 100644
index 00000000000..dedb309e7fd
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_buffer.m
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_buffer.h"
+
+/* TODO_KOSMICKRISP Remove */
+#include "kk_image_layout.h"
+
+#include <Metal/MTLBuffer.h>
+#include <Metal/MTLTexture.h>
+
+uint64_t
+mtl_buffer_get_length(mtl_buffer *buffer)
+{
+   @autoreleasepool {
+      id<MTLBuffer> buf = (id<MTLBuffer>)buffer;
+      return buf.length;
+   }
+}
+
+uint64_t
+mtl_buffer_get_gpu_address(mtl_buffer *buffer)
+{
+   @autoreleasepool {
+      id<MTLBuffer> buf = (id<MTLBuffer>)buffer;
+      return [buf gpuAddress];
+   }
+}
+
+void *
+mtl_get_contents(mtl_buffer *buffer)
+{
+   @autoreleasepool {
+      id<MTLBuffer> buf = (id<MTLBuffer>)buffer;
+      return [buf contents];
+   }
+}
+
+/* TODO_KOSMICKRISP This is a duplicate, but both should be removed once we move kk_image_layout to the bridge. */
+static MTLTextureDescriptor *
+mtl_new_texture_descriptor(const struct kk_image_layout *layout)
+{
+   @autoreleasepool {
+      MTLTextureDescriptor *descriptor = [MTLTextureDescriptor new];
+      descriptor.textureType = (MTLTextureType)layout->type;
+      descriptor.pixelFormat = layout->format.mtl;
+      descriptor.width = layout->width_px;
+      descriptor.height = layout->height_px;
+      descriptor.depth = layout->depth_px;
+      descriptor.mipmapLevelCount = layout->levels;
+      descriptor.sampleCount = layout->sample_count_sa;
+      descriptor.arrayLength = layout->layers;
+      descriptor.allowGPUOptimizedContents = layout->optimized_layout;
+      descriptor.usage = (MTLTextureUsage)layout->usage;
+      /* We don't set the swizzle because Metal complains when the usage has store or render target with swizzle... */
+      
+      return descriptor;
+   }
+}
+
+mtl_texture *
+mtl_new_texture_with_descriptor_linear(mtl_buffer *buffer,
+                                       const struct kk_image_layout *layout,
+                                       uint64_t offset)
+{
+   @autoreleasepool {
+      id<MTLBuffer> buf = (id<MTLBuffer>)buffer;
+      MTLTextureDescriptor *descriptor = [mtl_new_texture_descriptor(layout) autorelease];
+      descriptor.resourceOptions = buf.resourceOptions;
+      id<MTLTexture> texture = [buf newTextureWithDescriptor:descriptor offset:offset bytesPerRow:layout->linear_stride_B];
+
+      return texture;
+   }
+}
+
diff --git a/src/kosmickrisp/bridge/mtl_command_buffer.h b/src/kosmickrisp/bridge/mtl_command_buffer.h
new file mode 100644
index 00000000000..6567c0a278e
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_command_buffer.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef MTL_COMMAND_BUFFER_H
+#define MTL_COMMAND_BUFFER_H 1
+
+#include "mtl_types.h"
+
+#include <stdint.h>
+
+void mtl_encode_signal_event(mtl_command_buffer *cmd_buf_handle,
+                             mtl_event *event_handle, uint64_t value);
+
+void mtl_encode_wait_for_event(mtl_command_buffer *cmd_buf_handle,
+                               mtl_event *event_handle, uint64_t value);
+
+void mtl_add_completed_handler(mtl_command_buffer *cmd,
+                               void (*callback)(void *data), void *data);
+
+void mtl_command_buffer_commit(mtl_command_buffer *cmd_buf);
+
+void mtl_present_drawable(mtl_command_buffer *cmd_buf, void *drawable);
+
+#endif /* MTL_COMMAND_BUFFER_H */
diff --git a/src/kosmickrisp/bridge/mtl_command_buffer.m b/src/kosmickrisp/bridge/mtl_command_buffer.m
new file mode 100644
index 00000000000..3086bd293c2
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_command_buffer.m
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_command_buffer.h"
+
+#include <Metal/MTLCommandBuffer.h>
+#include <QuartzCore/CAMetalLayer.h>
+
+void
+mtl_encode_signal_event(mtl_command_buffer *cmd_buf_handle,
+                        mtl_event *event_handle, uint64_t value)
+{
+   @autoreleasepool {
+      id<MTLCommandBuffer> cmd_buf = (id<MTLCommandBuffer>)cmd_buf_handle;
+      id<MTLEvent> event = (id<MTLEvent>)event_handle;
+      [cmd_buf encodeSignalEvent:event value:value];
+   }
+}
+
+void
+mtl_encode_wait_for_event(mtl_command_buffer *cmd_buf_handle,
+                          mtl_event *event_handle, uint64_t value)
+{
+   @autoreleasepool {
+      id<MTLCommandBuffer> cmd_buf = (id<MTLCommandBuffer>)cmd_buf_handle;
+      id<MTLEvent> event = (id<MTLEvent>)event_handle;
+      [cmd_buf encodeWaitForEvent:event value:value];
+   }
+}
+
+void
+mtl_add_completed_handler(mtl_command_buffer *cmd, void (*callback)(void *data),
+                          void *data)
+{
+   @autoreleasepool {
+      id<MTLCommandBuffer> mtl_cmd = (id<MTLCommandBuffer>)cmd;
+      [mtl_cmd addCompletedHandler:^(id<MTLCommandBuffer> _Nonnull cmd_buf) {
+         if (callback)
+            callback(data);
+      }];
+   }
+}
+
+void
+mtl_command_buffer_commit(mtl_command_buffer *cmd_buffer)
+{
+   @autoreleasepool {
+      id<MTLCommandBuffer> cmd_buf = (id<MTLCommandBuffer>)cmd_buffer;
+      [cmd_buf commit];
+   }
+}
+
+void
+mtl_present_drawable(mtl_command_buffer *cmd_buf, void *drawable_ptr)
+{
+   @autoreleasepool {
+      id<MTLCommandBuffer> cmd = (id<MTLCommandBuffer>)cmd_buf;
+      id<CAMetalDrawable> drawable = [(id<CAMetalDrawable>)drawable_ptr autorelease];
+      [cmd presentDrawable:drawable];
+   }
+}
diff --git a/src/kosmickrisp/bridge/mtl_command_queue.h b/src/kosmickrisp/bridge/mtl_command_queue.h
new file mode 100644
index 00000000000..8cc0149d3a6
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_command_queue.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef MTL_COMMAND_QUEUE_H
+#define MTL_COMMAND_QUEUE_H 1
+
+#include "mtl_types.h"
+
+#include <stdint.h>
+
+mtl_command_queue *mtl_new_command_queue(mtl_device *device,
+                                         uint32_t cmd_buffer_count);
+
+mtl_command_buffer *mtl_new_command_buffer(mtl_command_queue *cmd_queue);
+
+#endif /* MTL_COMMAND_QUEUE_H */
\ No newline at end of file
diff --git a/src/kosmickrisp/bridge/mtl_command_queue.m b/src/kosmickrisp/bridge/mtl_command_queue.m
new file mode 100644
index 00000000000..7f36cc69d9c
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_command_queue.m
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_command_queue.h"
+
+#include <Metal/MTLDevice.h>
+#include <Metal/MTLCommandQueue.h>
+
+mtl_command_queue *
+mtl_new_command_queue(mtl_device *device, uint32_t cmd_buffer_count)
+{
+   @autoreleasepool {
+      id<MTLDevice> dev = (id<MTLDevice>)device;
+      return [dev newCommandQueueWithMaxCommandBufferCount:cmd_buffer_count];
+   }
+}
+
+mtl_command_buffer *
+mtl_new_command_buffer(mtl_command_queue *cmd_queue)
+{
+   @autoreleasepool {
+      id<MTLCommandQueue> queue = (id<MTLCommandQueue>)cmd_queue;
+      return [[queue commandBuffer] retain];
+   }
+}
diff --git a/src/kosmickrisp/bridge/mtl_compute_state.h b/src/kosmickrisp/bridge/mtl_compute_state.h
new file mode 100644
index 00000000000..f47a9e7e9c5
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_compute_state.h
@@ -0,0 +1,13 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_types.h"
+
+#include <stdint.h>
+
+mtl_compute_pipeline_state *
+mtl_new_compute_pipeline_state(mtl_device *device, mtl_function *function,
+                               uint64_t max_total_threads_per_threadgroup);
\ No newline at end of file
diff --git a/src/kosmickrisp/bridge/mtl_compute_state.m b/src/kosmickrisp/bridge/mtl_compute_state.m
new file mode 100644
index 00000000000..f6ebce751b5
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_compute_state.m
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_compute_state.h"
+
+#include <Metal/MTLComputePipeline.h>
+
+mtl_compute_pipeline_state *
+mtl_new_compute_pipeline_state(mtl_device *device, mtl_function *function,
+                               uint64_t max_total_threads_per_threadgroup)
+{
+   @autoreleasepool {
+      id<MTLDevice> dev = (id<MTLDevice>)device;
+      id<MTLComputePipelineState> pipeline = NULL;
+      
+      MTLComputePipelineDescriptor *comp_desc = [[[MTLComputePipelineDescriptor alloc] init] autorelease];
+      NSError *error;
+      comp_desc.computeFunction = (id<MTLFunction>)function;
+      comp_desc.maxTotalThreadsPerThreadgroup = max_total_threads_per_threadgroup;
+      pipeline = [dev newComputePipelineStateWithDescriptor:comp_desc options:0 reflection:nil error:&error];
+
+      /* TODO_KOSMICKRISP Error checking */
+
+      return pipeline;
+   }
+}
diff --git a/src/kosmickrisp/bridge/mtl_device.h b/src/kosmickrisp/bridge/mtl_device.h
new file mode 100644
index 00000000000..30ee1b0967e
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_device.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef MTL_DEVICE_H
+#define MTL_DEVICE_H 1
+
+#include "mtl_types.h"
+
+#include <stdint.h>
+
+/* TODO_KOSMICKRISP Remove */
+struct kk_image_layout;
+
+/* Device creation */
+mtl_device *mtl_device_create(void);
+
+/* Device operations */
+void mtl_start_gpu_capture(mtl_device *mtl_dev_handle);
+void mtl_stop_gpu_capture(void);
+
+/* Device feature query */
+void mtl_device_get_name(mtl_device *dev, char buffer[256]);
+void mtl_device_get_architecture_name(mtl_device *dev, char buffer[256]);
+uint64_t mtl_device_get_peer_group_id(mtl_device *dev);
+uint32_t mtl_device_get_peer_index(mtl_device *dev);
+uint64_t mtl_device_get_registry_id(mtl_device *dev);
+struct mtl_size mtl_device_max_threads_per_threadgroup(mtl_device *dev);
+
+/* Resource queries */
+void mtl_heap_buffer_size_and_align_with_length(mtl_device *device,
+                                                uint64_t *size_B,
+                                                uint64_t *align_B);
+void
+mtl_heap_texture_size_and_align_with_descriptor(mtl_device *device,
+                                                struct kk_image_layout *layout);
+
+#endif /* MTL_DEVICE_H */
\ No newline at end of file
diff --git a/src/kosmickrisp/bridge/mtl_device.m b/src/kosmickrisp/bridge/mtl_device.m
new file mode 100644
index 00000000000..aab0e735ff6
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_device.m
@@ -0,0 +1,197 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_device.h"
+
+/* TODO_KOSMICKRISP Remove */
+#include "kk_image_layout.h"
+#include "kk_private.h"
+
+#include <Metal/MTLDevice.h>
+#include <Metal/MTLCaptureManager.h>
+
+/* Device creation */
+mtl_device *
+mtl_device_create()
+{
+   mtl_device *device = 0u;
+
+   @autoreleasepool {
+      NSArray<id<MTLDevice>> *devs = MTLCopyAllDevices();
+      uint32_t device_count = [devs count];
+      
+      for (uint32_t i = 0u; i < device_count; ++i) {
+         if (@available(macOS 10.15, *)) {
+            if (!device && [devs[i] supportsFamily:MTLGPUFamilyMetal3]) {
+               device = (mtl_device *)[devs[i] retain];
+            }
+            [devs[i] autorelease];
+         }
+      }
+      
+      return device;
+   }
+}
+
+/* Device operations */
+void
+mtl_start_gpu_capture(mtl_device *mtl_dev_handle)
+{
+   @autoreleasepool {
+      id<MTLDevice> mtl_dev = (id<MTLDevice>)mtl_dev_handle;
+      MTLCaptureManager *captureMgr = [MTLCaptureManager sharedCaptureManager];
+
+      // Before macOS 10.15 and iOS 13.0, captureDesc will just be nil
+      MTLCaptureDescriptor *captureDesc = [[MTLCaptureDescriptor new] autorelease];
+      captureDesc.captureObject = mtl_dev;
+      captureDesc.destination = MTLCaptureDestinationDeveloperTools;
+
+      // TODO_KOSMICKRISP Support dumping a trace to a file?
+      // NSString *tmp_dir = NSTemporaryDirectory();
+      // NSString *pname = [[NSProcessInfo processInfo] processName];
+      // NSString *capture_path = [NSString stringWithFormat:@"%@/%@.gputrace", tmp_dir, pname];
+      // if ([captureMgr supportsDestination: MTLCaptureDestinationGPUTraceDocument] ) {
+      //   captureDesc.destination = MTLCaptureDestinationGPUTraceDocument;
+      //   captureDesc.outputURL = [NSURL fileURLWithPath: capture_path];
+      //}
+
+      NSError *err = nil;
+      if (![captureMgr startCaptureWithDescriptor:captureDesc error:&err]) {
+         // fprintf(stderr, "Failed to automatically start GPU capture session (Error code %li) using startCaptureWithDescriptor: %s\n",
+         //         (long)err.code, err.localizedDescription.UTF8String);
+         // fprintf(stderr, "Using startCaptureWithDevice\n");
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+         [captureMgr startCaptureWithDevice:mtl_dev];
+#pragma clang diagnostic pop
+      }
+
+      //[tmp_dir release];
+      //[pname release];
+      //[capture_path release];
+   }
+}
+
+void
+mtl_stop_gpu_capture()
+{
+   @autoreleasepool {
+      [[MTLCaptureManager sharedCaptureManager] stopCapture];
+   }
+}
+
+/* Device feature query */
+void
+mtl_device_get_name(mtl_device *dev, char buffer[256])
+{
+   @autoreleasepool {
+      id<MTLDevice> device = (id<MTLDevice>)dev;
+      [device.name getCString:buffer maxLength:(sizeof(char) * 256) encoding:NSUTF8StringEncoding];
+   }
+}
+
+void
+mtl_device_get_architecture_name(mtl_device *dev, char buffer[256])
+{
+   @autoreleasepool {
+      id<MTLDevice> device = (id<MTLDevice>)dev;
+      [device.architecture.name getCString:buffer maxLength:(sizeof(char) * 256) encoding:NSUTF8StringEncoding];
+   }
+}
+
+uint64_t
+mtl_device_get_peer_group_id(mtl_device *dev)
+{
+   @autoreleasepool {
+      id<MTLDevice> device = (id<MTLDevice>)dev;
+      return device.peerGroupID;
+   }
+}
+
+uint32_t
+mtl_device_get_peer_index(mtl_device *dev)
+{
+   @autoreleasepool {
+      id<MTLDevice> device = (id<MTLDevice>)dev;
+      return device.peerIndex;
+   }
+}
+
+uint64_t
+mtl_device_get_registry_id(mtl_device *dev)
+{
+   @autoreleasepool {
+      id<MTLDevice> device = (id<MTLDevice>)dev;
+      return device.registryID;
+   }
+}
+
+struct mtl_size
+mtl_device_max_threads_per_threadgroup(mtl_device *dev)
+{
+   @autoreleasepool {
+      id<MTLDevice> device = (id<MTLDevice>)dev;
+      return (struct mtl_size){.x = device.maxThreadsPerThreadgroup.width,
+                               .y = device.maxThreadsPerThreadgroup.height,
+                               .z = device.maxThreadsPerThreadgroup.depth};
+   }
+}
+
+/* Resource queries */
+/* TODO_KOSMICKRISP Return a struct */
+void
+mtl_heap_buffer_size_and_align_with_length(mtl_device *device, uint64_t *size_B,
+                                           uint64_t *align_B)
+{
+   @autoreleasepool {
+      id<MTLDevice> dev = (id<MTLDevice>)device;
+      MTLSizeAndAlign size_align = [dev heapBufferSizeAndAlignWithLength:*size_B options:KK_MTL_RESOURCE_OPTIONS];
+      *size_B = size_align.size;
+      *align_B = size_align.align;
+   }
+}
+
+/* TODO_KOSMICKRISP Remove */
+static MTLTextureDescriptor *
+mtl_new_texture_descriptor(const struct kk_image_layout *layout)
+{
+   @autoreleasepool {
+      MTLTextureDescriptor *descriptor = [MTLTextureDescriptor new];
+      descriptor.textureType = (MTLTextureType)layout->type;
+      descriptor.pixelFormat = layout->format.mtl;
+      descriptor.width = layout->width_px;
+      descriptor.height = layout->height_px;
+      descriptor.depth = layout->depth_px;
+      descriptor.mipmapLevelCount = layout->levels;
+      descriptor.sampleCount = layout->sample_count_sa;
+      descriptor.arrayLength = layout->layers;
+      descriptor.allowGPUOptimizedContents = layout->optimized_layout;
+      descriptor.usage = (MTLTextureUsage)layout->usage;
+      /* We don't set the swizzle because Metal complains when the usage has store or render target with swizzle... */
+      
+      return descriptor;
+   }
+}
+
+void
+mtl_heap_texture_size_and_align_with_descriptor(mtl_device *device,
+                                                struct kk_image_layout *layout)
+{
+   @autoreleasepool {
+      id<MTLDevice> dev = (id<MTLDevice>)device;
+      if (layout->optimized_layout) {
+         MTLTextureDescriptor *descriptor = [mtl_new_texture_descriptor(layout) autorelease];
+         descriptor.resourceOptions = KK_MTL_RESOURCE_OPTIONS;
+         MTLSizeAndAlign size_align = [dev heapTextureSizeAndAlignWithDescriptor:descriptor];
+         layout->size_B = size_align.size;
+         layout->align_B = size_align.align;
+      } else {
+         /* Linear textures have different alignment since they are allocated on top of MTLBuffers */
+         layout->align_B = [dev minimumLinearTextureAlignmentForPixelFormat:layout->format.mtl];
+      }
+   }
+}
diff --git a/src/kosmickrisp/bridge/mtl_encoder.h b/src/kosmickrisp/bridge/mtl_encoder.h
new file mode 100644
index 00000000000..bfd582d571e
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_encoder.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef MTL_ENCODER_H
+#define MTL_ENCODER_H 1
+
+#include "mtl_types.h"
+
+#include <stdint.h>
+
+/* Common encoder utils */
+void mtl_end_encoding(void *encoder);
+
+/* MTLBlitEncoder */
+mtl_blit_encoder *mtl_new_blit_command_encoder(mtl_command_buffer *cmd_buffer);
+
+void mtl_blit_update_fence(mtl_blit_encoder *encoder, mtl_fence *fence);
+void mtl_blit_wait_for_fence(mtl_blit_encoder *encoder, mtl_fence *fence);
+
+void mtl_copy_from_buffer_to_buffer(mtl_blit_encoder *blit_enc_handle,
+                                    mtl_buffer *src_buf, size_t src_offset,
+                                    mtl_buffer *dst_buf, size_t dst_offset,
+                                    size_t size);
+
+void mtl_copy_from_buffer_to_texture(mtl_blit_encoder *blit_enc_handle,
+                                     struct mtl_buffer_image_copy *data);
+
+void mtl_copy_from_texture_to_buffer(mtl_blit_encoder *blit_enc_handle,
+                                     struct mtl_buffer_image_copy *data);
+
+void mtl_copy_from_texture_to_texture(
+   mtl_blit_encoder *blit_enc_handle, mtl_texture *src_tex_handle,
+   size_t src_slice, size_t src_level, struct mtl_origin src_origin,
+   struct mtl_size src_size, mtl_texture *dst_tex_handle, size_t dst_slice,
+   size_t dst_level, struct mtl_origin dst_origin);
+
+/* MTLComputeEncoder */
+mtl_compute_encoder *
+mtl_new_compute_command_encoder(mtl_command_buffer *cmd_buffer);
+
+void mtl_compute_update_fence(mtl_compute_encoder *encoder, mtl_fence *fence);
+void mtl_compute_wait_for_fence(mtl_compute_encoder *encoder, mtl_fence *fence);
+
+void mtl_compute_set_pipeline_state(mtl_compute_encoder *encoder,
+                                    mtl_compute_pipeline_state *state_handle);
+
+void mtl_compute_set_buffer(mtl_compute_encoder *encoder, mtl_buffer *buffer,
+                            size_t offset, size_t index);
+
+void mtl_compute_use_resource(mtl_compute_encoder *encoder,
+                              mtl_resource *res_handle, uint32_t usage);
+
+void mtl_compute_use_resources(mtl_compute_encoder *encoder,
+                               mtl_resource **resource_handles, uint32_t count,
+                               enum mtl_resource_usage usage);
+
+void mtl_compute_use_heaps(mtl_compute_encoder *encoder, mtl_heap **heaps,
+                           uint32_t count);
+
+void mtl_dispatch_threads(mtl_compute_encoder *encoder,
+                          struct mtl_size grid_size,
+                          struct mtl_size local_size);
+
+void mtl_dispatch_threadgroups_with_indirect_buffer(
+   mtl_compute_encoder *encoder, mtl_buffer *buffer, uint32_t offset,
+   struct mtl_size local_size);
+
+/* MTLRenderEncoder */
+mtl_render_encoder *mtl_new_render_command_encoder_with_descriptor(
+   mtl_command_buffer *command_buffer, mtl_render_pass_descriptor *descriptor);
+
+void mtl_render_update_fence(mtl_render_encoder *encoder, mtl_fence *fence);
+void mtl_render_wait_for_fence(mtl_render_encoder *encoder, mtl_fence *fence);
+
+void mtl_set_viewports(mtl_render_encoder *encoder,
+                       struct mtl_viewport *viewports, uint32_t count);
+
+void mtl_set_scissor_rects(mtl_render_encoder *encoder,
+                           struct mtl_scissor_rect *scissor_rects,
+                           uint32_t count);
+
+void mtl_render_set_pipeline_state(mtl_render_encoder *encoder,
+                                   mtl_render_pipeline_state *pipeline);
+
+void mtl_set_depth_stencil_state(mtl_render_encoder *encoder,
+                                 mtl_depth_stencil_state *state);
+
+void mtl_set_stencil_references(mtl_render_encoder *encoder, uint32_t front,
+                                uint32_t back);
+
+void mtl_set_front_face_winding(mtl_render_encoder *encoder,
+                                enum mtl_winding winding);
+
+void mtl_set_cull_mode(mtl_render_encoder *encoder, enum mtl_cull_mode mode);
+
+void mtl_set_visibility_result_mode(mtl_render_encoder *encoder,
+                                    enum mtl_visibility_result_mode mode,
+                                    size_t offset);
+
+void mtl_set_depth_bias(mtl_render_encoder *encoder, float depth_bias,
+                        float slope_scale, float clamp);
+
+void mtl_set_depth_clip_mode(mtl_render_encoder *encoder,
+                             enum mtl_depth_clip_mode mode);
+
+void mtl_set_vertex_amplification_count(mtl_render_encoder *encoder,
+                                        uint32_t *layer_ids, uint32_t id_count);
+
+void mtl_set_vertex_buffer(mtl_render_encoder *encoder, mtl_buffer *buffer,
+                           uint32_t offset, uint32_t index);
+
+void mtl_set_fragment_buffer(mtl_render_encoder *encoder, mtl_buffer *buffer,
+                             uint32_t offset, uint32_t index);
+
+void mtl_draw_primitives(mtl_render_encoder *encoder,
+                         enum mtl_primitive_type primitve_type,
+                         uint32_t vertexStart, uint32_t vertexCount,
+                         uint32_t instanceCount, uint32_t baseInstance);
+
+void mtl_draw_indexed_primitives(
+   mtl_render_encoder *encoder, enum mtl_primitive_type primitve_type,
+   uint32_t index_count, enum mtl_index_type index_type,
+   mtl_buffer *index_buffer, uint32_t index_buffer_offset,
+   uint32_t instance_count, int32_t base_vertex, uint32_t base_instance);
+
+void mtl_draw_primitives_indirect(mtl_render_encoder *encoder,
+                                  enum mtl_primitive_type primitve_type,
+                                  mtl_buffer *indirect_buffer,
+                                  uint64_t indirect_buffer_offset);
+
+void mtl_draw_indexed_primitives_indirect(mtl_render_encoder *encoder,
+                                          enum mtl_primitive_type primitve_type,
+                                          enum mtl_index_type index_type,
+                                          mtl_buffer *index_buffer,
+                                          uint32_t index_buffer_offset,
+                                          mtl_buffer *indirect_buffer,
+                                          uint64_t indirect_buffer_offset);
+
+void mtl_render_use_resource(mtl_compute_encoder *encoder,
+                             mtl_resource *res_handle, uint32_t usage);
+
+void mtl_render_use_resources(mtl_render_encoder *encoder,
+                              mtl_resource **resource_handles, uint32_t count,
+                              enum mtl_resource_usage usage);
+
+void mtl_render_use_heaps(mtl_render_encoder *encoder, mtl_heap **heaps,
+                          uint32_t count);
+
+#endif /* MTL_ENCODER_H */
diff --git a/src/kosmickrisp/bridge/mtl_encoder.m b/src/kosmickrisp/bridge/mtl_encoder.m
new file mode 100644
index 00000000000..8385ea8ac0b
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_encoder.m
@@ -0,0 +1,537 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_encoder.h"
+
+#include <Metal/MTLBlitCommandEncoder.h>
+#include <Metal/MTLComputeCommandEncoder.h>
+#include <Metal/MTLRenderCommandEncoder.h>
+
+/* Common encoder utils */
+void
+mtl_end_encoding(void *encoder)
+{
+   @autoreleasepool {
+      id<MTLCommandEncoder> enc = (id<MTLComputeCommandEncoder>)encoder;
+      [enc endEncoding];
+   }
+}
+
+/* MTLBlitEncoder */
+mtl_blit_encoder *
+mtl_new_blit_command_encoder(mtl_command_buffer *cmd_buffer)
+{
+   @autoreleasepool {
+      id<MTLCommandBuffer> cmd_buf = (id<MTLCommandBuffer>)cmd_buffer;
+      return [[cmd_buf blitCommandEncoder] retain];
+   }
+}
+
+void
+mtl_blit_update_fence(mtl_blit_encoder *encoder,
+                      mtl_fence *fence)
+{
+   @autoreleasepool {
+      id<MTLBlitCommandEncoder> enc = (id<MTLBlitCommandEncoder>)encoder;
+      id<MTLFence> f = (id<MTLFence>)fence;
+      [enc updateFence:f];
+   }
+}
+
+void
+mtl_blit_wait_for_fence(mtl_blit_encoder *encoder,
+                            mtl_fence *fence)
+{
+   @autoreleasepool {
+      id<MTLBlitCommandEncoder> enc = (id<MTLBlitCommandEncoder>)encoder;
+      id<MTLFence> f = (id<MTLFence>)fence;
+      [enc waitForFence:f];
+   }
+}
+
+void
+mtl_copy_from_buffer_to_buffer(mtl_blit_encoder *blit_enc_handle,
+                               mtl_buffer *src_buf, size_t src_offset,
+                               mtl_buffer *dst_buf, size_t dst_offset,
+                               size_t size)
+{
+   @autoreleasepool {
+      id<MTLBlitCommandEncoder> blit = (id<MTLBlitCommandEncoder>)blit_enc_handle;
+      id<MTLBuffer> mtl_src_buffer = (id<MTLBuffer>)src_buf;
+      id<MTLBuffer> mtl_dst_buffer = (id<MTLBuffer>)dst_buf;
+      [blit copyFromBuffer:mtl_src_buffer sourceOffset:src_offset toBuffer:mtl_dst_buffer destinationOffset:dst_offset size:size];
+   }
+}
+
+void
+mtl_copy_from_buffer_to_texture(mtl_blit_encoder *blit_enc_handle,
+                                struct mtl_buffer_image_copy *data)
+{
+   @autoreleasepool {
+      const MTLSize size = MTLSizeMake(data->image_size.x, data->image_size.y, data->image_size.z);
+      const MTLOrigin origin = MTLOriginMake(data->image_origin.x, data->image_origin.y, data->image_origin.z);
+      id<MTLBlitCommandEncoder> blit = (id<MTLBlitCommandEncoder>)blit_enc_handle;
+      id<MTLBuffer> buffer = (id<MTLBuffer>)data->buffer;
+      id<MTLTexture> image = (id<MTLTexture>)data->image;
+      [blit copyFromBuffer:buffer
+              sourceOffset:data->buffer_offset_B
+         sourceBytesPerRow:data->buffer_stride_B
+       sourceBytesPerImage:data->buffer_2d_image_size_B
+                sourceSize:size
+                 toTexture:image
+          destinationSlice:data->image_slice
+          destinationLevel:data->image_level
+         destinationOrigin:origin
+                   options:(MTLBlitOption)data->options];
+   }
+}
+
+void
+mtl_copy_from_texture_to_buffer(mtl_blit_encoder *blit_enc_handle,
+                                struct mtl_buffer_image_copy *data)
+{
+   @autoreleasepool {
+      const MTLSize size = MTLSizeMake(data->image_size.x, data->image_size.y, data->image_size.z);
+      const MTLOrigin origin = MTLOriginMake(data->image_origin.x, data->image_origin.y, data->image_origin.z);
+      id<MTLBlitCommandEncoder> blit = (id<MTLBlitCommandEncoder>)blit_enc_handle;
+      id<MTLBuffer> buffer = (id<MTLBuffer>)data->buffer;
+      id<MTLTexture> image = (id<MTLTexture>)data->image;
+      [blit copyFromTexture:image
+                sourceSlice:data->image_slice
+                sourceLevel:data->image_level
+               sourceOrigin:origin
+                 sourceSize:size
+                   toBuffer:buffer
+          destinationOffset:data->buffer_offset_B
+     destinationBytesPerRow:data->buffer_stride_B
+   destinationBytesPerImage:data->buffer_2d_image_size_B
+                    options:(MTLBlitOption)data->options];
+   }
+}
+
+void
+mtl_copy_from_texture_to_texture(mtl_blit_encoder *blit_enc_handle,
+                                 mtl_texture *src_tex_handle, size_t src_slice,
+                                 size_t src_level, struct mtl_origin src_origin,
+                                 struct mtl_size src_size,
+                                 mtl_texture *dst_tex_handle, size_t dst_slice,
+                                 size_t dst_level, struct mtl_origin dst_origin)
+{
+   @autoreleasepool {
+      MTLOrigin mtl_src_origin = MTLOriginMake(src_origin.x, src_origin.y, src_origin.z);
+      MTLSize mtl_src_size = MTLSizeMake(src_size.x, src_size.y, src_size.z);
+      MTLOrigin mtl_dst_origin = MTLOriginMake(dst_origin.x, dst_origin.y, dst_origin.z);
+      id<MTLTexture> mtl_dst_tex = (id<MTLTexture>)dst_tex_handle;
+      id<MTLBlitCommandEncoder> blit = (id<MTLBlitCommandEncoder>)blit_enc_handle;
+      id<MTLTexture> mtl_src_tex = (id<MTLTexture>)src_tex_handle;
+      [blit copyFromTexture:mtl_src_tex
+                sourceSlice:src_slice
+                sourceLevel:src_level
+               sourceOrigin:mtl_src_origin
+                 sourceSize:mtl_src_size
+                  toTexture:mtl_dst_tex
+           destinationSlice:dst_slice
+           destinationLevel:dst_level
+          destinationOrigin:mtl_dst_origin];
+   }
+}
+
+/* MTLComputeEncoder */
+mtl_compute_encoder *
+mtl_new_compute_command_encoder(mtl_command_buffer *cmd_buffer)
+{
+   @autoreleasepool {
+      id<MTLCommandBuffer> cmd_buf = (id<MTLCommandBuffer>)cmd_buffer;
+      return [[cmd_buf computeCommandEncoder] retain];
+   }
+}
+
+void
+mtl_compute_update_fence(mtl_compute_encoder *encoder, mtl_fence *fence)
+{
+   @autoreleasepool {
+      id<MTLComputeCommandEncoder> enc = (id<MTLComputeCommandEncoder>)encoder;
+      id<MTLFence> f = (id<MTLFence>)fence;
+      [enc updateFence:f];
+   }
+}
+
+void
+mtl_compute_wait_for_fence(mtl_compute_encoder *encoder, mtl_fence *fence)
+{
+   @autoreleasepool {
+      id<MTLComputeCommandEncoder> enc = (id<MTLComputeCommandEncoder>)encoder;
+      id<MTLFence> f = (id<MTLFence>)fence;
+      [enc waitForFence:f];
+   }
+}
+
+void
+mtl_compute_set_pipeline_state(mtl_compute_encoder *encoder,
+                               mtl_compute_pipeline_state *state_handle)
+{
+   @autoreleasepool {
+      id<MTLComputeCommandEncoder> enc = (id<MTLComputeCommandEncoder>)encoder;
+      id<MTLComputePipelineState> state = (id<MTLComputePipelineState>)state_handle;
+      [enc setComputePipelineState:state];
+   }
+}
+
+void
+mtl_compute_set_buffer(mtl_compute_encoder *encoder,
+                       mtl_buffer *buffer, size_t offset, size_t index)
+{
+   @autoreleasepool {
+      id<MTLComputeCommandEncoder> enc = (id<MTLComputeCommandEncoder>)encoder;
+      id<MTLBuffer> buf = (id<MTLBuffer>)buffer;
+      [enc setBuffer:buf offset:offset atIndex:index];
+   }
+}
+
+void
+mtl_compute_use_resource(mtl_compute_encoder *encoder,
+                         mtl_resource *res_handle, uint32_t usage)
+{
+   @autoreleasepool {
+      id<MTLComputeCommandEncoder> enc = (id<MTLComputeCommandEncoder>)encoder;
+      id<MTLResource> res = (id<MTLResource>)res_handle;
+      [enc useResource:res usage:(MTLResourceUsage)usage];
+   }
+}
+
+void
+mtl_compute_use_resources(mtl_compute_encoder *encoder,
+                          mtl_resource **resource_handles, uint32_t count,
+                          enum mtl_resource_usage usage)
+{
+   @autoreleasepool {
+      id<MTLComputeCommandEncoder> enc = (id<MTLComputeCommandEncoder>)encoder;
+      id<MTLResource> *handles = (id<MTLResource>*)resource_handles;
+      [enc useResources:handles count:count usage:(MTLResourceUsage)usage];
+   }
+}
+
+void
+mtl_compute_use_heaps(mtl_compute_encoder *encoder, mtl_heap **heaps,
+                      uint32_t count)
+{
+   @autoreleasepool {
+      id<MTLComputeCommandEncoder> enc = (id<MTLComputeCommandEncoder>)encoder;
+      id<MTLHeap> *handles = (id<MTLHeap>*)heaps;
+      [enc useHeaps:handles count:count];
+   }
+}
+
+void
+mtl_dispatch_threads(mtl_compute_encoder *encoder,
+                     struct mtl_size grid_size, struct mtl_size local_size)
+{
+   @autoreleasepool {
+      id<MTLComputeCommandEncoder> enc = (id<MTLComputeCommandEncoder>)encoder;
+      MTLSize thread_count = MTLSizeMake(grid_size.x * local_size.x,
+                                         grid_size.y * local_size.y,
+                                         grid_size.z * local_size.z);
+      MTLSize threads_per_threadgroup = MTLSizeMake(local_size.x,
+                                                    local_size.y,
+                                                    local_size.z);
+
+      // TODO_KOSMICKRISP can we rely on nonuniform threadgroup size support?
+      [enc dispatchThreads:thread_count threadsPerThreadgroup:threads_per_threadgroup];
+   }
+}
+
+void
+mtl_dispatch_threadgroups_with_indirect_buffer(mtl_compute_encoder *encoder,
+                                               mtl_buffer *buffer,
+                                               uint32_t offset,
+                                               struct mtl_size local_size)
+{
+   @autoreleasepool {
+      id<MTLComputeCommandEncoder> enc = (id<MTLComputeCommandEncoder>)encoder;
+      id<MTLBuffer> buf = (id<MTLBuffer>)buffer;
+      MTLSize threads_per_threadgroup = MTLSizeMake(local_size.x,
+                                                    local_size.y,
+                                                    local_size.z);
+
+      [enc dispatchThreadgroupsWithIndirectBuffer:buf indirectBufferOffset:offset threadsPerThreadgroup:threads_per_threadgroup];
+   }
+}
+
+/* MTLRenderEncoder */
+
+/* Encoder commands */
+mtl_render_encoder *
+mtl_new_render_command_encoder_with_descriptor(
+   mtl_command_buffer *command_buffer, mtl_render_pass_descriptor *descriptor)
+{
+   @autoreleasepool {
+      id<MTLCommandBuffer> cmd = (id<MTLCommandBuffer>)command_buffer;
+      MTLRenderPassDescriptor *desc = (MTLRenderPassDescriptor *)descriptor;
+      return [[cmd renderCommandEncoderWithDescriptor:desc] retain];
+   }
+}
+
+void
+mtl_render_update_fence(mtl_render_encoder *encoder, mtl_fence *fence)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      id<MTLFence> f = (id<MTLFence>)fence;
+      [enc updateFence:f afterStages:MTLRenderStageFragment];
+   }
+}
+
+void
+mtl_render_wait_for_fence(mtl_render_encoder *encoder, mtl_fence *fence)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      id<MTLFence> f = (id<MTLFence>)fence;
+      [enc waitForFence:f beforeStages:MTLRenderStageVertex];
+   }
+}
+
+void
+mtl_set_viewports(mtl_render_encoder *encoder, struct mtl_viewport *viewports,
+                  uint32_t count)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      MTLViewport *vps = (MTLViewport *)viewports;
+      [enc setViewports:vps count:count];
+   }
+}
+
+void
+mtl_set_scissor_rects(mtl_render_encoder *encoder,
+                      struct mtl_scissor_rect *scissor_rects, uint32_t count)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      MTLScissorRect *rects = (MTLScissorRect *)scissor_rects;
+      [enc setScissorRects:rects count:count];
+   }
+}
+
+void
+mtl_render_set_pipeline_state(mtl_render_encoder *encoder,
+                              mtl_render_pipeline_state *pipeline)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      id<MTLRenderPipelineState> pipe = (id<MTLRenderPipelineState>)pipeline;
+      [enc setRenderPipelineState:pipe];
+   }
+}
+
+void
+mtl_set_depth_stencil_state(mtl_render_encoder *encoder,
+                            mtl_depth_stencil_state *state)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      id<MTLDepthStencilState> s = (id<MTLDepthStencilState>)state;
+      [enc setDepthStencilState:s];
+   }
+}
+
+void
+mtl_set_stencil_references(mtl_render_encoder *encoder, uint32_t front,
+                           uint32_t back)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      [enc setStencilFrontReferenceValue:front backReferenceValue:back];
+   }
+}
+
+void
+mtl_set_front_face_winding(mtl_render_encoder *encoder,
+                           enum mtl_winding winding)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      [enc setFrontFacingWinding:(MTLWinding)winding];
+   }
+}
+
+void
+mtl_set_cull_mode(mtl_render_encoder *encoder, enum mtl_cull_mode mode)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      [enc setCullMode:(MTLCullMode)mode];
+   }
+}
+
+void
+mtl_set_visibility_result_mode(mtl_render_encoder *encoder,
+                               enum mtl_visibility_result_mode mode,
+                               size_t offset)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      [enc setVisibilityResultMode:(MTLVisibilityResultMode)mode offset:offset];
+   }
+}
+
+void
+mtl_set_depth_bias(mtl_render_encoder *encoder, float depth_bias,
+                   float slope_scale, float clamp)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      [enc setDepthBias:depth_bias slopeScale:slope_scale clamp:clamp];
+   }
+}
+
+void
+mtl_set_depth_clip_mode(mtl_render_encoder *encoder,
+                        enum mtl_depth_clip_mode mode)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      [enc setDepthClipMode:(MTLDepthClipMode)mode];
+   }
+}
+
+void
+mtl_set_vertex_amplification_count(mtl_render_encoder *encoder,
+                                   uint32_t *layer_ids, uint32_t id_count)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      MTLVertexAmplificationViewMapping mappings[32];
+      for (uint32_t i = 0u; i < id_count; ++i) {
+         mappings[i].renderTargetArrayIndexOffset = layer_ids[i];
+         mappings[i].viewportArrayIndexOffset = 0u;
+      }
+      [enc setVertexAmplificationCount:id_count viewMappings:mappings];
+   }
+}
+
+void
+mtl_set_vertex_buffer(mtl_render_encoder *encoder, mtl_buffer *buffer,
+                      uint32_t offset, uint32_t index)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      id<MTLBuffer> buf = (id<MTLBuffer>)buffer;
+      [enc setVertexBuffer:buf offset:offset atIndex:index];
+   }
+}
+
+void
+mtl_set_fragment_buffer(mtl_render_encoder *encoder, mtl_buffer *buffer,
+                        uint32_t offset, uint32_t index)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      id<MTLBuffer> buf = (id<MTLBuffer>)buffer;
+      [enc setFragmentBuffer:buf offset:offset atIndex:index];
+   }
+}
+
+void
+mtl_draw_primitives(mtl_render_encoder *encoder,
+                    enum mtl_primitive_type primitve_type, uint32_t vertexStart,
+                    uint32_t vertexCount, uint32_t instanceCount,
+                    uint32_t baseInstance)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      MTLPrimitiveType type = (MTLPrimitiveType)primitve_type;
+      [enc drawPrimitives:type vertexStart:vertexStart vertexCount:vertexCount instanceCount:instanceCount baseInstance:baseInstance];
+   }
+}
+
+void
+mtl_draw_indexed_primitives(
+   mtl_render_encoder *encoder, enum mtl_primitive_type primitve_type,
+   uint32_t index_count, enum mtl_index_type index_type,
+   mtl_buffer *index_buffer, uint32_t index_buffer_offset,
+   uint32_t instance_count, int32_t base_vertex, uint32_t base_instance)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      id<MTLBuffer> buf = (id<MTLBuffer>)index_buffer;
+      MTLIndexType ndx_type = (MTLIndexType)index_type;
+      MTLPrimitiveType primitive = (MTLPrimitiveType)primitve_type;
+      [enc drawIndexedPrimitives:primitive indexCount:index_count indexType:ndx_type indexBuffer:buf indexBufferOffset:index_buffer_offset instanceCount:instance_count baseVertex:base_vertex baseInstance:base_instance];
+   }
+}
+
+void
+mtl_draw_primitives_indirect(mtl_render_encoder *encoder,
+                             enum mtl_primitive_type primitve_type,
+                             mtl_buffer *indirect_buffer,
+                             uint64_t indirect_buffer_offset)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      id<MTLBuffer> buf = (id<MTLBuffer>)indirect_buffer;
+      MTLPrimitiveType type = (MTLPrimitiveType)primitve_type;
+      [enc drawPrimitives:type indirectBuffer:buf indirectBufferOffset:indirect_buffer_offset];
+   }
+}
+
+void
+mtl_draw_indexed_primitives_indirect(mtl_render_encoder *encoder,
+                                     enum mtl_primitive_type primitve_type,
+                                     enum mtl_index_type index_type,
+                                     mtl_buffer *index_buffer,
+                                     uint32_t index_buffer_offset,
+                                     mtl_buffer *indirect_buffer,
+                                     uint64_t indirect_buffer_offset)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      id<MTLBuffer> buf = (id<MTLBuffer>)indirect_buffer;
+      id<MTLBuffer> ndx_buf = (id<MTLBuffer>)index_buffer;
+      MTLPrimitiveType type = (MTLPrimitiveType)primitve_type;
+      MTLIndexType ndx_type = (MTLIndexType)index_type;
+      [enc drawIndexedPrimitives:type indexType:ndx_type indexBuffer:ndx_buf indexBufferOffset:index_buffer_offset indirectBuffer:buf indirectBufferOffset:indirect_buffer_offset];
+   }
+}
+
+void
+mtl_render_use_resource(mtl_compute_encoder *encoder, mtl_resource *res_handle,
+                        uint32_t usage)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      id<MTLResource> res = (id<MTLResource>)res_handle;
+      [enc useResource:res usage:(MTLResourceUsage)usage stages:MTLRenderStageVertex|MTLRenderStageFragment];
+   }
+}
+
+void
+mtl_render_use_resources(mtl_render_encoder *encoder,
+                         mtl_resource **resource_handles, uint32_t count,
+                         enum mtl_resource_usage usage)
+{
+   @autoreleasepool {
+      // id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      id<MTLResource> *handles = (id<MTLResource>*)resource_handles;
+      for (uint32_t i = 0u; i < count; ++i) {
+         if (handles[i] != NULL)
+            mtl_render_use_resource(encoder, handles[i], usage);
+      }
+      /* TODO_KOSMICKRISP No null values in the array or Metal complains */
+      // [enc useResources:handles count:count usage:(MTLResourceUsage)usage];
+   }
+}
+
+void
+mtl_render_use_heaps(mtl_render_encoder *encoder, mtl_heap **heaps,
+                     uint32_t count)
+{
+   @autoreleasepool {
+      id<MTLRenderCommandEncoder> enc = (id<MTLRenderCommandEncoder>)encoder;
+      id<MTLHeap> *handles = (id<MTLHeap>*)heaps;
+      [enc useHeaps:handles count:count stages:MTLRenderStageVertex|MTLRenderStageFragment];
+   }
+}
diff --git a/src/kosmickrisp/bridge/mtl_format.h b/src/kosmickrisp/bridge/mtl_format.h
new file mode 100644
index 00000000000..5a2577c5a28
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_format.h
@@ -0,0 +1,205 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+#ifndef MTL_FORMAT_H
+#define MTL_FORMAT_H 1
+
+/* TODO_KOSMICKRISP Haven't modified all
+ * Slightly modified naming so they match to enum pipe_format for convenience
+ */
+enum mtl_pixel_format {
+   MTL_PIXEL_FORMAT_INVALID = 0,
+
+   /* Normal 8 bit formats */
+   MTL_PIXEL_FORMAT_A8_UNORM = 1,
+
+   MTL_PIXEL_FORMAT_R8_UNORM = 10,
+   MTL_PIXEL_FORMAT_R8_SRGB = 11,
+   MTL_PIXEL_FORMAT_R8_SNORM = 12,
+   MTL_PIXEL_FORMAT_R8_UINT = 13,
+   MTL_PIXEL_FORMAT_R8_SINT = 14,
+
+   /* Normal 16 bit formats */
+   MTL_PIXEL_FORMAT_R16_UNORM = 20,
+   MTL_PIXEL_FORMAT_R16_SNORM = 22,
+   MTL_PIXEL_FORMAT_R16_UINT = 23,
+   MTL_PIXEL_FORMAT_R16_SINT = 24,
+   MTL_PIXEL_FORMAT_R16_FLOAT = 25,
+
+   MTL_PIXEL_FORMAT_R8G8_UNORM = 30,
+   MTL_PIXEL_FORMAT_R8G8_SRGB = 31,
+   MTL_PIXEL_FORMAT_R8G8_SNORM = 32,
+   MTL_PIXEL_FORMAT_R8G8_UINT = 33,
+   MTL_PIXEL_FORMAT_R8G8_SINT = 34,
+
+   /* Packed 16 bit formats */
+   MTL_PIXEL_FORMAT_B5G6R5_UNORM = 40,
+   MTL_PIXEL_FORMAT_A1B5G5R5_UNORM = 41,
+   MTL_PIXEL_FORMAT_A4B4G4R4_UNORM = 42,
+   MTL_PIXEL_FORMAT_B5G5R5A1_UNORM = 43,
+
+   /* Normal 32 bit formats */
+   MTL_PIXEL_FORMAT_R32_UINT = 53,
+   MTL_PIXEL_FORMAT_R32_SINT = 54,
+   MTL_PIXEL_FORMAT_R32_FLOAT = 55,
+
+   MTL_PIXEL_FORMAT_R16G16_UNORM = 60,
+   MTL_PIXEL_FORMAT_R16G16_SNORM = 62,
+   MTL_PIXEL_FORMAT_R16G16_UINT = 63,
+   MTL_PIXEL_FORMAT_R16G16_SINT = 64,
+   MTL_PIXEL_FORMAT_R16G16_FLOAT = 65,
+
+   MTL_PIXEL_FORMAT_R8G8B8A8_UNORM = 70,
+   MTL_PIXEL_FORMAT_R8G8B8A8_SRGB = 71,
+   MTL_PIXEL_FORMAT_R8G8B8A8_SNORM = 72,
+   MTL_PIXEL_FORMAT_R8G8B8A8_UINT = 73,
+   MTL_PIXEL_FORMAT_R8G8B8A8_SINT = 74,
+
+   MTL_PIXEL_FORMAT_B8G8R8A8_UNORM = 80,
+   MTL_PIXEL_FORMAT_B8G8R8A8_SRGB = 81,
+
+   /* Packed 32 bit formats */
+   MTL_PIXEL_FORMAT_R10G10B10A2_UNORM = 90,
+   MTL_PIXEL_FORMAT_R10G10B10A2_UINT = 91,
+
+   MTL_PIXEL_FORMAT_R11G11B10_FLOAT = 92,
+   MTL_PIXEL_FORMAT_R9G9B9E5_FLOAT = 93,
+
+   MTL_PIXEL_FORMAT_B10G10R10A2_UNORM = 94,
+
+   MTL_PIXEL_FORMAT_BGR10_XR = 554,
+   MTL_PIXEL_FORMAT_BGR10_XR_SRGB = 555,
+
+   /* Normal 64 bit formats */
+   MTL_PIXEL_FORMAT_R32G32_UINT = 103,
+   MTL_PIXEL_FORMAT_R32G32_SINT = 104,
+   MTL_PIXEL_FORMAT_R32G32_FLOAT = 105,
+
+   MTL_PIXEL_FORMAT_R16G16B16A16_UNORM = 110,
+   MTL_PIXEL_FORMAT_R16G16B16A16_SNORM = 112,
+   MTL_PIXEL_FORMAT_R16G16B16A16_UINT = 113,
+   MTL_PIXEL_FORMAT_R16G16B16A16_SINT = 114,
+   MTL_PIXEL_FORMAT_R16G16B16A16_FLOAT = 115,
+
+   MTL_PIXEL_FORMAT_BGRA10_XR = 552,
+   MTL_PIXEL_FORMAT_BGRA10_XR_SRGB = 553,
+
+   /* Normal 128 bit formats */
+   MTL_PIXEL_FORMAT_R32G32B32A32_UINT = 123,
+   MTL_PIXEL_FORMAT_R32G32B32A32_SINT = 124,
+   MTL_PIXEL_FORMAT_R32G32B32A32_FLOAT = 125,
+
+   /* Compressed formats. */
+
+   /* S3TC/DXT */
+   MTL_PIXEL_FORMAT_BC1_RGBA = 130,
+   MTL_PIXEL_FORMAT_BC1_RGBA_SRGB = 131,
+   MTL_PIXEL_FORMAT_BC2_RGBA = 132,
+   MTL_PIXEL_FORMAT_BC2_RGBA_SRGB = 133,
+   MTL_PIXEL_FORMAT_BC3_RGBA = 134,
+   MTL_PIXEL_FORMAT_BC3_RGBA_SRGB = 135,
+
+   /* RGTC */
+   MTL_PIXEL_FORMAT_BC4_R_UNORM = 140,
+   MTL_PIXEL_FORMAT_BC4_R_SNORM = 141,
+   MTL_PIXEL_FORMAT_BC5_RG_UNORM = 142,
+   MTL_PIXEL_FORMAT_BC5_RG_SNORM = 143,
+
+   /* BPTC */
+   MTL_PIXEL_FORMAT_BC6H_RGB_FLOAT = 150,
+   MTL_PIXEL_FORMAT_BC6H_RGBU_FLOAT = 151,
+   MTL_PIXEL_FORMAT_BC7_RGBA_UNORM = 152,
+   MTL_PIXEL_FORMAT_BC7_RGBA_SRGB = 153,
+
+   /* PVRTC */
+   MTL_PIXEL_FORMAT_PVRTC_RGB_2BPP = 160,
+   MTL_PIXEL_FORMAT_PVRTC_RGB_2BPP_SRGB = 161,
+   MTL_PIXEL_FORMAT_PVRTC_RGB_4BPP = 162,
+   MTL_PIXEL_FORMAT_PVRTC_RGB_4BPP_SRGB = 163,
+   MTL_PIXEL_FORMAT_PVRTC_RGBA_2BPP = 164,
+   MTL_PIXEL_FORMAT_PVRTC_RGBA_2BPP_SRGB = 165,
+   MTL_PIXEL_FORMAT_PVRTC_RGBA_4BPP = 166,
+   MTL_PIXEL_FORMAT_PVRTC_RGBA_4BPP_SRGB = 167,
+
+   /* ETC2 */
+   MTL_PIXEL_FORMAT_ETC2_R11_UNORM = 170,
+   MTL_PIXEL_FORMAT_ETC2_R11_SNORM = 172,
+   MTL_PIXEL_FORMAT_ETC2_RG11_UNORM = 174,
+   MTL_PIXEL_FORMAT_ETC2_RG11_SNORM = 176,
+   MTL_PIXEL_FORMAT_ETC2_RGBA8 = 178,
+   MTL_PIXEL_FORMAT_ETC2_SRGBA8 = 179,
+
+   MTL_PIXEL_FORMAT_ETC2_RGB8 = 180,
+   MTL_PIXEL_FORMAT_ETC2_SRGB8 = 181,
+   MTL_PIXEL_FORMAT_ETC2_RGB8A1 = 182,
+   MTL_PIXEL_FORMAT_ETC2_SRGB8A1 = 183,
+
+   /* ASTC */
+   MTL_PIXEL_FORMAT_ASTC_4x4_SRGB = 186,
+   MTL_PIXEL_FORMAT_ASTC_5x4_SRGB = 187,
+   MTL_PIXEL_FORMAT_ASTC_5x5_SRGB = 188,
+   MTL_PIXEL_FORMAT_ASTC_6x5_SRGB = 189,
+   MTL_PIXEL_FORMAT_ASTC_6x6_SRGB = 190,
+   MTL_PIXEL_FORMAT_ASTC_8x5_SRGB = 192,
+   MTL_PIXEL_FORMAT_ASTC_8x6_SRGB = 193,
+   MTL_PIXEL_FORMAT_ASTC_8x8_SRGB = 194,
+   MTL_PIXEL_FORMAT_ASTC_10x5_SRGB = 195,
+   MTL_PIXEL_FORMAT_ASTC_10x6_SRGB = 196,
+   MTL_PIXEL_FORMAT_ASTC_10x8_SRGB = 197,
+   MTL_PIXEL_FORMAT_ASTC_10x10_SRGB = 198,
+   MTL_PIXEL_FORMAT_ASTC_12x10_SRGB = 199,
+   MTL_PIXEL_FORMAT_ASTC_12x12_SRGB = 200,
+
+   MTL_PIXEL_FORMAT_ASTC_4x4 = 204,
+   MTL_PIXEL_FORMAT_ASTC_5x4 = 205,
+   MTL_PIXEL_FORMAT_ASTC_5x5 = 206,
+   MTL_PIXEL_FORMAT_ASTC_6x5 = 207,
+   MTL_PIXEL_FORMAT_ASTC_6x6 = 208,
+   MTL_PIXEL_FORMAT_ASTC_8x5 = 210,
+   MTL_PIXEL_FORMAT_ASTC_8x6 = 211,
+   MTL_PIXEL_FORMAT_ASTC_8x8 = 212,
+   MTL_PIXEL_FORMAT_ASTC_10x5 = 213,
+   MTL_PIXEL_FORMAT_ASTC_10x6 = 214,
+   MTL_PIXEL_FORMAT_ASTC_10x8 = 215,
+   MTL_PIXEL_FORMAT_ASTC_10x10 = 216,
+   MTL_PIXEL_FORMAT_ASTC_12x10 = 217,
+   MTL_PIXEL_FORMAT_ASTC_12x12 = 218,
+
+   /* ASTC HDR (High Dynamic Range) */
+   MTL_PIXEL_FORMAT_ASTC_4x4_HDR = 222,
+   MTL_PIXEL_FORMAT_ASTC_5x4_HDR = 223,
+   MTL_PIXEL_FORMAT_ASTC_5x5_HDR = 224,
+   MTL_PIXEL_FORMAT_ASTC_6x5_HDR = 225,
+   MTL_PIXEL_FORMAT_ASTC_6x6_HDR = 226,
+   MTL_PIXEL_FORMAT_ASTC_8x5_HDR = 228,
+   MTL_PIXEL_FORMAT_ASTC_8x6_HDR = 229,
+   MTL_PIXEL_FORMAT_ASTC_8x8_HDR = 230,
+   MTL_PIXEL_FORMAT_ASTC_10x5_HDR = 231,
+   MTL_PIXEL_FORMAT_ASTC_10x6_HDR = 232,
+   MTL_PIXEL_FORMAT_ASTC_10x8_HDR = 233,
+   MTL_PIXEL_FORMAT_ASTC_10x10_HDR = 234,
+   MTL_PIXEL_FORMAT_ASTC_12x10_HDR = 235,
+   MTL_PIXEL_FORMAT_ASTC_12x12_HDR = 236,
+
+   /* YUV */
+   MTL_PIXEL_FORMAT_GBGR422 = 240,
+   MTL_PIXEL_FORMAT_BGRG422 = 241,
+
+   /* DEPTH */
+   MTL_PIXEL_FORMAT_Z16_UNORM = 250,
+   MTL_PIXEL_FORMAT_Z32_FLOAT = 252,
+
+   /* STENCIL */
+   MTL_PIXEL_FORMAT_S8_UINT = 253,
+
+   /* DEPTH STENCIL */
+   MTL_PIXEL_FORMAT_Z24_UNORM_S8_UINT = 255,
+   MTL_PIXEL_FORMAT_Z32_FLOAT_S8X24_UINT = 260,
+
+   MTL_PIXEL_FORMAT_X32_S8X24_UINT = 261,
+   MTL_PIXEL_FORMAT_X24_S8_UINT = 262,
+};
+
+#endif /* MTL_FORMAT_H */
diff --git a/src/kosmickrisp/bridge/mtl_heap.h b/src/kosmickrisp/bridge/mtl_heap.h
new file mode 100644
index 00000000000..fd34ac4ac5b
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_heap.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef MTL_HEAP_H
+#define MTL_HEAP_H 1
+
+#include "mtl_types.h"
+
+#include <inttypes.h>
+
+/* TODO_KOSMICKRISP We should move this struct to the bridge side. */
+struct kk_image_layout;
+
+/* Creation */
+mtl_heap *mtl_new_heap(mtl_device *device, uint64_t size,
+                       enum mtl_resource_options resource_options);
+
+/* Utils */
+uint64_t mtl_heap_get_size(mtl_heap *heap);
+
+/* Allocation from heap */
+mtl_buffer *mtl_new_buffer_with_length(mtl_heap *heap, uint64_t size_B,
+                                       uint64_t offset_B);
+mtl_texture *mtl_new_texture_with_descriptor(
+   mtl_heap *heap, const struct kk_image_layout *layout, uint64_t offset);
+
+#endif /* MTL_HEAP_H */
\ No newline at end of file
diff --git a/src/kosmickrisp/bridge/mtl_heap.m b/src/kosmickrisp/bridge/mtl_heap.m
new file mode 100644
index 00000000000..c658c0253ec
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_heap.m
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_heap.h"
+
+/* TODO_KOSMICKRISP Remove */
+#include "kk_private.h"
+#include "kk_image_layout.h"
+
+#include <Metal/MTLHeap.h>
+
+/* Creation */
+mtl_heap *
+mtl_new_heap(mtl_device *device, uint64_t size,
+             enum mtl_resource_options resource_options)
+{
+   @autoreleasepool {
+      id<MTLDevice> dev = (id<MTLDevice>)device;
+      MTLHeapDescriptor *descriptor = [[MTLHeapDescriptor new] autorelease];
+      descriptor.type = MTLHeapTypePlacement;
+      descriptor.resourceOptions = (MTLResourceOptions)resource_options;
+      descriptor.size = size;
+      descriptor.sparsePageSize = MTLSparsePageSize16;
+      return [dev newHeapWithDescriptor:descriptor];
+   }
+}
+
+/* Utils */
+uint64_t
+mtl_heap_get_size(mtl_heap *heap)
+{
+   @autoreleasepool {
+      id<MTLHeap> hp = (id<MTLHeap>)heap;
+      return hp.size;
+   }
+}
+
+static MTLTextureDescriptor *
+mtl_new_texture_descriptor(const struct kk_image_layout *layout)
+{
+   @autoreleasepool {
+      MTLTextureDescriptor *descriptor = [MTLTextureDescriptor new];
+      descriptor.textureType = (MTLTextureType)layout->type;
+      descriptor.pixelFormat = layout->format.mtl;
+      descriptor.width = layout->width_px;
+      descriptor.height = layout->height_px;
+      descriptor.depth = layout->depth_px;
+      descriptor.mipmapLevelCount = layout->levels;
+      descriptor.sampleCount = layout->sample_count_sa;
+      descriptor.arrayLength = layout->layers;
+      descriptor.allowGPUOptimizedContents = layout->optimized_layout;
+      descriptor.usage = (MTLTextureUsage)layout->usage;
+      /* We don't set the swizzle because Metal complains when the usage has store or render target with swizzle... */
+      
+      return descriptor;
+   }
+}
+
+/* Allocation from heap */
+mtl_buffer *
+mtl_new_buffer_with_length(mtl_heap *heap, uint64_t size_B, uint64_t offset_B)
+{
+   @autoreleasepool {
+      id<MTLHeap> hp = (id<MTLHeap>)heap;
+      return (mtl_buffer *)[hp newBufferWithLength:size_B options:KK_MTL_RESOURCE_OPTIONS offset:offset_B];
+   }
+}
+
+mtl_texture *
+mtl_new_texture_with_descriptor(mtl_heap *heap,
+                                const struct kk_image_layout *layout,
+                                uint64_t offset)
+{
+   @autoreleasepool {
+      id<MTLHeap> hp = (id<MTLHeap>)heap;
+      MTLTextureDescriptor *descriptor = [mtl_new_texture_descriptor(layout) autorelease];
+      descriptor.resourceOptions = hp.resourceOptions;
+      return [hp newTextureWithDescriptor:descriptor offset:offset];
+   }
+}
diff --git a/src/kosmickrisp/bridge/mtl_library.h b/src/kosmickrisp/bridge/mtl_library.h
new file mode 100644
index 00000000000..32bdd8a5529
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_library.h
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef MTL_LIBRARY_H
+#define MTL_LIBRARY_H 1
+
+#include "mtl_types.h"
+
+mtl_library *mtl_new_library(mtl_device *device, const char *src);
+mtl_function *mtl_new_function_with_name(mtl_library *lib,
+                                         const char *entry_point);
+
+#endif /* MTL_LIBRARY_H */
diff --git a/src/kosmickrisp/bridge/mtl_library.m b/src/kosmickrisp/bridge/mtl_library.m
new file mode 100644
index 00000000000..a40cea9619b
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_library.m
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_library.h"
+
+#include <Metal/MTLDevice.h>
+
+mtl_library *
+mtl_new_library(mtl_device *device, const char *src)
+{
+   @autoreleasepool {
+      id<MTLDevice> dev = (id<MTLDevice>)device;
+      id<MTLLibrary> lib = NULL;
+      NSString *nsstr = [NSString stringWithCString:src encoding:NSASCIIStringEncoding];
+      NSError *error;
+      MTLCompileOptions *comp_opts = [MTLCompileOptions new];
+      comp_opts.languageVersion = MTLLanguageVersion3_2;
+      comp_opts.mathMode = MTLMathModeSafe;
+      comp_opts.mathFloatingPointFunctions = MTLMathFloatingPointFunctionsPrecise;
+      lib = [dev newLibraryWithSource:nsstr options:comp_opts error:&error];
+
+      if (error != nil) {
+         fprintf(stderr, "Failed to create MTLLibrary: %s\n", [error.localizedDescription UTF8String]);
+      }
+
+      [comp_opts release];
+      return lib;
+   }
+}
+
+mtl_function *
+mtl_new_function_with_name(mtl_library *lib, const char *entry_point)
+{
+   @autoreleasepool {
+      id<MTLLibrary> mtl_lib = (id<MTLLibrary>)lib;
+      NSString *ns_entry_point = [NSString stringWithCString:entry_point encoding:NSASCIIStringEncoding];
+      return [mtl_lib newFunctionWithName:ns_entry_point];
+   }
+}
+
diff --git a/src/kosmickrisp/bridge/mtl_render_state.h b/src/kosmickrisp/bridge/mtl_render_state.h
new file mode 100644
index 00000000000..cf13b4678f8
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_render_state.h
@@ -0,0 +1,165 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef MTL_RENDER_STATE_H
+#define MTL_RENDER_STATE_H 1
+
+#include "mtl_types.h"
+
+#include <inttypes.h>
+#include <stdbool.h>
+
+/* Bridge enums */
+enum mtl_pixel_format;
+
+/* TODO_KOSMICKRISP Remove */
+enum VkCompareOp;
+enum VkStencilOp;
+
+/* Render pass descriptor */
+mtl_render_pass_descriptor *mtl_new_render_pass_descriptor(void);
+
+mtl_render_pass_attachment_descriptor *
+mtl_render_pass_descriptor_get_color_attachment(
+   mtl_render_pass_descriptor *descriptor, uint32_t index);
+
+mtl_render_pass_attachment_descriptor *
+mtl_render_pass_descriptor_get_depth_attachment(
+   mtl_render_pass_descriptor *descriptor);
+
+mtl_render_pass_attachment_descriptor *
+mtl_render_pass_descriptor_get_stencil_attachment(
+   mtl_render_pass_descriptor *descriptor);
+
+void mtl_render_pass_attachment_descriptor_set_texture(
+   mtl_render_pass_attachment_descriptor *descriptor, mtl_texture *texture);
+
+void mtl_render_pass_attachment_descriptor_set_level(
+   mtl_render_pass_attachment_descriptor *descriptor, uint32_t level);
+
+void mtl_render_pass_attachment_descriptor_set_slice(
+   mtl_render_pass_attachment_descriptor *descriptor, uint32_t slice);
+
+void mtl_render_pass_attachment_descriptor_set_load_action(
+   mtl_render_pass_attachment_descriptor *descriptor,
+   enum mtl_load_action action);
+
+void mtl_render_pass_attachment_descriptor_set_store_action(
+   mtl_render_pass_attachment_descriptor *descriptor,
+   enum mtl_store_action action);
+
+void mtl_render_pass_attachment_descriptor_set_clear_color(
+   mtl_render_pass_attachment_descriptor *descriptor,
+   struct mtl_clear_color clear_color);
+
+void mtl_render_pass_attachment_descriptor_set_clear_depth(
+   mtl_render_pass_attachment_descriptor *descriptor, double depth);
+
+void mtl_render_pass_attachment_descriptor_set_clear_stencil(
+   mtl_render_pass_attachment_descriptor *descriptor, uint32_t stencil);
+
+void mtl_render_pass_descriptor_set_render_target_array_length(
+   mtl_render_pass_descriptor *descriptor, uint32_t length);
+
+void mtl_render_pass_descriptor_set_render_target_width(
+   mtl_render_pass_descriptor *descriptor, uint32_t width);
+
+void mtl_render_pass_descriptor_set_render_target_height(
+   mtl_render_pass_descriptor *descriptor, uint32_t height);
+
+void mtl_render_pass_descriptor_set_default_raster_sample_count(
+   mtl_render_pass_descriptor *descriptor, uint32_t sample_count);
+
+void mtl_render_pass_descriptor_set_visibility_buffer(
+   mtl_render_pass_descriptor *descriptor, mtl_buffer *visibility_buffer);
+
+/* Render pipeline descriptor */
+mtl_render_pipeline_descriptor *mtl_new_render_pipeline_descriptor(void);
+
+void mtl_render_pipeline_descriptor_set_vertex_shader(
+   mtl_render_pass_descriptor *descriptor, mtl_function *shader);
+
+void mtl_render_pipeline_descriptor_set_fragment_shader(
+   mtl_render_pass_descriptor *descriptor, mtl_function *shader);
+
+void mtl_render_pipeline_descriptor_set_input_primitive_topology(
+   mtl_render_pass_descriptor *descriptor,
+   enum mtl_primitive_topology_class topology_class);
+
+void mtl_render_pipeline_descriptor_set_color_attachment_format(
+   mtl_render_pass_descriptor *descriptor, uint8_t index,
+   enum mtl_pixel_format format);
+
+void mtl_render_pipeline_descriptor_set_depth_attachment_format(
+   mtl_render_pass_descriptor *descriptor, enum mtl_pixel_format format);
+
+void mtl_render_pipeline_descriptor_set_stencil_attachment_format(
+   mtl_render_pass_descriptor *descriptor, enum mtl_pixel_format format);
+
+void mtl_render_pipeline_descriptor_set_raster_sample_count(
+   mtl_render_pass_descriptor *descriptor, uint32_t sample_count);
+
+void mtl_render_pipeline_descriptor_set_alpha_to_coverage(
+   mtl_render_pass_descriptor *descriptor, bool enabled);
+
+void mtl_render_pipeline_descriptor_set_alpha_to_one(
+   mtl_render_pass_descriptor *descriptor, bool enabled);
+
+void mtl_render_pipeline_descriptor_set_rasterization_enabled(
+   mtl_render_pass_descriptor *descriptor, bool enabled);
+
+void mtl_render_pipeline_descriptor_set_max_vertex_amplification_count(
+   mtl_render_pass_descriptor *descriptor, uint32_t count);
+
+/* Render pipeline */
+mtl_render_pipeline_state *
+mtl_new_render_pipeline(mtl_device *device,
+                        mtl_render_pass_descriptor *descriptor);
+
+/* Stencil descriptor */
+mtl_stencil_descriptor *mtl_new_stencil_descriptor(void);
+
+void mtl_stencil_descriptor_set_stencil_failure_operation(
+   mtl_stencil_descriptor *descriptor, enum VkStencilOp op);
+
+void mtl_stencil_descriptor_set_depth_failure_operation(
+   mtl_stencil_descriptor *descriptor, enum VkStencilOp op);
+
+void mtl_stencil_descriptor_set_depth_stencil_pass_operation(
+   mtl_stencil_descriptor *descriptor, enum VkStencilOp op);
+
+void mtl_stencil_descriptor_set_stencil_compare_function(
+   mtl_stencil_descriptor *descriptor, enum VkCompareOp op);
+
+void mtl_stencil_descriptor_set_read_mask(mtl_stencil_descriptor *descriptor,
+                                          uint32_t mask);
+
+void mtl_stencil_descriptor_set_write_mask(mtl_stencil_descriptor *descriptor,
+                                           uint32_t mask);
+
+/* Depth stencil descriptor */
+mtl_depth_stencil_descriptor *mtl_new_depth_stencil_descriptor(void);
+
+void mtl_depth_stencil_descriptor_set_depth_compare_function(
+   mtl_depth_stencil_descriptor *descriptor, enum VkCompareOp op);
+
+void mtl_depth_stencil_descriptor_set_depth_write_enabled(
+   mtl_depth_stencil_descriptor *descriptor, bool enable_write);
+
+void mtl_depth_stencil_descriptor_set_back_face_stencil(
+   mtl_depth_stencil_descriptor *descriptor,
+   mtl_stencil_descriptor *stencil_descriptor);
+
+void mtl_depth_stencil_descriptor_set_front_face_stencil(
+   mtl_depth_stencil_descriptor *descriptor,
+   mtl_stencil_descriptor *stencil_descriptor);
+
+/* Depth stencil state */
+mtl_depth_stencil_state *
+mtl_new_depth_stencil_state(mtl_device *device,
+                            mtl_depth_stencil_descriptor *descriptor);
+
+#endif /* MTL_RENDER_STATE_H */
diff --git a/src/kosmickrisp/bridge/mtl_render_state.m b/src/kosmickrisp/bridge/mtl_render_state.m
new file mode 100644
index 00000000000..0a5051c286a
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_render_state.m
@@ -0,0 +1,475 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_render_state.h"
+
+#include "mtl_format.h"
+
+/* TODO_KOSMICKRISP Remove */
+#include "vk_to_mtl_map.h"
+
+/* TODO_KOSMICKRISP Remove */
+#include "vulkan/vulkan.h"
+
+#include <Metal/MTLRenderPass.h>
+#include <Metal/MTLRenderPipeline.h>
+#include <Metal/MTLDepthStencil.h>
+
+/* Render pass descriptor */
+mtl_render_pass_descriptor *
+mtl_new_render_pass_descriptor(void)
+{
+   @autoreleasepool {
+      return [[MTLRenderPassDescriptor renderPassDescriptor] retain];
+   }
+}
+
+mtl_render_pass_attachment_descriptor *
+mtl_render_pass_descriptor_get_color_attachment(
+   mtl_render_pass_descriptor *descriptor, uint32_t index)
+{
+   @autoreleasepool {
+      MTLRenderPassDescriptor *desc = (MTLRenderPassDescriptor *)descriptor;
+      return desc.colorAttachments[index];
+   }
+}
+
+mtl_render_pass_attachment_descriptor *
+mtl_render_pass_descriptor_get_depth_attachment(
+   mtl_render_pass_descriptor *descriptor)
+{
+   @autoreleasepool {
+      MTLRenderPassDescriptor *desc = (MTLRenderPassDescriptor *)descriptor;
+      return desc.depthAttachment;
+   }
+}
+
+mtl_render_pass_attachment_descriptor *
+mtl_render_pass_descriptor_get_stencil_attachment(
+   mtl_render_pass_descriptor *descriptor)
+{
+   @autoreleasepool {
+      MTLRenderPassDescriptor *desc = (MTLRenderPassDescriptor *)descriptor;
+      return desc.stencilAttachment;
+   }
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_texture(
+   mtl_render_pass_attachment_descriptor *descriptor, mtl_texture *texture)
+{
+   @autoreleasepool {
+      MTLRenderPassAttachmentDescriptor *desc = (MTLRenderPassAttachmentDescriptor *)descriptor;
+      desc.texture = (id<MTLTexture>)texture;
+   }
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_level(
+   mtl_render_pass_attachment_descriptor *descriptor, uint32_t level)
+{
+   @autoreleasepool {
+      MTLRenderPassAttachmentDescriptor *desc = (MTLRenderPassAttachmentDescriptor *)descriptor;
+      desc.level = level;
+   }
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_slice(
+   mtl_render_pass_attachment_descriptor *descriptor, uint32_t slice)
+{
+   @autoreleasepool {
+      MTLRenderPassAttachmentDescriptor *desc = (MTLRenderPassAttachmentDescriptor *)descriptor;
+      desc.slice = slice;
+   }
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_load_action(
+   mtl_render_pass_attachment_descriptor *descriptor,
+   enum mtl_load_action action)
+{
+   @autoreleasepool {
+      MTLRenderPassAttachmentDescriptor *desc = (MTLRenderPassAttachmentDescriptor *)descriptor;
+      desc.loadAction = (MTLLoadAction)action;
+   }
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_store_action(
+   mtl_render_pass_attachment_descriptor *descriptor,
+   enum mtl_store_action action)
+{
+   @autoreleasepool {
+      MTLRenderPassAttachmentDescriptor *desc = (MTLRenderPassAttachmentDescriptor *)descriptor;
+      desc.storeAction = (MTLStoreAction)action;
+      desc.storeActionOptions = MTLStoreActionOptionNone; /* TODO_KOSMICKRISP Maybe expose this? */
+   }
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_clear_color(
+   mtl_render_pass_attachment_descriptor *descriptor,
+   struct mtl_clear_color clear_color)
+{
+   @autoreleasepool {
+      MTLRenderPassColorAttachmentDescriptor *desc = (MTLRenderPassColorAttachmentDescriptor *)descriptor;
+      desc.clearColor = MTLClearColorMake(clear_color.red, clear_color.green, clear_color.blue, clear_color.alpha);
+   }
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_clear_depth(
+   mtl_render_pass_attachment_descriptor *descriptor, double depth)
+{
+   @autoreleasepool {
+      MTLRenderPassDepthAttachmentDescriptor *desc = (MTLRenderPassDepthAttachmentDescriptor *)descriptor;
+      desc.clearDepth = depth;
+   }
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_clear_stencil(mtl_render_pass_attachment_descriptor *descriptor,
+                                                        uint32_t stencil)
+{
+   @autoreleasepool {
+      MTLRenderPassStencilAttachmentDescriptor *desc = (MTLRenderPassStencilAttachmentDescriptor *)descriptor;
+      desc.clearStencil = stencil;
+   }
+}
+
+void
+mtl_render_pass_descriptor_set_render_target_array_length(mtl_render_pass_descriptor *descriptor,
+                                                          uint32_t length)
+{
+   @autoreleasepool {
+      MTLRenderPassDescriptor *desc = (MTLRenderPassDescriptor *)descriptor;
+      desc.renderTargetArrayLength = length;
+   }
+}
+
+void
+mtl_render_pass_descriptor_set_render_target_width(mtl_render_pass_descriptor *descriptor,
+                                                   uint32_t width)
+{
+   @autoreleasepool {
+      MTLRenderPassDescriptor *desc = (MTLRenderPassDescriptor *)descriptor;
+      desc.renderTargetWidth = width;
+   }
+}
+
+void
+mtl_render_pass_descriptor_set_render_target_height(mtl_render_pass_descriptor *descriptor,
+                                                    uint32_t height)
+{
+   @autoreleasepool {
+      MTLRenderPassDescriptor *desc = (MTLRenderPassDescriptor *)descriptor;
+      desc.renderTargetHeight = height;
+   }
+}
+
+void
+mtl_render_pass_descriptor_set_default_raster_sample_count(mtl_render_pass_descriptor *descriptor,
+                                                           uint32_t sample_count)
+{
+   @autoreleasepool {
+      MTLRenderPassDescriptor *desc = (MTLRenderPassDescriptor *)descriptor;
+      desc.defaultRasterSampleCount = sample_count;
+   }
+}
+
+void
+mtl_render_pass_descriptor_set_visibility_buffer(mtl_render_pass_descriptor *descriptor,
+                                                 mtl_buffer *visibility_buffer)
+{
+   @autoreleasepool {
+      MTLRenderPassDescriptor *desc = (MTLRenderPassDescriptor *)descriptor;
+      id<MTLBuffer> buffer = (id<MTLBuffer>)visibility_buffer;
+      desc.visibilityResultBuffer = buffer;
+   }
+}
+
+/* Render pipeline descriptor */
+mtl_render_pipeline_descriptor *
+mtl_new_render_pipeline_descriptor()
+{
+   @autoreleasepool {
+      return [[MTLRenderPipelineDescriptor alloc] init];
+   }
+}
+
+void
+mtl_render_pipeline_descriptor_set_vertex_shader(mtl_render_pass_descriptor *descriptor,
+                                                 mtl_function *shader)
+{
+   @autoreleasepool {
+      MTLRenderPipelineDescriptor *desc = (MTLRenderPipelineDescriptor *)descriptor;
+      desc.vertexFunction = (id<MTLFunction>)shader;
+   }
+}
+
+void
+mtl_render_pipeline_descriptor_set_fragment_shader(mtl_render_pass_descriptor *descriptor,
+                                                   mtl_function *shader)
+{
+   @autoreleasepool {
+      MTLRenderPipelineDescriptor *desc = (MTLRenderPipelineDescriptor *)descriptor;
+      desc.fragmentFunction = (id<MTLFunction>)shader;
+   }
+}
+
+void
+mtl_render_pipeline_descriptor_set_input_primitive_topology(mtl_render_pass_descriptor *descriptor,
+                                                            enum mtl_primitive_topology_class class)
+{
+   @autoreleasepool {
+      MTLRenderPipelineDescriptor *desc = (MTLRenderPipelineDescriptor *)descriptor;
+      desc.inputPrimitiveTopology = (MTLPrimitiveTopologyClass)class;
+   }
+}
+
+void
+mtl_render_pipeline_descriptor_set_color_attachment_format(mtl_render_pass_descriptor *descriptor,
+                                                           uint8_t index,
+                                                           enum mtl_pixel_format format)
+{
+   @autoreleasepool {
+      MTLRenderPipelineDescriptor *desc = (MTLRenderPipelineDescriptor *)descriptor;
+      desc.colorAttachments[index].pixelFormat = (MTLPixelFormat)format;
+   }
+}
+
+void
+mtl_render_pipeline_descriptor_set_depth_attachment_format(mtl_render_pass_descriptor *descriptor,
+                                                           enum mtl_pixel_format format)
+{
+   @autoreleasepool {
+      MTLRenderPipelineDescriptor *desc = (MTLRenderPipelineDescriptor *)descriptor;
+      desc.depthAttachmentPixelFormat = (MTLPixelFormat)format;
+   }
+}
+
+void
+mtl_render_pipeline_descriptor_set_stencil_attachment_format(mtl_render_pass_descriptor *descriptor,
+                                                             enum mtl_pixel_format format)
+{
+   @autoreleasepool {
+      MTLRenderPipelineDescriptor *desc = (MTLRenderPipelineDescriptor *)descriptor;
+      desc.stencilAttachmentPixelFormat = (MTLPixelFormat)format;
+   }
+}
+
+void
+mtl_render_pipeline_descriptor_set_raster_sample_count(mtl_render_pass_descriptor *descriptor,
+                                                       uint32_t sample_count)
+{
+   @autoreleasepool {
+      MTLRenderPipelineDescriptor *desc = (MTLRenderPipelineDescriptor *)descriptor;
+      desc.rasterSampleCount = sample_count;
+   }
+}
+
+void
+mtl_render_pipeline_descriptor_set_alpha_to_coverage(mtl_render_pass_descriptor *descriptor,
+                                                     bool enabled)
+{
+   @autoreleasepool {
+      MTLRenderPipelineDescriptor *desc = (MTLRenderPipelineDescriptor *)descriptor;
+      desc.alphaToCoverageEnabled = enabled;
+   }
+}
+
+void
+mtl_render_pipeline_descriptor_set_alpha_to_one(mtl_render_pass_descriptor *descriptor,
+                                                bool enabled)
+{
+   @autoreleasepool {
+      MTLRenderPipelineDescriptor *desc = (MTLRenderPipelineDescriptor *)descriptor;
+      desc.alphaToOneEnabled = enabled;
+   }
+}
+
+void
+mtl_render_pipeline_descriptor_set_rasterization_enabled(mtl_render_pass_descriptor *descriptor,
+                                                         bool enabled)
+{
+   @autoreleasepool {
+      MTLRenderPipelineDescriptor *desc = (MTLRenderPipelineDescriptor *)descriptor;
+      desc.rasterizationEnabled = enabled;
+   }
+}
+
+void
+mtl_render_pipeline_descriptor_set_max_vertex_amplification_count( mtl_render_pass_descriptor *descriptor,
+                                                                  uint32_t count)
+{
+   @autoreleasepool {
+      MTLRenderPipelineDescriptor *desc = (MTLRenderPipelineDescriptor *)descriptor;
+      desc.maxVertexAmplificationCount = count;
+   }
+}
+
+/* Render pipeline */
+mtl_render_pipeline_state *
+mtl_new_render_pipeline(mtl_device *device, mtl_render_pass_descriptor *descriptor)
+{
+   @autoreleasepool {
+      MTLRenderPipelineDescriptor *desc = (MTLRenderPipelineDescriptor *)descriptor;
+      id<MTLDevice> dev = (id<MTLDevice>)device;
+      NSError *error = nil;
+      mtl_render_pipeline_state *pipeline = [dev newRenderPipelineStateWithDescriptor:desc error:&error];
+      if (error != nil) {
+         fprintf(stderr, "Failed to create MTLLibrary: %s\n", [error.localizedDescription UTF8String]);
+      }
+
+      return pipeline;
+   }
+}
+
+/* Stencil descriptor */
+mtl_stencil_descriptor *
+mtl_new_stencil_descriptor()
+{
+   @autoreleasepool {
+      return [[MTLStencilDescriptor new] init];
+   }
+}
+
+/* TODO_KOSMICKRISP Move this to map */
+static MTLStencilOperation
+map_vk_stencil_op_to_mtl_stencil_operation(VkStencilOp op)
+{
+   switch (op) {
+   case VK_STENCIL_OP_KEEP:
+      return MTLStencilOperationKeep;
+   case VK_STENCIL_OP_ZERO:
+      return MTLStencilOperationZero;
+   case VK_STENCIL_OP_REPLACE:
+      return MTLStencilOperationReplace;
+   case VK_STENCIL_OP_INCREMENT_AND_CLAMP:
+      return MTLStencilOperationIncrementClamp;
+   case VK_STENCIL_OP_DECREMENT_AND_CLAMP:
+      return MTLStencilOperationDecrementClamp;
+   case VK_STENCIL_OP_INVERT:
+      return MTLStencilOperationInvert;
+   case VK_STENCIL_OP_INCREMENT_AND_WRAP:
+      return MTLStencilOperationIncrementWrap;
+   case VK_STENCIL_OP_DECREMENT_AND_WRAP:
+      return MTLStencilOperationDecrementWrap;
+   default:
+      assert(false && "Unsupported VkStencilOp");
+      return MTLStencilOperationZero;
+   };
+}
+
+void
+mtl_stencil_descriptor_set_stencil_failure_operation(mtl_stencil_descriptor *descriptor, VkStencilOp op)
+{
+   @autoreleasepool {
+      MTLStencilDescriptor *desc = (MTLStencilDescriptor *)descriptor;
+      desc.stencilFailureOperation = map_vk_stencil_op_to_mtl_stencil_operation(op);
+   }
+}
+
+void
+mtl_stencil_descriptor_set_depth_failure_operation(mtl_stencil_descriptor *descriptor, VkStencilOp op)
+{
+   @autoreleasepool {
+      MTLStencilDescriptor *desc = (MTLStencilDescriptor *)descriptor;
+      desc.depthFailureOperation = map_vk_stencil_op_to_mtl_stencil_operation(op);
+   }
+}
+
+void
+mtl_stencil_descriptor_set_depth_stencil_pass_operation(mtl_stencil_descriptor *descriptor, VkStencilOp op)
+{
+   @autoreleasepool {
+      MTLStencilDescriptor *desc = (MTLStencilDescriptor *)descriptor;
+      desc.depthStencilPassOperation = map_vk_stencil_op_to_mtl_stencil_operation(op);
+   }
+}
+
+void
+mtl_stencil_descriptor_set_stencil_compare_function(mtl_stencil_descriptor *descriptor, VkCompareOp op)
+{
+   @autoreleasepool {
+      MTLStencilDescriptor *desc = (MTLStencilDescriptor *)descriptor;
+      desc.stencilCompareFunction = (MTLCompareFunction)vk_compare_op_to_mtl_compare_function(op);
+   }
+}
+
+void
+mtl_stencil_descriptor_set_read_mask(mtl_stencil_descriptor *descriptor, uint32_t mask)
+{
+   @autoreleasepool {
+      MTLStencilDescriptor *desc = (MTLStencilDescriptor *)descriptor;
+      desc.readMask = mask;
+   }
+}
+
+void
+mtl_stencil_descriptor_set_write_mask(mtl_stencil_descriptor *descriptor, uint32_t mask)
+{
+   @autoreleasepool {
+      MTLStencilDescriptor *desc = (MTLStencilDescriptor *)descriptor;
+      desc.writeMask = mask;
+   }
+}
+
+/* Depth stencil descriptor */
+mtl_depth_stencil_descriptor *
+mtl_new_depth_stencil_descriptor()
+{
+   @autoreleasepool {
+      return [[MTLDepthStencilDescriptor new] init];
+   }
+}
+
+void
+mtl_depth_stencil_descriptor_set_depth_compare_function(mtl_depth_stencil_descriptor *descriptor, VkCompareOp op)
+{
+   @autoreleasepool {
+      MTLDepthStencilDescriptor *desc = (MTLDepthStencilDescriptor *)descriptor;
+      desc.depthCompareFunction = (MTLCompareFunction)vk_compare_op_to_mtl_compare_function(op);
+   }
+}
+
+void
+mtl_depth_stencil_descriptor_set_depth_write_enabled(mtl_depth_stencil_descriptor *descriptor, bool enable_write)
+{
+   @autoreleasepool {
+      MTLDepthStencilDescriptor *desc = (MTLDepthStencilDescriptor *)descriptor;
+      desc.depthWriteEnabled = enable_write;
+   }
+}
+
+void
+mtl_depth_stencil_descriptor_set_back_face_stencil(mtl_depth_stencil_descriptor *descriptor, mtl_stencil_descriptor *stencil_descriptor)
+{
+   @autoreleasepool {
+      MTLDepthStencilDescriptor *desc = (MTLDepthStencilDescriptor *)descriptor;
+      desc.backFaceStencil = (MTLStencilDescriptor *)stencil_descriptor;
+   }
+}
+
+void
+mtl_depth_stencil_descriptor_set_front_face_stencil(mtl_depth_stencil_descriptor *descriptor, mtl_stencil_descriptor *stencil_descriptor)
+{
+   @autoreleasepool {
+      MTLDepthStencilDescriptor *desc = (MTLDepthStencilDescriptor *)descriptor;
+      desc.frontFaceStencil = (MTLStencilDescriptor *)stencil_descriptor;
+   }
+}
+
+mtl_depth_stencil_state *
+mtl_new_depth_stencil_state(mtl_device *device, mtl_depth_stencil_descriptor *descriptor)
+{
+   @autoreleasepool {
+      id<MTLDevice> dev = (id<MTLDevice>)device;
+      MTLDepthStencilDescriptor *desc = (MTLDepthStencilDescriptor *)descriptor;
+      return [dev newDepthStencilStateWithDescriptor:desc];
+   }
+}
diff --git a/src/kosmickrisp/bridge/mtl_sampler.h b/src/kosmickrisp/bridge/mtl_sampler.h
new file mode 100644
index 00000000000..ab751195b2c
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_sampler.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef MTL_SAMPLER_H
+#define MTL_SAMPLER_H 1
+
+#include "mtl_types.h"
+
+#include <inttypes.h>
+#include <stdbool.h>
+
+/* Sampler descriptor */
+mtl_sampler_descriptor *mtl_new_sampler_descriptor(void);
+
+/* Sampler descriptor utils */
+void mtl_sampler_descriptor_set_normalized_coordinates(
+   mtl_sampler_descriptor *descriptor, bool normalized_coordinates);
+void mtl_sampler_descriptor_set_address_mode(
+   mtl_sampler_descriptor *descriptor,
+   enum mtl_sampler_address_mode address_mode_u,
+   enum mtl_sampler_address_mode address_mode_v,
+   enum mtl_sampler_address_mode address_mode_w);
+void
+mtl_sampler_descriptor_set_border_color(mtl_sampler_descriptor *descriptor,
+                                        enum mtl_sampler_border_color color);
+void
+mtl_sampler_descriptor_set_filters(mtl_sampler_descriptor *descriptor,
+                                   enum mtl_sampler_min_mag_filter min_filter,
+                                   enum mtl_sampler_min_mag_filter mag_filter,
+                                   enum mtl_sampler_mip_filter mip_filter);
+void mtl_sampler_descriptor_set_lod_clamp(mtl_sampler_descriptor *descriptor,
+                                          float min, float max);
+void
+mtl_sampler_descriptor_set_max_anisotropy(mtl_sampler_descriptor *descriptor,
+                                          uint64_t max);
+void
+mtl_sampler_descriptor_set_compare_function(mtl_sampler_descriptor *descriptor,
+                                            enum mtl_compare_function function);
+
+/* Sampler */
+mtl_sampler *mtl_new_sampler(mtl_device *device,
+                             mtl_sampler_descriptor *descriptor);
+
+/* Sampler utils */
+uint64_t mtl_sampler_get_gpu_resource_id(mtl_sampler *sampler);
+
+#endif /* MTL_SAMPLER_H */
\ No newline at end of file
diff --git a/src/kosmickrisp/bridge/mtl_sampler.m b/src/kosmickrisp/bridge/mtl_sampler.m
new file mode 100644
index 00000000000..f7ddb66b7e1
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_sampler.m
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_sampler.h"
+
+#include <Metal/MTLSampler.h>
+
+mtl_sampler_descriptor *
+mtl_new_sampler_descriptor()
+{
+   @autoreleasepool {
+      MTLSamplerDescriptor *descriptor = [MTLSamplerDescriptor new];
+      /* Set common variables we don't expose */
+      descriptor.lodAverage = false;
+      descriptor.supportArgumentBuffers = true;
+      return descriptor;
+   }
+}
+
+void
+mtl_sampler_descriptor_set_normalized_coordinates(mtl_sampler_descriptor *descriptor, bool normalized_coordinates)
+{
+   @autoreleasepool {
+      MTLSamplerDescriptor *desc = (MTLSamplerDescriptor *)descriptor;
+      desc.normalizedCoordinates = normalized_coordinates;
+   }
+}
+
+void
+mtl_sampler_descriptor_set_address_mode(mtl_sampler_descriptor *descriptor,
+                                        enum mtl_sampler_address_mode address_mode_u,
+                                        enum mtl_sampler_address_mode address_mode_v,
+                                        enum mtl_sampler_address_mode address_mode_w)
+{
+   @autoreleasepool {
+      MTLSamplerDescriptor *desc = (MTLSamplerDescriptor *)descriptor;
+      desc.sAddressMode = (MTLSamplerAddressMode)address_mode_u;
+      desc.tAddressMode = (MTLSamplerAddressMode)address_mode_v;
+      desc.rAddressMode = (MTLSamplerAddressMode)address_mode_w;
+   }
+}
+
+void
+mtl_sampler_descriptor_set_border_color(mtl_sampler_descriptor *descriptor, enum mtl_sampler_border_color color)
+{
+   @autoreleasepool {
+      MTLSamplerDescriptor *desc = (MTLSamplerDescriptor *)descriptor;
+      desc.borderColor = (MTLSamplerBorderColor)color;
+   }
+}
+
+void
+mtl_sampler_descriptor_set_filters(mtl_sampler_descriptor *descriptor,
+                                   enum mtl_sampler_min_mag_filter min_filter,
+                                   enum mtl_sampler_min_mag_filter mag_filter,
+                                   enum mtl_sampler_mip_filter mip_filter)
+{
+   @autoreleasepool {
+      MTLSamplerDescriptor *desc = (MTLSamplerDescriptor *)descriptor;
+      desc.minFilter = (MTLSamplerMinMagFilter)min_filter;
+      desc.magFilter = (MTLSamplerMinMagFilter)mag_filter;
+      desc.mipFilter = (MTLSamplerMipFilter)mip_filter;
+   }
+}
+
+void
+mtl_sampler_descriptor_set_lod_clamp(mtl_sampler_descriptor *descriptor,
+                                     float min,
+                                     float max)
+{
+   @autoreleasepool {
+      MTLSamplerDescriptor *desc = (MTLSamplerDescriptor *)descriptor;
+      desc.lodMinClamp = min;
+      desc.lodMaxClamp = max;
+   }
+}
+
+void
+mtl_sampler_descriptor_set_max_anisotropy(mtl_sampler_descriptor *descriptor,
+                                          uint64_t max)
+{
+   @autoreleasepool {
+      MTLSamplerDescriptor *desc = (MTLSamplerDescriptor *)descriptor;
+      desc.maxAnisotropy = max ? max : 1u; /* Metal requires a non-zero value */
+   }
+}
+
+void
+mtl_sampler_descriptor_set_compare_function(mtl_sampler_descriptor *descriptor,
+                                            enum mtl_compare_function function)
+{
+   @autoreleasepool {
+      MTLSamplerDescriptor *desc = (MTLSamplerDescriptor *)descriptor;
+      desc.compareFunction = (MTLCompareFunction)function;
+   }
+}
+
+mtl_sampler *
+mtl_new_sampler(mtl_device *device, mtl_sampler_descriptor *descriptor)
+{
+   @autoreleasepool {
+      id<MTLDevice> dev = (id<MTLDevice>)device;
+      MTLSamplerDescriptor *desc = (MTLSamplerDescriptor *)descriptor;
+      return [dev newSamplerStateWithDescriptor:desc];
+   }
+}
+
+uint64_t
+mtl_sampler_get_gpu_resource_id(mtl_sampler *sampler)
+{
+   @autoreleasepool {
+      id<MTLSamplerState> samp = (id<MTLSamplerState>)sampler;
+      return [samp gpuResourceID]._impl;
+   }
+}
diff --git a/src/kosmickrisp/bridge/mtl_sync.h b/src/kosmickrisp/bridge/mtl_sync.h
new file mode 100644
index 00000000000..8df0057cd75
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_sync.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef MTL_SYNC_H
+#define MTL_SYNC_H 1
+
+#include "mtl_types.h"
+
+#include <inttypes.h>
+
+/* MTLFence */
+mtl_fence *mtl_new_fence(mtl_device *device);
+
+/* MTLEvent */
+mtl_event *mtl_new_event(mtl_device *device);
+
+/* MTLSharedEvent */
+mtl_shared_event *mtl_new_shared_event(mtl_device *device);
+int mtl_shared_event_wait_until_signaled_value(mtl_shared_event *event_handle,
+                                               uint64_t value,
+                                               uint64_t timeout_ms);
+uint64_t mtl_shared_event_get_signaled_value(mtl_shared_event *event_handle);
+void mtl_shared_event_set_signaled_value(mtl_shared_event *event_handle,
+                                         uint64_t value);
+
+#endif /* MTL_SYNC_H */
\ No newline at end of file
diff --git a/src/kosmickrisp/bridge/mtl_sync.m b/src/kosmickrisp/bridge/mtl_sync.m
new file mode 100644
index 00000000000..d7f5b211318
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_sync.m
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_sync.h"
+
+#include <Metal/MTLEvent.h>
+
+/* MTLFence */
+mtl_fence *
+mtl_new_fence(mtl_device *device)
+{
+   @autoreleasepool {
+      id<MTLDevice> dev = (id<MTLDevice>)device;
+      return (mtl_fence *)[dev newFence];
+   }
+}
+
+/* MTLEvent */
+mtl_event *
+mtl_new_event(mtl_device *device)
+{
+   @autoreleasepool {
+      id<MTLDevice> dev = (id<MTLDevice>)device;
+      return [dev newEvent];
+   }
+}
+
+/* MTLSharedEvent */
+mtl_shared_event *
+mtl_new_shared_event(mtl_device *device)
+{
+   @autoreleasepool {
+      id<MTLDevice> dev = (id<MTLDevice>)device;
+      return [dev newSharedEvent];
+   }
+}
+
+int
+mtl_shared_event_wait_until_signaled_value(mtl_shared_event *event_handle, uint64_t value, uint64_t timeout_ms)
+{
+   @autoreleasepool {
+      id<MTLSharedEvent> event = (id<MTLSharedEvent>)event_handle;
+      return (int)[event waitUntilSignaledValue:value timeoutMS:timeout_ms];
+   }
+}
+
+void
+mtl_shared_event_set_signaled_value(mtl_shared_event *event_handle, uint64_t value)
+{
+   @autoreleasepool {
+      id<MTLSharedEvent> event = (id<MTLSharedEvent>)event_handle;
+      event.signaledValue = value;
+   }
+}
+
+uint64_t
+mtl_shared_event_get_signaled_value(mtl_shared_event *event_handle)
+{
+   @autoreleasepool {
+      id<MTLSharedEvent> event = (id<MTLSharedEvent>)event_handle;
+      return event.signaledValue;
+   }
+}
diff --git a/src/kosmickrisp/bridge/mtl_texture.h b/src/kosmickrisp/bridge/mtl_texture.h
new file mode 100644
index 00000000000..ab1de341b01
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_texture.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef MTL_TEXTURE_H
+#define MTL_TEXTURE_H 1
+
+#include "mtl_types.h"
+
+#include <inttypes.h>
+
+/* TODO_KOSMICKRISP Move this to bridge. */
+struct kk_view_layout;
+
+/* Utils*/
+uint64_t mtl_texture_get_gpu_resource_id(mtl_texture *texture);
+
+/* Texture view creation */
+mtl_texture *mtl_new_texture_view_with(mtl_texture *texture,
+                                       const struct kk_view_layout *layout);
+mtl_texture *
+mtl_new_texture_view_with_no_swizzle(mtl_texture *texture,
+                                     const struct kk_view_layout *layout);
+
+#endif /* MTL_TEXTURE_H */
diff --git a/src/kosmickrisp/bridge/mtl_texture.m b/src/kosmickrisp/bridge/mtl_texture.m
new file mode 100644
index 00000000000..5042e7f2926
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_texture.m
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_texture.h"
+
+/* TODO_LUNARG Remove */
+#include "kk_image_layout.h"
+
+/* TODO_LUNARG Remove */
+#include "vulkan/vulkan.h"
+
+#include <Metal/MTLTexture.h>
+
+uint64_t
+mtl_texture_get_gpu_resource_id(mtl_texture *texture)
+{
+   @autoreleasepool {
+      id<MTLTexture> tex = (id<MTLTexture>)texture;
+      return (uint64_t)[tex gpuResourceID]._impl;
+   }
+}
+
+/* TODO_KOSMICKRISP This should be part of the mapping */
+static uint32_t
+mtl_texture_view_type(uint32_t type, uint8_t sample_count)
+{
+   switch (type) {
+   case VK_IMAGE_VIEW_TYPE_1D:
+      return MTLTextureType1D;
+   case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
+      return MTLTextureType1DArray;
+   case VK_IMAGE_VIEW_TYPE_2D:
+      return sample_count > 1u ? MTLTextureType2DMultisample : MTLTextureType2D;;
+   case VK_IMAGE_VIEW_TYPE_CUBE:
+      return MTLTextureTypeCube;
+   case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
+      return MTLTextureTypeCubeArray;
+   case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
+      return sample_count > 1u ? MTLTextureType2DMultisampleArray : MTLTextureType2DArray;
+   case VK_IMAGE_VIEW_TYPE_3D:
+      return MTLTextureType3D;
+   default:
+      assert(false && "Unsupported VkViewType");
+      return MTLTextureType1D;
+   }
+}
+
+static MTLTextureSwizzle
+mtl_texture_swizzle(enum pipe_swizzle swizzle)
+{
+   const MTLTextureSwizzle map[] =
+      {
+         [PIPE_SWIZZLE_X] = MTLTextureSwizzleRed,
+         [PIPE_SWIZZLE_Y] = MTLTextureSwizzleGreen,
+         [PIPE_SWIZZLE_Z] = MTLTextureSwizzleBlue,
+         [PIPE_SWIZZLE_W] = MTLTextureSwizzleAlpha,
+         [PIPE_SWIZZLE_0] = MTLTextureSwizzleZero,
+         [PIPE_SWIZZLE_1] = MTLTextureSwizzleOne,
+      };
+
+   return map[swizzle];
+}
+
+mtl_texture *
+mtl_new_texture_view_with(mtl_texture *texture, const struct kk_view_layout *layout)
+{
+   @autoreleasepool {
+      id<MTLTexture> tex = (id<MTLTexture>)texture;
+      MTLTextureType type = mtl_texture_view_type(layout->view_type, layout->sample_count_sa);
+      NSRange levels = NSMakeRange(layout->base_level, layout->num_levels);
+      NSRange slices = NSMakeRange(layout->base_array_layer, layout->array_len);
+      MTLTextureSwizzleChannels swizzle = MTLTextureSwizzleChannelsMake(mtl_texture_swizzle(layout->swizzle.red),
+                                                                        mtl_texture_swizzle(layout->swizzle.green),
+                                                                        mtl_texture_swizzle(layout->swizzle.blue),
+                                                                        mtl_texture_swizzle(layout->swizzle.alpha));
+      return [tex newTextureViewWithPixelFormat:layout->format.mtl textureType:type levels:levels slices:slices swizzle:swizzle];
+   }
+}
+
+mtl_texture *
+mtl_new_texture_view_with_no_swizzle(mtl_texture *texture, const struct kk_view_layout *layout)
+{
+   @autoreleasepool {
+      id<MTLTexture> tex = (id<MTLTexture>)texture;
+      MTLTextureType type = mtl_texture_view_type(layout->view_type, layout->sample_count_sa);
+      NSRange levels = NSMakeRange(layout->base_level, layout->num_levels);
+      NSRange slices = NSMakeRange(layout->base_array_layer, layout->array_len);
+      return [tex newTextureViewWithPixelFormat:layout->format.mtl textureType:type levels:levels slices:slices];
+   }
+}
+
diff --git a/src/kosmickrisp/bridge/mtl_types.h b/src/kosmickrisp/bridge/mtl_types.h
new file mode 100644
index 00000000000..90bfbdb8315
--- /dev/null
+++ b/src/kosmickrisp/bridge/mtl_types.h
@@ -0,0 +1,272 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ *
+ * Structures and enums found in this file are a 1-1 mapping of Metal's
+ * equivalents
+ */
+
+#ifndef KK_MTL_TYPES_H
+#define KK_MTL_TYPES_H 1
+
+#include <stddef.h> /* For size_t definition */
+
+/** HANDLES */
+typedef void mtl_device;
+typedef void mtl_heap;
+typedef void mtl_buffer;
+typedef void mtl_texture;
+typedef void mtl_command_queue;
+typedef void mtl_command_buffer;
+typedef void mtl_command_encoder;
+typedef void mtl_blit_encoder;
+typedef void mtl_compute_encoder;
+typedef void mtl_render_encoder;
+typedef void mtl_event;
+typedef void mtl_shared_event;
+typedef void mtl_sampler_descriptor;
+typedef void mtl_sampler;
+typedef void mtl_compute_pipeline_state;
+typedef void mtl_library;
+typedef void mtl_render_pipeline_state;
+typedef void mtl_function;
+typedef void mtl_resource;
+typedef void mtl_render_pass_descriptor;
+typedef void mtl_render_pipeline_descriptor;
+typedef void mtl_fence;
+typedef void mtl_stencil_descriptor;
+typedef void mtl_depth_stencil_descriptor;
+typedef void mtl_depth_stencil_state;
+typedef void mtl_render_pass_attachment_descriptor;
+
+/** ENUMS */
+enum mtl_cpu_cache_mode {
+   MTL_CPU_CACHE_MODE_DEFAULT_CACHE = 0,
+   MTL_CPU_CACHE_MODE_WRITE_COMBINED = 1,
+};
+
+enum mtl_storage_mode {
+   MTL_STORAGE_MODE_SHARED = 0,
+   MTL_STORAGE_MODE_MANAGED = 1,
+   MTL_STORAGE_MODE_PRIVATE = 2,
+   MTL_STORAGE_MODE_MEMORYLESS = 3,
+};
+
+enum mtl_hazard_tracking_mode {
+   MTL_HAZARD_TRACKING_MODE_DFEAULT = 0,
+   MTL_HAZARD_TRACKING_MODE_UNTRACKED = 1,
+   MTL_HAZARD_TRACKING_MODE_TRACKED = 2,
+};
+
+#define MTL_RESOURCE_CPU_CACHE_MODE_SHIFT       0
+#define MTL_RESOURCE_STORAGE_MODE_SHIFT         4
+#define MTL_RESOURCE_HAZARD_TRACKING_MODE_SHIFT 8
+enum mtl_resource_options {
+   MTL_RESOURCE_CPU_CACHE_MODE_DEFAULT_CACHE =
+      MTL_CPU_CACHE_MODE_DEFAULT_CACHE << MTL_RESOURCE_CPU_CACHE_MODE_SHIFT,
+   MTL_RESOURCE_CPU_CACHE_MODE_WRITE_COMBINED =
+      MTL_CPU_CACHE_MODE_WRITE_COMBINED << MTL_RESOURCE_CPU_CACHE_MODE_SHIFT,
+   MTL_RESOURCE_STORAGE_MODE_SHARED = MTL_STORAGE_MODE_SHARED
+                                      << MTL_RESOURCE_STORAGE_MODE_SHIFT,
+   MTL_RESOURCE_STORAGE_MODE_PRIVATE = MTL_STORAGE_MODE_PRIVATE
+                                       << MTL_RESOURCE_STORAGE_MODE_SHIFT,
+   MTL_RESOURCE_TRACKING_MODE_DEFAULT =
+      MTL_HAZARD_TRACKING_MODE_DFEAULT
+      << MTL_RESOURCE_HAZARD_TRACKING_MODE_SHIFT,
+   MTL_RESOURCE_TRACKING_MODE_UNTRACKED =
+      MTL_HAZARD_TRACKING_MODE_UNTRACKED
+      << MTL_RESOURCE_HAZARD_TRACKING_MODE_SHIFT,
+   MTL_RESOURCE_TRACKING_MODE_TRACKED =
+      MTL_HAZARD_TRACKING_MODE_TRACKED
+      << MTL_RESOURCE_HAZARD_TRACKING_MODE_SHIFT,
+};
+
+enum mtl_blit_options {
+   MTL_BLIT_OPTION_NONE = 0,
+   MTL_BLIT_OPTION_DEPTH_FROM_DEPTH_STENCIL = 1 << 0,
+   MTL_BLIT_OPTION_STENCIL_FROM_DEPTH_STENCIL = 1 << 1,
+};
+
+enum mtl_resource_usage {
+   MTL_RESOURCE_USAGE_READ = 1 << 0,
+   MTL_RESOURCE_USAGE_WRITE = 1 << 1,
+};
+
+enum mtl_primitive_type {
+   MTL_PRIMITIVE_TYPE_POINT = 0,
+   MTL_PRIMITIVE_TYPE_LINE = 1,
+   MTL_PRIMITIVE_TYPE_LINE_STRIP = 2,
+   MTL_PRIMITIVE_TYPE_TRIANGLE = 3,
+   MTL_PRIMITIVE_TYPE_TRIANGLE_STRIP = 4,
+};
+
+enum mtl_primitive_topology_class {
+   MTL_PRIMITIVE_TOPOLOGY_CLASS_UNSPECIFIED = 0,
+   MTL_PRIMITIVE_TOPOLOGY_CLASS_POINT = 1,
+   MTL_PRIMITIVE_TOPOLOGY_CLASS_LINE = 2,
+   MTL_PRIMITIVE_TOPOLOGY_CLASS_TRIANGLE = 3,
+};
+
+enum mtl_texture_type {
+   MTL_TEXTURE_TYPE_1D = 0u,
+   MTL_TEXTURE_TYPE_1D_ARRAY = 1u,
+   MTL_TEXTURE_TYPE_2D = 2u,
+   MTL_TEXTURE_TYPE_2D_ARRAY = 3u,
+   MTL_TEXTURE_TYPE_2D_MULTISAMPLE = 4u,
+   MTL_TEXTURE_TYPE_CUBE = 5u,
+   MTL_TEXTURE_TYPE_CUBE_ARRAY = 6u,
+   MTL_TEXTURE_TYPE_3D = 7u,
+   MTL_TEXTURE_TYPE_2D_ARRAY_MULTISAMPLE = 8u,
+   MTL_TEXTURE_TYPE_TEXTURE_BUFFER = 9u,
+};
+
+enum mtl_texture_usage {
+   MTL_TEXTURE_USAGE_UNKNOWN = 0x0000,
+   MTL_TEXTURE_USAGE_SHADER_READ = 0x0001,
+   MTL_TEXTURE_USAGE_SHADER_WRITE = 0X0002,
+   MTL_TEXTURE_USAGE_RENDER_TARGET = 0X0004,
+   MTL_TEXTURE_USAGE_PIXEL_FORMAT_VIEW = 0X0010,
+   MTL_TEXTURE_USAGE_SHADER_ATOMIC = 0X0020,
+};
+
+enum mtl_load_action {
+   MTL_LOAD_ACTION_DONT_CARE = 0u,
+   MTL_LOAD_ACTION_LOAD = 1u,
+   MTL_LOAD_ACTION_CLEAR = 2u,
+};
+
+enum mtl_store_action {
+   MTL_STORE_ACTION_DONT_CARE = 0u,
+   MTL_STORE_ACTION_STORE = 1u,
+   MTL_STORE_ACTION_MULTISAMPLE_RESOLVE = 2u,
+   MTL_STORE_ACTION_STORE_AND_MULTISAMPLE_RESOLVE = 3u,
+   MTL_STORE_ACTION_UNKNOWN = 4u,
+   MTL_STORE_ACTION_CUSTOM_SAMPLE_DEPTH_STORE = 5u,
+};
+
+enum mtl_texture_swizzle {
+   MTL_TEXTURE_SWIZZLE_ZERO = 0,
+   MTL_TEXTURE_SWIZZLE_ONE = 1,
+   MTL_TEXTURE_SWIZZLE_RED = 2,
+   MTL_TEXTURE_SWIZZLE_GREEN = 3,
+   MTL_TEXTURE_SWIZZLE_BLUE = 4,
+   MTL_TEXTURE_SWIZZLE_ALPHA = 5,
+};
+
+enum mtl_index_type {
+   MTL_INDEX_TYPE_UINT16 = 0,
+   MTL_INDEX_TYPE_UINT32 = 1,
+};
+
+enum mtl_sampler_address_mode {
+   MTL_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 0,
+   MTL_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 1,
+   MTL_SAMPLER_ADDRESS_MODE_REPEAT = 2,
+   MTL_SAMPLER_ADDRESS_MODE_MIRROR_REPEAT = 3,
+   MTL_SAMPLER_ADDRESS_MODE_CLAMP_TO_ZERO = 4,
+   MTL_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER_COLOR = 5,
+};
+
+enum mtl_sampler_border_color {
+   MTL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK = 0,
+   MTL_SAMPLER_BORDER_COLOR_OPAQUE_BLACK = 1,
+   MTL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE = 2,
+};
+
+enum mtl_sampler_min_mag_filter {
+   MTL_SAMPLER_MIN_MAG_FILTER_NEAREST = 0,
+   MTL_SAMPLER_MIN_MAG_FILTER_LINEAR = 1,
+};
+
+enum mtl_sampler_mip_filter {
+   MTL_SAMPLER_MIP_FILTER_NOT_MIP_MAPPED = 0,
+   MTL_SAMPLER_MIP_FILTER_NEAREST = 1,
+   MTL_SAMPLER_MIP_FILTER_LINEAR = 2,
+};
+
+enum mtl_compare_function {
+   MTL_COMPARE_FUNCTION_NEVER = 0,
+   MTL_COMPARE_FUNCTION_LESS = 1,
+   MTL_COMPARE_FUNCTION_EQUAL = 2,
+   MTL_COMPARE_FUNCTION_LESS_EQUAL = 3,
+   MTL_COMPARE_FUNCTION_GREATER = 4,
+   MTL_COMPARE_FUNCTION_NOT_EQUAL = 5,
+   MTL_COMPARE_FUNCTION_GREATER_EQUAL = 6,
+   MTL_COMPARE_FUNCTION_ALWAYS = 7,
+};
+
+enum mtl_winding {
+   MTL_WINDING_CLOCKWISE = 0,
+   MTL_WINDING_COUNTER_CLOCKWISE = 1,
+};
+
+enum mtl_cull_mode {
+   MTL_CULL_MODE_NONE = 0,
+   MTL_CULL_MODE_FRONT = 1,
+   MTL_CULL_MODE_BACK = 2,
+};
+
+enum mtl_visibility_result_mode {
+   MTL_VISIBILITY_RESULT_MODE_DISABLED = 0,
+   MTL_VISIBILITY_RESULT_MODE_BOOLEAN = 1,
+   MTL_VISIBILITY_RESULT_MODE_COUNTING = 2,
+};
+
+enum mtl_depth_clip_mode {
+   MTL_DEPTH_CLIP_MODE_CLIP = 0,
+   MTL_DEPTH_CLIP_MODE_CLAMP = 1,
+};
+
+/** STRUCTURES */
+struct mtl_range {
+   size_t offset;
+   size_t length;
+};
+
+struct mtl_origin {
+   size_t x, y, z;
+};
+
+struct mtl_size {
+   size_t x, y, z;
+};
+
+struct mtl_viewport {
+   double originX, originY, width, height, znear, zfar;
+};
+
+struct mtl_clear_color {
+   union {
+      struct {
+         double red, green, blue, alpha;
+      };
+      double channel[4];
+   };
+};
+
+struct mtl_scissor_rect {
+   size_t x, y, width, height;
+};
+
+struct mtl_texture_swizzle_channels {
+   enum mtl_texture_swizzle red;
+   enum mtl_texture_swizzle green;
+   enum mtl_texture_swizzle blue;
+   enum mtl_texture_swizzle alpha;
+};
+
+struct mtl_buffer_image_copy {
+   struct mtl_size image_size;
+   struct mtl_origin image_origin;
+   mtl_buffer *buffer;
+   mtl_texture *image;
+   size_t buffer_offset_B;
+   size_t buffer_stride_B;
+   size_t buffer_2d_image_size_B;
+   size_t image_slice;
+   size_t image_level;
+   enum mtl_blit_options options;
+};
+
+#endif /* KK_MTL_TYPES_H */
diff --git a/src/kosmickrisp/bridge/stubs/mtl_bridge.c b/src/kosmickrisp/bridge/stubs/mtl_bridge.c
new file mode 100644
index 00000000000..10628fcf89c
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_bridge.c
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_bridge.h"
+
+mtl_texture *
+mtl_drawable_get_texture(void *drawable_ptr)
+{
+   return NULL;
+}
+
+void *
+mtl_retain(void *handle)
+{
+   return NULL;
+}
+
+void
+mtl_release(void *handle)
+{
+}
diff --git a/src/kosmickrisp/bridge/stubs/mtl_buffer.c b/src/kosmickrisp/bridge/stubs/mtl_buffer.c
new file mode 100644
index 00000000000..ee98a5c88e2
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_buffer.c
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_buffer.h"
+
+uint64_t
+mtl_buffer_get_length(mtl_buffer *buffer)
+{
+   return 0u;
+}
+
+uint64_t
+mtl_buffer_get_gpu_address(mtl_buffer *buffer)
+{
+   return 0u;
+}
+
+void *
+mtl_get_contents(mtl_buffer *buffer)
+{
+   return NULL;
+}
+
+mtl_texture *
+mtl_new_texture_with_descriptor_linear(mtl_buffer *buffer,
+                                       const struct kk_image_layout *layout,
+                                       uint64_t offset)
+{
+   return NULL;
+}
diff --git a/src/kosmickrisp/bridge/stubs/mtl_command_buffer.c b/src/kosmickrisp/bridge/stubs/mtl_command_buffer.c
new file mode 100644
index 00000000000..ff36e37aa9d
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_command_buffer.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_command_buffer.h"
+
+void
+mtl_encode_signal_event(mtl_command_buffer *cmd_buf_handle,
+                        mtl_event *event_handle, uint64_t value)
+{
+}
+
+void
+mtl_encode_wait_for_event(mtl_command_buffer *cmd_buf_handle,
+                          mtl_event *event_handle, uint64_t value)
+{
+}
+
+void
+mtl_add_completed_handler(mtl_command_buffer *cmd, void (*callback)(void *data),
+                          void *data)
+{
+}
+
+void
+mtl_command_buffer_commit(mtl_command_buffer *cmd_buf)
+{
+}
+
+void
+mtl_present_drawable(mtl_command_buffer *cmd_buf, void *drawable)
+{
+}
\ No newline at end of file
diff --git a/src/kosmickrisp/bridge/stubs/mtl_command_queue.c b/src/kosmickrisp/bridge/stubs/mtl_command_queue.c
new file mode 100644
index 00000000000..aa39a3446ee
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_command_queue.c
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_command_queue.h"
+
+mtl_command_queue *
+mtl_new_command_queue(mtl_device *device, uint32_t cmd_buffer_count)
+{
+   return NULL;
+}
+
+mtl_command_buffer *
+mtl_new_command_buffer(mtl_command_queue *cmd_queue)
+{
+   return NULL;
+}
diff --git a/src/kosmickrisp/bridge/stubs/mtl_compute_state.c b/src/kosmickrisp/bridge/stubs/mtl_compute_state.c
new file mode 100644
index 00000000000..f7a8a6aa26f
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_compute_state.c
@@ -0,0 +1,14 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_compute_state.h"
+
+mtl_compute_pipeline_state *
+mtl_new_compute_pipeline_state(mtl_device *device, mtl_function *function,
+                               uint64_t max_total_threads_per_threadgroup)
+{
+   return NULL;
+}
diff --git a/src/kosmickrisp/bridge/stubs/mtl_device.c b/src/kosmickrisp/bridge/stubs/mtl_device.c
new file mode 100644
index 00000000000..78e22e30c12
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_device.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_device.h"
+
+/* Device creation */
+mtl_device *
+mtl_device_create(void)
+{
+   return NULL;
+}
+
+/* Device operations */
+void
+mtl_start_gpu_capture(mtl_device *mtl_dev_handle)
+{
+}
+
+void
+mtl_stop_gpu_capture(void)
+{
+}
+
+/* Device feature query */
+void
+mtl_device_get_name(mtl_device *dev, char buffer[256])
+{
+}
+
+void
+mtl_device_get_architecture_name(mtl_device *dev, char buffer[256])
+{
+}
+
+uint64_t
+mtl_device_get_peer_group_id(mtl_device *dev)
+{
+   return 0u;
+}
+
+uint32_t
+mtl_device_get_peer_index(mtl_device *dev)
+{
+   return 0u;
+}
+
+uint64_t
+mtl_device_get_registry_id(mtl_device *dev)
+{
+   return 0u;
+}
+
+struct mtl_size
+mtl_device_max_threads_per_threadgroup(mtl_device *dev)
+{
+   return (struct mtl_size){};
+}
+
+/* Resource queries */
+void
+mtl_heap_buffer_size_and_align_with_length(mtl_device *device, uint64_t *size_B,
+                                           uint64_t *align_B)
+{
+}
+
+void
+mtl_heap_texture_size_and_align_with_descriptor(mtl_device *device,
+                                                struct kk_image_layout *layout)
+{
+}
diff --git a/src/kosmickrisp/bridge/stubs/mtl_encoder.c b/src/kosmickrisp/bridge/stubs/mtl_encoder.c
new file mode 100644
index 00000000000..672e628c1dc
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_encoder.c
@@ -0,0 +1,273 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_encoder.h"
+
+/* Common encoder utils */
+void
+mtl_end_encoding(void *encoder)
+{
+}
+
+/* MTLBlitEncoder */
+mtl_blit_encoder *
+mtl_new_blit_command_encoder(mtl_command_buffer *cmd_buffer)
+{
+   return NULL;
+}
+
+void
+mtl_blit_update_fence(mtl_blit_encoder *encoder, mtl_fence *fence)
+{
+}
+
+void
+mtl_blit_wait_for_fence(mtl_blit_encoder *encoder, mtl_fence *fence)
+{
+}
+
+void
+mtl_copy_from_buffer_to_buffer(mtl_blit_encoder *blit_enc_handle,
+                               mtl_buffer *src_buf, size_t src_offset,
+                               mtl_buffer *dst_buf, size_t dst_offset,
+                               size_t size)
+{
+}
+
+void
+mtl_copy_from_buffer_to_texture(mtl_blit_encoder *blit_enc_handle,
+                                struct mtl_buffer_image_copy *data)
+{
+}
+
+void
+mtl_copy_from_texture_to_buffer(mtl_blit_encoder *blit_enc_handle,
+                                struct mtl_buffer_image_copy *data)
+{
+}
+
+void
+mtl_copy_from_texture_to_texture(mtl_blit_encoder *blit_enc_handle,
+                                 mtl_texture *src_tex_handle, size_t src_slice,
+                                 size_t src_level, struct mtl_origin src_origin,
+                                 struct mtl_size src_size,
+                                 mtl_texture *dst_tex_handle, size_t dst_slice,
+                                 size_t dst_level, struct mtl_origin dst_origin)
+{
+}
+
+/* MTLComputeEncoder */
+mtl_compute_encoder *
+mtl_new_compute_command_encoder(mtl_command_buffer *cmd_buffer)
+{
+   return NULL;
+}
+
+void
+mtl_compute_update_fence(mtl_compute_encoder *encoder, mtl_fence *fence)
+{
+}
+
+void
+mtl_compute_wait_for_fence(mtl_compute_encoder *encoder, mtl_fence *fence)
+{
+}
+
+void
+mtl_compute_set_pipeline_state(mtl_compute_encoder *encoder,
+                               mtl_compute_pipeline_state *state_handle)
+{
+}
+
+void
+mtl_compute_set_buffer(mtl_compute_encoder *encoder, mtl_buffer *buffer,
+                       size_t offset, size_t index)
+{
+}
+
+void
+mtl_compute_use_resource(mtl_compute_encoder *encoder, mtl_resource *res_handle,
+                         uint32_t usage)
+{
+}
+
+void
+mtl_compute_use_resources(mtl_compute_encoder *encoder,
+                          mtl_resource **resource_handles, uint32_t count,
+                          enum mtl_resource_usage usage)
+{
+}
+
+void
+mtl_compute_use_heaps(mtl_compute_encoder *encoder, mtl_heap **heaps,
+                      uint32_t count)
+{
+}
+
+void
+mtl_dispatch_threads(mtl_compute_encoder *encoder, struct mtl_size grid_size,
+                     struct mtl_size local_size)
+{
+}
+
+void
+mtl_dispatch_threadgroups_with_indirect_buffer(mtl_compute_encoder *encoder,
+                                               mtl_buffer *buffer,
+                                               uint32_t offset,
+                                               struct mtl_size local_size)
+{
+}
+
+/* MTLRenderEncoder */
+mtl_render_encoder *
+mtl_new_render_command_encoder_with_descriptor(
+   mtl_command_buffer *command_buffer, mtl_render_pass_descriptor *descriptor)
+{
+   return NULL;
+}
+
+void
+mtl_render_update_fence(mtl_render_encoder *encoder, mtl_fence *fence)
+{
+}
+
+void
+mtl_render_wait_for_fence(mtl_render_encoder *encoder, mtl_fence *fence)
+{
+}
+
+void
+mtl_set_viewports(mtl_render_encoder *encoder, struct mtl_viewport *viewports,
+                  uint32_t count)
+{
+}
+
+void
+mtl_set_scissor_rects(mtl_render_encoder *encoder,
+                      struct mtl_scissor_rect *scissor_rects, uint32_t count)
+{
+}
+
+void
+mtl_render_set_pipeline_state(mtl_render_encoder *encoder,
+                              mtl_render_pipeline_state *pipeline)
+{
+}
+
+void
+mtl_set_depth_stencil_state(mtl_render_encoder *encoder,
+                            mtl_depth_stencil_state *state)
+{
+}
+
+void
+mtl_set_stencil_references(mtl_render_encoder *encoder, uint32_t front,
+                           uint32_t back)
+{
+}
+
+void
+mtl_set_front_face_winding(mtl_render_encoder *encoder,
+                           enum mtl_winding winding)
+{
+}
+
+void
+mtl_set_cull_mode(mtl_render_encoder *encoder, enum mtl_cull_mode mode)
+{
+}
+
+void
+mtl_set_visibility_result_mode(mtl_render_encoder *encoder,
+                               enum mtl_visibility_result_mode mode,
+                               size_t offset)
+{
+}
+
+void
+mtl_set_depth_bias(mtl_render_encoder *encoder, float depth_bias,
+                   float slope_scale, float clamp)
+{
+}
+
+void
+mtl_set_depth_clip_mode(mtl_render_encoder *encoder,
+                        enum mtl_depth_clip_mode mode)
+{
+}
+
+void
+mtl_set_vertex_amplification_count(mtl_render_encoder *encoder,
+                                   uint32_t *layer_ids, uint32_t id_count)
+{
+}
+
+void
+mtl_set_vertex_buffer(mtl_render_encoder *encoder, mtl_buffer *buffer,
+                      uint32_t offset, uint32_t index)
+{
+}
+
+void
+mtl_set_fragment_buffer(mtl_render_encoder *encoder, mtl_buffer *buffer,
+                        uint32_t offset, uint32_t index)
+{
+}
+
+void
+mtl_draw_primitives(mtl_render_encoder *encoder,
+                    enum mtl_primitive_type primitve_type, uint32_t vertexStart,
+                    uint32_t vertexCount, uint32_t instanceCount,
+                    uint32_t baseInstance)
+{
+}
+
+void
+mtl_draw_indexed_primitives(
+   mtl_render_encoder *encoder, enum mtl_primitive_type primitve_type,
+   uint32_t index_count, enum mtl_index_type index_type,
+   mtl_buffer *index_buffer, uint32_t index_buffer_offset,
+   uint32_t instance_count, int32_t base_vertex, uint32_t base_instance)
+{
+}
+
+void
+mtl_draw_primitives_indirect(mtl_render_encoder *encoder,
+                             enum mtl_primitive_type primitve_type,
+                             mtl_buffer *indirect_buffer,
+                             uint64_t indirect_buffer_offset)
+{
+}
+
+void
+mtl_draw_indexed_primitives_indirect(mtl_render_encoder *encoder,
+                                     enum mtl_primitive_type primitve_type,
+                                     enum mtl_index_type index_type,
+                                     mtl_buffer *index_buffer,
+                                     uint32_t index_buffer_offset,
+                                     mtl_buffer *indirect_buffer,
+                                     uint64_t indirect_buffer_offset)
+{
+}
+
+void
+mtl_render_use_resource(mtl_compute_encoder *encoder, mtl_resource *res_handle,
+                        uint32_t usage)
+{
+}
+
+void
+mtl_render_use_resources(mtl_render_encoder *encoder,
+                         mtl_resource **resource_handles, uint32_t count,
+                         enum mtl_resource_usage usage)
+{
+}
+
+void
+mtl_render_use_heaps(mtl_render_encoder *encoder, mtl_heap **heaps,
+                     uint32_t count)
+{
+}
diff --git a/src/kosmickrisp/bridge/stubs/mtl_heap.c b/src/kosmickrisp/bridge/stubs/mtl_heap.c
new file mode 100644
index 00000000000..de916c4d76c
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_heap.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_heap.h"
+
+/* Creation */
+mtl_heap *
+mtl_new_heap(mtl_device *device, uint64_t size,
+             enum mtl_resource_options resource_options)
+{
+   return NULL;
+}
+
+/* Utils */
+uint64_t
+mtl_heap_get_size(mtl_heap *heap)
+{
+   return 0u;
+}
+
+/* Allocation from heap */
+mtl_buffer *
+mtl_new_buffer_with_length(mtl_heap *heap, uint64_t size_B, uint64_t offset_B)
+{
+   return NULL;
+}
+
+mtl_texture *
+mtl_new_texture_with_descriptor(mtl_heap *heap,
+                                const struct kk_image_layout *layout,
+                                uint64_t offset)
+{
+   return NULL;
+}
diff --git a/src/kosmickrisp/bridge/stubs/mtl_library.c b/src/kosmickrisp/bridge/stubs/mtl_library.c
new file mode 100644
index 00000000000..dcd41781e8b
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_library.c
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_library.h"
+
+mtl_library *
+mtl_new_library(mtl_device *device, const char *src)
+{
+   return NULL;
+}
+
+mtl_function *
+mtl_new_function_with_name(mtl_library *lib, const char *entry_point)
+{
+   return NULL;
+}
diff --git a/src/kosmickrisp/bridge/stubs/mtl_render_state.c b/src/kosmickrisp/bridge/stubs/mtl_render_state.c
new file mode 100644
index 00000000000..e971c5e460f
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_render_state.c
@@ -0,0 +1,288 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_render_state.h"
+
+#include "mtl_format.h"
+
+/* TODO_KOSMICKRISP Remove */
+#include "vulkan/vulkan.h"
+
+/* Render pass descriptor */
+mtl_render_pass_descriptor *
+mtl_new_render_pass_descriptor(void)
+{
+   return NULL;
+}
+
+mtl_render_pass_attachment_descriptor *
+mtl_render_pass_descriptor_get_color_attachment(
+   mtl_render_pass_descriptor *descriptor, uint32_t index)
+{
+   return NULL;
+}
+
+mtl_render_pass_attachment_descriptor *
+mtl_render_pass_descriptor_get_depth_attachment(
+   mtl_render_pass_descriptor *descriptor)
+{
+   return NULL;
+}
+
+mtl_render_pass_attachment_descriptor *
+mtl_render_pass_descriptor_get_stencil_attachment(
+   mtl_render_pass_descriptor *descriptor)
+{
+   return NULL;
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_texture(
+   mtl_render_pass_attachment_descriptor *descriptor, mtl_texture *texture)
+{
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_level(
+   mtl_render_pass_attachment_descriptor *descriptor, uint32_t level)
+{
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_slice(
+   mtl_render_pass_attachment_descriptor *descriptor, uint32_t slice)
+{
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_load_action(
+   mtl_render_pass_attachment_descriptor *descriptor,
+   enum mtl_load_action action)
+{
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_store_action(
+   mtl_render_pass_attachment_descriptor *descriptor,
+   enum mtl_store_action action)
+{
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_clear_color(
+   mtl_render_pass_attachment_descriptor *descriptor,
+   struct mtl_clear_color clear_color)
+{
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_clear_depth(
+   mtl_render_pass_attachment_descriptor *descriptor, double depth)
+{
+}
+
+void
+mtl_render_pass_attachment_descriptor_set_clear_stencil(
+   mtl_render_pass_attachment_descriptor *descriptor, uint32_t stencil)
+{
+}
+
+void
+mtl_render_pass_descriptor_set_render_target_array_length(
+   mtl_render_pass_descriptor *descriptor, uint32_t length)
+{
+}
+
+void
+mtl_render_pass_descriptor_set_render_target_width(
+   mtl_render_pass_descriptor *descriptor, uint32_t width)
+{
+}
+
+void
+mtl_render_pass_descriptor_set_render_target_height(
+   mtl_render_pass_descriptor *descriptor, uint32_t height)
+{
+}
+
+void
+mtl_render_pass_descriptor_set_default_raster_sample_count(
+   mtl_render_pass_descriptor *descriptor, uint32_t sample_count)
+{
+}
+
+void
+mtl_render_pass_descriptor_set_visibility_buffer(
+   mtl_render_pass_descriptor *descriptor, mtl_buffer *visibility_buffer)
+{
+}
+
+/* Render pipeline descriptor */
+mtl_render_pipeline_descriptor *
+mtl_new_render_pipeline_descriptor(void)
+{
+   return NULL;
+}
+
+void
+mtl_render_pipeline_descriptor_set_vertex_shader(
+   mtl_render_pass_descriptor *descriptor, mtl_function *shader)
+{
+}
+
+void
+mtl_render_pipeline_descriptor_set_fragment_shader(
+   mtl_render_pass_descriptor *descriptor, mtl_function *shader)
+{
+}
+
+void
+mtl_render_pipeline_descriptor_set_input_primitive_topology(
+   mtl_render_pass_descriptor *descriptor,
+   enum mtl_primitive_topology_class topology_class)
+{
+}
+
+void
+mtl_render_pipeline_descriptor_set_color_attachment_format(
+   mtl_render_pass_descriptor *descriptor, uint8_t index,
+   enum mtl_pixel_format format)
+{
+}
+
+void
+mtl_render_pipeline_descriptor_set_depth_attachment_format(
+   mtl_render_pass_descriptor *descriptor, enum mtl_pixel_format format)
+{
+}
+
+void
+mtl_render_pipeline_descriptor_set_stencil_attachment_format(
+   mtl_render_pass_descriptor *descriptor, enum mtl_pixel_format format)
+{
+}
+
+void
+mtl_render_pipeline_descriptor_set_raster_sample_count(
+   mtl_render_pass_descriptor *descriptor, uint32_t sample_count)
+{
+}
+
+void
+mtl_render_pipeline_descriptor_set_alpha_to_coverage(
+   mtl_render_pass_descriptor *descriptor, bool enabled)
+{
+}
+
+void
+mtl_render_pipeline_descriptor_set_alpha_to_one(
+   mtl_render_pass_descriptor *descriptor, bool enabled)
+{
+}
+
+void
+mtl_render_pipeline_descriptor_set_rasterization_enabled(
+   mtl_render_pass_descriptor *descriptor, bool enabled)
+{
+}
+
+void
+mtl_render_pipeline_descriptor_set_max_vertex_amplification_count(
+   mtl_render_pass_descriptor *descriptor, uint32_t count)
+{
+}
+
+/* Render pipeline */
+mtl_render_pipeline_state *
+mtl_new_render_pipeline(mtl_device *device,
+                        mtl_render_pass_descriptor *descriptor)
+{
+   return NULL;
+}
+
+/* Stencil descriptor */
+mtl_stencil_descriptor *
+mtl_new_stencil_descriptor(void)
+{
+   return NULL;
+}
+
+void
+mtl_stencil_descriptor_set_stencil_failure_operation(
+   mtl_stencil_descriptor *descriptor, enum VkStencilOp op)
+{
+}
+
+void
+mtl_stencil_descriptor_set_depth_failure_operation(
+   mtl_stencil_descriptor *descriptor, enum VkStencilOp op)
+{
+}
+
+void
+mtl_stencil_descriptor_set_depth_stencil_pass_operation(
+   mtl_stencil_descriptor *descriptor, enum VkStencilOp op)
+{
+}
+
+void
+mtl_stencil_descriptor_set_stencil_compare_function(
+   mtl_stencil_descriptor *descriptor, enum VkCompareOp op)
+{
+}
+
+void
+mtl_stencil_descriptor_set_read_mask(mtl_stencil_descriptor *descriptor,
+                                     uint32_t mask)
+{
+}
+
+void
+mtl_stencil_descriptor_set_write_mask(mtl_stencil_descriptor *descriptor,
+                                      uint32_t mask)
+{
+}
+
+/* Depth stencil descriptor */
+mtl_depth_stencil_descriptor *
+mtl_new_depth_stencil_descriptor(void)
+{
+   return NULL;
+}
+
+void
+mtl_depth_stencil_descriptor_set_depth_compare_function(
+   mtl_depth_stencil_descriptor *descriptor, enum VkCompareOp op)
+{
+}
+
+void
+mtl_depth_stencil_descriptor_set_depth_write_enabled(
+   mtl_depth_stencil_descriptor *descriptor, bool enable_write)
+{
+}
+
+void
+mtl_depth_stencil_descriptor_set_back_face_stencil(
+   mtl_depth_stencil_descriptor *descriptor,
+   mtl_stencil_descriptor *stencil_descriptor)
+{
+}
+
+void
+mtl_depth_stencil_descriptor_set_front_face_stencil(
+   mtl_depth_stencil_descriptor *descriptor,
+   mtl_stencil_descriptor *stencil_descriptor)
+{
+}
+
+/* Depth stencil state */
+mtl_depth_stencil_state *
+mtl_new_depth_stencil_state(mtl_device *device,
+                            mtl_depth_stencil_descriptor *descriptor)
+{
+   return NULL;
+}
diff --git a/src/kosmickrisp/bridge/stubs/mtl_sampler.c b/src/kosmickrisp/bridge/stubs/mtl_sampler.c
new file mode 100644
index 00000000000..a3530b38440
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_sampler.c
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_sampler.h"
+
+/* Sampler descriptor */
+mtl_sampler_descriptor *
+mtl_new_sampler_descriptor(void)
+{
+   return NULL;
+}
+
+/* Sampler descriptor utils */
+void
+mtl_sampler_descriptor_set_normalized_coordinates(
+   mtl_sampler_descriptor *descriptor, bool normalized_coordinates)
+{
+}
+
+void
+mtl_sampler_descriptor_set_address_mode(
+   mtl_sampler_descriptor *descriptor,
+   enum mtl_sampler_address_mode address_mode_u,
+   enum mtl_sampler_address_mode address_mode_v,
+   enum mtl_sampler_address_mode address_mode_w)
+{
+}
+
+void
+mtl_sampler_descriptor_set_border_color(mtl_sampler_descriptor *descriptor,
+                                        enum mtl_sampler_border_color color)
+{
+}
+void
+mtl_sampler_descriptor_set_filters(mtl_sampler_descriptor *descriptor,
+                                   enum mtl_sampler_min_mag_filter min_filter,
+                                   enum mtl_sampler_min_mag_filter mag_filter,
+                                   enum mtl_sampler_mip_filter mip_filter)
+{
+}
+
+void
+mtl_sampler_descriptor_set_lod_clamp(mtl_sampler_descriptor *descriptor,
+                                     float min, float max)
+{
+}
+
+void
+mtl_sampler_descriptor_set_max_anisotropy(mtl_sampler_descriptor *descriptor,
+                                          uint64_t max)
+{
+}
+void
+mtl_sampler_descriptor_set_compare_function(mtl_sampler_descriptor *descriptor,
+                                            enum mtl_compare_function function)
+{
+}
+
+/* Sampler */
+mtl_sampler *
+mtl_new_sampler(mtl_device *device, mtl_sampler_descriptor *descriptor)
+{
+   return NULL;
+}
+
+/* Sampler utils */
+uint64_t
+mtl_sampler_get_gpu_resource_id(mtl_sampler *sampler)
+{
+   return 0u;
+}
diff --git a/src/kosmickrisp/bridge/stubs/mtl_sync.c b/src/kosmickrisp/bridge/stubs/mtl_sync.c
new file mode 100644
index 00000000000..0d4e1a8512e
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_sync.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_sync.h"
+
+/* MTLFence */
+mtl_fence *
+mtl_new_fence(mtl_device *device)
+{
+   return NULL;
+}
+
+/* MTLEvent */
+mtl_event *
+mtl_new_event(mtl_device *device)
+{
+   return NULL;
+}
+
+/* MTLSharedEvent */
+mtl_shared_event *
+mtl_new_shared_event(mtl_device *device)
+{
+   return NULL;
+}
+
+int
+mtl_shared_event_wait_until_signaled_value(mtl_shared_event *event_handle,
+                                           uint64_t value, uint64_t timeout_ms)
+{
+   return 0;
+}
+
+uint64_t
+mtl_shared_event_get_signaled_value(mtl_shared_event *event_handle)
+{
+   return 0u;
+}
+
+void
+mtl_shared_event_set_signaled_value(mtl_shared_event *event_handle,
+                                    uint64_t value)
+{
+}
diff --git a/src/kosmickrisp/bridge/stubs/mtl_texture.c b/src/kosmickrisp/bridge/stubs/mtl_texture.c
new file mode 100644
index 00000000000..8ed3b22ec95
--- /dev/null
+++ b/src/kosmickrisp/bridge/stubs/mtl_texture.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "mtl_texture.h"
+
+/* Utils*/
+uint64_t
+mtl_texture_get_gpu_resource_id(mtl_texture *texture)
+{
+   return 0u;
+}
+
+/* Texture view creation */
+mtl_texture *
+mtl_new_texture_view_with(mtl_texture *texture,
+                          const struct kk_view_layout *layout)
+{
+   return NULL;
+}
+
+mtl_texture *
+mtl_new_texture_view_with_no_swizzle(mtl_texture *texture,
+                                     const struct kk_view_layout *layout)
+{
+   return NULL;
+}
diff --git a/src/kosmickrisp/bridge/vk_to_mtl_map.c b/src/kosmickrisp/bridge/vk_to_mtl_map.c
new file mode 100644
index 00000000000..ef586dc09a0
--- /dev/null
+++ b/src/kosmickrisp/bridge/vk_to_mtl_map.c
@@ -0,0 +1,251 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "vk_to_mtl_map.h"
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "util/format/u_format.h"
+
+#include "vulkan/vulkan.h"
+#include "vk_meta.h"
+
+struct mtl_origin
+vk_offset_3d_to_mtl_origin(const struct VkOffset3D *offset)
+{
+   struct mtl_origin ret = {
+      .x = offset->x,
+      .y = offset->y,
+      .z = offset->z,
+   };
+   return ret;
+}
+
+struct mtl_size
+vk_extent_3d_to_mtl_size(const struct VkExtent3D *extent)
+{
+   struct mtl_size ret = {
+      .x = extent->width,
+      .y = extent->height,
+      .z = extent->depth,
+   };
+   return ret;
+}
+
+enum mtl_primitive_type
+vk_primitive_topology_to_mtl_primitive_type(enum VkPrimitiveTopology topology)
+{
+   switch (topology) {
+   case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
+      return MTL_PRIMITIVE_TYPE_POINT;
+   case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
+      return MTL_PRIMITIVE_TYPE_LINE;
+   case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
+      return MTL_PRIMITIVE_TYPE_LINE_STRIP;
+   case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wswitch"
+   case VK_PRIMITIVE_TOPOLOGY_META_RECT_LIST_MESA:
+#pragma GCC diagnostic pop
+      /* Triangle fans are emulated meaning we'll translate the index buffer to
+       * triangle list or generate a index buffer if there's none */
+   case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
+      return MTL_PRIMITIVE_TYPE_TRIANGLE;
+   case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
+      return MTL_PRIMITIVE_TYPE_TRIANGLE_STRIP;
+   default:
+      assert(0 && "Primitive topology not supported!");
+      return 0;
+   }
+}
+
+enum mtl_primitive_topology_class
+vk_primitive_topology_to_mtl_primitive_topology_class(
+   enum VkPrimitiveTopology topology)
+{
+   switch (topology) {
+   case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
+      return MTL_PRIMITIVE_TOPOLOGY_CLASS_POINT;
+   case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
+   case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
+      return MTL_PRIMITIVE_TOPOLOGY_CLASS_LINE;
+   case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
+   case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wswitch"
+   case VK_PRIMITIVE_TOPOLOGY_META_RECT_LIST_MESA:
+#pragma GCC diagnostic pop
+      return MTL_PRIMITIVE_TOPOLOGY_CLASS_TRIANGLE;
+   default:
+      return MTL_PRIMITIVE_TOPOLOGY_CLASS_UNSPECIFIED;
+   }
+}
+
+enum mtl_load_action
+vk_attachment_load_op_to_mtl_load_action(enum VkAttachmentLoadOp op)
+{
+   switch (op) {
+   case VK_ATTACHMENT_LOAD_OP_LOAD:
+      return MTL_LOAD_ACTION_LOAD;
+   case VK_ATTACHMENT_LOAD_OP_CLEAR:
+      return MTL_LOAD_ACTION_CLEAR;
+   case VK_ATTACHMENT_LOAD_OP_DONT_CARE:
+      return MTL_LOAD_ACTION_DONT_CARE;
+   default:
+      assert(false && "Unsupported VkAttachmentLoadOp");
+      return MTL_LOAD_ACTION_DONT_CARE;
+   };
+}
+
+enum mtl_store_action
+vk_attachment_store_op_to_mtl_store_action(enum VkAttachmentStoreOp op)
+{
+   switch (op) {
+   case VK_ATTACHMENT_STORE_OP_STORE:
+      return MTL_STORE_ACTION_STORE;
+   case VK_ATTACHMENT_STORE_OP_DONT_CARE:
+      return MTL_STORE_ACTION_DONT_CARE;
+   case VK_ATTACHMENT_STORE_OP_NONE:
+      return MTL_STORE_ACTION_UNKNOWN;
+   default:
+      assert(false && "Unsupported VkAttachmentStoreOp");
+      return MTL_STORE_ACTION_UNKNOWN;
+   };
+}
+
+enum mtl_sampler_address_mode
+vk_sampler_address_mode_to_mtl_sampler_address_mode(
+   enum VkSamplerAddressMode mode)
+{
+   switch (mode) {
+   case VK_SAMPLER_ADDRESS_MODE_REPEAT:
+      return MTL_SAMPLER_ADDRESS_MODE_REPEAT;
+   case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT:
+      return MTL_SAMPLER_ADDRESS_MODE_MIRROR_REPEAT;
+   case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:
+      return MTL_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+   case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER:
+      return MTL_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER_COLOR;
+   case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE:
+      return MTL_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
+   default:
+      UNREACHABLE("Unsupported address mode");
+   }
+}
+
+enum mtl_sampler_border_color
+vk_border_color_to_mtl_sampler_border_color(enum VkBorderColor color)
+{
+   switch (color) {
+   case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
+   case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
+      return MTL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK;
+   case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
+   case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
+      return MTL_SAMPLER_BORDER_COLOR_OPAQUE_BLACK;
+   case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
+   case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
+      return MTL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE;
+   case VK_BORDER_COLOR_FLOAT_CUSTOM_EXT:
+   case VK_BORDER_COLOR_INT_CUSTOM_EXT:
+      return MTL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE;
+   default:
+      UNREACHABLE("Unsupported address mode");
+   }
+}
+
+enum mtl_sampler_min_mag_filter
+vk_filter_to_mtl_sampler_min_mag_filter(enum VkFilter filter)
+{
+   switch (filter) {
+   case VK_FILTER_NEAREST:
+      return MTL_SAMPLER_MIN_MAG_FILTER_NEAREST;
+   case VK_FILTER_LINEAR:
+      return MTL_SAMPLER_MIN_MAG_FILTER_LINEAR;
+   default:
+      UNREACHABLE("Unsupported address mode");
+   }
+}
+
+enum mtl_sampler_mip_filter
+vk_sampler_mipmap_mode_to_mtl_sampler_mip_filter(enum VkSamplerMipmapMode mode)
+{
+   switch (mode) {
+   case VK_SAMPLER_MIPMAP_MODE_NEAREST:
+      return MTL_SAMPLER_MIP_FILTER_NEAREST;
+   case VK_SAMPLER_MIPMAP_MODE_LINEAR:
+      return MTL_SAMPLER_MIP_FILTER_LINEAR;
+   default:
+      UNREACHABLE("Unsupported address mode");
+   }
+}
+
+enum mtl_compare_function
+vk_compare_op_to_mtl_compare_function(enum VkCompareOp op)
+{
+   switch (op) {
+   case VK_COMPARE_OP_NEVER:
+      return MTL_COMPARE_FUNCTION_NEVER;
+   case VK_COMPARE_OP_LESS:
+      return MTL_COMPARE_FUNCTION_LESS;
+   case VK_COMPARE_OP_EQUAL:
+      return MTL_COMPARE_FUNCTION_EQUAL;
+   case VK_COMPARE_OP_LESS_OR_EQUAL:
+      return MTL_COMPARE_FUNCTION_LESS_EQUAL;
+   case VK_COMPARE_OP_GREATER:
+      return MTL_COMPARE_FUNCTION_GREATER;
+   case VK_COMPARE_OP_NOT_EQUAL:
+      return MTL_COMPARE_FUNCTION_NOT_EQUAL;
+   case VK_COMPARE_OP_GREATER_OR_EQUAL:
+      return MTL_COMPARE_FUNCTION_GREATER_EQUAL;
+   case VK_COMPARE_OP_ALWAYS:
+      return MTL_COMPARE_FUNCTION_ALWAYS;
+   default:
+      UNREACHABLE("Unsupported address mode");
+   }
+}
+
+enum mtl_winding
+vk_front_face_to_mtl_winding(enum VkFrontFace face)
+{
+   switch (face) {
+   case VK_FRONT_FACE_CLOCKWISE:
+      return MTL_WINDING_CLOCKWISE;
+   case VK_FRONT_FACE_COUNTER_CLOCKWISE:
+      return MTL_WINDING_COUNTER_CLOCKWISE;
+   default:
+      assert(false && "Unsupported VkFrontFace");
+      return MTL_WINDING_CLOCKWISE;
+   }
+}
+
+enum mtl_cull_mode
+vk_front_face_to_mtl_cull_mode(enum VkCullModeFlagBits mode)
+{
+   switch (mode) {
+   case VK_CULL_MODE_NONE:
+      return MTL_CULL_MODE_NONE;
+   case VK_CULL_MODE_FRONT_BIT:
+      return MTL_CULL_MODE_FRONT;
+   case VK_CULL_MODE_BACK_BIT:
+      return MTL_CULL_MODE_BACK;
+   default:
+      UNREACHABLE("Unsupported VkCullModeFlags");
+   }
+}
+
+enum mtl_index_type
+index_size_in_bytes_to_mtl_index_type(unsigned bytes)
+{
+   switch (bytes) {
+   case 2u:
+      return MTL_INDEX_TYPE_UINT16;
+   case 4u:
+      return MTL_INDEX_TYPE_UINT32;
+   default:
+      UNREACHABLE("Unsupported byte size for index");
+   }
+}
diff --git a/src/kosmickrisp/bridge/vk_to_mtl_map.h b/src/kosmickrisp/bridge/vk_to_mtl_map.h
new file mode 100644
index 00000000000..23e5506d9a6
--- /dev/null
+++ b/src/kosmickrisp/bridge/vk_to_mtl_map.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+#ifndef KK_MTL_TO_VK_MAP_H
+#define KK_MTL_TO_VK_MAP_H 1
+
+enum pipe_format;
+
+struct mtl_origin;
+struct mtl_size;
+enum mtl_primitive_type;
+enum mtl_primitive_topology_class;
+enum mtl_load_action;
+enum mtl_store_action;
+enum mtl_sampler_address_mode;
+enum mtl_sampler_border_color;
+enum mtl_sampler_min_mag_filter;
+enum mtl_sampler_mip_filter;
+enum mtl_compare_function;
+enum mtl_winding;
+enum mtl_cull_mode;
+enum mtl_index_type;
+
+struct VkOffset3D;
+struct VkExtent3D;
+union VkClearColorValue;
+enum VkPrimitiveTopology;
+enum VkAttachmentLoadOp;
+enum VkAttachmentStoreOp;
+enum VkSamplerAddressMode;
+enum VkBorderColor;
+enum VkFilter;
+enum VkSamplerMipmapMode;
+enum VkCompareOp;
+enum VkFrontFace;
+enum VkCullModeFlagBits;
+
+/* STRUCTS */
+struct mtl_origin vk_offset_3d_to_mtl_origin(const struct VkOffset3D *offset);
+
+struct mtl_size vk_extent_3d_to_mtl_size(const struct VkExtent3D *extent);
+
+/* ENUMS */
+enum mtl_primitive_type
+vk_primitive_topology_to_mtl_primitive_type(enum VkPrimitiveTopology topology);
+
+enum mtl_primitive_topology_class
+vk_primitive_topology_to_mtl_primitive_topology_class(
+   enum VkPrimitiveTopology topology);
+
+enum mtl_load_action
+vk_attachment_load_op_to_mtl_load_action(enum VkAttachmentLoadOp op);
+
+enum mtl_store_action
+vk_attachment_store_op_to_mtl_store_action(enum VkAttachmentStoreOp op);
+
+enum mtl_sampler_address_mode
+vk_sampler_address_mode_to_mtl_sampler_address_mode(
+   enum VkSamplerAddressMode mode);
+
+enum mtl_sampler_border_color
+vk_border_color_to_mtl_sampler_border_color(enum VkBorderColor color);
+
+enum mtl_sampler_min_mag_filter
+vk_filter_to_mtl_sampler_min_mag_filter(enum VkFilter filter);
+
+enum mtl_sampler_mip_filter
+vk_sampler_mipmap_mode_to_mtl_sampler_mip_filter(enum VkSamplerMipmapMode mode);
+
+enum mtl_compare_function
+vk_compare_op_to_mtl_compare_function(enum VkCompareOp op);
+
+enum mtl_winding vk_front_face_to_mtl_winding(enum VkFrontFace face);
+
+enum mtl_cull_mode vk_front_face_to_mtl_cull_mode(enum VkCullModeFlagBits mode);
+
+enum mtl_index_type index_size_in_bytes_to_mtl_index_type(unsigned bytes);
+
+#endif /* KK_MTL_TO_VK_MAP_H */
diff --git a/src/kosmickrisp/compiler/meson.build b/src/kosmickrisp/compiler/meson.build
new file mode 100644
index 00000000000..34fe22245d2
--- /dev/null
+++ b/src/kosmickrisp/compiler/meson.build
@@ -0,0 +1,35 @@
+# Copyright 2025 LunarG, Inc.
+# Copyright 2025 Google LLC
+# SPDX-License-Identifier: MIT
+
+libmsl_compiler_files = files(
+    'nir_to_msl.c',
+    'msl_type_inference.c',
+    'msl_iomap.c',
+    'msl_nir_lower_common.c',
+    'msl_nir_lower_subgroups.c',
+)
+
+msl_nir_algebraic_c = custom_target(
+  input : 'msl_nir_algebraic.py',
+  output : 'msl_nir_algebraic.c',
+  command : [
+    prog_python, '@INPUT@', '-p', dir_compiler_nir,
+  ],
+  capture : true,
+  depend_files : nir_algebraic_depends,
+)
+
+
+libmsl_compiler = static_library(
+    'msl_compiler',
+    [libmsl_compiler_files, msl_nir_algebraic_c],
+    dependencies : [idep_nir, idep_mesautil],
+    gnu_symbol_visibility: 'hidden',
+    build_by_default: false,
+)
+
+idep_msl_to_nir = declare_dependency(
+  link_with : libmsl_compiler,
+)
+
diff --git a/src/kosmickrisp/compiler/msl_iomap.c b/src/kosmickrisp/compiler/msl_iomap.c
new file mode 100644
index 00000000000..aed3f012d29
--- /dev/null
+++ b/src/kosmickrisp/compiler/msl_iomap.c
@@ -0,0 +1,447 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+/* This file primarily concerns itself with mapping from the NIR (and Vulkan)
+ * model of I/O to the Metal one. */
+
+#include "msl_private.h"
+
+#include "nir_builder.h"
+
+/* Mapping from alu type to Metal scalar type */
+static const char *
+alu_type_to_string(nir_alu_type type)
+{
+   switch (type) {
+   case nir_type_uint8:
+      return "uchar";
+   case nir_type_uint16:
+      return "ushort";
+   case nir_type_uint32:
+      return "uint";
+   case nir_type_uint64:
+      return "ulong";
+   case nir_type_int8:
+      return "char";
+   case nir_type_int16:
+      return "short";
+   case nir_type_int32:
+      return "int";
+   case nir_type_int64:
+      return "long";
+   case nir_type_float16:
+      return "half";
+   case nir_type_float32:
+      return "float";
+   case nir_type_bool8:
+      return "bool";
+   default:
+      UNREACHABLE("Unsupported nir_alu_type");
+   }
+};
+
+/* Type suffix for a vector of a given size. */
+static const char *vector_suffixes[] = {
+   [1] = "",
+   [2] = "2",
+   [3] = "3",
+   [4] = "4",
+};
+
+/* The type names of the generated output structs */
+static const char *VERTEX_OUTPUT_TYPE = "VertexOut";
+static const char *FRAGMENT_OUTPUT_TYPE = "FragmentOut";
+
+/* Mapping from NIR's varying slots to the generated struct member name */
+static const char *VARYING_SLOT_NAME[NUM_TOTAL_VARYING_SLOTS] = {
+   [VARYING_SLOT_POS] = "position",
+   [VARYING_SLOT_PSIZ] = "point_size",
+   [VARYING_SLOT_PRIMITIVE_ID] = "primitive_id",
+   [VARYING_SLOT_LAYER] = "layer",
+   [VARYING_SLOT_VAR0] = "vary_00",
+   [VARYING_SLOT_VAR1] = "vary_01",
+   [VARYING_SLOT_VAR2] = "vary_02",
+   [VARYING_SLOT_VAR3] = "vary_03",
+   [VARYING_SLOT_VAR4] = "vary_04",
+   [VARYING_SLOT_VAR5] = "vary_05",
+   [VARYING_SLOT_VAR6] = "vary_06",
+   [VARYING_SLOT_VAR7] = "vary_07",
+   [VARYING_SLOT_VAR8] = "vary_08",
+   [VARYING_SLOT_VAR9] = "vary_09",
+   [VARYING_SLOT_VAR10] = "vary_10",
+   [VARYING_SLOT_VAR11] = "vary_11",
+   [VARYING_SLOT_VAR12] = "vary_12",
+   [VARYING_SLOT_VAR13] = "vary_13",
+   [VARYING_SLOT_VAR14] = "vary_14",
+   [VARYING_SLOT_VAR15] = "vary_15",
+   [VARYING_SLOT_VAR16] = "vary_16",
+   [VARYING_SLOT_VAR17] = "vary_17",
+   [VARYING_SLOT_VAR18] = "vary_18",
+   [VARYING_SLOT_VAR19] = "vary_19",
+   [VARYING_SLOT_VAR20] = "vary_20",
+   [VARYING_SLOT_VAR21] = "vary_21",
+   [VARYING_SLOT_VAR22] = "vary_22",
+   [VARYING_SLOT_VAR23] = "vary_23",
+   [VARYING_SLOT_VAR24] = "vary_24",
+   [VARYING_SLOT_VAR25] = "vary_25",
+   [VARYING_SLOT_VAR26] = "vary_26",
+   [VARYING_SLOT_VAR27] = "vary_27",
+   [VARYING_SLOT_VAR28] = "vary_28",
+   [VARYING_SLOT_VAR29] = "vary_29",
+   [VARYING_SLOT_VAR30] = "vary_30",
+   [VARYING_SLOT_VAR31] = "vary_31",
+};
+
+/* Mapping from NIR varying slot to the MSL struct member attribute. */
+static const char *VARYING_SLOT_SEMANTIC[NUM_TOTAL_VARYING_SLOTS] = {
+   [VARYING_SLOT_POS] = "[[position]]",
+   [VARYING_SLOT_PSIZ] = "[[point_size]]",
+   [VARYING_SLOT_PRIMITIVE_ID] = "[[primitive_id]]",
+   [VARYING_SLOT_LAYER] = "[[render_target_array_index]]",
+   [VARYING_SLOT_VAR0] = "[[user(vary_00)]]",
+   [VARYING_SLOT_VAR1] = "[[user(vary_01)]]",
+   [VARYING_SLOT_VAR2] = "[[user(vary_02)]]",
+   [VARYING_SLOT_VAR3] = "[[user(vary_03)]]",
+   [VARYING_SLOT_VAR4] = "[[user(vary_04)]]",
+   [VARYING_SLOT_VAR5] = "[[user(vary_05)]]",
+   [VARYING_SLOT_VAR6] = "[[user(vary_06)]]",
+   [VARYING_SLOT_VAR7] = "[[user(vary_07)]]",
+   [VARYING_SLOT_VAR8] = "[[user(vary_08)]]",
+   [VARYING_SLOT_VAR9] = "[[user(vary_09)]]",
+   [VARYING_SLOT_VAR10] = "[[user(vary_10)]]",
+   [VARYING_SLOT_VAR11] = "[[user(vary_11)]]",
+   [VARYING_SLOT_VAR12] = "[[user(vary_12)]]",
+   [VARYING_SLOT_VAR13] = "[[user(vary_13)]]",
+   [VARYING_SLOT_VAR14] = "[[user(vary_14)]]",
+   [VARYING_SLOT_VAR15] = "[[user(vary_15)]]",
+   [VARYING_SLOT_VAR16] = "[[user(vary_16)]]",
+   [VARYING_SLOT_VAR17] = "[[user(vary_17)]]",
+   [VARYING_SLOT_VAR18] = "[[user(vary_18)]]",
+   [VARYING_SLOT_VAR19] = "[[user(vary_19)]]",
+   [VARYING_SLOT_VAR20] = "[[user(vary_20)]]",
+   [VARYING_SLOT_VAR21] = "[[user(vary_21)]]",
+   [VARYING_SLOT_VAR22] = "[[user(vary_22)]]",
+   [VARYING_SLOT_VAR23] = "[[user(vary_23)]]",
+   [VARYING_SLOT_VAR24] = "[[user(vary_24)]]",
+   [VARYING_SLOT_VAR25] = "[[user(vary_25)]]",
+   [VARYING_SLOT_VAR26] = "[[user(vary_26)]]",
+   [VARYING_SLOT_VAR27] = "[[user(vary_27)]]",
+   [VARYING_SLOT_VAR28] = "[[user(vary_28)]]",
+   [VARYING_SLOT_VAR29] = "[[user(vary_29)]]",
+   [VARYING_SLOT_VAR30] = "[[user(vary_30)]]",
+   [VARYING_SLOT_VAR31] = "[[user(vary_31)]]",
+};
+
+/* Mapping from NIR fragment output slot to MSL struct member name */
+static const char *FS_OUTPUT_NAME[] = {
+   [FRAG_RESULT_DEPTH] = "depth_out",
+   [FRAG_RESULT_STENCIL] = "stencil_out",
+   [FRAG_RESULT_SAMPLE_MASK] = "sample_mask_out",
+   [FRAG_RESULT_DATA0] = "color_0",
+   [FRAG_RESULT_DATA1] = "color_1",
+   [FRAG_RESULT_DATA2] = "color_2",
+   [FRAG_RESULT_DATA3] = "color_3",
+   [FRAG_RESULT_DATA4] = "color_4",
+   [FRAG_RESULT_DATA5] = "color_5",
+   [FRAG_RESULT_DATA6] = "color_6",
+   [FRAG_RESULT_DATA7] = "color_7",
+};
+
+/* Mapping from NIR fragment output slot to MSL struct member attribute */
+static const char *FS_OUTPUT_SEMANTIC[] = {
+   [FRAG_RESULT_DEPTH] = "", // special case, depends on depth layout
+   [FRAG_RESULT_STENCIL] = "stencil", [FRAG_RESULT_SAMPLE_MASK] = "sample_mask",
+   [FRAG_RESULT_DATA0] = "color(0)",  [FRAG_RESULT_DATA1] = "color(1)",
+   [FRAG_RESULT_DATA2] = "color(2)",  [FRAG_RESULT_DATA3] = "color(3)",
+   [FRAG_RESULT_DATA4] = "color(4)",  [FRAG_RESULT_DATA5] = "color(5)",
+   [FRAG_RESULT_DATA6] = "color(6)",  [FRAG_RESULT_DATA7] = "color(7)",
+};
+
+const char *depth_layout_arg[8] = {
+   [FRAG_DEPTH_LAYOUT_ANY] = "any",
+   [FRAG_DEPTH_LAYOUT_GREATER] = "greater",
+   [FRAG_DEPTH_LAYOUT_LESS] = "less",
+   [FRAG_DEPTH_LAYOUT_UNCHANGED] = "any",
+};
+
+/* Generate the struct definition for the vertex shader return value */
+static void
+vs_output_block(nir_shader *shader, struct nir_to_msl_ctx *ctx)
+{
+   P(ctx, "struct %s {\n", VERTEX_OUTPUT_TYPE);
+   ctx->indentlevel++;
+   u_foreach_bit64(location, shader->info.outputs_written) {
+      struct io_slot_info info = ctx->outputs_info[location];
+      const char *type = alu_type_to_string(info.type);
+      const char *vector_suffix = vector_suffixes[info.num_components];
+      P_IND(ctx, "%s%s %s %s;\n", type, vector_suffix,
+            VARYING_SLOT_NAME[location], VARYING_SLOT_SEMANTIC[location]);
+   }
+
+   ctx->indentlevel--;
+   P(ctx, "};\n");
+}
+
+/* Generate the struct definition for the fragment shader input argument */
+static void
+fs_input_block(nir_shader *shader, struct nir_to_msl_ctx *ctx)
+{
+   P(ctx, "struct FragmentIn {\n");
+   ctx->indentlevel++;
+   u_foreach_bit64(location, shader->info.inputs_read) {
+      struct io_slot_info info = ctx->inputs_info[location];
+      const char *type = alu_type_to_string(info.type);
+      const char *vector_suffix = vector_suffixes[info.num_components];
+      const char *interp = "";
+      switch (info.interpolation) {
+      case INTERP_MODE_NOPERSPECTIVE:
+         if (info.centroid)
+            interp = "[[centroid_no_perspective]]";
+         else if (info.sample)
+            interp = "[[sample_no_perspective]]";
+         else
+            interp = "[[center_no_perspective]]";
+         break;
+      case INTERP_MODE_FLAT:
+         interp = "[[flat]]";
+         break;
+      default:
+         if (info.centroid)
+            interp = "[[centroid_perspective]]";
+         else if (info.sample)
+            interp = "[[sample_perspective]]";
+         break;
+      }
+      P_IND(ctx, "%s%s %s %s %s;\n", type, vector_suffix,
+            VARYING_SLOT_NAME[location], VARYING_SLOT_SEMANTIC[location],
+            interp);
+   }
+
+   /* Enable reading from framebuffer */
+   u_foreach_bit64(location, shader->info.outputs_read) {
+      struct io_slot_info info = ctx->outputs_info[location];
+      const char *type = alu_type_to_string(info.type);
+      const char *vector_suffix = vector_suffixes[info.num_components];
+      P_IND(ctx, "%s%s ", type, vector_suffix);
+      P(ctx, "%s [[%s, raster_order_group(0)]];\n", FS_OUTPUT_NAME[location],
+        FS_OUTPUT_SEMANTIC[location]);
+   }
+
+   ctx->indentlevel--;
+   P(ctx, "};\n");
+}
+
+/* Generate the struct definition for the fragment shader return value */
+static void
+fs_output_block(nir_shader *shader, struct nir_to_msl_ctx *ctx)
+{
+   P_IND(ctx, "struct %s {\n", FRAGMENT_OUTPUT_TYPE);
+   ctx->indentlevel++;
+   u_foreach_bit64(location, shader->info.outputs_written) {
+      struct io_slot_info info = ctx->outputs_info[location];
+      const char *type = alu_type_to_string(info.type);
+      const char *vector_suffix = vector_suffixes[info.num_components];
+      P_IND(ctx, "%s%s ", type, vector_suffix);
+      if (location == FRAG_RESULT_DEPTH) {
+         enum gl_frag_depth_layout depth_layout = shader->info.fs.depth_layout;
+         assert(depth_layout_arg[depth_layout]);
+         P(ctx, "%s [[depth(%s)]];\n", FS_OUTPUT_NAME[location],
+           depth_layout_arg[depth_layout]);
+      } else {
+         P(ctx, "%s [[%s]];\n", FS_OUTPUT_NAME[location],
+           FS_OUTPUT_SEMANTIC[location]);
+      }
+   }
+   ctx->indentlevel--;
+   P_IND(ctx, "};\n")
+}
+
+struct gather_ctx {
+   struct io_slot_info *input;
+   struct io_slot_info *output;
+};
+
+static bool
+msl_nir_gather_io_info(nir_builder *b, nir_intrinsic_instr *intrin, void *data)
+{
+   struct gather_ctx *ctx = (struct gather_ctx *)data;
+   switch (intrin->intrinsic) {
+   case nir_intrinsic_load_interpolated_input: {
+      unsigned component = nir_intrinsic_component(intrin);
+      struct nir_io_semantics io = nir_intrinsic_io_semantics(intrin);
+      assert(io.num_slots == 1u && "We don't support arrays");
+
+      unsigned location = nir_src_as_uint(intrin->src[1u]) + io.location;
+      ctx->input[location].type = nir_intrinsic_dest_type(intrin);
+      ctx->input[location].num_components =
+         MAX2(ctx->input[location].num_components,
+              intrin->num_components + component);
+      assert(ctx->input[location].num_components <= 4u &&
+             "Cannot have more than a vec4");
+
+      nir_intrinsic_instr *interp_intrin =
+         nir_src_as_intrinsic(intrin->src[0u]);
+      ctx->input[location].interpolation =
+         nir_intrinsic_interp_mode(interp_intrin);
+      ctx->input[location].centroid =
+         interp_intrin->intrinsic == nir_intrinsic_load_barycentric_centroid;
+      ctx->input[location].sample =
+         interp_intrin->intrinsic == nir_intrinsic_load_barycentric_sample;
+      break;
+   }
+   case nir_intrinsic_load_input: {
+      unsigned component = nir_intrinsic_component(intrin);
+      struct nir_io_semantics io = nir_intrinsic_io_semantics(intrin);
+      assert(io.num_slots == 1u && "We don't support arrays");
+
+      unsigned location = nir_src_as_uint(intrin->src[0u]) + io.location;
+      ctx->input[location].type = nir_intrinsic_dest_type(intrin);
+      ctx->input[location].interpolation = INTERP_MODE_FLAT;
+      ctx->input[location].num_components =
+         MAX2(ctx->input[location].num_components,
+              intrin->num_components + component);
+      assert(ctx->input[location].num_components <= 4u &&
+             "Cannot have more than a vec4");
+      break;
+   }
+   case nir_intrinsic_load_output: {
+      unsigned component = nir_intrinsic_component(intrin);
+      struct nir_io_semantics io = nir_intrinsic_io_semantics(intrin);
+      assert(io.num_slots == 1u && "We don't support arrays");
+
+      unsigned location = nir_src_as_uint(intrin->src[0u]) + io.location;
+      ctx->output[location].type = nir_intrinsic_dest_type(intrin);
+      ctx->output[location].num_components =
+         MAX2(ctx->output[location].num_components,
+              intrin->num_components + component);
+      assert(ctx->output[location].num_components <= 4u &&
+             "Cannot have more than a vec4");
+      break;
+   }
+   case nir_intrinsic_store_output: {
+      unsigned component = nir_intrinsic_component(intrin);
+      unsigned write_mask = nir_intrinsic_write_mask(intrin);
+      struct nir_io_semantics io = nir_intrinsic_io_semantics(intrin);
+      assert(io.num_slots == 1u && "We don't support arrays");
+
+      /* Due to nir_lower_blend that doesn't generate intrinsics with the same
+       * num_components as destination, we need to compute current store's
+       * num_components using offset and mask. */
+      unsigned num_components = component + 1u;
+      unsigned mask_left_most_index = 0u;
+      for (unsigned i = 0u; i < intrin->num_components; ++i) {
+         if ((write_mask >> i) & 1u)
+            mask_left_most_index = i;
+      }
+      num_components += mask_left_most_index;
+      unsigned location = nir_src_as_uint(intrin->src[1u]) + io.location;
+      ctx->output[location].type = nir_intrinsic_src_type(intrin);
+      ctx->output[location].num_components =
+         MAX3(ctx->output[location].num_components, num_components,
+              intrin->num_components);
+      assert(ctx->output[location].num_components <= 4u &&
+             "Cannot have more than a vec4");
+      break;
+   }
+   default:
+      break;
+   }
+
+   return false;
+}
+
+void
+msl_gather_io_info(struct nir_to_msl_ctx *ctx,
+                   struct io_slot_info *info_array_input,
+                   struct io_slot_info *info_array_output)
+{
+   struct gather_ctx gather_ctx = {
+      .input = info_array_input,
+      .output = info_array_output,
+   };
+   nir_shader_intrinsics_pass(ctx->shader, msl_nir_gather_io_info,
+                              nir_metadata_all, &gather_ctx);
+}
+
+/* Generate all the struct definitions needed for shader I/O */
+void
+msl_emit_io_blocks(struct nir_to_msl_ctx *ctx, nir_shader *shader)
+{
+   switch (ctx->shader->info.stage) {
+   case MESA_SHADER_VERTEX:
+      vs_output_block(shader, ctx);
+      break;
+   case MESA_SHADER_FRAGMENT:
+      fs_input_block(shader, ctx);
+      fs_output_block(shader, ctx);
+      break;
+   case MESA_SHADER_COMPUTE:
+      break;
+   default:
+      assert(0);
+   }
+   // TODO_KOSMICKRISP This should not exist. We need to create input structs in
+   // nir that will later be translated
+   P(ctx, "struct Buffer {\n");
+   ctx->indentlevel++;
+   P_IND(ctx, "uint64_t contents[1];\n"); // TODO_KOSMICKRISP This should not be
+                                          // a cpu pointer
+   ctx->indentlevel--;
+   P(ctx, "};\n")
+
+   P(ctx, "struct SamplerTable {\n");
+   ctx->indentlevel++;
+   P_IND(ctx, "sampler handles[1024];\n");
+   ctx->indentlevel--;
+   P(ctx, "};\n")
+}
+
+void
+msl_emit_output_var(struct nir_to_msl_ctx *ctx, nir_shader *shader)
+{
+   switch (shader->info.stage) {
+   case MESA_SHADER_VERTEX:
+      P_IND(ctx, "%s out = {};\n", VERTEX_OUTPUT_TYPE);
+      break;
+   case MESA_SHADER_FRAGMENT:
+      P_IND(ctx, "%s out = {};\n", FRAGMENT_OUTPUT_TYPE);
+
+      /* Load inputs to output */
+      u_foreach_bit64(location, shader->info.outputs_read) {
+         P_IND(ctx, "out.%s = in.%s;\n", FS_OUTPUT_NAME[location],
+               FS_OUTPUT_NAME[location]);
+      }
+      break;
+   default:
+      break;
+   }
+}
+
+const char *
+msl_output_name(struct nir_to_msl_ctx *ctx, unsigned location)
+{
+   switch (ctx->shader->info.stage) {
+   case MESA_SHADER_VERTEX:
+      return VARYING_SLOT_NAME[location];
+   case MESA_SHADER_FRAGMENT:
+      return FS_OUTPUT_NAME[location];
+   default:
+      assert(0);
+      return "";
+   }
+}
+
+const char *
+msl_input_name(struct nir_to_msl_ctx *ctx, unsigned location)
+{
+   switch (ctx->shader->info.stage) {
+   case MESA_SHADER_FRAGMENT:
+      return VARYING_SLOT_NAME[location];
+   default:
+      assert(0);
+      return "";
+   }
+}
diff --git a/src/kosmickrisp/compiler/msl_nir_algebraic.py b/src/kosmickrisp/compiler/msl_nir_algebraic.py
new file mode 100644
index 00000000000..16d5fdaea9d
--- /dev/null
+++ b/src/kosmickrisp/compiler/msl_nir_algebraic.py
@@ -0,0 +1,38 @@
+# Copyright 2025 LunarG, Inc.
+# Copyright 2025 Google LLC
+# Copyright 2022 Alyssa Rosenzweig
+# Copyright 2021 Collabora, Ltd.
+# Copyright 2016 Intel Corporation
+# SPDX-License-Identifier: MIT
+
+import argparse
+import sys
+import math
+
+a = 'a'
+
+lower_pack = [
+  # Based on the VIR lowering
+  (('f2f16_rtz', 'a@32'),
+   ('bcsel', ('flt', ('fabs', a), ('fabs', ('f2f32', ('f2f16_rtne', a)))),
+    ('isub', ('f2f16_rtne', a), 1), ('f2f16_rtne', a))),
+]
+
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-p', '--import-path', required=True)
+    args = parser.parse_args()
+    sys.path.insert(0, args.import_path)
+    run()
+
+def run():
+    import nir_algebraic  # pylint: disable=import-error
+
+    print('#include "msl_private.h"')
+
+    print(nir_algebraic.AlgebraicPass("msl_nir_lower_algebraic_late", lower_pack).render())
+
+if __name__ == '__main__':
+    main()
diff --git a/src/kosmickrisp/compiler/msl_nir_lower_common.c b/src/kosmickrisp/compiler/msl_nir_lower_common.c
new file mode 100644
index 00000000000..34e0f264bcb
--- /dev/null
+++ b/src/kosmickrisp/compiler/msl_nir_lower_common.c
@@ -0,0 +1,255 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+#include "nir_to_msl.h"
+
+#include "nir.h"
+#include "nir_builder.h"
+
+#include "util/format/u_format.h"
+
+bool
+msl_nir_vs_remove_point_size_write(nir_builder *b, nir_intrinsic_instr *intrin,
+                                   void *data)
+{
+   if (intrin->intrinsic != nir_intrinsic_store_output)
+      return false;
+
+   nir_io_semantics io = nir_intrinsic_io_semantics(intrin);
+   if (io.location == VARYING_SLOT_PSIZ) {
+      return nir_remove_sysval_output(intrin, MESA_SHADER_FRAGMENT);
+   }
+
+   return false;
+}
+
+bool
+msl_nir_fs_remove_depth_write(nir_builder *b, nir_intrinsic_instr *intrin,
+                              void *data)
+{
+   if (intrin->intrinsic != nir_intrinsic_store_output)
+      return false;
+
+   nir_io_semantics io = nir_intrinsic_io_semantics(intrin);
+   if (io.location == FRAG_RESULT_DEPTH) {
+      return nir_remove_sysval_output(intrin, MESA_SHADER_FRAGMENT);
+   }
+
+   return false;
+}
+
+bool
+msl_nir_fs_force_output_signedness(
+   nir_shader *nir, enum pipe_format render_target_formats[MAX_DRAW_BUFFERS])
+{
+   assert(nir->info.stage == MESA_SHADER_FRAGMENT);
+
+   bool update_derefs = false;
+   nir_foreach_variable_with_modes(var, nir, nir_var_shader_out) {
+      if (FRAG_RESULT_DATA0 <= var->data.location &&
+          var->data.location <= FRAG_RESULT_DATA7 &&
+          glsl_type_is_integer(var->type)) {
+         unsigned int slot = var->data.location - FRAG_RESULT_DATA0;
+
+         if (glsl_type_is_uint_16_32_64(var->type) &&
+             util_format_is_pure_sint(render_target_formats[slot])) {
+            var->type = glsl_ivec_type(var->type->vector_elements);
+            update_derefs = true;
+         } else if (glsl_type_is_int_16_32_64(var->type) &&
+                    util_format_is_pure_uint(render_target_formats[slot])) {
+            var->type = glsl_uvec_type(var->type->vector_elements);
+            update_derefs = true;
+         }
+      }
+   }
+
+   if (update_derefs) {
+      nir_foreach_function_impl(impl, nir) {
+         nir_foreach_block(block, impl) {
+            nir_foreach_instr(instr, block) {
+               switch (instr->type) {
+               case nir_instr_type_deref: {
+                  nir_deref_instr *deref = nir_instr_as_deref(instr);
+                  if (deref->deref_type == nir_deref_type_var) {
+                     deref->type = deref->var->type;
+                  }
+                  break;
+               }
+               default:
+                  break;
+               }
+            }
+         }
+         nir_progress(update_derefs, impl, nir_metadata_control_flow);
+      }
+   }
+
+   return update_derefs;
+}
+
+bool
+msl_lower_textures(nir_shader *nir)
+{
+   bool progress = false;
+   nir_lower_tex_options lower_tex_options = {
+      .lower_txp = ~0u,
+      .lower_sampler_lod_bias = true,
+
+      /* We don't use 1D textures because they are really limited in Metal */
+      .lower_1d = true,
+
+      /* Metal does not support tg4 with individual offsets for each sample */
+      .lower_tg4_offsets = true,
+
+      /* Metal does not natively support offsets for texture.read operations */
+      .lower_txf_offset = true,
+      .lower_txd_cube_map = true,
+   };
+
+   NIR_PASS(progress, nir, nir_lower_tex, &lower_tex_options);
+   return progress;
+}
+
+static bool
+replace_sample_id_for_sample_mask(nir_builder *b, nir_intrinsic_instr *intrin,
+                                  void *data)
+{
+   if (intrin->intrinsic != nir_intrinsic_load_sample_mask_in)
+      return false;
+
+   nir_def_replace(nir_instr_def(&intrin->instr), (nir_def *)data);
+   return true;
+}
+
+static bool
+msl_replace_load_sample_mask_in_for_static_sample_mask(
+   nir_builder *b, nir_intrinsic_instr *intr, void *data)
+{
+   if (intr->intrinsic != nir_intrinsic_load_sample_mask_in)
+      return false;
+
+   nir_def *sample_mask = (nir_def *)data;
+   nir_def_rewrite_uses(&intr->def, sample_mask);
+   return true;
+}
+
+bool
+msl_lower_static_sample_mask(nir_shader *nir, uint32_t sample_mask)
+{
+   /* Only support vertex for now */
+   assert(nir->info.stage == MESA_SHADER_FRAGMENT);
+
+   /* Embed sample mask */
+   nir_function_impl *entrypoint = nir_shader_get_entrypoint(nir);
+   nir_builder b = nir_builder_at(nir_before_impl(entrypoint));
+
+   struct nir_io_semantics io_semantics = {
+      .location = FRAG_RESULT_SAMPLE_MASK,
+      .num_slots = 1u,
+   };
+   nir_def *sample_mask_def = nir_imm_int(&b, sample_mask);
+   nir_store_output(&b, sample_mask_def, nir_imm_int(&b, 0u), .base = 0u,
+                    .range = 1u, .write_mask = 0x1, .component = 0u,
+                    .src_type = nir_type_uint32, .io_semantics = io_semantics);
+
+   return nir_shader_intrinsics_pass(
+      nir, msl_replace_load_sample_mask_in_for_static_sample_mask,
+      nir_metadata_control_flow, sample_mask_def);
+
+   return true;
+}
+
+bool
+msl_ensure_depth_write(nir_shader *nir)
+{
+   assert(nir->info.stage == MESA_SHADER_FRAGMENT);
+
+   bool has_depth_write =
+      nir->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_DEPTH);
+   if (!has_depth_write) {
+      nir_variable *depth_var = nir_create_variable_with_location(
+         nir, nir_var_shader_out, FRAG_RESULT_DEPTH, glsl_float_type());
+
+      /* Write to depth at the very beginning */
+      nir_function_impl *entrypoint = nir_shader_get_entrypoint(nir);
+      nir_builder b = nir_builder_at(nir_before_impl(entrypoint));
+
+      nir_deref_instr *depth_deref = nir_build_deref_var(&b, depth_var);
+      nir_def *position = nir_load_frag_coord(&b);
+      nir_store_deref(&b, depth_deref, nir_channel(&b, position, 2u),
+                      0xFFFFFFFF);
+
+      nir->info.outputs_written |= BITFIELD64_BIT(FRAG_RESULT_DEPTH);
+      nir->info.fs.depth_layout = FRAG_DEPTH_LAYOUT_ANY;
+      return nir_progress(true, entrypoint, nir_metadata_control_flow);
+   }
+   return false;
+}
+
+bool
+msl_ensure_vertex_position_output(nir_shader *nir)
+{
+   assert(nir->info.stage == MESA_SHADER_VERTEX);
+
+   bool has_position_write =
+      nir->info.outputs_written & BITFIELD64_BIT(VARYING_SLOT_POS);
+   if (!has_position_write) {
+      nir_variable *position_var = nir_create_variable_with_location(
+         nir, nir_var_shader_out, VARYING_SLOT_POS, glsl_vec4_type());
+
+      /* Write to depth at the very beginning */
+      nir_function_impl *entrypoint = nir_shader_get_entrypoint(nir);
+      nir_builder b = nir_builder_at(nir_before_impl(entrypoint));
+
+      nir_deref_instr *position_deref = nir_build_deref_var(&b, position_var);
+      nir_def *zero = nir_imm_float(&b, 0.0f);
+      nir_store_deref(&b, position_deref, nir_vec4(&b, zero, zero, zero, zero),
+                      0xFFFFFFFF);
+
+      nir->info.outputs_written |= BITFIELD64_BIT(VARYING_SLOT_POS);
+      return nir_progress(true, entrypoint, nir_metadata_control_flow);
+   }
+   return false;
+}
+
+static bool
+msl_sample_mask_uint(nir_builder *b, nir_intrinsic_instr *intr, void *data)
+{
+   if (intr->intrinsic == nir_intrinsic_store_output) {
+      struct nir_io_semantics io = nir_intrinsic_io_semantics(intr);
+      if (io.location == FRAG_RESULT_SAMPLE_MASK)
+         nir_intrinsic_set_src_type(intr, nir_type_uint32);
+   }
+
+   return false;
+}
+
+bool
+msl_nir_sample_mask_type(nir_shader *nir)
+{
+   assert(nir->info.stage == MESA_SHADER_FRAGMENT);
+   return nir_shader_intrinsics_pass(nir, msl_sample_mask_uint,
+                                     nir_metadata_all, NULL);
+}
+
+static bool
+msl_layer_id_uint(nir_builder *b, nir_intrinsic_instr *intr, void *data)
+{
+   if (intr->intrinsic == nir_intrinsic_store_output) {
+      struct nir_io_semantics io = nir_intrinsic_io_semantics(intr);
+      if (io.location == VARYING_SLOT_LAYER)
+         nir_intrinsic_set_src_type(intr, nir_type_uint32);
+   }
+
+   return false;
+}
+
+bool
+msl_nir_layer_id_type(nir_shader *nir)
+{
+   assert(nir->info.stage == MESA_SHADER_VERTEX);
+   return nir_shader_intrinsics_pass(nir, msl_layer_id_uint, nir_metadata_all,
+                                     NULL);
+}
diff --git a/src/kosmickrisp/compiler/msl_nir_lower_subgroups.c b/src/kosmickrisp/compiler/msl_nir_lower_subgroups.c
new file mode 100644
index 00000000000..30201145c4a
--- /dev/null
+++ b/src/kosmickrisp/compiler/msl_nir_lower_subgroups.c
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2023 Valve Corporation
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "msl_private.h"
+#include "nir.h"
+#include "nir_builder.h"
+
+static bool
+needs_bool_widening(nir_intrinsic_instr *intrin)
+{
+   switch (intrin->intrinsic) {
+   case nir_intrinsic_read_invocation:
+   case nir_intrinsic_read_first_invocation:
+   case nir_intrinsic_reduce:
+   case nir_intrinsic_quad_broadcast:
+   case nir_intrinsic_quad_swap_horizontal:
+   case nir_intrinsic_quad_swap_vertical:
+   case nir_intrinsic_quad_swap_diagonal:
+   case nir_intrinsic_shuffle:
+   case nir_intrinsic_shuffle_down:
+   case nir_intrinsic_shuffle_up:
+   case nir_intrinsic_shuffle_xor:
+      return true;
+   default:
+      return false;
+   }
+}
+
+static bool
+lower_bool_ops(nir_builder *b, nir_intrinsic_instr *intrin, void *_unused)
+{
+   if (!needs_bool_widening(intrin))
+      return false;
+
+   if (intrin->def.bit_size != 1)
+      return false;
+
+   b->cursor = nir_before_instr(&intrin->instr);
+   nir_def *widen = nir_b2i32(b, intrin->src[0].ssa);
+   nir_src_rewrite(&intrin->src[0], widen);
+   intrin->def.bit_size = 32;
+   b->cursor = nir_after_instr(&intrin->instr);
+   nir_def *narrow = nir_b2b1(b, &intrin->def);
+   nir_def_rewrite_uses_after(&intrin->def, narrow);
+
+   return true;
+}
+
+static bool
+lower(nir_builder *b, nir_intrinsic_instr *intr, void *data)
+{
+   b->cursor = nir_before_instr(&intr->instr);
+
+   switch (intr->intrinsic) {
+   case nir_intrinsic_vote_any: {
+      /* We don't have vote instructions, but we have efficient ballots */
+      nir_def *ballot = nir_ballot(b, 1, 32, intr->src[0].ssa);
+      nir_def_rewrite_uses(&intr->def, nir_ine_imm(b, ballot, 0));
+      return true;
+   }
+
+   case nir_intrinsic_vote_all: {
+      nir_def *ballot = nir_ballot(b, 1, 32, nir_inot(b, intr->src[0].ssa));
+      nir_def_rewrite_uses(&intr->def, nir_ieq_imm(b, ballot, 0));
+      return true;
+   }
+
+   default:
+      return false;
+   }
+}
+
+void
+msl_nir_lower_subgroups(nir_shader *nir)
+{
+   const nir_lower_subgroups_options subgroups_options = {
+      .subgroup_size = 32,
+      .ballot_bit_size = 32,
+      .ballot_components = 1,
+      .lower_subgroup_masks = true,
+      .lower_vote_ieq = true,
+      .lower_vote_feq = true,
+      .lower_vote_bool_eq = true,
+      .lower_inverse_ballot = true,
+      .lower_relative_shuffle = true,
+      .lower_quad = true,
+      .lower_reduce = true,
+   };
+   NIR_PASS(_, nir, nir_lower_subgroups, &subgroups_options);
+   NIR_PASS(_, nir, nir_shader_intrinsics_pass, lower,
+            nir_metadata_control_flow, NULL);
+   NIR_PASS(_, nir, nir_shader_intrinsics_pass, lower_bool_ops,
+            nir_metadata_control_flow, NULL);
+}
diff --git a/src/kosmickrisp/compiler/msl_private.h b/src/kosmickrisp/compiler/msl_private.h
new file mode 100644
index 00000000000..9ccd2bd7922
--- /dev/null
+++ b/src/kosmickrisp/compiler/msl_private.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+#include "util/string_buffer.h"
+#include "nir.h"
+
+struct io_slot_info {
+   nir_alu_type type;
+   uint32_t interpolation;
+   unsigned num_components;
+   bool centroid;
+   bool sample;
+};
+
+struct nir_to_msl_ctx {
+   FILE *output;
+   struct hash_table *types;
+   nir_shader *shader;
+   struct _mesa_string_buffer *text;
+   unsigned short indentlevel;
+   struct io_slot_info inputs_info[NUM_TOTAL_VARYING_SLOTS];
+   struct io_slot_info outputs_info[NUM_TOTAL_VARYING_SLOTS];
+};
+
+#define P_IND(ctx, ...)                                                        \
+   do {                                                                        \
+      for (unsigned i = 0; i < (ctx)->indentlevel; i++)                        \
+         _mesa_string_buffer_append((ctx)->text, "    ");                      \
+      _mesa_string_buffer_printf((ctx)->text, __VA_ARGS__);                    \
+   } while (0);
+
+#define P(ctx, ...) _mesa_string_buffer_printf((ctx)->text, __VA_ARGS__);
+
+#define P_INDENT(ctx)                                                          \
+   do {                                                                        \
+      for (unsigned i = 0; i < (ctx)->indentlevel; i++)                        \
+         _mesa_string_buffer_append((ctx)->text, "    ");                      \
+   } while (0)
+
+/* Perform type inference. The returned value is a
+ * map from nir_def* to base type.*/
+
+struct hash_table *msl_infer_types(nir_shader *shader);
+
+const char *msl_type_for_def(struct hash_table *types, nir_def *def);
+
+const char *msl_uint_type(uint8_t bit_size, uint8_t num_components);
+
+const char *msl_type_for_src(struct hash_table *types, nir_src *src);
+
+const char *msl_bitcast_for_src(struct hash_table *types, nir_src *src);
+
+void msl_src_as_const(struct nir_to_msl_ctx *ctx, nir_src *src);
+
+void msl_emit_io_blocks(struct nir_to_msl_ctx *ctx, nir_shader *shader);
+
+void msl_emit_output_var(struct nir_to_msl_ctx *ctx, nir_shader *shader);
+
+void msl_gather_io_info(struct nir_to_msl_ctx *ctx,
+                        struct io_slot_info *info_array_input,
+                        struct io_slot_info *info_array_output);
+
+const char *msl_input_name(struct nir_to_msl_ctx *ctx, unsigned location);
+
+const char *msl_output_name(struct nir_to_msl_ctx *ctx, unsigned location);
+
+bool msl_src_is_float(struct nir_to_msl_ctx *ctx, nir_src *src);
+bool msl_def_is_sampler(struct nir_to_msl_ctx *ctx, nir_def *def);
+
+void msl_nir_lower_subgroups(nir_shader *nir);
+
+bool msl_nir_lower_algebraic_late(nir_shader *shader);
diff --git a/src/kosmickrisp/compiler/msl_type_inference.c b/src/kosmickrisp/compiler/msl_type_inference.c
new file mode 100644
index 00000000000..c10d90c3481
--- /dev/null
+++ b/src/kosmickrisp/compiler/msl_type_inference.c
@@ -0,0 +1,857 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "vulkan/vulkan_core.h"
+#include "msl_private.h"
+
+typedef enum ti_type {
+   /* We haven't been able to assign a type yet */
+   TYPE_NONE = 0,
+   /* All we know is that this is used in I/O, we
+    * can treat it as an opaque value (i.e. uint) */
+   TYPE_GENERIC_DATA,
+   /* A generic int used in ALU operations but also can a bool for bitwise ops */
+   TYPE_GENERIC_INT_OR_BOOL,
+   /* A generic int used in ALU operations that can be int or uint */
+   TYPE_GENERIC_INT,
+   /* These are actual concrete types. */
+   TYPE_INT,
+   TYPE_UINT,
+   TYPE_BOOL,
+   TYPE_FLOAT,
+   TYPE_SAMPLER,
+} ti_type;
+
+static ti_type
+unify_types(ti_type t1, ti_type t2)
+{
+   ti_type generic = MIN2(t1, t2);
+   ti_type specific = MAX2(t1, t2);
+   if (t1 == t2)
+      return TYPE_NONE;
+   // NONE or GENERIC_DATA can be upgraded into any concrete type
+   if (generic == TYPE_GENERIC_DATA || generic == TYPE_NONE)
+      return specific;
+   if ((generic == TYPE_GENERIC_INT_OR_BOOL) &&
+       ((specific == TYPE_INT) || (specific == TYPE_UINT) ||
+        (specific == TYPE_BOOL)))
+      return specific;
+   if ((generic == TYPE_GENERIC_INT) &&
+       ((specific == TYPE_INT) || (specific == TYPE_UINT)))
+      return specific;
+   return TYPE_NONE;
+}
+
+static ti_type
+ti_type_from_nir(nir_alu_type nir_type)
+{
+   switch (nir_alu_type_get_base_type(nir_type)) {
+   case nir_type_int:
+      return TYPE_INT;
+   case nir_type_uint:
+      return TYPE_UINT;
+   case nir_type_float:
+      return TYPE_FLOAT;
+   case nir_type_bool:
+      return TYPE_BOOL;
+   default:
+      assert(0);
+      return TYPE_NONE;
+   }
+}
+
+static ti_type
+ti_type_from_pipe_format(enum pipe_format format)
+{
+   switch (format) {
+   case PIPE_FORMAT_R16_FLOAT:
+   case PIPE_FORMAT_R32_FLOAT:
+      return TYPE_FLOAT;
+   case PIPE_FORMAT_R8_UINT:
+   case PIPE_FORMAT_R16_UINT:
+   case PIPE_FORMAT_R32_UINT:
+   case PIPE_FORMAT_R64_UINT:
+      return TYPE_UINT;
+   case PIPE_FORMAT_R8_SINT:
+   case PIPE_FORMAT_R16_SINT:
+   case PIPE_FORMAT_R32_SINT:
+   case PIPE_FORMAT_R64_SINT:
+      return TYPE_INT;
+   default:
+      assert(0);
+      return 0u;
+   }
+}
+
+static void
+set_type(struct hash_table *types, void *key, ti_type type)
+{
+   // convert nir_type
+   _mesa_hash_table_insert(types, key, (void *)type);
+}
+
+static ti_type
+get_type(struct hash_table *types, void *key)
+{
+   struct hash_entry *entry = _mesa_hash_table_search(types, key);
+   if (!entry)
+      return TYPE_NONE;
+   return (ti_type)(intptr_t)(entry->data);
+}
+
+static bool
+update_instr_type(struct hash_table *types, nir_instr *instr, ti_type type)
+{
+   if (instr->type == nir_instr_type_alu) {
+      nir_alu_instr *alu = nir_instr_as_alu(instr);
+      switch (alu->op) {
+      case nir_op_iadd:
+      case nir_op_isub:
+      case nir_op_ishl:
+      case nir_op_iand:
+      case nir_op_ior:
+      case nir_op_ixor:
+         set_type(types, &alu->def, type);
+         set_type(types, &alu->src[0].src, type);
+         set_type(types, &alu->src[1].src, type);
+         return true;
+      case nir_op_inot:
+         set_type(types, &alu->def, type);
+         set_type(types, &alu->src[0].src, type);
+         return true;
+      case nir_op_ieq:
+      case nir_op_ine:
+         set_type(types, &alu->src[0].src, type);
+         set_type(types, &alu->src[1].src, type);
+         return true;
+      case nir_op_bcsel:
+         set_type(types, &alu->def, type);
+         set_type(types, &alu->src[1].src, type);
+         set_type(types, &alu->src[2].src, type);
+         return true;
+      case nir_op_mov:
+      case nir_op_vec2:
+      case nir_op_vec3:
+      case nir_op_vec4:
+         set_type(types, &alu->def, type);
+         for (int i = 0; i < nir_op_infos[alu->op].num_inputs; i++)
+            set_type(types, &alu->src[i].src, type);
+         return true;
+      default:
+         return false;
+      }
+   } else if (instr->type == nir_instr_type_intrinsic) {
+      nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
+      nir_intrinsic_info info = nir_intrinsic_infos[intr->intrinsic];
+      switch (intr->intrinsic) {
+      case nir_intrinsic_load_reg:
+         set_type(types, &intr->def, type);
+         set_type(types, &intr->src[0], type);
+         return true;
+      case nir_intrinsic_store_reg:
+         set_type(types, &intr->src[0], type);
+         set_type(types, &intr->src[1], type);
+         return true;
+      case nir_intrinsic_decl_reg:
+         set_type(types, &intr->def, type);
+         return true;
+      case nir_intrinsic_load_global:
+      case nir_intrinsic_load_global_constant:
+      case nir_intrinsic_load_global_constant_bounded:
+      case nir_intrinsic_load_global_constant_offset:
+      case nir_intrinsic_load_push_constant:
+         set_type(types, &intr->def, type);
+         return true;
+      /* Scratch and shared are always UINT */
+      case nir_intrinsic_load_scratch:
+      case nir_intrinsic_store_scratch:
+      case nir_intrinsic_load_shared:
+      case nir_intrinsic_store_shared:
+         return false;
+      case nir_intrinsic_store_global:
+         set_type(types, &intr->src[0], type);
+         return true;
+      case nir_intrinsic_read_first_invocation:
+      case nir_intrinsic_read_invocation:
+      case nir_intrinsic_quad_broadcast:
+      case nir_intrinsic_quad_swap_horizontal:
+      case nir_intrinsic_quad_swap_vertical:
+      case nir_intrinsic_quad_swap_diagonal:
+      case nir_intrinsic_shuffle:
+      case nir_intrinsic_shuffle_down:
+      case nir_intrinsic_shuffle_up:
+      case nir_intrinsic_shuffle_xor:
+         set_type(types, &intr->src[0], type);
+         set_type(types, &intr->def, type);
+         return true;
+      default:
+         if (info.has_dest && info.num_srcs == 0) {
+            set_type(types, &intr->def, type);
+            return true;
+         }
+         return false;
+      }
+   } else
+      return false;
+}
+
+static void
+infer_types_from_alu(struct hash_table *types, nir_alu_instr *alu)
+{
+   // for most types, we infer the type from the nir_op_info,
+   // but some ALU instructions are the same for int and uint. Those
+   // have their sources and defs get marked by TYPE_GENERIC_INT.
+   switch (alu->op) {
+   case nir_op_iadd:
+   case nir_op_isub:
+   case nir_op_ishl:
+      // (N, N) -> N
+      set_type(types, &alu->def, TYPE_GENERIC_INT);
+      set_type(types, &alu->src[0].src, TYPE_GENERIC_INT);
+      set_type(types, &alu->src[1].src, TYPE_GENERIC_INT);
+      break;
+   case nir_op_iand:
+   case nir_op_ior:
+   case nir_op_ixor:
+      set_type(types, &alu->def, TYPE_GENERIC_INT_OR_BOOL);
+      set_type(types, &alu->src[0].src, TYPE_GENERIC_INT_OR_BOOL);
+      set_type(types, &alu->src[1].src, TYPE_GENERIC_INT_OR_BOOL);
+      break;
+   case nir_op_inot:
+      // N -> N
+      set_type(types, &alu->def, TYPE_GENERIC_INT_OR_BOOL);
+      set_type(types, &alu->src[0].src, TYPE_GENERIC_INT_OR_BOOL);
+      break;
+   case nir_op_ieq:
+   case nir_op_ine:
+      // (N, N) -> bool
+      set_type(types, &alu->def, TYPE_BOOL);
+      set_type(types, &alu->src[0].src, TYPE_GENERIC_INT_OR_BOOL);
+      set_type(types, &alu->src[1].src, TYPE_GENERIC_INT_OR_BOOL);
+      break;
+   case nir_op_bcsel:
+      // (bool, T, T) -> T
+      set_type(types, &alu->def, TYPE_GENERIC_DATA);
+      set_type(types, &alu->src[0].src, TYPE_BOOL);
+      set_type(types, &alu->src[1].src, TYPE_GENERIC_DATA);
+      set_type(types, &alu->src[2].src, TYPE_GENERIC_DATA);
+      break;
+   // These don't provide any type information, we rely on type propagation
+   // to fill in the type data
+   case nir_op_mov:
+   case nir_op_vec2:
+   case nir_op_vec3:
+   case nir_op_vec4:
+      break;
+   /* We don't have 32-bit width boolean, those are uints. */
+   case nir_op_b2b32:
+      set_type(types, &alu->def, TYPE_UINT);
+      set_type(types, &alu->src[0].src, TYPE_UINT);
+      break;
+
+   default: {
+      // set type for def
+      const nir_op_info *info = &nir_op_infos[alu->op];
+      set_type(types, &alu->def, ti_type_from_nir(info->output_type));
+      for (int i = 0; i < info->num_inputs; i++) {
+         // set type for src
+         set_type(types, &alu->src[i].src,
+                  ti_type_from_nir(info->input_types[i]));
+      }
+   }
+   }
+}
+
+static void
+infer_types_from_intrinsic(struct hash_table *types, nir_intrinsic_instr *instr)
+{
+   switch (instr->intrinsic) {
+   case nir_intrinsic_load_input:
+   case nir_intrinsic_load_interpolated_input:
+   case nir_intrinsic_load_output: {
+      ti_type ty = ti_type_from_nir(nir_intrinsic_dest_type(instr));
+      set_type(types, &instr->def, ty);
+      break;
+   }
+   case nir_intrinsic_load_global_constant:
+      set_type(types, &instr->def, TYPE_GENERIC_DATA);
+      set_type(types, &instr->src[0], TYPE_UINT);
+      break;
+   case nir_intrinsic_load_global_constant_bounded:
+      set_type(types, &instr->def, TYPE_GENERIC_DATA);
+      set_type(types, &instr->src[0], TYPE_UINT);
+      set_type(types, &instr->src[1], TYPE_UINT);
+      set_type(types, &instr->src[2], TYPE_UINT);
+      break;
+   case nir_intrinsic_load_global_constant_offset:
+      set_type(types, &instr->def, TYPE_GENERIC_DATA);
+      set_type(types, &instr->src[0], TYPE_UINT);
+      set_type(types, &instr->src[1], TYPE_UINT);
+      break;
+   case nir_intrinsic_load_global:
+   case nir_intrinsic_load_push_constant:
+      set_type(types, &instr->def, TYPE_GENERIC_DATA);
+      set_type(types, &instr->src[0], TYPE_UINT);
+      break;
+
+   case nir_intrinsic_global_atomic:
+   case nir_intrinsic_global_atomic_swap:
+   case nir_intrinsic_shared_atomic:
+   case nir_intrinsic_shared_atomic_swap: {
+      ti_type type =
+         ti_type_from_nir(nir_atomic_op_type(nir_intrinsic_atomic_op(instr)));
+      set_type(types, &instr->def, type);
+      set_type(types, &instr->src[0], TYPE_UINT);
+      set_type(types, &instr->src[1], type);
+      set_type(types, &instr->src[2], type);
+      break;
+   }
+   case nir_intrinsic_store_global:
+      set_type(types, &instr->src[0], TYPE_GENERIC_DATA);
+      set_type(types, &instr->src[1], TYPE_UINT);
+      break;
+   case nir_intrinsic_store_output: {
+      ti_type ty = ti_type_from_nir(nir_intrinsic_src_type(instr));
+      set_type(types, &instr->src[0], ty);
+      break;
+   }
+   case nir_intrinsic_decl_reg:
+      if (nir_intrinsic_bit_size(instr) == 1)
+         set_type(types, &instr->def, TYPE_BOOL);
+      else
+         set_type(types, &instr->def, TYPE_NONE);
+      break;
+   case nir_intrinsic_store_reg:
+      set_type(types, &instr->src[0], TYPE_NONE);
+      set_type(types, &instr->src[1], TYPE_NONE);
+      break;
+   case nir_intrinsic_load_reg:
+      set_type(types, &instr->src[0], TYPE_NONE);
+      set_type(types, &instr->def, TYPE_NONE);
+      break;
+   case nir_intrinsic_load_scratch:
+   case nir_intrinsic_load_shared:
+      set_type(types, &instr->def, TYPE_UINT);
+      set_type(types, &instr->src[0], TYPE_UINT);
+      break;
+   case nir_intrinsic_store_scratch:
+   case nir_intrinsic_store_shared:
+      set_type(types, &instr->src[0], TYPE_UINT);
+      set_type(types, &instr->src[1], TYPE_UINT);
+      break;
+   case nir_intrinsic_load_workgroup_id:
+   case nir_intrinsic_load_subgroup_id:
+   case nir_intrinsic_load_local_invocation_id:
+   case nir_intrinsic_load_global_invocation_id:
+   case nir_intrinsic_load_num_workgroups:
+   case nir_intrinsic_load_num_subgroups:
+   case nir_intrinsic_load_subgroup_size:
+   case nir_intrinsic_load_sample_id:
+   case nir_intrinsic_load_sample_mask:
+   case nir_intrinsic_load_subgroup_invocation:
+   case nir_intrinsic_load_amplification_id_kk:
+      set_type(types, &instr->def, TYPE_UINT);
+      break;
+   case nir_intrinsic_load_vulkan_descriptor:
+      set_type(types, &instr->src[0], TYPE_UINT);
+      set_type(types, &instr->def, TYPE_UINT);
+      break;
+   case nir_intrinsic_load_buffer_ptr_kk:
+      set_type(types, &instr->def, TYPE_UINT);
+      break;
+   // The defs of these instructions don't participate in type inference
+   // but their sources are pointers (i.e. uints).
+   case nir_intrinsic_load_texture_handle_kk:
+   case nir_intrinsic_load_depth_texture_kk:
+      set_type(types, &instr->src[0], TYPE_UINT);
+      break;
+   case nir_intrinsic_load_sampler_handle_kk:
+      set_type(types, &instr->def, TYPE_SAMPLER);
+      break;
+   case nir_intrinsic_ddx:
+   case nir_intrinsic_ddy:
+   case nir_intrinsic_ddx_coarse:
+   case nir_intrinsic_ddy_coarse:
+   case nir_intrinsic_ddx_fine:
+   case nir_intrinsic_ddy_fine:
+      set_type(types, &instr->src[0], TYPE_FLOAT);
+      set_type(types, &instr->def, TYPE_FLOAT);
+      break;
+   case nir_intrinsic_load_point_coord:
+      set_type(types, &instr->def, TYPE_FLOAT);
+      break;
+   case nir_intrinsic_load_front_face:
+   case nir_intrinsic_elect:
+   case nir_intrinsic_load_helper_invocation:
+   case nir_intrinsic_is_helper_invocation:
+      set_type(types, &instr->def, TYPE_BOOL);
+      break;
+   case nir_intrinsic_load_constant_agx:
+      set_type(types, &instr->src[0], TYPE_UINT);
+      set_type(types, &instr->src[1], TYPE_UINT);
+      set_type(types, &instr->def,
+               ti_type_from_pipe_format(nir_intrinsic_format(instr)));
+      break;
+   case nir_intrinsic_bindless_image_load:
+      set_type(types, &instr->def,
+               ti_type_from_nir(nir_intrinsic_dest_type(instr)));
+      set_type(types, &instr->src[1], TYPE_UINT); // coords
+      set_type(types, &instr->src[3], TYPE_UINT); // level
+      break;
+   case nir_intrinsic_bindless_image_store:
+      set_type(types, &instr->src[1], TYPE_UINT); // coords
+      set_type(types, &instr->src[3],
+               ti_type_from_nir(nir_intrinsic_src_type(instr)));
+      set_type(types, &instr->src[4], TYPE_UINT); // level
+      break;
+   case nir_intrinsic_demote_if:
+   case nir_intrinsic_terminate_if:
+      set_type(types, &instr->src[0], TYPE_BOOL);
+      break;
+   case nir_intrinsic_bindless_image_atomic:
+   case nir_intrinsic_bindless_image_atomic_swap: {
+      set_type(types, &instr->src[1], TYPE_UINT); // coords
+      set_type(types, &instr->src[2], TYPE_UINT); // level
+      ti_type type =
+         ti_type_from_nir(nir_atomic_op_type(nir_intrinsic_atomic_op(instr)));
+      set_type(types, &instr->src[3], type);
+      if (instr->intrinsic == nir_intrinsic_bindless_image_atomic_swap)
+         set_type(types, &instr->src[4], type);
+      set_type(types, &instr->def, type);
+      break;
+   }
+   case nir_intrinsic_ballot:
+      set_type(types, &instr->src[0], TYPE_BOOL);
+      set_type(types, &instr->def, TYPE_UINT);
+      break;
+   case nir_intrinsic_vote_all:
+   case nir_intrinsic_vote_any:
+      set_type(types, &instr->src[0], TYPE_BOOL);
+      set_type(types, &instr->def, TYPE_BOOL);
+      break;
+   case nir_intrinsic_read_first_invocation:
+   case nir_intrinsic_quad_swap_horizontal:
+   case nir_intrinsic_quad_swap_vertical:
+   case nir_intrinsic_quad_swap_diagonal:
+      set_type(types, &instr->src[0], TYPE_GENERIC_DATA);
+      set_type(types, &instr->def, TYPE_GENERIC_DATA);
+      break;
+   case nir_intrinsic_read_invocation:
+   case nir_intrinsic_quad_broadcast:
+   case nir_intrinsic_shuffle:
+   case nir_intrinsic_shuffle_down:
+   case nir_intrinsic_shuffle_up:
+   case nir_intrinsic_shuffle_xor:
+      set_type(types, &instr->src[0], TYPE_GENERIC_DATA);
+      set_type(types, &instr->def, TYPE_GENERIC_DATA);
+      set_type(types, &instr->src[1], TYPE_UINT);
+      break;
+   case nir_intrinsic_reduce:
+      switch (nir_intrinsic_reduction_op(instr)) {
+      case nir_op_iand:
+      case nir_op_ior:
+      case nir_op_ixor:
+      case nir_op_iadd:
+      case nir_op_imul:
+         set_type(types, &instr->src[0], TYPE_GENERIC_INT);
+         set_type(types, &instr->def, TYPE_GENERIC_INT);
+         break;
+      case nir_op_imax:
+      case nir_op_imin:
+         set_type(types, &instr->src[0], TYPE_INT);
+         set_type(types, &instr->def, TYPE_INT);
+         break;
+      case nir_op_umax:
+      case nir_op_umin:
+         set_type(types, &instr->src[0], TYPE_UINT);
+         set_type(types, &instr->def, TYPE_UINT);
+         break;
+      case nir_op_fadd:
+      case nir_op_fmax:
+      case nir_op_fmin:
+      case nir_op_fmul:
+         set_type(types, &instr->src[0], TYPE_FLOAT);
+         set_type(types, &instr->def, TYPE_FLOAT);
+         break;
+      default:
+         break;
+      }
+      break;
+   default:
+      break;
+   }
+}
+
+static void
+infer_types_from_tex(struct hash_table *types, nir_tex_instr *tex)
+{
+   set_type(types, &tex->def, ti_type_from_nir(tex->dest_type));
+   for (int i = 0; i < tex->num_srcs; i++) {
+      nir_src *src = &tex->src[i].src;
+      switch (tex->src[i].src_type) {
+      case nir_tex_src_coord:
+         if (tex->op == nir_texop_txf || tex->op == nir_texop_txf_ms)
+            set_type(types, src, TYPE_UINT);
+         else
+            set_type(types, src, TYPE_FLOAT);
+         break;
+      case nir_tex_src_comparator:
+         set_type(types, src, TYPE_FLOAT);
+         break;
+      case nir_tex_src_offset:
+         set_type(types, src, TYPE_INT);
+         break;
+      case nir_tex_src_bias:
+         set_type(types, src, TYPE_FLOAT);
+         break;
+      case nir_tex_src_lod:
+         if (tex->op == nir_texop_txf || tex->op == nir_texop_txf_ms ||
+             tex->op == nir_texop_txs)
+            set_type(types, src, TYPE_UINT);
+         else
+            set_type(types, src, TYPE_FLOAT);
+         break;
+      case nir_tex_src_min_lod:
+         set_type(types, src, TYPE_FLOAT);
+         break;
+      case nir_tex_src_ms_index:
+         set_type(types, src, TYPE_UINT);
+         break;
+      case nir_tex_src_ddx:
+      case nir_tex_src_ddy:
+         set_type(types, src, TYPE_FLOAT);
+         break;
+      default:
+         break;
+      }
+   }
+}
+
+static void
+infer_types_from_instr(struct hash_table *types, nir_instr *instr)
+{
+   switch (instr->type) {
+   case nir_instr_type_alu:
+      infer_types_from_alu(types, nir_instr_as_alu(instr));
+      return;
+   case nir_instr_type_intrinsic:
+      infer_types_from_intrinsic(types, nir_instr_as_intrinsic(instr));
+      return;
+   case nir_instr_type_tex:
+      infer_types_from_tex(types, nir_instr_as_tex(instr));
+      break;
+   default:
+      break;
+   }
+}
+
+static bool
+propagate_types(struct hash_table *types, nir_instr *instr)
+{
+   bool progress = false;
+   switch (instr->type) {
+   case nir_instr_type_alu: {
+      nir_alu_instr *alu = nir_instr_as_alu(instr);
+      nir_op_info info = nir_op_infos[alu->op];
+      for (int i = 0; i < info.num_inputs; i++) {
+         ti_type src_type = get_type(types, &alu->src[i].src);
+         ti_type def_type = get_type(types, alu->src[i].src.ssa);
+         ti_type unified_type = unify_types(src_type, def_type);
+         nir_instr *parent_instr = alu->src[i].src.ssa->parent_instr;
+         if (unified_type > src_type) {
+            progress |= update_instr_type(types, instr, unified_type);
+         } else if (unified_type > def_type) {
+            progress |= update_instr_type(types, parent_instr, unified_type);
+         }
+      }
+      break;
+   }
+   case nir_instr_type_intrinsic: {
+      nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
+      nir_intrinsic_info info = nir_intrinsic_infos[intr->intrinsic];
+      for (int i = 0; i < info.num_srcs; i++) {
+         ti_type src_type = get_type(types, &intr->src[i]);
+         ti_type def_type = get_type(types, intr->src[i].ssa);
+         ti_type unified_type = unify_types(src_type, def_type);
+         nir_instr *parent_instr = intr->src[i].ssa->parent_instr;
+         if (unified_type > src_type) {
+            progress |= update_instr_type(types, instr, unified_type);
+         } else if (unified_type > def_type) {
+            progress |= update_instr_type(types, parent_instr, unified_type);
+         }
+      }
+      break;
+   }
+   case nir_instr_type_tex: {
+      nir_tex_instr *tex = nir_instr_as_tex(instr);
+      for (int i = 0; i < tex->num_srcs; i++) {
+         ti_type src_type = get_type(types, &tex->src[i].src);
+         ti_type def_type = get_type(types, tex->src[i].src.ssa);
+         ti_type unified_type = unify_types(src_type, def_type);
+         if (src_type == 0)
+            continue;
+         nir_instr *parent_instr = tex->src[i].src.ssa->parent_instr;
+         if (unified_type > def_type) {
+            progress |= update_instr_type(types, parent_instr, unified_type);
+         }
+      }
+      break;
+   }
+   default:
+      break;
+   }
+   return progress;
+}
+
+static const char *float_names[] = {"float", "float2", "float3", "float4"};
+static const char *half_names[] = {"half", "half2", "half3", "half4"};
+static const char *bool_names[] = {"bool", "bool2", "bool3", "bool4"};
+static const char *int8_names[] = {"char", "char2", "char3", "char4"};
+static const char *uint8_names[] = {"uchar", "uchar2", "uchar3", "uchar4"};
+static const char *int16_names[] = {"short", "short2", "short3", "short4"};
+static const char *uint16_names[] = {"ushort", "ushort2", "ushort3", "ushort4"};
+static const char *int32_names[] = {"int", "int2", "int3", "int4"};
+static const char *uint32_names[] = {"uint", "uint2", "uint3", "uint4"};
+static const char *int64_names[] = {"long", "long2", "long3", "long4"};
+static const char *uint64_names[] = {"ulong", "ulong2", "ulong3", "ulong4"};
+
+static const char *
+ti_type_to_msl_type(ti_type type, uint8_t bit_width, uint8_t num_components)
+{
+   switch (type) {
+   case TYPE_GENERIC_DATA:
+   case TYPE_GENERIC_INT:
+   case TYPE_GENERIC_INT_OR_BOOL:
+   case TYPE_UINT:
+      switch (bit_width) {
+      case 1:
+         return bool_names[num_components - 1];
+      case 8:
+         return uint8_names[num_components - 1];
+      case 16:
+         return uint16_names[num_components - 1];
+      case 32:
+         return uint32_names[num_components - 1];
+      case 64:
+         return uint64_names[num_components - 1];
+      default:
+         assert(!"Bad uint length");
+      }
+      break;
+   case TYPE_BOOL:
+      return bool_names[num_components - 1];
+   case TYPE_INT:
+      switch (bit_width) {
+      case 8:
+         return int8_names[num_components - 1];
+      case 16:
+         return int16_names[num_components - 1];
+      case 32:
+         return int32_names[num_components - 1];
+      case 64:
+         return int64_names[num_components - 1];
+      default:
+         assert(!"Bad uint length");
+      }
+      break;
+   case TYPE_FLOAT:
+      switch (bit_width) {
+      case 16:
+         return half_names[num_components - 1];
+      case 32:
+         return float_names[num_components - 1];
+      default:
+         assert(!"Bad float length");
+      }
+      break;
+   case TYPE_SAMPLER:
+      return "sampler";
+   default:
+      return NULL;
+   }
+
+   return NULL;
+}
+
+const char *
+msl_uint_type(uint8_t bit_size, uint8_t num_components)
+{
+   return ti_type_to_msl_type(TYPE_UINT, bit_size, num_components);
+}
+
+const char *
+msl_type_for_def(struct hash_table *types, nir_def *def)
+{
+   ti_type type = get_type(types, def);
+   return ti_type_to_msl_type(type, def->bit_size, def->num_components);
+}
+
+const char *
+msl_type_for_src(struct hash_table *types, nir_src *src)
+{
+   ti_type type = get_type(types, src);
+   // This won't necessarily work for alu srcs but for intrinsics it's fine.
+   return ti_type_to_msl_type(type, src->ssa->bit_size,
+                              src->ssa->num_components);
+}
+
+const char *
+msl_bitcast_for_src(struct hash_table *types, nir_src *src)
+{
+   ti_type src_type = get_type(types, src);
+   ti_type def_type = get_type(types, src->ssa);
+   if (nir_src_is_if(src))
+      return NULL;
+   if (src_type != def_type) {
+      /* bool types cannot use as_type casting */
+      if (src_type == TYPE_BOOL || def_type == TYPE_BOOL)
+         return NULL;
+
+      // produce bitcast _into_ src_type
+      return ti_type_to_msl_type(src_type, src->ssa->bit_size,
+                                 src->ssa->num_components);
+   } else {
+      return NULL;
+   }
+}
+
+static void
+emit_src_component(struct nir_to_msl_ctx *ctx, nir_src *src, unsigned comp)
+{
+   ti_type type = get_type(ctx->types, src);
+   switch (type) {
+   case TYPE_FLOAT: {
+      double v = nir_src_comp_as_float(*src, comp);
+      if (isinf(v)) {
+         P(ctx, "(INFINITY");
+      } else if (isnan(v)) {
+         P(ctx, "(NAN");
+      } else {
+         /* Building the types explicitly is required since the MSL compiler is
+          * too dumb to understand that "max(as_type<int>(t53), -2147483648)" is
+          * not ambiguous since both are ints and there's no room for longs.
+          * From CTS test:
+          * dEQP-VK.renderpass.suballocation.multisample.r32_sint.samples_2 */
+         if (src->ssa->bit_size == 16) {
+            P(ctx, "half(");
+         } else {
+            P(ctx, "float(");
+         }
+         P(ctx, "%.*le", DBL_DECIMAL_DIG, nir_src_comp_as_float(*src, comp));
+      }
+      break;
+   }
+   case TYPE_BOOL:
+      P(ctx, "bool(%d", nir_src_comp_as_bool(*src, comp));
+      break;
+   case TYPE_INT:
+      switch (src->ssa->bit_size) {
+      case 8:
+         P(ctx, "char(");
+         break;
+      case 16:
+         P(ctx, "short(");
+         break;
+      case 32:
+         P(ctx, "int(");
+         break;
+      case 64:
+         P(ctx, "long(");
+         break;
+      default:
+         UNREACHABLE("Incorrect bit_size for TYPE_INT");
+      }
+      P(ctx, "%" PRId64, nir_src_comp_as_int(*src, comp));
+      break;
+   case TYPE_UINT:
+   case TYPE_GENERIC_DATA:
+   case TYPE_GENERIC_INT:
+   case TYPE_GENERIC_INT_OR_BOOL:
+      switch (src->ssa->bit_size) {
+      case 8:
+         P(ctx, "uchar(");
+         break;
+      case 16:
+         P(ctx, "ushort(");
+         break;
+      case 32:
+         P(ctx, "uint(");
+         break;
+      case 64:
+         P(ctx, "ulong(");
+         break;
+      default:
+         UNREACHABLE("Incorrect bit_size for TYPE_UINT");
+      }
+      P(ctx, "%" PRIu64 "u", nir_src_comp_as_uint(*src, comp));
+      break;
+   case TYPE_NONE:
+      assert(0);
+      P(ctx, "UNTYPED!");
+      break;
+   default:
+      return;
+   }
+   P(ctx, ")");
+}
+
+void
+msl_src_as_const(struct nir_to_msl_ctx *ctx, nir_src *src)
+{
+   ti_type type = get_type(ctx->types, src);
+   if (src->ssa->num_components == 1) {
+      emit_src_component(ctx, src, 0);
+   } else {
+      P(ctx, "%s(",
+        ti_type_to_msl_type(type, src->ssa->bit_size,
+                            src->ssa->num_components));
+      for (int i = 0; i < src->ssa->num_components; i++) {
+         if (i)
+            P(ctx, ", ");
+         emit_src_component(ctx, src, i);
+      }
+      P(ctx, ")");
+   }
+}
+
+struct hash_table *
+msl_infer_types(nir_shader *shader)
+{
+   struct hash_table *types = _mesa_pointer_hash_table_create(NULL);
+   bool progress = false;
+   // First, seed the types for every instruction for every source and def
+   nir_foreach_function_impl(impl, shader) {
+      nir_foreach_block(block, impl) {
+         nir_foreach_instr(instr, block) {
+            infer_types_from_instr(types, instr);
+         }
+      }
+   }
+
+   do {
+      progress = false;
+      nir_foreach_function_impl(impl, shader) {
+         nir_foreach_block(block, impl) {
+            nir_foreach_instr(instr, block) {
+               progress |= propagate_types(types, instr);
+            }
+         }
+      }
+   } while (progress);
+   return types;
+}
+
+bool
+msl_src_is_float(struct nir_to_msl_ctx *ctx, nir_src *src)
+{
+   return get_type(ctx->types, src) == TYPE_FLOAT;
+}
+
+bool
+msl_def_is_sampler(struct nir_to_msl_ctx *ctx, nir_def *def)
+{
+   return get_type(ctx->types, def) == TYPE_SAMPLER;
+}
diff --git a/src/kosmickrisp/compiler/nir_to_msl.c b/src/kosmickrisp/compiler/nir_to_msl.c
new file mode 100644
index 00000000000..51b96bb2c62
--- /dev/null
+++ b/src/kosmickrisp/compiler/nir_to_msl.c
@@ -0,0 +1,2051 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "nir_to_msl.h"
+#include "msl_private.h"
+#include "nir.h"
+
+static const char *
+get_stage_string(mesa_shader_stage stage)
+{
+   switch (stage) {
+   case MESA_SHADER_VERTEX:
+      return "vertex";
+   case MESA_SHADER_FRAGMENT:
+      return "fragment";
+   case MESA_SHADER_COMPUTE:
+      return "kernel";
+   default:
+      assert(0);
+      return "";
+   }
+}
+
+static const char *
+get_entrypoint_name(nir_shader *shader)
+{
+   return nir_shader_get_entrypoint(shader)->function->name;
+}
+
+static const char *sysval_table[SYSTEM_VALUE_MAX] = {
+   [SYSTEM_VALUE_SUBGROUP_SIZE] =
+      "uint gl_SubGroupSize [[threads_per_simdgroup]]",
+   [SYSTEM_VALUE_SUBGROUP_INVOCATION] =
+      "uint gl_SubGroupInvocation [[thread_index_in_simdgroup]]",
+   [SYSTEM_VALUE_NUM_SUBGROUPS] =
+      "uint gl_NumSubGroups [[simdgroups_per_threadgroup]]",
+   [SYSTEM_VALUE_SUBGROUP_ID] =
+      "uint gl_SubGroupID [[simdgroup_index_in_threadgroup]]",
+   [SYSTEM_VALUE_WORKGROUP_ID] =
+      "uint3 gl_WorkGroupID [[threadgroup_position_in_grid]]",
+   [SYSTEM_VALUE_LOCAL_INVOCATION_ID] =
+      "uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]",
+   [SYSTEM_VALUE_GLOBAL_INVOCATION_ID] =
+      "uint3 gl_GlobalInvocationID [[thread_position_in_grid]]",
+   [SYSTEM_VALUE_NUM_WORKGROUPS] =
+      "uint3 gl_NumWorkGroups [[threadgroups_per_grid]]",
+   [SYSTEM_VALUE_LOCAL_INVOCATION_INDEX] =
+      "uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]]",
+   [SYSTEM_VALUE_VERTEX_ID] = "uint gl_VertexID [[vertex_id]]",
+   [SYSTEM_VALUE_INSTANCE_ID] = "uint gl_InstanceID [[instance_id]]",
+   [SYSTEM_VALUE_BASE_INSTANCE] = "uint gl_BaseInstance [[base_instance]]",
+   [SYSTEM_VALUE_FRAG_COORD] = "float4 gl_FragCoord [[position]]",
+   [SYSTEM_VALUE_POINT_COORD] = "float2 gl_PointCoord [[point_coord]]",
+   [SYSTEM_VALUE_FRONT_FACE] = "bool gl_FrontFacing [[front_facing]]",
+   [SYSTEM_VALUE_LAYER_ID] = "uint gl_Layer [[render_target_array_index]]",
+   [SYSTEM_VALUE_SAMPLE_ID] = "uint gl_SampleID [[sample_id]]",
+   [SYSTEM_VALUE_SAMPLE_MASK_IN] = "uint gl_SampleMask [[sample_mask]]",
+   [SYSTEM_VALUE_AMPLIFICATION_ID_KK] =
+      "uint mtl_AmplificationID [[amplification_id]]",
+   /* These are functions and not shader input variables */
+   [SYSTEM_VALUE_HELPER_INVOCATION] = "",
+};
+
+static void
+emit_sysvals(struct nir_to_msl_ctx *ctx, nir_shader *shader)
+{
+   unsigned i;
+   BITSET_FOREACH_SET(i, shader->info.system_values_read, SYSTEM_VALUE_MAX) {
+      assert(sysval_table[i]);
+      if (sysval_table[i] && sysval_table[i][0])
+         P_IND(ctx, "%s,\n", sysval_table[i]);
+   }
+}
+
+static void
+emit_inputs(struct nir_to_msl_ctx *ctx, nir_shader *shader)
+{
+   switch (shader->info.stage) {
+   case MESA_SHADER_FRAGMENT:
+      P_IND(ctx, "FragmentIn in [[stage_in]],\n");
+      break;
+   default:
+      break;
+   }
+   P_IND(ctx, "constant Buffer &buf0 [[buffer(0)]],\n");
+   P_IND(ctx, "constant SamplerTable &sampler_table [[buffer(1)]]\n");
+}
+
+static const char *
+output_type(nir_shader *shader)
+{
+   switch (shader->info.stage) {
+   case MESA_SHADER_VERTEX:
+      return "VertexOut";
+   case MESA_SHADER_FRAGMENT:
+      return "FragmentOut";
+   default:
+      return "void";
+   }
+}
+
+static void
+emit_local_vars(struct nir_to_msl_ctx *ctx, nir_shader *shader)
+{
+   if (shader->info.shared_size) {
+      P_IND(ctx, "threadgroup char shared_data[%d];\n",
+            shader->info.shared_size);
+   }
+   if (shader->scratch_size) {
+      P_IND(ctx, "uchar scratch[%d] = {0};\n", shader->scratch_size);
+   }
+   if (BITSET_TEST(shader->info.system_values_read,
+                   SYSTEM_VALUE_HELPER_INVOCATION)) {
+      P_IND(ctx, "bool gl_HelperInvocation = simd_is_helper_thread();\n");
+   }
+}
+
+static bool
+is_register(nir_def *def)
+{
+   return ((def->parent_instr->type == nir_instr_type_intrinsic) &&
+           (nir_instr_as_intrinsic(def->parent_instr)->intrinsic ==
+            nir_intrinsic_load_reg));
+}
+
+static void
+writemask_to_msl(struct nir_to_msl_ctx *ctx, unsigned write_mask,
+                 unsigned num_components)
+{
+   if (num_components != util_bitcount(write_mask)) {
+      P(ctx, ".");
+      for (unsigned i = 0; i < num_components; i++)
+         if ((write_mask >> i) & 1)
+            P(ctx, "%c", "xyzw"[i]);
+   }
+}
+
+static void
+src_to_msl(struct nir_to_msl_ctx *ctx, nir_src *src)
+{
+   /* Pointer types cannot use as_type casting */
+   const char *bitcast = msl_bitcast_for_src(ctx->types, src);
+   if (nir_src_is_const(*src)) {
+      msl_src_as_const(ctx, src);
+      return;
+   }
+   if (nir_src_is_undef(*src)) {
+      if (src->ssa->num_components == 1) {
+         P(ctx, "00");
+      } else {
+         P(ctx, "%s(", msl_type_for_src(ctx->types, src));
+         for (int i = 0; i < src->ssa->num_components; i++) {
+            if (i)
+               P(ctx, ", ");
+            P(ctx, "00");
+         }
+         P(ctx, ")");
+      }
+      return;
+   }
+
+   if (bitcast)
+      P(ctx, "as_type<%s>(", bitcast);
+   if (is_register(src->ssa)) {
+      nir_intrinsic_instr *instr =
+         nir_instr_as_intrinsic(src->ssa->parent_instr);
+      if (src->ssa->bit_size != 1u) {
+         P(ctx, "as_type<%s>(r%d)", msl_type_for_def(ctx->types, src->ssa),
+           instr->src[0].ssa->index);
+      } else {
+         P(ctx, "%s(r%d)", msl_type_for_def(ctx->types, src->ssa),
+           instr->src[0].ssa->index);
+      }
+   } else if (nir_src_is_const(*src)) {
+      msl_src_as_const(ctx, src);
+   } else {
+      P(ctx, "t%d", src->ssa->index);
+   }
+   if (bitcast)
+      P(ctx, ")");
+}
+
+static void
+alu_src_to_msl(struct nir_to_msl_ctx *ctx, nir_alu_instr *instr, int srcn)
+{
+   nir_alu_src *src = &instr->src[srcn];
+   src_to_msl(ctx, &src->src);
+   if (!nir_alu_src_is_trivial_ssa(instr, srcn) &&
+       src->src.ssa->num_components > 1) {
+      int num_components = nir_src_num_components(src->src);
+      assert(num_components <= 4);
+
+      P(ctx, ".");
+      for (int i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) {
+         if (!nir_alu_instr_channel_used(instr, srcn, i))
+            continue;
+         P(ctx, "%c", "xyzw"[src->swizzle[i]]);
+      }
+   }
+}
+
+static void
+alu_funclike(struct nir_to_msl_ctx *ctx, nir_alu_instr *instr, const char *name)
+{
+   const nir_op_info *info = &nir_op_infos[instr->op];
+   P(ctx, "%s(", name);
+   for (int i = 0; i < info->num_inputs; i++) {
+      alu_src_to_msl(ctx, instr, i);
+      if (i < info->num_inputs - 1)
+         P(ctx, ", ");
+   }
+   P(ctx, ")");
+}
+
+static void
+alu_to_msl(struct nir_to_msl_ctx *ctx, nir_alu_instr *instr)
+{
+
+#define ALU_BINOP(op)                                                          \
+   do {                                                                        \
+      alu_src_to_msl(ctx, instr, 0);                                           \
+      P(ctx, " %s ", op);                                                      \
+      alu_src_to_msl(ctx, instr, 1);                                           \
+   } while (0);
+
+   switch (instr->op) {
+   case nir_op_isign:
+      alu_src_to_msl(ctx, instr, 0);
+      P(ctx, " == 0 ? 0.0 : ((");
+      alu_src_to_msl(ctx, instr, 0);
+      P(ctx, " < 0) ? -1 : 1)");
+      break;
+   case nir_op_iadd:
+   case nir_op_fadd:
+      ALU_BINOP("+");
+      break;
+   case nir_op_uadd_sat:
+   case nir_op_iadd_sat:
+      alu_funclike(ctx, instr, "addsat");
+      break;
+   case nir_op_isub:
+   case nir_op_fsub:
+      ALU_BINOP("-");
+      break;
+   case nir_op_imul:
+   case nir_op_fmul:
+      ALU_BINOP("*");
+      break;
+   case nir_op_idiv:
+   case nir_op_udiv:
+   case nir_op_fdiv:
+      ALU_BINOP("/");
+      break;
+   case nir_op_irem:
+      ALU_BINOP("%");
+      break;
+   case nir_op_ishl:
+      ALU_BINOP("<<");
+      break;
+   case nir_op_ishr:
+   case nir_op_ushr:
+      ALU_BINOP(">>");
+      break;
+   case nir_op_ige:
+   case nir_op_uge:
+   case nir_op_fge:
+      ALU_BINOP(">=");
+      break;
+   case nir_op_ilt:
+   case nir_op_ult:
+   case nir_op_flt:
+      ALU_BINOP("<")
+      break;
+   case nir_op_iand:
+      ALU_BINOP("&");
+      break;
+   case nir_op_ior:
+      ALU_BINOP("|");
+      break;
+   case nir_op_ixor:
+      ALU_BINOP("^");
+      break;
+   case nir_op_bitfield_insert:
+      alu_funclike(ctx, instr, "insert_bits");
+      break;
+   case nir_op_ibitfield_extract:
+   case nir_op_ubitfield_extract:
+      alu_funclike(ctx, instr, "extract_bits");
+      break;
+   case nir_op_bitfield_reverse:
+      alu_funclike(ctx, instr, "reverse_bits");
+      break;
+   case nir_op_bit_count:
+      alu_funclike(ctx, instr, "popcount");
+      break;
+   case nir_op_uclz:
+      alu_funclike(ctx, instr, "clz");
+      break;
+   case nir_op_ieq:
+   case nir_op_feq:
+      ALU_BINOP("==");
+      break;
+   case nir_op_ine:
+   case nir_op_fneu:
+      ALU_BINOP("!=");
+      break;
+   case nir_op_umax:
+   case nir_op_imax:
+      alu_funclike(ctx, instr, "max");
+      break;
+   case nir_op_umin:
+   case nir_op_imin:
+      alu_funclike(ctx, instr, "min");
+      break;
+   case nir_op_umod:
+   case nir_op_imod:
+      ALU_BINOP("%");
+      break;
+   case nir_op_imul_high:
+   case nir_op_umul_high:
+      alu_funclike(ctx, instr, "mulhi");
+      break;
+   case nir_op_usub_sat:
+      alu_funclike(ctx, instr, "subsat");
+      break;
+   case nir_op_fsat:
+      alu_funclike(ctx, instr, "saturate");
+      break;
+   /* Functions from <metal_relational> */
+   case nir_op_fisfinite:
+      alu_funclike(ctx, instr, "isfinite");
+      break;
+   case nir_op_fisnormal:
+      alu_funclike(ctx, instr, "isnormal");
+      break;
+   /* Functions from <metal_math> */
+   case nir_op_iabs:
+   case nir_op_fabs:
+      alu_funclike(ctx, instr, "abs");
+      break;
+   case nir_op_fceil:
+      alu_funclike(ctx, instr, "ceil");
+      break;
+   case nir_op_fcos:
+      alu_funclike(ctx, instr, "cos");
+      break;
+   case nir_op_fdot2:
+   case nir_op_fdot3:
+   case nir_op_fdot4:
+      alu_funclike(ctx, instr, "dot");
+      break;
+   case nir_op_fexp2:
+      alu_funclike(ctx, instr, "exp2");
+      break;
+   case nir_op_ffloor:
+      alu_funclike(ctx, instr, "floor");
+      break;
+   case nir_op_ffma:
+      alu_funclike(ctx, instr, "fma");
+      break;
+   case nir_op_ffract:
+      alu_funclike(ctx, instr, "fract");
+      break;
+   case nir_op_flog2:
+      alu_funclike(ctx, instr, "log2");
+      break;
+   case nir_op_flrp:
+      alu_funclike(ctx, instr, "mix");
+      break;
+   case nir_op_fmax:
+      alu_funclike(ctx, instr, "fmax");
+      break;
+   case nir_op_fmin:
+      alu_funclike(ctx, instr, "fmin");
+      break;
+   case nir_op_frem:
+      alu_funclike(ctx, instr, "fmod");
+      break;
+   case nir_op_fpow:
+      alu_funclike(ctx, instr, "pow");
+      break;
+   case nir_op_fround_even:
+      alu_funclike(ctx, instr, "rint");
+      break;
+   case nir_op_frsq:
+      alu_funclike(ctx, instr, "rsqrt");
+      break;
+   case nir_op_fsign:
+      alu_funclike(ctx, instr, "sign");
+      break;
+   case nir_op_fsqrt:
+      alu_funclike(ctx, instr, "sqrt");
+      break;
+   case nir_op_fsin:
+      alu_funclike(ctx, instr, "sin");
+      break;
+   case nir_op_ldexp:
+      alu_funclike(ctx, instr, "ldexp");
+      break;
+   case nir_op_ftrunc:
+      alu_funclike(ctx, instr, "trunc");
+      break;
+   case nir_op_pack_snorm_4x8:
+      alu_funclike(ctx, instr, "pack_float_to_snorm4x8");
+      break;
+   case nir_op_pack_unorm_4x8:
+      alu_funclike(ctx, instr, "pack_float_to_unorm4x8");
+      break;
+   case nir_op_pack_snorm_2x16:
+      alu_funclike(ctx, instr, "pack_float_to_snorm2x16");
+      break;
+   case nir_op_pack_unorm_2x16:
+      alu_funclike(ctx, instr, "pack_float_to_unorm2x16");
+      break;
+   case nir_op_unpack_snorm_4x8:
+      alu_funclike(ctx, instr, "unpack_snorm4x8_to_float");
+      break;
+   case nir_op_unpack_unorm_4x8:
+      alu_funclike(ctx, instr, "unpack_unorm4x8_to_float");
+      break;
+   case nir_op_unpack_snorm_2x16:
+      alu_funclike(ctx, instr, "unpack_snorm2x16_to_float");
+      break;
+   case nir_op_unpack_unorm_2x16:
+      alu_funclike(ctx, instr, "unpack_unorm2x16_to_float");
+      break;
+   case nir_op_vec2:
+   case nir_op_vec3:
+   case nir_op_vec4:
+   case nir_op_b2b1:
+   case nir_op_b2b32:
+   case nir_op_b2i8:
+   case nir_op_b2i16:
+   case nir_op_b2i32:
+   case nir_op_b2i64:
+   case nir_op_b2f16:
+   case nir_op_i2f16:
+   case nir_op_u2f16:
+   case nir_op_i2f32:
+   case nir_op_u2f32:
+   case nir_op_i2i8:
+   case nir_op_i2i16:
+   case nir_op_i2i32:
+   case nir_op_i2i64:
+   case nir_op_f2i8:
+   case nir_op_f2i16:
+   case nir_op_f2i32:
+   case nir_op_f2i64:
+   case nir_op_f2u8:
+   case nir_op_f2u16:
+   case nir_op_f2u32:
+   case nir_op_f2u64:
+   case nir_op_u2u8:
+   case nir_op_u2u16:
+   case nir_op_u2u32:
+   case nir_op_u2u64:
+   case nir_op_f2f16:
+   case nir_op_f2f16_rtne:
+   case nir_op_f2f32:
+      alu_funclike(ctx, instr, msl_type_for_def(ctx->types, &instr->def));
+      break;
+   case nir_op_unpack_half_2x16_split_x:
+      P(ctx, "float(as_type<half>(ushort(t%d & 0x0000ffff)))",
+        instr->src[0].src.ssa->index);
+      break;
+   case nir_op_frcp:
+      P(ctx, "1/");
+      alu_src_to_msl(ctx, instr, 0);
+      break;
+   case nir_op_inot:
+      if (instr->src[0].src.ssa->bit_size == 1) {
+         P(ctx, "!");
+      } else {
+         P(ctx, "~");
+      }
+      alu_src_to_msl(ctx, instr, 0);
+      break;
+   case nir_op_ineg:
+   case nir_op_fneg:
+      P(ctx, "-");
+      alu_src_to_msl(ctx, instr, 0);
+      break;
+   case nir_op_mov:
+      alu_src_to_msl(ctx, instr, 0);
+      break;
+   case nir_op_b2f32:
+      alu_src_to_msl(ctx, instr, 0);
+      P(ctx, " ? 1.0 : 0.0");
+      break;
+   case nir_op_bcsel:
+      alu_src_to_msl(ctx, instr, 0);
+      P(ctx, " ? ");
+      alu_src_to_msl(ctx, instr, 1);
+      P(ctx, " : ");
+      alu_src_to_msl(ctx, instr, 2);
+      break;
+   default:
+      P(ctx, "ALU %s", nir_op_infos[instr->op].name);
+   }
+}
+
+static const char *
+texture_dim(enum glsl_sampler_dim dim)
+{
+   switch (dim) {
+   case GLSL_SAMPLER_DIM_1D:
+      return "1d";
+   case GLSL_SAMPLER_DIM_2D:
+      return "2d";
+   case GLSL_SAMPLER_DIM_3D:
+      return "3d";
+   case GLSL_SAMPLER_DIM_CUBE:
+      return "cube";
+   case GLSL_SAMPLER_DIM_BUF:
+      return "_buffer";
+   case GLSL_SAMPLER_DIM_MS:
+      return "2d_ms";
+   default:
+      fprintf(stderr, "Bad texture dim %d\n", dim);
+      assert(!"Bad texture dimension");
+      return "BAD";
+   }
+}
+
+static const char *
+tex_type_name(nir_alu_type ty)
+{
+   switch (ty) {
+   case nir_type_int16:
+      return "short";
+   case nir_type_int32:
+      return "int";
+   case nir_type_uint16:
+      return "ushort";
+   case nir_type_uint32:
+      return "uint";
+   case nir_type_float16:
+      return "half";
+   case nir_type_float32:
+      return "float";
+   default:
+      return "BAD";
+   }
+}
+
+static bool
+instrinsic_needs_dest_type(nir_intrinsic_instr *instr)
+{
+   const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
+   nir_intrinsic_op op = instr->intrinsic;
+   if (op == nir_intrinsic_decl_reg || op == nir_intrinsic_load_reg ||
+       op == nir_intrinsic_load_texture_handle_kk ||
+       op == nir_intrinsic_load_depth_texture_kk ||
+       /* Atomic swaps have a custom codegen */
+       op == nir_intrinsic_global_atomic_swap ||
+       op == nir_intrinsic_shared_atomic_swap ||
+       op == nir_intrinsic_bindless_image_atomic_swap)
+      return false;
+   return info->has_dest;
+}
+
+static const char *
+msl_pipe_format_to_msl_type(enum pipe_format format)
+{
+   switch (format) {
+   case PIPE_FORMAT_R16_FLOAT:
+      return "half";
+   case PIPE_FORMAT_R32_FLOAT:
+      return "float";
+   case PIPE_FORMAT_R8_UINT:
+      return "uchar";
+   case PIPE_FORMAT_R16_UINT:
+      return "ushort";
+   case PIPE_FORMAT_R32_UINT:
+      return "uint";
+   case PIPE_FORMAT_R64_UINT:
+      return "unsigned long";
+   case PIPE_FORMAT_R8_SINT:
+      return "char";
+   case PIPE_FORMAT_R16_SINT:
+      return "short";
+   case PIPE_FORMAT_R32_SINT:
+      return "int";
+   case PIPE_FORMAT_R64_SINT:
+      return "long";
+   default:
+      assert(0);
+      return "";
+   }
+}
+
+static const char *
+component_str(uint8_t num_components)
+{
+   switch (num_components) {
+   default:
+   case 1:
+      return "";
+   case 2:
+      return "2";
+   case 3:
+      return "3";
+   case 4:
+      return "4";
+   }
+}
+
+static void
+round_src_component_to_uint(struct nir_to_msl_ctx *ctx, nir_src *src,
+                            char component)
+{
+   bool is_float = msl_src_is_float(ctx, src);
+   if (is_float) {
+      P(ctx, "uint(rint(");
+   }
+   src_to_msl(ctx, src);
+   P(ctx, ".%c", component);
+   if (is_float) {
+      P(ctx, "))");
+   }
+}
+
+static void
+texture_src_coord_swizzle(struct nir_to_msl_ctx *ctx, nir_src *coord,
+                          uint32_t num_components, bool is_cube, bool is_array)
+{
+   src_to_msl(ctx, coord);
+
+   uint32_t coord_components =
+      num_components - (uint32_t)is_array - (uint32_t)is_cube;
+   if (coord_components < coord->ssa->num_components) {
+      const char *swizzle = "xyzw";
+      uint32_t i = 0;
+      P(ctx, ".");
+      for (i = 0; i < coord_components; i++)
+         P(ctx, "%c", swizzle[i]);
+
+      if (is_cube) {
+         P(ctx, ", ");
+         round_src_component_to_uint(ctx, coord, swizzle[i++]);
+      }
+      if (is_array) {
+         P(ctx, ", ");
+         round_src_component_to_uint(ctx, coord, swizzle[i++]);
+      }
+   }
+}
+
+static void
+image_coord_swizzle(struct nir_to_msl_ctx *ctx, nir_intrinsic_instr *instr)
+{
+   unsigned comps = 0;
+   bool is_array = nir_intrinsic_image_array(instr);
+   bool is_cube = false;
+   switch (nir_intrinsic_image_dim(instr)) {
+   case GLSL_SAMPLER_DIM_BUF:
+   case GLSL_SAMPLER_DIM_1D:
+      comps = 1;
+      break;
+   case GLSL_SAMPLER_DIM_2D:
+   case GLSL_SAMPLER_DIM_MS:
+      comps = 2;
+      break;
+   case GLSL_SAMPLER_DIM_3D:
+      comps = 3;
+      break;
+   case GLSL_SAMPLER_DIM_CUBE:
+      comps = 3;
+      is_cube = true;
+      break;
+   default:
+      assert(!"Bad dimension for image");
+      break;
+   }
+   if (is_array)
+      comps += 1;
+
+   texture_src_coord_swizzle(ctx, &instr->src[1], comps, is_cube, is_array);
+}
+
+/* Non-packed types have stricter alignment requirements that packed types.
+ * This helps us build a packed format for storage.
+ */
+static void
+src_to_packed(struct nir_to_msl_ctx *ctx, nir_src *src, const char *type,
+              uint32_t component_count)
+{
+   if (component_count == 1) {
+      P(ctx, "%s(", type);
+   } else {
+      P(ctx, "packed_%s(", type);
+   }
+   src_to_msl(ctx, src);
+   P(ctx, ")");
+}
+
+/* Non-packed types have stricter alignment requirements that packed types.
+ * This helps us cast the pointer to a packed type and then it builds the
+ * non-packed type for Metal usage.
+ */
+static void
+src_to_packed_load(struct nir_to_msl_ctx *ctx, nir_src *src,
+                   const char *addressing, const char *type,
+                   uint32_t component_count)
+{
+   if (component_count == 1) {
+      P(ctx, "*(%s %s*)(", addressing, type);
+   } else {
+      P(ctx, "%s(*(%s packed_%s*)", type, addressing, type);
+   }
+   src_to_msl(ctx, src);
+   P(ctx, ")");
+}
+
+/* Non-packed types have stricter alignment requirements that packed types.
+ * This helps us cast the pointer to a packed type and then it builds the
+ * non-packed type for Metal usage.
+ */
+static void
+src_to_packed_load_offset(struct nir_to_msl_ctx *ctx, nir_src *src,
+                          nir_src *offset, const char *addressing,
+                          const char *type, uint32_t component_count)
+{
+   if (component_count == 1) {
+      P(ctx, "*(%s %s*)((", addressing, type);
+   } else {
+      P(ctx, "%s(*(%s packed_%s*)(", type, addressing, type);
+   }
+   src_to_msl(ctx, src);
+   P(ctx, " + ");
+   src_to_msl(ctx, offset);
+   P(ctx, "))");
+}
+
+/* Non-packed types have stricter alignment requirements that packed types.
+ * This helps us cast the pointer to a packed type for storage.
+ */
+static void
+src_to_packed_store(struct nir_to_msl_ctx *ctx, nir_src *src,
+                    const char *addressing, const char *type,
+                    uint32_t num_components)
+{
+   if (num_components == 1) {
+      P_IND(ctx, "*(%s %s*)", addressing, type);
+   } else {
+      P_IND(ctx, "*(%s packed_%s*)", addressing, type);
+   }
+   src_to_msl(ctx, src);
+}
+
+static const char *
+atomic_op_to_msl(nir_atomic_op op)
+{
+   switch (op) {
+   case nir_atomic_op_iadd:
+   case nir_atomic_op_fadd:
+      return "atomic_fetch_add";
+   case nir_atomic_op_umin:
+   case nir_atomic_op_imin:
+   case nir_atomic_op_fmin:
+      return "atomic_fetch_min";
+   case nir_atomic_op_umax:
+   case nir_atomic_op_imax:
+   case nir_atomic_op_fmax:
+      return "atomic_fetch_max";
+   case nir_atomic_op_iand:
+      return "atomic_fetch_and";
+   case nir_atomic_op_ior:
+      return "atomic_fetch_or";
+   case nir_atomic_op_ixor:
+      return "atomic_fetch_xor";
+   case nir_atomic_op_xchg:
+      return "atomic_exchange";
+   case nir_atomic_op_cmpxchg:
+   case nir_atomic_op_fcmpxchg:
+      return "atomic_compare_exchange_weak";
+   default:
+      UNREACHABLE("Unhandled atomic op");
+   }
+}
+
+static void
+atomic_to_msl(struct nir_to_msl_ctx *ctx, nir_intrinsic_instr *instr,
+              const char *scope, bool shared)
+{
+   const char *atomic_op = atomic_op_to_msl(nir_intrinsic_atomic_op(instr));
+   const char *mem_order = "memory_order_relaxed";
+
+   P(ctx, "%s_explicit((%s atomic_%s*)", atomic_op, scope,
+     msl_type_for_def(ctx->types, &instr->def));
+   if (shared)
+      P(ctx, "&shared_data[");
+   src_to_msl(ctx, &instr->src[0]);
+   if (shared)
+      P(ctx, "]");
+   P(ctx, ", ");
+   src_to_msl(ctx, &instr->src[1]);
+   P(ctx, ", %s", mem_order);
+   P(ctx, ");\n");
+}
+
+static void
+atomic_swap_to_msl(struct nir_to_msl_ctx *ctx, nir_intrinsic_instr *instr,
+                   const char *scope, bool shared)
+{
+   const char *atomic_op = atomic_op_to_msl(nir_intrinsic_atomic_op(instr));
+   const char *mem_order = "memory_order_relaxed";
+   const char *type = msl_type_for_def(ctx->types, &instr->def);
+
+   P_IND(ctx, "%s ta%d = ", type, instr->def.index);
+   src_to_msl(ctx, &instr->src[1]);
+   P(ctx, "; %s_explicit((%s atomic_%s*)", atomic_op, scope, type);
+   if (shared)
+      P(ctx, "&shared_data[");
+   src_to_msl(ctx, &instr->src[0]);
+   if (shared)
+      P(ctx, "]");
+   P(ctx, ", ");
+   P(ctx, "&ta%d, ", instr->def.index);
+   src_to_msl(ctx, &instr->src[2]);
+   P(ctx, ", %s, %s);", mem_order, mem_order);
+   P(ctx, "%s t%d = ta%d;\n", type, instr->def.index, instr->def.index);
+}
+
+static void
+memory_modes_to_msl(struct nir_to_msl_ctx *ctx, nir_variable_mode modes)
+{
+   bool requires_or = false;
+   u_foreach_bit(i, modes) {
+      nir_variable_mode single_mode = (1 << i);
+      if (requires_or)
+         P(ctx, " | ");
+      switch (single_mode) {
+      case nir_var_image:
+         P(ctx, "mem_flags::mem_texture");
+         break;
+      case nir_var_mem_ssbo:
+      case nir_var_mem_global:
+         P(ctx, "mem_flags::mem_device");
+         break;
+      case nir_var_function_temp:
+         P(ctx, "mem_flags::mem_none");
+         break;
+      case nir_var_mem_shared:
+         P(ctx, "mem_flags::mem_threadgroup");
+         break;
+      default:
+         UNREACHABLE("bad_memory_mode");
+      }
+      requires_or = true;
+   }
+}
+
+static uint32_t
+get_input_num_components(struct nir_to_msl_ctx *ctx, uint32_t location)
+{
+   return ctx->inputs_info[location].num_components;
+}
+
+static uint32_t
+get_output_num_components(struct nir_to_msl_ctx *ctx, uint32_t location)
+{
+   return ctx->outputs_info[location].num_components;
+}
+
+static void
+intrinsic_to_msl(struct nir_to_msl_ctx *ctx, nir_intrinsic_instr *instr)
+{
+   /* These instructions are only used to understand interpolation modes, they
+    * don't generate any code. */
+   if (instr->intrinsic == nir_intrinsic_load_barycentric_pixel ||
+       instr->intrinsic == nir_intrinsic_load_barycentric_centroid ||
+       instr->intrinsic == nir_intrinsic_load_barycentric_sample)
+      return;
+
+   const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
+   if (instrinsic_needs_dest_type(instr)) {
+      P_IND(ctx, "t%d = ", instr->def.index);
+   }
+   switch (instr->intrinsic) {
+   case nir_intrinsic_decl_reg: {
+      const char *reg_type = msl_uint_type(nir_intrinsic_bit_size(instr),
+                                           nir_intrinsic_num_components(instr));
+      P_IND(ctx, "%s r%d = %s(0);\n", reg_type, instr->def.index, reg_type);
+   } break;
+   case nir_intrinsic_load_reg:
+      // register loads get inlined into the uses
+      break;
+   case nir_intrinsic_store_reg:
+      P_IND(ctx, "r%d", instr->src[1].ssa->index);
+      writemask_to_msl(ctx, nir_intrinsic_write_mask(instr),
+                       instr->num_components);
+      /* Registers don't store the component count, so get it from the value we
+       * are assigning */
+      if (instr->src[0].ssa->bit_size == 1u) {
+         P(ctx, " = bool%s((", component_str(instr->num_components));
+      } else if (nir_src_is_const(instr->src[0])) {
+         /* Const vector types already build the type */
+         if (instr->src[0].ssa->num_components > 1) {
+            P(ctx, " = as_type<%s>((",
+              msl_uint_type(instr->src[0].ssa->bit_size,
+                            instr->src[0].ssa->num_components));
+         } else {
+            P(ctx, " = as_type<%s>(%s(",
+              msl_uint_type(instr->src[0].ssa->bit_size,
+                            instr->src[0].ssa->num_components),
+              msl_type_for_src(ctx->types, &instr->src[0]));
+         }
+      } else {
+         P(ctx, " = as_type<%s>((",
+           msl_uint_type(instr->src[0].ssa->bit_size,
+                         instr->src[0].ssa->num_components));
+      }
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, "));\n");
+      break;
+   case nir_intrinsic_load_subgroup_size:
+      P(ctx, "gl_SubGroupSize;\n");
+      break;
+   case nir_intrinsic_load_subgroup_invocation:
+      P(ctx, "gl_SubGroupInvocation;\n");
+      break;
+   case nir_intrinsic_load_num_subgroups:
+      P(ctx, "gl_NumSubGroups;\n");
+      break;
+   case nir_intrinsic_load_subgroup_id:
+      P(ctx, "gl_SubGroupID;\n");
+      break;
+   case nir_intrinsic_load_workgroup_id:
+      P(ctx, "gl_WorkGroupID;\n");
+      break;
+   case nir_intrinsic_load_local_invocation_id:
+      P(ctx, "gl_LocalInvocationID;\n");
+      break;
+   case nir_intrinsic_load_global_invocation_id:
+      P(ctx, "gl_GlobalInvocationID;\n");
+      break;
+   case nir_intrinsic_load_num_workgroups:
+      P(ctx, "gl_NumWorkGroups;\n");
+      break;
+   case nir_intrinsic_load_local_invocation_index:
+      P(ctx, "gl_LocalInvocationIndex;\n");
+      break;
+   case nir_intrinsic_load_frag_coord:
+      P(ctx, "gl_FragCoord;\n");
+      break;
+   case nir_intrinsic_load_point_coord:
+      P(ctx, "gl_PointCoord;\n");
+      break;
+   case nir_intrinsic_load_vertex_id:
+      P(ctx, "gl_VertexID;\n");
+      break;
+   case nir_intrinsic_load_instance_id:
+      P(ctx, "gl_InstanceID;\n");
+      break;
+   case nir_intrinsic_load_base_instance:
+      P(ctx, "gl_BaseInstance;\n");
+      break;
+   case nir_intrinsic_load_helper_invocation:
+      P(ctx, "gl_HelperInvocation;\n");
+      break;
+   case nir_intrinsic_is_helper_invocation:
+      P(ctx, "simd_is_helper_thread();\n");
+      break;
+   case nir_intrinsic_ddx:
+   case nir_intrinsic_ddx_coarse:
+   case nir_intrinsic_ddx_fine:
+      P(ctx, "dfdx(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ");\n");
+      break;
+   case nir_intrinsic_ddy:
+   case nir_intrinsic_ddy_coarse:
+   case nir_intrinsic_ddy_fine:
+      P(ctx, "dfdy(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ");\n");
+      break;
+   case nir_intrinsic_load_front_face:
+      P(ctx, "gl_FrontFacing;\n");
+      break;
+   case nir_intrinsic_load_layer_id:
+      P(ctx, "gl_Layer;\n");
+      break;
+   case nir_intrinsic_load_sample_id:
+      P(ctx, "gl_SampleID;\n");
+      break;
+   case nir_intrinsic_load_sample_mask_in:
+      P(ctx, "gl_SampleMask;\n");
+      break;
+   case nir_intrinsic_load_amplification_id_kk:
+      P(ctx, "mtl_AmplificationID;\n");
+      break;
+   case nir_intrinsic_load_interpolated_input: {
+      unsigned idx = nir_src_as_uint(instr->src[1u]);
+      nir_io_semantics io = nir_intrinsic_io_semantics(instr);
+      uint32_t component = nir_intrinsic_component(instr);
+      uint32_t location = io.location + idx;
+      P(ctx, "in.%s", msl_input_name(ctx, location));
+      if (instr->num_components < get_input_num_components(ctx, location)) {
+         P(ctx, ".");
+         for (unsigned i = 0; i < instr->num_components; i++)
+            P(ctx, "%c", "xyzw"[component + i]);
+      }
+      P(ctx, ";\n");
+      break;
+   }
+   case nir_intrinsic_load_input: {
+      unsigned idx = nir_src_as_uint(instr->src[0u]);
+      nir_io_semantics io = nir_intrinsic_io_semantics(instr);
+      uint32_t component = nir_intrinsic_component(instr);
+      uint32_t location = io.location + idx;
+      P(ctx, "in.%s", msl_input_name(ctx, location));
+      if (instr->num_components < get_input_num_components(ctx, location)) {
+         P(ctx, ".");
+         for (unsigned i = 0; i < instr->num_components; i++)
+            P(ctx, "%c", "xyzw"[component + i]);
+      }
+      P(ctx, ";\n");
+      break;
+   }
+   case nir_intrinsic_load_output: {
+      unsigned idx = nir_src_as_uint(instr->src[0]);
+      nir_io_semantics io = nir_intrinsic_io_semantics(instr);
+      P(ctx, "out.%s;\n", msl_output_name(ctx, io.location + idx));
+      break;
+   }
+   case nir_intrinsic_store_output: {
+      uint32_t idx = nir_src_as_uint(instr->src[1]);
+      nir_io_semantics io = nir_intrinsic_io_semantics(instr);
+      uint32_t location = io.location + idx;
+      uint32_t write_mask = nir_intrinsic_write_mask(instr);
+      uint32_t component = nir_intrinsic_component(instr);
+      uint32_t dst_num_components = get_output_num_components(ctx, location);
+      uint32_t num_components = instr->num_components;
+
+      P_IND(ctx, "out.%s", msl_output_name(ctx, location));
+      if (dst_num_components > 1u) {
+         P(ctx, ".");
+         for (unsigned i = 0; i < num_components; i++)
+            if ((write_mask >> i) & 1)
+               P(ctx, "%c", "xyzw"[component + i]);
+      }
+      P(ctx, " = ");
+      src_to_msl(ctx, &instr->src[0]);
+      if (num_components > 1u) {
+         P(ctx, ".");
+         for (unsigned i = 0; i < num_components; i++)
+            if ((write_mask >> i) & 1)
+               P(ctx, "%c", "xyzw"[i]);
+      }
+      P(ctx, ";\n");
+      break;
+   }
+   case nir_intrinsic_load_push_constant: {
+      const char *ty = msl_type_for_def(ctx->types, &instr->def);
+      assert(nir_intrinsic_base(instr) == 0);
+      P(ctx, "*((constant %s*)&buf.push_consts[", ty);
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, "]);\n");
+      break;
+   }
+   case nir_intrinsic_load_buffer_ptr_kk:
+      P(ctx, "(ulong)&buf%d.contents[0];\n", nir_intrinsic_binding(instr));
+      break;
+   case nir_intrinsic_load_global: {
+      src_to_packed_load(ctx, &instr->src[0], "device",
+                         msl_type_for_def(ctx->types, &instr->def),
+                         instr->def.num_components);
+      P(ctx, ";\n");
+      break;
+   }
+   case nir_intrinsic_load_global_constant: {
+      src_to_packed_load(ctx, &instr->src[0], "constant",
+                         msl_type_for_def(ctx->types, &instr->def),
+                         instr->def.num_components);
+      P(ctx, ";\n");
+      break;
+   }
+   case nir_intrinsic_load_global_constant_bounded: {
+      src_to_msl(ctx, &instr->src[1]);
+      P(ctx, " < ");
+      src_to_msl(ctx, &instr->src[2]);
+      P(ctx, " ? ");
+      src_to_packed_load_offset(ctx, &instr->src[0], &instr->src[1], "constant",
+                                msl_type_for_def(ctx->types, &instr->def),
+                                instr->def.num_components);
+      P(ctx, " : 0;\n");
+      break;
+   }
+   case nir_intrinsic_load_global_constant_offset: {
+      src_to_packed_load_offset(ctx, &instr->src[0], &instr->src[1], "device",
+                                msl_type_for_def(ctx->types, &instr->def),
+                                instr->def.num_components);
+      P(ctx, ";\n");
+      break;
+   }
+   case nir_intrinsic_global_atomic:
+      atomic_to_msl(ctx, instr, "device", false);
+      break;
+   case nir_intrinsic_global_atomic_swap:
+      atomic_swap_to_msl(ctx, instr, "device", false);
+      break;
+   case nir_intrinsic_shared_atomic:
+      atomic_to_msl(ctx, instr, "threadgroup", true);
+      break;
+   case nir_intrinsic_shared_atomic_swap:
+      atomic_swap_to_msl(ctx, instr, "threadgroup", true);
+      break;
+   case nir_intrinsic_store_global: {
+      const char *type = msl_type_for_src(ctx->types, &instr->src[0]);
+      src_to_packed_store(ctx, &instr->src[1], "device", type,
+                          instr->src[0].ssa->num_components);
+      writemask_to_msl(ctx, nir_intrinsic_write_mask(instr),
+                       instr->num_components);
+      P(ctx, " = ")
+      src_to_packed(ctx, &instr->src[0], type,
+                    instr->src[0].ssa->num_components);
+      P(ctx, ";\n");
+      break;
+   }
+   case nir_intrinsic_barrier: {
+      mesa_scope execution_scope = nir_intrinsic_execution_scope(instr);
+      nir_variable_mode memory_modes = nir_intrinsic_memory_modes(instr);
+      if (execution_scope == SCOPE_SUBGROUP) {
+         P_IND(ctx, "simdgroup_barrier(");
+         memory_modes_to_msl(ctx, memory_modes);
+      } else if (execution_scope == SCOPE_WORKGROUP) {
+         P_IND(ctx, "threadgroup_barrier(");
+         memory_modes_to_msl(ctx, memory_modes);
+      } else if (execution_scope == SCOPE_NONE) {
+         /* Empty barrier */
+         if (memory_modes == 0u)
+            break;
+
+         P_IND(ctx, "atomic_thread_fence(");
+         memory_modes_to_msl(ctx, memory_modes);
+         P(ctx, ", memory_order_seq_cst, ");
+         switch (nir_intrinsic_memory_scope(instr)) {
+         case SCOPE_SUBGROUP:
+            P(ctx, "thread_scope::thread_scope_simdgroup");
+            break;
+         case SCOPE_WORKGROUP:
+            /* TODO_KOSMICKRISP This if case should not be needed but we fail
+             * the following CTS tests otherwise:
+             * dEQP-VK.memory_model.*.ext.u32.*coherent.*.atomicwrite.workgroup.payload_*local.*.guard_local.*.comp
+             * The last two wild cards being either 'workgroup' or 'physbuffer'
+             */
+            if (memory_modes &
+                (nir_var_mem_global | nir_var_mem_ssbo | nir_var_image)) {
+               P(ctx, "thread_scope::thread_scope_device");
+            } else {
+               P(ctx, "thread_scope::thread_scope_threadgroup");
+            }
+
+            break;
+         case SCOPE_QUEUE_FAMILY:
+         case SCOPE_DEVICE:
+            P(ctx, "thread_scope::thread_scope_device");
+            break;
+         default:
+            P(ctx, "bad_scope");
+            assert(!"bad scope");
+            break;
+         }
+      } else {
+         UNREACHABLE("bad_execution scope");
+      }
+      P(ctx, ");\n");
+      break;
+   }
+   case nir_intrinsic_demote:
+      P_IND(ctx, "discard_fragment();\n");
+      break;
+   case nir_intrinsic_demote_if:
+      P_IND(ctx, "if (")
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ")\n");
+      ctx->indentlevel++;
+      P_IND(ctx, "discard_fragment();\n");
+      ctx->indentlevel--;
+      break;
+   case nir_intrinsic_terminate:
+      P_IND(ctx, "discard_fragment();\n");
+      P_IND(ctx, "return {};\n");
+      break;
+   case nir_intrinsic_terminate_if:
+      P_IND(ctx, "if (")
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ") {\n");
+      ctx->indentlevel++;
+      P_IND(ctx, "discard_fragment();\n");
+      P_IND(ctx, "return {};\n");
+      ctx->indentlevel--;
+      P_IND(ctx, "}\n");
+      break;
+   case nir_intrinsic_load_shared:
+      assert(nir_intrinsic_base(instr) == 0);
+      P(ctx, "*(threadgroup %s*)&shared_data[",
+        msl_type_for_def(ctx->types, &instr->def));
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, "];\n");
+      break;
+   case nir_intrinsic_store_shared:
+      assert(nir_intrinsic_base(instr) == 0);
+      P_IND(ctx, "(*(threadgroup %s*)&shared_data[",
+            msl_type_for_src(ctx->types, &instr->src[0]));
+      src_to_msl(ctx, &instr->src[1]);
+      P(ctx, "])");
+      writemask_to_msl(ctx, nir_intrinsic_write_mask(instr),
+                       instr->num_components);
+      P(ctx, " = ");
+      src_to_msl(ctx, &instr->src[0]);
+      if (instr->src[0].ssa->num_components > 1)
+         writemask_to_msl(ctx, nir_intrinsic_write_mask(instr),
+                          instr->num_components);
+      P(ctx, ";\n");
+      break;
+   case nir_intrinsic_load_scratch:
+      P(ctx, "*(thread %s*)&scratch[",
+        msl_type_for_def(ctx->types, &instr->def));
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, "];\n");
+      break;
+   case nir_intrinsic_store_scratch:
+      P_IND(ctx, "(*(thread %s*)&scratch[",
+            msl_type_for_src(ctx->types, &instr->src[0]));
+      src_to_msl(ctx, &instr->src[1]);
+      P(ctx, "])");
+      writemask_to_msl(ctx, nir_intrinsic_write_mask(instr),
+                       instr->num_components);
+      P(ctx, " = ");
+      src_to_msl(ctx, &instr->src[0]);
+      if (instr->src[0].ssa->num_components > 1)
+         writemask_to_msl(ctx, nir_intrinsic_write_mask(instr),
+                          instr->num_components);
+      P(ctx, ";\n");
+      break;
+   case nir_intrinsic_load_texture_handle_kk: {
+      const char *access = "";
+      switch (nir_intrinsic_flags(instr)) {
+      case MSL_ACCESS_READ:
+         access = ", access::read";
+         break;
+      case MSL_ACCESS_WRITE:
+         access = ", access::write";
+         break;
+      case MSL_ACCESS_READ_WRITE:
+         access = ", access::read_write";
+         break;
+      }
+      P_IND(ctx, "texture%s%s<%s%s> t%d = *(constant texture%s%s<%s%s>*)",
+            texture_dim(nir_intrinsic_image_dim(instr)),
+            nir_intrinsic_image_array(instr) ? "_array" : "",
+            tex_type_name(nir_intrinsic_dest_type(instr)), access,
+            instr->def.index, texture_dim(nir_intrinsic_image_dim(instr)),
+            nir_intrinsic_image_array(instr) ? "_array" : "",
+            tex_type_name(nir_intrinsic_dest_type(instr)), access);
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ";\n");
+      break;
+   }
+   case nir_intrinsic_load_depth_texture_kk:
+      P_IND(ctx, "depth%s%s<float> t%d = *(constant depth%s%s<float>*)",
+            texture_dim(nir_intrinsic_image_dim(instr)),
+            nir_intrinsic_image_array(instr) ? "_array" : "", instr->def.index,
+            texture_dim(nir_intrinsic_image_dim(instr)),
+            nir_intrinsic_image_array(instr) ? "_array" : "");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ";\n");
+      break;
+   case nir_intrinsic_load_sampler_handle_kk:
+      P(ctx, "sampler_table.handles[");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, "];\n");
+      break;
+   case nir_intrinsic_load_constant_agx: {
+      const char *type = msl_type_for_def(ctx->types, &instr->def);
+      const char *no_component_type =
+         msl_pipe_format_to_msl_type(nir_intrinsic_format(instr));
+      if (instr->def.num_components == 1) {
+         P(ctx, "(*(((constant %s*)", type);
+      } else {
+         P(ctx, "%s(*(constant packed_%s*)(((constant %s*)", type, type,
+           no_component_type);
+      }
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ") + ");
+      src_to_msl(ctx, &instr->src[1]);
+      P(ctx, "));\n");
+      break;
+   }
+   case nir_intrinsic_bindless_image_load:
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ".read(");
+      image_coord_swizzle(ctx, instr);
+      if (nir_intrinsic_image_dim(instr) != GLSL_SAMPLER_DIM_BUF) {
+         P(ctx, ", ");
+         src_to_msl(ctx, &instr->src[3]);
+      }
+      /* read will always return vec4 and we may try to assign that to an uint
+       * which is illegal. */
+      P(ctx, ").");
+      for (uint32_t i = 0u; i < instr->def.num_components; ++i) {
+         P(ctx, "%c", "xyzw"[i]);
+      }
+      P(ctx, ";\n");
+      break;
+   case nir_intrinsic_bindless_image_store:
+      P_INDENT(ctx);
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ".write(");
+      src_to_msl(ctx, &instr->src[3]);
+      P(ctx, ", ");
+      image_coord_swizzle(ctx, instr);
+      if (nir_intrinsic_image_dim(instr) != GLSL_SAMPLER_DIM_BUF) {
+         P(ctx, ", ");
+         src_to_msl(ctx, &instr->src[4]);
+      }
+      P(ctx, ");\n");
+      break;
+   case nir_intrinsic_bindless_image_atomic:
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ".%s(", atomic_op_to_msl(nir_intrinsic_atomic_op(instr)));
+      image_coord_swizzle(ctx, instr);
+      P(ctx, ", ");
+      src_to_msl(ctx, &instr->src[3]);
+      P(ctx, ").x;\n");
+      break;
+   case nir_intrinsic_bindless_image_atomic_swap: {
+      const char *type = msl_type_for_def(ctx->types, &instr->def);
+      P_IND(ctx, "%s4 ta%d = ", type, instr->def.index);
+      src_to_msl(ctx, &instr->src[3]);
+      P(ctx, "; ");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ".%s(", atomic_op_to_msl(nir_intrinsic_atomic_op(instr)));
+      image_coord_swizzle(ctx, instr);
+      P(ctx, ", &ta%d, ", instr->def.index);
+      src_to_msl(ctx, &instr->src[4]);
+      P(ctx, "); %s t%d = ta%d.x;\n", type, instr->def.index, instr->def.index);
+      break;
+   }
+   case nir_intrinsic_ballot:
+      P(ctx, "(ulong)simd_ballot(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ");\n");
+      break;
+   case nir_intrinsic_elect:
+      /* If we don't add && "(ulong)simd_ballot(true)"" the following CTS tests
+       * fail:
+       * dEQP-VK.subgroups.ballot_other.graphics.subgroupballotfindlsb
+       * dEQP-VK.subgroups.ballot_other.compute.subgroupballotfindlsb
+       * Weird Metal bug:
+       * if (simd_is_first())
+       *    temp = 3u;
+       * else
+       *    temp = simd_ballot(true); <- This will return all active threads...
+       */
+      P(ctx, "simd_is_first() && (ulong)simd_ballot(true);\n");
+      break;
+   case nir_intrinsic_read_first_invocation:
+      P(ctx, "simd_broadcast_first(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ");\n");
+      break;
+   case nir_intrinsic_read_invocation:
+      P(ctx, "simd_broadcast(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ", ");
+      src_to_msl(ctx, &instr->src[1]);
+      P(ctx, ");");
+      break;
+   case nir_intrinsic_shuffle:
+      P(ctx, "simd_shuffle(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ", ");
+      src_to_msl(ctx, &instr->src[1]);
+      P(ctx, ");\n");
+      break;
+   case nir_intrinsic_shuffle_xor:
+      P(ctx, "simd_shuffle_xor(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ", ");
+      src_to_msl(ctx, &instr->src[1]);
+      P(ctx, ");\n");
+      break;
+   case nir_intrinsic_shuffle_up:
+      P(ctx, "simd_shuffle_up(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ", ");
+      src_to_msl(ctx, &instr->src[1]);
+      P(ctx, ");\n");
+      break;
+   case nir_intrinsic_shuffle_down:
+      P(ctx, "simd_shuffle_down(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ", ");
+      src_to_msl(ctx, &instr->src[1]);
+      P(ctx, ");\n");
+      break;
+
+   case nir_intrinsic_vote_all:
+      P(ctx, "simd_all(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ");\n");
+      break;
+   case nir_intrinsic_vote_any:
+      P(ctx, "simd_any(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ");\n");
+      break;
+   case nir_intrinsic_quad_broadcast:
+      P(ctx, "quad_broadcast(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ", ");
+      src_to_msl(ctx, &instr->src[1]);
+      P(ctx, ");\n");
+      break;
+   case nir_intrinsic_quad_swap_horizontal:
+      P(ctx, "quad_shuffle_xor(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ", 1);\n");
+      break;
+   case nir_intrinsic_quad_swap_vertical:
+      P(ctx, "quad_shuffle_xor(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ", 2);\n");
+      break;
+   case nir_intrinsic_quad_swap_diagonal:
+      P(ctx, "quad_shuffle_xor(");
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ", 3);\n");
+      break;
+   case nir_intrinsic_reduce:
+      switch (nir_intrinsic_reduction_op(instr)) {
+      case nir_op_iadd:
+      case nir_op_fadd:
+         P(ctx, "simd_sum(");
+         break;
+      case nir_op_imul:
+      case nir_op_fmul:
+         P(ctx, "simd_product(");
+         break;
+      case nir_op_imin:
+      case nir_op_umin:
+      case nir_op_fmin:
+         P(ctx, "simd_min(");
+         break;
+      case nir_op_imax:
+      case nir_op_umax:
+      case nir_op_fmax:
+         P(ctx, "simd_max(");
+         break;
+      case nir_op_iand:
+         P(ctx, "simd_and(");
+         break;
+      case nir_op_ior:
+         P(ctx, "simd_or(");
+         break;
+      case nir_op_ixor:
+         P(ctx, "simd_xor(");
+         break;
+      default:
+         UNREACHABLE("Bad reduction op");
+      }
+
+      src_to_msl(ctx, &instr->src[0]);
+      P(ctx, ");\n");
+      break;
+   default:
+      P_IND(ctx, "Unknown intrinsic %s\n", info->name);
+   }
+}
+
+static nir_src *
+nir_tex_get_src(struct nir_tex_instr *tex, nir_tex_src_type type)
+{
+   int idx = nir_tex_instr_src_index(tex, type);
+   if (idx == -1)
+      return NULL;
+   return &tex->src[idx].src;
+}
+
+static void
+tex_coord_swizzle(struct nir_to_msl_ctx *ctx, nir_tex_instr *tex)
+{
+   texture_src_coord_swizzle(ctx, nir_tex_get_src(tex, nir_tex_src_coord),
+                             tex->coord_components, false, tex->is_array);
+}
+
+static void
+tex_to_msl(struct nir_to_msl_ctx *ctx, nir_tex_instr *tex)
+{
+   nir_src *texhandle = nir_tex_get_src(tex, nir_tex_src_texture_handle);
+   nir_src *sampler = nir_tex_get_src(tex, nir_tex_src_sampler_handle);
+   // Projectors have to be lowered away to regular arithmetic
+   assert(!nir_tex_get_src(tex, nir_tex_src_projector));
+
+   P_IND(ctx, "t%d = ", tex->def.index);
+
+   switch (tex->op) {
+   case nir_texop_tex:
+   case nir_texop_txb:
+   case nir_texop_txl:
+   case nir_texop_txd: {
+      nir_src *bias = nir_tex_get_src(tex, nir_tex_src_bias);
+      nir_src *lod = nir_tex_get_src(tex, nir_tex_src_lod);
+      nir_src *ddx = nir_tex_get_src(tex, nir_tex_src_ddx);
+      nir_src *ddy = nir_tex_get_src(tex, nir_tex_src_ddy);
+      nir_src *min_lod_clamp = nir_tex_get_src(tex, nir_tex_src_min_lod);
+      nir_src *offset = nir_tex_get_src(tex, nir_tex_src_offset);
+      nir_src *comparator = nir_tex_get_src(tex, nir_tex_src_comparator);
+      src_to_msl(ctx, texhandle);
+      if (comparator) {
+         P(ctx, ".sample_compare(");
+      } else {
+         P(ctx, ".sample(");
+      }
+      src_to_msl(ctx, sampler);
+      P(ctx, ", ");
+      tex_coord_swizzle(ctx, tex);
+      if (comparator) {
+         P(ctx, ", ");
+         src_to_msl(ctx, comparator);
+      }
+      if (bias) {
+         P(ctx, ", bias(");
+         src_to_msl(ctx, bias);
+         P(ctx, ")");
+      }
+      if (lod) {
+         P(ctx, ", level(");
+         src_to_msl(ctx, lod);
+         P(ctx, ")");
+      }
+      if (ddx) {
+         P(ctx, ", gradient%s(", texture_dim(tex->sampler_dim));
+         src_to_msl(ctx, ddx);
+         P(ctx, ", ");
+         src_to_msl(ctx, ddy);
+         P(ctx, ")");
+      }
+      if (min_lod_clamp) {
+         P(ctx, ", min_lod_clamp(");
+         src_to_msl(ctx, min_lod_clamp);
+         P(ctx, ")");
+      }
+      if (offset) {
+         P(ctx, ", ");
+         src_to_msl(ctx, offset);
+      }
+      P(ctx, ");\n");
+      break;
+   }
+   case nir_texop_txf: {
+      src_to_msl(ctx, texhandle);
+      P(ctx, ".read(");
+      tex_coord_swizzle(ctx, tex);
+      nir_src *lod = nir_tex_get_src(tex, nir_tex_src_lod);
+      if (lod) {
+         P(ctx, ", ");
+         src_to_msl(ctx, lod);
+      }
+      P(ctx, ");\n");
+      break;
+   }
+   case nir_texop_txf_ms:
+      src_to_msl(ctx, texhandle);
+      P(ctx, ".read(");
+      tex_coord_swizzle(ctx, tex);
+      P(ctx, ", ");
+      src_to_msl(ctx, nir_tex_get_src(tex, nir_tex_src_ms_index));
+      P(ctx, ");\n");
+      break;
+   case nir_texop_txs: {
+      nir_src *lod = nir_tex_get_src(tex, nir_tex_src_lod);
+      if (tex->def.num_components > 1u) {
+         P(ctx, "%s%d(", tex_type_name(tex->dest_type),
+           tex->def.num_components);
+      } else {
+         P(ctx, "%s(", tex_type_name(tex->dest_type));
+      }
+      src_to_msl(ctx, texhandle);
+      P(ctx, ".get_width(")
+      if (lod && tex->sampler_dim != GLSL_SAMPLER_DIM_MS &&
+          tex->sampler_dim != GLSL_SAMPLER_DIM_BUF)
+         src_to_msl(ctx, lod);
+      P(ctx, ")");
+      if (tex->sampler_dim != GLSL_SAMPLER_DIM_1D &&
+          tex->sampler_dim != GLSL_SAMPLER_DIM_BUF) {
+         P(ctx, ", ");
+         src_to_msl(ctx, texhandle);
+         P(ctx, ".get_height(");
+         if (lod && tex->sampler_dim != GLSL_SAMPLER_DIM_MS &&
+             tex->sampler_dim != GLSL_SAMPLER_DIM_BUF)
+            src_to_msl(ctx, lod);
+         P(ctx, ")");
+      }
+      if (tex->sampler_dim == GLSL_SAMPLER_DIM_3D) {
+         P(ctx, ", ");
+         src_to_msl(ctx, texhandle);
+         P(ctx, ".get_depth(");
+         if (lod)
+            src_to_msl(ctx, lod);
+         P(ctx, ")");
+      }
+      if (tex->is_array) {
+         P(ctx, ", ");
+         src_to_msl(ctx, texhandle);
+         P(ctx, ".get_array_size()");
+      }
+      P(ctx, ");\n")
+      break;
+   }
+   case nir_texop_query_levels:
+      src_to_msl(ctx, texhandle);
+      P(ctx, ".get_num_mip_levels();\n");
+      break;
+   case nir_texop_tg4: {
+      nir_src *offset = nir_tex_get_src(tex, nir_tex_src_offset);
+      nir_src *comparator = nir_tex_get_src(tex, nir_tex_src_comparator);
+      src_to_msl(ctx, texhandle);
+      if (comparator) {
+         P(ctx, ".gather_compare(");
+      } else {
+         P(ctx, ".gather(");
+      }
+      src_to_msl(ctx, sampler);
+      P(ctx, ", ");
+      tex_coord_swizzle(ctx, tex);
+      if (comparator) {
+         P(ctx, ", ");
+         src_to_msl(ctx, comparator);
+      }
+      P(ctx, ", ");
+      if (offset)
+         src_to_msl(ctx, offset);
+      else
+         P(ctx, "int2(0)");
+
+      /* Non-depth textures require component */
+      if (!comparator) {
+         P(ctx, ", component::%c", "xyzw"[tex->component]);
+      }
+
+      P(ctx, ");\n");
+      break;
+   }
+
+   case nir_texop_texture_samples:
+      src_to_msl(ctx, texhandle);
+      P(ctx, ".get_num_samples();\n");
+      break;
+   case nir_texop_lod: {
+      nir_src *coord = nir_tex_get_src(tex, nir_tex_src_coord);
+      nir_src *bias = nir_tex_get_src(tex, nir_tex_src_bias);
+      nir_src *min = nir_tex_get_src(tex, nir_tex_src_min_lod);
+      nir_src *max = nir_tex_get_src(tex, nir_tex_src_max_lod_kk);
+      P(ctx, "float2(round(clamp(")
+      src_to_msl(ctx, texhandle);
+      P(ctx, ".calculate_unclamped_lod(");
+      src_to_msl(ctx, sampler);
+      P(ctx, ", ");
+      src_to_msl(ctx, coord);
+      P(ctx, ") + ");
+      src_to_msl(ctx, bias);
+      P(ctx, ", ");
+      src_to_msl(ctx, min);
+      P(ctx, ", ");
+      src_to_msl(ctx, max);
+      P(ctx, ")), ");
+      src_to_msl(ctx, texhandle);
+      P(ctx, ".calculate_unclamped_lod(");
+      src_to_msl(ctx, sampler);
+      P(ctx, ", ");
+      src_to_msl(ctx, coord);
+      P(ctx, ")");
+      P(ctx, ");\n");
+      break;
+   }
+   default:
+      assert(!"Unsupported texture op");
+   }
+}
+
+static void
+jump_instr_to_msl(struct nir_to_msl_ctx *ctx, nir_jump_instr *jump)
+{
+   switch (jump->type) {
+   case nir_jump_halt:
+      P_IND(ctx, "TODO: halt\n");
+      assert(!"Unimplemented");
+      break;
+   case nir_jump_break:
+      P_IND(ctx, "break;\n");
+      break;
+   case nir_jump_continue:
+      P_IND(ctx, "continue;\n");
+      break;
+   case nir_jump_return:
+      assert(!"functions should have been inlined by now");
+      break;
+   case nir_jump_goto:
+   case nir_jump_goto_if:
+      assert(!"Unstructured control flow not supported");
+      break;
+   }
+}
+
+static void
+instr_to_msl(struct nir_to_msl_ctx *ctx, nir_instr *instr)
+{
+   switch (instr->type) {
+   case nir_instr_type_alu: {
+      nir_alu_instr *alu = nir_instr_as_alu(instr);
+      P_IND(ctx, "t%d = ", alu->def.index);
+      alu_to_msl(ctx, alu);
+      P(ctx, ";\n");
+      break;
+   }
+   case nir_instr_type_deref:
+      assert(!"We should have lowered derefs by now");
+      break;
+   case nir_instr_type_call:
+      assert(!"We should have inlined all functions by now");
+      break;
+   case nir_instr_type_tex:
+      tex_to_msl(ctx, nir_instr_as_tex(instr));
+      break;
+   case nir_instr_type_intrinsic:
+      intrinsic_to_msl(ctx, nir_instr_as_intrinsic(instr));
+      break;
+   case nir_instr_type_load_const:
+      // consts get inlined into their uses
+      break;
+   case nir_instr_type_jump:
+      jump_instr_to_msl(ctx, nir_instr_as_jump(instr));
+      break;
+   case nir_instr_type_undef:
+      // undefs get inlined into their uses (and we shouldn't see them hopefully)
+      break;
+   case nir_instr_type_phi:
+   case nir_instr_type_parallel_copy:
+      assert(!"NIR should be taken out of SSA");
+      break;
+   }
+}
+
+static void
+cf_node_to_metal(struct nir_to_msl_ctx *ctx, nir_cf_node *node)
+{
+   switch (node->type) {
+   case nir_cf_node_block: {
+      nir_block *block = nir_cf_node_as_block(node);
+      nir_foreach_instr(instr, block) {
+         instr_to_msl(ctx, instr);
+      }
+      break;
+   }
+   case nir_cf_node_if: {
+      nir_if *ifnode = nir_cf_node_as_if(node);
+      P_IND(ctx, "if (");
+      src_to_msl(ctx, &ifnode->condition);
+      P(ctx, ") {\n");
+      ctx->indentlevel++;
+      foreach_list_typed(nir_cf_node, node, node, &ifnode->then_list) {
+         cf_node_to_metal(ctx, node);
+      }
+      ctx->indentlevel--;
+      if (!nir_cf_list_is_empty_block(&ifnode->else_list)) {
+         P_IND(ctx, "} else {\n");
+         ctx->indentlevel++;
+         foreach_list_typed(nir_cf_node, node, node, &ifnode->else_list) {
+            cf_node_to_metal(ctx, node);
+         }
+         ctx->indentlevel--;
+      }
+      P_IND(ctx, "}\n");
+      break;
+   }
+   case nir_cf_node_loop: {
+      nir_loop *loop = nir_cf_node_as_loop(node);
+      assert(!nir_loop_has_continue_construct(loop));
+      /* We need to loop to infinite since MSL compiler crashes if we have
+       something like (simplified version):
+       * // clang-format off
+       * while (true) {
+       *     if (some_conditional) {
+       *         break_loop = true;
+       *     } else {
+       *         break_loop = false;
+       *     }
+       *     if (break_loop) {
+       *         break;
+       *     }
+       * }
+       * // clang-format on
+       * The issue I believe is that some_conditional wouldn't change the value
+       * no matter in which iteration we are (something like fetching the same
+       * value from a buffer) and the MSL compiler doesn't seem to like that
+       * much to the point it crashes.
+       * With this for loop now, we trick the MSL compiler into believing we are
+       * not doing an infinite loop (wink wink)
+       */
+      P_IND(ctx,
+            "for (uint64_t no_crash = 0u; no_crash < %" PRIu64
+            "; ++no_crash) {\n",
+            UINT64_MAX);
+      ctx->indentlevel++;
+      foreach_list_typed(nir_cf_node, node, node, &loop->body) {
+         cf_node_to_metal(ctx, node);
+      }
+      ctx->indentlevel--;
+      P_IND(ctx, "}\n");
+      break;
+   }
+   case nir_cf_node_function:
+      assert(!"All functions are supposed to be inlined");
+   }
+}
+
+static void
+emit_output_return(struct nir_to_msl_ctx *ctx, nir_shader *shader)
+{
+   if (shader->info.stage == MESA_SHADER_VERTEX ||
+       shader->info.stage == MESA_SHADER_FRAGMENT)
+      P_IND(ctx, "return out;\n");
+}
+
+static void
+rename_main_entrypoint(struct nir_shader *nir)
+{
+   /* Rename entrypoint to avoid MSL limitations after we've removed all others.
+    * We don't really care what it's named as long as it's not "main"
+    */
+   const char *entrypoint_name = "main_entrypoint";
+   nir_function_impl *entrypoint = nir_shader_get_entrypoint(nir);
+   struct nir_function *function = entrypoint->function;
+   ralloc_free((void *)function->name);
+   function->name = ralloc_strdup(function, entrypoint_name);
+}
+
+static bool
+kk_scalarize_filter(const nir_instr *instr, const void *data)
+{
+   if (instr->type != nir_instr_type_alu)
+      return false;
+   return true;
+}
+
+void
+msl_preprocess_nir(struct nir_shader *nir)
+{
+   /* First, inline away all the functions */
+   NIR_PASS(_, nir, nir_lower_variable_initializers, nir_var_function_temp);
+   NIR_PASS(_, nir, nir_lower_returns);
+   NIR_PASS(_, nir, nir_inline_functions);
+   NIR_PASS(_, nir, nir_opt_deref);
+   nir_remove_non_entrypoints(nir);
+
+   NIR_PASS(_, nir, nir_lower_global_vars_to_local);
+   NIR_PASS(_, nir, nir_split_var_copies);
+   NIR_PASS(_, nir, nir_split_struct_vars, nir_var_function_temp);
+   NIR_PASS(_, nir, nir_split_array_vars, nir_var_function_temp);
+   NIR_PASS(_, nir, nir_split_per_member_structs);
+   NIR_PASS(_, nir, nir_lower_continue_constructs);
+
+   NIR_PASS(_, nir, nir_lower_frexp);
+
+   NIR_PASS(_, nir, nir_lower_vars_to_ssa);
+   NIR_PASS(_, nir, nir_remove_dead_variables, nir_var_function_temp, NULL);
+   if (nir->info.stage == MESA_SHADER_FRAGMENT) {
+      nir_input_attachment_options input_attachment_options = {
+         .use_fragcoord_sysval = true,
+         .use_layer_id_sysval = true,
+      };
+      NIR_PASS(_, nir, nir_lower_input_attachments, &input_attachment_options);
+   }
+   NIR_PASS(_, nir, nir_opt_combine_barriers, NULL, NULL);
+   NIR_PASS(_, nir, nir_lower_var_copies);
+   NIR_PASS(_, nir, nir_split_var_copies);
+
+   NIR_PASS(_, nir, nir_split_array_vars,
+            nir_var_function_temp | nir_var_shader_in | nir_var_shader_out);
+   NIR_PASS(_, nir, nir_lower_alu_to_scalar, kk_scalarize_filter, NULL);
+
+   NIR_PASS(_, nir, nir_lower_indirect_derefs,
+            nir_var_shader_in | nir_var_shader_out, UINT32_MAX);
+   NIR_PASS(_, nir, nir_lower_vars_to_scratch, nir_var_function_temp, 0,
+            glsl_get_natural_size_align_bytes,
+            glsl_get_natural_size_align_bytes);
+
+   NIR_PASS(_, nir, nir_lower_system_values);
+
+   nir_lower_compute_system_values_options csv_options = {
+      .has_base_global_invocation_id = 0,
+      .has_base_workgroup_id = true,
+   };
+   NIR_PASS(_, nir, nir_lower_compute_system_values, &csv_options);
+
+   msl_nir_lower_subgroups(nir);
+}
+
+bool
+msl_optimize_nir(struct nir_shader *nir)
+{
+   bool progress;
+   NIR_PASS(_, nir, nir_lower_int64);
+   do {
+      progress = false;
+
+      NIR_PASS(progress, nir, nir_split_var_copies);
+      NIR_PASS(progress, nir, nir_split_struct_vars, nir_var_function_temp);
+      NIR_PASS(progress, nir, nir_lower_var_copies);
+      NIR_PASS(progress, nir, nir_lower_vars_to_ssa);
+      NIR_PASS(progress, nir, nir_opt_undef);
+      NIR_PASS(progress, nir, nir_opt_dce);
+      NIR_PASS(progress, nir, nir_opt_cse);
+      NIR_PASS(progress, nir, nir_opt_dead_cf);
+      NIR_PASS(progress, nir, nir_copy_prop);
+      NIR_PASS(progress, nir, nir_opt_deref);
+      NIR_PASS(progress, nir, nir_opt_constant_folding);
+      NIR_PASS(progress, nir, nir_opt_copy_prop_vars);
+      NIR_PASS(progress, nir, nir_opt_dead_write_vars);
+      NIR_PASS(progress, nir, nir_opt_combine_stores, nir_var_all);
+      NIR_PASS(progress, nir, nir_remove_dead_variables, nir_var_function_temp,
+               NULL);
+      NIR_PASS(progress, nir, nir_opt_algebraic);
+      NIR_PASS(progress, nir, nir_opt_if, 0);
+      NIR_PASS(progress, nir, nir_opt_remove_phis);
+      NIR_PASS(progress, nir, nir_opt_loop);
+      NIR_PASS(progress, nir, nir_lower_pack);
+      NIR_PASS(progress, nir, nir_lower_alu_to_scalar, kk_scalarize_filter,
+               NULL);
+   } while (progress);
+   NIR_PASS(_, nir, nir_lower_load_const_to_scalar);
+   NIR_PASS(_, nir, msl_nir_lower_algebraic_late);
+   NIR_PASS(_, nir, nir_convert_from_ssa, true, false);
+   nir_trivialize_registers(nir);
+   NIR_PASS(_, nir, nir_copy_prop);
+
+   return progress;
+}
+
+static void
+msl_gather_info(struct nir_to_msl_ctx *ctx)
+{
+   nir_function_impl *impl = nir_shader_get_entrypoint(ctx->shader);
+   ctx->types = msl_infer_types(ctx->shader);
+
+   /* TODO_KOSMICKRISP
+    * Reindex blocks and ssa. This allows us to optimize things we don't at the
+    * moment. */
+   nir_index_blocks(impl);
+   nir_index_ssa_defs(impl);
+
+   if (ctx->shader->info.stage == MESA_SHADER_VERTEX ||
+       ctx->shader->info.stage == MESA_SHADER_FRAGMENT) {
+      msl_gather_io_info(ctx, ctx->inputs_info, ctx->outputs_info);
+   }
+}
+
+static void
+predeclare_ssa_values(struct nir_to_msl_ctx *ctx, nir_function_impl *impl)
+{
+   nir_foreach_block(block, impl) {
+      nir_foreach_instr(instr, block) {
+         nir_def *def;
+         switch (instr->type) {
+         case nir_instr_type_alu: {
+            nir_alu_instr *alu = nir_instr_as_alu(instr);
+            def = &alu->def;
+            break;
+         }
+         case nir_instr_type_intrinsic: {
+            nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
+            if (!instrinsic_needs_dest_type(intr))
+               continue;
+            def = &intr->def;
+            break;
+         }
+         case nir_instr_type_tex: {
+            nir_tex_instr *tex = nir_instr_as_tex(instr);
+            def = &tex->def;
+            break;
+         }
+         default:
+            continue;
+         }
+         const char *type = msl_type_for_def(ctx->types, def);
+         if (!type)
+            continue;
+         if (msl_def_is_sampler(ctx, def)) {
+            P_IND(ctx, "%s t%u;\n", type, def->index);
+         } else
+            P_IND(ctx, "%s t%u = %s(0);\n", type, def->index, type);
+      }
+   }
+}
+
+char *
+nir_to_msl(nir_shader *shader, void *mem_ctx)
+{
+   /* Need to rename the entrypoint here since hardcoded shaders used by vk_meta
+    * don't go through the preprocess step since we are the ones creating them.
+    */
+   rename_main_entrypoint(shader);
+
+   struct nir_to_msl_ctx ctx = {
+      .shader = shader,
+      .text = _mesa_string_buffer_create(mem_ctx, 1024),
+   };
+   nir_function_impl *impl = nir_shader_get_entrypoint(shader);
+   msl_gather_info(&ctx);
+
+   P(&ctx, "// Generated by Mesa compiler\n");
+   if (shader->info.stage == MESA_SHADER_COMPUTE)
+      P(&ctx, "#include <metal_compute>\n");
+   P(&ctx, "#include <metal_stdlib>\n");
+   P(&ctx, "using namespace metal;\n");
+
+   msl_emit_io_blocks(&ctx, shader);
+   if (shader->info.stage == MESA_SHADER_FRAGMENT &&
+       shader->info.fs.early_fragment_tests)
+      P(&ctx, "[[early_fragment_tests]]\n");
+   P(&ctx, "%s %s %s(\n", get_stage_string(shader->info.stage),
+     output_type(shader), get_entrypoint_name(shader));
+   ctx.indentlevel++;
+   emit_sysvals(&ctx, shader);
+   emit_inputs(&ctx, shader);
+   ctx.indentlevel--;
+   P(&ctx, ")\n");
+   P(&ctx, "{\n");
+   ctx.indentlevel++;
+   msl_emit_output_var(&ctx, shader);
+   emit_local_vars(&ctx, shader);
+   predeclare_ssa_values(&ctx, impl);
+   foreach_list_typed(nir_cf_node, node, node, &impl->body) {
+      cf_node_to_metal(&ctx, node);
+   }
+   emit_output_return(&ctx, shader);
+   ctx.indentlevel--;
+   P(&ctx, "}\n");
+   char *ret = ctx.text->buf;
+   ralloc_steal(mem_ctx, ctx.text->buf);
+   ralloc_free(ctx.text);
+   return ret;
+}
diff --git a/src/kosmickrisp/compiler/nir_to_msl.h b/src/kosmickrisp/compiler/nir_to_msl.h
new file mode 100644
index 00000000000..0a4d50109ed
--- /dev/null
+++ b/src/kosmickrisp/compiler/nir_to_msl.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+#include "nir.h"
+
+enum pipe_format;
+
+/* Assumes nir_shader_gather_info has been called beforehand. */
+char *nir_to_msl(nir_shader *shader, void *mem_ctx);
+
+/* Call this after all API-specific lowerings. It will bring the NIR out of SSA
+ * at the end */
+bool msl_optimize_nir(struct nir_shader *nir);
+
+/* Call this before all API-speicific lowerings, it will */
+void msl_preprocess_nir(struct nir_shader *nir);
+
+enum msl_tex_access_flag {
+   MSL_ACCESS_SAMPLE = 0,
+   MSL_ACCESS_READ,
+   MSL_ACCESS_WRITE,
+   MSL_ACCESS_READ_WRITE,
+};
+
+static inline enum msl_tex_access_flag
+msl_convert_access_flag(enum gl_access_qualifier qual)
+{
+   if (qual & ACCESS_NON_WRITEABLE)
+      return MSL_ACCESS_READ;
+   if (qual & ACCESS_NON_READABLE)
+      return MSL_ACCESS_WRITE;
+   return MSL_ACCESS_READ_WRITE;
+}
+
+bool msl_nir_fs_force_output_signedness(
+   nir_shader *nir, enum pipe_format render_target_formats[MAX_DRAW_BUFFERS]);
+
+bool msl_nir_vs_remove_point_size_write(nir_builder *b,
+                                        nir_intrinsic_instr *intrin,
+                                        void *data);
+
+bool msl_nir_fs_remove_depth_write(nir_builder *b, nir_intrinsic_instr *intrin,
+                                   void *data);
+
+bool msl_lower_textures(nir_shader *s);
+
+bool msl_lower_static_sample_mask(nir_shader *nir, uint32_t sample_mask);
+bool msl_ensure_depth_write(nir_shader *nir);
+bool msl_ensure_vertex_position_output(nir_shader *nir);
+bool msl_nir_sample_mask_type(nir_shader *nir);
+bool msl_nir_layer_id_type(nir_shader *nir);
diff --git a/src/kosmickrisp/kosmicomp.c b/src/kosmickrisp/kosmicomp.c
new file mode 100644
index 00000000000..a45d8203c96
--- /dev/null
+++ b/src/kosmickrisp/kosmicomp.c
@@ -0,0 +1,187 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <stdio.h>
+
+#include "compiler/nir_to_msl.h"
+#include "spirv/nir_spirv.h"
+
+static int
+load_spirv(const char *filename, uint32_t **words, size_t *nwords)
+{
+   const size_t CHUNK_SIZE = 4096;
+   uint32_t buf[CHUNK_SIZE];
+   FILE *input = fopen(filename, "r");
+   if (!input) {
+      fprintf(stderr, "Could not open file %s: %s\n", filename,
+              strerror(errno));
+      return -1;
+   }
+
+   *nwords = 0;
+   *words = malloc(CHUNK_SIZE * sizeof(buf[0]));
+   size_t read_size;
+   while (1) {
+      read_size = fread(buf, sizeof(buf[0]), CHUNK_SIZE, input);
+      if (read_size == 0)
+         break;
+      *words = realloc(*words, (*nwords + read_size) * sizeof(buf[0]));
+      memcpy(*words + *nwords, buf, sizeof(buf[0]) * read_size);
+      *nwords += read_size;
+   };
+
+   if (*words[0] != 0x07230203) {
+      fprintf(stderr, "%s is not a SPIR-V file?\n", filename);
+      return -1;
+   }
+
+   return 0;
+}
+
+static void
+debug_callback(void *priv, enum nir_spirv_debug_level debuglevel, size_t offset,
+               const char *message)
+{
+   fprintf(stderr, "<%d> at %ld %s\n", debuglevel, offset, message);
+}
+
+static int
+type_size_vec4(const struct glsl_type *type, bool bindless)
+{
+   return glsl_count_attribute_slots(type, false);
+}
+
+static void
+shared_var_info(const struct glsl_type *type, unsigned *size, unsigned *align)
+{
+   assert(glsl_type_is_vector_or_scalar(type));
+
+   uint32_t comp_size =
+      glsl_type_is_boolean(type) ? 4 : glsl_get_bit_size(type) / 8;
+   unsigned length = glsl_get_vector_elements(type);
+   *size = comp_size * length, *align = comp_size;
+}
+
+static void
+optimize(nir_shader *nir)
+{
+   msl_preprocess_nir(nir);
+
+   NIR_PASS(_, nir, nir_lower_explicit_io, nir_var_mem_push_const,
+            nir_address_format_32bit_offset);
+   NIR_PASS(_, nir, nir_lower_explicit_io,
+            nir_var_mem_global | nir_var_mem_ubo | nir_var_mem_ssbo,
+            nir_address_format_64bit_global);
+   if (nir->info.stage == MESA_SHADER_COMPUTE) {
+      if (!nir->info.shared_memory_explicit_layout) {
+         /* There may be garbage in shared_size, but it's the job of
+          * nir_lower_vars_to_explicit_types to allocate it. We have to reset to
+          * avoid overallocation.
+          */
+         nir->info.shared_size = 0;
+
+         NIR_PASS(_, nir, nir_lower_vars_to_explicit_types, nir_var_mem_shared,
+                  shared_var_info);
+      }
+      NIR_PASS(_, nir, nir_lower_explicit_io, nir_var_mem_shared,
+               nir_address_format_32bit_offset);
+   }
+
+   NIR_PASS(_, nir, nir_lower_io, nir_var_shader_in | nir_var_shader_out,
+            type_size_vec4, (nir_lower_io_options)0);
+
+   NIR_PASS(_, nir, nir_lower_variable_initializers, ~nir_var_function_temp);
+   NIR_PASS(_, nir, nir_remove_dead_variables,
+            nir_var_shader_in | nir_var_shader_out | nir_var_system_value,
+            NULL);
+   NIR_PASS(_, nir, nir_lower_io_vars_to_temporaries,
+            nir_shader_get_entrypoint(nir), true, false);
+   nir_lower_compute_system_values_options options = {
+      .has_base_global_invocation_id = 0,
+   };
+   NIR_PASS(_, nir, nir_lower_system_values);
+   NIR_PASS(_, nir, nir_lower_compute_system_values, &options);
+   NIR_PASS(_, nir, nir_lower_global_vars_to_local);
+   NIR_PASS(_, nir, nir_lower_load_const_to_scalar);
+
+   msl_optimize_nir(nir);
+}
+
+static mesa_shader_stage
+stage_from_filename(const char *filename)
+{
+   struct StageMapping {
+      char *name;
+      mesa_shader_stage stage;
+   };
+   struct StageMapping stage_mappings[] = {
+      {.name = ".frag.", .stage = MESA_SHADER_FRAGMENT},
+      {.name = ".vert.", .stage = MESA_SHADER_VERTEX},
+      {.name = ".comp.", .stage = MESA_SHADER_COMPUTE},
+   };
+   for (int i = 0; i < ARRAY_SIZE(stage_mappings); i++) {
+      if (strstr(filename, stage_mappings[i].name))
+         return stage_mappings[i].stage;
+   }
+   return MESA_SHADER_NONE;
+}
+
+int
+main(int argc, char **argv)
+{
+   if (argc != 2) {
+      fprintf(stderr, "Usage: kosmicomp filename.spv\n");
+      return 1;
+   }
+
+   // read file
+   size_t nwords = 0;
+   uint32_t *words = NULL;
+   int result = load_spirv(argv[1], &words, &nwords);
+   if (result == -1) {
+      return 2;
+   }
+
+   // run spirv_to_nir
+   struct spirv_to_nir_options options = {
+      .environment = NIR_SPIRV_VULKAN,
+      .debug =
+         {
+            .func = &debug_callback,
+            .private_data = NULL,
+         },
+      .ubo_addr_format = nir_address_format_64bit_global,
+      .ssbo_addr_format = nir_address_format_64bit_global,
+      .phys_ssbo_addr_format = nir_address_format_64bit_global,
+   };
+   glsl_type_singleton_init_or_ref();
+   struct nir_shader_compiler_options nir_options = {
+      .lower_fdph = 1,
+   };
+   mesa_shader_stage stage = stage_from_filename(argv[1]);
+   if (stage == MESA_SHADER_NONE) {
+      fprintf(stderr, "Couldn't guess shader stage from %s\n", argv[1]);
+      return 4;
+   }
+   nir_shader *shader = spirv_to_nir(words, nwords, NULL, 0, stage, "main",
+                                     &options, &nir_options);
+   if (!shader) {
+      fprintf(stderr, "Compilation failed!\n");
+      return 3;
+   }
+   // print nir
+   nir_print_shader(shader, stdout);
+   optimize(shader);
+   nir_print_shader(shader, stdout);
+
+   char *msl_text = nir_to_msl(shader, shader);
+
+   fputs(msl_text, stdout);
+
+   ralloc_free(msl_text);
+
+   return 0;
+}
diff --git a/src/kosmickrisp/meson.build b/src/kosmickrisp/meson.build
new file mode 100644
index 00000000000..fe54329e132
--- /dev/null
+++ b/src/kosmickrisp/meson.build
@@ -0,0 +1,16 @@
+# Copyright 2025 LunarG, Inc.
+# Copyright 2025 Google LLC
+# SPDX-License-Identifier: MIT
+
+subdir('bridge')
+subdir('compiler')
+subdir('util')
+subdir('vulkan')
+
+executable(
+    'kosmicomp',
+    files('kosmicomp.c'),
+    dependencies : [idep_nir, idep_vtn, idep_vulkan_runtime_headers, idep_vulkan_util_headers],
+    link_with: [libkk],
+    link_args: ['-Wl,-undefined,dynamic_lookup'],
+)
diff --git a/src/kosmickrisp/util/kk_dispatch_trampolines_gen.py b/src/kosmickrisp/util/kk_dispatch_trampolines_gen.py
new file mode 100644
index 00000000000..468f5679ea1
--- /dev/null
+++ b/src/kosmickrisp/util/kk_dispatch_trampolines_gen.py
@@ -0,0 +1,195 @@
+# coding=utf-8
+COPYRIGHT = """\
+/*
+ * Copyright 2020 Intel Corporation
+ * Copyright 2025 LunarG, Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+"""
+
+import argparse
+import os
+
+from mako.template import Template
+
+# Mesa-local imports must be declared in meson variable
+# '{file_without_suffix}_depend_files'.
+from vk_entrypoints import get_entrypoints_from_xml
+
+TEMPLATE_H = Template(COPYRIGHT + """\
+/* This file generated from ${filename}, don't edit directly. */
+
+#ifndef VK_DISPATCH_TRAMPOLINES_H
+#define VK_DISPATCH_TRAMPOLINES_H
+
+#include "vk_dispatch_table.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct vk_physical_device_dispatch_table kk_physical_device_trampolines;
+extern struct vk_device_dispatch_table kk_device_trampolines;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* VK_DISPATCH_TRAMPOLINES_H */
+""")
+
+TEMPLATE_C = Template(COPYRIGHT + """\
+/* This file generated from ${filename}, don't edit directly. */
+
+#include "kk_device.h"
+#include "kk_dispatch_trampolines.h"
+#include "vk_object.h"
+#include "vk_physical_device.h"
+
+% for e in entrypoints:
+  % if not e.is_physical_device_entrypoint() or e.alias:
+    <% continue %>
+  % endif
+  % if e.guard is not None:
+#ifdef ${e.guard}
+  % endif
+static VKAPI_ATTR ${e.return_type} VKAPI_CALL
+${e.prefixed_name('kk_tramp')}(${e.decl_params()})
+{
+    <% assert e.params[0].type == 'VkPhysicalDevice' %>
+    VK_FROM_HANDLE(vk_physical_device, vk_physical_device, ${e.params[0].name});
+  % if e.return_type == 'void':
+    vk_physical_device->dispatch_table.${e.name}(${e.call_params()});
+  % else:
+    return vk_physical_device->dispatch_table.${e.name}(${e.call_params()});
+  % endif
+}
+  % if e.guard is not None:
+#endif
+  % endif
+% endfor
+
+struct vk_physical_device_dispatch_table kk_physical_device_trampolines = {
+% for e in entrypoints:
+  % if not e.is_physical_device_entrypoint() or e.alias:
+    <% continue %>
+  % endif
+  % if e.guard is not None:
+#ifdef ${e.guard}
+  % endif
+    .${e.name} = ${e.prefixed_name('kk_tramp')},
+  % if e.guard is not None:
+#endif
+  % endif
+% endfor
+};
+
+% for e in entrypoints:
+  % if not e.is_device_entrypoint() or e.alias:
+    <% continue %>
+  % endif
+  % if e.guard is not None:
+#ifdef ${e.guard}
+  % endif
+static VKAPI_ATTR ${e.return_type} VKAPI_CALL
+${e.prefixed_name('kk_tramp')}(${e.decl_params()})
+{
+  % if e.params[0].type == 'VkDevice':
+    VK_FROM_HANDLE(kk_device, kk_device, ${e.params[0].name});
+    % if e.return_type == 'void':
+    kk_device->exposed_dispatch_table.${e.name}(${e.call_params()});
+    % else:
+    return kk_device->exposed_dispatch_table.${e.name}(${e.call_params()});
+    % endif
+  % elif e.params[0].type in ('VkCommandBuffer', 'VkQueue'):
+    struct vk_object_base *vk_object = (struct vk_object_base *)${e.params[0].name};
+    struct kk_device *kk_device = container_of(vk_object->device, struct kk_device, vk);
+    % if e.return_type == 'void':
+    kk_device->exposed_dispatch_table.${e.name}(${e.call_params()});
+    % else:
+    return kk_device->exposed_dispatch_table.${e.name}(${e.call_params()});
+    % endif
+  % else:
+    assert(!"Unhandled device child trampoline case: ${e.params[0].type}");
+  % endif
+}
+  % if e.guard is not None:
+#endif
+  % endif
+% endfor
+
+struct vk_device_dispatch_table kk_device_trampolines = {
+% for e in entrypoints:
+  % if not e.is_device_entrypoint() or e.alias:
+    <% continue %>
+  % endif
+  % if e.guard is not None:
+#ifdef ${e.guard}
+  % endif
+    .${e.name} = ${e.prefixed_name('kk_tramp')},
+  % if e.guard is not None:
+#endif
+  % endif
+% endfor
+};
+""")
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-c', help='Output C file.')
+    parser.add_argument('--out-h', help='Output H file.')
+    parser.add_argument('--beta', required=True, help='Enable beta extensions.')
+    parser.add_argument('--xml',
+                        help='Vulkan API XML file.',
+                        required=True,
+                        action='append',
+                        dest='xml_files')
+    args = parser.parse_args()
+
+    entrypoints = get_entrypoints_from_xml(args.xml_files, args.beta)
+
+    # For outputting entrypoints.h we generate a anv_EntryPoint() prototype
+    # per entry point.
+    try:
+        if args.out_h:
+            with open(args.out_h, 'w', encoding='utf-8') as f:
+                f.write(TEMPLATE_H.render(entrypoints=entrypoints,
+                                          filename=os.path.basename(__file__)))
+        if args.out_c:
+            with open(args.out_c, 'w', encoding='utf-8') as f:
+                f.write(TEMPLATE_C.render(entrypoints=entrypoints,
+                                          filename=os.path.basename(__file__)))
+    except Exception:
+        # In the event there's an error, this imports some helpers from mako
+        # to print a useful stack trace and prints it, then exits with
+        # status 1, if python is run with debug; otherwise it just raises
+        # the exception
+        if __debug__:
+            import sys
+            from mako import exceptions
+            sys.stderr.write(exceptions.text_error_template().render() + '\n')
+            sys.exit(1)
+        raise
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/kosmickrisp/util/meson.build b/src/kosmickrisp/util/meson.build
new file mode 100644
index 00000000000..43316831cec
--- /dev/null
+++ b/src/kosmickrisp/util/meson.build
@@ -0,0 +1,16 @@
+# Copyright © 2025 LunarG, Inc
+# SPDX-License-Identifier: MIT
+
+kk_dispatch_trampolines_gen = files('kk_dispatch_trampolines_gen.py')
+
+kk_dispatch_trampolines = custom_target(
+  'kk_dispatch_trampolines',
+  input : [kk_dispatch_trampolines_gen, vk_api_xml],
+  output : ['kk_dispatch_trampolines.c', 'kk_dispatch_trampolines.h'],
+  command : [
+    prog_python, '@INPUT0@', '--xml', '@INPUT1@',
+    '--out-c', '@OUTPUT0@', '--out-h', '@OUTPUT1@',
+    '--beta', with_vulkan_beta.to_string()
+  ],
+  depend_files : vk_dispatch_trampolines_gen_depend_files,
+)
diff --git a/src/kosmickrisp/util/vk_entrypoints.py b/src/kosmickrisp/util/vk_entrypoints.py
new file mode 100644
index 00000000000..a8280bae2ff
--- /dev/null
+++ b/src/kosmickrisp/util/vk_entrypoints.py
@@ -0,0 +1,147 @@
+# Copyright 2020 Intel Corporation
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sub license, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice (including the
+# next paragraph) shall be included in all copies or substantial portions
+# of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+# IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+import xml.etree.ElementTree as et
+
+from collections import OrderedDict, namedtuple
+
+# Mesa-local imports must be declared in meson variable
+# '{file_without_suffix}_depend_files'.
+from vk_extensions import get_all_required, filter_api
+
+EntrypointParam = namedtuple('EntrypointParam', 'type name decl len')
+
+class EntrypointBase:
+    def __init__(self, name):
+        assert name.startswith('vk')
+        self.name = name[2:]
+        self.alias = None
+        self.guard = None
+        self.entry_table_index = None
+        # Extensions which require this entrypoint
+        self.core_version = None
+        self.extensions = []
+
+    def prefixed_name(self, prefix):
+        return prefix + '_' + self.name
+
+class Entrypoint(EntrypointBase):
+    def __init__(self, name, return_type, params):
+        super(Entrypoint, self).__init__(name)
+        self.return_type = return_type
+        self.params = params
+        self.guard = None
+        self.aliases = []
+        self.disp_table_index = None
+
+    def is_physical_device_entrypoint(self):
+        return self.params[0].type in ('VkPhysicalDevice', )
+
+    def is_device_entrypoint(self):
+        return self.params[0].type in ('VkDevice', 'VkCommandBuffer', 'VkQueue')
+
+    def decl_params(self, start=0):
+        return ', '.join(p.decl for p in self.params[start:])
+
+    def call_params(self, start=0):
+        return ', '.join(p.name for p in self.params[start:])
+
+class EntrypointAlias(EntrypointBase):
+    def __init__(self, name, entrypoint):
+        super(EntrypointAlias, self).__init__(name)
+        self.alias = entrypoint
+        entrypoint.aliases.append(self)
+
+    def is_physical_device_entrypoint(self):
+        return self.alias.is_physical_device_entrypoint()
+
+    def is_device_entrypoint(self):
+        return self.alias.is_device_entrypoint()
+
+    def prefixed_name(self, prefix):
+        return self.alias.prefixed_name(prefix)
+
+    @property
+    def params(self):
+        return self.alias.params
+
+    @property
+    def return_type(self):
+        return self.alias.return_type
+
+    @property
+    def disp_table_index(self):
+        return self.alias.disp_table_index
+
+    def decl_params(self):
+        return self.alias.decl_params()
+
+    def call_params(self):
+        return self.alias.call_params()
+
+def get_entrypoints(doc, api, beta):
+    """Extract the entry points from the registry."""
+    entrypoints = OrderedDict()
+
+    required = get_all_required(doc, 'command', api, beta)
+
+    for command in doc.findall('./commands/command'):
+        if not filter_api(command, api):
+            continue
+
+        if 'alias' in command.attrib:
+            name = command.attrib['name']
+            target = command.attrib['alias']
+            e = EntrypointAlias(name, entrypoints[target])
+        else:
+            name = command.find('./proto/name').text
+            ret_type = command.find('./proto/type').text
+            params = [EntrypointParam(
+                type=p.find('./type').text,
+                name=p.find('./name').text,
+                decl=''.join(p.itertext()),
+                len=p.attrib.get('altlen', p.attrib.get('len', None))
+            ) for p in command.findall('./param') if filter_api(p, api)]
+            # They really need to be unique
+            e = Entrypoint(name, ret_type, params)
+
+        if name not in required:
+            continue
+
+        r = required[name]
+        e.core_version = r.core_version
+        e.extensions = r.extensions
+        e.guard = r.guard
+
+        assert name not in entrypoints, name
+        entrypoints[name] = e
+
+    return entrypoints.values()
+
+def get_entrypoints_from_xml(xml_files, beta, api='vulkan'):
+    entrypoints = []
+
+    for filename in xml_files:
+        doc = et.parse(filename)
+        entrypoints += get_entrypoints(doc, api, beta)
+
+    return entrypoints
diff --git a/src/kosmickrisp/util/vk_extensions.py b/src/kosmickrisp/util/vk_extensions.py
new file mode 100644
index 00000000000..f58b04f71cb
--- /dev/null
+++ b/src/kosmickrisp/util/vk_extensions.py
@@ -0,0 +1,371 @@
+import copy
+import re
+import xml.etree.ElementTree as et
+
+def get_api_list(s):
+    apis = []
+    for a in s.split(','):
+        if a == 'disabled':
+            continue
+        assert a in ('vulkan', 'vulkansc')
+        apis.append(a)
+    return apis
+
+class Extension:
+    def __init__(self, name, number, ext_version):
+        self.name = name
+        self.type = None
+        self.number = number
+        self.platform = None
+        self.provisional = False
+        self.ext_version = int(ext_version)
+        self.supported = []
+
+    def from_xml(ext_elem):
+        name = ext_elem.attrib['name']
+        number = int(ext_elem.attrib['number'])
+        supported = get_api_list(ext_elem.attrib['supported'])
+        if name == 'VK_ANDROID_native_buffer':
+            assert not supported
+            supported = ['vulkan']
+
+        if not supported:
+            return Extension(name, number, 0)
+
+        version = None
+        for enum_elem in ext_elem.findall('.require/enum'):
+            if enum_elem.attrib['name'].endswith('_SPEC_VERSION'):
+                # Skip alias SPEC_VERSIONs
+                if 'value' in enum_elem.attrib:
+                    assert version is None
+                    version = int(enum_elem.attrib['value'])
+
+        assert version is not None
+        ext = Extension(name, number, version)
+        ext.type = ext_elem.attrib['type']
+        ext.platform = ext_elem.attrib.get('platform', None)
+        ext.provisional = ext_elem.attrib.get('provisional', False)
+        ext.supported = supported
+
+        return ext
+
+    def c_android_condition(self):
+        # if it's an EXT or vendor extension, it's allowed
+        if not self.name.startswith(ANDROID_EXTENSION_WHITELIST_PREFIXES):
+            return 'true'
+
+        allowed_version = ALLOWED_ANDROID_VERSION.get(self.name, None)
+        if allowed_version is None:
+            return 'false'
+
+        return 'ANDROID_API_LEVEL >= %d' % (allowed_version)
+
+class ApiVersion:
+    def __init__(self, version):
+        self.version = version
+
+class VkVersion:
+    def __init__(self, string):
+        split = string.split('.')
+        self.major = int(split[0])
+        self.minor = int(split[1])
+        if len(split) > 2:
+            assert len(split) == 3
+            self.patch = int(split[2])
+        else:
+            self.patch = None
+
+        # Sanity check.  The range bits are required by the definition of the
+        # VK_MAKE_VERSION macro
+        assert self.major < 1024 and self.minor < 1024
+        assert self.patch is None or self.patch < 4096
+        assert str(self) == string
+
+    def __str__(self):
+        ver_list = [str(self.major), str(self.minor)]
+        if self.patch is not None:
+            ver_list.append(str(self.patch))
+        return '.'.join(ver_list)
+
+    def c_vk_version(self):
+        ver_list = [str(self.major), str(self.minor), str(self.patch or 0)]
+        return 'VK_MAKE_VERSION(' + ', '.join(ver_list) + ')'
+
+    def __int_ver(self):
+        # This is just an expansion of VK_VERSION
+        return (self.major << 22) | (self.minor << 12) | (self.patch or 0)
+
+    def __gt__(self, other):
+        # If only one of them has a patch version, "ignore" it by making
+        # other's patch version match self.
+        if (self.patch is None) != (other.patch is None):
+            other = copy.copy(other)
+            other.patch = self.patch
+
+        return self.__int_ver() > other.__int_ver()
+
+# Sort the extension list the way we expect: KHR, then EXT, then vendors
+# alphabetically. For digits, read them as a whole number sort that.
+# eg.: VK_KHR_8bit_storage < VK_KHR_16bit_storage < VK_EXT_acquire_xlib_display
+def extension_order(ext):
+    order = []
+    for substring in re.split('(KHR|EXT|[0-9]+)', ext.name):
+        if substring == 'KHR':
+            order.append(1)
+        if substring == 'EXT':
+            order.append(2)
+        elif substring.isdigit():
+            order.append(int(substring))
+        else:
+            order.append(substring)
+    return order
+
+def get_all_exts_from_xml(xml, api='vulkan'):
+    """ Get a list of all Vulkan extensions. """
+
+    xml = et.parse(xml)
+
+    extensions = []
+    for ext_elem in xml.findall('.extensions/extension'):
+        ext = Extension.from_xml(ext_elem)
+        if api in ext.supported:
+            extensions.append(ext)
+
+    return sorted(extensions, key=extension_order)
+
+def init_exts_from_xml(xml, extensions, platform_defines):
+    """ Walk the Vulkan XML and fill out extra extension information. """
+
+    xml = et.parse(xml)
+
+    ext_name_map = {}
+    for ext in extensions:
+        ext_name_map[ext.name] = ext
+
+    # KHR_display is missing from the list.
+    platform_defines.append('VK_USE_PLATFORM_DISPLAY_KHR')
+    for platform in xml.findall('./platforms/platform'):
+        platform_defines.append(platform.attrib['protect'])
+
+    for ext_elem in xml.findall('.extensions/extension'):
+        ext_name = ext_elem.attrib['name']
+        if ext_name not in ext_name_map:
+            continue
+
+        ext = ext_name_map[ext_name]
+        ext.type = ext_elem.attrib['type']
+
+class Requirements:
+    def __init__(self, core_version=None):
+        self.core_version = core_version
+        self.extensions = []
+        self.guard = None
+
+    def add_extension(self, ext):
+        for e in self.extensions:
+            if e == ext:
+                return;
+            assert e.name != ext.name
+
+        self.extensions.append(ext)
+
+def filter_api(elem, api):
+    if 'api' not in elem.attrib:
+        return True
+
+    return api in elem.attrib['api'].split(',')
+
+def get_alias(aliases, name):
+    if name in aliases:
+        # in case the spec registry adds an alias chain later
+        return get_alias(aliases, aliases[name])
+    return name
+
+def get_all_required(xml, thing, api, beta):
+    things = {}
+    aliases = {}
+    for struct in xml.findall('./types/type[@category="struct"][@alias]'):
+        if not filter_api(struct, api):
+            continue
+
+        name = struct.attrib['name']
+        alias = struct.attrib['alias']
+        aliases[name] = alias
+
+    for feature in xml.findall('./feature'):
+        if not filter_api(feature, api):
+            continue
+
+        version = VkVersion(feature.attrib['number'])
+        for t in feature.findall('./require/' + thing):
+            name = t.attrib['name']
+            assert name not in things
+            things[name] = Requirements(core_version=version)
+
+    for extension in xml.findall('.extensions/extension'):
+        ext = Extension.from_xml(extension)
+        if api not in ext.supported:
+            continue
+
+        if beta != 'true' and ext.provisional:
+            continue
+
+        for require in extension.findall('./require'):
+            if not filter_api(require, api):
+                continue
+
+            for t in require.findall('./' + thing):
+                name = get_alias(aliases, t.attrib['name'])
+                r = things.setdefault(name, Requirements())
+                r.add_extension(ext)
+
+    platform_defines = {}
+    for platform in xml.findall('./platforms/platform'):
+        name = platform.attrib['name']
+        define = platform.attrib['protect']
+        platform_defines[name] = define
+
+    for req in things.values():
+        if req.core_version is not None:
+            continue
+
+        for ext in req.extensions:
+            if ext.platform in platform_defines:
+                req.guard = platform_defines[ext.platform]
+                break
+
+    return things
+
+# Mapping between extension name and the android version in which the extension
+# was whitelisted in Android CTS's dEQP-VK.info.device_extensions and
+# dEQP-VK.api.info.android.no_unknown_extensions, excluding those blocked by
+# android.graphics.cts.VulkanFeaturesTest#testVulkanBlockedExtensions.
+ALLOWED_ANDROID_VERSION = {
+    # checkInstanceExtensions on oreo-cts-release
+    "VK_KHR_surface": 26,
+    "VK_KHR_display": 26,
+    "VK_KHR_android_surface": 26,
+    "VK_KHR_mir_surface": 26,
+    "VK_KHR_wayland_surface": 26,
+    "VK_KHR_win32_surface": 26,
+    "VK_KHR_xcb_surface": 26,
+    "VK_KHR_xlib_surface": 26,
+    "VK_KHR_get_physical_device_properties2": 26,
+    "VK_KHR_get_surface_capabilities2": 26,
+    "VK_KHR_external_memory_capabilities": 26,
+    "VK_KHR_external_semaphore_capabilities": 26,
+    "VK_KHR_external_fence_capabilities": 26,
+    # on pie-cts-release
+    "VK_KHR_device_group_creation": 28,
+    "VK_KHR_get_display_properties2": 28,
+    # on android10-tests-release
+    "VK_KHR_surface_protected_capabilities": 29,
+    # on android13-tests-release
+    "VK_KHR_portability_enumeration": 33,
+
+    # checkDeviceExtensions on oreo-cts-release
+    "VK_KHR_swapchain": 26,
+    "VK_KHR_display_swapchain": 26,
+    "VK_KHR_sampler_mirror_clamp_to_edge": 26,
+    "VK_KHR_shader_draw_parameters": 26,
+    "VK_KHR_maintenance1": 26,
+    "VK_KHR_push_descriptor": 26,
+    "VK_KHR_descriptor_update_template": 26,
+    "VK_KHR_incremental_present": 26,
+    "VK_KHR_shared_presentable_image": 26,
+    "VK_KHR_storage_buffer_storage_class": 26,
+    "VK_KHR_16bit_storage": 26,
+    "VK_KHR_get_memory_requirements2": 26,
+    "VK_KHR_external_memory": 26,
+    "VK_KHR_external_memory_fd": 26,
+    "VK_KHR_external_memory_win32": 26,
+    "VK_KHR_external_semaphore": 26,
+    "VK_KHR_external_semaphore_fd": 26,
+    "VK_KHR_external_semaphore_win32": 26,
+    "VK_KHR_external_fence": 26,
+    "VK_KHR_external_fence_fd": 26,
+    "VK_KHR_external_fence_win32": 26,
+    "VK_KHR_win32_keyed_mutex": 26,
+    "VK_KHR_dedicated_allocation": 26,
+    "VK_KHR_variable_pointers": 26,
+    "VK_KHR_relaxed_block_layout": 26,
+    "VK_KHR_bind_memory2": 26,
+    "VK_KHR_maintenance2": 26,
+    "VK_KHR_image_format_list": 26,
+    "VK_KHR_sampler_ycbcr_conversion": 26,
+    # on oreo-mr1-cts-release
+    "VK_KHR_draw_indirect_count": 27,
+    # on pie-cts-release
+    "VK_KHR_device_group": 28,
+    "VK_KHR_multiview": 28,
+    "VK_KHR_maintenance3": 28,
+    "VK_KHR_create_renderpass2": 28,
+    "VK_KHR_driver_properties": 28,
+    # on android10-tests-release
+    "VK_KHR_shader_float_controls": 29,
+    "VK_KHR_shader_float16_int8": 29,
+    "VK_KHR_8bit_storage": 29,
+    "VK_KHR_depth_stencil_resolve": 29,
+    "VK_KHR_swapchain_mutable_format": 29,
+    "VK_KHR_shader_atomic_int64": 29,
+    "VK_KHR_vulkan_memory_model": 29,
+    "VK_KHR_swapchain_mutable_format": 29,
+    "VK_KHR_uniform_buffer_standard_layout": 29,
+    # on android11-tests-release
+    "VK_KHR_imageless_framebuffer": 30,
+    "VK_KHR_shader_subgroup_extended_types": 30,
+    "VK_KHR_buffer_device_address": 30,
+    "VK_KHR_separate_depth_stencil_layouts": 30,
+    "VK_KHR_timeline_semaphore": 30,
+    "VK_KHR_spirv_1_4": 30,
+    "VK_KHR_pipeline_executable_properties": 30,
+    "VK_KHR_shader_clock": 30,
+    # blocked by testVulkanBlockedExtensions
+    # "VK_KHR_performance_query": 30,
+    "VK_KHR_shader_non_semantic_info": 30,
+    "VK_KHR_copy_commands2": 30,
+    # on android12-tests-release
+    "VK_KHR_shader_terminate_invocation": 31,
+    "VK_KHR_ray_tracing_pipeline": 31,
+    "VK_KHR_ray_query": 31,
+    "VK_KHR_acceleration_structure": 31,
+    "VK_KHR_pipeline_library": 31,
+    "VK_KHR_deferred_host_operations": 31,
+    "VK_KHR_fragment_shading_rate": 31,
+    "VK_KHR_zero_initialize_workgroup_memory": 31,
+    "VK_KHR_workgroup_memory_explicit_layout": 31,
+    "VK_KHR_synchronization2": 31,
+    "VK_KHR_shader_integer_dot_product": 31,
+    # on android13-tests-release
+    "VK_KHR_dynamic_rendering": 33,
+    "VK_KHR_format_feature_flags2": 33,
+    "VK_KHR_global_priority": 33,
+    "VK_KHR_maintenance4": 33,
+    "VK_KHR_portability_subset": 33,
+    "VK_KHR_present_id": 33,
+    "VK_KHR_present_wait": 33,
+    "VK_KHR_shader_subgroup_uniform_control_flow": 33,
+
+    # testNoUnknownExtensions on oreo-cts-release
+    "VK_GOOGLE_display_timing": 26,
+    # on pie-cts-release
+    "VK_ANDROID_external_memory_android_hardware_buffer": 28,
+    # on android11-tests-release
+    "VK_GOOGLE_decorate_string": 30,
+    "VK_GOOGLE_hlsl_functionality1": 30,
+    # on android13-tests-release
+    "VK_GOOGLE_surfaceless_query": 33,
+
+    # this HAL extension is always allowed and will be filtered out by the
+    # loader
+    "VK_ANDROID_native_buffer": 26,
+}
+
+# Extensions with these prefixes are checked in Android CTS, and thus must be
+# whitelisted per the preceding dict.
+ANDROID_EXTENSION_WHITELIST_PREFIXES = (
+    "VK_KHX",
+    "VK_KHR",
+    "VK_GOOGLE",
+    "VK_ANDROID"
+)
diff --git a/src/kosmickrisp/vulkan/cl/kk_query.cl b/src/kosmickrisp/vulkan/cl/kk_query.cl
new file mode 100644
index 00000000000..ef24ab8ab7b
--- /dev/null
+++ b/src/kosmickrisp/vulkan/cl/kk_query.cl
@@ -0,0 +1,50 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright © 2024 Alyssa Rosenzweig
+ * Copyright © 2024 Valve Corporation
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+#include "compiler/libcl/libcl_vk.h"
+
+#include "kk_query.h"
+
+void
+libkk_write_u64(global struct libkk_imm_write *write_array)
+{
+   *write_array[cl_group_id.x].address = write_array[cl_group_id.x].value;
+}
+
+void
+libkk_copy_queries(global uint64_t *availability, global uint64_t *results,
+                   global uint16_t *oq_index, uint64_t dst_addr,
+                   uint64_t dst_stride, uint32_t first_query,
+                   VkQueryResultFlagBits flags, uint16_t reports_per_query)
+{
+   uint index = cl_group_id.x;
+   uint64_t dst = dst_addr + (((uint64_t)index) * dst_stride);
+   uint32_t query = first_query + index;
+
+   bool available;
+   if (availability)
+      available = availability[query];
+   else
+      available = (results[query] != LIBKK_QUERY_UNAVAILABLE);
+
+   if (available || (flags & VK_QUERY_RESULT_PARTIAL_BIT)) {
+      /* For occlusion queries, results[] points to the device global heap. We
+       * need to remap indices according to the query pool's allocation.
+       */
+      uint result_index = oq_index ? oq_index[query] : query;
+      uint idx = result_index * reports_per_query;
+
+      for (unsigned i = 0; i < reports_per_query; ++i) {
+         vk_write_query(dst, i, flags, results[idx + i]);
+      }
+   }
+
+   if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) {
+      vk_write_query(dst, reports_per_query, flags, available);
+   }
+}
diff --git a/src/kosmickrisp/vulkan/cl/kk_query.h b/src/kosmickrisp/vulkan/cl/kk_query.h
new file mode 100644
index 00000000000..8b37d36bb74
--- /dev/null
+++ b/src/kosmickrisp/vulkan/cl/kk_query.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright © 2024 Alyssa Rosenzweig
+ * Copyright © 2024 Valve Corporation
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+#ifndef KK_QUERY_H
+#define KK_QUERY_H
+
+#include "compiler/libcl/libcl.h"
+
+struct libkk_imm_write {
+   DEVICE(uint64_t) address;
+   uint64_t value;
+};
+
+#define LIBKK_QUERY_UNAVAILABLE (uint64_t)((int64_t)-1)
+
+#endif /* KK_QUERY_H */
diff --git a/src/kosmickrisp/vulkan/cl/kk_triangle_fan.cl b/src/kosmickrisp/vulkan/cl/kk_triangle_fan.cl
new file mode 100644
index 00000000000..bc2e250d072
--- /dev/null
+++ b/src/kosmickrisp/vulkan/cl/kk_triangle_fan.cl
@@ -0,0 +1,283 @@
+/*
+ * Copyright 2023 Alyssa Rosenzweig
+ * Copyright 2023 Valve Corporation
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+#include "compiler/libcl/libcl_vk.h"
+#include "compiler/shader_enums.h"
+
+static uint
+libkk_vertex_id_for_line_loop(uint prim, uint vert, uint num_prims)
+{
+   /* (0, 1), (1, 2), (2, 0) */
+   if (prim == (num_prims - 1) && vert == 1)
+      return 0;
+   else
+      return prim + vert;
+}
+
+/* Swap the two non-provoking vertices third vert in odd triangles. This
+ * generates a vertex ID list with a consistent winding order.
+ *
+ * With prim and flatshade_first, the map : [0, 1, 2] -> [0, 1, 2] is its own
+ * inverse. This lets us reuse it for both vertex fetch and transform feedback.
+ */
+static uint
+libagx_map_vertex_in_tri_strip(uint prim, uint vert, bool flatshade_first)
+{
+   unsigned pv = flatshade_first ? 0 : 2;
+
+   bool even = (prim & 1) == 0;
+   bool provoking = vert == pv;
+
+   return (provoking || even) ? vert : ((3 - pv) - vert);
+}
+
+static uint
+libkk_vertex_id_for_tri_fan(uint prim, uint vert, bool flatshade_first)
+{
+   /* Vulkan spec section 20.1.7 gives (i + 1, i + 2, 0) for a provoking
+    * first. OpenGL instead wants (0, i + 1, i + 2) with a provoking last.
+    * Piglit clipflat expects us to switch between these orders depending on
+    * provoking vertex, to avoid trivializing the fan.
+    *
+    * Rotate accordingly.
+    */
+   if (flatshade_first) {
+      vert = (vert == 2) ? 0 : (vert + 1);
+   }
+
+   /* The simpler form assuming last is provoking. */
+   return (vert == 0) ? 0 : prim + vert;
+}
+
+static uint
+libkk_vertex_id_for_tri_strip_adj(uint prim, uint vert, uint num_prims,
+                                  bool flatshade_first)
+{
+   /* See Vulkan spec section 20.1.11 "Triangle Strips With Adjancency".
+    *
+    * There are different cases for first/middle/last/only primitives and for
+    * odd/even primitives.  Determine which case we're in.
+    */
+   bool last = prim == (num_prims - 1);
+   bool first = prim == 0;
+   bool even = (prim & 1) == 0;
+   bool even_or_first = even || first;
+
+   /* When the last vertex is provoking, we rotate the primitives
+    * accordingly. This seems required for OpenGL.
+    */
+   if (!flatshade_first && !even_or_first) {
+      vert = (vert + 4u) % 6u;
+   }
+
+   /* Offsets per the spec. The spec lists 6 cases with 6 offsets. Luckily,
+    * there are lots of patterns we can exploit, avoiding a full 6x6 LUT.
+    *
+    * Here we assume the first vertex is provoking, the Vulkan default.
+    */
+   uint offsets[6] = {
+      0,
+      first ? 1 : (even ? -2 : 3),
+      even_or_first ? 2 : 4,
+      last ? 5 : 6,
+      even_or_first ? 4 : 2,
+      even_or_first ? 3 : -2,
+   };
+
+   /* Ensure NIR can see thru the local array */
+   uint offset = 0;
+   for (uint i = 1; i < 6; ++i) {
+      if (i == vert)
+         offset = offsets[i];
+   }
+
+   /* Finally add to the base of the primitive */
+   return (prim * 2) + offset;
+}
+
+static uint
+vertex_id_for_topology(enum mesa_prim mode, bool flatshade_first, uint prim,
+                       uint vert, uint num_prims)
+{
+   switch (mode) {
+   case MESA_PRIM_POINTS:
+   case MESA_PRIM_LINES:
+   case MESA_PRIM_TRIANGLES:
+   case MESA_PRIM_LINES_ADJACENCY:
+   case MESA_PRIM_TRIANGLES_ADJACENCY:
+      /* Regular primitive: every N vertices defines a primitive */
+      return (prim * mesa_vertices_per_prim(mode)) + vert;
+
+   case MESA_PRIM_LINE_LOOP:
+      return libkk_vertex_id_for_line_loop(prim, vert, num_prims);
+
+   case MESA_PRIM_LINE_STRIP:
+   case MESA_PRIM_LINE_STRIP_ADJACENCY:
+      /* (i, i + 1) or (i, ..., i + 3) */
+      return prim + vert;
+
+   case MESA_PRIM_TRIANGLE_STRIP: {
+      /* Order depends on the provoking vert.
+       *
+       * First: (0, 1, 2), (1, 3, 2), (2, 3, 4).
+       * Last:  (0, 1, 2), (2, 1, 3), (2, 3, 4).
+       *
+       * Pull the (maybe swapped) vert from the corresponding primitive
+       */
+      return prim + libagx_map_vertex_in_tri_strip(prim, vert, flatshade_first);
+   }
+
+   case MESA_PRIM_TRIANGLE_FAN:
+      return libkk_vertex_id_for_tri_fan(prim, vert, flatshade_first);
+
+   case MESA_PRIM_TRIANGLE_STRIP_ADJACENCY:
+      return libkk_vertex_id_for_tri_strip_adj(prim, vert, num_prims,
+                                               flatshade_first);
+
+   default:
+      return 0;
+   }
+}
+
+static void
+store_index(global uint8_t *index_buffer, uint index_size_B, uint id,
+            uint value)
+{
+   global uint32_t *out_32 = (global uint32_t *)index_buffer;
+   global uint16_t *out_16 = (global uint16_t *)index_buffer;
+   global uint8_t *out_8 = (global uint8_t *)index_buffer;
+
+   if (index_size_B == 4)
+      out_32[id] = value;
+   else if (index_size_B == 2)
+      out_16[id] = value;
+   else
+      out_8[id] = value;
+}
+
+static uint
+load_index(constant uint8_t *index_buffer, uint32_t index_buffer_range_el,
+           uint id, uint index_size)
+{
+   /* We have no index buffer, index is the id */
+   if (index_buffer == 0u)
+      return id;
+
+   /* When no index_buffer is present, index_buffer_range_el is vtx count */
+   bool oob = id >= index_buffer_range_el;
+
+   /* If the load would be out-of-bounds, load the first element which is
+    * assumed valid. If the application index buffer is empty with robustness2,
+    * index_buffer will point to a zero sink where only the first is valid.
+    */
+   if (oob) {
+      id = 0u;
+   }
+
+   uint el;
+   if (index_size == 1) {
+      el = ((constant uint8_t *)index_buffer)[id];
+   } else if (index_size == 2) {
+      el = ((constant uint16_t *)index_buffer)[id];
+   } else {
+      el = ((constant uint32_t *)index_buffer)[id];
+   }
+
+   /* D3D robustness semantics. TODO: Optimize? */
+   if (oob) {
+      el = 0;
+   }
+
+   return el;
+}
+
+/*
+ * Return the ID of the first thread in the workgroup where cond is true, or
+ * 1024 if cond is false across the workgroup.
+ */
+static uint
+first_true_thread_in_workgroup(bool cond, local uint *scratch)
+{
+   barrier(CLK_LOCAL_MEM_FENCE);
+   scratch[get_sub_group_id()] = sub_group_ballot(cond)[0];
+   barrier(CLK_LOCAL_MEM_FENCE);
+
+   uint first_group =
+      ctz(sub_group_ballot(scratch[get_sub_group_local_id()])[0]);
+   uint off = ctz(first_group < 32 ? scratch[first_group] : 0);
+   return (first_group * 32) + off;
+}
+
+// TODO_KOSMICKRISP
+// KERNEL(1024)
+void
+libkk_unroll_geometry_and_restart(
+   constant uint8_t *index_buffer, global uint8_t *out_ptr,
+   constant uint32_t *in_draw, global uint32_t *out_draw,
+   uint32_t restart_index, uint32_t index_buffer_size_el, uint32_t in_el_size_B,
+   uint32_t out_el_size_B, uint32_t flatshade_first, uint32_t mode)
+{
+   uint tid = cl_local_id.x;
+   uint count = in_draw[0];
+
+   constant uint8_t *in_ptr =
+      index_buffer ? index_buffer + (in_draw[2] * in_el_size_B) : index_buffer;
+
+   // local uint scratch[32];
+
+   uint out_prims = 0;
+   uint needle = 0;
+   uint per_prim = mesa_vertices_per_prim(mode);
+   while (needle < count) {
+      /* Search for next restart or the end. Lanes load in parallel. */
+      uint next_restart = needle;
+      for (;;) {
+         uint idx = next_restart + tid;
+         bool restart =
+            idx >= count || load_index(in_ptr, index_buffer_size_el, idx,
+                                       in_el_size_B) == restart_index;
+
+         // uint next_offs = first_true_thread_in_workgroup(restart, scratch);
+
+         // next_restart += next_offs;
+         // if (next_offs < 1024)
+         //    break;
+         if (restart)
+            break;
+         next_restart++;
+      }
+
+      /* Emit up to the next restart. Lanes output in parallel */
+      uint subcount = next_restart - needle;
+      uint subprims = u_decomposed_prims_for_vertices(mode, subcount);
+      uint out_prims_base = out_prims;
+      for (uint i = tid; i < subprims; /*i += 1024*/ ++i) {
+         for (uint vtx = 0; vtx < per_prim; ++vtx) {
+            uint id =
+               vertex_id_for_topology(mode, flatshade_first, i, vtx, subprims);
+            uint offset = needle + id;
+
+            uint x = ((out_prims_base + i) * per_prim) + vtx;
+            uint y =
+               load_index(in_ptr, index_buffer_size_el, offset, in_el_size_B);
+
+            store_index(out_ptr, out_el_size_B, x, y);
+         }
+      }
+
+      out_prims += subprims;
+      needle = next_restart + 1;
+   }
+
+   if (tid == 0) {
+      out_draw[0] = out_prims * per_prim;                   /* indexCount */
+      out_draw[1] = in_draw[1];                             /* instanceCount */
+      out_draw[2] = 0u;                                     /* firstIndex */
+      out_draw[3] = index_buffer ? in_draw[3] : in_draw[2]; /* vertexOffset */
+      out_draw[4] = index_buffer ? in_draw[4] : in_draw[3]; /* firstInstance */
+   }
+}
diff --git a/src/kosmickrisp/vulkan/kk_bo.c b/src/kosmickrisp/vulkan/kk_bo.c
new file mode 100644
index 00000000000..708b93fb2ed
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_bo.c
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_bo.h"
+
+#include "kk_device.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+#include "util/u_memory.h"
+
+VkResult
+kk_alloc_bo(struct kk_device *dev, struct vk_object_base *log_obj,
+            uint64_t size_B, uint64_t align_B, struct kk_bo **bo_out)
+{
+   VkResult result = VK_SUCCESS;
+
+   // TODO_KOSMICKRISP: Probably requires handling the buffer maximum 256MB
+   uint64_t minimum_alignment = 0u;
+   mtl_heap_buffer_size_and_align_with_length(dev->mtl_handle, &size_B,
+                                              &minimum_alignment);
+   minimum_alignment = MAX2(minimum_alignment, align_B);
+   size_B = align64(size_B, minimum_alignment);
+   mtl_heap *handle =
+      mtl_new_heap(dev->mtl_handle, size_B, KK_MTL_RESOURCE_OPTIONS);
+   if (handle == NULL) {
+      result = vk_errorf(log_obj, VK_ERROR_OUT_OF_DEVICE_MEMORY, "%m");
+      goto fail_heap;
+   }
+
+   mtl_buffer *map = mtl_new_buffer_with_length(handle, size_B, 0u);
+   if (map == NULL) {
+      result = vk_errorf(log_obj, VK_ERROR_OUT_OF_DEVICE_MEMORY, "%m");
+      goto fail_map;
+   }
+
+   struct kk_bo *bo = CALLOC_STRUCT(kk_bo);
+
+   if (bo == NULL) {
+      result = vk_errorf(log_obj, VK_ERROR_OUT_OF_HOST_MEMORY, "%m");
+      goto fail_alloc;
+   }
+
+   bo->mtl_handle = handle;
+   bo->size_B = size_B;
+   bo->map = map;
+   bo->gpu = mtl_buffer_get_gpu_address(map);
+   bo->cpu = mtl_get_contents(map);
+
+   *bo_out = bo;
+   return result;
+
+fail_alloc:
+   mtl_release(map);
+fail_map:
+   mtl_release(handle);
+fail_heap:
+   return result;
+}
+
+void
+kk_destroy_bo(struct kk_device *dev, struct kk_bo *bo)
+{
+   mtl_release(bo->map);
+   mtl_release(bo->mtl_handle);
+   FREE(bo);
+}
diff --git a/src/kosmickrisp/vulkan/kk_bo.h b/src/kosmickrisp/vulkan/kk_bo.h
new file mode 100644
index 00000000000..5a97723720b
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_bo.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright © 2025 LunarG, Inc
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_BO_H
+#define KK_BO_H 1
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "vulkan/vulkan_core.h"
+
+#include <inttypes.h>
+
+struct kk_device;
+struct vk_object_base;
+
+struct kk_bo {
+   mtl_heap *mtl_handle;
+   mtl_buffer *map;
+   uint64_t size_B;
+   uint64_t gpu; // GPU address
+   void *cpu;    // CPU address
+};
+
+VkResult kk_alloc_bo(struct kk_device *dev, struct vk_object_base *log_obj,
+                     uint64_t size_B, uint64_t align_B, struct kk_bo **bo_out);
+
+void kk_destroy_bo(struct kk_device *dev, struct kk_bo *bo);
+
+#endif /* KK_BO_H */
diff --git a/src/kosmickrisp/vulkan/kk_buffer.c b/src/kosmickrisp/vulkan/kk_buffer.c
new file mode 100644
index 00000000000..75c10ab86f9
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_buffer.c
@@ -0,0 +1,209 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_buffer.h"
+
+#include "kk_device.h"
+#include "kk_entrypoints.h"
+#include "kk_physical_device.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+static uint64_t
+kk_get_buffer_alignment(const struct kk_physical_device *pdev, uint64_t size,
+                        VkBufferUsageFlags2KHR usage_flags,
+                        VkBufferCreateFlags create_flags)
+{
+   uint64_t alignment;
+   mtl_heap_buffer_size_and_align_with_length(pdev->mtl_dev_handle, &size,
+                                              &alignment);
+
+   /** TODO_KOSMICKRISP Metal requires that texel buffers be aligned to the
+    * format they'll use. Since we won't be able to know the format until the
+    * view is created, we should align to the worst case scenario. For this, we
+    * need to request all supported format alignments and take the largest one.
+    */
+   return alignment;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_CreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
+                const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   struct kk_buffer *buffer;
+
+   if (pCreateInfo->size > KK_MAX_BUFFER_SIZE)
+      return vk_error(dev, VK_ERROR_OUT_OF_DEVICE_MEMORY);
+
+   buffer =
+      vk_buffer_create(&dev->vk, pCreateInfo, pAllocator, sizeof(*buffer));
+   if (!buffer)
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   *pBuffer = kk_buffer_to_handle(buffer);
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_DestroyBuffer(VkDevice device, VkBuffer _buffer,
+                 const VkAllocationCallbacks *pAllocator)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_buffer, buffer, _buffer);
+
+   if (!buffer)
+      return;
+
+   if (buffer->mtl_handle)
+      mtl_release(buffer->mtl_handle);
+
+   vk_buffer_destroy(&dev->vk, pAllocator, &buffer->vk);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetDeviceBufferMemoryRequirements(
+   VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo,
+   VkMemoryRequirements2 *pMemoryRequirements)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   struct kk_physical_device *pdev = kk_device_physical(dev);
+
+   const uint64_t alignment = kk_get_buffer_alignment(
+      pdev, pInfo->pCreateInfo->size, pInfo->pCreateInfo->usage,
+      pInfo->pCreateInfo->flags);
+
+   pMemoryRequirements->memoryRequirements = (VkMemoryRequirements){
+      .size = align64(pInfo->pCreateInfo->size, alignment),
+      .alignment = alignment,
+      .memoryTypeBits = BITFIELD_MASK(pdev->mem_type_count),
+   };
+
+   vk_foreach_struct_const(ext, pMemoryRequirements->pNext) {
+      switch (ext->sType) {
+      case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
+         VkMemoryDedicatedRequirements *dedicated = (void *)ext;
+         dedicated->prefersDedicatedAllocation = false;
+         dedicated->requiresDedicatedAllocation = false;
+         break;
+      }
+      default:
+         vk_debug_ignored_stype(ext->sType);
+         break;
+      }
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetPhysicalDeviceExternalBufferProperties(
+   VkPhysicalDevice physicalDevice,
+   const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
+   VkExternalBufferProperties *pExternalBufferProperties)
+{
+   /* The Vulkan 1.3.256 spec says:
+    *
+    *    VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter
+    *
+    *    "handleType must be a valid VkExternalMemoryHandleTypeFlagBits value"
+    *
+    * This differs from VkPhysicalDeviceExternalImageFormatInfo, which
+    * surprisingly permits handleType == 0.
+    */
+   assert(pExternalBufferInfo->handleType != 0);
+
+   /* All of the current flags are for sparse which we don't support yet.
+    * Even when we do support it, doing sparse on external memory sounds
+    * sketchy.  Also, just disallowing flags is the safe option.
+    */
+   if (pExternalBufferInfo->flags)
+      goto unsupported;
+
+   switch (pExternalBufferInfo->handleType) {
+   case VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT:
+      pExternalBufferProperties->externalMemoryProperties =
+         kk_mtlheap_mem_props;
+      return;
+   default:
+      goto unsupported;
+   }
+
+unsupported:
+   /* From the Vulkan 1.3.256 spec:
+    *
+    *    compatibleHandleTypes must include at least handleType.
+    */
+   pExternalBufferProperties->externalMemoryProperties =
+      (VkExternalMemoryProperties){
+         .compatibleHandleTypes = pExternalBufferInfo->handleType,
+      };
+}
+
+static VkResult
+kk_bind_buffer_memory(struct kk_device *dev, const VkBindBufferMemoryInfo *info)
+{
+   // Do the actual memory binding
+   VK_FROM_HANDLE(kk_device_memory, mem, info->memory);
+   VK_FROM_HANDLE(kk_buffer, buffer, info->buffer);
+
+   buffer->mtl_handle = mtl_new_buffer_with_length(
+      mem->bo->mtl_handle, buffer->vk.size, info->memoryOffset);
+   buffer->vk.device_address = mtl_buffer_get_gpu_address(buffer->mtl_handle);
+   /* We need Metal to give us a CPU mapping so it correctly captures the
+    * data in the GPU debugger... */
+   mtl_get_contents(buffer->mtl_handle);
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_BindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
+                     const VkBindBufferMemoryInfo *pBindInfos)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VkResult first_error_or_success = VK_SUCCESS;
+
+   for (uint32_t i = 0; i < bindInfoCount; ++i) {
+      VkResult result = kk_bind_buffer_memory(dev, &pBindInfos[i]);
+
+      const VkBindMemoryStatusKHR *status =
+         vk_find_struct_const(pBindInfos[i].pNext, BIND_MEMORY_STATUS_KHR);
+      if (status != NULL && status->pResult != NULL)
+         *status->pResult = result;
+
+      if (first_error_or_success == VK_SUCCESS)
+         first_error_or_success = result;
+   }
+
+   return first_error_or_success;
+}
+
+VKAPI_ATTR VkDeviceAddress VKAPI_CALL
+kk_GetBufferDeviceAddress(UNUSED VkDevice device,
+                          const VkBufferDeviceAddressInfo *pInfo)
+{
+   VK_FROM_HANDLE(kk_buffer, buffer, pInfo->buffer);
+
+   return vk_buffer_address(&buffer->vk, 0);
+}
+
+VKAPI_ATTR uint64_t VKAPI_CALL
+kk_GetBufferOpaqueCaptureAddress(UNUSED VkDevice device,
+                                 const VkBufferDeviceAddressInfo *pInfo)
+{
+   VK_FROM_HANDLE(kk_buffer, buffer, pInfo->buffer);
+
+   return vk_buffer_address(&buffer->vk, 0);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_GetBufferOpaqueCaptureDescriptorDataEXT(
+   VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo,
+   void *pData)
+{
+   return VK_SUCCESS;
+}
diff --git a/src/kosmickrisp/vulkan/kk_buffer.h b/src/kosmickrisp/vulkan/kk_buffer.h
new file mode 100644
index 00000000000..1d9744678b6
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_buffer.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_BUFFER_H
+#define KK_BUFFER_H 1
+
+#include "kk_device_memory.h"
+#include "kk_private.h"
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "vk_buffer.h"
+
+struct kk_buffer {
+   struct vk_buffer vk;
+   mtl_buffer *mtl_handle;
+};
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_buffer, vk.base, VkBuffer,
+                               VK_OBJECT_TYPE_BUFFER)
+
+static inline struct kk_addr_range
+kk_buffer_addr_range(const struct kk_buffer *buffer, uint64_t offset,
+                     uint64_t range)
+{
+   if (buffer == NULL)
+      return (struct kk_addr_range){.range = 0};
+
+   return (struct kk_addr_range){
+      .addr = vk_buffer_address(&buffer->vk, offset),
+      .range = vk_buffer_range(&buffer->vk, offset, range),
+   };
+}
+
+static inline mtl_resource *
+kk_buffer_to_mtl_resource(const struct kk_buffer *buffer)
+{
+   if (buffer != NULL) {
+      return (mtl_resource *)buffer->mtl_handle;
+   }
+   return NULL;
+}
+
+#endif // KK_BUFFER_H
diff --git a/src/kosmickrisp/vulkan/kk_buffer_view.c b/src/kosmickrisp/vulkan/kk_buffer_view.c
new file mode 100644
index 00000000000..0ee011f2f73
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_buffer_view.c
@@ -0,0 +1,124 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_buffer_view.h"
+
+#include "kk_buffer.h"
+#include "kk_device.h"
+#include "kk_entrypoints.h"
+#include "kk_format.h"
+#include "kk_image_layout.h"
+#include "kk_nir_lower_vbo.h"
+#include "kk_physical_device.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+#include "kosmickrisp/bridge/mtl_format.h"
+
+#include "vk_format.h"
+
+VkFormatFeatureFlags2
+kk_get_buffer_format_features(struct kk_physical_device *pdev,
+                              VkFormat vk_format)
+{
+   VkFormatFeatureFlags2 features = 0;
+   enum pipe_format p_format = vk_format_to_pipe_format(vk_format);
+
+   if (p_format == PIPE_FORMAT_NONE)
+      return 0;
+
+   const struct kk_va_format *format = kk_get_va_format(p_format);
+   if (format) {
+      if (format->texel_buffer.read)
+         features |= VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT;
+
+      if (format->texel_buffer.write)
+         features |= VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT;
+
+      /* Only these formats allow atomics for texel buffers */
+      if (vk_format == VK_FORMAT_R32_UINT || vk_format == VK_FORMAT_R32_SINT)
+         features |= VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
+   }
+
+   if (kk_vbo_supports_format(p_format))
+      features |= VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT;
+
+   return features;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_CreateBufferView(VkDevice _device, const VkBufferViewCreateInfo *pCreateInfo,
+                    const VkAllocationCallbacks *pAllocator,
+                    VkBufferView *pBufferView)
+{
+   VK_FROM_HANDLE(kk_device, dev, _device);
+   struct kk_buffer_view *view =
+      vk_buffer_view_create(&dev->vk, pCreateInfo, pAllocator, sizeof(*view));
+   if (!view)
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   enum pipe_format p_format = vk_format_to_pipe_format(view->vk.format);
+   const struct kk_va_format *supported_format = kk_get_va_format(p_format);
+
+   /* If we reached here, we support reading at least */
+   enum mtl_texture_usage usage = MTL_TEXTURE_USAGE_SHADER_READ;
+   if (supported_format->texel_buffer.write)
+      usage |= MTL_TEXTURE_USAGE_SHADER_WRITE;
+
+   /* Only these formats allow atomics for texel buffers */
+   if (view->vk.format == VK_FORMAT_R32_UINT ||
+       view->vk.format == VK_FORMAT_R32_SINT)
+      usage |= MTL_TEXTURE_USAGE_SHADER_ATOMIC;
+
+   struct kk_image_layout layout = {
+      .width_px = view->vk.elements,
+      .height_px = 1u,
+      .depth_px = 1u,
+      .layers = 1u,
+      .type = MTL_TEXTURE_TYPE_TEXTURE_BUFFER,
+      .sample_count_sa = 1u,
+      .levels = 1u,
+      .optimized_layout = false,
+      .usage = usage,
+      .format = {.pipe = p_format, .mtl = supported_format->mtl_pixel_format},
+      .swizzle =
+         {
+            .red = supported_format->swizzle.red,
+            .green = supported_format->swizzle.green,
+            .blue = supported_format->swizzle.blue,
+            .alpha = supported_format->swizzle.alpha,
+         },
+      .linear_stride_B = view->vk.range,
+   };
+   struct kk_buffer *buffer =
+      container_of(view->vk.buffer, struct kk_buffer, vk);
+   view->mtl_texel_buffer_handle = mtl_new_texture_with_descriptor_linear(
+      buffer->mtl_handle, &layout, view->vk.offset);
+   if (!view->mtl_texel_buffer_handle) {
+      vk_buffer_view_destroy(&dev->vk, pAllocator, &view->vk);
+      return vk_error(dev, VK_ERROR_OUT_OF_DEVICE_MEMORY);
+   }
+   view->texel_buffer_gpu_id =
+      mtl_texture_get_gpu_resource_id(view->mtl_texel_buffer_handle);
+
+   *pBufferView = kk_buffer_view_to_handle(view);
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_DestroyBufferView(VkDevice _device, VkBufferView bufferView,
+                     const VkAllocationCallbacks *pAllocator)
+{
+   VK_FROM_HANDLE(kk_device, dev, _device);
+   VK_FROM_HANDLE(kk_buffer_view, view, bufferView);
+
+   if (!view)
+      return;
+
+   mtl_release(view->mtl_texel_buffer_handle);
+   vk_buffer_view_destroy(&dev->vk, pAllocator, &view->vk);
+}
diff --git a/src/kosmickrisp/vulkan/kk_buffer_view.h b/src/kosmickrisp/vulkan/kk_buffer_view.h
new file mode 100644
index 00000000000..8525e50b760
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_buffer_view.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_BUFFER_VIEW_H
+#define KK_BUFFER_VIEW_H 1
+
+#include "kk_private.h"
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "vk_buffer_view.h"
+
+struct kk_physical_device;
+
+VkFormatFeatureFlags2
+kk_get_buffer_format_features(struct kk_physical_device *pdev, VkFormat format);
+
+struct kk_buffer_view {
+   struct vk_buffer_view vk;
+   mtl_texture *mtl_texel_buffer_handle;
+   uint64_t texel_buffer_gpu_id;
+};
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_buffer_view, vk.base, VkBufferView,
+                               VK_OBJECT_TYPE_BUFFER_VIEW)
+
+#endif
diff --git a/src/kosmickrisp/vulkan/kk_cmd_buffer.c b/src/kosmickrisp/vulkan/kk_cmd_buffer.c
new file mode 100644
index 00000000000..c4366012a8f
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_cmd_buffer.c
@@ -0,0 +1,533 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_cmd_buffer.h"
+
+#include "kk_buffer.h"
+#include "kk_cmd_pool.h"
+#include "kk_descriptor_set_layout.h"
+#include "kk_encoder.h"
+#include "kk_entrypoints.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+#include "vk_alloc.h"
+#include "vk_pipeline_layout.h"
+
+static void
+kk_descriptor_state_fini(struct kk_cmd_buffer *cmd,
+                         struct kk_descriptor_state *desc)
+{
+   struct kk_cmd_pool *pool = kk_cmd_buffer_pool(cmd);
+
+   for (unsigned i = 0; i < KK_MAX_SETS; i++) {
+      vk_free(&pool->vk.alloc, desc->push[i]);
+      desc->push[i] = NULL;
+      desc->sets[i] = NULL; /* We also need to set sets to NULL so state doesn't
+                               propagate if we reset it */
+      desc->sets_not_resident = 0u;
+   }
+}
+
+void
+kk_cmd_release_resources(struct kk_device *dev, struct kk_cmd_buffer *cmd)
+{
+   kk_cmd_release_dynamic_ds_state(cmd);
+   kk_descriptor_state_fini(cmd, &cmd->state.gfx.descriptors);
+   kk_descriptor_state_fini(cmd, &cmd->state.cs.descriptors);
+
+   /* Release all BOs used as descriptor buffers for submissions */
+   util_dynarray_foreach(&cmd->large_bos, struct kk_bo *, bo) {
+      kk_destroy_bo(dev, *bo);
+   }
+   util_dynarray_clear(&cmd->large_bos);
+}
+
+static void
+kk_destroy_cmd_buffer(struct vk_command_buffer *vk_cmd_buffer)
+{
+   struct kk_cmd_buffer *cmd =
+      container_of(vk_cmd_buffer, struct kk_cmd_buffer, vk);
+   struct kk_cmd_pool *pool = kk_cmd_buffer_pool(cmd);
+
+   vk_command_buffer_finish(&cmd->vk);
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+
+   kk_cmd_release_resources(dev, cmd);
+
+   vk_free(&pool->vk.alloc, cmd);
+}
+
+static VkResult
+kk_create_cmd_buffer(struct vk_command_pool *vk_pool,
+                     VkCommandBufferLevel level,
+                     struct vk_command_buffer **cmd_buffer_out)
+{
+   struct kk_cmd_pool *pool = container_of(vk_pool, struct kk_cmd_pool, vk);
+   struct kk_device *dev = kk_cmd_pool_device(pool);
+   struct kk_cmd_buffer *cmd;
+   VkResult result;
+
+   cmd = vk_zalloc(&pool->vk.alloc, sizeof(*cmd), 8,
+                   VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+   if (cmd == NULL)
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   result =
+      vk_command_buffer_init(&pool->vk, &cmd->vk, &kk_cmd_buffer_ops, level);
+   if (result != VK_SUCCESS) {
+      vk_free(&pool->vk.alloc, cmd);
+      return result;
+   }
+
+   util_dynarray_init(&cmd->large_bos, NULL);
+
+   cmd->vk.dynamic_graphics_state.vi = &cmd->state.gfx._dynamic_vi;
+   cmd->vk.dynamic_graphics_state.ms.sample_locations =
+      &cmd->state.gfx._dynamic_sl;
+
+   *cmd_buffer_out = &cmd->vk;
+
+   return VK_SUCCESS;
+}
+
+static void
+kk_reset_cmd_buffer(struct vk_command_buffer *vk_cmd_buffer,
+                    UNUSED VkCommandBufferResetFlags flags)
+{
+   struct kk_cmd_buffer *cmd =
+      container_of(vk_cmd_buffer, struct kk_cmd_buffer, vk);
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+
+   vk_command_buffer_reset(&cmd->vk);
+   kk_cmd_release_resources(dev, cmd);
+}
+
+const struct vk_command_buffer_ops kk_cmd_buffer_ops = {
+   .create = kk_create_cmd_buffer,
+   .reset = kk_reset_cmd_buffer,
+   .destroy = kk_destroy_cmd_buffer,
+};
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_BeginCommandBuffer(VkCommandBuffer commandBuffer,
+                      const VkCommandBufferBeginInfo *pBeginInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+
+   kk_reset_cmd_buffer(&cmd->vk, 0u);
+   vk_command_buffer_begin(&cmd->vk, pBeginInfo);
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_EndCommandBuffer(VkCommandBuffer commandBuffer)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+
+   return vk_command_buffer_end(&cmd->vk);
+}
+
+static bool
+kk_can_ignore_barrier(VkAccessFlags2 access, VkPipelineStageFlags2 stage)
+{
+   if (access == VK_ACCESS_2_NONE || stage == VK_PIPELINE_STAGE_2_NONE)
+      return true;
+
+   const VkAccessFlags2 ignore_access =
+      VK_ACCESS_2_HOST_READ_BIT | VK_ACCESS_2_HOST_WRITE_BIT;
+   const VkPipelineStageFlags2 ignore_stage = VK_PIPELINE_STAGE_2_HOST_BIT;
+   return (!(access ^ ignore_access)) || (!(stage ^ ignore_stage));
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdPipelineBarrier2(VkCommandBuffer commandBuffer,
+                       const VkDependencyInfo *pDependencyInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   enum kk_encoder_type last_used = cmd->encoder->main.last_used;
+   kk_encoder_signal_fence_and_end(cmd);
+
+   /* If we were inside a render pass, restart it loading attachments */
+   if (last_used == KK_ENC_RENDER) {
+      struct kk_graphics_state *state = &cmd->state.gfx;
+      assert(state->render_pass_descriptor);
+      kk_encoder_start_render(cmd, state->render_pass_descriptor,
+                              state->render.view_mask);
+      kk_cmd_buffer_dirty_all_gfx(cmd);
+   }
+}
+
+static void
+kk_bind_descriptor_sets(struct kk_descriptor_state *desc,
+                        const VkBindDescriptorSetsInfoKHR *info)
+{
+   VK_FROM_HANDLE(vk_pipeline_layout, pipeline_layout, info->layout);
+
+   /* From the Vulkan 1.3.275 spec:
+    *
+    *    "When binding a descriptor set (see Descriptor Set Binding) to
+    *    set number N...
+    *
+    *    If, additionally, the previously bound descriptor set for set
+    *    N was bound using a pipeline layout not compatible for set N,
+    *    then all bindings in sets numbered greater than N are
+    *    disturbed."
+    *
+    * This means that, if some earlier set gets bound in such a way that
+    * it changes set_dynamic_buffer_start[s], this binding is implicitly
+    * invalidated.  Therefore, we can always look at the current value
+    * of set_dynamic_buffer_start[s] as the base of our dynamic buffer
+    * range and it's only our responsibility to adjust all
+    * set_dynamic_buffer_start[p] for p > s as needed.
+    */
+   uint8_t dyn_buffer_start =
+      desc->root.set_dynamic_buffer_start[info->firstSet];
+
+   uint32_t next_dyn_offset = 0;
+   for (uint32_t i = 0; i < info->descriptorSetCount; ++i) {
+      unsigned s = i + info->firstSet;
+      VK_FROM_HANDLE(kk_descriptor_set, set, info->pDescriptorSets[i]);
+
+      if (desc->sets[s] != set) {
+         if (set != NULL) {
+            desc->root.sets[s] = set->addr;
+            desc->set_sizes[s] = set->size;
+         } else {
+            desc->root.sets[s] = 0;
+            desc->set_sizes[s] = 0;
+         }
+         desc->sets[s] = set;
+
+         desc->sets_not_resident |= BITFIELD_BIT(s);
+
+         /* Binding descriptors invalidates push descriptors */
+         desc->push_dirty &= ~BITFIELD_BIT(s);
+      }
+
+      if (pipeline_layout->set_layouts[s] != NULL) {
+         const struct kk_descriptor_set_layout *set_layout =
+            vk_to_kk_descriptor_set_layout(pipeline_layout->set_layouts[s]);
+
+         if (set != NULL && set_layout->dynamic_buffer_count > 0) {
+            for (uint32_t j = 0; j < set_layout->dynamic_buffer_count; j++) {
+               struct kk_buffer_address addr = set->dynamic_buffers[j];
+               addr.base_addr += info->pDynamicOffsets[next_dyn_offset + j];
+               desc->root.dynamic_buffers[dyn_buffer_start + j] = addr;
+            }
+            next_dyn_offset += set->layout->dynamic_buffer_count;
+         }
+
+         dyn_buffer_start += set_layout->dynamic_buffer_count;
+      } else {
+         assert(set == NULL);
+      }
+   }
+   assert(dyn_buffer_start <= KK_MAX_DYNAMIC_BUFFERS);
+   assert(next_dyn_offset <= info->dynamicOffsetCount);
+
+   for (uint32_t s = info->firstSet + info->descriptorSetCount; s < KK_MAX_SETS;
+        s++)
+      desc->root.set_dynamic_buffer_start[s] = dyn_buffer_start;
+
+   desc->root_dirty = true;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdBindDescriptorSets2KHR(
+   VkCommandBuffer commandBuffer,
+   const VkBindDescriptorSetsInfoKHR *pBindDescriptorSetsInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+
+   if (pBindDescriptorSetsInfo->stageFlags & VK_SHADER_STAGE_ALL_GRAPHICS) {
+      kk_bind_descriptor_sets(&cmd->state.gfx.descriptors,
+                              pBindDescriptorSetsInfo);
+   }
+
+   if (pBindDescriptorSetsInfo->stageFlags & VK_SHADER_STAGE_COMPUTE_BIT) {
+      kk_bind_descriptor_sets(&cmd->state.cs.descriptors,
+                              pBindDescriptorSetsInfo);
+   }
+}
+
+static struct kk_push_descriptor_set *
+kk_cmd_push_descriptors(struct kk_cmd_buffer *cmd,
+                        struct kk_descriptor_state *desc,
+                        struct kk_descriptor_set_layout *set_layout,
+                        uint32_t set)
+{
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+   assert(set < KK_MAX_SETS);
+   if (unlikely(desc->push[set] == NULL)) {
+      size_t size = sizeof(*desc->push[set]) +
+                    (sizeof(mtl_resource *) * set_layout->descriptor_count);
+      desc->push[set] = vk_zalloc(&cmd->vk.pool->alloc, size, 8,
+                                  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+      if (unlikely(desc->push[set] == NULL)) {
+         vk_command_buffer_set_error(&cmd->vk, VK_ERROR_OUT_OF_HOST_MEMORY);
+         return NULL;
+      }
+      desc->push[set]->layout = set_layout;
+      for (uint32_t i = 0u; i < set_layout->descriptor_count; ++i)
+         desc->push[set]->mtl_resources[i] = dev->null_descriptor->map;
+   }
+
+   /* Pushing descriptors replaces whatever sets are bound */
+   desc->sets[set] = NULL;
+   desc->push_dirty |= BITFIELD_BIT(set);
+   desc->sets_not_resident |= BITFIELD_BIT(set);
+
+   return desc->push[set];
+}
+
+static void
+kk_push_descriptor_set(struct kk_cmd_buffer *cmd,
+                       struct kk_descriptor_state *desc,
+                       const VkPushDescriptorSetInfoKHR *info)
+{
+   VK_FROM_HANDLE(vk_pipeline_layout, pipeline_layout, info->layout);
+
+   struct kk_descriptor_set_layout *set_layout =
+      vk_to_kk_descriptor_set_layout(pipeline_layout->set_layouts[info->set]);
+
+   struct kk_push_descriptor_set *push_set =
+      kk_cmd_push_descriptors(cmd, desc, set_layout, info->set);
+   if (unlikely(push_set == NULL))
+      return;
+
+   kk_push_descriptor_set_update(push_set, info->descriptorWriteCount,
+                                 info->pDescriptorWrites);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdPushDescriptorSet2KHR(
+   VkCommandBuffer commandBuffer,
+   const VkPushDescriptorSetInfoKHR *pPushDescriptorSetInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+
+   if (pPushDescriptorSetInfo->stageFlags & VK_SHADER_STAGE_ALL_GRAPHICS) {
+      kk_push_descriptor_set(cmd, &cmd->state.gfx.descriptors,
+                             pPushDescriptorSetInfo);
+   }
+
+   if (pPushDescriptorSetInfo->stageFlags & VK_SHADER_STAGE_COMPUTE_BIT) {
+      kk_push_descriptor_set(cmd, &cmd->state.cs.descriptors,
+                             pPushDescriptorSetInfo);
+   }
+}
+
+static void
+kk_push_constants(UNUSED struct kk_cmd_buffer *cmd,
+                  struct kk_descriptor_state *desc,
+                  const VkPushConstantsInfoKHR *info)
+{
+   memcpy(desc->root.push + info->offset, info->pValues, info->size);
+   desc->root_dirty = true;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdPushConstants2KHR(VkCommandBuffer commandBuffer,
+                        const VkPushConstantsInfoKHR *pPushConstantsInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+
+   if (pPushConstantsInfo->stageFlags & VK_SHADER_STAGE_ALL_GRAPHICS)
+      kk_push_constants(cmd, &cmd->state.gfx.descriptors, pPushConstantsInfo);
+
+   if (pPushConstantsInfo->stageFlags & VK_SHADER_STAGE_COMPUTE_BIT)
+      kk_push_constants(cmd, &cmd->state.cs.descriptors, pPushConstantsInfo);
+}
+
+void
+kk_cmd_buffer_write_descriptor_buffer(struct kk_cmd_buffer *cmd,
+                                      struct kk_descriptor_state *desc,
+                                      size_t size, size_t offset)
+{
+   assert(size + offset <= sizeof(desc->root.sets));
+
+   struct kk_bo *root_buffer = desc->root.root_buffer;
+
+   memcpy(root_buffer->cpu, (uint8_t *)desc->root.sets + offset, size);
+}
+
+void
+kk_cmd_release_dynamic_ds_state(struct kk_cmd_buffer *cmd)
+{
+   if (cmd->state.gfx.is_depth_stencil_dynamic &&
+       cmd->state.gfx.depth_stencil_state)
+      mtl_release(cmd->state.gfx.depth_stencil_state);
+   cmd->state.gfx.depth_stencil_state = NULL;
+}
+
+struct kk_bo *
+kk_cmd_allocate_buffer(struct kk_cmd_buffer *cmd, size_t size_B,
+                       size_t alignment_B)
+{
+   struct kk_bo *buffer = NULL;
+
+   VkResult result = kk_alloc_bo(kk_cmd_buffer_device(cmd), &cmd->vk.base,
+                                 size_B, alignment_B, &buffer);
+   if (result != VK_SUCCESS) {
+      vk_command_buffer_set_error(&cmd->vk, result);
+      return NULL;
+   }
+   util_dynarray_append(&cmd->large_bos, struct kk_bo *, buffer);
+
+   return buffer;
+}
+
+struct kk_pool
+kk_pool_upload(struct kk_cmd_buffer *cmd, void *data, size_t size_B,
+               size_t alignment_B)
+{
+   struct kk_bo *bo = kk_cmd_allocate_buffer(cmd, size_B, alignment_B);
+   if (!bo)
+      return (struct kk_pool){};
+
+   memcpy(bo->cpu, data, size_B);
+   struct kk_pool pool = {.handle = bo->map, .gpu = bo->gpu, .cpu = bo->cpu};
+
+   return pool;
+}
+
+uint64_t
+kk_upload_descriptor_root(struct kk_cmd_buffer *cmd,
+                          VkPipelineBindPoint bind_point)
+{
+   struct kk_descriptor_state *desc = kk_get_descriptors_state(cmd, bind_point);
+   struct kk_root_descriptor_table *root = &desc->root;
+   struct kk_bo *bo = kk_cmd_allocate_buffer(cmd, sizeof(*root), 8u);
+   if (bo == NULL)
+      return 0u;
+
+   memcpy(bo->cpu, root, sizeof(*root));
+   root->root_buffer = bo;
+
+   return bo->gpu;
+}
+
+void
+kk_cmd_buffer_flush_push_descriptors(struct kk_cmd_buffer *cmd,
+                                     struct kk_descriptor_state *desc)
+{
+   u_foreach_bit(set_idx, desc->push_dirty) {
+      struct kk_push_descriptor_set *push_set = desc->push[set_idx];
+      struct kk_bo *bo = kk_cmd_allocate_buffer(cmd, sizeof(push_set->data),
+                                                KK_MIN_UBO_ALIGNMENT);
+      if (bo == NULL)
+         return;
+
+      memcpy(bo->cpu, push_set->data, sizeof(push_set->data));
+      push_set->mtl_descriptor_buffer = bo->map;
+      desc->root.sets[set_idx] = bo->gpu;
+      desc->set_sizes[set_idx] = sizeof(push_set->data);
+   }
+
+   desc->root_dirty = true;
+   desc->push_dirty = 0;
+}
+
+static void
+kk_make_graphics_descriptor_resources_resident(struct kk_cmd_buffer *cmd)
+{
+   struct kk_descriptor_state *desc = &cmd->state.gfx.descriptors;
+   mtl_render_encoder *encoder = kk_render_encoder(cmd);
+   /* Make resources resident as required by Metal */
+   u_foreach_bit(set_index, desc->sets_not_resident) {
+      mtl_resource *descriptor_buffer = NULL;
+
+      /* If we have no set, it means it was a push set */
+      if (desc->sets[set_index]) {
+         struct kk_descriptor_set *set = desc->sets[set_index];
+         descriptor_buffer = set->mtl_descriptor_buffer;
+      } else {
+         struct kk_push_descriptor_set *push_set = desc->push[set_index];
+         descriptor_buffer = push_set->mtl_descriptor_buffer;
+      }
+
+      /* We could have empty descriptor sets for some reason... */
+      if (descriptor_buffer) {
+         mtl_render_use_resource(encoder, descriptor_buffer,
+                                 MTL_RESOURCE_USAGE_READ);
+      }
+   }
+
+   desc->sets_not_resident = 0u;
+}
+
+static void
+kk_make_compute_descriptor_resources_resident(struct kk_cmd_buffer *cmd)
+{
+   struct kk_descriptor_state *desc = &cmd->state.cs.descriptors;
+   mtl_compute_encoder *encoder = kk_compute_encoder(cmd);
+   u_foreach_bit(set_index, desc->sets_not_resident) {
+      /* Make resources resident as required by Metal */
+      mtl_resource *descriptor_buffer = NULL;
+      if (desc->sets[set_index]) {
+         struct kk_descriptor_set *set = desc->sets[set_index];
+         descriptor_buffer = set->mtl_descriptor_buffer;
+      } else {
+         struct kk_push_descriptor_set *push_set = desc->push[set_index];
+         descriptor_buffer = push_set->mtl_descriptor_buffer;
+      }
+
+      /* We could have empty descriptor sets for some reason... */
+      if (descriptor_buffer) {
+         mtl_compute_use_resource(encoder, descriptor_buffer,
+                                  MTL_RESOURCE_USAGE_READ);
+      }
+   }
+
+   desc->sets_not_resident = 0u;
+}
+
+void
+kk_make_descriptor_resources_resident(struct kk_cmd_buffer *cmd,
+                                      VkPipelineBindPoint bind_point)
+{
+   if (bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS)
+      kk_make_graphics_descriptor_resources_resident(cmd);
+   else if (bind_point == VK_PIPELINE_BIND_POINT_COMPUTE)
+      kk_make_compute_descriptor_resources_resident(cmd);
+}
+
+void
+kk_cmd_write(struct kk_cmd_buffer *cmd, mtl_buffer *buffer, uint64_t addr,
+             uint64_t value)
+{
+   util_dynarray_append(&cmd->encoder->imm_writes, uint64_t, addr);
+   util_dynarray_append(&cmd->encoder->imm_writes, uint64_t, value);
+   util_dynarray_append(&cmd->encoder->resident_buffers, mtl_buffer *, buffer);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdPushDescriptorSetWithTemplate2KHR(
+   VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR
+                                     *pPushDescriptorSetWithTemplateInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(vk_descriptor_update_template, template,
+                  pPushDescriptorSetWithTemplateInfo->descriptorUpdateTemplate);
+   VK_FROM_HANDLE(vk_pipeline_layout, pipeline_layout,
+                  pPushDescriptorSetWithTemplateInfo->layout);
+
+   struct kk_descriptor_state *desc =
+      kk_get_descriptors_state(cmd, template->bind_point);
+   struct kk_descriptor_set_layout *set_layout = vk_to_kk_descriptor_set_layout(
+      pipeline_layout->set_layouts[pPushDescriptorSetWithTemplateInfo->set]);
+   struct kk_push_descriptor_set *push_set = kk_cmd_push_descriptors(
+      cmd, desc, set_layout, pPushDescriptorSetWithTemplateInfo->set);
+   if (unlikely(push_set == NULL))
+      return;
+
+   kk_push_descriptor_set_update_template(
+      push_set, set_layout, template,
+      pPushDescriptorSetWithTemplateInfo->pData);
+}
diff --git a/src/kosmickrisp/vulkan/kk_cmd_buffer.h b/src/kosmickrisp/vulkan/kk_cmd_buffer.h
new file mode 100644
index 00000000000..83d91f4e0b2
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_cmd_buffer.h
@@ -0,0 +1,270 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_CMD_BUFFER_H
+#define KK_CMD_BUFFER_H 1
+
+#include "kk_private.h"
+
+#include "kk_descriptor_set.h"
+#include "kk_image.h"
+#include "kk_nir_lower_vbo.h"
+#include "kk_shader.h"
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "util/u_dynarray.h"
+
+#include "vk_command_buffer.h"
+
+#include <stdio.h>
+
+struct kk_query_pool;
+
+struct kk_root_descriptor_table {
+   struct kk_bo *root_buffer;
+
+   union {
+      struct {
+         /* Vertex input state */
+         uint32_t buffer_strides[KK_MAX_VBUFS];
+         uint64_t attrib_base[KK_MAX_ATTRIBS];
+         uint32_t attrib_clamps[KK_MAX_ATTRIBS];
+         float blend_constant[4];
+      } draw;
+      struct {
+         uint32_t base_group[3];
+      } cs;
+   };
+
+   /* Client push constants */
+   uint8_t push[KK_MAX_PUSH_SIZE];
+
+   /* Descriptor set base addresses */
+   uint64_t sets[KK_MAX_SETS];
+
+   /* Dynamic buffer bindings */
+   struct kk_buffer_address dynamic_buffers[KK_MAX_DYNAMIC_BUFFERS];
+
+   /* Start index in dynamic_buffers where each set starts */
+   uint8_t set_dynamic_buffer_start[KK_MAX_SETS];
+};
+
+struct kk_descriptor_state {
+   bool root_dirty;
+   struct kk_root_descriptor_table root;
+
+   uint32_t set_sizes[KK_MAX_SETS];
+   struct kk_descriptor_set *sets[KK_MAX_SETS];
+   mtl_resource **resources[KK_MAX_SETS];
+   /* Non resident sets can either be sets or push. If sets[index] == NULL, then
+    * push[index] != NULL */
+   uint32_t sets_not_resident;
+
+   uint32_t push_dirty;
+   struct kk_push_descriptor_set *push[KK_MAX_SETS];
+};
+
+struct kk_attachment {
+   VkFormat vk_format;
+   struct kk_image_view *iview;
+
+   VkResolveModeFlagBits resolve_mode;
+   struct kk_image_view *resolve_iview;
+
+   /* Needed to track the value of storeOp in case we need to copy images for
+    * the DRM_FORMAT_MOD_LINEAR case */
+   VkAttachmentStoreOp store_op;
+};
+
+struct kk_rendering_state {
+   VkRenderingFlagBits flags;
+
+   VkRect2D area;
+   uint32_t layer_count;
+   uint32_t view_mask;
+   uint32_t samples;
+
+   uint32_t color_att_count;
+   struct kk_attachment color_att[KK_MAX_RTS];
+   struct kk_attachment depth_att;
+   struct kk_attachment stencil_att;
+   struct kk_attachment fsr_att;
+};
+
+/* Dirty tracking bits for state not tracked by vk_dynamic_graphics_state or
+ * shaders_dirty.
+ */
+enum kk_dirty {
+   KK_DIRTY_INDEX = BITFIELD_BIT(0),
+   KK_DIRTY_VB = BITFIELD_BIT(1),
+   KK_DIRTY_OCCLUSION = BITFIELD_BIT(2),
+   KK_DIRTY_PROVOKING = BITFIELD_BIT(3),
+   KK_DIRTY_VARYINGS = BITFIELD_BIT(4),
+   KK_DIRTY_PIPELINE = BITFIELD_BIT(5),
+};
+
+struct kk_graphics_state {
+   struct kk_rendering_state render;
+   struct kk_descriptor_state descriptors;
+
+   mtl_render_pipeline_state *pipeline_state;
+   mtl_depth_stencil_state *depth_stencil_state;
+   mtl_render_pass_descriptor *render_pass_descriptor;
+   bool is_depth_stencil_dynamic;
+   bool is_cull_front_and_back;
+   bool restart_disabled;
+
+   enum mtl_primitive_type primitive_type;
+   enum mesa_prim prim;
+   enum kk_dirty dirty;
+
+   struct {
+      enum mtl_visibility_result_mode mode;
+
+      /* If enabled, index of the current occlusion query in the occlusion heap.
+       * There can only be one active at a time (hardware constraint).
+       */
+      uint16_t index;
+   } occlusion;
+
+   /* Index buffer */
+   struct {
+      mtl_buffer *handle;
+      uint32_t size;
+      uint32_t offset;
+      uint32_t restart;
+      uint8_t bytes_per_index;
+   } index;
+
+   /* Vertex buffers */
+   struct {
+      struct kk_addr_range addr_range[KK_MAX_VBUFS];
+      mtl_buffer *handles[KK_MAX_VBUFS];
+      uint32_t attribs_read;
+      /* Required to understand maximum size of index buffer if primitive is
+       * triangle fans */
+      uint32_t max_vertices;
+   } vb;
+
+   /* Needed by vk_command_buffer::dynamic_graphics_state */
+   struct vk_vertex_input_state _dynamic_vi;
+   struct vk_sample_locations_state _dynamic_sl;
+};
+
+struct kk_compute_state {
+   struct kk_descriptor_state descriptors;
+   mtl_compute_pipeline_state *pipeline_state;
+   struct mtl_size local_size;
+   enum kk_dirty dirty;
+};
+
+struct kk_encoder;
+
+struct kk_cmd_buffer {
+   struct vk_command_buffer vk;
+
+   struct kk_encoder *encoder;
+   void *drawable;
+
+   struct {
+      struct kk_graphics_state gfx;
+      struct kk_compute_state cs;
+   } state;
+
+   /* Owned large BOs */
+   struct util_dynarray large_bos;
+};
+
+VK_DEFINE_HANDLE_CASTS(kk_cmd_buffer, vk.base, VkCommandBuffer,
+                       VK_OBJECT_TYPE_COMMAND_BUFFER)
+
+extern const struct vk_command_buffer_ops kk_cmd_buffer_ops;
+
+static inline struct kk_device *
+kk_cmd_buffer_device(struct kk_cmd_buffer *cmd)
+{
+   return (struct kk_device *)cmd->vk.base.device;
+}
+
+static inline struct kk_cmd_pool *
+kk_cmd_buffer_pool(struct kk_cmd_buffer *cmd)
+{
+   return (struct kk_cmd_pool *)cmd->vk.pool;
+}
+
+static inline struct kk_descriptor_state *
+kk_get_descriptors_state(struct kk_cmd_buffer *cmd,
+                         VkPipelineBindPoint bind_point)
+{
+   switch (bind_point) {
+   case VK_PIPELINE_BIND_POINT_GRAPHICS:
+      return &cmd->state.gfx.descriptors;
+   case VK_PIPELINE_BIND_POINT_COMPUTE:
+      return &cmd->state.cs.descriptors;
+   default:
+      UNREACHABLE("Unhandled bind point");
+   }
+};
+
+void kk_cmd_release_resources(struct kk_device *dev, struct kk_cmd_buffer *cmd);
+
+static void
+kk_cmd_buffer_dirty_all_gfx(struct kk_cmd_buffer *cmd)
+{
+   /* Ensure we flush all graphics state */
+   vk_dynamic_graphics_state_dirty_all(&cmd->vk.dynamic_graphics_state);
+   cmd->state.gfx.dirty = ~0u;
+}
+
+void kk_cmd_release_dynamic_ds_state(struct kk_cmd_buffer *cmd);
+
+mtl_depth_stencil_state *
+kk_compile_depth_stencil_state(struct kk_device *device,
+                               const struct vk_depth_stencil_state *ds,
+                               bool has_depth, bool has_stencil);
+
+void kk_meta_resolve_rendering(struct kk_cmd_buffer *cmd,
+                               const VkRenderingInfo *pRenderingInfo);
+
+void kk_cmd_buffer_write_descriptor_buffer(struct kk_cmd_buffer *cmd,
+                                           struct kk_descriptor_state *desc,
+                                           size_t size, size_t offset);
+
+/* Allocates temporary buffer that will be released once the command buffer has
+ * completed */
+struct kk_bo *kk_cmd_allocate_buffer(struct kk_cmd_buffer *cmd, size_t size_B,
+                                     size_t alignment_B);
+
+struct kk_pool {
+   mtl_buffer *handle;
+   uint64_t gpu;
+   void *cpu;
+};
+struct kk_pool kk_pool_upload(struct kk_cmd_buffer *cmd, void *data,
+                              size_t size_B, size_t alignment_B);
+
+uint64_t kk_upload_descriptor_root(struct kk_cmd_buffer *cmd,
+                                   VkPipelineBindPoint bind_point);
+
+void kk_cmd_buffer_flush_push_descriptors(struct kk_cmd_buffer *cmd,
+                                          struct kk_descriptor_state *desc);
+
+void kk_make_descriptor_resources_resident(struct kk_cmd_buffer *cmd,
+                                           VkPipelineBindPoint bind_point);
+
+void kk_cmd_write(struct kk_cmd_buffer *cmd, mtl_buffer *buffer, uint64_t addr,
+                  uint64_t value);
+
+void kk_cmd_dispatch_pipeline(struct kk_cmd_buffer *cmd,
+                              mtl_compute_encoder *encoder,
+                              mtl_compute_pipeline_state *pipeline,
+                              const void *push_data, size_t push_size,
+                              uint32_t groupCountX, uint32_t groupCountY,
+                              uint32_t groupCountZ);
+
+#endif
diff --git a/src/kosmickrisp/vulkan/kk_cmd_clear.c b/src/kosmickrisp/vulkan/kk_cmd_clear.c
new file mode 100644
index 00000000000..2f5e418d1ae
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_cmd_clear.c
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2024 Valve Corporation
+ * Copyright 2024 Alyssa Rosenzweig
+ * Copyright 2022-2023 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+#include "kk_cmd_buffer.h"
+
+#include "kk_device.h"
+#include "kk_entrypoints.h"
+#include "kk_image.h"
+#include "kk_image_view.h"
+#include "kk_physical_device.h"
+
+#include "vk_format.h"
+#include "vk_meta.h"
+
+static VkImageViewType
+render_view_type(VkImageType image_type, unsigned layer_count)
+{
+   switch (image_type) {
+   case VK_IMAGE_TYPE_1D:
+      return layer_count == 1 ? VK_IMAGE_VIEW_TYPE_1D
+                              : VK_IMAGE_VIEW_TYPE_1D_ARRAY;
+   case VK_IMAGE_TYPE_2D:
+      return layer_count == 1 ? VK_IMAGE_VIEW_TYPE_2D
+                              : VK_IMAGE_VIEW_TYPE_2D_ARRAY;
+   case VK_IMAGE_TYPE_3D:
+      return VK_IMAGE_VIEW_TYPE_3D;
+   default:
+      UNREACHABLE("Invalid image type");
+   }
+}
+
+static void
+clear_image(struct kk_cmd_buffer *cmd, struct kk_image *image,
+            VkImageLayout image_layout, VkFormat format,
+            const VkClearValue *clear_value, uint32_t range_count,
+            const VkImageSubresourceRange *ranges)
+{
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+   ASSERTED VkResult result;
+
+   for (uint32_t r = 0; r < range_count; r++) {
+      const uint32_t level_count =
+         vk_image_subresource_level_count(&image->vk, &ranges[r]);
+
+      for (uint32_t l = 0; l < level_count; l++) {
+         const uint32_t level = ranges[r].baseMipLevel + l;
+
+         const VkExtent3D level_extent =
+            vk_image_mip_level_extent(&image->vk, level);
+
+         uint32_t base_array_layer, layer_count;
+         if (image->vk.image_type == VK_IMAGE_TYPE_3D) {
+            base_array_layer = 0;
+            layer_count = level_extent.depth;
+         } else {
+            base_array_layer = ranges[r].baseArrayLayer;
+            layer_count =
+               vk_image_subresource_layer_count(&image->vk, &ranges[r]);
+         }
+
+         const VkImageViewUsageCreateInfo view_usage_info = {
+            .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
+            .usage = (ranges[r].aspectMask & VK_IMAGE_ASPECT_COLOR_BIT)
+                        ? VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
+                        : VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
+         };
+         const VkImageViewCreateInfo view_info = {
+            .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+            .flags = VK_IMAGE_VIEW_CREATE_DRIVER_INTERNAL_BIT_MESA,
+            .pNext = &view_usage_info,
+            .image = kk_image_to_handle(image),
+            .viewType = render_view_type(image->vk.image_type, layer_count),
+            .format = format,
+            .subresourceRange =
+               {
+                  .aspectMask = image->vk.aspects,
+                  .baseMipLevel = level,
+                  .levelCount = 1,
+                  .baseArrayLayer = base_array_layer,
+                  .layerCount = layer_count,
+               },
+         };
+
+         /* We use vk_meta_create_image_view here for lifetime managemnt */
+         VkImageView view;
+         result =
+            vk_meta_create_image_view(&cmd->vk, &dev->meta, &view_info, &view);
+         assert(result == VK_SUCCESS);
+
+         VkRenderingInfo render = {
+            .sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
+            .renderArea =
+               {
+                  .offset = {0, 0},
+                  .extent = {level_extent.width, level_extent.height},
+               },
+            .layerCount = layer_count,
+         };
+
+         VkRenderingAttachmentInfo vk_att = {
+            .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
+            .imageView = view,
+            .imageLayout = image_layout,
+            .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
+            .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
+            .clearValue = *clear_value,
+         };
+
+         if (ranges[r].aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
+            render.colorAttachmentCount = 1;
+            render.pColorAttachments = &vk_att;
+         }
+         if (ranges[r].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT)
+            render.pDepthAttachment = &vk_att;
+         if (ranges[r].aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT)
+            render.pStencilAttachment = &vk_att;
+
+         kk_CmdBeginRendering(kk_cmd_buffer_to_handle(cmd), &render);
+         kk_CmdEndRendering(kk_cmd_buffer_to_handle(cmd));
+      }
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage _image,
+                      VkImageLayout imageLayout,
+                      const VkClearColorValue *pColor, uint32_t rangeCount,
+                      const VkImageSubresourceRange *pRanges)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_image, image, _image);
+
+   VkClearValue clear_value = {
+      .color = *pColor,
+   };
+
+   VkFormat vk_format = image->vk.format;
+   if (vk_format == VK_FORMAT_R64_UINT || vk_format == VK_FORMAT_R64_SINT)
+      vk_format = VK_FORMAT_R32G32_UINT;
+
+   enum pipe_format p_format = vk_format_to_pipe_format(vk_format);
+   assert(p_format != PIPE_FORMAT_NONE);
+
+   clear_image(cmd, image, imageLayout, vk_format, &clear_value, rangeCount,
+               pRanges);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage _image,
+                             VkImageLayout imageLayout,
+                             const VkClearDepthStencilValue *pDepthStencil,
+                             uint32_t rangeCount,
+                             const VkImageSubresourceRange *pRanges)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_image, image, _image);
+
+   const VkClearValue clear_value = {
+      .depthStencil = *pDepthStencil,
+   };
+
+   clear_image(cmd, image, imageLayout, image->vk.format, &clear_value,
+               rangeCount, pRanges);
+}
diff --git a/src/kosmickrisp/vulkan/kk_cmd_copy.c b/src/kosmickrisp/vulkan/kk_cmd_copy.c
new file mode 100644
index 00000000000..32b1b5af359
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_cmd_copy.c
@@ -0,0 +1,355 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_cmd_buffer.h"
+
+#include "kk_bo.h"
+#include "kk_buffer.h"
+#include "kk_device.h"
+#include "kk_encoder.h"
+#include "kk_entrypoints.h"
+#include "kk_physical_device.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+#include "kosmickrisp/bridge/vk_to_mtl_map.h"
+
+#include "util/format/u_format.h"
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdCopyBuffer2(VkCommandBuffer commandBuffer,
+                  const VkCopyBufferInfo2 *pCopyBufferInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_buffer, src, pCopyBufferInfo->srcBuffer);
+   VK_FROM_HANDLE(kk_buffer, dst, pCopyBufferInfo->dstBuffer);
+
+   mtl_blit_encoder *blit = kk_blit_encoder(cmd);
+   for (uint32_t i = 0; i < pCopyBufferInfo->regionCount; i++) {
+      const VkBufferCopy2 *region = &pCopyBufferInfo->pRegions[i];
+      mtl_copy_from_buffer_to_buffer(blit, src->mtl_handle, region->srcOffset,
+                                     dst->mtl_handle, region->dstOffset,
+                                     region->size);
+   }
+}
+
+struct kk_buffer_image_copy_info {
+   struct mtl_buffer_image_copy mtl_data;
+   size_t buffer_slice_size_B;
+};
+
+static struct kk_buffer_image_copy_info
+vk_buffer_image_copy_to_mtl_buffer_image_copy(
+   const VkBufferImageCopy2 *region, const struct kk_image_plane *plane)
+{
+   struct kk_buffer_image_copy_info copy;
+   enum pipe_format p_format = plane->layout.format.pipe;
+   if (region->imageSubresource.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT) {
+      copy.mtl_data.options = MTL_BLIT_OPTION_DEPTH_FROM_DEPTH_STENCIL;
+      p_format = util_format_get_depth_only(p_format);
+   } else if (region->imageSubresource.aspectMask ==
+              VK_IMAGE_ASPECT_STENCIL_BIT) {
+      copy.mtl_data.options = MTL_BLIT_OPTION_STENCIL_FROM_DEPTH_STENCIL;
+      p_format = PIPE_FORMAT_S8_UINT;
+   } else
+      copy.mtl_data.options = MTL_BLIT_OPTION_NONE;
+
+   const uint32_t buffer_width = region->bufferRowLength
+                                    ? region->bufferRowLength
+                                    : region->imageExtent.width;
+   const uint32_t buffer_height = region->bufferImageHeight
+                                     ? region->bufferImageHeight
+                                     : region->imageExtent.height;
+
+   const uint32_t buffer_stride_B =
+      util_format_get_stride(p_format, buffer_width);
+   const uint32_t buffer_size_2d_B =
+      util_format_get_2d_size(p_format, buffer_stride_B, buffer_height);
+
+   /* Metal requires this value to be 0 for 2D images, otherwise the number of
+    * bytes between each 2D image of a 3D texture */
+   copy.mtl_data.buffer_2d_image_size_B =
+      plane->layout.depth_px == 1u ? 0u : buffer_size_2d_B;
+   copy.mtl_data.buffer_stride_B = buffer_stride_B;
+   copy.mtl_data.image_size = vk_extent_3d_to_mtl_size(&region->imageExtent);
+   copy.mtl_data.image_origin =
+      vk_offset_3d_to_mtl_origin(&region->imageOffset);
+   copy.mtl_data.image_level = region->imageSubresource.mipLevel;
+   copy.buffer_slice_size_B = buffer_size_2d_B;
+
+   return copy;
+}
+
+#define kk_foreach_slice(ndx, image, subresource_member)                       \
+   for (uint32_t ndx = region->subresource_member.baseArrayLayer;              \
+        ndx < (region->subresource_member.baseArrayLayer +                     \
+               vk_image_subresource_layer_count(&image->vk,                    \
+                                                &region->subresource_member)); \
+        ++ndx)
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
+                         const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_buffer, buffer, pCopyBufferToImageInfo->srcBuffer);
+   VK_FROM_HANDLE(kk_image, image, pCopyBufferToImageInfo->dstImage);
+
+   mtl_blit_encoder *blit = kk_blit_encoder(cmd);
+   for (int r = 0; r < pCopyBufferToImageInfo->regionCount; r++) {
+      const VkBufferImageCopy2 *region = &pCopyBufferToImageInfo->pRegions[r];
+      const uint8_t plane_index = kk_image_memory_aspects_to_plane(
+         image, region->imageSubresource.aspectMask);
+      struct kk_image_plane *plane = &image->planes[plane_index];
+      struct kk_buffer_image_copy_info info =
+         vk_buffer_image_copy_to_mtl_buffer_image_copy(region, plane);
+      info.mtl_data.buffer = buffer->mtl_handle;
+      info.mtl_data.image = plane->mtl_handle;
+      size_t buffer_offset = region->bufferOffset;
+
+      kk_foreach_slice(slice, image, imageSubresource)
+      {
+         info.mtl_data.image_slice = slice;
+         info.mtl_data.buffer_offset_B = buffer_offset;
+         mtl_copy_from_buffer_to_texture(blit, &info.mtl_data);
+         buffer_offset += info.buffer_slice_size_B;
+      }
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
+                         const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_image, image, pCopyImageToBufferInfo->srcImage);
+   VK_FROM_HANDLE(kk_buffer, buffer, pCopyImageToBufferInfo->dstBuffer);
+
+   mtl_blit_encoder *blit = kk_blit_encoder(cmd);
+   for (unsigned r = 0; r < pCopyImageToBufferInfo->regionCount; r++) {
+      const VkBufferImageCopy2 *region = &pCopyImageToBufferInfo->pRegions[r];
+      const uint8_t plane_index = kk_image_memory_aspects_to_plane(
+         image, region->imageSubresource.aspectMask);
+      struct kk_image_plane *plane = &image->planes[plane_index];
+      struct kk_buffer_image_copy_info info =
+         vk_buffer_image_copy_to_mtl_buffer_image_copy(region, plane);
+      info.mtl_data.buffer = buffer->mtl_handle;
+      info.mtl_data.image = plane->mtl_handle;
+      size_t buffer_offset = region->bufferOffset;
+
+      kk_foreach_slice(slice, image, imageSubresource)
+      {
+         info.mtl_data.image_slice = slice;
+         info.mtl_data.buffer_offset_B = buffer_offset;
+         mtl_copy_from_texture_to_buffer(blit, &info.mtl_data);
+         buffer_offset += info.buffer_slice_size_B;
+      }
+   }
+}
+
+struct copy_image_data {
+   struct kk_cmd_buffer *cmd;
+   struct kk_image *src;
+   struct kk_image *dst;
+   const VkImageCopy2 *regions;
+   uint32_t plane_index;
+   uint32_t region_count;
+};
+
+/* Copies images by doing a texture->buffer->texture transfer. This is required
+ * for compressed formats */
+static void
+copy_through_buffer(struct copy_image_data *data)
+{
+   struct kk_image *src = data->src;
+   struct kk_image *dst = data->dst;
+   struct kk_image_plane *src_plane = &src->planes[data->plane_index];
+   struct kk_image_plane *dst_plane = &dst->planes[data->plane_index];
+   enum pipe_format src_format = src_plane->layout.format.pipe;
+   enum pipe_format dst_format = dst_plane->layout.format.pipe;
+   bool is_src_compressed = util_format_is_compressed(src_format);
+   bool is_dst_compressed = util_format_is_compressed(dst_format);
+   /* We shouldn't do any depth/stencil through this path */
+   assert(!util_format_is_depth_or_stencil(src_format) ||
+          !util_format_is_depth_or_stencil(dst_format));
+   mtl_blit_encoder *blit = kk_blit_encoder(data->cmd);
+
+   size_t buffer_size = 0u;
+   for (unsigned r = 0; r < data->region_count; r++) {
+      const VkImageCopy2 *region = &data->regions[r];
+      const uint32_t buffer_stride_B =
+         util_format_get_stride(src_format, region->extent.width);
+      const uint32_t buffer_size_2d_B = util_format_get_2d_size(
+         src_format, buffer_stride_B, region->extent.height);
+      const uint32_t layer_count =
+         vk_image_subresource_layer_count(&src->vk, &region->srcSubresource);
+      buffer_size += buffer_size_2d_B * layer_count;
+   }
+   struct kk_bo *bo = kk_cmd_allocate_buffer(data->cmd, buffer_size, 8);
+
+   size_t buffer_offset = 0u;
+   for (unsigned r = 0; r < data->region_count; r++) {
+      const VkImageCopy2 *region = &data->regions[r];
+      uint32_t mip_level = region->srcSubresource.mipLevel;
+      const uint32_t mip_width =
+         u_minify(src_plane->layout.width_px, mip_level);
+      const uint32_t mip_height =
+         u_minify(src_plane->layout.height_px, mip_level);
+      const uint32_t stride_B = util_format_get_stride(src_format, mip_width);
+      const uint32_t size_2d_B =
+         util_format_get_2d_size(src_format, stride_B, mip_height);
+      const uint32_t buffer_stride_B =
+         util_format_get_stride(src_format, region->extent.width);
+      const uint32_t buffer_size_2d_B = util_format_get_2d_size(
+         src_format, buffer_stride_B, region->extent.height);
+
+      struct kk_buffer_image_copy_info info;
+
+      /* Metal requires this value to be 0 for 2D images, otherwise the number
+       * of bytes between each 2D image of a 3D texture */
+      info.mtl_data.buffer_2d_image_size_B =
+         src_plane->layout.depth_px == 1u ? 0u : size_2d_B;
+      info.mtl_data.buffer_stride_B = buffer_stride_B;
+      info.mtl_data.image_level = mip_level;
+      info.mtl_data.buffer = bo->map;
+      info.mtl_data.options = MTL_BLIT_OPTION_NONE;
+      info.buffer_slice_size_B = buffer_size_2d_B;
+      struct mtl_size src_size = vk_extent_3d_to_mtl_size(&region->extent);
+      struct mtl_size dst_size = vk_extent_3d_to_mtl_size(&region->extent);
+      /* Need to adjust size to block dimensions */
+      if (is_src_compressed) {
+         dst_size.x /= util_format_get_blockwidth(src_format);
+         dst_size.y /= util_format_get_blockheight(src_format);
+         dst_size.z /= util_format_get_blockdepth(src_format);
+      }
+      if (is_dst_compressed) {
+         dst_size.x *= util_format_get_blockwidth(dst_format);
+         dst_size.y *= util_format_get_blockheight(dst_format);
+         dst_size.z *= util_format_get_blockdepth(dst_format);
+      }
+      struct mtl_origin src_origin =
+         vk_offset_3d_to_mtl_origin(&region->srcOffset);
+      struct mtl_origin dst_origin =
+         vk_offset_3d_to_mtl_origin(&region->dstOffset);
+
+      /* Texture->Buffer->Texture */
+      // TODO_KOSMICKRISP We don't handle 3D to 2D array nor vice-versa in this
+      // path. Unsure if it's even needed, can compressed textures be 3D?
+      kk_foreach_slice(slice, src, srcSubresource)
+      {
+         info.mtl_data.image = src_plane->mtl_handle;
+         info.mtl_data.image_size = src_size;
+         info.mtl_data.image_origin = src_origin;
+         info.mtl_data.image_slice = slice;
+         info.mtl_data.buffer_offset_B = buffer_offset;
+         mtl_copy_from_texture_to_buffer(blit, &info.mtl_data);
+
+         info.mtl_data.image = dst_plane->mtl_handle;
+         info.mtl_data.image_size = dst_size;
+         info.mtl_data.image_origin = dst_origin;
+         mtl_copy_from_buffer_to_texture(blit, &info.mtl_data);
+
+         buffer_offset += info.buffer_slice_size_B;
+      }
+   }
+}
+
+/* Copies images through Metal's texture->texture copy mechanism */
+static void
+copy_image(struct copy_image_data *data)
+{
+   mtl_blit_encoder *blit = kk_blit_encoder(data->cmd);
+   for (unsigned r = 0; r < data->region_count; r++) {
+      const VkImageCopy2 *region = &data->regions[r];
+      uint8_t src_plane_index = kk_image_aspects_to_plane(
+         data->src, region->srcSubresource.aspectMask);
+      if (data->plane_index != src_plane_index)
+         continue;
+
+      uint8_t dst_plane_index = kk_image_aspects_to_plane(
+         data->dst, region->dstSubresource.aspectMask);
+      struct kk_image *src = data->src;
+      struct kk_image *dst = data->dst;
+      struct kk_image_plane *src_plane = &src->planes[src_plane_index];
+      struct kk_image_plane *dst_plane = &dst->planes[dst_plane_index];
+
+      /* From the Vulkan 1.3.217 spec:
+       *
+       *    "When copying between compressed and uncompressed formats the
+       *    extent members represent the texel dimensions of the source image
+       *    and not the destination."
+       */
+      const VkExtent3D extent_px =
+         vk_image_sanitize_extent(&src->vk, region->extent);
+
+      size_t src_slice = region->srcSubresource.baseArrayLayer;
+      size_t src_level = region->srcSubresource.mipLevel;
+      struct mtl_origin src_origin =
+         vk_offset_3d_to_mtl_origin(&region->srcOffset);
+      struct mtl_size size = {.x = extent_px.width,
+                              .y = extent_px.height,
+                              .z = extent_px.depth};
+      size_t dst_slice = region->dstSubresource.baseArrayLayer;
+      size_t dst_level = region->dstSubresource.mipLevel;
+      struct mtl_origin dst_origin =
+         vk_offset_3d_to_mtl_origin(&region->dstOffset);
+
+      /* When copying 3D to 2D layered or vice-versa, we need to change the 3D
+       * size to 2D and iterate on the layer count of the 2D image (which is the
+       * same as the depth of the 3D) and adjust origin and slice accordingly */
+      uint32_t layer_count =
+         vk_image_subresource_layer_count(&src->vk, &region->srcSubresource);
+      const uint32_t dst_layer_count =
+         vk_image_subresource_layer_count(&dst->vk, &region->dstSubresource);
+      size_t *src_increase = &src_slice;
+      size_t *dst_increase = &dst_slice;
+
+      if (layer_count < dst_layer_count) { /* 3D to 2D layered */
+         layer_count = dst_layer_count;
+         src_increase = &src_origin.z;
+         size.z = 1u;
+      } else if (dst_layer_count < layer_count) { /* 2D layered to 3D */
+         dst_increase = &dst_origin.z;
+         size.z = 1u;
+      }
+      for (uint32_t l = 0; l < layer_count;
+           ++l, ++(*src_increase), ++(*dst_increase)) {
+         mtl_copy_from_texture_to_texture(
+            blit, src_plane->mtl_handle, src_slice, src_level, src_origin, size,
+            dst_plane->mtl_handle, dst_slice, dst_level, dst_origin);
+      }
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdCopyImage2(VkCommandBuffer commandBuffer,
+                 const VkCopyImageInfo2 *pCopyImageInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_image, src, pCopyImageInfo->srcImage);
+   VK_FROM_HANDLE(kk_image, dst, pCopyImageInfo->dstImage);
+
+   for (uint32_t i = 0u; i < src->plane_count; ++i) {
+      struct kk_image_plane *src_plane = &src->planes[i];
+      struct kk_image_plane *dst_plane = &dst->planes[i];
+      enum pipe_format src_format = src_plane->layout.format.pipe;
+      enum pipe_format dst_format = dst_plane->layout.format.pipe;
+      struct copy_image_data data = {
+         .cmd = cmd,
+         .src = src,
+         .dst = dst,
+         .regions = pCopyImageInfo->pRegions,
+         .plane_index = i,
+         .region_count = pCopyImageInfo->regionCount,
+      };
+      bool is_src_compressed = util_format_is_compressed(src_format);
+      bool is_dst_compressed = util_format_is_compressed(dst_format);
+      if (src_format != dst_format && (is_src_compressed || is_dst_compressed))
+         copy_through_buffer(&data);
+      else
+         copy_image(&data);
+   }
+}
diff --git a/src/kosmickrisp/vulkan/kk_cmd_dispatch.c b/src/kosmickrisp/vulkan/kk_cmd_dispatch.c
new file mode 100644
index 00000000000..338766ef12d
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_cmd_dispatch.c
@@ -0,0 +1,152 @@
+/*
+ * Copyright © 2025 LunarG, Inc
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "vulkan/vulkan_core.h"
+
+#include "kk_buffer.h"
+#include "kk_cmd_buffer.h"
+#include "kk_descriptor_set_layout.h"
+#include "kk_device.h"
+#include "kk_encoder.h"
+#include "kk_entrypoints.h"
+#include "kk_shader.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+#include "vk_common_entrypoints.h"
+
+void
+kk_cmd_dispatch_pipeline(struct kk_cmd_buffer *cmd,
+                         mtl_compute_encoder *encoder,
+                         mtl_compute_pipeline_state *pipeline,
+                         const void *push_data, size_t push_size,
+                         uint32_t groupCountX, uint32_t groupCountY,
+                         uint32_t groupCountZ)
+{
+   struct kk_root_descriptor_table *root = NULL;
+   struct kk_bo *bo = kk_cmd_allocate_buffer(cmd, sizeof(*root), 8u);
+   /* kk_cmd_allocate_buffer already sets the error, we can just exit */
+   if (!bo)
+      return;
+
+   root = bo->cpu;
+   assert(push_size <= sizeof(root->push));
+   memcpy(root->push, push_data, push_size);
+   root->cs.base_group[0] = 1; /* TODO_KOSMICKRISP This is hard-coded because we
+                                  know this is the size we create them with */
+   root->cs.base_group[1] = 1;
+   root->cs.base_group[2] = 1;
+
+   mtl_compute_set_buffer(encoder, bo->map, 0, 0);
+   mtl_compute_set_pipeline_state(encoder, pipeline);
+
+   struct mtl_size grid_size = {
+      .x = groupCountX,
+      .y = groupCountY,
+      .z = groupCountZ,
+   };
+   struct mtl_size local_size = {
+      .x = 1,
+      .y = 1,
+      .z = 1,
+   };
+   mtl_dispatch_threads(encoder, grid_size, local_size);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
+               uint32_t groupCountY, uint32_t groupCountZ)
+{
+   kk_CmdDispatchBase(commandBuffer, 0, 0, 0, groupCountX, groupCountY,
+                      groupCountZ);
+}
+
+static void
+kk_flush_compute_state(struct kk_cmd_buffer *cmd)
+{
+   mtl_compute_encoder *enc = kk_compute_encoder(cmd);
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+
+   // Fill Metal argument buffer with descriptor set addresses
+   struct kk_descriptor_state *desc = &cmd->state.cs.descriptors;
+
+   if (desc->push_dirty)
+      kk_cmd_buffer_flush_push_descriptors(cmd, desc);
+   /* After push descriptors' buffers are created. Otherwise, the buffer where
+    * they live will not be created and cannot make it resident */
+   if (desc->sets_not_resident)
+      kk_make_descriptor_resources_resident(cmd,
+                                            VK_PIPELINE_BIND_POINT_COMPUTE);
+   if (desc->root_dirty)
+      kk_upload_descriptor_root(cmd, VK_PIPELINE_BIND_POINT_COMPUTE);
+
+   /* Make user allocated heaps resident */
+   simple_mtx_lock(&dev->user_heap_cache.mutex);
+   if (cmd->encoder->main.user_heap_hash != dev->user_heap_cache.hash) {
+      cmd->encoder->main.user_heap_hash = dev->user_heap_cache.hash;
+      mtl_heap **heaps = util_dynarray_begin(&dev->user_heap_cache.handles);
+      uint32_t count =
+         util_dynarray_num_elements(&dev->user_heap_cache.handles, mtl_heap *);
+      mtl_compute_use_heaps(enc, heaps, count);
+   }
+   simple_mtx_unlock(&dev->user_heap_cache.mutex);
+
+   struct kk_bo *root_buffer = desc->root.root_buffer;
+   if (root_buffer)
+      mtl_compute_set_buffer(enc, root_buffer->map, 0, 0);
+
+   mtl_compute_set_pipeline_state(enc, cmd->state.cs.pipeline_state);
+   cmd->state.cs.dirty = 0u;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
+                   uint32_t baseGroupY, uint32_t baseGroupZ,
+                   uint32_t groupCountX, uint32_t groupCountY,
+                   uint32_t groupCountZ)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+
+   struct kk_descriptor_state *desc = &cmd->state.cs.descriptors;
+   desc->root_dirty |= desc->root.cs.base_group[0] != baseGroupX;
+   desc->root_dirty |= desc->root.cs.base_group[1] != baseGroupY;
+   desc->root_dirty |= desc->root.cs.base_group[2] != baseGroupZ;
+   desc->root.cs.base_group[0] = baseGroupX;
+   desc->root.cs.base_group[1] = baseGroupY;
+   desc->root.cs.base_group[2] = baseGroupZ;
+
+   kk_flush_compute_state(cmd);
+
+   struct mtl_size grid_size = {
+      .x = groupCountX,
+      .y = groupCountY,
+      .z = groupCountZ,
+   };
+   mtl_compute_encoder *enc = kk_compute_encoder(cmd);
+   mtl_dispatch_threads(enc, grid_size, cmd->state.cs.local_size);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer _buffer,
+                       VkDeviceSize offset)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_buffer, buffer, _buffer);
+
+   struct kk_descriptor_state *desc = &cmd->state.cs.descriptors;
+   desc->root_dirty |= desc->root.cs.base_group[0] != 0;
+   desc->root_dirty |= desc->root.cs.base_group[1] != 0;
+   desc->root_dirty |= desc->root.cs.base_group[2] != 0;
+   desc->root.cs.base_group[0] = 0;
+   desc->root.cs.base_group[1] = 0;
+   desc->root.cs.base_group[2] = 0;
+
+   kk_flush_compute_state(cmd);
+
+   mtl_compute_encoder *enc = kk_compute_encoder(cmd);
+   mtl_dispatch_threadgroups_with_indirect_buffer(
+      enc, buffer->mtl_handle, offset, cmd->state.cs.local_size);
+}
diff --git a/src/kosmickrisp/vulkan/kk_cmd_draw.c b/src/kosmickrisp/vulkan/kk_cmd_draw.c
new file mode 100644
index 00000000000..84008e68af6
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_cmd_draw.c
@@ -0,0 +1,1010 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2024 Valve Corporation
+ * Copyright 2024 Alyssa Rosenzweig
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_entrypoints.h"
+
+#include "kk_buffer.h"
+#include "kk_cmd_buffer.h"
+#include "kk_encoder.h"
+#include "kk_format.h"
+#include "kk_image_view.h"
+#include "kk_query_pool.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+#include "kosmickrisp/bridge/vk_to_mtl_map.h"
+
+#include "vulkan/util/vk_format.h"
+
+static void
+kk_cmd_buffer_dirty_render_pass(struct kk_cmd_buffer *cmd)
+{
+   struct vk_dynamic_graphics_state *dyn = &cmd->vk.dynamic_graphics_state;
+
+   /* These depend on color attachment count */
+   BITSET_SET(dyn->dirty, MESA_VK_DYNAMIC_CB_COLOR_WRITE_ENABLES);
+   BITSET_SET(dyn->dirty, MESA_VK_DYNAMIC_CB_BLEND_ENABLES);
+   BITSET_SET(dyn->dirty, MESA_VK_DYNAMIC_CB_BLEND_EQUATIONS);
+   BITSET_SET(dyn->dirty, MESA_VK_DYNAMIC_CB_WRITE_MASKS);
+
+   /* These depend on the depth/stencil format */
+   BITSET_SET(dyn->dirty, MESA_VK_DYNAMIC_DS_DEPTH_TEST_ENABLE);
+   BITSET_SET(dyn->dirty, MESA_VK_DYNAMIC_DS_DEPTH_WRITE_ENABLE);
+   BITSET_SET(dyn->dirty, MESA_VK_DYNAMIC_DS_DEPTH_BOUNDS_TEST_ENABLE);
+   BITSET_SET(dyn->dirty, MESA_VK_DYNAMIC_DS_STENCIL_TEST_ENABLE);
+
+   /* This may depend on render targets for ESO */
+   BITSET_SET(dyn->dirty, MESA_VK_DYNAMIC_MS_RASTERIZATION_SAMPLES);
+
+   /* This may depend on render targets */
+   BITSET_SET(dyn->dirty, MESA_VK_DYNAMIC_COLOR_ATTACHMENT_MAP);
+}
+
+static void
+kk_attachment_init(struct kk_attachment *att,
+                   const VkRenderingAttachmentInfo *info)
+{
+   if (info == NULL || info->imageView == VK_NULL_HANDLE) {
+      *att = (struct kk_attachment){
+         .iview = NULL,
+      };
+      return;
+   }
+
+   VK_FROM_HANDLE(kk_image_view, iview, info->imageView);
+   *att = (struct kk_attachment){
+      .vk_format = iview->vk.format,
+      .iview = iview,
+   };
+
+   if (info->resolveMode != VK_RESOLVE_MODE_NONE) {
+      VK_FROM_HANDLE(kk_image_view, res_iview, info->resolveImageView);
+      att->resolve_mode = info->resolveMode;
+      att->resolve_iview = res_iview;
+   }
+
+   att->store_op = info->storeOp;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetRenderingAreaGranularityKHR(
+   VkDevice device, const VkRenderingAreaInfoKHR *pRenderingAreaInfo,
+   VkExtent2D *pGranularity)
+{
+   *pGranularity = (VkExtent2D){.width = 1, .height = 1};
+}
+
+static void
+kk_merge_render_iview(VkExtent2D *extent, struct kk_image_view *iview)
+{
+   if (iview) {
+      /* TODO: is this right for ycbcr? */
+      unsigned level = iview->vk.base_mip_level;
+      unsigned width = u_minify(iview->vk.image->extent.width, level);
+      unsigned height = u_minify(iview->vk.image->extent.height, level);
+
+      extent->width = MAX2(extent->width, width);
+      extent->height = MAX2(extent->height, height);
+   }
+}
+
+static void
+kk_fill_common_attachment_description(
+   mtl_render_pass_attachment_descriptor *descriptor,
+   const struct kk_image_view *iview, const VkRenderingAttachmentInfo *info,
+   bool force_attachment_load)
+{
+   assert(iview->plane_count ==
+          1); /* TODO_KOSMICKRISP Handle multiplanar images? */
+   mtl_render_pass_attachment_descriptor_set_texture(
+      descriptor, iview->planes[0].mtl_handle_render);
+   mtl_render_pass_attachment_descriptor_set_level(descriptor,
+                                                   iview->vk.base_mip_level);
+   mtl_render_pass_attachment_descriptor_set_slice(descriptor,
+                                                   iview->vk.base_array_layer);
+   enum mtl_load_action load_action =
+      force_attachment_load
+         ? MTL_LOAD_ACTION_LOAD
+         : vk_attachment_load_op_to_mtl_load_action(info->loadOp);
+   mtl_render_pass_attachment_descriptor_set_load_action(descriptor,
+                                                         load_action);
+   /* We need to force attachment store to correctly handle situations where the
+    * attachment is written to in a subpass, and later read from in the next one
+    * with the store operation being something else than store. The other reason
+    * being that we break renderpasses when a pipeline barrier is used, so we
+    * need to not loose the information of the attachment when we restart it. */
+   enum mtl_store_action store_action = MTL_STORE_ACTION_STORE;
+   mtl_render_pass_attachment_descriptor_set_store_action(descriptor,
+                                                          store_action);
+}
+
+static struct mtl_clear_color
+vk_clear_color_value_to_mtl_clear_color(union VkClearColorValue color,
+                                        enum pipe_format format)
+{
+   struct mtl_clear_color value;
+   if (util_format_is_pure_sint(format)) {
+      value.red = color.int32[0];
+      value.green = color.int32[1];
+      value.blue = color.int32[2];
+      value.alpha = color.int32[3];
+   } else if (util_format_is_pure_uint(format)) {
+      value.red = color.uint32[0];
+      value.green = color.uint32[1];
+      value.blue = color.uint32[2];
+      value.alpha = color.uint32[3];
+   } else {
+      value.red = color.float32[0];
+      value.green = color.float32[1];
+      value.blue = color.float32[2];
+      value.alpha = color.float32[3];
+   }
+
+   /* Apply swizzle to color since Metal does not allow swizzle for renderable
+    * textures, but we need to support that for formats like
+    * VK_FORMAT_B4G4R4A4_UNORM_PACK16 */
+   const struct kk_va_format *supported_format = kk_get_va_format(format);
+   struct mtl_clear_color swizzled_color;
+   for (uint32_t i = 0u; i < 4; ++i)
+      swizzled_color.channel[i] =
+         value.channel[supported_format->swizzle.channels[i]];
+
+   return swizzled_color;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdBeginRendering(VkCommandBuffer commandBuffer,
+                     const VkRenderingInfo *pRenderingInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+
+   struct kk_rendering_state *render = &cmd->state.gfx.render;
+
+   memset(render, 0, sizeof(*render));
+
+   render->flags = pRenderingInfo->flags;
+   render->area = pRenderingInfo->renderArea;
+   render->view_mask = pRenderingInfo->viewMask;
+   render->layer_count = pRenderingInfo->layerCount;
+   render->samples = 0;
+   render->color_att_count = pRenderingInfo->colorAttachmentCount;
+
+   const uint32_t layer_count = render->view_mask
+                                   ? util_last_bit(render->view_mask)
+                                   : render->layer_count;
+
+   VkExtent2D framebuffer_extent = {.width = 0u, .height = 0u};
+   bool does_any_attachment_clear = false;
+   for (uint32_t i = 0; i < render->color_att_count; i++) {
+      kk_attachment_init(&render->color_att[i],
+                         &pRenderingInfo->pColorAttachments[i]);
+      kk_merge_render_iview(&framebuffer_extent, render->color_att[i].iview);
+      does_any_attachment_clear |=
+         (pRenderingInfo->pColorAttachments[i].loadOp ==
+          VK_ATTACHMENT_LOAD_OP_CLEAR);
+   }
+   if (pRenderingInfo->pDepthAttachment)
+      does_any_attachment_clear |= (pRenderingInfo->pDepthAttachment->loadOp ==
+                                    VK_ATTACHMENT_LOAD_OP_CLEAR);
+   if (pRenderingInfo->pStencilAttachment)
+      does_any_attachment_clear |=
+         (pRenderingInfo->pStencilAttachment->loadOp ==
+          VK_ATTACHMENT_LOAD_OP_CLEAR);
+
+   kk_attachment_init(&render->depth_att, pRenderingInfo->pDepthAttachment);
+   kk_attachment_init(&render->stencil_att, pRenderingInfo->pStencilAttachment);
+   kk_merge_render_iview(&framebuffer_extent,
+                         render->depth_att.iview ?: render->stencil_att.iview);
+
+   const VkRenderingFragmentShadingRateAttachmentInfoKHR *fsr_att_info =
+      vk_find_struct_const(pRenderingInfo->pNext,
+                           RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR);
+   if (fsr_att_info != NULL && fsr_att_info->imageView != VK_NULL_HANDLE) {
+      VK_FROM_HANDLE(kk_image_view, iview, fsr_att_info->imageView);
+      render->fsr_att = (struct kk_attachment){
+         .vk_format = iview->vk.format,
+         .iview = iview,
+         .store_op = VK_ATTACHMENT_STORE_OP_NONE,
+      };
+   }
+
+   const VkRenderingAttachmentLocationInfoKHR ral_info = {
+      .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR,
+      .colorAttachmentCount = pRenderingInfo->colorAttachmentCount,
+   };
+   vk_cmd_set_rendering_attachment_locations(&cmd->vk, &ral_info);
+
+   kk_cmd_buffer_dirty_render_pass(cmd);
+   mtl_render_pass_descriptor *pass_descriptor =
+      mtl_new_render_pass_descriptor();
+
+   /* Framebufferless rendering, need to set pass_descriptors
+    * renderTargetWidth/Height to non-0 values and defaultRasterSampleCount */
+   if (framebuffer_extent.width == 0u && framebuffer_extent.height == 0u) {
+      framebuffer_extent.width = render->area.extent.width;
+      framebuffer_extent.height = render->area.extent.height;
+      mtl_render_pass_descriptor_set_render_target_width(
+         pass_descriptor, framebuffer_extent.width);
+      mtl_render_pass_descriptor_set_render_target_height(
+         pass_descriptor, framebuffer_extent.height);
+      mtl_render_pass_descriptor_set_default_raster_sample_count(
+         pass_descriptor, 1u);
+   }
+
+   /* Check if we are rendering to the whole framebuffer. Required to understand
+    * if we need to load to avoid clearing all attachment when loading.
+    */
+   bool is_whole_framebuffer =
+      framebuffer_extent.width == render->area.extent.width &&
+      framebuffer_extent.height == render->area.extent.height &&
+      render->area.offset.x == 0u && render->area.offset.y == 0u &&
+      (render->view_mask == 0u ||
+       render->view_mask == BITFIELD64_MASK(render->layer_count));
+
+   /* Understand if the render area is tile aligned so we know if we actually
+    * need to load the tile to not lose information. */
+   uint32_t tile_alignment = 31u;
+   bool is_tile_aligned = !(render->area.offset.x & tile_alignment) &&
+                          !(render->area.offset.y & tile_alignment) &&
+                          !(render->area.extent.width & tile_alignment) &&
+                          !(render->area.extent.height & tile_alignment);
+
+   /* Rendering to the whole framebuffer */
+   is_tile_aligned |= is_whole_framebuffer;
+
+   /* There are 3 cases where we need to force a load instead of using the user
+    * defined load operation:
+    * 1. Render area is not tile aligned
+    * 2. Load operation is clear but doesn't render to the whole attachment
+    * 3. Resuming renderpass
+    */
+   bool force_attachment_load =
+      !is_tile_aligned ||
+      (!is_whole_framebuffer && does_any_attachment_clear) ||
+      (render->flags & VK_RENDERING_RESUMING_BIT);
+
+   for (uint32_t i = 0; i < render->color_att_count; i++) {
+      const struct kk_image_view *iview = render->color_att[i].iview;
+      if (!iview)
+         continue;
+
+      assert(iview->plane_count ==
+             1); /* TODO_KOSMICKRISP Handle multiplanar images? */
+      const struct kk_image *image =
+         container_of(iview->vk.image, struct kk_image, vk);
+      render->samples = image->vk.samples;
+
+      mtl_render_pass_attachment_descriptor *attachment_descriptor =
+         mtl_render_pass_descriptor_get_color_attachment(pass_descriptor, i);
+      kk_fill_common_attachment_description(
+         attachment_descriptor, iview, &pRenderingInfo->pColorAttachments[i],
+         force_attachment_load);
+      struct mtl_clear_color clear_color =
+         vk_clear_color_value_to_mtl_clear_color(
+            pRenderingInfo->pColorAttachments[i].clearValue.color,
+            iview->planes[0].format);
+      mtl_render_pass_attachment_descriptor_set_clear_color(
+         attachment_descriptor, clear_color);
+   }
+
+   if (render->depth_att.iview) {
+      const struct kk_image_view *iview = render->depth_att.iview;
+      const struct kk_image *image =
+         container_of(iview->vk.image, struct kk_image, vk);
+      render->samples = image->vk.samples;
+
+      mtl_render_pass_attachment_descriptor *attachment_descriptor =
+         mtl_render_pass_descriptor_get_depth_attachment(pass_descriptor);
+      kk_fill_common_attachment_description(
+         attachment_descriptor, render->depth_att.iview,
+         pRenderingInfo->pDepthAttachment, force_attachment_load);
+      mtl_render_pass_attachment_descriptor_set_clear_depth(
+         attachment_descriptor,
+         pRenderingInfo->pDepthAttachment->clearValue.depthStencil.depth);
+   }
+   if (render->stencil_att.iview) {
+      const struct kk_image_view *iview = render->stencil_att.iview;
+      const struct kk_image *image =
+         container_of(iview->vk.image, struct kk_image, vk);
+      render->samples = image->vk.samples;
+
+      mtl_render_pass_attachment_descriptor *attachment_descriptor =
+         mtl_render_pass_descriptor_get_stencil_attachment(pass_descriptor);
+      kk_fill_common_attachment_description(
+         attachment_descriptor, render->stencil_att.iview,
+         pRenderingInfo->pStencilAttachment, force_attachment_load);
+      mtl_render_pass_attachment_descriptor_set_clear_stencil(
+         attachment_descriptor,
+         pRenderingInfo->pStencilAttachment->clearValue.depthStencil.stencil);
+   }
+
+   /* Render targets are always arrays */
+   mtl_render_pass_descriptor_set_render_target_array_length(
+      pass_descriptor, layer_count ? layer_count : 1u);
+
+   /* Set global visibility buffer */
+   mtl_render_pass_descriptor_set_visibility_buffer(
+      pass_descriptor, dev->occlusion_queries.bo->map);
+
+   // TODO_KOSMICKRISP Fragment shading rate support goes here if Metal supports
+   // it
+
+   /* Start new encoder and encode sync commands from previous barriers (aka
+    * fences) */
+   kk_encoder_start_render(cmd, pass_descriptor, render->view_mask);
+
+   /* Store descriptor in case we need to restart the pass at pipeline barrier,
+    * but force loads */
+   for (uint32_t i = 0; i < render->color_att_count; i++) {
+      const struct kk_image_view *iview = render->color_att[i].iview;
+      if (!iview)
+         continue;
+      mtl_render_pass_attachment_descriptor *attachment_descriptor =
+         mtl_render_pass_descriptor_get_color_attachment(pass_descriptor, i);
+      mtl_render_pass_attachment_descriptor_set_load_action(
+         attachment_descriptor, MTL_LOAD_ACTION_LOAD);
+   }
+   if (render->depth_att.iview) {
+      mtl_render_pass_attachment_descriptor *attachment_descriptor =
+         mtl_render_pass_descriptor_get_depth_attachment(pass_descriptor);
+      mtl_render_pass_attachment_descriptor_set_load_action(
+         attachment_descriptor, MTL_LOAD_ACTION_LOAD);
+   }
+   if (render->stencil_att.iview) {
+      mtl_render_pass_attachment_descriptor *attachment_descriptor =
+         mtl_render_pass_descriptor_get_stencil_attachment(pass_descriptor);
+      mtl_render_pass_attachment_descriptor_set_load_action(
+         attachment_descriptor, MTL_LOAD_ACTION_LOAD);
+   }
+   cmd->state.gfx.render_pass_descriptor = pass_descriptor;
+
+   kk_cmd_buffer_dirty_all_gfx(cmd);
+
+   if (render->flags & VK_RENDERING_RESUMING_BIT)
+      return;
+
+   /* Clear attachments if we forced a load and there's a clear */
+   if (!force_attachment_load || !does_any_attachment_clear)
+      return;
+
+   uint32_t clear_count = 0;
+   VkClearAttachment clear_att[KK_MAX_RTS + 1];
+   for (uint32_t i = 0; i < pRenderingInfo->colorAttachmentCount; i++) {
+      const VkRenderingAttachmentInfo *att_info =
+         &pRenderingInfo->pColorAttachments[i];
+      if (att_info->imageView == VK_NULL_HANDLE ||
+          att_info->loadOp != VK_ATTACHMENT_LOAD_OP_CLEAR)
+         continue;
+
+      clear_att[clear_count++] = (VkClearAttachment){
+         .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+         .colorAttachment = i,
+         .clearValue = att_info->clearValue,
+      };
+   }
+
+   clear_att[clear_count] = (VkClearAttachment){
+      .aspectMask = 0,
+   };
+   if (pRenderingInfo->pDepthAttachment != NULL &&
+       pRenderingInfo->pDepthAttachment->imageView != VK_NULL_HANDLE &&
+       pRenderingInfo->pDepthAttachment->loadOp ==
+          VK_ATTACHMENT_LOAD_OP_CLEAR) {
+      clear_att[clear_count].aspectMask |= VK_IMAGE_ASPECT_DEPTH_BIT;
+      clear_att[clear_count].clearValue.depthStencil.depth =
+         pRenderingInfo->pDepthAttachment->clearValue.depthStencil.depth;
+   }
+   if (pRenderingInfo->pStencilAttachment != NULL &&
+       pRenderingInfo->pStencilAttachment->imageView != VK_NULL_HANDLE &&
+       pRenderingInfo->pStencilAttachment->loadOp ==
+          VK_ATTACHMENT_LOAD_OP_CLEAR) {
+      clear_att[clear_count].aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
+      clear_att[clear_count].clearValue.depthStencil.stencil =
+         pRenderingInfo->pStencilAttachment->clearValue.depthStencil.stencil;
+   }
+   if (clear_att[clear_count].aspectMask != 0)
+      clear_count++;
+
+   if (clear_count > 0) {
+      const VkClearRect clear_rect = {
+         .rect = render->area,
+         .baseArrayLayer = 0,
+         .layerCount = render->view_mask ? 1 : render->layer_count,
+      };
+
+      kk_CmdClearAttachments(kk_cmd_buffer_to_handle(cmd), clear_count,
+                             clear_att, 1, &clear_rect);
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdEndRendering(VkCommandBuffer commandBuffer)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   struct kk_rendering_state *render = &cmd->state.gfx.render;
+   bool need_resolve = false;
+
+   /* Translate render state back to VK for meta */
+   VkRenderingAttachmentInfo vk_color_att[KK_MAX_RTS];
+   for (uint32_t i = 0; i < render->color_att_count; i++) {
+      if (render->color_att[i].resolve_mode != VK_RESOLVE_MODE_NONE)
+         need_resolve = true;
+
+      vk_color_att[i] = (VkRenderingAttachmentInfo){
+         .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
+         .imageView = kk_image_view_to_handle(render->color_att[i].iview),
+         .imageLayout = VK_IMAGE_LAYOUT_GENERAL,
+         .resolveMode = render->color_att[i].resolve_mode,
+         .resolveImageView =
+            kk_image_view_to_handle(render->color_att[i].resolve_iview),
+         .resolveImageLayout = VK_IMAGE_LAYOUT_GENERAL,
+      };
+   }
+
+   const VkRenderingAttachmentInfo vk_depth_att = {
+      .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
+      .imageView = kk_image_view_to_handle(render->depth_att.iview),
+      .imageLayout = VK_IMAGE_LAYOUT_GENERAL,
+      .resolveMode = render->depth_att.resolve_mode,
+      .resolveImageView =
+         kk_image_view_to_handle(render->depth_att.resolve_iview),
+      .resolveImageLayout = VK_IMAGE_LAYOUT_GENERAL,
+   };
+   if (render->depth_att.resolve_mode != VK_RESOLVE_MODE_NONE)
+      need_resolve = true;
+
+   const VkRenderingAttachmentInfo vk_stencil_att = {
+      .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
+      .imageView = kk_image_view_to_handle(render->stencil_att.iview),
+      .imageLayout = VK_IMAGE_LAYOUT_GENERAL,
+      .resolveMode = render->stencil_att.resolve_mode,
+      .resolveImageView =
+         kk_image_view_to_handle(render->stencil_att.resolve_iview),
+      .resolveImageLayout = VK_IMAGE_LAYOUT_GENERAL,
+   };
+   if (render->stencil_att.resolve_mode != VK_RESOLVE_MODE_NONE)
+      need_resolve = true;
+
+   const VkRenderingInfo vk_render = {
+      .sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
+      .renderArea = render->area,
+      .layerCount = render->layer_count,
+      .viewMask = render->view_mask,
+      .colorAttachmentCount = render->color_att_count,
+      .pColorAttachments = vk_color_att,
+      .pDepthAttachment = &vk_depth_att,
+      .pStencilAttachment = &vk_stencil_att,
+   };
+
+   /* Clean up previous encoder */
+   kk_encoder_signal_fence_and_end(cmd);
+   mtl_release(cmd->state.gfx.render_pass_descriptor);
+   cmd->state.gfx.render_pass_descriptor = NULL;
+
+   if (render->flags & VK_RENDERING_SUSPENDING_BIT)
+      need_resolve = false;
+
+   memset(render, 0, sizeof(*render));
+
+   if (need_resolve) {
+      kk_meta_resolve_rendering(cmd, &vk_render);
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer _buffer,
+                          VkDeviceSize offset, VkDeviceSize size,
+                          VkIndexType indexType)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_buffer, buffer, _buffer);
+
+   cmd->state.gfx.index.handle = buffer->mtl_handle;
+   cmd->state.gfx.index.size = size;
+   cmd->state.gfx.index.offset = offset;
+   cmd->state.gfx.index.bytes_per_index = vk_index_type_to_bytes(indexType);
+   cmd->state.gfx.index.restart = vk_index_to_restart(indexType);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                         uint32_t bindingCount, const VkBuffer *pBuffers,
+                         const VkDeviceSize *pOffsets,
+                         const VkDeviceSize *pSizes,
+                         const VkDeviceSize *pStrides)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+
+   if (pStrides) {
+      vk_cmd_set_vertex_binding_strides(&cmd->vk, firstBinding, bindingCount,
+                                        pStrides);
+   }
+
+   for (uint32_t i = 0; i < bindingCount; i++) {
+      VK_FROM_HANDLE(kk_buffer, buffer, pBuffers[i]);
+      uint32_t idx = firstBinding + i;
+      uint64_t size = pSizes ? pSizes[i] : VK_WHOLE_SIZE;
+      const struct kk_addr_range addr_range =
+         kk_buffer_addr_range(buffer, pOffsets[i], size);
+      cmd->state.gfx.vb.addr_range[idx] = addr_range;
+      cmd->state.gfx.vb.handles[idx] = buffer->mtl_handle;
+      cmd->state.gfx.dirty |= KK_DIRTY_VB;
+   }
+}
+
+static void
+kk_flush_vp_state(struct kk_cmd_buffer *cmd)
+{
+   const struct vk_dynamic_graphics_state *dyn =
+      &cmd->vk.dynamic_graphics_state;
+
+   /* We always need at least 1 viewport for the hardware. With rasterizer
+    * discard the app may not supply any, but we can just program garbage.
+    */
+   unsigned count = MAX2(dyn->vp.scissor_count, 1);
+
+   /* Need to clamp scissor rectangles to render area, otherwise Metal doesn't
+    * like it */
+   struct mtl_scissor_rect rects[KK_MAX_VIEWPORTS] = {0};
+   VkOffset2D origin = cmd->state.gfx.render.area.offset;
+   VkOffset2D end = {.x = origin.x + cmd->state.gfx.render.area.extent.width,
+                     .y = origin.y + cmd->state.gfx.render.area.extent.height};
+   for (uint32_t i = 0; i < dyn->vp.scissor_count; i++) {
+      const VkRect2D *rect = &dyn->vp.scissors[i];
+
+      size_t x0 = CLAMP(rect->offset.x, origin.x, end.x);
+      size_t x1 = CLAMP(rect->offset.x + rect->extent.width, origin.x, end.x);
+      size_t y0 = CLAMP(rect->offset.y, origin.y, end.y);
+      size_t y1 = CLAMP(rect->offset.y + rect->extent.height, origin.y, end.y);
+      size_t minx = MIN2(x0, x1);
+      size_t miny = MIN2(y0, y1);
+      size_t maxx = MAX2(x0, x1);
+      size_t maxy = MAX2(y0, y1);
+      rects[i].x = minx;
+      rects[i].y = miny;
+      rects[i].width = maxx - minx;
+      rects[i].height = maxy - miny;
+   }
+
+   mtl_set_scissor_rects(kk_render_encoder(cmd), rects, count);
+
+   count = MAX2(dyn->vp.viewport_count, 1);
+
+   struct mtl_viewport viewports[KK_MAX_VIEWPORTS] = {0};
+
+   /* NDC in Metal is pointing downwards. Vulkan is pointing upwards. Account
+    * for that here */
+   for (uint32_t i = 0; i < dyn->vp.viewport_count; i++) {
+      const VkViewport *vp = &dyn->vp.viewports[i];
+
+      viewports[i].originX = vp->x;
+      viewports[i].originY = vp->y + vp->height;
+      viewports[i].width = vp->width;
+      viewports[i].height = -vp->height;
+
+      viewports[i].znear = vp->minDepth;
+      viewports[i].zfar = vp->maxDepth;
+   }
+
+   mtl_set_viewports(kk_render_encoder(cmd), viewports, count);
+}
+
+static inline uint32_t
+kk_calculate_vbo_clamp(uint64_t vbuf, uint64_t sink, enum pipe_format format,
+                       uint32_t size_B, uint32_t stride_B, uint32_t offset_B,
+                       uint64_t *vbuf_out)
+{
+   unsigned elsize_B = util_format_get_blocksize(format);
+   unsigned subtracted_B = offset_B + elsize_B;
+
+   /* If at least one index is valid, determine the max. Otherwise, direct reads
+    * to zero.
+    */
+   if (size_B >= subtracted_B) {
+      *vbuf_out = vbuf + offset_B;
+
+      /* If stride is zero, do not clamp, everything is valid. */
+      if (stride_B)
+         return ((size_B - subtracted_B) / stride_B);
+      else
+         return UINT32_MAX;
+   } else {
+      *vbuf_out = sink;
+      return 0;
+   }
+}
+
+static void
+set_empty_scissor(mtl_render_encoder *enc)
+{
+   struct mtl_scissor_rect rect = {.x = 0u, .y = 0u, .width = 0u, .height = 0u};
+   mtl_set_scissor_rects(enc, &rect, 1);
+}
+
+/* TODO_KOSMICKRISP: Move to common */
+static inline enum mesa_prim
+vk_conv_topology(VkPrimitiveTopology topology)
+{
+   switch (topology) {
+   case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
+      return MESA_PRIM_POINTS;
+   case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
+      return MESA_PRIM_LINES;
+   case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
+      return MESA_PRIM_LINE_STRIP;
+   case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wswitch"
+   case VK_PRIMITIVE_TOPOLOGY_META_RECT_LIST_MESA:
+#pragma GCC diagnostic pop
+      return MESA_PRIM_TRIANGLES;
+   case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
+      return MESA_PRIM_TRIANGLE_STRIP;
+   case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
+      return MESA_PRIM_TRIANGLE_FAN;
+   case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
+      return MESA_PRIM_LINES_ADJACENCY;
+   case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
+      return MESA_PRIM_LINE_STRIP_ADJACENCY;
+   case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
+      return MESA_PRIM_TRIANGLES_ADJACENCY;
+   case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
+      return MESA_PRIM_TRIANGLE_STRIP_ADJACENCY;
+   case VK_PRIMITIVE_TOPOLOGY_PATCH_LIST:
+      return MESA_PRIM_PATCHES;
+   default:
+      UNREACHABLE("invalid");
+   }
+}
+
+static void
+kk_flush_draw_state(struct kk_cmd_buffer *cmd)
+{
+   struct kk_device *device = kk_cmd_buffer_device(cmd);
+   struct kk_graphics_state *gfx = &cmd->state.gfx;
+   struct vk_dynamic_graphics_state *dyn = &cmd->vk.dynamic_graphics_state;
+   struct kk_descriptor_state *desc = &cmd->state.gfx.descriptors;
+   mtl_render_encoder *enc = kk_render_encoder(cmd);
+
+   if (BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_VI_BINDING_STRIDES)) {
+      u_foreach_bit(ndx, dyn->vi->bindings_valid) {
+         desc->root.draw.buffer_strides[ndx] = dyn->vi_binding_strides[ndx];
+      }
+      desc->root_dirty = true;
+   }
+
+   if (BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_RS_RASTERIZER_DISCARD_ENABLE)) {
+      if (dyn->rs.rasterizer_discard_enable) {
+         set_empty_scissor(enc);
+      } else {
+         /* Enforce setting the correct scissors */
+         BITSET_SET(dyn->dirty, MESA_VK_DYNAMIC_VP_VIEWPORT_COUNT);
+      }
+   }
+
+   if (BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_RS_CULL_MODE)) {
+      gfx->is_cull_front_and_back =
+         dyn->rs.cull_mode == VK_CULL_MODE_FRONT_AND_BACK;
+      if (gfx->is_cull_front_and_back) {
+         set_empty_scissor(enc);
+      } else {
+         mtl_set_cull_mode(enc,
+                           vk_front_face_to_mtl_cull_mode(dyn->rs.cull_mode));
+         /* Enforce setting the correct scissors */
+         BITSET_SET(dyn->dirty, MESA_VK_DYNAMIC_VP_VIEWPORT_COUNT);
+      }
+   }
+
+   if (BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_IA_PRIMITIVE_TOPOLOGY)) {
+      gfx->primitive_type = vk_primitive_topology_to_mtl_primitive_type(
+         dyn->ia.primitive_topology);
+      gfx->prim = vk_conv_topology(dyn->ia.primitive_topology);
+   }
+
+   if (BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_IA_PRIMITIVE_RESTART_ENABLE)) {
+      gfx->restart_disabled = !dyn->ia.primitive_restart_enable;
+   }
+
+   /* We enable raster discard by setting scissor to size (0, 0) */
+   if (!(dyn->rs.rasterizer_discard_enable || gfx->is_cull_front_and_back) &&
+       (BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_VP_VIEWPORT_COUNT) ||
+        BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_VP_VIEWPORTS) ||
+        BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_VP_SCISSOR_COUNT) ||
+        BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_VP_SCISSORS)))
+      kk_flush_vp_state(cmd);
+
+   if (cmd->state.gfx.is_depth_stencil_dynamic &&
+       (cmd->state.gfx.render.depth_att.vk_format != VK_FORMAT_UNDEFINED ||
+        cmd->state.gfx.render.stencil_att.vk_format != VK_FORMAT_UNDEFINED) &&
+       (BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_DS_DEPTH_TEST_ENABLE) |
+        BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_DS_DEPTH_WRITE_ENABLE) |
+        BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_DS_DEPTH_COMPARE_OP) |
+        // BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_DS_DEPTH_BOUNDS_TEST_ENABLE)
+        // | BITSET_TEST(dyn->dirty,
+        // MESA_VK_DYNAMIC_DS_DEPTH_BOUNDS_TEST_BOUNDS) |
+        BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_DS_STENCIL_TEST_ENABLE) |
+        BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_DS_STENCIL_OP) |
+        BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_DS_STENCIL_COMPARE_MASK) |
+        BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_DS_STENCIL_WRITE_MASK))) {
+      kk_cmd_release_dynamic_ds_state(cmd);
+
+      bool has_depth = dyn->rp.attachments & MESA_VK_RP_ATTACHMENT_DEPTH_BIT;
+      bool has_stencil =
+         dyn->rp.attachments & MESA_VK_RP_ATTACHMENT_STENCIL_BIT;
+      gfx->depth_stencil_state = kk_compile_depth_stencil_state(
+         device, &dyn->ds, has_depth, has_stencil);
+      mtl_set_depth_stencil_state(enc, gfx->depth_stencil_state);
+   }
+
+   if (BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_RS_FRONT_FACE)) {
+      mtl_set_front_face_winding(
+         enc, vk_front_face_to_mtl_winding(
+                 cmd->vk.dynamic_graphics_state.rs.front_face));
+   }
+
+   if (BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_RS_DEPTH_BIAS_FACTORS)) {
+      mtl_set_depth_bias(enc, dyn->rs.depth_bias.constant_factor,
+                         dyn->rs.depth_bias.slope_factor,
+                         dyn->rs.depth_bias.clamp);
+   }
+
+   if (BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_RS_DEPTH_CLAMP_ENABLE)) {
+      enum mtl_depth_clip_mode mode = dyn->rs.depth_clamp_enable
+                                         ? MTL_DEPTH_CLIP_MODE_CLAMP
+                                         : MTL_DEPTH_CLIP_MODE_CLIP;
+      mtl_set_depth_clip_mode(enc, mode);
+   }
+
+   if (BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_DS_STENCIL_REFERENCE))
+      mtl_set_stencil_references(
+         enc, cmd->vk.dynamic_graphics_state.ds.stencil.front.reference,
+         cmd->vk.dynamic_graphics_state.ds.stencil.back.reference);
+
+   if (BITSET_TEST(dyn->dirty, MESA_VK_DYNAMIC_CB_BLEND_CONSTANTS)) {
+      static_assert(sizeof(desc->root.draw.blend_constant) ==
+                       sizeof(dyn->cb.blend_constants),
+                    "common size");
+
+      memcpy(desc->root.draw.blend_constant, dyn->cb.blend_constants,
+             sizeof(dyn->cb.blend_constants));
+      desc->root_dirty = true;
+   }
+
+   if (gfx->dirty & KK_DIRTY_VB) {
+      unsigned slot = 0;
+      cmd->state.gfx.vb.max_vertices = 0u;
+      u_foreach_bit(i, cmd->state.gfx.vb.attribs_read) {
+         if (dyn->vi->attributes_valid & BITFIELD_BIT(i)) {
+            struct vk_vertex_attribute_state attr = dyn->vi->attributes[i];
+            struct kk_addr_range vb = gfx->vb.addr_range[attr.binding];
+
+            mtl_render_use_resource(enc, gfx->vb.handles[attr.binding],
+                                    MTL_RESOURCE_USAGE_READ);
+            desc->root.draw.attrib_clamps[slot] = kk_calculate_vbo_clamp(
+               vb.addr, 0, vk_format_to_pipe_format(attr.format), vb.range,
+               dyn->vi_binding_strides[attr.binding], attr.offset,
+               &desc->root.draw.attrib_base[slot]);
+            desc->root.draw.buffer_strides[attr.binding] =
+               dyn->vi_binding_strides[attr.binding];
+
+            cmd->state.gfx.vb.max_vertices =
+               MAX2(vb.range / dyn->vi_binding_strides[attr.binding],
+                    cmd->state.gfx.vb.max_vertices);
+         }
+         slot++;
+      }
+      desc->root_dirty = true;
+   }
+
+   if (gfx->dirty & KK_DIRTY_PIPELINE) {
+      mtl_render_set_pipeline_state(enc, gfx->pipeline_state);
+      if (gfx->depth_stencil_state)
+         mtl_set_depth_stencil_state(enc, gfx->depth_stencil_state);
+   }
+
+   if (desc->push_dirty)
+      kk_cmd_buffer_flush_push_descriptors(cmd, desc);
+   /* After push descriptors' buffers are created. Otherwise, the buffer where
+    * they live will not be created and cannot make it resident */
+   if (desc->sets_not_resident)
+      kk_make_descriptor_resources_resident(cmd,
+                                            VK_PIPELINE_BIND_POINT_GRAPHICS);
+   if (desc->root_dirty)
+      kk_upload_descriptor_root(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS);
+
+   /* Make user allocated heaps resident */
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+   simple_mtx_lock(&dev->user_heap_cache.mutex);
+   if (cmd->encoder->main.user_heap_hash != dev->user_heap_cache.hash) {
+      cmd->encoder->main.user_heap_hash = dev->user_heap_cache.hash;
+      mtl_heap **heaps = util_dynarray_begin(&dev->user_heap_cache.handles);
+      uint32_t count =
+         util_dynarray_num_elements(&dev->user_heap_cache.handles, mtl_heap *);
+      mtl_render_use_heaps(enc, heaps, count);
+   }
+   simple_mtx_unlock(&dev->user_heap_cache.mutex);
+
+   struct kk_bo *root_buffer = desc->root.root_buffer;
+   if (root_buffer) {
+      mtl_set_vertex_buffer(enc, root_buffer->map, 0, 0);
+      mtl_set_fragment_buffer(enc, root_buffer->map, 0, 0);
+   }
+
+   if (gfx->dirty & KK_DIRTY_OCCLUSION) {
+      mtl_set_visibility_result_mode(enc, gfx->occlusion.mode,
+                                     gfx->occlusion.index * sizeof(uint64_t));
+   }
+
+   gfx->dirty = 0u;
+   vk_dynamic_graphics_state_clear_dirty(dyn);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
+           uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+
+   kk_flush_draw_state(cmd);
+
+   /* Metal does not support triangle fans */
+   bool requires_unroll = cmd->state.gfx.prim == MESA_PRIM_TRIANGLE_FAN;
+   if (requires_unroll) {
+      VkDrawIndirectCommand draw = {
+         .vertexCount = vertexCount,
+         .instanceCount = instanceCount,
+         .firstVertex = firstVertex,
+         .firstInstance = firstInstance,
+      };
+      struct kk_pool pool = kk_pool_upload(cmd, &draw, sizeof(draw), 4u);
+      kk_encoder_render_triangle_fan_indirect(cmd, pool.handle, 0u);
+   } else {
+      mtl_render_encoder *enc = kk_render_encoder(cmd);
+      mtl_draw_primitives(enc, cmd->state.gfx.primitive_type, firstVertex,
+                          vertexCount, instanceCount, firstInstance);
+   }
+}
+
+static bool
+requires_increasing_index_el_size(struct kk_cmd_buffer *cmd)
+{
+   enum mesa_prim prim = cmd->state.gfx.prim;
+   switch (prim) {
+   case MESA_PRIM_LINE_STRIP:
+   case MESA_PRIM_TRIANGLE_STRIP:
+   case MESA_PRIM_TRIANGLE_FAN:
+      return (cmd->state.gfx.restart_disabled &&
+              cmd->state.gfx.index.bytes_per_index < sizeof(uint32_t));
+   default:
+      return false;
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
+                  uint32_t instanceCount, uint32_t firstIndex,
+                  int32_t vertexOffset, uint32_t firstInstance)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+
+   kk_flush_draw_state(cmd);
+
+   /* Metal does not support triangle fans */
+   bool requires_triangle_fan_unroll =
+      cmd->state.gfx.prim == MESA_PRIM_TRIANGLE_FAN;
+
+   /* Metal does not support disabling primitive restart. We need to create a
+    * new index buffer for primitives that allow restart (line strip, triangle
+    * strip and triangle fan). Never ever support
+    * VK_EXT_primitive_topology_list_restart since it'll just add overhead */
+   bool increase_index_el_size = requires_increasing_index_el_size(cmd);
+   if (requires_triangle_fan_unroll || increase_index_el_size) {
+      VkDrawIndexedIndirectCommand draw = {
+         .indexCount = indexCount,
+         .instanceCount = instanceCount,
+         .firstIndex = firstIndex,
+         .vertexOffset = vertexOffset,
+         .firstInstance = firstInstance,
+      };
+      struct kk_pool pool = kk_pool_upload(cmd, &draw, sizeof(draw), 4u);
+      kk_encoder_render_triangle_fan_indexed_indirect(cmd, pool.handle, 0u,
+                                                      increase_index_el_size);
+   } else {
+      uint32_t bytes_per_index = cmd->state.gfx.index.bytes_per_index;
+      enum mtl_index_type index_type =
+         index_size_in_bytes_to_mtl_index_type(bytes_per_index);
+      uint32_t index_buffer_offset_B =
+         firstIndex * bytes_per_index + cmd->state.gfx.index.offset;
+
+      mtl_render_encoder *enc = kk_render_encoder(cmd);
+      mtl_draw_indexed_primitives(
+         enc, cmd->state.gfx.primitive_type, indexCount, index_type,
+         cmd->state.gfx.index.handle, index_buffer_offset_B, instanceCount,
+         vertexOffset, firstInstance);
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer _buffer,
+                   VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_buffer, buffer, _buffer);
+
+   kk_flush_draw_state(cmd);
+   mtl_render_encoder *enc = kk_render_encoder(cmd);
+
+   /* Metal does not support triangle fans */
+   bool requires_unroll = cmd->state.gfx.prim == MESA_PRIM_TRIANGLE_FAN;
+   for (uint32_t i = 0u; i < drawCount; ++i, offset += stride) {
+      if (requires_unroll) {
+         kk_encoder_render_triangle_fan_indirect(cmd, buffer->mtl_handle,
+                                                 offset);
+      } else {
+         mtl_draw_primitives_indirect(enc, cmd->state.gfx.primitive_type,
+                                      buffer->mtl_handle, offset);
+      }
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer _buffer,
+                        VkDeviceSize offset, VkBuffer countBuffer,
+                        VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                        uint32_t stride)
+{
+   /* TODO_KOSMICKRISP */
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer _buffer,
+                          VkDeviceSize offset, uint32_t drawCount,
+                          uint32_t stride)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_buffer, buffer, _buffer);
+
+   kk_flush_draw_state(cmd);
+
+   /* Metal does not support triangle fans */
+   bool requires_triangle_fan_unroll =
+      cmd->state.gfx.prim == MESA_PRIM_TRIANGLE_FAN;
+
+   /* Metal does not support disabling primitive restart. We need to create a
+    * new index buffer for primitives that allow restart (line strip, triangle
+    * strip and triangle fan). Never ever support
+    * VK_EXT_primitive_topology_list_restart since it'll just add overhead */
+   bool increase_index_el_size = requires_increasing_index_el_size(cmd);
+   for (uint32_t i = 0u; i < drawCount; ++i, offset += stride) {
+      if (requires_triangle_fan_unroll || increase_index_el_size) {
+         kk_encoder_render_triangle_fan_indexed_indirect(
+            cmd, buffer->mtl_handle, offset, increase_index_el_size);
+      } else {
+         uint32_t bytes_per_index = cmd->state.gfx.index.bytes_per_index;
+         enum mtl_index_type index_type =
+            index_size_in_bytes_to_mtl_index_type(bytes_per_index);
+         uint32_t index_buffer_offset = cmd->state.gfx.index.offset;
+
+         mtl_render_encoder *enc = kk_render_encoder(cmd);
+         mtl_draw_indexed_primitives_indirect(
+            enc, cmd->state.gfx.primitive_type, index_type,
+            cmd->state.gfx.index.handle, index_buffer_offset,
+            buffer->mtl_handle, offset);
+      }
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer _buffer,
+                               VkDeviceSize offset, VkBuffer countBuffer,
+                               VkDeviceSize countBufferOffset,
+                               uint32_t maxDrawCount, uint32_t stride)
+{
+   /* TODO_KOSMICKRISP */
+}
diff --git a/src/kosmickrisp/vulkan/kk_cmd_meta.c b/src/kosmickrisp/vulkan/kk_cmd_meta.c
new file mode 100644
index 00000000000..debf9cd467c
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_cmd_meta.c
@@ -0,0 +1,318 @@
+/*
+ * Copyright 2024 Valve Corporation
+ * Copyright 2024 Alyssa Rosenzweig
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_private.h"
+
+#include "kk_buffer.h"
+#include "kk_cmd_buffer.h"
+#include "kk_encoder.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+#include "kk_entrypoints.h"
+
+static VkResult
+kk_cmd_bind_map_buffer(struct vk_command_buffer *vk_cmd,
+                       struct vk_meta_device *meta, VkBuffer _buffer,
+                       void **map_out)
+{
+   struct kk_cmd_buffer *cmd = container_of(vk_cmd, struct kk_cmd_buffer, vk);
+   VK_FROM_HANDLE(kk_buffer, buffer, _buffer);
+
+   assert(buffer->vk.size < UINT_MAX);
+   struct kk_bo *bo = kk_cmd_allocate_buffer(cmd, buffer->vk.size, 16u);
+   if (unlikely(bo == NULL))
+      return VK_ERROR_OUT_OF_POOL_MEMORY;
+
+   /* Need to retain since VkBuffers release the mtl_handle too */
+   mtl_retain(bo->map);
+   buffer->mtl_handle = bo->map;
+   buffer->vk.device_address = bo->gpu;
+   *map_out = bo->cpu;
+   mtl_compute_use_resource(cmd->encoder->main.encoder, buffer->mtl_handle,
+                            MTL_RESOURCE_USAGE_WRITE | MTL_RESOURCE_USAGE_READ);
+   return VK_SUCCESS;
+}
+
+VkResult
+kk_device_init_meta(struct kk_device *dev)
+{
+   VkResult result = vk_meta_device_init(&dev->vk, &dev->meta);
+   if (result != VK_SUCCESS)
+      return result;
+
+   dev->meta.use_gs_for_layer = false;
+   dev->meta.use_stencil_export = true;
+   dev->meta.use_rect_list_pipeline = true;
+   dev->meta.cmd_bind_map_buffer = kk_cmd_bind_map_buffer;
+   dev->meta.max_bind_map_buffer_size_B = 64 * 1024;
+
+   for (unsigned i = 0; i < VK_META_BUFFER_CHUNK_SIZE_COUNT; ++i) {
+      dev->meta.buffer_access.optimal_wg_size[i] = 64;
+   }
+
+   return VK_SUCCESS;
+}
+
+void
+kk_device_finish_meta(struct kk_device *dev)
+{
+   vk_meta_device_finish(&dev->vk, &dev->meta);
+}
+
+struct kk_meta_save {
+   struct vk_vertex_input_state _dynamic_vi;
+   struct vk_sample_locations_state _dynamic_sl;
+   struct vk_dynamic_graphics_state dynamic;
+   struct {
+      union {
+         struct {
+            mtl_render_pipeline_state *ps;
+            mtl_depth_stencil_state *ds;
+            uint32_t attribs_read;
+            enum mtl_primitive_type primitive_type;
+            enum mtl_visibility_result_mode occlusion;
+            bool is_ds_dynamic;
+         } gfx;
+         struct {
+            mtl_compute_pipeline_state *pipeline_state;
+            struct mtl_size local_size;
+         } cs;
+      };
+   } pipeline;
+   struct kk_descriptor_set *desc0;
+   struct kk_push_descriptor_set *push_desc0;
+   mtl_buffer *vb0_handle;
+   struct kk_addr_range vb0;
+   struct kk_buffer_address desc0_set_addr;
+   bool has_push_desc0;
+   uint8_t push[KK_MAX_PUSH_SIZE];
+};
+
+static void
+kk_meta_begin(struct kk_cmd_buffer *cmd, struct kk_meta_save *save,
+              VkPipelineBindPoint bind_point)
+{
+   struct kk_descriptor_state *desc = kk_get_descriptors_state(cmd, bind_point);
+
+   if (bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS) {
+      save->dynamic = cmd->vk.dynamic_graphics_state;
+      save->_dynamic_vi = cmd->state.gfx._dynamic_vi;
+      save->_dynamic_sl = cmd->state.gfx._dynamic_sl;
+      save->pipeline.gfx.ps = cmd->state.gfx.pipeline_state;
+      save->pipeline.gfx.ds = cmd->state.gfx.depth_stencil_state;
+      save->pipeline.gfx.attribs_read = cmd->state.gfx.vb.attribs_read;
+      save->pipeline.gfx.primitive_type = cmd->state.gfx.primitive_type;
+      save->pipeline.gfx.occlusion = cmd->state.gfx.occlusion.mode;
+      save->pipeline.gfx.is_ds_dynamic =
+         cmd->state.gfx.is_depth_stencil_dynamic;
+
+      cmd->state.gfx.is_depth_stencil_dynamic = false;
+      cmd->state.gfx.depth_stencil_state = NULL;
+      cmd->state.gfx.occlusion.mode = MTL_VISIBILITY_RESULT_MODE_DISABLED;
+      cmd->state.gfx.dirty |= KK_DIRTY_OCCLUSION;
+      desc->root_dirty = true;
+   } else {
+      save->pipeline.cs.pipeline_state = cmd->state.cs.pipeline_state;
+      save->pipeline.cs.local_size = cmd->state.cs.local_size;
+   }
+
+   save->vb0_handle = cmd->state.gfx.vb.handles[0];
+   save->vb0 = cmd->state.gfx.vb.addr_range[0];
+
+   save->desc0 = desc->sets[0];
+   save->has_push_desc0 = desc->push[0];
+   if (save->has_push_desc0)
+      save->push_desc0 = desc->push[0];
+
+   static_assert(sizeof(save->push) == sizeof(desc->root.push),
+                 "Size mismatch for push in meta_save");
+   memcpy(save->push, desc->root.push, sizeof(save->push));
+}
+
+static void
+kk_meta_end(struct kk_cmd_buffer *cmd, struct kk_meta_save *save,
+            VkPipelineBindPoint bind_point)
+{
+   struct kk_descriptor_state *desc = kk_get_descriptors_state(cmd, bind_point);
+   desc->root_dirty = true;
+
+   if (save->desc0) {
+      desc->sets[0] = save->desc0;
+      desc->root.sets[0] = save->desc0->addr;
+      desc->set_sizes[0] = save->desc0->size;
+      desc->sets_not_resident |= BITFIELD_BIT(0);
+      desc->push_dirty &= ~BITFIELD_BIT(0);
+   } else if (save->has_push_desc0) {
+      desc->push[0] = save->push_desc0;
+      desc->sets_not_resident |= BITFIELD_BIT(0);
+      desc->push_dirty |= BITFIELD_BIT(0);
+   }
+
+   if (bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS) {
+      /* Restore the dynamic state */
+      assert(save->dynamic.vi == &cmd->state.gfx._dynamic_vi);
+      assert(save->dynamic.ms.sample_locations == &cmd->state.gfx._dynamic_sl);
+      cmd->vk.dynamic_graphics_state = save->dynamic;
+      cmd->state.gfx._dynamic_vi = save->_dynamic_vi;
+      cmd->state.gfx._dynamic_sl = save->_dynamic_sl;
+      memcpy(cmd->vk.dynamic_graphics_state.dirty,
+             cmd->vk.dynamic_graphics_state.set,
+             sizeof(cmd->vk.dynamic_graphics_state.set));
+
+      if (cmd->state.gfx.is_depth_stencil_dynamic)
+         mtl_release(cmd->state.gfx.depth_stencil_state);
+      cmd->state.gfx.pipeline_state = save->pipeline.gfx.ps;
+      cmd->state.gfx.depth_stencil_state = save->pipeline.gfx.ds;
+      cmd->state.gfx.primitive_type = save->pipeline.gfx.primitive_type;
+      cmd->state.gfx.vb.attribs_read = save->pipeline.gfx.attribs_read;
+      cmd->state.gfx.is_depth_stencil_dynamic =
+         save->pipeline.gfx.is_ds_dynamic;
+      cmd->state.gfx.dirty |= KK_DIRTY_PIPELINE;
+
+      cmd->state.gfx.vb.addr_range[0] = save->vb0;
+      cmd->state.gfx.vb.handles[0] = save->vb0_handle;
+      cmd->state.gfx.dirty |= KK_DIRTY_VB;
+
+      cmd->state.gfx.occlusion.mode = save->pipeline.gfx.occlusion;
+      cmd->state.gfx.dirty |= KK_DIRTY_OCCLUSION;
+
+      desc->root_dirty = true;
+   } else {
+      cmd->state.cs.local_size = save->pipeline.cs.local_size;
+      cmd->state.cs.pipeline_state = save->pipeline.cs.pipeline_state;
+   }
+
+   memcpy(desc->root.push, save->push, sizeof(save->push));
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+                 VkDeviceSize dstOffset, VkDeviceSize dstRange, uint32_t data)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_buffer, buf, dstBuffer);
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+
+   struct kk_meta_save save;
+   kk_meta_begin(cmd, &save, VK_PIPELINE_BIND_POINT_COMPUTE);
+   mtl_compute_use_resource(kk_compute_encoder(cmd), buf->mtl_handle,
+                            MTL_RESOURCE_USAGE_WRITE);
+   vk_meta_fill_buffer(&cmd->vk, &dev->meta, dstBuffer, dstOffset, dstRange,
+                       data);
+   kk_meta_end(cmd, &save, VK_PIPELINE_BIND_POINT_COMPUTE);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+                   VkDeviceSize dstOffset, VkDeviceSize dstRange,
+                   const void *pData)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_buffer, buf, dstBuffer);
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+
+   struct kk_meta_save save;
+   kk_meta_begin(cmd, &save, VK_PIPELINE_BIND_POINT_COMPUTE);
+   mtl_compute_use_resource(kk_compute_encoder(cmd), buf->mtl_handle,
+                            MTL_RESOURCE_USAGE_WRITE);
+   vk_meta_update_buffer(&cmd->vk, &dev->meta, dstBuffer, dstOffset, dstRange,
+                         pData);
+   kk_meta_end(cmd, &save, VK_PIPELINE_BIND_POINT_COMPUTE);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdBlitImage2(VkCommandBuffer commandBuffer,
+                 const VkBlitImageInfo2 *pBlitImageInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+
+   struct kk_meta_save save;
+   kk_meta_begin(cmd, &save, VK_PIPELINE_BIND_POINT_GRAPHICS);
+   vk_meta_blit_image2(&cmd->vk, &dev->meta, pBlitImageInfo);
+   kk_meta_end(cmd, &save, VK_PIPELINE_BIND_POINT_GRAPHICS);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdResolveImage2(VkCommandBuffer commandBuffer,
+                    const VkResolveImageInfo2 *pResolveImageInfo)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+
+   struct kk_meta_save save;
+   kk_meta_begin(cmd, &save, VK_PIPELINE_BIND_POINT_GRAPHICS);
+   vk_meta_resolve_image2(&cmd->vk, &dev->meta, pResolveImageInfo);
+   kk_meta_end(cmd, &save, VK_PIPELINE_BIND_POINT_GRAPHICS);
+}
+
+static void
+kk_meta_init_render(struct kk_cmd_buffer *cmd,
+                    struct vk_meta_rendering_info *info)
+{
+   const struct kk_rendering_state *render = &cmd->state.gfx.render;
+
+   *info = (struct vk_meta_rendering_info){
+      .samples = MAX2(render->samples, 1),
+      .view_mask = render->view_mask,
+      .color_attachment_count = render->color_att_count,
+      .depth_attachment_format = render->depth_att.vk_format,
+      .stencil_attachment_format = render->stencil_att.vk_format,
+   };
+   for (uint32_t a = 0; a < render->color_att_count; a++) {
+      info->color_attachment_formats[a] = render->color_att[a].vk_format;
+      info->color_attachment_write_masks[a] =
+         VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
+         VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+                       const VkClearAttachment *pAttachments,
+                       uint32_t rectCount, const VkClearRect *pRects)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+
+   struct vk_meta_rendering_info render_info;
+   kk_meta_init_render(cmd, &render_info);
+
+   uint32_t view_mask = cmd->state.gfx.render.view_mask;
+   struct kk_encoder *encoder = cmd->encoder;
+   uint32_t layer_ids[KK_MAX_MULTIVIEW_VIEW_COUNT] = {};
+   mtl_set_vertex_amplification_count(encoder->main.encoder, layer_ids, 1u);
+
+   struct kk_meta_save save;
+   kk_meta_begin(cmd, &save, VK_PIPELINE_BIND_POINT_GRAPHICS);
+   vk_meta_clear_attachments(&cmd->vk, &dev->meta, &render_info,
+                             attachmentCount, pAttachments, rectCount, pRects);
+   kk_meta_end(cmd, &save, VK_PIPELINE_BIND_POINT_GRAPHICS);
+
+   uint32_t count = 0u;
+   u_foreach_bit(id, view_mask)
+      layer_ids[count++] = id;
+   if (view_mask == 0u) {
+      layer_ids[count++] = 0;
+   }
+   mtl_set_vertex_amplification_count(encoder->main.encoder, layer_ids, count);
+}
+
+void
+kk_meta_resolve_rendering(struct kk_cmd_buffer *cmd,
+                          const VkRenderingInfo *pRenderingInfo)
+{
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+
+   struct kk_meta_save save;
+   kk_meta_begin(cmd, &save, VK_PIPELINE_BIND_POINT_GRAPHICS);
+   vk_meta_resolve_rendering(&cmd->vk, &dev->meta, pRenderingInfo);
+   kk_meta_end(cmd, &save, VK_PIPELINE_BIND_POINT_GRAPHICS);
+}
diff --git a/src/kosmickrisp/vulkan/kk_cmd_pool.c b/src/kosmickrisp/vulkan/kk_cmd_pool.c
new file mode 100644
index 00000000000..15e571c9723
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_cmd_pool.c
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_cmd_pool.h"
+
+#include "kk_device.h"
+#include "kk_entrypoints.h"
+#include "kk_physical_device.h"
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_CreateCommandPool(VkDevice _device,
+                     const VkCommandPoolCreateInfo *pCreateInfo,
+                     const VkAllocationCallbacks *pAllocator,
+                     VkCommandPool *pCmdPool)
+{
+   VK_FROM_HANDLE(kk_device, device, _device);
+   struct kk_cmd_pool *pool;
+
+   pool = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*pool), 8,
+                    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+   if (pool == NULL)
+      return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   VkResult result =
+      vk_command_pool_init(&device->vk, &pool->vk, pCreateInfo, pAllocator);
+   if (result != VK_SUCCESS) {
+      vk_free2(&device->vk.alloc, pAllocator, pool);
+      return result;
+   }
+
+   list_inithead(&pool->free_mem);
+   list_inithead(&pool->free_gart_mem);
+
+   *pCmdPool = kk_cmd_pool_to_handle(pool);
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_DestroyCommandPool(VkDevice _device, VkCommandPool commandPool,
+                      const VkAllocationCallbacks *pAllocator)
+{
+   VK_FROM_HANDLE(kk_device, device, _device);
+   VK_FROM_HANDLE(kk_cmd_pool, pool, commandPool);
+
+   if (!pool)
+      return;
+
+   vk_command_pool_finish(&pool->vk);
+   vk_free2(&device->vk.alloc, pAllocator, pool);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_TrimCommandPool(VkDevice device, VkCommandPool commandPool,
+                   VkCommandPoolTrimFlags flags)
+{
+   VK_FROM_HANDLE(kk_cmd_pool, pool, commandPool);
+
+   vk_command_pool_trim(&pool->vk, flags);
+}
diff --git a/src/kosmickrisp/vulkan/kk_cmd_pool.h b/src/kosmickrisp/vulkan/kk_cmd_pool.h
new file mode 100644
index 00000000000..c3a58f78524
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_cmd_pool.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_CMD_POOL_H
+#define KK_CMD_POOL_H
+
+#include "kk_private.h"
+
+#include "vk_command_pool.h"
+
+struct kk_cmd_pool {
+   struct vk_command_pool vk;
+
+   /** List of nvk_cmd_mem */
+   struct list_head free_mem;
+   struct list_head free_gart_mem;
+};
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_cmd_pool, vk.base, VkCommandPool,
+                               VK_OBJECT_TYPE_COMMAND_POOL)
+
+static inline struct kk_device *
+kk_cmd_pool_device(struct kk_cmd_pool *pool)
+{
+   return (struct kk_device *)pool->vk.base.device;
+}
+
+#endif /* KK_CMD_POOL_H */
diff --git a/src/kosmickrisp/vulkan/kk_debug.c b/src/kosmickrisp/vulkan/kk_debug.c
new file mode 100644
index 00000000000..dfc0385be41
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_debug.c
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+#include "kk_debug.h"
+#include "util/u_debug.h"
+
+enum kk_debug kk_mesa_debug_flags = 0;
+
+const struct debug_named_value flags[] = {
+   {"nir", KK_DEBUG_NIR},
+   {"msl", KK_DEBUG_MSL},
+   {NULL, 0},
+};
+
+DEBUG_GET_ONCE_FLAGS_OPTION(mesa_kk_debug, "MESA_KK_DEBUG", flags, 0);
+
+void
+kk_process_debug_variable(void)
+{
+   kk_mesa_debug_flags = debug_get_option_mesa_kk_debug();
+}
diff --git a/src/kosmickrisp/vulkan/kk_debug.h b/src/kosmickrisp/vulkan/kk_debug.h
new file mode 100644
index 00000000000..e50b3098c30
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_debug.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+#ifndef KK_DEBUG_H
+#define KK_DEBUG_H 1
+
+enum kk_debug {
+   /* Print out the NIR from the compiler */
+   KK_DEBUG_NIR = 1ull << 0,
+   /* Print out the generated MSL source code from the compiler */
+   KK_DEBUG_MSL = 1ull << 1,
+};
+
+extern enum kk_debug kk_mesa_debug_flags;
+
+#define KK_DEBUG(flag) unlikely(kk_mesa_debug_flags &KK_DEBUG_##flag)
+
+extern void kk_process_debug_variable(void);
+
+#endif /* KK_DEBUG_H */
diff --git a/src/kosmickrisp/vulkan/kk_descriptor_set.c b/src/kosmickrisp/vulkan/kk_descriptor_set.c
new file mode 100644
index 00000000000..0637fddc812
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_descriptor_set.c
@@ -0,0 +1,806 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_descriptor_set.h"
+
+#include "kk_bo.h"
+#include "kk_buffer.h"
+#include "kk_buffer_view.h"
+#include "kk_descriptor_set_layout.h"
+#include "kk_device.h"
+#include "kk_entrypoints.h"
+#include "kk_image_view.h"
+#include "kk_physical_device.h"
+#include "kk_sampler.h"
+
+#include "util/format/u_format.h"
+
+static inline uint32_t
+align_u32(uint32_t v, uint32_t a)
+{
+   assert(a != 0 && a == (a & -a));
+   return (v + a - 1) & ~(a - 1);
+}
+
+static inline void *
+desc_ubo_data(struct kk_descriptor_set *set, uint32_t binding, uint32_t elem,
+              uint32_t *size_out)
+{
+   const struct kk_descriptor_set_binding_layout *binding_layout =
+      &set->layout->binding[binding];
+
+   uint32_t offset = binding_layout->offset + elem * binding_layout->stride;
+   assert(offset < set->size);
+
+   if (size_out != NULL)
+      *size_out = set->size - offset;
+
+   return (char *)set->mapped_ptr + offset;
+}
+
+static void
+write_desc(struct kk_descriptor_set *set, uint32_t binding, uint32_t elem,
+           const void *desc_data, size_t desc_size)
+{
+   ASSERTED uint32_t dst_size;
+   void *dst = desc_ubo_data(set, binding, elem, &dst_size);
+   assert(desc_size <= dst_size);
+   memcpy(dst, desc_data, desc_size);
+}
+
+static void
+get_sampled_image_view_desc(VkDescriptorType descriptor_type,
+                            const VkDescriptorImageInfo *const info, void *dst,
+                            size_t dst_size, bool is_input_attachment)
+{
+   struct kk_sampled_image_descriptor desc[3] = {};
+   uint8_t plane_count = 1;
+
+   if (descriptor_type != VK_DESCRIPTOR_TYPE_SAMPLER && info &&
+       info->imageView != VK_NULL_HANDLE) {
+      VK_FROM_HANDLE(kk_image_view, view, info->imageView);
+
+      plane_count = view->plane_count;
+      for (uint8_t plane = 0; plane < plane_count; plane++) {
+         if (is_input_attachment) {
+            assert(view->planes[plane].sampled_gpu_resource_id);
+            desc[plane].image_gpu_resource_id =
+               view->planes[plane].input_gpu_resource_id;
+         } else {
+            assert(view->planes[plane].sampled_gpu_resource_id);
+            desc[plane].image_gpu_resource_id =
+               view->planes[plane].sampled_gpu_resource_id;
+         }
+      }
+   }
+
+   if (descriptor_type == VK_DESCRIPTOR_TYPE_SAMPLER ||
+       descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) {
+      VK_FROM_HANDLE(kk_sampler, sampler, info->sampler);
+
+      plane_count = MAX2(plane_count, sampler->plane_count);
+
+      for (uint8_t plane = 0; plane < plane_count; plane++) {
+         /* We need to replicate the last sampler plane out to all image
+          * planes due to sampler table entry limitations. See
+          * nvk_CreateSampler in nvk_sampler.c for more details.
+          */
+         uint8_t sampler_plane = MIN2(plane, sampler->plane_count - 1u);
+         assert(sampler->planes[sampler_plane].hw->handle);
+         desc[plane].sampler_index = sampler->planes[sampler_plane].hw->index;
+         desc[plane].lod_bias_fp16 = sampler->lod_bias_fp16;
+         desc[plane].lod_min_fp16 = sampler->lod_min_fp16;
+         desc[plane].lod_max_fp16 = sampler->lod_max_fp16;
+      }
+   }
+
+   assert(sizeof(desc[0]) * plane_count <= dst_size);
+   memcpy(dst, desc, sizeof(desc[0]) * plane_count);
+}
+
+static void
+write_sampled_image_view_desc(struct kk_descriptor_set *set,
+                              const VkDescriptorImageInfo *const _info,
+                              uint32_t binding, uint32_t elem,
+                              VkDescriptorType descriptor_type)
+{
+   VkDescriptorImageInfo info = *_info;
+
+   struct kk_descriptor_set_binding_layout *binding_layout =
+      &set->layout->binding[binding];
+   if (descriptor_type == VK_DESCRIPTOR_TYPE_SAMPLER ||
+       descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) {
+      if (binding_layout->immutable_samplers != NULL) {
+         info.sampler =
+            kk_sampler_to_handle(binding_layout->immutable_samplers[elem]);
+      }
+   }
+
+   uint32_t dst_size;
+   void *dst = desc_ubo_data(set, binding, elem, &dst_size);
+   get_sampled_image_view_desc(
+      descriptor_type, &info, dst, dst_size,
+      descriptor_type == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT);
+}
+
+static void
+get_storage_image_view_desc(
+   struct kk_descriptor_set_binding_layout *binding_layout,
+   const VkDescriptorImageInfo *const info, void *dst, size_t dst_size)
+{
+   struct kk_storage_image_descriptor desc = {};
+
+   if (info && info->imageView != VK_NULL_HANDLE) {
+      VK_FROM_HANDLE(kk_image_view, view, info->imageView);
+
+      /* Storage images are always single plane */
+      assert(view->plane_count == 1);
+      uint8_t plane = 0;
+
+      assert(view->planes[plane].storage_gpu_resource_id);
+      desc.image_gpu_resource_id = view->planes[plane].storage_gpu_resource_id;
+   }
+
+   assert(sizeof(desc) <= dst_size);
+   memcpy(dst, &desc, sizeof(desc));
+}
+
+static void
+write_storage_image_view_desc(struct kk_descriptor_set *set,
+                              const VkDescriptorImageInfo *const info,
+                              uint32_t binding, uint32_t elem)
+{
+   uint32_t dst_size;
+   void *dst = desc_ubo_data(set, binding, elem, &dst_size);
+   struct kk_descriptor_set_binding_layout *binding_layout =
+      &set->layout->binding[binding];
+   get_storage_image_view_desc(binding_layout, info, dst, dst_size);
+}
+
+static void
+write_buffer_desc(struct kk_descriptor_set *set,
+                  const VkDescriptorBufferInfo *const info, uint32_t binding,
+                  uint32_t elem)
+{
+   VK_FROM_HANDLE(kk_buffer, buffer, info->buffer);
+
+   const struct kk_addr_range addr_range =
+      kk_buffer_addr_range(buffer, info->offset, info->range);
+   assert(addr_range.range <= UINT32_MAX);
+
+   const struct kk_buffer_address desc = {
+      .base_addr = addr_range.addr,
+      .size = addr_range.range,
+   };
+   write_desc(set, binding, elem, &desc, sizeof(desc));
+}
+
+static void
+write_dynamic_buffer_desc(struct kk_descriptor_set *set,
+                          const VkDescriptorBufferInfo *const info,
+                          uint32_t binding, uint32_t elem)
+{
+   VK_FROM_HANDLE(kk_buffer, buffer, info->buffer);
+   const struct kk_descriptor_set_binding_layout *binding_layout =
+      &set->layout->binding[binding];
+
+   const struct kk_addr_range addr_range =
+      kk_buffer_addr_range(buffer, info->offset, info->range);
+   assert(addr_range.range <= UINT32_MAX);
+
+   struct kk_buffer_address *desc =
+      &set->dynamic_buffers[binding_layout->dynamic_buffer_index + elem];
+   *desc = (struct kk_buffer_address){
+      .base_addr = addr_range.addr,
+      .size = addr_range.range,
+   };
+}
+
+static void
+write_buffer_view_desc(struct kk_descriptor_set *set,
+                       const VkBufferView bufferView, uint32_t binding,
+                       uint32_t elem)
+{
+   struct kk_storage_image_descriptor desc = {};
+   if (bufferView != VK_NULL_HANDLE) {
+      VK_FROM_HANDLE(kk_buffer_view, view, bufferView);
+
+      assert(view->mtl_texel_buffer_handle);
+      assert(view->texel_buffer_gpu_id);
+
+      desc.image_gpu_resource_id = view->texel_buffer_gpu_id;
+   }
+   write_desc(set, binding, elem, &desc, sizeof(desc));
+}
+
+static void
+write_inline_uniform_data(struct kk_descriptor_set *set,
+                          const VkWriteDescriptorSetInlineUniformBlock *info,
+                          uint32_t binding, uint32_t offset)
+{
+   assert(set->layout->binding[binding].stride == 1);
+   write_desc(set, binding, offset, info->pData, info->dataSize);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
+                        const VkWriteDescriptorSet *pDescriptorWrites,
+                        uint32_t descriptorCopyCount,
+                        const VkCopyDescriptorSet *pDescriptorCopies)
+{
+   for (uint32_t w = 0; w < descriptorWriteCount; w++) {
+      const VkWriteDescriptorSet *write = &pDescriptorWrites[w];
+      VK_FROM_HANDLE(kk_descriptor_set, set, write->dstSet);
+
+      switch (write->descriptorType) {
+      case VK_DESCRIPTOR_TYPE_SAMPLER:
+      case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+      case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+      case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+         for (uint32_t j = 0; j < write->descriptorCount; j++) {
+            write_sampled_image_view_desc(
+               set, write->pImageInfo + j, write->dstBinding,
+               write->dstArrayElement + j, write->descriptorType);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+         for (uint32_t j = 0; j < write->descriptorCount; j++) {
+            write_storage_image_view_desc(set, write->pImageInfo + j,
+                                          write->dstBinding,
+                                          write->dstArrayElement + j);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+      case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+         for (uint32_t j = 0; j < write->descriptorCount; j++) {
+            write_buffer_view_desc(set, write->pTexelBufferView[j],
+                                   write->dstBinding,
+                                   write->dstArrayElement + j);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+      case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+         for (uint32_t j = 0; j < write->descriptorCount; j++) {
+            write_buffer_desc(set, write->pBufferInfo + j, write->dstBinding,
+                              write->dstArrayElement + j);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+      case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+         for (uint32_t j = 0; j < write->descriptorCount; j++) {
+            write_dynamic_buffer_desc(set, write->pBufferInfo + j,
+                                      write->dstBinding,
+                                      write->dstArrayElement + j);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK: {
+         const VkWriteDescriptorSetInlineUniformBlock *write_inline =
+            vk_find_struct_const(write->pNext,
+                                 WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK);
+         assert(write_inline->dataSize == write->descriptorCount);
+         write_inline_uniform_data(set, write_inline, write->dstBinding,
+                                   write->dstArrayElement);
+         break;
+      }
+
+      default:
+         break;
+      }
+   }
+
+   for (uint32_t i = 0; i < descriptorCopyCount; i++) {
+      const VkCopyDescriptorSet *copy = &pDescriptorCopies[i];
+      VK_FROM_HANDLE(kk_descriptor_set, src, copy->srcSet);
+      VK_FROM_HANDLE(kk_descriptor_set, dst, copy->dstSet);
+
+      const struct kk_descriptor_set_binding_layout *src_binding_layout =
+         &src->layout->binding[copy->srcBinding];
+      const struct kk_descriptor_set_binding_layout *dst_binding_layout =
+         &dst->layout->binding[copy->dstBinding];
+
+      if (dst_binding_layout->stride > 0 && src_binding_layout->stride > 0) {
+         for (uint32_t j = 0; j < copy->descriptorCount; j++) {
+            ASSERTED uint32_t dst_max_size, src_max_size;
+            void *dst_map = desc_ubo_data(
+               dst, copy->dstBinding, copy->dstArrayElement + j, &dst_max_size);
+            const void *src_map = desc_ubo_data(
+               src, copy->srcBinding, copy->srcArrayElement + j, &src_max_size);
+            const uint32_t copy_size =
+               MIN2(dst_binding_layout->stride, src_binding_layout->stride);
+            assert(copy_size <= dst_max_size && copy_size <= src_max_size);
+            memcpy(dst_map, src_map, copy_size);
+         }
+      }
+
+      switch (src_binding_layout->type) {
+      case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+      case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: {
+         const uint32_t dst_dyn_start =
+            dst_binding_layout->dynamic_buffer_index + copy->dstArrayElement;
+         const uint32_t src_dyn_start =
+            src_binding_layout->dynamic_buffer_index + copy->srcArrayElement;
+         typed_memcpy(&dst->dynamic_buffers[dst_dyn_start],
+                      &src->dynamic_buffers[src_dyn_start],
+                      copy->descriptorCount);
+         break;
+      }
+      default:
+         break;
+      }
+   }
+}
+
+void
+kk_push_descriptor_set_update(struct kk_push_descriptor_set *push_set,
+                              uint32_t write_count,
+                              const VkWriteDescriptorSet *writes)
+{
+   struct kk_descriptor_set_layout *layout = push_set->layout;
+   assert(layout->non_variable_descriptor_buffer_size < sizeof(push_set->data));
+   struct kk_descriptor_set set = {
+      .layout = push_set->layout,
+      .size = sizeof(push_set->data),
+      .mapped_ptr = push_set->data,
+   };
+
+   for (uint32_t w = 0; w < write_count; w++) {
+      const VkWriteDescriptorSet *write = &writes[w];
+      assert(write->dstSet == VK_NULL_HANDLE);
+
+      switch (write->descriptorType) {
+      case VK_DESCRIPTOR_TYPE_SAMPLER:
+      case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+      case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+      case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+         for (uint32_t j = 0; j < write->descriptorCount; j++) {
+            write_sampled_image_view_desc(
+               &set, write->pImageInfo + j, write->dstBinding,
+               write->dstArrayElement + j, write->descriptorType);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+         for (uint32_t j = 0; j < write->descriptorCount; j++) {
+            write_storage_image_view_desc(&set, write->pImageInfo + j,
+                                          write->dstBinding,
+                                          write->dstArrayElement + j);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+      case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+         for (uint32_t j = 0; j < write->descriptorCount; j++) {
+            write_buffer_view_desc(&set, write->pTexelBufferView[j],
+                                   write->dstBinding,
+                                   write->dstArrayElement + j);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+      case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+         for (uint32_t j = 0; j < write->descriptorCount; j++) {
+            write_buffer_desc(&set, write->pBufferInfo + j, write->dstBinding,
+                              write->dstArrayElement + j);
+         }
+         break;
+
+      default:
+         break;
+      }
+   }
+}
+
+static void kk_descriptor_pool_free(struct kk_descriptor_pool *pool,
+                                    uint64_t addr, uint64_t size);
+
+static void
+kk_descriptor_set_destroy(struct kk_device *dev,
+                          struct kk_descriptor_pool *pool,
+                          struct kk_descriptor_set *set)
+{
+   list_del(&set->link);
+   if (set->size > 0)
+      kk_descriptor_pool_free(pool, set->addr, set->size);
+   vk_descriptor_set_layout_unref(&dev->vk, &set->layout->vk);
+
+   vk_object_free(&dev->vk, NULL, set);
+}
+
+static void
+kk_destroy_descriptor_pool(struct kk_device *dev,
+                           const VkAllocationCallbacks *pAllocator,
+                           struct kk_descriptor_pool *pool)
+{
+   list_for_each_entry_safe(struct kk_descriptor_set, set, &pool->sets, link)
+      kk_descriptor_set_destroy(dev, pool, set);
+
+   util_vma_heap_finish(&pool->heap);
+
+   if (pool->bo != NULL)
+      kk_destroy_bo(dev, pool->bo);
+
+   vk_object_free(&dev->vk, pAllocator, pool);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_CreateDescriptorPool(VkDevice _device,
+                        const VkDescriptorPoolCreateInfo *pCreateInfo,
+                        const VkAllocationCallbacks *pAllocator,
+                        VkDescriptorPool *pDescriptorPool)
+{
+   VK_FROM_HANDLE(kk_device, dev, _device);
+   struct kk_descriptor_pool *pool;
+   VkResult result = VK_SUCCESS;
+
+   pool = vk_object_zalloc(&dev->vk, pAllocator, sizeof(*pool),
+                           VK_OBJECT_TYPE_DESCRIPTOR_POOL);
+   if (!pool)
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   list_inithead(&pool->sets);
+
+   const VkMutableDescriptorTypeCreateInfoEXT *mutable_info =
+      vk_find_struct_const(pCreateInfo->pNext,
+                           MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT);
+
+   uint32_t max_align = 0;
+   for (unsigned i = 0; i < pCreateInfo->poolSizeCount; ++i) {
+      const VkMutableDescriptorTypeListEXT *type_list = NULL;
+      if (pCreateInfo->pPoolSizes[i].type == VK_DESCRIPTOR_TYPE_MUTABLE_EXT &&
+          mutable_info && i < mutable_info->mutableDescriptorTypeListCount)
+         type_list = &mutable_info->pMutableDescriptorTypeLists[i];
+
+      uint32_t stride, alignment;
+      kk_descriptor_stride_align_for_type(pCreateInfo->pPoolSizes[i].type,
+                                          type_list, &stride, &alignment);
+      max_align = MAX2(max_align, alignment);
+   }
+
+   uint64_t mem_size = 0;
+   for (unsigned i = 0; i < pCreateInfo->poolSizeCount; ++i) {
+      const VkMutableDescriptorTypeListEXT *type_list = NULL;
+      if (pCreateInfo->pPoolSizes[i].type == VK_DESCRIPTOR_TYPE_MUTABLE_EXT &&
+          mutable_info && i < mutable_info->mutableDescriptorTypeListCount)
+         type_list = &mutable_info->pMutableDescriptorTypeLists[i];
+
+      uint32_t stride, alignment;
+      kk_descriptor_stride_align_for_type(pCreateInfo->pPoolSizes[i].type,
+                                          type_list, &stride, &alignment);
+      mem_size +=
+         MAX2(stride, max_align) * pCreateInfo->pPoolSizes[i].descriptorCount;
+   }
+
+   /* Individual descriptor sets are aligned to the min UBO alignment to
+    * ensure that we don't end up with unaligned data access in any shaders.
+    * This means that each descriptor buffer allocated may burn up to 16B of
+    * extra space to get the right alignment.  (Technically, it's at most 28B
+    * because we're always going to start at least 4B aligned but we're being
+    * conservative here.)  Allocate enough extra space that we can chop it
+    * into maxSets pieces and align each one of them to 32B.
+    */
+   mem_size += kk_min_cbuf_alignment() * pCreateInfo->maxSets;
+
+   if (mem_size) {
+      result = kk_alloc_bo(dev, &dev->vk.base, mem_size, 0u, &pool->bo);
+      if (result != VK_SUCCESS) {
+         kk_destroy_descriptor_pool(dev, pAllocator, pool);
+         return result;
+      }
+
+      /* The BO may be larger thanks to GPU page alignment.  We may as well
+       * make that extra space available to the client.
+       */
+      assert(pool->bo->size_B >= mem_size);
+      util_vma_heap_init(&pool->heap, pool->bo->gpu, pool->bo->size_B);
+   } else {
+      util_vma_heap_init(&pool->heap, 0, 0);
+   }
+
+   *pDescriptorPool = kk_descriptor_pool_to_handle(pool);
+   return result;
+}
+
+static VkResult
+kk_descriptor_pool_alloc(struct kk_descriptor_pool *pool, uint64_t size,
+                         uint64_t alignment, uint64_t *addr_out, void **map_out)
+{
+   assert(size > 0);
+   assert(size % alignment == 0);
+
+   if (size > pool->heap.free_size)
+      return VK_ERROR_OUT_OF_POOL_MEMORY;
+
+   uint64_t addr = util_vma_heap_alloc(&pool->heap, size, alignment);
+   if (addr == 0)
+      return VK_ERROR_FRAGMENTED_POOL;
+
+   assert(addr >= pool->bo->gpu);
+   assert(addr + size <= pool->bo->gpu + pool->bo->size_B);
+   uint64_t offset = addr - pool->bo->gpu;
+
+   *addr_out = addr;
+   *map_out = pool->bo->cpu + offset;
+
+   return VK_SUCCESS;
+}
+
+static void
+kk_descriptor_pool_free(struct kk_descriptor_pool *pool, uint64_t addr,
+                        uint64_t size)
+{
+   assert(size > 0);
+   assert(addr >= pool->bo->gpu);
+   assert(addr + size <= pool->bo->gpu + pool->bo->size_B);
+   util_vma_heap_free(&pool->heap, addr, size);
+}
+
+static VkResult
+kk_descriptor_set_create(struct kk_device *dev, struct kk_descriptor_pool *pool,
+                         struct kk_descriptor_set_layout *layout,
+                         uint32_t variable_count,
+                         struct kk_descriptor_set **out_set)
+{
+   struct kk_descriptor_set *set;
+   VkResult result = VK_SUCCESS;
+
+   uint32_t mem_size =
+      sizeof(struct kk_descriptor_set) +
+      layout->dynamic_buffer_count * sizeof(struct kk_buffer_address);
+   set =
+      vk_object_zalloc(&dev->vk, NULL, mem_size, VK_OBJECT_TYPE_DESCRIPTOR_SET);
+   if (!set)
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   set->size = layout->non_variable_descriptor_buffer_size;
+
+   if (layout->binding_count > 0 &&
+       (layout->binding[layout->binding_count - 1].flags &
+        VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT)) {
+      uint32_t stride = layout->binding[layout->binding_count - 1].stride;
+      set->size += stride * variable_count;
+   }
+
+   uint32_t alignment = kk_min_cbuf_alignment();
+   set->size = align64(set->size, alignment);
+
+   if (set->size > 0) {
+      result = kk_descriptor_pool_alloc(pool, set->size, alignment, &set->addr,
+                                        &set->mapped_ptr);
+      if (result != VK_SUCCESS) {
+         vk_object_free(&dev->vk, NULL, set);
+         return result;
+      }
+      set->mtl_descriptor_buffer = pool->bo->map;
+   }
+
+   vk_descriptor_set_layout_ref(&layout->vk);
+   set->layout = layout;
+
+   for (uint32_t b = 0; b < layout->binding_count; b++) {
+      if (layout->binding[b].type != VK_DESCRIPTOR_TYPE_SAMPLER &&
+          layout->binding[b].type != VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
+         continue;
+
+      if (layout->binding[b].immutable_samplers == NULL)
+         continue;
+
+      uint32_t array_size = layout->binding[b].array_size;
+      if (layout->binding[b].flags &
+          VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT)
+         array_size = variable_count;
+
+      const VkDescriptorImageInfo empty = {};
+      for (uint32_t j = 0; j < array_size; j++) {
+         write_sampled_image_view_desc(set, &empty, b, j,
+                                       layout->binding[b].type);
+      }
+   }
+
+   list_addtail(&set->link, &pool->sets);
+   *out_set = set;
+
+   return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_AllocateDescriptorSets(VkDevice device,
+                          const VkDescriptorSetAllocateInfo *pAllocateInfo,
+                          VkDescriptorSet *pDescriptorSets)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_descriptor_pool, pool, pAllocateInfo->descriptorPool);
+
+   VkResult result = VK_SUCCESS;
+   uint32_t i;
+
+   struct kk_descriptor_set *set = NULL;
+
+   const VkDescriptorSetVariableDescriptorCountAllocateInfo *var_desc_count =
+      vk_find_struct_const(
+         pAllocateInfo->pNext,
+         DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO);
+
+   /* allocate a set of buffers for each shader to contain descriptors */
+   for (i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
+      VK_FROM_HANDLE(kk_descriptor_set_layout, layout,
+                     pAllocateInfo->pSetLayouts[i]);
+      /* If descriptorSetCount is zero or this structure is not included in
+       * the pNext chain, then the variable lengths are considered to be zero.
+       */
+      const uint32_t variable_count =
+         var_desc_count && var_desc_count->descriptorSetCount > 0
+            ? var_desc_count->pDescriptorCounts[i]
+            : 0;
+
+      result =
+         kk_descriptor_set_create(dev, pool, layout, variable_count, &set);
+      if (result != VK_SUCCESS)
+         break;
+
+      pDescriptorSets[i] = kk_descriptor_set_to_handle(set);
+   }
+
+   if (result != VK_SUCCESS) {
+      kk_FreeDescriptorSets(device, pAllocateInfo->descriptorPool, i,
+                            pDescriptorSets);
+      for (i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
+         pDescriptorSets[i] = VK_NULL_HANDLE;
+      }
+   }
+   return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+                      uint32_t descriptorSetCount,
+                      const VkDescriptorSet *pDescriptorSets)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_descriptor_pool, pool, descriptorPool);
+
+   for (uint32_t i = 0; i < descriptorSetCount; i++) {
+      VK_FROM_HANDLE(kk_descriptor_set, set, pDescriptorSets[i]);
+
+      if (set)
+         kk_descriptor_set_destroy(dev, pool, set);
+   }
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_DestroyDescriptorPool(VkDevice device, VkDescriptorPool _pool,
+                         const VkAllocationCallbacks *pAllocator)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_descriptor_pool, pool, _pool);
+
+   if (!_pool)
+      return;
+
+   kk_destroy_descriptor_pool(dev, pAllocator, pool);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                       VkDescriptorPoolResetFlags flags)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_descriptor_pool, pool, descriptorPool);
+
+   list_for_each_entry_safe(struct kk_descriptor_set, set, &pool->sets, link)
+      kk_descriptor_set_destroy(dev, pool, set);
+
+   return VK_SUCCESS;
+}
+
+static void
+kk_descriptor_set_write_template(
+   struct kk_descriptor_set *set,
+   const struct vk_descriptor_update_template *template, const void *data)
+{
+   for (uint32_t i = 0; i < template->entry_count; i++) {
+      const struct vk_descriptor_template_entry *entry = &template->entries[i];
+
+      switch (entry->type) {
+      case VK_DESCRIPTOR_TYPE_SAMPLER:
+      case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+      case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+      case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+         for (uint32_t j = 0; j < entry->array_count; j++) {
+            const VkDescriptorImageInfo *info =
+               data + entry->offset + j * entry->stride;
+
+            write_sampled_image_view_desc(set, info, entry->binding,
+                                          entry->array_element + j,
+                                          entry->type);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+         for (uint32_t j = 0; j < entry->array_count; j++) {
+            const VkDescriptorImageInfo *info =
+               data + entry->offset + j * entry->stride;
+
+            write_storage_image_view_desc(set, info, entry->binding,
+                                          entry->array_element + j);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+      case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+         for (uint32_t j = 0; j < entry->array_count; j++) {
+            const VkBufferView *bview =
+               data + entry->offset + j * entry->stride;
+
+            write_buffer_view_desc(set, *bview, entry->binding,
+                                   entry->array_element + j);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+      case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+         for (uint32_t j = 0; j < entry->array_count; j++) {
+            const VkDescriptorBufferInfo *info =
+               data + entry->offset + j * entry->stride;
+
+            write_buffer_desc(set, info, entry->binding,
+                              entry->array_element + j);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+      case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+         for (uint32_t j = 0; j < entry->array_count; j++) {
+            const VkDescriptorBufferInfo *info =
+               data + entry->offset + j * entry->stride;
+
+            write_dynamic_buffer_desc(set, info, entry->binding,
+                                      entry->array_element + j);
+         }
+         break;
+
+      case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
+         write_desc(set, entry->binding, entry->array_element,
+                    data + entry->offset, entry->array_count);
+         break;
+
+      default:
+         break;
+      }
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_UpdateDescriptorSetWithTemplate(
+   VkDevice device, VkDescriptorSet descriptorSet,
+   VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
+{
+   VK_FROM_HANDLE(kk_descriptor_set, set, descriptorSet);
+   VK_FROM_HANDLE(vk_descriptor_update_template, template,
+                  descriptorUpdateTemplate);
+
+   kk_descriptor_set_write_template(set, template, pData);
+}
+
+void
+kk_push_descriptor_set_update_template(
+   struct kk_push_descriptor_set *push_set,
+   struct kk_descriptor_set_layout *layout,
+   const struct vk_descriptor_update_template *template, const void *data)
+{
+   struct kk_descriptor_set tmp_set = {
+      .layout = layout,
+      .size = sizeof(push_set->data),
+      .mapped_ptr = push_set->data,
+   };
+   kk_descriptor_set_write_template(&tmp_set, template, data);
+}
diff --git a/src/kosmickrisp/vulkan/kk_descriptor_set.h b/src/kosmickrisp/vulkan/kk_descriptor_set.h
new file mode 100644
index 00000000000..d1652448a41
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_descriptor_set.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_DESCRIPTOR_SET
+#define KK_DESCRIPTOR_SET 1
+
+#include "kk_private.h"
+
+#include "kk_descriptor_types.h"
+#include "kk_device.h"
+
+#include "vk_descriptor_update_template.h"
+#include "vk_object.h"
+
+#include "util/list.h"
+#include "util/vma.h"
+
+struct kk_descriptor_set_layout;
+struct kk_bo;
+
+struct kk_descriptor_pool {
+   struct vk_object_base base;
+
+   struct list_head sets;
+
+   struct kk_bo *bo;
+   struct util_vma_heap heap;
+};
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_descriptor_pool, base, VkDescriptorPool,
+                               VK_OBJECT_TYPE_DESCRIPTOR_POOL)
+
+struct kk_descriptor_set {
+   struct vk_object_base base;
+
+   /* Link in kk_descriptor_pool::sets */
+   struct list_head link;
+
+   struct kk_descriptor_set_layout *layout;
+   mtl_resource *mtl_descriptor_buffer;
+   void *mapped_ptr;
+   uint64_t addr;
+   uint32_t size;
+
+   struct kk_buffer_address dynamic_buffers[];
+};
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_descriptor_set, base, VkDescriptorSet,
+                               VK_OBJECT_TYPE_DESCRIPTOR_SET)
+
+static inline struct kk_buffer_address
+kk_descriptor_set_addr(const struct kk_descriptor_set *set)
+{
+   return (struct kk_buffer_address){
+      .base_addr = set->addr,
+      .size = set->size,
+   };
+}
+
+struct kk_push_descriptor_set {
+   uint8_t data[KK_PUSH_DESCRIPTOR_SET_SIZE];
+   struct kk_descriptor_set_layout *layout;
+   mtl_resource *mtl_descriptor_buffer;
+   uint32_t resource_count;
+   mtl_resource *mtl_resources[];
+};
+
+void kk_push_descriptor_set_update(struct kk_push_descriptor_set *push_set,
+                                   uint32_t write_count,
+                                   const VkWriteDescriptorSet *writes);
+
+void kk_push_descriptor_set_update_template(
+   struct kk_push_descriptor_set *push_set,
+   struct kk_descriptor_set_layout *layout,
+   const struct vk_descriptor_update_template *template, const void *data);
+
+#endif
diff --git a/src/kosmickrisp/vulkan/kk_descriptor_set_layout.c b/src/kosmickrisp/vulkan/kk_descriptor_set_layout.c
new file mode 100644
index 00000000000..11b4c98b9f6
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_descriptor_set_layout.c
@@ -0,0 +1,496 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_descriptor_set_layout.h"
+
+#include "kk_descriptor_types.h"
+#include "kk_device.h"
+#include "kk_entrypoints.h"
+#include "kk_physical_device.h"
+#include "kk_sampler.h"
+
+#include "vk_pipeline_layout.h"
+
+static bool
+binding_has_immutable_samplers(const VkDescriptorSetLayoutBinding *binding)
+{
+   switch (binding->descriptorType) {
+   case VK_DESCRIPTOR_TYPE_SAMPLER:
+   case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+      return binding->pImmutableSamplers != NULL;
+
+   default:
+      return false;
+   }
+}
+
+void
+kk_descriptor_stride_align_for_type(
+   VkDescriptorType type, const VkMutableDescriptorTypeListEXT *type_list,
+   uint32_t *stride, uint32_t *alignment)
+{
+   switch (type) {
+   case VK_DESCRIPTOR_TYPE_SAMPLER:
+   case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+      /* TODO: How do samplers work? */
+   case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+   case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+      *stride = *alignment = sizeof(struct kk_sampled_image_descriptor);
+      break;
+
+   case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+   case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+   case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+      *stride = *alignment = sizeof(struct kk_storage_image_descriptor);
+      break;
+
+   case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+   case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+      *stride = *alignment = sizeof(struct kk_buffer_address);
+      break;
+
+   case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+   case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+      *stride = *alignment = 0; /* These don't take up buffer space */
+      break;
+
+   case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
+      *stride = 1; /* Array size is bytes */
+      *alignment = kk_min_cbuf_alignment();
+      break;
+
+   case VK_DESCRIPTOR_TYPE_MUTABLE_EXT:
+      *stride = *alignment = 0;
+      if (type_list == NULL)
+         *stride = *alignment = KK_MAX_DESCRIPTOR_SIZE;
+      for (unsigned i = 0; type_list && i < type_list->descriptorTypeCount;
+           i++) {
+         /* This shouldn't recurse */
+         assert(type_list->pDescriptorTypes[i] !=
+                VK_DESCRIPTOR_TYPE_MUTABLE_EXT);
+         uint32_t desc_stride, desc_align;
+         kk_descriptor_stride_align_for_type(type_list->pDescriptorTypes[i],
+                                             NULL, &desc_stride, &desc_align);
+         *stride = MAX2(*stride, desc_stride);
+         *alignment = MAX2(*alignment, desc_align);
+      }
+      *stride = ALIGN(*stride, *alignment);
+      break;
+
+   default:
+      UNREACHABLE("Invalid descriptor type");
+   }
+
+   assert(*stride <= KK_MAX_DESCRIPTOR_SIZE);
+}
+
+static const VkMutableDescriptorTypeListEXT *
+kk_descriptor_get_type_list(VkDescriptorType type,
+                            const VkMutableDescriptorTypeCreateInfoEXT *info,
+                            const uint32_t info_idx)
+{
+   const VkMutableDescriptorTypeListEXT *type_list = NULL;
+   if (type == VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
+      assert(info != NULL);
+      assert(info_idx < info->mutableDescriptorTypeListCount);
+      type_list = &info->pMutableDescriptorTypeLists[info_idx];
+   }
+   return type_list;
+}
+
+static void
+kk_descriptor_set_layout_destroy(struct vk_device *vk_dev,
+                                 struct vk_descriptor_set_layout *vk_layout)
+{
+   struct kk_device *dev = container_of(vk_dev, struct kk_device, vk);
+   struct kk_descriptor_set_layout *layout =
+      vk_to_kk_descriptor_set_layout(vk_layout);
+
+   vk_object_free(&dev->vk, NULL, layout);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_CreateDescriptorSetLayout(VkDevice device,
+                             const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
+                             const VkAllocationCallbacks *pAllocator,
+                             VkDescriptorSetLayout *pSetLayout)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+
+   uint32_t num_bindings = 0;
+   uint32_t immutable_sampler_count = 0;
+   for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) {
+      const VkDescriptorSetLayoutBinding *binding = &pCreateInfo->pBindings[j];
+      num_bindings = MAX2(num_bindings, binding->binding + 1);
+
+      /* From the Vulkan 1.1.97 spec for VkDescriptorSetLayoutBinding:
+       *
+       *    "If descriptorType specifies a VK_DESCRIPTOR_TYPE_SAMPLER or
+       *    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER type descriptor, then
+       *    pImmutableSamplers can be used to initialize a set of immutable
+       *    samplers. [...]  If descriptorType is not one of these descriptor
+       *    types, then pImmutableSamplers is ignored.
+       *
+       * We need to be careful here and only parse pImmutableSamplers if we
+       * have one of the right descriptor types.
+       */
+      if (binding_has_immutable_samplers(binding))
+         immutable_sampler_count += binding->descriptorCount;
+   }
+
+   VK_MULTIALLOC(ma);
+   VK_MULTIALLOC_DECL(&ma, struct kk_descriptor_set_layout, layout, 1);
+   VK_MULTIALLOC_DECL(&ma, struct kk_descriptor_set_binding_layout, bindings,
+                      num_bindings);
+   VK_MULTIALLOC_DECL(&ma, struct kk_sampler *, samplers,
+                      immutable_sampler_count);
+
+   if (!vk_descriptor_set_layout_multizalloc(&dev->vk, &ma, pCreateInfo))
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   layout->vk.destroy = kk_descriptor_set_layout_destroy;
+   layout->flags = pCreateInfo->flags;
+   layout->binding_count = num_bindings;
+
+   for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) {
+      const VkDescriptorSetLayoutBinding *binding = &pCreateInfo->pBindings[j];
+      uint32_t b = binding->binding;
+      /* We temporarily store pCreateInfo->pBindings[] index (plus one) in the
+       * immutable_samplers pointer.  This provides us with a quick-and-dirty
+       * way to sort the bindings by binding number.
+       */
+      layout->binding[b].immutable_samplers = (void *)(uintptr_t)(j + 1);
+   }
+
+   const VkDescriptorSetLayoutBindingFlagsCreateInfo *binding_flags_info =
+      vk_find_struct_const(pCreateInfo->pNext,
+                           DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO);
+   const VkMutableDescriptorTypeCreateInfoEXT *mutable_info =
+      vk_find_struct_const(pCreateInfo->pNext,
+                           MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT);
+
+   uint32_t buffer_size = 0;
+   uint32_t max_variable_descriptor_size = 0;
+   uint8_t dynamic_buffer_count = 0;
+   uint32_t total_descriptor_count = 0u;
+   for (uint32_t b = 0; b < num_bindings; b++) {
+      /* We stashed the pCreateInfo->pBindings[] index (plus one) in the
+       * immutable_samplers pointer.  Check for NULL (empty binding) and then
+       * reset it and compute the index.
+       */
+      if (layout->binding[b].immutable_samplers == NULL)
+         continue;
+      const uint32_t info_idx =
+         (uintptr_t)(void *)layout->binding[b].immutable_samplers - 1;
+      layout->binding[b].immutable_samplers = NULL;
+
+      const VkDescriptorSetLayoutBinding *binding =
+         &pCreateInfo->pBindings[info_idx];
+
+      if (binding->descriptorCount == 0)
+         continue;
+
+      layout->binding[b].type = binding->descriptorType;
+      layout->binding[b].mtl_resources_index = total_descriptor_count;
+      layout->descriptor_count += binding->descriptorCount;
+
+      if (binding_flags_info && binding_flags_info->bindingCount > 0) {
+         assert(binding_flags_info->bindingCount == pCreateInfo->bindingCount);
+         layout->binding[b].flags = binding_flags_info->pBindingFlags[info_idx];
+      }
+
+      layout->binding[b].array_size = binding->descriptorCount;
+
+      switch (binding->descriptorType) {
+      case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+         layout->binding[b].dynamic_buffer_index = dynamic_buffer_count;
+         BITSET_SET_RANGE(layout->dynamic_ubos, dynamic_buffer_count,
+                          dynamic_buffer_count + binding->descriptorCount - 1);
+         dynamic_buffer_count += binding->descriptorCount;
+         break;
+
+      case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+         layout->binding[b].dynamic_buffer_index = dynamic_buffer_count;
+         dynamic_buffer_count += binding->descriptorCount;
+         break;
+
+      default:
+         break;
+      }
+
+      const VkMutableDescriptorTypeListEXT *type_list =
+         kk_descriptor_get_type_list(binding->descriptorType, mutable_info,
+                                     info_idx);
+
+      uint32_t stride, alignment;
+      kk_descriptor_stride_align_for_type(binding->descriptorType, type_list,
+                                          &stride, &alignment);
+
+      uint8_t max_plane_count = 1;
+
+      if (binding_has_immutable_samplers(binding)) {
+         layout->binding[b].immutable_samplers = samplers;
+         samplers += binding->descriptorCount;
+         for (uint32_t i = 0; i < binding->descriptorCount; i++) {
+            VK_FROM_HANDLE(kk_sampler, sampler, binding->pImmutableSamplers[i]);
+            layout->binding[b].immutable_samplers[i] = sampler;
+            const uint8_t sampler_plane_count =
+               sampler->vk.ycbcr_conversion
+                  ? vk_format_get_plane_count(
+                       sampler->vk.ycbcr_conversion->state.format)
+                  : 1;
+            if (max_plane_count < sampler_plane_count)
+               max_plane_count = sampler_plane_count;
+         }
+      }
+
+      stride *= max_plane_count;
+      layout->binding[b].count_per_element = max_plane_count;
+      total_descriptor_count += max_plane_count * binding->descriptorCount;
+
+      if (stride > 0) {
+         assert(stride <= UINT8_MAX);
+         assert(util_is_power_of_two_nonzero(alignment));
+
+         buffer_size = align64(buffer_size, alignment);
+         layout->binding[b].offset = buffer_size;
+         layout->binding[b].stride = stride;
+
+         if (layout->binding[b].flags &
+             VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT) {
+            /* From the Vulkan 1.3.256 spec:
+             *
+             *    VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004
+             *    "If an element of pBindingFlags includes
+             *    VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then
+             *    all other elements of
+             *    VkDescriptorSetLayoutCreateInfo::pBindings must have a
+             *    smaller value of binding"
+             *
+             * In other words, it has to be the last binding.
+             */
+            assert(b == num_bindings - 1);
+            assert(max_variable_descriptor_size == 0);
+            max_variable_descriptor_size = stride * binding->descriptorCount;
+         } else {
+            /* the allocation size will be computed at descriptor allocation,
+             * but the buffer size will be already aligned as this binding will
+             * be the last
+             */
+            buffer_size += stride * binding->descriptorCount;
+         }
+      }
+   }
+
+   layout->non_variable_descriptor_buffer_size = buffer_size;
+   layout->max_buffer_size = buffer_size + max_variable_descriptor_size;
+   layout->dynamic_buffer_count = dynamic_buffer_count;
+
+   struct mesa_blake3 blake3_ctx;
+   _mesa_blake3_init(&blake3_ctx);
+
+#define BLAKE3_UPDATE_VALUE(x)                                                 \
+   _mesa_blake3_update(&blake3_ctx, &(x), sizeof(x));
+   BLAKE3_UPDATE_VALUE(layout->non_variable_descriptor_buffer_size);
+   BLAKE3_UPDATE_VALUE(layout->dynamic_buffer_count);
+   BLAKE3_UPDATE_VALUE(layout->binding_count);
+
+   for (uint32_t b = 0; b < num_bindings; b++) {
+      BLAKE3_UPDATE_VALUE(layout->binding[b].type);
+      BLAKE3_UPDATE_VALUE(layout->binding[b].flags);
+      BLAKE3_UPDATE_VALUE(layout->binding[b].array_size);
+      BLAKE3_UPDATE_VALUE(layout->binding[b].offset);
+      BLAKE3_UPDATE_VALUE(layout->binding[b].stride);
+      BLAKE3_UPDATE_VALUE(layout->binding[b].dynamic_buffer_index);
+
+      if (layout->binding[b].immutable_samplers != NULL) {
+         for (uint32_t i = 0; i < layout->binding[b].array_size; i++) {
+            const struct kk_sampler *sampler =
+               layout->binding[b].immutable_samplers[i];
+
+            /* We zalloc the object, so it's safe to hash the whole thing */
+            if (sampler != NULL && sampler->vk.ycbcr_conversion != NULL)
+               BLAKE3_UPDATE_VALUE(sampler->vk.ycbcr_conversion->state);
+         }
+      }
+   }
+#undef BLAKE3_UPDATE_VALUE
+
+   _mesa_blake3_final(&blake3_ctx, layout->vk.blake3);
+
+   if (pCreateInfo->flags &
+       VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT) {
+      void *sampler_desc_data =
+         vk_alloc2(&dev->vk.alloc, pAllocator, buffer_size, 4,
+                   VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
+      if (sampler_desc_data == NULL) {
+         kk_descriptor_set_layout_destroy(&dev->vk, &layout->vk);
+         return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+      }
+
+      for (uint32_t b = 0; b < num_bindings; b++) {
+         assert(layout->binding[b].type == VK_DESCRIPTOR_TYPE_SAMPLER);
+         assert(layout->binding[b].array_size == 1);
+         assert(layout->binding[b].immutable_samplers != NULL);
+         assert(!(layout->binding[b].flags &
+                  VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT));
+
+         /* I'm paranoid */
+         if (layout->binding[b].immutable_samplers == NULL)
+            continue;
+
+         struct kk_sampler *sampler = layout->binding[b].immutable_samplers[0];
+
+         /* YCbCr has to come in through a combined image/sampler */
+         assert(sampler->plane_count == 1);
+
+         assert(sampler->planes[0].hw->handle);
+      }
+
+      vk_free2(&dev->vk.alloc, pAllocator, sampler_desc_data);
+   }
+
+   *pSetLayout = kk_descriptor_set_layout_to_handle(layout);
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetDescriptorSetLayoutSupport(
+   VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
+   VkDescriptorSetLayoutSupport *pSupport)
+{
+   const VkMutableDescriptorTypeCreateInfoEXT *mutable_info =
+      vk_find_struct_const(pCreateInfo->pNext,
+                           MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT);
+   const VkDescriptorSetLayoutBindingFlagsCreateInfo *binding_flags =
+      vk_find_struct_const(pCreateInfo->pNext,
+                           DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO);
+
+   /* Figure out the maximum alignment up-front.  Otherwise, we need to sort
+    * the list of descriptors by binding number in order to get the size
+    * accumulation right.
+    */
+   uint32_t max_align = 0;
+   for (uint32_t i = 0; i < pCreateInfo->bindingCount; i++) {
+      const VkDescriptorSetLayoutBinding *binding = &pCreateInfo->pBindings[i];
+      const VkMutableDescriptorTypeListEXT *type_list =
+         kk_descriptor_get_type_list(binding->descriptorType, mutable_info, i);
+
+      uint32_t stride, alignment;
+      kk_descriptor_stride_align_for_type(binding->descriptorType, type_list,
+                                          &stride, &alignment);
+      max_align = MAX2(max_align, alignment);
+   }
+
+   uint64_t non_variable_size = 0;
+   uint32_t variable_stride = 0;
+   uint32_t variable_count = 0;
+   uint8_t dynamic_buffer_count = 0;
+
+   for (uint32_t i = 0; i < pCreateInfo->bindingCount; i++) {
+      const VkDescriptorSetLayoutBinding *binding = &pCreateInfo->pBindings[i];
+
+      VkDescriptorBindingFlags flags = 0;
+      if (binding_flags != NULL && binding_flags->bindingCount > 0)
+         flags = binding_flags->pBindingFlags[i];
+
+      switch (binding->descriptorType) {
+      case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+      case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+         dynamic_buffer_count += binding->descriptorCount;
+         break;
+      default:
+         break;
+      }
+
+      const VkMutableDescriptorTypeListEXT *type_list =
+         kk_descriptor_get_type_list(binding->descriptorType, mutable_info, i);
+
+      uint32_t stride, alignment;
+      kk_descriptor_stride_align_for_type(binding->descriptorType, type_list,
+                                          &stride, &alignment);
+
+      if (stride > 0) {
+         assert(stride <= UINT8_MAX);
+         assert(util_is_power_of_two_nonzero(alignment));
+
+         if (flags & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT) {
+            /* From the Vulkan 1.3.256 spec:
+             *
+             *    "For the purposes of this command, a variable-sized
+             *    descriptor binding with a descriptorCount of zero is treated
+             *    as if the descriptorCount is one"
+             */
+            variable_count = MAX2(1, binding->descriptorCount);
+            variable_stride = stride;
+         } else {
+            /* Since we're aligning to the maximum and since this is just a
+             * check for whether or not the max buffer size is big enough, we
+             * keep non_variable_size aligned to max_align.
+             */
+            non_variable_size += stride * binding->descriptorCount;
+            non_variable_size = align64(non_variable_size, max_align);
+         }
+      }
+   }
+
+   uint64_t buffer_size = non_variable_size;
+   if (variable_stride > 0) {
+      buffer_size += variable_stride * variable_count;
+      buffer_size = align64(buffer_size, max_align);
+   }
+
+   uint32_t max_buffer_size;
+   if (pCreateInfo->flags &
+       VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR)
+      max_buffer_size = KK_PUSH_DESCRIPTOR_SET_SIZE;
+   else
+      max_buffer_size = KK_MAX_DESCRIPTOR_SET_SIZE;
+
+   pSupport->supported = dynamic_buffer_count <= KK_MAX_DYNAMIC_BUFFERS &&
+                         buffer_size <= max_buffer_size;
+
+   vk_foreach_struct(ext, pSupport->pNext) {
+      switch (ext->sType) {
+      case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
+         VkDescriptorSetVariableDescriptorCountLayoutSupport *vs = (void *)ext;
+         if (variable_stride > 0) {
+            vs->maxVariableDescriptorCount =
+               (max_buffer_size - non_variable_size) / variable_stride;
+         } else {
+            vs->maxVariableDescriptorCount = 0;
+         }
+         break;
+      }
+
+      default:
+         vk_debug_ignored_stype(ext->sType);
+         break;
+      }
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout _layout,
+                                 VkDeviceSize *pLayoutSizeInBytes)
+{
+   VK_FROM_HANDLE(kk_descriptor_set_layout, layout, _layout);
+
+   *pLayoutSizeInBytes = layout->max_buffer_size;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetDescriptorSetLayoutBindingOffsetEXT(VkDevice device,
+                                          VkDescriptorSetLayout _layout,
+                                          uint32_t binding,
+                                          VkDeviceSize *pOffset)
+{
+   VK_FROM_HANDLE(kk_descriptor_set_layout, layout, _layout);
+
+   *pOffset = layout->binding[binding].offset;
+}
diff --git a/src/kosmickrisp/vulkan/kk_descriptor_set_layout.h b/src/kosmickrisp/vulkan/kk_descriptor_set_layout.h
new file mode 100644
index 00000000000..14ecda0f62a
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_descriptor_set_layout.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_DESCRIPTOR_SET_LAYOUT
+#define KK_DESCRIPTOR_SET_LAYOUT 1
+
+#include "kk_private.h"
+
+#include "vk_descriptor_set_layout.h"
+#include "vk_object.h"
+
+#include "util/bitset.h"
+
+struct kk_device;
+struct kk_physical_device;
+struct kk_sampler;
+struct vk_pipeline_layout;
+
+struct kk_descriptor_set_binding_layout {
+   /* The type of the descriptors in this binding */
+   VkDescriptorType type;
+
+   /* Flags provided when this binding was created */
+   VkDescriptorBindingFlags flags;
+
+   /* Number of array elements in this binding (or size in bytes for inline
+    * uniform data)
+    */
+   uint32_t array_size;
+
+   /* Number of actual descriptors per element */
+   uint32_t count_per_element;
+
+   /* Offset into the descriptor buffer where this descriptor lives */
+   uint32_t offset;
+
+   /* Offset to the mtl_resource_ids array where this descriptor stores them */
+   uint32_t mtl_resources_index;
+
+   /* Stride between array elements in the descriptor buffer */
+   uint8_t stride;
+
+   /* Index into the dynamic buffer binding array */
+   uint8_t dynamic_buffer_index;
+
+   /* Immutable samplers (or NULL if no immutable samplers) */
+   struct kk_sampler **immutable_samplers;
+};
+
+struct kk_descriptor_set_layout {
+   struct vk_descriptor_set_layout vk;
+
+   VkDescriptorSetLayoutCreateFlagBits flags;
+
+   /* Size of the descriptor buffer for this descriptor set */
+   /* Does not contain the size needed for variable count descriptors */
+   uint32_t non_variable_descriptor_buffer_size;
+
+   /* Maximum possible buffer size for this descriptor set */
+   uint32_t max_buffer_size;
+
+   /* Number of dynamic UBO bindings in this set */
+   uint8_t dynamic_buffer_count;
+
+   /* Which dynamic buffers are UBOs */
+   BITSET_DECLARE(dynamic_ubos, KK_MAX_DYNAMIC_BUFFERS);
+
+   /* Number of bindings in this descriptor set */
+   uint32_t binding_count;
+
+   /* Number of descriptors in the layout */
+   uint32_t descriptor_count;
+
+   /* Address to the embedded sampler descriptor buffer.
+    *
+    * This is allocated from nvk_device::heap and has the size
+    * non_variable_descriptor_buffer_size.
+    */
+   uint64_t embedded_samplers_addr;
+
+   /* Bindings in this descriptor set */
+   struct kk_descriptor_set_binding_layout binding[0];
+};
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_descriptor_set_layout, vk.base,
+                               VkDescriptorSetLayout,
+                               VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT)
+
+void kk_descriptor_stride_align_for_type(
+   VkDescriptorType type, const VkMutableDescriptorTypeListEXT *type_list,
+   uint32_t *stride, uint32_t *alignment);
+
+static inline struct kk_descriptor_set_layout *
+vk_to_kk_descriptor_set_layout(struct vk_descriptor_set_layout *layout)
+{
+   return container_of(layout, struct kk_descriptor_set_layout, vk);
+}
+
+#endif /* KK_DESCRIPTOR_SET_LAYOUT */
diff --git a/src/kosmickrisp/vulkan/kk_descriptor_types.h b/src/kosmickrisp/vulkan/kk_descriptor_types.h
new file mode 100644
index 00000000000..5296366c8c6
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_descriptor_types.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright © 2024 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+#ifndef KK_DESCRIPTOR_TYPES
+#define KK_DESCRIPTOR_TYPES 1
+
+#include "kk_private.h"
+
+/* TODO_KOSMICKRISP Reduce size to 32 bytes by moving border to a heap. */
+struct kk_sampled_image_descriptor {
+   uint64_t image_gpu_resource_id;
+   uint16_t sampler_index;
+   uint16_t lod_bias_fp16;
+   uint16_t lod_min_fp16;
+   uint16_t lod_max_fp16;
+   uint32_t has_border;
+   uint32_t pad_to_64_bits;
+   uint32_t border[4];
+   uint64_t pad_to_power_2[3];
+};
+
+static_assert(sizeof(struct kk_sampled_image_descriptor) == 64,
+              "kk_sampled_image_descriptor has no holes");
+
+struct kk_storage_image_descriptor {
+   uint64_t image_gpu_resource_id;
+};
+
+static_assert(sizeof(struct kk_storage_image_descriptor) == 8,
+              "kk_storage_image_descriptor has no holes");
+
+/* This has to match nir_address_format_64bit_bounded_global */
+struct kk_buffer_address {
+   uint64_t base_addr;
+   uint32_t size;
+   uint32_t zero; /* Must be zero! */
+};
+
+static_assert(sizeof(struct kk_buffer_address) == 16,
+              "kk_buffer_address has no holes");
+
+#endif /* KK_DESCRIPTOR_TYPES */
diff --git a/src/kosmickrisp/vulkan/kk_device.c b/src/kosmickrisp/vulkan/kk_device.c
new file mode 100644
index 00000000000..0581b7d4bda
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_device.c
@@ -0,0 +1,348 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_device.h"
+
+#include "kk_cmd_buffer.h"
+#include "kk_entrypoints.h"
+#include "kk_instance.h"
+#include "kk_physical_device.h"
+#include "kk_shader.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+#include "vk_cmd_enqueue_entrypoints.h"
+#include "vk_common_entrypoints.h"
+
+#include "vulkan/wsi/wsi_common.h"
+#include "vk_pipeline_cache.h"
+
+#include <time.h>
+
+DERIVE_HASH_TABLE(mtl_sampler_packed);
+
+static VkResult
+kk_init_sampler_heap(struct kk_device *dev, struct kk_sampler_heap *h)
+{
+   h->ht = mtl_sampler_packed_table_create(NULL);
+   if (!h->ht)
+      return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+   VkResult result = kk_query_table_init(dev, &h->table, 1024);
+
+   if (result != VK_SUCCESS) {
+      ralloc_free(h->ht);
+      return result;
+   }
+
+   simple_mtx_init(&h->lock, mtx_plain);
+   return VK_SUCCESS;
+}
+
+static void
+kk_destroy_sampler_heap(struct kk_device *dev, struct kk_sampler_heap *h)
+{
+   struct hash_entry *entry = _mesa_hash_table_next_entry(h->ht, NULL);
+   while (entry) {
+      struct kk_rc_sampler *sampler = (struct kk_rc_sampler *)entry->data;
+      mtl_release(sampler->handle);
+      entry = _mesa_hash_table_next_entry(h->ht, entry);
+   }
+   kk_query_table_finish(dev, &h->table);
+   ralloc_free(h->ht);
+   simple_mtx_destroy(&h->lock);
+}
+
+static VkResult
+kk_sampler_heap_add_locked(struct kk_device *dev, struct kk_sampler_heap *h,
+                           struct mtl_sampler_packed desc,
+                           struct kk_rc_sampler **out)
+{
+   struct hash_entry *ent = _mesa_hash_table_search(h->ht, &desc);
+   if (ent != NULL) {
+      *out = ent->data;
+
+      assert((*out)->refcount != 0);
+      (*out)->refcount++;
+
+      return VK_SUCCESS;
+   }
+
+   struct kk_rc_sampler *rc = ralloc(h->ht, struct kk_rc_sampler);
+   if (!rc)
+      return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+   mtl_sampler *handle = kk_sampler_create(dev, &desc);
+   uint64_t gpu_id = mtl_sampler_get_gpu_resource_id(handle);
+
+   uint32_t index;
+   VkResult result = kk_query_table_add(dev, &h->table, gpu_id, &index);
+   if (result != VK_SUCCESS) {
+      mtl_release(handle);
+      ralloc_free(rc);
+      return result;
+   }
+
+   *rc = (struct kk_rc_sampler){
+      .key = desc,
+      .handle = handle,
+      .refcount = 1,
+      .index = index,
+   };
+
+   _mesa_hash_table_insert(h->ht, &rc->key, rc);
+   *out = rc;
+
+   return VK_SUCCESS;
+}
+
+VkResult
+kk_sampler_heap_add(struct kk_device *dev, struct mtl_sampler_packed desc,
+                    struct kk_rc_sampler **out)
+{
+   struct kk_sampler_heap *h = &dev->samplers;
+
+   simple_mtx_lock(&h->lock);
+   VkResult result = kk_sampler_heap_add_locked(dev, h, desc, out);
+   simple_mtx_unlock(&h->lock);
+
+   return result;
+}
+
+static void
+kk_sampler_heap_remove_locked(struct kk_device *dev, struct kk_sampler_heap *h,
+                              struct kk_rc_sampler *rc)
+{
+   assert(rc->refcount != 0);
+   rc->refcount--;
+
+   if (rc->refcount == 0) {
+      mtl_release(rc->handle);
+      kk_query_table_remove(dev, &h->table, rc->index);
+      _mesa_hash_table_remove_key(h->ht, &rc->key);
+      ralloc_free(rc);
+   }
+}
+
+void
+kk_sampler_heap_remove(struct kk_device *dev, struct kk_rc_sampler *rc)
+{
+   struct kk_sampler_heap *h = &dev->samplers;
+
+   simple_mtx_lock(&h->lock);
+   kk_sampler_heap_remove_locked(dev, h, rc);
+   simple_mtx_unlock(&h->lock);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_CreateDevice(VkPhysicalDevice physicalDevice,
+                const VkDeviceCreateInfo *pCreateInfo,
+                const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
+{
+   VK_FROM_HANDLE(kk_physical_device, pdev, physicalDevice);
+   VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
+   struct kk_device *dev;
+
+   dev = vk_zalloc2(&pdev->vk.instance->alloc, pAllocator, sizeof(*dev), 8,
+                    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
+   if (!dev)
+      return vk_error(pdev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   /* Fill the dispatch table we will expose to the users */
+   vk_device_dispatch_table_from_entrypoints(
+      &dev->exposed_dispatch_table, &vk_cmd_enqueue_device_entrypoints, true);
+   vk_device_dispatch_table_from_entrypoints(&dev->exposed_dispatch_table,
+                                             &kk_device_entrypoints, false);
+   vk_device_dispatch_table_from_entrypoints(&dev->exposed_dispatch_table,
+                                             &wsi_device_entrypoints, false);
+   vk_device_dispatch_table_from_entrypoints(
+      &dev->exposed_dispatch_table, &vk_common_device_entrypoints, false);
+
+   struct vk_device_dispatch_table dispatch_table;
+   vk_device_dispatch_table_from_entrypoints(&dispatch_table,
+                                             &kk_device_entrypoints, true);
+   vk_device_dispatch_table_from_entrypoints(
+      &dispatch_table, &vk_common_device_entrypoints, false);
+   vk_device_dispatch_table_from_entrypoints(&dispatch_table,
+                                             &wsi_device_entrypoints, false);
+
+   result = vk_device_init(&dev->vk, &pdev->vk, &dispatch_table, pCreateInfo,
+                           pAllocator);
+   if (result != VK_SUCCESS)
+      goto fail_alloc;
+
+   dev->vk.shader_ops = &kk_device_shader_ops;
+   dev->mtl_handle = pdev->mtl_dev_handle;
+   dev->vk.command_buffer_ops = &kk_cmd_buffer_ops;
+   dev->vk.command_dispatch_table = &dev->vk.dispatch_table;
+
+   /* Buffer to use as null descriptor */
+   result = kk_alloc_bo(dev, &dev->vk.base, sizeof(uint64_t) * 8, 8u,
+                        &dev->null_descriptor);
+   if (result != VK_SUCCESS)
+      goto fail_init;
+
+   result =
+      kk_queue_init(dev, &dev->queue, &pCreateInfo->pQueueCreateInfos[0], 0);
+   if (result != VK_SUCCESS)
+      goto fail_vab_memory;
+
+   result = kk_device_init_meta(dev);
+   if (result != VK_SUCCESS)
+      goto fail_mem_cache;
+
+   result = kk_query_table_init(dev, &dev->occlusion_queries,
+                                KK_MAX_OCCLUSION_QUERIES);
+   if (result != VK_SUCCESS)
+      goto fail_meta;
+
+   result = kk_init_sampler_heap(dev, &dev->samplers);
+   if (result != VK_SUCCESS)
+      goto fail_query_table;
+
+   result = kk_device_init_lib(dev);
+   if (result != VK_SUCCESS)
+      goto fail_sampler_heap;
+
+   simple_mtx_init(&dev->user_heap_cache.mutex, mtx_plain);
+   util_dynarray_init(&dev->user_heap_cache.handles, NULL);
+
+   *pDevice = kk_device_to_handle(dev);
+
+   dev->gpu_capture_enabled = kk_get_environment_boolean(KK_ENABLE_GPU_CAPTURE);
+   mtl_start_gpu_capture(dev->mtl_handle);
+
+   return VK_SUCCESS;
+
+fail_sampler_heap:
+   kk_destroy_sampler_heap(dev, &dev->samplers);
+fail_query_table:
+   kk_query_table_finish(dev, &dev->occlusion_queries);
+fail_meta:
+   kk_device_finish_meta(dev);
+fail_mem_cache:
+   kk_queue_finish(dev, &dev->queue);
+fail_vab_memory:
+   kk_destroy_bo(dev, dev->null_descriptor);
+fail_init:
+   vk_device_finish(&dev->vk);
+fail_alloc:
+   vk_free(&dev->vk.alloc, dev);
+   return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_DestroyDevice(VkDevice _device, const VkAllocationCallbacks *pAllocator)
+{
+   VK_FROM_HANDLE(kk_device, dev, _device);
+
+   if (!dev)
+      return;
+
+   /* Meta first since it may destroy Vulkan objects */
+   kk_device_finish_meta(dev);
+
+   util_dynarray_fini(&dev->user_heap_cache.handles);
+   simple_mtx_destroy(&dev->user_heap_cache.mutex);
+   kk_device_finish_lib(dev);
+   kk_query_table_finish(dev, &dev->occlusion_queries);
+   kk_destroy_sampler_heap(dev, &dev->samplers);
+
+   kk_queue_finish(dev, &dev->queue);
+   kk_destroy_bo(dev, dev->null_descriptor);
+   vk_device_finish(&dev->vk);
+
+   if (dev->gpu_capture_enabled) {
+      mtl_stop_gpu_capture();
+   }
+
+   vk_free(&dev->vk.alloc, dev);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_GetCalibratedTimestampsKHR(
+   VkDevice _device, uint32_t timestampCount,
+   const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps,
+   uint64_t *pMaxDeviation)
+{
+   uint64_t max_clock_period = 0;
+   uint64_t begin, end;
+   int d;
+
+#ifdef CLOCK_MONOTONIC_RAW
+   begin = vk_clock_gettime(CLOCK_MONOTONIC_RAW);
+#else
+   begin = vk_clock_gettime(CLOCK_MONOTONIC);
+#endif
+
+   for (d = 0; d < timestampCount; d++) {
+      switch (pTimestampInfos[d].timeDomain) {
+      case VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR:
+         pTimestamps[d] = vk_clock_gettime(CLOCK_MONOTONIC);
+         max_clock_period = MAX2(max_clock_period, 1);
+         break;
+
+#ifdef CLOCK_MONOTONIC_RAW
+      case VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR:
+         pTimestamps[d] = begin;
+         break;
+#endif
+      default:
+         pTimestamps[d] = 0;
+         break;
+      }
+   }
+
+#ifdef CLOCK_MONOTONIC_RAW
+   end = vk_clock_gettime(CLOCK_MONOTONIC_RAW);
+#else
+   end = vk_clock_gettime(CLOCK_MONOTONIC);
+#endif
+
+   *pMaxDeviation = vk_time_max_deviation(begin, end, max_clock_period);
+
+   return VK_SUCCESS;
+}
+
+/* We need to implement this ourselves so we give the fake ones for vk_common_*
+ * to work when executing actual commands */
+static PFN_vkVoidFunction
+kk_device_get_proc_addr(const struct kk_device *device, const char *name)
+{
+   if (device == NULL || name == NULL)
+      return NULL;
+
+   struct vk_instance *instance = device->vk.physical->instance;
+   return vk_device_dispatch_table_get_if_supported(
+      &device->exposed_dispatch_table, name, instance->app_info.api_version,
+      &instance->enabled_extensions, &device->vk.enabled_extensions);
+}
+
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+kk_GetDeviceProcAddr(VkDevice _device, const char *pName)
+{
+   VK_FROM_HANDLE(kk_device, device, _device);
+   return kk_device_get_proc_addr(device, pName);
+}
+
+void
+kk_device_add_user_heap(struct kk_device *dev, mtl_heap *heap)
+{
+   simple_mtx_lock(&dev->user_heap_cache.mutex);
+   util_dynarray_append(&dev->user_heap_cache.handles, mtl_heap *, heap);
+   dev->user_heap_cache.hash += 1u;
+   simple_mtx_unlock(&dev->user_heap_cache.mutex);
+}
+
+void
+kk_device_remove_user_heap(struct kk_device *dev, mtl_heap *heap)
+{
+   simple_mtx_lock(&dev->user_heap_cache.mutex);
+   util_dynarray_delete_unordered(&dev->user_heap_cache.handles, mtl_heap *,
+                                  heap);
+   simple_mtx_unlock(&dev->user_heap_cache.mutex);
+}
diff --git a/src/kosmickrisp/vulkan/kk_device.h b/src/kosmickrisp/vulkan/kk_device.h
new file mode 100644
index 00000000000..50e05e934c9
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_device.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_DEVICE_H
+#define KK_DEVICE_H 1
+
+#include "kk_private.h"
+
+#include "kk_query_table.h"
+#include "kk_queue.h"
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "util/u_dynarray.h"
+
+#include "vk_device.h"
+#include "vk_meta.h"
+#include "vk_queue.h"
+
+struct kk_bo;
+struct kk_physical_device;
+struct vk_pipeline_cache;
+
+enum kk_device_lib_pipeline {
+   KK_LIB_IMM_WRITE = 0,
+   KK_LIB_COPY_QUERY,
+   KK_LIB_TRIANGLE_FAN,
+   KK_LIB_COUNT,
+};
+
+struct kk_user_heap_cache {
+   simple_mtx_t mutex;
+   uint32_t hash;
+   struct util_dynarray handles;
+};
+
+struct mtl_sampler_packed {
+   enum mtl_sampler_address_mode mode_u;
+   enum mtl_sampler_address_mode mode_v;
+   enum mtl_sampler_address_mode mode_w;
+   enum mtl_sampler_border_color border_color;
+
+   enum mtl_sampler_min_mag_filter min_filter;
+   enum mtl_sampler_min_mag_filter mag_filter;
+   enum mtl_sampler_mip_filter mip_filter;
+
+   enum mtl_compare_function compare_func;
+   float min_lod;
+   float max_lod;
+   uint32_t max_anisotropy;
+   bool normalized_coordinates;
+};
+
+struct kk_rc_sampler {
+   struct mtl_sampler_packed key;
+
+   mtl_sampler *handle;
+
+   /* Reference count for this hardware sampler, protected by the heap mutex */
+   uint16_t refcount;
+
+   /* Index of this hardware sampler in the hardware sampler heap */
+   uint16_t index;
+};
+
+struct kk_sampler_heap {
+   simple_mtx_t lock;
+
+   struct kk_query_table table;
+
+   /* Map of agx_sampler_packed to hk_rc_sampler */
+   struct hash_table *ht;
+};
+
+struct kk_device {
+   struct vk_device vk;
+
+   mtl_device *mtl_handle;
+
+   /* Dispatch table exposed to the user. Required since we need to record all
+    * commands due to Metal limitations */
+   struct vk_device_dispatch_table exposed_dispatch_table;
+
+   struct kk_bo *null_descriptor;
+
+   struct kk_sampler_heap samplers;
+   struct kk_query_table occlusion_queries;
+
+   /* Track all heaps the user allocated so we can set them all as resident when
+    * recording as required by Metal. */
+   struct kk_user_heap_cache user_heap_cache;
+
+   mtl_compute_pipeline_state *lib_pipelines[KK_LIB_COUNT];
+
+   struct kk_queue queue;
+
+   struct vk_meta_device meta;
+
+   bool gpu_capture_enabled;
+};
+
+VK_DEFINE_HANDLE_CASTS(kk_device, vk.base, VkDevice, VK_OBJECT_TYPE_DEVICE)
+
+static inline mtl_compute_pipeline_state *
+kk_device_lib_pipeline(const struct kk_device *dev,
+                       enum kk_device_lib_pipeline pipeline)
+{
+   assert(pipeline < KK_LIB_COUNT);
+   return dev->lib_pipelines[pipeline];
+}
+
+static inline struct kk_physical_device *
+kk_device_physical(const struct kk_device *dev)
+{
+   return (struct kk_physical_device *)dev->vk.physical;
+}
+
+VkResult kk_device_init_meta(struct kk_device *dev);
+void kk_device_finish_meta(struct kk_device *dev);
+VkResult kk_device_init_lib(struct kk_device *dev);
+void kk_device_finish_lib(struct kk_device *dev);
+void kk_device_add_user_heap(struct kk_device *dev, mtl_heap *heap);
+void kk_device_remove_user_heap(struct kk_device *dev, mtl_heap *heap);
+
+/* Required to create a sampler */
+mtl_sampler *kk_sampler_create(struct kk_device *dev,
+                               const struct mtl_sampler_packed *packed);
+VkResult kk_sampler_heap_add(struct kk_device *dev,
+                             struct mtl_sampler_packed desc,
+                             struct kk_rc_sampler **out);
+void kk_sampler_heap_remove(struct kk_device *dev, struct kk_rc_sampler *rc);
+
+#endif // KK_DEVICE_H
diff --git a/src/kosmickrisp/vulkan/kk_device_lib.c b/src/kosmickrisp/vulkan/kk_device_lib.c
new file mode 100644
index 00000000000..9d2afbf9e45
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_device_lib.c
@@ -0,0 +1,191 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_device.h"
+
+#include "kk_shader.h"
+
+#include "kkcl.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+#include "nir/nir.h"
+#include "nir/nir_builder.h"
+
+static nir_def *
+load_struct_var(nir_builder *b, nir_variable *var, uint32_t field)
+{
+   nir_deref_instr *deref =
+      nir_build_deref_struct(b, nir_build_deref_var(b, var), field);
+   return nir_load_deref(b, deref);
+}
+
+static nir_shader *
+create_imm_write_shader()
+{
+   nir_builder build = nir_builder_init_simple_shader(MESA_SHADER_COMPUTE, NULL,
+                                                      "kk-meta-imm-write-u64");
+   nir_builder *b = &build;
+
+   struct glsl_struct_field push_fields[] = {
+      {.type = glsl_uint64_t_type(), .name = "buffer_address", .offset = 0},
+   };
+   const struct glsl_type *push_iface_type = glsl_interface_type(
+      push_fields, ARRAY_SIZE(push_fields), GLSL_INTERFACE_PACKING_STD140,
+      false /* row_major */, "push");
+   nir_variable *push = nir_variable_create(b->shader, nir_var_mem_push_const,
+                                            push_iface_type, "push");
+
+   b->shader->info.workgroup_size[0] = 1;
+   b->shader->info.workgroup_size[1] = 1;
+   b->shader->info.workgroup_size[2] = 1;
+
+   libkk_write_u64(b, load_struct_var(b, push, 0));
+
+   return build.shader;
+}
+
+static nir_shader *
+create_copy_query_shader()
+{
+   nir_builder build = nir_builder_init_simple_shader(MESA_SHADER_COMPUTE, NULL,
+                                                      "kk-meta-copy-queries");
+   nir_builder *b = &build;
+
+   struct glsl_struct_field push_fields[] = {
+      {.type = glsl_uint64_t_type(), .name = "availability", .offset = 0},
+      {.type = glsl_uint64_t_type(), .name = "results", .offset = 8},
+      {.type = glsl_uint64_t_type(), .name = "indices", .offset = 16},
+      {.type = glsl_uint64_t_type(), .name = "dst_addr", .offset = 24},
+      {.type = glsl_uint64_t_type(), .name = "dst_stride", .offset = 32},
+      {.type = glsl_uint_type(), .name = "first_query", .offset = 40},
+      {.type = glsl_uint_type(), .name = "flags", .offset = 44},
+      {.type = glsl_uint16_t_type(), .name = "reports_per_query", .offset = 48},
+   };
+   /* TODO_KOSMICKRISP Don't use push constants and directly bind the buffer to
+    * the binding index. This requires compiler work first to remove the
+    * hard-coded buffer0 value. Same applies to other creation functions.
+    */
+   const struct glsl_type *push_iface_type = glsl_interface_type(
+      push_fields, ARRAY_SIZE(push_fields), GLSL_INTERFACE_PACKING_STD140,
+      false /* row_major */, "push");
+   nir_variable *push = nir_variable_create(b->shader, nir_var_mem_push_const,
+                                            push_iface_type, "push");
+
+   b->shader->info.workgroup_size[0] = 1;
+   b->shader->info.workgroup_size[1] = 1;
+   b->shader->info.workgroup_size[2] = 1;
+
+   libkk_copy_queries(b, load_struct_var(b, push, 0),
+                      load_struct_var(b, push, 1), load_struct_var(b, push, 2),
+                      load_struct_var(b, push, 3), load_struct_var(b, push, 4),
+                      load_struct_var(b, push, 5), load_struct_var(b, push, 6),
+                      load_struct_var(b, push, 7));
+
+   return build.shader;
+}
+
+static nir_shader *
+create_triangle_fan_shader()
+{
+   nir_builder build = nir_builder_init_simple_shader(
+      MESA_SHADER_COMPUTE, NULL, "kk-device-unroll-geomtry-and-restart");
+   nir_builder *b = &build;
+
+   struct glsl_struct_field push_fields[] = {
+      {.type = glsl_uint64_t_type(), .name = "index_buffer", .offset = 0},
+      {.type = glsl_uint64_t_type(), .name = "out_ptr", .offset = 8},
+      {.type = glsl_uint64_t_type(), .name = "indirect_in", .offset = 16},
+      {.type = glsl_uint64_t_type(), .name = "indirect_out", .offset = 24},
+      {.type = glsl_uint_type(), .name = "restart_index", .offset = 32},
+      {.type = glsl_uint_type(), .name = "index_buffer_size_el", .offset = 36},
+      {.type = glsl_uint_type(), .name = "in_el_size_B,", .offset = 40},
+      {.type = glsl_uint_type(), .name = "out_el_size_B,", .offset = 44},
+      {.type = glsl_uint_type(), .name = "flatshade_first", .offset = 48},
+      {.type = glsl_uint_type(), .name = "mode", .offset = 52},
+   };
+   const struct glsl_type *push_iface_type = glsl_interface_type(
+      push_fields, ARRAY_SIZE(push_fields), GLSL_INTERFACE_PACKING_STD140,
+      false /* row_major */, "push");
+   nir_variable *push = nir_variable_create(b->shader, nir_var_mem_push_const,
+                                            push_iface_type, "push");
+
+   b->shader->info.workgroup_size[0] = 1;
+   b->shader->info.workgroup_size[1] = 1;
+   b->shader->info.workgroup_size[2] = 1;
+
+   libkk_unroll_geometry_and_restart(
+      b, load_struct_var(b, push, 0), load_struct_var(b, push, 1),
+      load_struct_var(b, push, 2), load_struct_var(b, push, 3),
+      load_struct_var(b, push, 4), load_struct_var(b, push, 5),
+      load_struct_var(b, push, 6), load_struct_var(b, push, 7),
+      load_struct_var(b, push, 8), load_struct_var(b, push, 9));
+
+   return build.shader;
+}
+
+static struct {
+   enum kk_device_lib_pipeline ndx;
+   nir_shader *(*create_shader_fn)();
+} lib_shaders[KK_LIB_COUNT] = {
+   {KK_LIB_IMM_WRITE, create_imm_write_shader},
+   {KK_LIB_COPY_QUERY, create_copy_query_shader},
+   {KK_LIB_TRIANGLE_FAN, create_triangle_fan_shader},
+};
+static_assert(ARRAY_SIZE(lib_shaders) == KK_LIB_COUNT,
+              "Device lib shader count and created shader count mismatch");
+
+VkResult
+kk_device_init_lib(struct kk_device *dev)
+{
+   VkResult result = VK_SUCCESS;
+   uint32_t i = 0u;
+   for (; i < KK_LIB_COUNT; ++i) {
+      nir_shader *s = lib_shaders[i].create_shader_fn();
+      if (!s)
+         goto fail;
+
+      struct kk_shader *shader = NULL;
+      result = kk_compile_nir_shader(dev, s, &dev->vk.alloc, &shader);
+      if (result != VK_SUCCESS)
+         goto fail;
+
+      mtl_library *library = mtl_new_library(dev->mtl_handle, shader->msl_code);
+      if (library == NULL)
+         goto fail;
+
+      uint32_t local_size_threads = shader->info.cs.local_size.x *
+                                    shader->info.cs.local_size.y *
+                                    shader->info.cs.local_size.z;
+      mtl_function *function =
+         mtl_new_function_with_name(library, shader->entrypoint_name);
+      dev->lib_pipelines[i] = mtl_new_compute_pipeline_state(
+         dev->mtl_handle, function, local_size_threads);
+      mtl_release(function);
+      mtl_release(library);
+
+      /* We no longer need the shader. Although it may be useful to keep it
+       * alive for the info maybe? */
+      shader->vk.ops->destroy(&dev->vk, &shader->vk, &dev->vk.alloc);
+
+      if (!dev->lib_pipelines[i])
+         goto fail;
+   }
+
+   return result;
+
+fail:
+   for (uint32_t j = 0u; j < i; ++j)
+      mtl_release(dev->lib_pipelines[j]);
+   return vk_error(dev, result);
+}
+
+void
+kk_device_finish_lib(struct kk_device *dev)
+{
+   for (uint32_t i = 0; i < KK_LIB_COUNT; ++i)
+      mtl_release(dev->lib_pipelines[i]);
+}
diff --git a/src/kosmickrisp/vulkan/kk_device_memory.c b/src/kosmickrisp/vulkan/kk_device_memory.c
new file mode 100644
index 00000000000..e020aa979f4
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_device_memory.c
@@ -0,0 +1,258 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_device_memory.h"
+
+#include "kk_device.h"
+#include "kk_entrypoints.h"
+#include "kk_physical_device.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+#include "vulkan/vulkan_metal.h"
+
+#include "util/u_atomic.h"
+#include "util/u_memory.h"
+
+#include <inttypes.h>
+#include <sys/mman.h>
+
+/* Supports mtlheap only */
+const VkExternalMemoryProperties kk_mtlheap_mem_props = {
+   .externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT |
+                             VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
+   .exportFromImportedHandleTypes =
+      VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT,
+   .compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT,
+};
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_GetMemoryMetalHandlePropertiesEXT(
+   VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
+   const void *pHandle,
+   VkMemoryMetalHandlePropertiesEXT *pMemoryMetalHandleProperties)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   struct kk_physical_device *pdev = kk_device_physical(dev);
+
+   /* We only support heaps since that's the backing for all our memory and
+    * simplifies implementation */
+   switch (handleType) {
+   case VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT:
+      break;
+   default:
+      return vk_error(dev, VK_ERROR_INVALID_EXTERNAL_HANDLE);
+   }
+   pMemoryMetalHandleProperties->memoryTypeBits =
+      BITFIELD_MASK(pdev->mem_type_count);
+
+   return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_METAL_EXT */
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_AllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
+                  const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMem)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   struct kk_physical_device *pdev = kk_device_physical(dev);
+   struct kk_device_memory *mem;
+   VkResult result = VK_SUCCESS;
+   const VkImportMemoryMetalHandleInfoEXT *metal_info = vk_find_struct_const(
+      pAllocateInfo->pNext, IMPORT_MEMORY_METAL_HANDLE_INFO_EXT);
+   const VkMemoryType *type = &pdev->mem_types[pAllocateInfo->memoryTypeIndex];
+
+   // TODO_KOSMICKRISP Do the actual memory allocation with alignment requirements
+   uint32_t alignment = (1ULL << 12);
+
+   const uint64_t aligned_size =
+      align64(pAllocateInfo->allocationSize, alignment);
+
+   mem = vk_device_memory_create(&dev->vk, pAllocateInfo, pAllocator,
+                                 sizeof(*mem));
+   if (!mem)
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   if (metal_info && metal_info->handleType) {
+      /* We only support heaps since that's the backing for all our memory and
+       * simplifies implementation */
+      assert(metal_info->handleType ==
+             VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT);
+      mem->bo = CALLOC_STRUCT(kk_bo);
+      if (!mem->bo) {
+         result = vk_errorf(&dev->vk.base, VK_ERROR_OUT_OF_DEVICE_MEMORY, "%m");
+         goto fail_alloc;
+      }
+      mem->bo->mtl_handle = mtl_retain(metal_info->handle);
+      mem->bo->map =
+         mtl_new_buffer_with_length(mem->bo->mtl_handle, mem->vk.size, 0u);
+      mem->bo->gpu = mtl_buffer_get_gpu_address(mem->bo->map);
+      mem->bo->cpu = mtl_get_contents(mem->bo->map);
+      mem->bo->size_B = mtl_heap_get_size(mem->bo->mtl_handle);
+   } else {
+      result =
+         kk_alloc_bo(dev, &dev->vk.base, aligned_size, alignment, &mem->bo);
+      if (result != VK_SUCCESS)
+         goto fail_alloc;
+   }
+
+   struct kk_memory_heap *heap = &pdev->mem_heaps[type->heapIndex];
+   p_atomic_add(&heap->used, mem->bo->size_B);
+
+   kk_device_add_user_heap(dev, mem->bo->mtl_handle);
+
+   *pMem = kk_device_memory_to_handle(mem);
+
+   return VK_SUCCESS;
+
+fail_alloc:
+   vk_device_memory_destroy(&dev->vk, pAllocator, &mem->vk);
+   return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_FreeMemory(VkDevice device, VkDeviceMemory _mem,
+              const VkAllocationCallbacks *pAllocator)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_device_memory, mem, _mem);
+   struct kk_physical_device *pdev = kk_device_physical(dev);
+
+   if (!mem)
+      return;
+
+   kk_device_remove_user_heap(dev, mem->bo->mtl_handle);
+
+   const VkMemoryType *type = &pdev->mem_types[mem->vk.memory_type_index];
+   struct kk_memory_heap *heap = &pdev->mem_heaps[type->heapIndex];
+   p_atomic_add(&heap->used, -((int64_t)mem->bo->size_B));
+
+   kk_destroy_bo(dev, mem->bo);
+
+   vk_device_memory_destroy(&dev->vk, pAllocator, &mem->vk);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_MapMemory2KHR(VkDevice device, const VkMemoryMapInfoKHR *pMemoryMapInfo,
+                 void **ppData)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_device_memory, mem, pMemoryMapInfo->memory);
+   VkResult result = VK_SUCCESS;
+
+   if (mem == NULL) {
+      *ppData = NULL;
+      return VK_SUCCESS;
+   }
+
+   const VkDeviceSize offset = pMemoryMapInfo->offset;
+   const VkDeviceSize size = vk_device_memory_range(
+      &mem->vk, pMemoryMapInfo->offset, pMemoryMapInfo->size);
+
+   /* From the Vulkan spec version 1.0.32 docs for MapMemory:
+    *
+    *  * If size is not equal to VK_WHOLE_SIZE, size must be greater than 0
+    *    assert(size != 0);
+    *  * If size is not equal to VK_WHOLE_SIZE, size must be less than or
+    *    equal to the size of the memory minus offset
+    */
+   assert(size > 0);
+   assert(offset + size <= mem->bo->size_B);
+
+   if (size != (size_t)size) {
+      return vk_errorf(dev, VK_ERROR_MEMORY_MAP_FAILED,
+                       "requested size 0x%" PRIx64 " does not fit in %u bits",
+                       size, (unsigned)(sizeof(size_t) * 8));
+   }
+
+   /* From the Vulkan 1.2.194 spec:
+    *
+    *    "memory must not be currently host mapped"
+    */
+   if (mem->map != NULL) {
+      return vk_errorf(dev, VK_ERROR_MEMORY_MAP_FAILED,
+                       "Memory object already mapped.");
+   }
+
+   // TODO_KOSMICKRISP Use mmap here to so we can support VK_EXT_map_memory_placed
+   mem->map = mem->bo->cpu;
+
+   *ppData = mem->map + offset;
+
+   return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_UnmapMemory2KHR(VkDevice device,
+                   const VkMemoryUnmapInfoKHR *pMemoryUnmapInfo)
+{
+   VK_FROM_HANDLE(kk_device_memory, mem, pMemoryUnmapInfo->memory);
+
+   if (mem == NULL)
+      return VK_SUCCESS;
+
+   // TODO_KOSMICKRISP Use unmap here to so we can support
+   // VK_EXT_map_memory_placed
+   mem->map = NULL;
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                           const VkMappedMemoryRange *pMemoryRanges)
+{
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                                const VkMappedMemoryRange *pMemoryRanges)
+{
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory _mem,
+                             VkDeviceSize *pCommittedMemoryInBytes)
+{
+   VK_FROM_HANDLE(kk_device_memory, mem, _mem);
+
+   *pCommittedMemoryInBytes = mem->bo->size_B;
+}
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_GetMemoryMetalHandleEXT(
+   VkDevice device, const VkMemoryGetMetalHandleInfoEXT *pGetMetalHandleInfo,
+   void **pHandle)
+{
+   /* We only support heaps since that's the backing for all our memory and
+    * simplifies implementation */
+   assert(pGetMetalHandleInfo->handleType ==
+          VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT);
+   VK_FROM_HANDLE(kk_device_memory, mem, pGetMetalHandleInfo->memory);
+
+   /* From the Vulkan spec of vkGetMemoryMetalHandleEXT:
+    *
+    *    "Unless the app retains the handle object returned by the call,
+    *     the lifespan will be the same as the associated VkDeviceMemory"
+    */
+   *pHandle = mem->bo->mtl_handle;
+   return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_METAL_EXT */
+
+VKAPI_ATTR uint64_t VKAPI_CALL
+kk_GetDeviceMemoryOpaqueCaptureAddress(
+   UNUSED VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
+{
+   VK_FROM_HANDLE(kk_device_memory, mem, pInfo->memory);
+
+   return mem->bo->gpu;
+}
diff --git a/src/kosmickrisp/vulkan/kk_device_memory.h b/src/kosmickrisp/vulkan/kk_device_memory.h
new file mode 100644
index 00000000000..44ced28aa67
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_device_memory.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_MEMORY_H
+#define KK_MEMORY_H 1
+
+#include "kk_private.h"
+
+#include "kk_bo.h"
+
+#include "vk_device_memory.h"
+
+#include "util/list.h"
+
+struct kk_device_memory {
+   struct vk_device_memory vk;
+   struct kk_bo *bo;
+   void *map;
+};
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_device_memory, vk.base, VkDeviceMemory,
+                               VK_OBJECT_TYPE_DEVICE_MEMORY)
+
+extern const VkExternalMemoryProperties kk_mtlheap_mem_props;
+
+#endif // KK_MEMORY_H
diff --git a/src/kosmickrisp/vulkan/kk_encoder.c b/src/kosmickrisp/vulkan/kk_encoder.c
new file mode 100644
index 00000000000..ca083674939
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_encoder.c
@@ -0,0 +1,480 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_encoder.h"
+
+#include "kk_bo.h"
+#include "kk_cmd_buffer.h"
+#include "kk_queue.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+#include "kosmickrisp/bridge/vk_to_mtl_map.h"
+
+#include "cl/kk_query.h"
+
+static void
+kk_encoder_start_internal(struct kk_encoder_internal *encoder,
+                          mtl_device *device, mtl_command_queue *queue)
+{
+   encoder->cmd_buffer = mtl_new_command_buffer(queue);
+   encoder->last_used = KK_ENC_NONE;
+   util_dynarray_init(&encoder->fences, NULL);
+}
+
+VkResult
+kk_encoder_init(mtl_device *device, struct kk_queue *queue,
+                struct kk_encoder **encoder)
+{
+   assert(encoder && device && queue);
+   struct kk_encoder *enc = (struct kk_encoder *)malloc(sizeof(*enc));
+   if (!enc)
+      return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+   memset(enc, 0u, sizeof(*enc));
+   enc->dev = device;
+   kk_encoder_start_internal(&enc->main, device, queue->main.mtl_handle);
+   kk_encoder_start_internal(&enc->pre_gfx, device, queue->pre_gfx.mtl_handle);
+   enc->event = mtl_new_event(device);
+   util_dynarray_init(&enc->imm_writes, NULL);
+   util_dynarray_init(&enc->resident_buffers, NULL);
+   util_dynarray_init(&enc->copy_query_pool_result_infos, NULL);
+
+   *encoder = enc;
+   return VK_SUCCESS;
+}
+
+mtl_render_encoder *
+kk_encoder_start_render(struct kk_cmd_buffer *cmd,
+                        mtl_render_pass_descriptor *descriptor,
+                        uint32_t view_mask)
+{
+   struct kk_encoder *encoder = cmd->encoder;
+   /* We must not already be in a render encoder */
+   assert(encoder->main.last_used != KK_ENC_RENDER ||
+          encoder->main.encoder == NULL);
+   if (encoder->main.last_used != KK_ENC_RENDER) {
+      kk_encoder_signal_fence_and_end(cmd);
+
+      /* Before we start any render operation we need to ensure we have the
+       * requried signals to insert pre_gfx execution before the render encoder
+       * in case we need to insert commands to massage input data for things
+       * like triangle fans. For this, we signal the value pre_gfx will wait on,
+       * and we wait on the value pre_gfx will signal once completed.
+       */
+      encoder->signal_value_pre_gfx = encoder->event_value;
+      mtl_encode_signal_event(encoder->main.cmd_buffer, encoder->event,
+                              ++encoder->event_value);
+      encoder->wait_value_pre_gfx = encoder->event_value;
+      mtl_encode_wait_for_event(encoder->main.cmd_buffer, encoder->event,
+                                ++encoder->event_value);
+
+      encoder->main.encoder = mtl_new_render_command_encoder_with_descriptor(
+         encoder->main.cmd_buffer, descriptor);
+      if (encoder->main.wait_fence) {
+         mtl_render_wait_for_fence(
+            encoder->main.encoder,
+            util_dynarray_top(&encoder->main.fences, mtl_fence *));
+         encoder->main.wait_fence = false;
+      }
+
+      uint32_t layer_ids[KK_MAX_MULTIVIEW_VIEW_COUNT] = {};
+      uint32_t count = 0u;
+      u_foreach_bit(id, view_mask)
+         layer_ids[count++] = id;
+      if (view_mask == 0u) {
+         layer_ids[count++] = 0;
+      }
+      mtl_set_vertex_amplification_count(encoder->main.encoder, layer_ids,
+                                         count);
+      encoder->main.user_heap_hash = UINT32_MAX;
+
+      /* Bind read only data aka samplers' argument buffer. */
+      struct kk_device *dev = kk_cmd_buffer_device(cmd);
+      mtl_set_vertex_buffer(encoder->main.encoder, dev->samplers.table.bo->map,
+                            0u, 1u);
+      mtl_set_fragment_buffer(encoder->main.encoder,
+                              dev->samplers.table.bo->map, 0u, 1u);
+   }
+   encoder->main.last_used = KK_ENC_RENDER;
+   return encoder->main.encoder;
+}
+
+mtl_compute_encoder *
+kk_encoder_start_compute(struct kk_cmd_buffer *cmd)
+{
+   struct kk_encoder *encoder = cmd->encoder;
+   /* We must not already be in a render encoder */
+   assert(encoder->main.last_used != KK_ENC_RENDER ||
+          encoder->main.encoder == NULL);
+   struct kk_encoder_internal *enc = &encoder->main;
+   if (encoder->main.last_used != KK_ENC_COMPUTE) {
+      kk_encoder_signal_fence_and_end(cmd);
+      enc->encoder = mtl_new_compute_command_encoder(enc->cmd_buffer);
+      if (enc->wait_fence) {
+         mtl_compute_wait_for_fence(
+            enc->encoder, util_dynarray_top(&enc->fences, mtl_fence *));
+         enc->wait_fence = false;
+      }
+      enc->user_heap_hash = UINT32_MAX;
+
+      /* Bind read only data aka samplers' argument buffer. */
+      struct kk_device *dev = kk_cmd_buffer_device(cmd);
+      mtl_compute_set_buffer(enc->encoder, dev->samplers.table.bo->map, 0u, 1u);
+   }
+   encoder->main.last_used = KK_ENC_COMPUTE;
+   return encoder->main.encoder;
+}
+
+mtl_compute_encoder *
+kk_encoder_start_blit(struct kk_cmd_buffer *cmd)
+{
+   struct kk_encoder *encoder = cmd->encoder;
+   /* We must not already be in a render encoder */
+   assert(encoder->main.last_used != KK_ENC_RENDER ||
+          encoder->main.encoder == NULL);
+   struct kk_encoder_internal *enc = &encoder->main;
+   if (encoder->main.last_used != KK_ENC_BLIT) {
+      kk_encoder_signal_fence_and_end(cmd);
+      enc->encoder = mtl_new_blit_command_encoder(enc->cmd_buffer);
+      if (enc->wait_fence) {
+         mtl_compute_wait_for_fence(
+            enc->encoder, util_dynarray_top(&enc->fences, mtl_fence *));
+         enc->wait_fence = false;
+      }
+   }
+   encoder->main.last_used = KK_ENC_BLIT;
+   return encoder->main.encoder;
+}
+
+void
+kk_encoder_end(struct kk_cmd_buffer *cmd)
+{
+   assert(cmd);
+
+   kk_encoder_signal_fence_and_end(cmd);
+
+   /* Let remaining render encoders run without waiting since we are done */
+   mtl_encode_signal_event(cmd->encoder->pre_gfx.cmd_buffer,
+                           cmd->encoder->event, cmd->encoder->event_value);
+}
+
+struct kk_imm_write_push {
+   uint64_t buffer_address;
+   uint32_t count;
+};
+
+void
+upload_queue_writes(struct kk_cmd_buffer *cmd)
+{
+   struct kk_encoder *enc = cmd->encoder;
+
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+   uint32_t count = util_dynarray_num_elements(&enc->imm_writes, uint64_t) / 2u;
+   if (count != 0) {
+      mtl_compute_encoder *compute = kk_compute_encoder(cmd);
+      struct kk_bo *bo = kk_cmd_allocate_buffer(cmd, enc->imm_writes.size, 8u);
+      /* kk_cmd_allocate_buffer sets the cmd buffer error so we can just exit */
+      if (!bo)
+         return;
+      memcpy(bo->cpu, enc->imm_writes.data, enc->imm_writes.size);
+      uint32_t buffer_count =
+         util_dynarray_num_elements(&enc->resident_buffers, mtl_buffer *);
+      mtl_compute_use_resource(compute, bo->map, MTL_RESOURCE_USAGE_READ);
+      mtl_compute_use_resources(
+         compute, enc->resident_buffers.data, buffer_count,
+         MTL_RESOURCE_USAGE_READ | MTL_RESOURCE_USAGE_WRITE);
+      struct kk_imm_write_push push_data = {
+         .buffer_address = bo->gpu,
+         .count = count,
+      };
+      kk_cmd_dispatch_pipeline(cmd, compute,
+                               kk_device_lib_pipeline(dev, KK_LIB_IMM_WRITE),
+                               &push_data, sizeof(push_data), count, 1, 1);
+      enc->resident_buffers.size = 0u;
+      enc->imm_writes.size = 0u;
+   }
+
+   count = util_dynarray_num_elements(&enc->copy_query_pool_result_infos,
+                                      struct kk_copy_query_pool_results_info);
+   if (count != 0u) {
+      mtl_compute_encoder *compute = kk_compute_encoder(cmd);
+      uint32_t buffer_count =
+         util_dynarray_num_elements(&enc->resident_buffers, mtl_buffer *);
+      mtl_compute_use_resources(
+         compute, enc->resident_buffers.data, buffer_count,
+         MTL_RESOURCE_USAGE_READ | MTL_RESOURCE_USAGE_WRITE);
+
+      for (uint32_t i = 0u; i < count; ++i) {
+         struct kk_copy_query_pool_results_info *push_data =
+            util_dynarray_element(&enc->copy_query_pool_result_infos,
+                                  struct kk_copy_query_pool_results_info, i);
+
+         kk_cmd_dispatch_pipeline(
+            cmd, compute, kk_device_lib_pipeline(dev, KK_LIB_COPY_QUERY),
+            push_data, sizeof(*push_data), push_data->query_count, 1, 1);
+      }
+      enc->resident_buffers.size = 0u;
+      enc->copy_query_pool_result_infos.size = 0u;
+   }
+
+   /* All immediate write done, reset encoder */
+   kk_encoder_signal_fence_and_end(cmd);
+}
+
+void
+kk_encoder_signal_fence_and_end(struct kk_cmd_buffer *cmd)
+{
+   struct kk_encoder *encoder = cmd->encoder;
+   /* End pre_gfx */
+   if (encoder->pre_gfx.encoder) {
+      mtl_end_encoding(encoder->pre_gfx.encoder);
+      mtl_release(encoder->pre_gfx.encoder);
+      encoder->pre_gfx.encoder = NULL;
+
+      /* We can start rendering once all pre-graphics work is done */
+      mtl_encode_signal_event(encoder->pre_gfx.cmd_buffer, encoder->event,
+                              encoder->event_value);
+   }
+
+   assert(encoder);
+   enum kk_encoder_type type = encoder->main.last_used;
+   struct kk_encoder_internal *enc = kk_encoder_get_internal(encoder, type);
+   if (!enc || !enc->encoder)
+      return;
+
+   mtl_fence *fence = mtl_new_fence(encoder->dev);
+   switch (type) {
+   case KK_ENC_RENDER:
+      mtl_render_update_fence(enc->encoder, fence);
+      break;
+   case KK_ENC_COMPUTE:
+      mtl_compute_update_fence(enc->encoder, fence);
+      break;
+   case KK_ENC_BLIT:
+      mtl_blit_update_fence(enc->encoder, fence);
+      break;
+   default:
+      assert(0);
+      break;
+   }
+
+   mtl_end_encoding(enc->encoder);
+   mtl_release(enc->encoder);
+   enc->encoder = NULL;
+   enc->last_used = KK_ENC_NONE;
+   enc->wait_fence = true;
+   util_dynarray_append(&enc->fences, mtl_fence *, fence);
+
+   if (cmd->drawable) {
+      mtl_present_drawable(enc->cmd_buffer, cmd->drawable);
+      cmd->drawable = NULL;
+   }
+   upload_queue_writes(cmd);
+}
+
+static void
+kk_post_execution_release_internal(struct kk_encoder_internal *encoder)
+{
+   mtl_release(encoder->cmd_buffer);
+   util_dynarray_foreach(&encoder->fences, mtl_fence *, fence)
+      mtl_release(*fence);
+   util_dynarray_fini(&encoder->fences);
+}
+
+static void
+kk_post_execution_release(void *data)
+{
+   struct kk_encoder *encoder = data;
+   kk_post_execution_release_internal(&encoder->main);
+   kk_post_execution_release_internal(&encoder->pre_gfx);
+   mtl_release(encoder->event);
+   util_dynarray_fini(&encoder->imm_writes);
+   util_dynarray_fini(&encoder->resident_buffers);
+   util_dynarray_fini(&encoder->copy_query_pool_result_infos);
+   free(encoder);
+}
+
+void
+kk_encoder_submit(struct kk_encoder *encoder)
+{
+   assert(encoder);
+
+   mtl_add_completed_handler(encoder->main.cmd_buffer,
+                             kk_post_execution_release, encoder);
+
+   mtl_command_buffer_commit(encoder->pre_gfx.cmd_buffer);
+   mtl_command_buffer_commit(encoder->main.cmd_buffer);
+}
+
+mtl_render_encoder *
+kk_render_encoder(struct kk_cmd_buffer *cmd)
+{
+   struct kk_encoder *encoder = cmd->encoder;
+   /* Render encoders are created at vkBeginRendering only */
+   assert(encoder->main.last_used == KK_ENC_RENDER && encoder->main.encoder);
+   return (mtl_render_encoder *)encoder->main.encoder;
+}
+
+mtl_compute_encoder *
+kk_compute_encoder(struct kk_cmd_buffer *cmd)
+{
+   struct kk_encoder *encoder = cmd->encoder;
+   return encoder->main.last_used == KK_ENC_COMPUTE
+             ? (mtl_blit_encoder *)encoder->main.encoder
+             : kk_encoder_start_compute(cmd);
+}
+
+mtl_blit_encoder *
+kk_blit_encoder(struct kk_cmd_buffer *cmd)
+{
+   struct kk_encoder *encoder = cmd->encoder;
+   return encoder->main.last_used == KK_ENC_BLIT
+             ? (mtl_blit_encoder *)encoder->main.encoder
+             : kk_encoder_start_blit(cmd);
+}
+
+struct kk_encoder_internal *
+kk_encoder_get_internal(struct kk_encoder *encoder, enum kk_encoder_type type)
+{
+   switch (type) {
+   case KK_ENC_NONE:
+      assert(encoder->main.last_used == KK_ENC_NONE);
+      return NULL;
+   case KK_ENC_RENDER:
+      assert(encoder->main.last_used == KK_ENC_RENDER);
+      return &encoder->main;
+   case KK_ENC_COMPUTE:
+      assert(encoder->main.last_used == KK_ENC_COMPUTE);
+      return &encoder->main;
+   case KK_ENC_BLIT:
+      assert(encoder->main.last_used == KK_ENC_BLIT);
+      return &encoder->main;
+   default:
+      assert(0);
+      return NULL;
+   }
+}
+
+static mtl_compute_encoder *
+kk_encoder_pre_gfx_encoder(struct kk_encoder *encoder)
+{
+   if (!encoder->pre_gfx.encoder) {
+      /* Fast-forward all previous render encoders and wait for the last one */
+      mtl_encode_signal_event(encoder->pre_gfx.cmd_buffer, encoder->event,
+                              encoder->signal_value_pre_gfx);
+      mtl_encode_wait_for_event(encoder->pre_gfx.cmd_buffer, encoder->event,
+                                encoder->wait_value_pre_gfx);
+      encoder->pre_gfx.encoder =
+         mtl_new_compute_command_encoder(encoder->pre_gfx.cmd_buffer);
+   }
+
+   return encoder->pre_gfx.encoder;
+}
+
+struct kk_triangle_fan_info {
+   uint64_t index_buffer;
+   uint64_t out_ptr;
+   uint64_t in_draw;
+   uint64_t out_draw;
+   uint32_t restart_index;
+   uint32_t index_buffer_size_el;
+   uint32_t in_el_size_B;
+   uint32_t out_el_size_B;
+   uint32_t flatshade_first;
+   uint32_t mode;
+};
+
+static void
+kk_encoder_render_triangle_fan_common(struct kk_cmd_buffer *cmd,
+                                      struct kk_triangle_fan_info *info,
+                                      mtl_buffer *indirect, mtl_buffer *index,
+                                      uint32_t index_count,
+                                      uint32_t in_el_size_B,
+                                      uint32_t out_el_size_B)
+{
+   uint32_t index_buffer_size_B = index_count * out_el_size_B;
+   uint32_t buffer_size_B =
+      sizeof(VkDrawIndexedIndirectCommand) + index_buffer_size_B;
+   struct kk_bo *index_buffer =
+      kk_cmd_allocate_buffer(cmd, buffer_size_B, out_el_size_B);
+
+   if (!index_buffer)
+      return;
+
+   info->out_ptr = index_buffer->gpu + sizeof(VkDrawIndexedIndirectCommand);
+   info->out_draw = index_buffer->gpu;
+   info->in_el_size_B = in_el_size_B;
+   info->out_el_size_B = out_el_size_B;
+   info->flatshade_first = true;
+   mtl_compute_encoder *encoder = kk_encoder_pre_gfx_encoder(cmd->encoder);
+   if (index)
+      mtl_compute_use_resource(encoder, index, MTL_RESOURCE_USAGE_READ);
+   mtl_compute_use_resource(encoder, indirect, MTL_RESOURCE_USAGE_READ);
+   mtl_compute_use_resource(encoder, index_buffer->map,
+                            MTL_RESOURCE_USAGE_WRITE);
+
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+   kk_cmd_dispatch_pipeline(cmd, encoder,
+                            kk_device_lib_pipeline(dev, KK_LIB_TRIANGLE_FAN),
+                            info, sizeof(*info), 1u, 1u, 1u);
+
+   enum mtl_index_type index_type =
+      index_size_in_bytes_to_mtl_index_type(out_el_size_B);
+   mtl_render_encoder *enc = kk_render_encoder(cmd);
+   mtl_draw_indexed_primitives_indirect(
+      enc, cmd->state.gfx.primitive_type, index_type, index_buffer->map,
+      sizeof(VkDrawIndexedIndirectCommand), index_buffer->map, 0u);
+}
+
+void
+kk_encoder_render_triangle_fan_indirect(struct kk_cmd_buffer *cmd,
+                                        mtl_buffer *indirect, uint64_t offset)
+{
+   enum mesa_prim mode = cmd->state.gfx.prim;
+   uint32_t decomposed_index_count =
+      u_decomposed_prims_for_vertices(mode, cmd->state.gfx.vb.max_vertices) *
+      mesa_vertices_per_prim(mode);
+   uint32_t el_size_B = decomposed_index_count < UINT16_MAX ? 2u : 4u;
+   struct kk_triangle_fan_info info = {
+      .in_draw = mtl_buffer_get_gpu_address(indirect) + offset,
+      .restart_index = UINT32_MAX, /* No restart */
+      .mode = mode,
+   };
+   kk_encoder_render_triangle_fan_common(
+      cmd, &info, indirect, NULL, decomposed_index_count, el_size_B, el_size_B);
+}
+
+void
+kk_encoder_render_triangle_fan_indexed_indirect(struct kk_cmd_buffer *cmd,
+                                                mtl_buffer *indirect,
+                                                uint64_t offset,
+                                                bool increase_el_size)
+{
+   uint32_t el_size_B = cmd->state.gfx.index.bytes_per_index;
+
+   enum mesa_prim mode = cmd->state.gfx.prim;
+   uint32_t max_index_count =
+      (mtl_buffer_get_length(cmd->state.gfx.index.handle) -
+       cmd->state.gfx.index.offset) /
+      el_size_B;
+   uint32_t decomposed_index_count =
+      u_decomposed_prims_for_vertices(mode, max_index_count) *
+      mesa_vertices_per_prim(mode);
+
+   struct kk_triangle_fan_info info = {
+      .index_buffer = mtl_buffer_get_gpu_address(cmd->state.gfx.index.handle) +
+                      cmd->state.gfx.index.offset,
+      .in_draw = mtl_buffer_get_gpu_address(indirect) + offset,
+      .restart_index =
+         increase_el_size ? UINT32_MAX : cmd->state.gfx.index.restart,
+      .index_buffer_size_el = max_index_count,
+      .mode = mode,
+   };
+   uint32_t out_el_size_B = increase_el_size ? sizeof(uint32_t) : el_size_B;
+   kk_encoder_render_triangle_fan_common(
+      cmd, &info, indirect, cmd->state.gfx.index.handle, decomposed_index_count,
+      el_size_B, out_el_size_B);
+}
diff --git a/src/kosmickrisp/vulkan/kk_encoder.h b/src/kosmickrisp/vulkan/kk_encoder.h
new file mode 100644
index 00000000000..5c45b87ecdd
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_encoder.h
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_ENCODER_H
+#define KK_ENCODER_H 1
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "util/u_dynarray.h"
+
+#include "vulkan/vulkan.h"
+
+struct kk_queue;
+struct kk_cmd_buffer;
+
+enum kk_encoder_type {
+   KK_ENC_NONE = 0,
+   KK_ENC_RENDER = BITFIELD_BIT(0),
+   KK_ENC_COMPUTE = BITFIELD_BIT(1),
+   KK_ENC_BLIT = BITFIELD_BIT(2),
+   KK_ENC_ALL = (KK_ENC_RENDER | KK_ENC_COMPUTE | KK_ENC_BLIT),
+   KK_ENC_COUNT = 3u,
+};
+
+struct kk_encoder_internal {
+   mtl_command_buffer *cmd_buffer;
+   mtl_command_encoder *encoder;
+
+   /* Used to know if we need to make heaps resident again */
+   uint32_t user_heap_hash;
+
+   /* Need to track last used to we can converge at submission */
+   enum kk_encoder_type last_used;
+
+   /* Used to synchronize between passes inside the same command buffer */
+   struct util_dynarray fences;
+   /* Tracks if we need to wait on the last fence present in fences at the start
+    * of the pass */
+   bool wait_fence;
+};
+
+struct kk_copy_query_pool_results_info {
+   uint64_t availability;
+   uint64_t results;
+   uint64_t indices;
+   uint64_t dst_addr;
+   uint64_t dst_stride;
+   uint32_t first_query;
+   VkQueryResultFlagBits flags;
+   uint16_t reports_per_query;
+   uint32_t query_count;
+};
+
+struct kk_encoder {
+   mtl_device *dev;
+   struct kk_encoder_internal main;
+   /* Compute only for pre gfx required work */
+   struct kk_encoder_internal pre_gfx;
+
+   /* Used to synchronize between main and pre_gfx encoders */
+   mtl_event *event;
+   uint64_t event_value;
+   /* Track what values pre_gfx must wait/signal before starting the encoding */
+   uint64_t wait_value_pre_gfx;
+   uint64_t signal_value_pre_gfx;
+
+   /* uint64_t pairs with first being the address, second being the value to
+    * write */
+   struct util_dynarray imm_writes;
+   /* mtl_buffers (destination buffers) so we can make them resident before the
+    * dispatch */
+   struct util_dynarray resident_buffers;
+   /* Array of kk_copy_quer_pool_results_info structs */
+   struct util_dynarray copy_query_pool_result_infos;
+};
+
+/* Allocates encoder and initialises/creates all resources required to start
+ * recording commands into the multiple encoders */
+VkResult kk_encoder_init(mtl_device *device, struct kk_queue *queue,
+                         struct kk_encoder **encoder);
+
+/* Submits all command buffers and releases encoder memory. Requires all command
+ * buffers in the encoder to be linked to the last one used so the post
+ * execution callback is called once all are done */
+void kk_encoder_submit(struct kk_encoder *encoder);
+
+mtl_render_encoder *
+kk_encoder_start_render(struct kk_cmd_buffer *cmd,
+                        mtl_render_pass_descriptor *descriptor,
+                        uint32_t view_mask);
+
+mtl_compute_encoder *kk_encoder_start_compute(struct kk_cmd_buffer *cmd);
+
+mtl_compute_encoder *kk_encoder_start_blit(struct kk_cmd_buffer *cmd);
+
+/* Ends encoding on all command buffers */
+void kk_encoder_end(struct kk_cmd_buffer *cmd);
+
+/* Creates a fence and signals it inside the encoder, then ends encoding */
+void kk_encoder_signal_fence_and_end(struct kk_cmd_buffer *cmd);
+
+mtl_render_encoder *kk_render_encoder(struct kk_cmd_buffer *cmd);
+
+mtl_compute_encoder *kk_compute_encoder(struct kk_cmd_buffer *cmd);
+
+mtl_blit_encoder *kk_blit_encoder(struct kk_cmd_buffer *cmd);
+
+struct kk_encoder_internal *kk_encoder_get_internal(struct kk_encoder *encoder,
+                                                    enum kk_encoder_type type);
+
+void upload_queue_writes(struct kk_cmd_buffer *cmd);
+
+void kk_encoder_render_triangle_fan_indirect(struct kk_cmd_buffer *cmd,
+                                             mtl_buffer *indirect,
+                                             uint64_t offset);
+
+void kk_encoder_render_triangle_fan_indexed_indirect(struct kk_cmd_buffer *cmd,
+                                                     mtl_buffer *indirect,
+                                                     uint64_t offset,
+                                                     bool increase_el_size);
+
+#endif /* KK_ENCODER_H */
diff --git a/src/kosmickrisp/vulkan/kk_event.c b/src/kosmickrisp/vulkan/kk_event.c
new file mode 100644
index 00000000000..3a16d19e49e
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_event.c
@@ -0,0 +1,143 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_event.h"
+
+#include "kk_bo.h"
+#include "kk_cmd_buffer.h"
+#include "kk_device.h"
+#include "kk_encoder.h"
+#include "kk_entrypoints.h"
+
+#define KK_EVENT_MEM_SIZE sizeof(uint64_t)
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_CreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
+               const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   struct kk_event *event;
+   VkResult result = VK_SUCCESS;
+
+   event = vk_object_zalloc(&dev->vk, pAllocator, sizeof(*event),
+                            VK_OBJECT_TYPE_EVENT);
+   if (!event)
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   /* TODO_KOSMICKRISP Bring back the heap. */
+   result = kk_alloc_bo(dev, &dev->vk.base, KK_EVENT_MEM_SIZE,
+                        KK_EVENT_MEM_SIZE, &event->bo);
+   if (result != VK_SUCCESS) {
+      vk_object_free(&dev->vk, pAllocator, event);
+      return result;
+   }
+
+   event->status = event->bo->cpu;
+   event->addr = event->bo->gpu;
+   *event->status = VK_EVENT_RESET;
+
+   *pEvent = kk_event_to_handle(event);
+
+   return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_DestroyEvent(VkDevice device, VkEvent _event,
+                const VkAllocationCallbacks *pAllocator)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_event, event, _event);
+
+   if (!event)
+      return;
+
+   kk_destroy_bo(dev, event->bo);
+
+   vk_object_free(&dev->vk, pAllocator, event);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_GetEventStatus(VkDevice device, VkEvent _event)
+{
+   VK_FROM_HANDLE(kk_event, event, _event);
+
+   return *event->status;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_SetEvent(VkDevice device, VkEvent _event)
+{
+   VK_FROM_HANDLE(kk_event, event, _event);
+
+   *event->status = VK_EVENT_SET;
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_ResetEvent(VkDevice device, VkEvent _event)
+{
+   VK_FROM_HANDLE(kk_event, event, _event);
+
+   *event->status = VK_EVENT_RESET;
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent _event,
+                const VkDependencyInfo *pDependencyInfo)
+{
+   VK_FROM_HANDLE(kk_event, event, _event);
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   enum kk_encoder_type last_used = cmd->encoder->main.last_used;
+   kk_cmd_write(cmd, event->bo->map, event->addr, VK_EVENT_SET);
+   if (last_used != KK_ENC_NONE)
+      kk_encoder_signal_fence_and_end(cmd);
+   else
+      upload_queue_writes(cmd);
+
+   /* If we were inside a render pass, restart it loading attachments */
+   if (last_used == KK_ENC_RENDER) {
+      struct kk_graphics_state *state = &cmd->state.gfx;
+      assert(state->render_pass_descriptor);
+      kk_encoder_start_render(cmd, state->render_pass_descriptor,
+                              state->render.view_mask);
+      kk_cmd_buffer_dirty_all_gfx(cmd);
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent _event,
+                  VkPipelineStageFlags2 stageMask)
+{
+   VK_FROM_HANDLE(kk_event, event, _event);
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   enum kk_encoder_type last_used = cmd->encoder->main.last_used;
+   kk_cmd_write(cmd, event->bo->map, event->addr, VK_EVENT_RESET);
+   if (last_used != KK_ENC_NONE)
+      kk_encoder_signal_fence_and_end(cmd);
+   else
+      upload_queue_writes(cmd);
+
+   /* If we were inside a render pass, restart it loading attachments */
+   if (last_used == KK_ENC_RENDER) {
+      struct kk_graphics_state *state = &cmd->state.gfx;
+      assert(state->render_pass_descriptor);
+      kk_encoder_start_render(cmd, state->render_pass_descriptor,
+                              state->render.view_mask);
+      kk_cmd_buffer_dirty_all_gfx(cmd);
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount,
+                  const VkEvent *pEvents,
+                  const VkDependencyInfo *pDependencyInfos)
+{
+   /* We do nothing, event should already be set by the time we are here. */
+}
diff --git a/src/kosmickrisp/vulkan/kk_event.h b/src/kosmickrisp/vulkan/kk_event.h
new file mode 100644
index 00000000000..4d6b7a14dcc
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_event.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_EVENT_H
+#define KK_EVENT_H 1
+
+#include "kk_private.h"
+
+#include "vk_object.h"
+
+struct kk_bo;
+
+struct kk_event {
+   struct vk_object_base base;
+   struct kk_bo *bo;
+
+   uint64_t addr;
+   uint64_t *status;
+};
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_event, base, VkEvent, VK_OBJECT_TYPE_EVENT)
+
+#endif /* KK_EVENT_H */
diff --git a/src/kosmickrisp/vulkan/kk_format.c b/src/kosmickrisp/vulkan/kk_format.c
new file mode 100644
index 00000000000..1a0347d5ac6
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_format.c
@@ -0,0 +1,359 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_format.h"
+
+#include "kk_buffer_view.h"
+#include "kk_entrypoints.h"
+#include "kk_image.h"
+#include "kk_physical_device.h"
+
+#include "kosmickrisp/bridge/mtl_format.h"
+
+#include "vk_enum_defines.h"
+#include "vk_format.h"
+
+#define MTL_FMT_ALL_NO_ATOMIC(width)                                           \
+   .bit_widths = width, .filter = 1u, .write = 1u, .color = 1u, .blend = 1u,   \
+   .msaa = 1u, .resolve = 1u, .sparse = 1u, .atomic = 0u
+
+// Filter, Write, Color, Blend, MSAA, Sparse
+#define MTL_FMT_FWCBMS(width)                                                  \
+   .bit_widths = width, .filter = 1u, .write = 1u, .color = 1u, .blend = 1u,   \
+   .msaa = 1u, .resolve = 0u, .sparse = 1u, .atomic = 0u
+
+// Filter, Color, Blend, MSAA, Resolve, Sparse
+#define MTL_FMT_FCBMRS(width)                                                  \
+   .bit_widths = width, .filter = 1u, .write = 0u, .color = 1u, .blend = 1u,   \
+   .msaa = 1u, .resolve = 1u, .sparse = 1u, .atomic = 0u
+
+// Filter, Write, Color, Blend, MSAA
+#define MTL_FMT_FWCBM(width)                                                   \
+   .bit_widths = width, .filter = 1u, .write = 1u, .color = 1u, .blend = 1u,   \
+   .msaa = 1u, .resolve = 0u, .sparse = 0u, .atomic = 0u
+
+// Write, Color, Blend, MSAA, Sparse
+#define MTL_FMT_WCBMS(width)                                                   \
+   .bit_widths = width, .filter = 0u, .write = 1u, .color = 1u, .blend = 1u,   \
+   .msaa = 1u, .resolve = 0u, .sparse = 0u, .atomic = 0u
+
+// Write, Color, MSAA, Sparse
+#define MTL_FMT_WCMS(width)                                                    \
+   .bit_widths = width, .filter = 0u, .write = 1u, .color = 1u, .blend = 0u,   \
+   .msaa = 1u, .resolve = 0u, .sparse = 1u, .atomic = 0u
+
+// Write, Color, Sparse, Atomic
+#define MTL_FMT_WCSA(width)                                                    \
+   .bit_widths = width, .filter = 0u, .write = 1u, .color = 1u, .blend = 0u,   \
+   .msaa = 0u, .resolve = 0u, .sparse = 1u, .atomic = 1u
+
+// Write, Color, Sparse
+#define MTL_FMT_WCS(width)                                                     \
+   .bit_widths = width, .filter = 0u, .write = 1u, .color = 1u, .blend = 0u,   \
+   .msaa = 0u, .resolve = 0u, .sparse = 1u, .atomic = 0u
+
+// Filter, MSAA, Resolve
+#define MTL_FMT_FMR(width)                                                     \
+   .bit_widths = width, .filter = 1u, .write = 0u, .color = 0u, .blend = 0u,   \
+   .msaa = 1u, .resolve = 1u, .sparse = 0u, .atomic = 0u
+
+// Filter, Sparse
+#define MTL_FMT_FS(width)                                                      \
+   .bit_widths = width, .filter = 1u, .write = 0u, .color = 0u, .blend = 0u,   \
+   .msaa = 0u, .resolve = 0u, .sparse = 1u, .atomic = 0u
+
+// MSAA, Resolve
+#define MTL_FMT_MR(width)                                                      \
+   .bit_widths = width, .filter = 0u, .write = 0u, .color = 0u, .blend = 0u,   \
+   .msaa = 1u, .resolve = 1u, .sparse = 0u, .atomic = 0u
+
+// MSAA
+#define MTL_FMT_M(width)                                                       \
+   .bit_widths = width, .filter = 0u, .write = 0u, .color = 0u, .blend = 0u,   \
+   .msaa = 1u, .resolve = 0u, .sparse = 0u, .atomic = 0u
+
+#define MTL_FMT_TB_ALL                                                         \
+   .texel_buffer = {                                                           \
+      .write = 1u,                                                             \
+      .read = 1u,                                                              \
+      .read_write = 1u,                                                        \
+   }
+
+#define MTL_FMT_TB_WR                                                          \
+   .texel_buffer = {                                                           \
+      .write = 1u,                                                             \
+      .read = 1u,                                                              \
+      .read_write = 0u,                                                        \
+   }
+
+#define MTL_FMT_TB_R                                                           \
+   .texel_buffer = {                                                           \
+      .write = 0u,                                                             \
+      .read = 1u,                                                              \
+      .read_write = 0u,                                                        \
+   }
+
+#define MTL_FMT_TB_NONE                                                        \
+   .texel_buffer = {                                                           \
+      .write = 0u,                                                             \
+      .read = 0u,                                                              \
+      .read_write = 0u,                                                        \
+   }
+
+#define MTL_SWIZZLE_IDENTITY                                                   \
+   .swizzle = {                                                                \
+      .red = PIPE_SWIZZLE_X,                                                   \
+      .green = PIPE_SWIZZLE_Y,                                                 \
+      .blue = PIPE_SWIZZLE_Z,                                                  \
+      .alpha = PIPE_SWIZZLE_W,                                                 \
+   }
+
+#define MTL_SWIZZLE_ABGR                                                       \
+   .swizzle = {                                                                \
+      .red = PIPE_SWIZZLE_W,                                                   \
+      .green = PIPE_SWIZZLE_Z,                                                 \
+      .blue = PIPE_SWIZZLE_Y,                                                  \
+      .alpha = PIPE_SWIZZLE_X,                                                 \
+   }
+
+#define MTL_SWIZZLE_BGRA                                                       \
+   .swizzle = {                                                                \
+      .red = PIPE_SWIZZLE_Z,                                                   \
+      .green = PIPE_SWIZZLE_Y,                                                 \
+      .blue = PIPE_SWIZZLE_X,                                                  \
+      .alpha = PIPE_SWIZZLE_W,                                                 \
+   }
+
+#define MTL_FMT(pipe_format, mtl_format, swizzle, capabilities,                \
+                texel_buffer_capabilities, native)                             \
+   [PIPE_FORMAT_##                                                             \
+      pipe_format] = {.mtl_pixel_format = MTL_PIXEL_FORMAT_##mtl_format,       \
+                      swizzle,                                                 \
+                      capabilities,                                            \
+                      texel_buffer_capabilities,                               \
+                      .is_native = native}
+
+#define MTL_FMT_NATIVE(format, capabilities, texel_buffer_capabilities)        \
+   [PIPE_FORMAT_##format] = {.mtl_pixel_format = MTL_PIXEL_FORMAT_##format,    \
+                             MTL_SWIZZLE_IDENTITY,                             \
+                             capabilities,                                     \
+                             texel_buffer_capabilities,                        \
+                             .is_native = 1}
+
+static const struct kk_va_format kk_vf_formats[] = {
+   // 8-bit formats
+   MTL_FMT_NATIVE(R8_UNORM, MTL_FMT_ALL_NO_ATOMIC(8), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(A8_UNORM, MTL_FMT_ALL_NO_ATOMIC(8), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R8_SRGB, MTL_FMT_ALL_NO_ATOMIC(8), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(R8_SNORM, MTL_FMT_ALL_NO_ATOMIC(8), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R8_UINT, MTL_FMT_WCMS(8), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R8_SINT, MTL_FMT_WCMS(8), MTL_FMT_TB_ALL),
+
+   // 16-bit formats
+   MTL_FMT_NATIVE(R16_UNORM, MTL_FMT_FWCBMS(16), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R16_SNORM, MTL_FMT_FWCBMS(16), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R16_UINT, MTL_FMT_WCMS(16), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R16_SINT, MTL_FMT_WCMS(16), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R16_FLOAT, MTL_FMT_ALL_NO_ATOMIC(16), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R8G8_UNORM, MTL_FMT_ALL_NO_ATOMIC(16), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R8G8_SNORM, MTL_FMT_ALL_NO_ATOMIC(16), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R8G8_SRGB, MTL_FMT_ALL_NO_ATOMIC(16), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(R8G8_UINT, MTL_FMT_WCMS(16), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R8G8_SINT, MTL_FMT_WCMS(16), MTL_FMT_TB_WR),
+
+   // 32-bit formats
+   MTL_FMT_NATIVE(R32_UINT, MTL_FMT_WCSA(32), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R32_SINT, MTL_FMT_WCSA(32), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R32_FLOAT, MTL_FMT_WCBMS(32), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R16G16_UNORM, MTL_FMT_FWCBMS(32), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R16G16_SNORM, MTL_FMT_FWCBMS(32), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R16G16_UINT, MTL_FMT_WCMS(32), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R16G16_SINT, MTL_FMT_WCMS(32), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R16G16_FLOAT, MTL_FMT_ALL_NO_ATOMIC(32), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R8G8B8A8_UNORM, MTL_FMT_ALL_NO_ATOMIC(32), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R8G8B8A8_SNORM, MTL_FMT_ALL_NO_ATOMIC(32), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R8G8B8A8_SRGB, MTL_FMT_ALL_NO_ATOMIC(32), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(R8G8B8A8_UINT, MTL_FMT_WCMS(32), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R8G8B8A8_SINT, MTL_FMT_WCMS(32), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(B8G8R8A8_UNORM, MTL_FMT_ALL_NO_ATOMIC(32), MTL_FMT_TB_R),
+   MTL_FMT_NATIVE(B8G8R8A8_SRGB, MTL_FMT_ALL_NO_ATOMIC(32), MTL_FMT_TB_NONE),
+
+   // 64-bit formats
+   MTL_FMT_NATIVE(R32G32_UINT, MTL_FMT_WCMS(64), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R32G32_SINT, MTL_FMT_WCMS(64), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R32G32_FLOAT, MTL_FMT_WCBMS(64), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R16G16B16A16_UNORM, MTL_FMT_FWCBMS(64), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R16G16B16A16_SNORM, MTL_FMT_FWCBMS(64), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R16G16B16A16_UINT, MTL_FMT_WCMS(64), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R16G16B16A16_SINT, MTL_FMT_WCMS(64), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R16G16B16A16_FLOAT, MTL_FMT_ALL_NO_ATOMIC(64),
+                  MTL_FMT_TB_ALL),
+
+   // 128-bit formats
+   MTL_FMT_NATIVE(R32G32B32A32_UINT, MTL_FMT_WCS(128), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R32G32B32A32_SINT, MTL_FMT_WCS(128), MTL_FMT_TB_ALL),
+   MTL_FMT_NATIVE(R32G32B32A32_FLOAT, MTL_FMT_WCMS(128), MTL_FMT_TB_ALL),
+
+   // 16-bit packed formats
+   MTL_FMT_NATIVE(B5G6R5_UNORM, MTL_FMT_FCBMRS(16), MTL_FMT_TB_NONE),
+   /* Hardware has issues with border color opaque black, and since it's not
+    * required by Vulkan, we can just disable it.
+    */
+   /* MTL_FMT_NATIVE(A1B5G5R5_UNORM, MTL_FMT_FCBMRS(16), MTL_FMT_TB_NONE), */
+   MTL_FMT_NATIVE(A4B4G4R4_UNORM, MTL_FMT_FCBMRS(16), MTL_FMT_TB_NONE),
+   MTL_FMT(R4G4B4A4_UNORM, A4B4G4R4_UNORM, MTL_SWIZZLE_ABGR, MTL_FMT_FCBMRS(16),
+           MTL_FMT_TB_NONE, false),
+   MTL_FMT(A4R4G4B4_UNORM, A4B4G4R4_UNORM, MTL_SWIZZLE_BGRA, MTL_FMT_FCBMRS(16),
+           MTL_FMT_TB_NONE, false),
+   MTL_FMT_NATIVE(B5G5R5A1_UNORM, MTL_FMT_FCBMRS(16), MTL_FMT_TB_NONE),
+
+   // 32-bit packed formats
+   MTL_FMT_NATIVE(R10G10B10A2_UNORM, MTL_FMT_ALL_NO_ATOMIC(32), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(B10G10R10A2_UNORM, MTL_FMT_ALL_NO_ATOMIC(32),
+                  MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(R10G10B10A2_UINT, MTL_FMT_WCMS(32), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R11G11B10_FLOAT, MTL_FMT_ALL_NO_ATOMIC(32), MTL_FMT_TB_WR),
+   MTL_FMT_NATIVE(R9G9B9E5_FLOAT, MTL_FMT_ALL_NO_ATOMIC(32), MTL_FMT_TB_NONE),
+
+   // ASTC formats
+   MTL_FMT_NATIVE(ASTC_4x4, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_5x4, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_5x5, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_6x5, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_6x6, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_8x5, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_8x6, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_8x8, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_10x5, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_10x6, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_10x8, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_10x10, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_12x10, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_12x12, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+
+   MTL_FMT_NATIVE(ASTC_4x4_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_5x4_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_5x5_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_6x5_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_6x6_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_8x5_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_8x6_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_8x8_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_10x5_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_10x6_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_10x8_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_10x10_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_12x10_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ASTC_12x12_SRGB, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+
+   // EAC/ETC formats
+   MTL_FMT_NATIVE(ETC2_R11_UNORM, MTL_FMT_FS(64), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ETC2_R11_SNORM, MTL_FMT_FS(64), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ETC2_RG11_UNORM, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ETC2_RG11_SNORM, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ETC2_RGBA8, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ETC2_SRGBA8, MTL_FMT_FS(128), MTL_FMT_TB_NONE),
+
+   MTL_FMT_NATIVE(ETC2_RGB8, MTL_FMT_FS(64), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ETC2_SRGB8, MTL_FMT_FS(64), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ETC2_RGB8A1, MTL_FMT_FS(64), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(ETC2_SRGB8A1, MTL_FMT_FS(64), MTL_FMT_TB_NONE),
+
+   // Compressed PVRTC, HDR ASTC, BC TODO_KOSMICKRISP
+   // YUV formats TODO_KOSMICKRISP
+   // Extended range and wide color formats TODO_KOSMICKRISP
+
+   // Depth and stencil formats
+   MTL_FMT_NATIVE(Z16_UNORM, MTL_FMT_FMR(16), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(Z32_FLOAT, MTL_FMT_MR(32), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(S8_UINT, MTL_FMT_M(8), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(Z32_FLOAT_S8X24_UINT, MTL_FMT_MR(64), MTL_FMT_TB_NONE),
+   MTL_FMT_NATIVE(X32_S8X24_UINT, MTL_FMT_MR(64), MTL_FMT_TB_NONE),
+};
+
+#undef MTL_FMT_NATIVE
+#undef MTL_FMT
+
+#undef MTL_SWIZZLE_BGRA
+#undef MTL_SWIZZLE_ABGR
+#undef MTL_SWIZZLE_IDENTITY
+
+#undef MTL_FMT_ALL_NO_ATOMIC
+#undef MTL_FMT_FWCBMS
+#undef MTL_FMT_FCBMRS
+#undef MTL_FMT_FWCBM
+#undef MTL_FMT_WCBMS
+#undef MTL_FMT_WCMS
+#undef MTL_FMT_WCSA
+#undef MTL_FMT_WCS
+#undef MTL_FMT_FMR
+#undef MTL_FMT_FS
+#undef MTL_FMT_MR
+#undef MTL_FMT_M
+
+#undef MTL_FMT_TB_ALL
+#undef MTL_FMT_TB_WR
+#undef MTL_FMT_TB_R
+#undef MTL_FMT_TB_NONE
+
+const struct kk_va_format *
+kk_get_va_format(enum pipe_format format)
+{
+   if (format >= ARRAY_SIZE(kk_vf_formats))
+      return NULL;
+
+   if (kk_vf_formats[format].bit_widths == 0)
+      return NULL;
+
+   return &kk_vf_formats[format];
+}
+
+enum mtl_pixel_format
+vk_format_to_mtl_pixel_format(VkFormat vkformat)
+{
+   enum pipe_format format = vk_format_to_pipe_format(vkformat);
+   const struct kk_va_format *supported_format = kk_get_va_format(format);
+   assert(supported_format);
+   return supported_format->mtl_pixel_format;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
+                                      VkFormat format,
+                                      VkFormatProperties2 *pFormatProperties)
+{
+   VK_FROM_HANDLE(kk_physical_device, pdevice, physicalDevice);
+
+   VkFormatFeatureFlags2 linear2, optimal2, buffer2;
+   linear2 =
+      kk_get_image_format_features(pdevice, format, VK_IMAGE_TILING_LINEAR, 0);
+   optimal2 =
+      kk_get_image_format_features(pdevice, format, VK_IMAGE_TILING_OPTIMAL, 0);
+   buffer2 = kk_get_buffer_format_features(pdevice, format);
+
+   pFormatProperties->formatProperties = (VkFormatProperties){
+      .linearTilingFeatures = vk_format_features2_to_features(linear2),
+      .optimalTilingFeatures = vk_format_features2_to_features(optimal2),
+      .bufferFeatures = vk_format_features2_to_features(buffer2),
+   };
+
+   vk_foreach_struct(ext, pFormatProperties->pNext) {
+      switch (ext->sType) {
+      case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
+         VkFormatProperties3 *p = (void *)ext;
+         p->linearTilingFeatures = linear2;
+         p->optimalTilingFeatures = optimal2;
+         p->bufferFeatures = buffer2;
+         break;
+      }
+
+      default:
+         vk_debug_ignored_stype(ext->sType);
+         break;
+      }
+   }
+}
diff --git a/src/kosmickrisp/vulkan/kk_format.h b/src/kosmickrisp/vulkan/kk_format.h
new file mode 100644
index 00000000000..64541a659e5
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_format.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_FORMAT_H
+#define KK_FORMAT_H 1
+
+#include "kk_private.h"
+
+#include "util/format/u_format.h"
+
+struct kk_physical_device;
+enum pipe_format;
+enum mtl_pixel_format;
+
+struct kk_va_format {
+   /* Would love to use enum pipe_swizzle, but it's bigger than the required
+    * type for util_format_compose_swizzles... */
+   struct {
+      union {
+         struct {
+            uint8_t red;
+            uint8_t green;
+            uint8_t blue;
+            uint8_t alpha;
+         };
+         uint8_t channels[4];
+      };
+   } swizzle;
+   uint32_t mtl_pixel_format;
+   uint8_t bit_widths;
+   uint8_t filter  : 1;
+   uint8_t write   : 1;
+   uint8_t color   : 1;
+   uint8_t blend   : 1;
+   uint8_t msaa    : 1;
+   uint8_t resolve : 1;
+   uint8_t sparse  : 1;
+   uint8_t atomic  : 1;
+   struct {
+      uint8_t write      : 1;
+      uint8_t read       : 1;
+      uint8_t read_write : 1;
+   } texel_buffer;
+   uint8_t is_native : 1;
+};
+
+const struct kk_va_format *kk_get_va_format(enum pipe_format format);
+
+enum mtl_pixel_format vk_format_to_mtl_pixel_format(enum VkFormat vkformat);
+
+#endif /* KK_FORMAT_H */
diff --git a/src/kosmickrisp/vulkan/kk_image.c b/src/kosmickrisp/vulkan/kk_image.c
new file mode 100644
index 00000000000..0b05fc82002
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_image.c
@@ -0,0 +1,967 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_image.h"
+
+#include "kk_device.h"
+#include "kk_device_memory.h"
+#include "kk_entrypoints.h"
+#include "kk_format.h"
+#include "kk_physical_device.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+#include "vk_enum_defines.h"
+#include "vk_enum_to_str.h"
+#include "vk_format.h"
+#include "wsi_common_private.h"
+
+static VkFormatFeatureFlags2
+kk_get_image_plane_format_features(struct kk_physical_device *pdev,
+                                   VkFormat vk_format, VkImageTiling tiling,
+                                   uint64_t drm_format_mod)
+{
+   VkFormatFeatureFlags2 features = 0;
+
+   /* Metal does not support linear tiling for compressed formats */
+   if (tiling == VK_IMAGE_TILING_LINEAR && vk_format_is_compressed(vk_format))
+      return 0;
+
+   enum pipe_format p_format = vk_format_to_pipe_format(vk_format);
+   if (p_format == PIPE_FORMAT_NONE)
+      return 0;
+
+   /* You can't tile a non-power-of-two */
+   if (!util_is_power_of_two_nonzero(util_format_get_blocksize(p_format)))
+      return 0;
+
+   const struct kk_va_format *va_format = kk_get_va_format(p_format);
+   if (va_format == NULL)
+      return 0;
+
+   // Textures can at least be sampled
+   features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT;
+   features |= VK_FORMAT_FEATURE_2_BLIT_SRC_BIT;
+
+   if (va_format->filter) {
+      features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
+      features |=
+         VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT; // TODO_KOSMICKRISP
+                                                              // Understand if
+                                                              // we want to
+                                                              // expose this
+   }
+
+   /* TODO: VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT */
+   if (vk_format_has_depth(vk_format)) {
+      features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT;
+   }
+
+   /* We disable A8 format due to lower blend pass issues */
+   if (va_format->color && tiling != VK_IMAGE_TILING_LINEAR &&
+       vk_format != VK_FORMAT_A8_UNORM) {
+      features |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT;
+      features |= VK_FORMAT_FEATURE_2_BLIT_DST_BIT;
+      // TODO_KOSMICKRISP Support snorm formats once the following spec issue is
+      // resolved: https://gitlab.khronos.org/vulkan/vulkan/-/issues/4293
+      if (!vk_format_is_snorm(vk_format))
+         features |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT;
+   }
+
+   if (vk_format_is_depth_or_stencil(vk_format)) {
+      if (tiling == VK_IMAGE_TILING_LINEAR)
+         return 0;
+
+      features |= VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT;
+   }
+
+   if (va_format->write) {
+      features |= VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT;
+   }
+
+   if (va_format->atomic)
+      features |= VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT;
+
+   if (features != 0) {
+      features |= VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT;
+      features |= VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
+   }
+
+   return features;
+}
+
+VkFormatFeatureFlags2
+kk_get_image_format_features(struct kk_physical_device *pdev,
+                             VkFormat vk_format, VkImageTiling tiling,
+                             uint64_t drm_format_mod)
+{
+   const struct vk_format_ycbcr_info *ycbcr_info =
+      vk_format_get_ycbcr_info(vk_format);
+   if (ycbcr_info == NULL) {
+      return kk_get_image_plane_format_features(pdev, vk_format, tiling,
+                                                drm_format_mod);
+   }
+
+   /* For multi-plane, we get the feature flags of each plane separately,
+    * then take their intersection as the overall format feature flags
+    */
+   VkFormatFeatureFlags2 features = ~0ull;
+   bool cosited_chroma = false;
+   for (uint8_t plane = 0; plane < ycbcr_info->n_planes; plane++) {
+      const struct vk_format_ycbcr_plane *plane_info =
+         &ycbcr_info->planes[plane];
+      features &= kk_get_image_plane_format_features(pdev, plane_info->format,
+                                                     tiling, drm_format_mod);
+      if (plane_info->denominator_scales[0] > 1 ||
+          plane_info->denominator_scales[1] > 1)
+         cosited_chroma = true;
+   }
+   if (features == 0)
+      return 0;
+
+   /* Uh... We really should be able to sample from YCbCr */
+   assert(features & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT);
+   assert(features & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT);
+
+   /* These aren't allowed for YCbCr formats */
+   features &=
+      ~(VK_FORMAT_FEATURE_2_BLIT_SRC_BIT | VK_FORMAT_FEATURE_2_BLIT_DST_BIT |
+        VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT |
+        VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT |
+        VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT);
+
+   /* This is supported on all YCbCr formats */
+   features |=
+      VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT;
+
+   if (ycbcr_info->n_planes > 1) {
+      /* DISJOINT_BIT implies that each plane has its own separate binding,
+       * while SEPARATE_RECONSTRUCTION_FILTER_BIT implies that luma and chroma
+       * each have their own, separate filters, so these two bits make sense
+       * for multi-planar formats only.
+       *
+       * For MIDPOINT_CHROMA_SAMPLES_BIT, NVIDIA HW on single-plane interleaved
+       * YCbCr defaults to COSITED_EVEN, which is inaccurate and fails tests.
+       * This can be fixed with a NIR tweak but for now, we only enable this bit
+       * for multi-plane formats. See Issue #9525 on the mesa/main tracker.
+       */
+      features |=
+         VK_FORMAT_FEATURE_DISJOINT_BIT |
+         VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT |
+         VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT;
+   }
+
+   if (cosited_chroma)
+      features |= VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT;
+
+   return features;
+}
+
+static VkFormatFeatureFlags2
+vk_image_usage_to_format_features(VkImageUsageFlagBits usage_flag)
+{
+   assert(util_bitcount(usage_flag) == 1);
+   switch (usage_flag) {
+   case VK_IMAGE_USAGE_TRANSFER_SRC_BIT:
+      return VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT |
+             VK_FORMAT_FEATURE_BLIT_SRC_BIT;
+   case VK_IMAGE_USAGE_TRANSFER_DST_BIT:
+      return VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT |
+             VK_FORMAT_FEATURE_BLIT_DST_BIT;
+   case VK_IMAGE_USAGE_SAMPLED_BIT:
+      return VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT;
+   case VK_IMAGE_USAGE_STORAGE_BIT:
+      return VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT;
+   case VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+      return VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT;
+   case VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT:
+      return VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT;
+   case VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT:
+      return VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT |
+             VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT;
+   case VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
+      return VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
+   default:
+      return 0;
+   }
+}
+
+uint32_t
+kk_image_max_dimension(VkImageType image_type)
+{
+   /* Values taken from Apple7
+    * https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf */
+   switch (image_type) {
+   case VK_IMAGE_TYPE_1D:
+   case VK_IMAGE_TYPE_2D:
+      return 16384;
+   case VK_IMAGE_TYPE_3D:
+      return 2048;
+   default:
+      UNREACHABLE("Invalid image type");
+   }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_GetPhysicalDeviceImageFormatProperties2(
+   VkPhysicalDevice physicalDevice,
+   const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
+   VkImageFormatProperties2 *pImageFormatProperties)
+{
+   VK_FROM_HANDLE(kk_physical_device, pdev, physicalDevice);
+
+   const VkPhysicalDeviceExternalImageFormatInfo *external_info =
+      vk_find_struct_const(pImageFormatInfo->pNext,
+                           PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
+
+   /* Initialize to zero in case we return VK_ERROR_FORMAT_NOT_SUPPORTED */
+   memset(&pImageFormatProperties->imageFormatProperties, 0,
+          sizeof(pImageFormatProperties->imageFormatProperties));
+
+   /* Metal does not support depth/stencil textures that are not 2D (we make 1D
+    * textures 2D) */
+   if (vk_format_is_depth_or_stencil(pImageFormatInfo->format) &&
+       pImageFormatInfo->type == VK_IMAGE_TYPE_3D)
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   /* Metal does not support EAC/ETC formats for 3D textures. */
+   if (util_format_is_etc(vk_format_to_pipe_format(pImageFormatInfo->format)) &&
+       pImageFormatInfo->type == VK_IMAGE_TYPE_3D)
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   /* Metal disallows reading compressed formats as uncompressed format.
+    * VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT is only used with
+    * compressed formats.
+    */
+   if (pImageFormatInfo->flags &
+       VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT)
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   const struct vk_format_ycbcr_info *ycbcr_info =
+      vk_format_get_ycbcr_info(pImageFormatInfo->format);
+
+   /* For the purposes of these checks, we don't care about all the extra
+    * YCbCr features and we just want the accumulation of features available
+    * to all planes of the given format.
+    */
+   VkFormatFeatureFlags2 features;
+   if (ycbcr_info == NULL) {
+      features = kk_get_image_plane_format_features(
+         pdev, pImageFormatInfo->format, pImageFormatInfo->tiling, 0u);
+   } else {
+      features = ~0ull;
+      assert(ycbcr_info->n_planes > 0);
+      for (uint8_t plane = 0; plane < ycbcr_info->n_planes; plane++) {
+         const VkFormat plane_format = ycbcr_info->planes[plane].format;
+         features &= kk_get_image_plane_format_features(
+            pdev, plane_format, pImageFormatInfo->tiling, 0u);
+      }
+   }
+
+   if (features == 0)
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   if (pImageFormatInfo->tiling == VK_IMAGE_TILING_LINEAR &&
+       pImageFormatInfo->type == VK_IMAGE_TYPE_3D)
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   /* TODO_KOSMICKRISP We could allow linear images that are used as render
+    * target as long as they are not used as input attachments. Main reason for
+    * this is that we expect arrays when rendering and reading from input
+    * attachments and Metal disallows arrays for linear textures.
+    */
+   if (pImageFormatInfo->tiling == VK_IMAGE_TILING_LINEAR &&
+       (pImageFormatInfo->usage &
+        (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+         VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)))
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   if (ycbcr_info && pImageFormatInfo->type != VK_IMAGE_TYPE_2D)
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   /* Don't support sparse residency */
+   if ((pImageFormatInfo->flags & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT))
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   /* From the Vulkan 1.3.279 spec:
+    *
+    *    VUID-VkImageCreateInfo-tiling-04121
+    *
+    *    "If tiling is VK_IMAGE_TILING_LINEAR, flags must not contain
+    *    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"
+    *
+    *    VUID-VkImageCreateInfo-imageType-00970
+    *
+    *    "If imageType is VK_IMAGE_TYPE_1D, flags must not contain
+    *    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"
+    */
+   if ((pImageFormatInfo->flags & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) &&
+       (pImageFormatInfo->type == VK_IMAGE_TYPE_1D ||
+        pImageFormatInfo->tiling == VK_IMAGE_TILING_LINEAR))
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   /* From the Vulkan 1.3.279 spec:
+    *
+    *    VUID-VkImageCreateInfo-flags-09403
+    *
+    *    "If flags contains VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, flags
+    *    must not include VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
+    *    VK_IMAGE_CREATE_SPARSE_BINDING_BIT, or
+    *    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"
+    */
+   if ((pImageFormatInfo->flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT) &&
+       (pImageFormatInfo->flags & (VK_IMAGE_CREATE_SPARSE_ALIASED_BIT |
+                                   VK_IMAGE_CREATE_SPARSE_BINDING_BIT |
+                                   VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)))
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   if (pImageFormatInfo->tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT &&
+       pImageFormatInfo->type != VK_IMAGE_TYPE_2D)
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   const uint32_t max_dim = kk_image_max_dimension(pImageFormatInfo->type);
+   assert(util_is_power_of_two_nonzero(max_dim));
+   uint32_t maxMipLevels = util_logbase2(max_dim) + 1;
+   VkExtent3D maxExtent;
+   uint32_t maxArraySize;
+   switch (pImageFormatInfo->type) {
+   case VK_IMAGE_TYPE_1D:
+      maxExtent = (VkExtent3D){max_dim, 1, 1};
+      maxArraySize = 2048u;
+      break;
+   case VK_IMAGE_TYPE_2D:
+      maxExtent = (VkExtent3D){max_dim, max_dim, 1};
+      maxArraySize = 2048u;
+      break;
+   case VK_IMAGE_TYPE_3D:
+      maxExtent = (VkExtent3D){max_dim, max_dim, max_dim};
+      maxArraySize = 1u;
+      break;
+   default:
+      UNREACHABLE("Invalid image type");
+   }
+   if (pImageFormatInfo->tiling == VK_IMAGE_TILING_LINEAR)
+      maxArraySize = 1;
+
+   if (ycbcr_info != NULL || pImageFormatInfo->tiling == VK_IMAGE_TILING_LINEAR)
+      maxMipLevels = 1;
+
+   if (pImageFormatInfo->tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT) {
+      maxArraySize = 1;
+      maxMipLevels = 1;
+   }
+
+   VkSampleCountFlags sampleCounts = VK_SAMPLE_COUNT_1_BIT;
+   if (pImageFormatInfo->tiling == VK_IMAGE_TILING_OPTIMAL &&
+       pImageFormatInfo->type == VK_IMAGE_TYPE_2D && ycbcr_info == NULL &&
+       (features & (VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT |
+                    VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT)) &&
+       !(pImageFormatInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)) {
+      sampleCounts =
+         VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT |
+         // TODO_KOSMICKRISP Modify sample count based on what pdev supports
+         VK_SAMPLE_COUNT_4_BIT /* |
+          VK_SAMPLE_COUNT_8_BIT */
+         ;
+   }
+
+   /* From the Vulkan 1.2.199 spec:
+    *
+    *    "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT specifies that the image can be
+    *    created with usage flags that are not supported for the format the
+    *    image is created with but are supported for at least one format a
+    *    VkImageView created from the image can have."
+    *
+    * If VK_IMAGE_CREATE_EXTENDED_USAGE_BIT is set, views can be created with
+    * different usage than the image so we can't always filter on usage.
+    * There is one exception to this below for storage.
+    */
+   const VkImageUsageFlags image_usage = pImageFormatInfo->usage;
+   VkImageUsageFlags view_usage = image_usage;
+   if (pImageFormatInfo->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT)
+      view_usage = 0;
+
+   u_foreach_bit(b, view_usage) {
+      VkFormatFeatureFlags2 usage_features =
+         vk_image_usage_to_format_features(1 << b);
+      if (usage_features && !(features & usage_features))
+         return VK_ERROR_FORMAT_NOT_SUPPORTED;
+   }
+
+   const VkExternalMemoryProperties *ext_mem_props = NULL;
+   if (external_info != NULL && external_info->handleType != 0) {
+      /* We only support heaps since that's the backing for all our memory and
+       * simplifies implementation */
+      switch (external_info->handleType) {
+      case VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT:
+         ext_mem_props = &kk_mtlheap_mem_props;
+         break;
+      default:
+         /* From the Vulkan 1.3.256 spec:
+          *
+          *    "If handleType is not compatible with the [parameters] in
+          *    VkPhysicalDeviceImageFormatInfo2, then
+          *    vkGetPhysicalDeviceImageFormatProperties2 returns
+          *    VK_ERROR_FORMAT_NOT_SUPPORTED."
+          */
+         return vk_errorf(pdev, VK_ERROR_FORMAT_NOT_SUPPORTED,
+                          "unsupported VkExternalMemoryHandleTypeFlagBits: %s ",
+                          vk_ExternalMemoryHandleTypeFlagBits_to_str(
+                             external_info->handleType));
+      }
+   }
+
+   const unsigned plane_count =
+      vk_format_get_plane_count(pImageFormatInfo->format);
+
+   /* From the Vulkan 1.3.259 spec, VkImageCreateInfo:
+    *
+    *    VUID-VkImageCreateInfo-imageCreateFormatFeatures-02260
+    *
+    *    "If format is a multi-planar format, and if imageCreateFormatFeatures
+    *    (as defined in Image Creation Limits) does not contain
+    *    VK_FORMAT_FEATURE_DISJOINT_BIT, then flags must not contain
+    *    VK_IMAGE_CREATE_DISJOINT_BIT"
+    *
+    * This is satisfied trivially because we support DISJOINT on all
+    * multi-plane formats.  Also,
+    *
+    *    VUID-VkImageCreateInfo-format-01577
+    *
+    *    "If format is not a multi-planar format, and flags does not include
+    *    VK_IMAGE_CREATE_ALIAS_BIT, flags must not contain
+    *    VK_IMAGE_CREATE_DISJOINT_BIT"
+    */
+   if (plane_count == 1 &&
+       !(pImageFormatInfo->flags & VK_IMAGE_CREATE_ALIAS_BIT) &&
+       (pImageFormatInfo->flags & VK_IMAGE_CREATE_DISJOINT_BIT))
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   if (ycbcr_info &&
+       ((pImageFormatInfo->flags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) ||
+        (pImageFormatInfo->flags & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)))
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   if ((pImageFormatInfo->flags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) &&
+       (pImageFormatInfo->usage & VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT))
+      return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+   pImageFormatProperties->imageFormatProperties = (VkImageFormatProperties){
+      .maxExtent = maxExtent,
+      .maxMipLevels = maxMipLevels,
+      .maxArrayLayers = maxArraySize,
+      .sampleCounts = sampleCounts,
+      .maxResourceSize = UINT32_MAX, /* TODO */
+   };
+
+   vk_foreach_struct(s, pImageFormatProperties->pNext) {
+      switch (s->sType) {
+      case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
+         VkExternalImageFormatProperties *p = (void *)s;
+         /* From the Vulkan 1.3.256 spec:
+          *
+          *    "If handleType is 0, vkGetPhysicalDeviceImageFormatProperties2
+          *    will behave as if VkPhysicalDeviceExternalImageFormatInfo was
+          *    not present, and VkExternalImageFormatProperties will be
+          *    ignored."
+          *
+          * This is true if and only if ext_mem_props == NULL
+          */
+         if (ext_mem_props != NULL)
+            p->externalMemoryProperties = *ext_mem_props;
+         break;
+      }
+      case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
+         VkSamplerYcbcrConversionImageFormatProperties *ycbcr_props = (void *)s;
+         ycbcr_props->combinedImageSamplerDescriptorCount = plane_count;
+         break;
+      }
+      case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
+         VkHostImageCopyDevicePerformanceQueryEXT *host_props = (void *)s;
+         host_props->optimalDeviceAccess = true;
+         host_props->identicalMemoryLayout = true;
+         break;
+      }
+      default:
+         vk_debug_ignored_stype(s->sType);
+         break;
+      }
+   }
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetPhysicalDeviceSparseImageFormatProperties2(
+   VkPhysicalDevice physicalDevice,
+   const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
+   uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
+{
+   *pPropertyCount = 0;
+   return;
+}
+
+static VkResult
+kk_image_init(struct kk_device *dev, struct kk_image *image,
+              const VkImageCreateInfo *pCreateInfo)
+{
+   vk_image_init(&dev->vk, &image->vk, pCreateInfo);
+
+   if ((image->vk.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                           VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) &&
+       image->vk.samples > 1) {
+      image->vk.usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
+      image->vk.stencil_usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
+   }
+
+   if (image->vk.usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT)
+      image->vk.usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
+   if (image->vk.usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT) {
+      if (util_format_is_depth_or_stencil(
+             vk_format_to_pipe_format(image->vk.format))) {
+         image->vk.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+         image->vk.stencil_usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+      } else {
+         image->vk.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+      }
+   }
+
+   image->plane_count = vk_format_get_plane_count(pCreateInfo->format);
+   image->disjoint = image->plane_count > 1 &&
+                     (pCreateInfo->flags & VK_IMAGE_CREATE_DISJOINT_BIT);
+
+   const struct vk_format_ycbcr_info *ycbcr_info =
+      vk_format_get_ycbcr_info(pCreateInfo->format);
+   for (uint8_t plane = 0; plane < image->plane_count; plane++) {
+      VkFormat format =
+         ycbcr_info ? ycbcr_info->planes[plane].format : pCreateInfo->format;
+      const uint8_t width_scale =
+         ycbcr_info ? ycbcr_info->planes[plane].denominator_scales[0] : 1;
+      const uint8_t height_scale =
+         ycbcr_info ? ycbcr_info->planes[plane].denominator_scales[1] : 1;
+      kk_image_layout_init(dev, pCreateInfo, vk_format_to_pipe_format(format),
+                           width_scale, height_scale,
+                           &image->planes[plane].layout);
+   }
+
+   if (image->vk.format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
+      kk_image_layout_init(dev, pCreateInfo, PIPE_FORMAT_R32_UINT, 1, 1,
+                           &image->stencil_copy_temp.layout);
+   }
+
+   return VK_SUCCESS;
+}
+
+static void
+kk_image_plane_size_align_B(struct kk_device *dev, const struct kk_image *image,
+                            const struct kk_image_plane *plane,
+                            uint64_t *size_B_out, uint64_t *align_B_out)
+{
+   *size_B_out = plane->layout.size_B;
+   *align_B_out = plane->layout.align_B;
+}
+
+static void
+kk_image_plane_finish(struct kk_device *dev, struct kk_image_plane *plane,
+                      VkImageCreateFlags create_flags,
+                      const VkAllocationCallbacks *pAllocator)
+{
+   if (plane->mtl_handle != NULL)
+      mtl_release(plane->mtl_handle);
+   if (plane->mtl_handle_array != NULL)
+      mtl_release(plane->mtl_handle_array);
+}
+
+static void
+kk_image_finish(struct kk_device *dev, struct kk_image *image,
+                const VkAllocationCallbacks *pAllocator)
+{
+   for (uint8_t plane = 0; plane < image->plane_count; plane++) {
+      kk_image_plane_finish(dev, &image->planes[plane], image->vk.create_flags,
+                            pAllocator);
+   }
+
+   if (image->stencil_copy_temp.layout.size_B > 0) {
+      kk_image_plane_finish(dev, &image->stencil_copy_temp,
+                            image->vk.create_flags, pAllocator);
+   }
+
+   vk_image_finish(&image->vk);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_CreateImage(VkDevice _device, const VkImageCreateInfo *pCreateInfo,
+               const VkAllocationCallbacks *pAllocator, VkImage *pImage)
+{
+   VK_FROM_HANDLE(kk_device, dev, _device);
+   struct kk_physical_device *pdev = kk_device_physical(dev);
+   struct kk_image *image;
+   VkResult result;
+
+#ifdef KK_USE_WSI_PLATFORM
+   /* Ignore swapchain creation info on Android. Since we don't have an
+    * implementation in Mesa, we're guaranteed to access an Android object
+    * incorrectly.
+    */
+   const VkImageSwapchainCreateInfoKHR *swapchain_info =
+      vk_find_struct_const(pCreateInfo->pNext, IMAGE_SWAPCHAIN_CREATE_INFO_KHR);
+   if (swapchain_info && swapchain_info->swapchain != VK_NULL_HANDLE) {
+      return wsi_common_create_swapchain_image(
+         &pdev->wsi_device, pCreateInfo, swapchain_info->swapchain, pImage);
+   }
+#endif
+
+   image = vk_zalloc2(&dev->vk.alloc, pAllocator, sizeof(*image), 8,
+                      VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+   if (!image)
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   result = kk_image_init(dev, image, pCreateInfo);
+   if (result != VK_SUCCESS) {
+      vk_free2(&dev->vk.alloc, pAllocator, image);
+      return result;
+   }
+
+   *pImage = kk_image_to_handle(image);
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_DestroyImage(VkDevice device, VkImage _image,
+                const VkAllocationCallbacks *pAllocator)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_image, image, _image);
+
+   if (!image)
+      return;
+
+   kk_image_finish(dev, image, pAllocator);
+   vk_free2(&dev->vk.alloc, pAllocator, image);
+}
+
+static void
+kk_image_plane_add_req(struct kk_device *dev, const struct kk_image *image,
+                       const struct kk_image_plane *plane, uint64_t *size_B,
+                       uint32_t *align_B)
+{
+   assert(util_is_power_of_two_or_zero64(*align_B));
+   uint64_t plane_size_B, plane_align_B;
+   kk_image_plane_size_align_B(dev, image, plane, &plane_size_B,
+                               &plane_align_B);
+
+   *align_B = MAX2(*align_B, plane_align_B);
+   *size_B = align64(*size_B, plane_align_B);
+   *size_B += plane_size_B;
+}
+
+static void
+kk_get_image_memory_requirements(struct kk_device *dev, struct kk_image *image,
+                                 VkImageAspectFlags aspects,
+                                 VkMemoryRequirements2 *pMemoryRequirements)
+{
+   struct kk_physical_device *pdev = kk_device_physical(dev);
+   uint32_t memory_types = (1 << pdev->mem_type_count) - 1;
+
+   /* Remove non host visible heaps from the types for host image copy in case
+    * of potential issues. This should be removed when we get ReBAR.
+    */
+   if (image->vk.usage & VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT) {
+      for (uint32_t i = 0; i < pdev->mem_type_count; i++) {
+         if (!(pdev->mem_types[i].propertyFlags &
+               VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))
+            memory_types &= ~BITFIELD_BIT(i);
+      }
+   }
+
+   // TODO hope for the best?
+
+   uint64_t size_B = 0;
+   uint32_t align_B = 0;
+   if (image->disjoint) {
+      uint8_t plane = kk_image_memory_aspects_to_plane(image, aspects);
+      kk_image_plane_add_req(dev, image, &image->planes[plane], &size_B,
+                             &align_B);
+   } else {
+      for (unsigned plane = 0; plane < image->plane_count; plane++) {
+         kk_image_plane_add_req(dev, image, &image->planes[plane], &size_B,
+                                &align_B);
+      }
+   }
+
+   if (image->stencil_copy_temp.layout.size_B > 0) {
+      kk_image_plane_add_req(dev, image, &image->stencil_copy_temp, &size_B,
+                             &align_B);
+   }
+
+   pMemoryRequirements->memoryRequirements.memoryTypeBits = memory_types;
+   pMemoryRequirements->memoryRequirements.alignment = align_B;
+   pMemoryRequirements->memoryRequirements.size = size_B;
+
+   vk_foreach_struct_const(ext, pMemoryRequirements->pNext) {
+      switch (ext->sType) {
+      case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
+         VkMemoryDedicatedRequirements *dedicated = (void *)ext;
+         dedicated->prefersDedicatedAllocation =
+            image->vk.tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
+         dedicated->requiresDedicatedAllocation =
+            image->vk.tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
+         break;
+      }
+      default:
+         vk_debug_ignored_stype(ext->sType);
+         break;
+      }
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetImageMemoryRequirements2(VkDevice device,
+                               const VkImageMemoryRequirementsInfo2 *pInfo,
+                               VkMemoryRequirements2 *pMemoryRequirements)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_image, image, pInfo->image);
+
+   const VkImagePlaneMemoryRequirementsInfo *plane_info =
+      vk_find_struct_const(pInfo->pNext, IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO);
+   const VkImageAspectFlags aspects =
+      image->disjoint ? plane_info->planeAspect : image->vk.aspects;
+
+   kk_get_image_memory_requirements(dev, image, aspects, pMemoryRequirements);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetDeviceImageMemoryRequirements(VkDevice device,
+                                    const VkDeviceImageMemoryRequirements *pInfo,
+                                    VkMemoryRequirements2 *pMemoryRequirements)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   ASSERTED VkResult result;
+   struct kk_image image = {0};
+
+   result = kk_image_init(dev, &image, pInfo->pCreateInfo);
+   assert(result == VK_SUCCESS);
+
+   const VkImageAspectFlags aspects =
+      image.disjoint ? pInfo->planeAspect : image.vk.aspects;
+
+   kk_get_image_memory_requirements(dev, &image, aspects, pMemoryRequirements);
+
+   kk_image_finish(dev, &image, NULL);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetImageSparseMemoryRequirements2(
+   VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo,
+   uint32_t *pSparseMemoryRequirementCount,
+   VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
+{
+   *pSparseMemoryRequirementCount = 0u;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetDeviceImageSparseMemoryRequirements(
+   VkDevice device, const VkDeviceImageMemoryRequirements *pInfo,
+   uint32_t *pSparseMemoryRequirementCount,
+   VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
+{
+   *pSparseMemoryRequirementCount = 0u;
+}
+
+static void
+kk_get_image_subresource_layout(struct kk_device *dev, struct kk_image *image,
+                                const VkImageSubresource2KHR *pSubresource,
+                                VkSubresourceLayout2KHR *pLayout)
+{
+   const VkImageSubresource *isr = &pSubresource->imageSubresource;
+
+   const uint8_t p = kk_image_memory_aspects_to_plane(image, isr->aspectMask);
+   const struct kk_image_plane *plane = &image->planes[p];
+
+   uint64_t offset_B = 0;
+   if (!image->disjoint) {
+      uint32_t align_B = 0;
+      for (unsigned i = 0; i < p; i++) {
+         kk_image_plane_add_req(dev, image, &image->planes[i], &offset_B,
+                                &align_B);
+      }
+   }
+
+   pLayout->subresourceLayout = (VkSubresourceLayout){
+      .offset = offset_B,
+      .size = plane->layout.size_B,
+      .rowPitch = plane->layout.linear_stride_B,
+      .arrayPitch = plane->layout.layer_stride_B,
+      .depthPitch = 1u,
+   };
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetImageSubresourceLayout2KHR(VkDevice device, VkImage _image,
+                                 const VkImageSubresource2KHR *pSubresource,
+                                 VkSubresourceLayout2KHR *pLayout)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_image, image, _image);
+
+   kk_get_image_subresource_layout(dev, image, pSubresource, pLayout);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetDeviceImageSubresourceLayoutKHR(
+   VkDevice device, const VkDeviceImageSubresourceInfoKHR *pInfo,
+   VkSubresourceLayout2KHR *pLayout)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   ASSERTED VkResult result;
+   struct kk_image image = {0};
+
+   result = kk_image_init(dev, &image, pInfo->pCreateInfo);
+   assert(result == VK_SUCCESS);
+
+   kk_get_image_subresource_layout(dev, &image, pInfo->pSubresource, pLayout);
+
+   kk_image_finish(dev, &image, NULL);
+}
+
+static VkResult
+kk_image_plane_bind(struct kk_device *dev, struct kk_image *image,
+                    struct kk_image_plane *plane, struct kk_device_memory *mem,
+                    uint64_t *offset_B)
+{
+   uint64_t plane_size_B, plane_align_B;
+   kk_image_plane_size_align_B(dev, image, plane, &plane_size_B,
+                               &plane_align_B);
+   *offset_B = align64(*offset_B, plane_align_B);
+
+   /* Linear textures in Metal need to be allocated through a buffer... */
+   if (plane->layout.optimized_layout)
+      plane->mtl_handle = mtl_new_texture_with_descriptor(
+         mem->bo->mtl_handle, &plane->layout, *offset_B);
+   else
+      plane->mtl_handle = mtl_new_texture_with_descriptor_linear(
+         mem->bo->map, &plane->layout, *offset_B);
+   plane->addr = mem->bo->gpu + *offset_B;
+
+   /* Create auxiliary 2D array texture for 3D images so we can use 2D views of
+    * it */
+   if (plane->layout.type == MTL_TEXTURE_TYPE_3D &&
+       (image->vk.create_flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT)) {
+      struct kk_image_layout array_layout = plane->layout;
+      array_layout.type = MTL_TEXTURE_TYPE_2D_ARRAY;
+      // TODO_KOSMICKRISP We need to make sure that this doesn't go over Metal's
+      // layer maximum which is 2048. Probably by limiting the dimensions and
+      // layers for 3D images
+      array_layout.layers = array_layout.layers * array_layout.depth_px;
+      array_layout.depth_px = 1u;
+      plane->mtl_handle_array = mtl_new_texture_with_descriptor(
+         mem->bo->mtl_handle, &array_layout, *offset_B);
+   }
+
+   *offset_B += plane_size_B;
+
+   return VK_SUCCESS;
+}
+
+static VkResult
+kk_bind_image_memory(struct kk_device *dev, const VkBindImageMemoryInfo *info)
+{
+   VK_FROM_HANDLE(kk_device_memory, mem, info->memory);
+   VK_FROM_HANDLE(kk_image, image, info->image);
+   VkResult result;
+
+   /* Ignore this struct on Android, we cannot access swapchain structures
+    * there. */
+#ifdef KK_USE_WSI_PLATFORM
+   const VkBindImageMemorySwapchainInfoKHR *swapchain_info =
+      vk_find_struct_const(info->pNext, BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR);
+
+   if (swapchain_info && swapchain_info->swapchain != VK_NULL_HANDLE) {
+      VK_FROM_HANDLE(wsi_swapchain, swapchain, swapchain_info->swapchain);
+      VkImage _wsi_image =
+         swapchain->get_wsi_image(swapchain, swapchain_info->imageIndex)->image;
+      VK_FROM_HANDLE(kk_image, wsi_img, _wsi_image);
+
+      assert(image->plane_count == 1);
+      assert(wsi_img->plane_count == 1);
+
+      struct kk_image_plane *plane = &image->planes[0];
+      struct kk_image_plane *swapchain_plane = &wsi_img->planes[0];
+
+      /* Copy swapchain plane data retaining relevant resources. */
+      plane->layout = swapchain_plane->layout;
+      plane->mtl_handle = mtl_retain(swapchain_plane->mtl_handle);
+      plane->mtl_handle_array =
+         swapchain_plane->mtl_handle_array
+            ? mtl_retain(swapchain_plane->mtl_handle_array)
+            : NULL;
+      plane->addr = swapchain_plane->addr;
+
+      return VK_SUCCESS;
+   }
+#endif
+
+   uint64_t offset_B = info->memoryOffset;
+   if (image->disjoint) {
+      const VkBindImagePlaneMemoryInfo *plane_info =
+         vk_find_struct_const(info->pNext, BIND_IMAGE_PLANE_MEMORY_INFO);
+      const uint8_t plane =
+         kk_image_memory_aspects_to_plane(image, plane_info->planeAspect);
+      result =
+         kk_image_plane_bind(dev, image, &image->planes[plane], mem, &offset_B);
+      if (result != VK_SUCCESS)
+         return result;
+   } else {
+      for (unsigned plane = 0; plane < image->plane_count; plane++) {
+         result = kk_image_plane_bind(dev, image, &image->planes[plane], mem,
+                                      &offset_B);
+         if (result != VK_SUCCESS)
+            return result;
+      }
+   }
+
+   if (image->stencil_copy_temp.layout.size_B > 0) {
+      result = kk_image_plane_bind(dev, image, &image->stencil_copy_temp, mem,
+                                   &offset_B);
+      if (result != VK_SUCCESS)
+         return result;
+   }
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_BindImageMemory2(VkDevice device, uint32_t bindInfoCount,
+                    const VkBindImageMemoryInfo *pBindInfos)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VkResult first_error_or_success = VK_SUCCESS;
+
+   for (uint32_t i = 0; i < bindInfoCount; ++i) {
+      VkResult result = kk_bind_image_memory(dev, &pBindInfos[i]);
+
+      const VkBindMemoryStatusKHR *status =
+         vk_find_struct_const(pBindInfos[i].pNext, BIND_MEMORY_STATUS_KHR);
+      if (status != NULL && status->pResult != NULL)
+         *status->pResult = VK_SUCCESS;
+
+      if (first_error_or_success == VK_SUCCESS)
+         first_error_or_success = result;
+   }
+
+   return first_error_or_success;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_GetImageOpaqueCaptureDescriptorDataEXT(
+   VkDevice _device, const VkImageCaptureDescriptorDataInfoEXT *pInfo,
+   void *pData)
+{
+   return VK_SUCCESS;
+}
diff --git a/src/kosmickrisp/vulkan/kk_image.h b/src/kosmickrisp/vulkan/kk_image.h
new file mode 100644
index 00000000000..7ef11db3133
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_image.h
@@ -0,0 +1,155 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_IMAGE_H
+#define KK_IMAGE_H 1
+
+#include "kk_private.h"
+
+#include "kk_device_memory.h"
+#include "kk_image_layout.h"
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "vk_image.h"
+
+/* Because small images can end up with an array_stride_B that is less than
+ * the sparse block size (in bytes), we have to set SINGLE_MIPTAIL_BIT when
+ * advertising sparse properties to the client.  This means that we get one
+ * single memory range for the miptail of the image.  For large images with
+ * mipTailStartLod > 0, we have to deal with the array stride ourselves.
+ *
+ * We do this by returning NVK_MIP_TAIL_START_OFFSET as the image's
+ * imageMipTailOffset.  We can then detect anything with that address as
+ * being part of the miptail and re-map it accordingly.  The Vulkan spec
+ * explicitly allows for this.
+ *
+ * From the Vulkan 1.3.279 spec:
+ *
+ *    "When VK_SPARSE_MEMORY_BIND_METADATA_BIT is present, the resourceOffset
+ *    must have been derived explicitly from the imageMipTailOffset in the
+ *    sparse resource properties returned for the metadata aspect. By
+ *    manipulating the value returned for imageMipTailOffset, the
+ *    resourceOffset does not have to correlate directly to a device virtual
+ *    address offset, and may instead be whatever value makes it easiest for
+ *    the implementation to derive the correct device virtual address."
+ */
+#define NVK_MIP_TAIL_START_OFFSET 0x6d74000000000000UL
+
+struct kk_device_memory;
+struct kk_physical_device;
+struct kk_queue;
+
+VkFormatFeatureFlags2
+kk_get_image_format_features(struct kk_physical_device *pdevice,
+                             VkFormat format, VkImageTiling tiling,
+                             uint64_t drm_format_mod);
+
+uint32_t kk_image_max_dimension(VkImageType image_type);
+
+struct kk_image_plane {
+   struct kk_image_layout layout;
+   // TODO_KOSMICKRISP Only have one handle since we will only create 2D arrays
+   // anyway
+   /* Metal handle with original handle type */
+   mtl_texture *mtl_handle;
+   /* Metal handle with 2D array type for 3D images */
+   mtl_texture *mtl_handle_array;
+   uint64_t addr;
+};
+
+struct kk_image {
+   struct vk_image vk;
+
+   /** True if the planes are bound separately
+    * * This is set based on VK_IMAGE_CREATE_DISJOINT_BIT
+    */
+   bool disjoint;
+
+   uint8_t plane_count;
+   struct kk_image_plane planes[3];
+
+   /* In order to support D32_SFLOAT_S8_UINT, a temp area is
+    * needed. The stencil plane can't be a copied using the DMA
+    * engine in a single pass since it would need 8 components support.
+    * Instead we allocate a 16-bit temp, that gets copied into, then
+    * copied again down to the 8-bit result.
+    */
+   struct kk_image_plane stencil_copy_temp;
+};
+
+static inline mtl_resource *
+kk_image_to_mtl_resource(const struct kk_image *image, int plane)
+{
+   if (image != NULL) {
+      assert(plane < ARRAY_SIZE(image->planes));
+      return (mtl_resource *)image->planes[plane].mtl_handle;
+   }
+   return NULL;
+}
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_image, vk.base, VkImage, VK_OBJECT_TYPE_IMAGE)
+
+static inline uint64_t
+kk_image_plane_base_address(const struct kk_image_plane *plane)
+{
+   return plane->addr;
+}
+
+static inline uint64_t
+kk_image_base_address(const struct kk_image *image, uint8_t plane)
+{
+   return kk_image_plane_base_address(&image->planes[plane]);
+}
+
+static inline uint8_t
+kk_image_aspects_to_plane(ASSERTED const struct kk_image *image,
+                          VkImageAspectFlags aspectMask)
+{
+   /* Memory planes are only allowed for memory operations */
+   assert(!(aspectMask & (VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT |
+                          VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT |
+                          VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT |
+                          VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT)));
+
+   /* Verify that the aspects are actually in the image */
+   assert(!(aspectMask & ~image->vk.aspects));
+
+   /* Must only be one aspect unless it's depth/stencil */
+   assert(aspectMask ==
+             (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) ||
+          util_bitcount(aspectMask) == 1);
+
+   switch (aspectMask) {
+   case VK_IMAGE_ASPECT_PLANE_1_BIT:
+      return 1;
+   case VK_IMAGE_ASPECT_PLANE_2_BIT:
+      return 2;
+   default:
+      return 0;
+   }
+}
+
+static inline uint8_t
+kk_image_memory_aspects_to_plane(ASSERTED const struct kk_image *image,
+                                 VkImageAspectFlags aspectMask)
+{
+   if (aspectMask & (VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT |
+                     VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT |
+                     VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT |
+                     VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT)) {
+      /* We don't support DRM format modifiers on anything but single-plane
+       * color at the moment.
+       */
+      assert(aspectMask == VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT);
+      return 0;
+   } else {
+      return kk_image_aspects_to_plane(image, aspectMask);
+   }
+}
+
+#endif
diff --git a/src/kosmickrisp/vulkan/kk_image_layout.c b/src/kosmickrisp/vulkan/kk_image_layout.c
new file mode 100644
index 00000000000..06d4ed8754a
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_image_layout.c
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_image_layout.h"
+
+#include "kk_device.h"
+#include "kk_format.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+#include "kosmickrisp/bridge/mtl_format.h"
+
+#include "util/format/u_format.h"
+
+static enum mtl_texture_type
+vk_image_create_info_to_mtl_texture_type(
+   const struct VkImageCreateInfo *create_info)
+{
+   uint32_t array_layers = create_info->arrayLayers;
+   uint32_t samples = create_info->samples;
+   switch (create_info->imageType) {
+   case VK_IMAGE_TYPE_1D:
+   case VK_IMAGE_TYPE_2D:
+      /* We require input attachments to be arrays */
+      if (array_layers > 1 ||
+          (create_info->usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT))
+         return samples > 1u ? MTL_TEXTURE_TYPE_2D_ARRAY_MULTISAMPLE
+                             : MTL_TEXTURE_TYPE_2D_ARRAY;
+      return samples > 1u ? MTL_TEXTURE_TYPE_2D_MULTISAMPLE
+                          : MTL_TEXTURE_TYPE_2D;
+   case VK_IMAGE_TYPE_3D:
+      return MTL_TEXTURE_TYPE_3D;
+   default:
+      UNREACHABLE("Invalid image type");
+      return MTL_TEXTURE_TYPE_1D; /* Just return a type we don't actually use */
+   }
+}
+
+static enum mtl_texture_usage
+vk_image_usage_flags_to_mtl_texture_usage(VkImageUsageFlags usage_flags,
+                                          VkImageCreateFlags create_flags,
+                                          bool supports_atomics)
+{
+   enum mtl_texture_usage usage = 0u;
+
+   const VkImageUsageFlags shader_write =
+      VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_STORAGE_BIT;
+   if (usage_flags & shader_write)
+      usage |= MTL_TEXTURE_USAGE_SHADER_WRITE;
+
+   const VkImageUsageFlags shader_read = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+                                         VK_IMAGE_USAGE_SAMPLED_BIT |
+                                         VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+   if (usage_flags & shader_read)
+      usage |= MTL_TEXTURE_USAGE_SHADER_READ;
+
+   const VkImageUsageFlags render_attachment =
+      VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+      VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
+      VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+
+   if (usage_flags & render_attachment)
+      usage |= MTL_TEXTURE_USAGE_RENDER_TARGET;
+
+   if (create_flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT)
+      usage |= MTL_TEXTURE_USAGE_PIXEL_FORMAT_VIEW;
+
+   if (supports_atomics) {
+      usage |= MTL_TEXTURE_USAGE_SHADER_READ;
+      usage |= MTL_TEXTURE_USAGE_SHADER_WRITE;
+      usage |= MTL_TEXTURE_USAGE_SHADER_ATOMIC;
+   }
+
+   return usage;
+}
+
+void
+kk_image_layout_init(const struct kk_device *dev,
+                     const struct VkImageCreateInfo *create_info,
+                     enum pipe_format format, const uint8_t width_scale,
+                     const uint8_t height_scale, struct kk_image_layout *layout)
+{
+   const struct kk_va_format *supported_format = kk_get_va_format(format);
+   layout->type = vk_image_create_info_to_mtl_texture_type(create_info);
+   layout->width_px = create_info->extent.width / width_scale;
+   layout->height_px = create_info->extent.height / height_scale;
+   layout->depth_px = create_info->extent.depth;
+   layout->layers = create_info->arrayLayers;
+   layout->levels = create_info->mipLevels;
+   layout->optimized_layout = create_info->tiling == VK_IMAGE_TILING_OPTIMAL;
+   layout->usage = vk_image_usage_flags_to_mtl_texture_usage(
+      create_info->usage, create_info->flags, supported_format->atomic);
+   layout->format.pipe = format;
+   layout->format.mtl = supported_format->mtl_pixel_format;
+   layout->swizzle.red = supported_format->swizzle.red;
+   layout->swizzle.green = supported_format->swizzle.green;
+   layout->swizzle.blue = supported_format->swizzle.blue;
+   layout->swizzle.alpha = supported_format->swizzle.alpha;
+   layout->sample_count_sa = create_info->samples;
+   mtl_heap_texture_size_and_align_with_descriptor(dev->mtl_handle, layout);
+
+   /*
+    * Metal requires adding MTL_TEXTURE_USAGE_PIXEL_FORMAT_VIEW if we are going
+    * to reinterpret the format with a different format. This seems to be the
+    * only format with this issue.
+    */
+   if (format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT) {
+      layout->usage |= MTL_TEXTURE_USAGE_PIXEL_FORMAT_VIEW;
+   }
+
+   // TODO_KOSMICKRISP Fill remaining offsets and strides whenever possible
+   if (create_info->tiling == VK_IMAGE_TILING_LINEAR) {
+      const struct util_format_description *format_desc =
+         util_format_description(layout->format.pipe);
+      size_t bytes_per_texel = format_desc->block.bits / 8;
+      layout->linear_stride_B =
+         align(bytes_per_texel * layout->width_px, layout->align_B);
+      layout->layer_stride_B = layout->linear_stride_B * layout->height_px;
+      /* Metal only allows for 2D texture with no mipmapping. */
+      layout->size_B = layout->layer_stride_B;
+   }
+}
diff --git a/src/kosmickrisp/vulkan/kk_image_layout.h b/src/kosmickrisp/vulkan/kk_image_layout.h
new file mode 100644
index 00000000000..70b1c2bfe68
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_image_layout.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_IMAGE_LAYOUT_H
+#define KK_IMAGE_LAYOUT_H 1
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "util/format/u_formats.h"
+
+#include "vulkan/vulkan.h"
+
+#define KK_MAX_MIP_LEVELS 16
+
+struct kk_device;
+struct VkImageCreateInfo;
+enum pipe_swizzle;
+
+struct kk_image_layout {
+   /** Width, height, and depth in pixels at level 0 */
+   uint32_t width_px, height_px, depth_px, layers;
+
+   enum mtl_texture_type type;
+
+   /** Number of samples per pixel. 1 if multisampling is disabled. */
+   uint8_t sample_count_sa;
+
+   /** Number of miplevels. 1 if no mipmapping is used. */
+   uint8_t levels;
+
+   uint8_t optimized_layout;
+
+   enum mtl_texture_usage usage;
+
+   /** Texture format */
+   struct {
+      enum pipe_format pipe;
+      uint32_t mtl;
+   } format;
+
+   /* Required to correctly set image swizzle for non-native formats */
+   /* Would love to use enum pipe_swizzle, but it's bigger than the required
+    * type for util_format_compose_swizzles... */
+   struct {
+      uint8_t red;
+      uint8_t green;
+      uint8_t blue;
+      uint8_t alpha;
+   } swizzle;
+
+   /**
+    * If tiling is LINEAR, the number of bytes between adjacent rows of
+    * elements. Otherwise, this field is zero.
+    */
+   uint32_t linear_stride_B;
+
+   /**
+    * Stride between layers of an array texture, including a cube map. Layer i
+    * begins at offset (i * layer_stride_B) from the beginning of the texture.
+    *
+    * If depth_px = 1, the value of this field is UNDEFINED.
+    */
+   uint64_t layer_stride_B;
+
+   /**
+    * Offsets of mip levels within a layer.
+    */
+   uint64_t level_offsets_B[KK_MAX_MIP_LEVELS];
+
+   /**
+    * If tiling is TWIDDLED, the stride in elements used for each mip level
+    * within a layer. Calculating level strides is the sole responsibility of
+    * ail_initialized_twiddled. This is necessary because compressed pixel
+    * formats may add extra stride padding.
+    */
+   uint32_t stride_el[KK_MAX_MIP_LEVELS];
+
+   /* Size of entire texture */
+   uint64_t size_B;
+
+   /* Alignment required */
+   uint64_t align_B;
+};
+
+struct kk_view_layout {
+   /** Type */
+   VkImageViewType view_type;
+
+   /** Number of samples per pixel. 1 if multisampling is disabled.
+    * Required to be able to correctly set the MTLTextureType.
+    */
+   uint8_t sample_count_sa;
+
+   /** Texture format */
+   struct {
+      enum pipe_format pipe;
+      uint32_t mtl;
+   } format;
+
+   /** Array base level. 0 if no array is used. */
+   uint16_t base_array_layer;
+
+   /** Array length. 1 if no array is used. */
+   uint16_t array_len;
+
+   /** Swizzle */
+   /* Would love to use enum pipe_swizzle, but it's bigger than the required
+    * type for util_format_compose_swizzles... */
+   struct {
+      union {
+         struct {
+            uint8_t red;
+            uint8_t green;
+            uint8_t blue;
+            uint8_t alpha;
+         };
+         uint8_t channels[4];
+      };
+   } swizzle;
+
+   /** Mipmap base level. 0 if no mipmapping is used. */
+   uint8_t base_level;
+
+   /** Number of miplevels. 1 if no mipmapping is used. */
+   uint8_t num_levels;
+
+   uint16_t min_lod_clamp;
+};
+
+void kk_image_layout_init(const struct kk_device *dev,
+                          const struct VkImageCreateInfo *create_info,
+                          enum pipe_format format, const uint8_t width_scale,
+                          const uint8_t height_scale,
+                          struct kk_image_layout *layout);
+
+#endif /* KK_IMAGE_LAYOUT_H */
diff --git a/src/kosmickrisp/vulkan/kk_image_view.c b/src/kosmickrisp/vulkan/kk_image_view.c
new file mode 100644
index 00000000000..ed8bd485972
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_image_view.c
@@ -0,0 +1,267 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_image_view.h"
+
+#include "kk_device.h"
+#include "kk_entrypoints.h"
+#include "kk_format.h"
+#include "kk_image.h"
+#include "kk_physical_device.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+#include "kosmickrisp/bridge/mtl_format.h"
+
+#include "vk_format.h"
+
+static enum pipe_swizzle
+vk_swizzle_to_pipe(VkComponentSwizzle swizzle)
+{
+   switch (swizzle) {
+   case VK_COMPONENT_SWIZZLE_R:
+      return PIPE_SWIZZLE_X;
+   case VK_COMPONENT_SWIZZLE_G:
+      return PIPE_SWIZZLE_Y;
+   case VK_COMPONENT_SWIZZLE_B:
+      return PIPE_SWIZZLE_Z;
+   case VK_COMPONENT_SWIZZLE_A:
+      return PIPE_SWIZZLE_W;
+   case VK_COMPONENT_SWIZZLE_ONE:
+      return PIPE_SWIZZLE_1;
+   case VK_COMPONENT_SWIZZLE_ZERO:
+      return PIPE_SWIZZLE_0;
+   default:
+      UNREACHABLE("Invalid component swizzle");
+   }
+}
+
+static enum VkImageViewType
+remove_1d_view_types(enum VkImageViewType type)
+{
+   if (type == VK_IMAGE_VIEW_TYPE_1D)
+      return VK_IMAGE_VIEW_TYPE_2D;
+   if (type == VK_IMAGE_VIEW_TYPE_1D_ARRAY)
+      return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
+   return type;
+}
+
+VkResult
+kk_image_view_init(struct kk_device *dev, struct kk_image_view *view,
+                   const VkImageViewCreateInfo *pCreateInfo)
+{
+   VK_FROM_HANDLE(kk_image, image, pCreateInfo->image);
+
+   memset(view, 0, sizeof(*view));
+
+   vk_image_view_init(&dev->vk, &view->vk, pCreateInfo);
+
+   /* First, figure out which image planes we need.
+    * For depth/stencil, we only have plane so simply assert
+    * and then map directly betweeen the image and view plane
+    */
+   if (image->vk.aspects &
+       (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
+      assert(image->plane_count == 1);
+      assert(kk_image_aspects_to_plane(image, view->vk.aspects) == 0);
+      view->plane_count = 1;
+      view->planes[0].image_plane = 0;
+   } else {
+      /* For other formats, retrieve the plane count from the aspect mask
+       * and then walk through the aspect mask to map each image plane
+       * to its corresponding view plane
+       */
+      assert(util_bitcount(view->vk.aspects) ==
+             vk_format_get_plane_count(view->vk.format));
+      view->plane_count = 0;
+      u_foreach_bit(aspect_bit, view->vk.aspects) {
+         uint8_t image_plane =
+            kk_image_aspects_to_plane(image, 1u << aspect_bit);
+         view->planes[view->plane_count++].image_plane = image_plane;
+      }
+   }
+   /* Finally, fill in each view plane separately */
+   for (unsigned view_plane = 0; view_plane < view->plane_count; view_plane++) {
+      const uint8_t image_plane = view->planes[view_plane].image_plane;
+      struct kk_image_plane *plane = &image->planes[image_plane];
+
+      const struct vk_format_ycbcr_info *ycbcr_info =
+         vk_format_get_ycbcr_info(view->vk.format);
+      assert(ycbcr_info || view_plane == 0);
+      VkFormat plane_format =
+         ycbcr_info ? ycbcr_info->planes[view_plane].format : view->vk.format;
+      enum pipe_format p_format = vk_format_to_pipe_format(plane_format);
+      if (view->vk.aspects == VK_IMAGE_ASPECT_DEPTH_BIT)
+         p_format = vk_format_to_pipe_format(image->vk.format);
+      else if (view->vk.aspects == VK_IMAGE_ASPECT_STENCIL_BIT)
+         p_format = util_format_stencil_only(
+            vk_format_to_pipe_format(image->vk.format));
+
+      view->planes[view_plane].format = p_format;
+      const struct kk_va_format *supported_format = kk_get_va_format(p_format);
+      assert(supported_format);
+
+      struct kk_view_layout view_layout = {
+         .view_type = remove_1d_view_types(view->vk.view_type),
+         .sample_count_sa = plane->layout.sample_count_sa,
+         .format = {.pipe = p_format,
+                    .mtl = supported_format->mtl_pixel_format},
+         .base_level = view->vk.base_mip_level,
+         .num_levels = view->vk.level_count,
+         .base_array_layer = view->vk.base_array_layer,
+         .array_len = view->vk.layer_count,
+         .min_lod_clamp = view->vk.min_lod,
+      };
+      uint8_t view_swizzle[4] = {vk_swizzle_to_pipe(view->vk.swizzle.r),
+                                 vk_swizzle_to_pipe(view->vk.swizzle.g),
+                                 vk_swizzle_to_pipe(view->vk.swizzle.b),
+                                 vk_swizzle_to_pipe(view->vk.swizzle.a)};
+      util_format_compose_swizzles(supported_format->swizzle.channels,
+                                   view_swizzle, view_layout.swizzle.channels);
+
+      /* When sampling a depth/stencil texture Metal returns (d, d, d, 1), but
+       * Vulkan requires (d, 0, 0, 1). This means, we need to convert G and B to
+       * 0 */
+      if (util_format_is_depth_or_stencil(p_format)) {
+         if (view_layout.swizzle.red == PIPE_SWIZZLE_Y ||
+             view_layout.swizzle.red == PIPE_SWIZZLE_Z)
+            view_layout.swizzle.red = PIPE_SWIZZLE_0;
+         if (view_layout.swizzle.green == PIPE_SWIZZLE_Y ||
+             view_layout.swizzle.green == PIPE_SWIZZLE_Z)
+            view_layout.swizzle.green = PIPE_SWIZZLE_0;
+         if (view_layout.swizzle.blue == PIPE_SWIZZLE_Y ||
+             view_layout.swizzle.blue == PIPE_SWIZZLE_Z)
+            view_layout.swizzle.blue = PIPE_SWIZZLE_0;
+         if (view_layout.swizzle.alpha == PIPE_SWIZZLE_Y ||
+             view_layout.swizzle.alpha == PIPE_SWIZZLE_Z)
+            view_layout.swizzle.alpha = PIPE_SWIZZLE_0;
+      }
+
+      mtl_texture *mtl_handle = image->planes[image_plane].mtl_handle;
+      if (image->vk.image_type == VK_IMAGE_TYPE_3D &&
+          view->vk.view_type != VK_IMAGE_VIEW_TYPE_3D)
+         mtl_handle = image->planes[image_plane].mtl_handle_array;
+
+      if (view->vk.usage &
+          (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) {
+         view->planes[view_plane].mtl_handle_sampled =
+            mtl_new_texture_view_with(mtl_handle, &view_layout);
+         view->planes[view_plane].sampled_gpu_resource_id =
+            mtl_texture_get_gpu_resource_id(
+               view->planes[view_plane].mtl_handle_sampled);
+      }
+
+      if (view->vk.usage & VK_IMAGE_USAGE_STORAGE_BIT) {
+         /* For storage images, we can't have any cubes */
+         if (view->vk.view_type == VK_IMAGE_VIEW_TYPE_CUBE ||
+             view->vk.view_type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)
+            view_layout.view_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
+
+         view->planes[view_plane].mtl_handle_storage =
+            mtl_new_texture_view_with(mtl_handle, &view_layout);
+         view->planes[view_plane].storage_gpu_resource_id =
+            mtl_texture_get_gpu_resource_id(
+               view->planes[view_plane].mtl_handle_storage);
+      }
+
+      if (view->vk.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                            VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
+         bool requires_type_change =
+            view_layout.view_type != VK_IMAGE_VIEW_TYPE_3D &&
+            view_layout.view_type != VK_IMAGE_VIEW_TYPE_2D_ARRAY;
+         bool requires_format_change = view->vk.format != image->vk.format;
+         VkImageViewType original_type = view_layout.view_type;
+
+         /* Required so sampling from input attachments actually return (d, 0,
+          * 0, 1) for d/s attachments and render targets cannot have swizzle
+          * according to Metal...
+          */
+         if (requires_type_change || requires_format_change) {
+            view_layout.view_type = requires_type_change
+                                       ? VK_IMAGE_VIEW_TYPE_2D_ARRAY
+                                       : original_type;
+            view->planes[view_plane].mtl_handle_input =
+               mtl_new_texture_view_with(mtl_handle, &view_layout);
+         } else
+            view->planes[view_plane].mtl_handle_input = mtl_retain(mtl_handle);
+         view->planes[view_plane].input_gpu_resource_id =
+            mtl_texture_get_gpu_resource_id(
+               view->planes[view_plane].mtl_handle_input);
+
+         /* Handle mutable formats */
+         if (requires_format_change) {
+            view_layout.view_type = original_type;
+            view_layout.base_array_layer = 0u;
+            view_layout.base_level = 0u;
+            view_layout.array_len = image->vk.array_layers;
+            view_layout.num_levels = image->vk.mip_levels;
+            view->planes[view_plane].mtl_handle_render =
+               mtl_new_texture_view_with_no_swizzle(mtl_handle, &view_layout);
+         } else
+            view->planes[view_plane].mtl_handle_render = mtl_retain(mtl_handle);
+      }
+   }
+
+   return VK_SUCCESS;
+}
+
+void
+kk_image_view_finish(struct kk_device *dev, struct kk_image_view *view)
+{
+   for (uint8_t plane = 0; plane < view->plane_count; plane++) {
+      if (view->planes[plane].mtl_handle_sampled)
+         mtl_release(view->planes[plane].mtl_handle_sampled);
+
+      if (view->planes[plane].mtl_handle_storage)
+         mtl_release(view->planes[plane].mtl_handle_storage);
+
+      if (view->planes[plane].mtl_handle_input)
+         mtl_release(view->planes[plane].mtl_handle_input);
+
+      if (view->planes[plane].mtl_handle_render)
+         mtl_release(view->planes[plane].mtl_handle_render);
+   }
+
+   vk_image_view_finish(&view->vk);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_CreateImageView(VkDevice _device, const VkImageViewCreateInfo *pCreateInfo,
+                   const VkAllocationCallbacks *pAllocator, VkImageView *pView)
+{
+   VK_FROM_HANDLE(kk_device, dev, _device);
+   struct kk_image_view *view;
+   VkResult result;
+
+   view = vk_alloc2(&dev->vk.alloc, pAllocator, sizeof(*view), 8,
+                    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+   if (!view)
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   result = kk_image_view_init(dev, view, pCreateInfo);
+   if (result != VK_SUCCESS) {
+      vk_free2(&dev->vk.alloc, pAllocator, view);
+      return result;
+   }
+
+   *pView = kk_image_view_to_handle(view);
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_DestroyImageView(VkDevice _device, VkImageView imageView,
+                    const VkAllocationCallbacks *pAllocator)
+{
+   VK_FROM_HANDLE(kk_device, dev, _device);
+   VK_FROM_HANDLE(kk_image_view, view, imageView);
+
+   if (!view)
+      return;
+
+   kk_image_view_finish(dev, view);
+   vk_free2(&dev->vk.alloc, pAllocator, view);
+}
diff --git a/src/kosmickrisp/vulkan/kk_image_view.h b/src/kosmickrisp/vulkan/kk_image_view.h
new file mode 100644
index 00000000000..1a18c5d6f66
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_image_view.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_IMAGE_VIEW_H
+#define KK_IMAGE_VIEW_H 1
+
+#include "kk_private.h"
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "util/format/u_formats.h"
+
+#include "vk_image.h"
+
+struct kk_device;
+
+struct kk_image_view {
+   struct vk_image_view vk;
+
+   uint8_t plane_count;
+   struct {
+      uint8_t image_plane;
+
+      enum pipe_format format;
+
+      mtl_texture *mtl_handle_sampled;
+      mtl_texture
+         *mtl_handle_storage; // TODO_KOSMICKRISP We can probably get rid of
+                              // this once we lower 2D cubes and 3D to 2D array?
+
+      /* Cached handle so we don't have to retrieve it from the image when we
+       * render */
+      mtl_texture *mtl_handle_render;
+
+      /* Input attachment handle. Required since input attachments needs to be
+       * arrays, and sampled may not be */
+      mtl_texture *mtl_handle_input;
+
+      uint64_t sampled_gpu_resource_id;
+      uint64_t storage_gpu_resource_id;
+      uint64_t input_gpu_resource_id;
+   } planes[3];
+};
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_image_view, vk.base, VkImageView,
+                               VK_OBJECT_TYPE_IMAGE_VIEW)
+
+VkResult kk_image_view_init(struct kk_device *dev, struct kk_image_view *view,
+                            const VkImageViewCreateInfo *pCreateInfo);
+
+void kk_image_view_finish(struct kk_device *dev, struct kk_image_view *view);
+
+#endif /* KK_IMAGE_VIEW_H */
diff --git a/src/kosmickrisp/vulkan/kk_instance.c b/src/kosmickrisp/vulkan/kk_instance.c
new file mode 100644
index 00000000000..a51f2fd958b
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_instance.c
@@ -0,0 +1,225 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_instance.h"
+
+#include "kk_debug.h"
+#include "kk_entrypoints.h"
+#include "kk_physical_device.h"
+
+#include "kk_dispatch_trampolines.h"
+
+#include "vulkan/wsi/wsi_common.h"
+
+#include "util/build_id.h"
+#include "util/driconf.h"
+#include "util/mesa-sha1.h"
+#include "util/u_debug.h"
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_EnumerateInstanceVersion(uint32_t *pApiVersion)
+{
+   uint32_t version_override = vk_get_version_override();
+   *pApiVersion = version_override ? version_override
+                                   : VK_MAKE_VERSION(1, 3, VK_HEADER_VERSION);
+
+   return VK_SUCCESS;
+}
+
+static const struct vk_instance_extension_table instance_extensions = {
+#ifdef KK_USE_WSI_PLATFORM
+   .KHR_get_surface_capabilities2 = true,
+   .KHR_surface = true,
+   .KHR_surface_protected_capabilities = true,
+   .EXT_surface_maintenance1 = true,
+   .EXT_swapchain_colorspace = true,
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+   .KHR_wayland_surface = true,
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+   .KHR_xcb_surface = true,
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+   .KHR_xlib_surface = true,
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+   .EXT_acquire_xlib_display = true,
+#endif
+#ifdef VK_USE_PLATFORM_DISPLAY_KHR
+   .KHR_display = true,
+   .KHR_get_display_properties2 = true,
+   .EXT_direct_mode_display = true,
+   .EXT_display_surface_counter = true,
+   .EXT_acquire_drm_display = true,
+#endif
+#ifdef VK_USE_PLATFORM_METAL_EXT
+   .EXT_metal_surface = true,
+#endif
+#ifndef VK_USE_PLATFORM_METAL_EXT
+   .EXT_headless_surface = true,
+#endif
+   .KHR_device_group_creation = true,
+   .KHR_external_fence_capabilities = true,
+   .KHR_external_memory_capabilities = true,
+   .KHR_external_semaphore_capabilities = true,
+   .KHR_get_physical_device_properties2 = true,
+   .EXT_debug_report = true,
+   .EXT_debug_utils = true,
+};
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_EnumerateInstanceExtensionProperties(const char *pLayerName,
+                                        uint32_t *pPropertyCount,
+                                        VkExtensionProperties *pProperties)
+{
+   if (pLayerName)
+      return vk_error(NULL, VK_ERROR_LAYER_NOT_PRESENT);
+
+   return vk_enumerate_instance_extension_properties(
+      &instance_extensions, pPropertyCount, pProperties);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
+                  const VkAllocationCallbacks *pAllocator,
+                  VkInstance *pInstance)
+{
+   struct kk_instance *instance;
+   VkResult result;
+
+   if (pAllocator == NULL)
+      pAllocator = vk_default_allocator();
+
+   instance = vk_alloc(pAllocator, sizeof(*instance), 8,
+                       VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+   if (!instance)
+      return vk_error(NULL, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   struct vk_instance_dispatch_table dispatch_table;
+   vk_instance_dispatch_table_from_entrypoints(&dispatch_table,
+                                               &kk_instance_entrypoints, true);
+   vk_instance_dispatch_table_from_entrypoints(
+      &dispatch_table, &wsi_instance_entrypoints, false);
+
+   result = vk_instance_init(&instance->vk, &instance_extensions,
+                             &dispatch_table, pCreateInfo, pAllocator);
+   if (result != VK_SUCCESS)
+      goto fail_alloc;
+
+   instance->vk.physical_devices.enumerate = kk_enumerate_physical_devices;
+   instance->vk.physical_devices.destroy = kk_physical_device_destroy;
+
+   /* TODO_KOSMICKRISP We need to fill instance->driver_build_sha */
+
+   kk_process_debug_variable();
+
+   *pInstance = kk_instance_to_handle(instance);
+   return VK_SUCCESS;
+
+// fail_init:
+//    vk_instance_finish(&instance->vk);
+fail_alloc:
+   vk_free(pAllocator, instance);
+
+   return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_DestroyInstance(VkInstance _instance,
+                   const VkAllocationCallbacks *pAllocator)
+{
+   VK_FROM_HANDLE(kk_instance, instance, _instance);
+
+   if (!instance)
+      return;
+
+   vk_instance_finish(&instance->vk);
+   vk_free(&instance->vk.alloc, instance);
+}
+
+/* We need this to return our own trampoline functions */
+static PFN_vkVoidFunction
+kk_instance_get_proc_addr(const struct vk_instance *instance,
+                          const struct vk_instance_entrypoint_table *entrypoints,
+                          const char *name)
+{
+   PFN_vkVoidFunction func;
+
+   /* The Vulkan 1.0 spec for vkGetInstanceProcAddr has a table of exactly
+    * when we have to return valid function pointers, NULL, or it's left
+    * undefined.  See the table for exact details.
+    */
+   if (name == NULL)
+      return NULL;
+
+#define LOOKUP_VK_ENTRYPOINT(entrypoint)                                       \
+   if (strcmp(name, "vk" #entrypoint) == 0)                                    \
+   return (PFN_vkVoidFunction)entrypoints->entrypoint
+
+   LOOKUP_VK_ENTRYPOINT(EnumerateInstanceExtensionProperties);
+   LOOKUP_VK_ENTRYPOINT(EnumerateInstanceLayerProperties);
+   LOOKUP_VK_ENTRYPOINT(EnumerateInstanceVersion);
+   LOOKUP_VK_ENTRYPOINT(CreateInstance);
+
+   /* GetInstanceProcAddr() can also be called with a NULL instance.
+    * See https://gitlab.khronos.org/vulkan/vulkan/issues/2057
+    */
+   LOOKUP_VK_ENTRYPOINT(GetInstanceProcAddr);
+
+#undef LOOKUP_VK_ENTRYPOINT
+
+   /* Beginning with ICD interface v7, the following functions can also be
+    * retrieved via vk_icdGetInstanceProcAddr.
+    */
+
+   if (strcmp(name, "vk_icdNegotiateLoaderICDInterfaceVersion") == 0)
+      return (PFN_vkVoidFunction)vk_icdNegotiateLoaderICDInterfaceVersion;
+   if (strcmp(name, "vk_icdGetPhysicalDeviceProcAddr") == 0)
+      return (PFN_vkVoidFunction)vk_icdGetPhysicalDeviceProcAddr;
+#ifdef _WIN32
+   if (strcmp(name, "vk_icdEnumerateAdapterPhysicalDevices") == 0)
+      return (PFN_vkVoidFunction)vk_icdEnumerateAdapterPhysicalDevices;
+#endif
+
+   if (instance == NULL)
+      return NULL;
+
+   func = vk_instance_dispatch_table_get_if_supported(
+      &instance->dispatch_table, name, instance->app_info.api_version,
+      &instance->enabled_extensions);
+   if (func != NULL)
+      return func;
+
+   func = vk_physical_device_dispatch_table_get_if_supported(
+      &kk_physical_device_trampolines, name, instance->app_info.api_version,
+      &instance->enabled_extensions);
+   if (func != NULL)
+      return func;
+
+   func = vk_device_dispatch_table_get_if_supported(
+      &kk_device_trampolines, name, instance->app_info.api_version,
+      &instance->enabled_extensions, NULL);
+   if (func != NULL)
+      return func;
+
+   return NULL;
+}
+
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+kk_GetInstanceProcAddr(VkInstance _instance, const char *pName)
+{
+   VK_FROM_HANDLE(kk_instance, instance, _instance);
+   return kk_instance_get_proc_addr(&instance->vk, &kk_instance_entrypoints,
+                                    pName);
+}
+
+PUBLIC VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+vk_icdGetInstanceProcAddr(VkInstance instance, const char *pName)
+{
+   return kk_GetInstanceProcAddr(instance, pName);
+}
diff --git a/src/kosmickrisp/vulkan/kk_instance.h b/src/kosmickrisp/vulkan/kk_instance.h
new file mode 100644
index 00000000000..0afbb29a55e
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_instance.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_INSTANCE_H
+#define KK_INSTANCE_H 1
+
+#include "kk_private.h"
+
+#include "util/xmlconfig.h"
+#include "vk_instance.h"
+
+struct kk_instance {
+   struct vk_instance vk;
+
+   uint8_t driver_build_sha[20];
+   uint32_t force_vk_vendor;
+};
+
+VK_DEFINE_HANDLE_CASTS(kk_instance, vk.base, VkInstance,
+                       VK_OBJECT_TYPE_INSTANCE)
+
+#endif // KK_INSTANCE_H
diff --git a/src/kosmickrisp/vulkan/kk_nir_lower_descriptors.c b/src/kosmickrisp/vulkan/kk_nir_lower_descriptors.c
new file mode 100644
index 00000000000..da076d41815
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_nir_lower_descriptors.c
@@ -0,0 +1,765 @@
+/*
+ * Copyright 2024 Valve Corporation
+ * Copyright 2024 Alyssa Rosenzweig
+ * Copyright 2022-2023 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+#include "kk_cmd_buffer.h"
+#include "kk_descriptor_set.h"
+#include "kk_descriptor_set_layout.h"
+#include "kk_shader.h"
+
+#include "kosmickrisp/compiler/nir_to_msl.h"
+
+#include "nir.h"
+#include "nir_builder.h"
+#include "nir_builder_opcodes.h"
+#include "nir_intrinsics.h"
+#include "nir_intrinsics_indices.h"
+#include "shader_enums.h"
+#include "vk_pipeline.h"
+
+#include "vulkan/vulkan_core.h"
+
+struct lower_descriptors_ctx {
+   const struct kk_descriptor_set_layout *set_layouts[KK_MAX_SETS];
+
+   bool clamp_desc_array_bounds;
+   nir_address_format ubo_addr_format;
+   nir_address_format ssbo_addr_format;
+};
+
+static const struct kk_descriptor_set_binding_layout *
+get_binding_layout(uint32_t set, uint32_t binding,
+                   const struct lower_descriptors_ctx *ctx)
+{
+   assert(set < KK_MAX_SETS);
+   assert(ctx->set_layouts[set] != NULL);
+
+   const struct kk_descriptor_set_layout *set_layout = ctx->set_layouts[set];
+
+   assert(binding < set_layout->binding_count);
+   return &set_layout->binding[binding];
+}
+
+static nir_def *
+load_speculatable(nir_builder *b, unsigned num_components, unsigned bit_size,
+                  nir_def *addr, unsigned align)
+{
+   return nir_build_load_global_constant(b, num_components, bit_size, addr,
+                                         .align_mul = align,
+                                         .access = ACCESS_CAN_SPECULATE);
+}
+
+static nir_def *
+load_root(nir_builder *b, unsigned num_components, unsigned bit_size,
+          nir_def *offset, unsigned align)
+{
+   nir_def *root = nir_load_buffer_ptr_kk(b, 1, 64, .binding = 0);
+
+   /* We've bound the address of the root descriptor, index in. */
+   nir_def *addr = nir_iadd(b, root, nir_u2u64(b, offset));
+
+   return load_speculatable(b, num_components, bit_size, addr, align);
+}
+
+static bool
+lower_load_constant(nir_builder *b, nir_intrinsic_instr *load,
+                    const struct lower_descriptors_ctx *ctx)
+{
+   assert(load->intrinsic == nir_intrinsic_load_constant);
+   UNREACHABLE("todo: stick an address in the root descriptor or something");
+
+   uint32_t base = nir_intrinsic_base(load);
+   uint32_t range = nir_intrinsic_range(load);
+
+   b->cursor = nir_before_instr(&load->instr);
+
+   nir_def *offset = nir_iadd_imm(b, load->src[0].ssa, base);
+   nir_def *data = nir_load_ubo(
+      b, load->def.num_components, load->def.bit_size, nir_imm_int(b, 0),
+      offset, .align_mul = nir_intrinsic_align_mul(load),
+      .align_offset = nir_intrinsic_align_offset(load), .range_base = base,
+      .range = range);
+
+   nir_def_rewrite_uses(&load->def, data);
+
+   return true;
+}
+
+/* helper macro for computing root descriptor byte offsets */
+#define kk_root_descriptor_offset(member)                                      \
+   offsetof(struct kk_root_descriptor_table, member)
+
+static nir_def *
+load_descriptor_set_addr(nir_builder *b, uint32_t set,
+                         UNUSED const struct lower_descriptors_ctx *ctx)
+{
+   uint32_t set_addr_offset =
+      kk_root_descriptor_offset(sets) + set * sizeof(uint64_t);
+
+   return load_root(b, 1, 64, nir_imm_int(b, set_addr_offset), 8);
+}
+
+static nir_def *
+load_dynamic_buffer_start(nir_builder *b, uint32_t set,
+                          const struct lower_descriptors_ctx *ctx)
+{
+   int dynamic_buffer_start_imm = 0;
+   for (uint32_t s = 0; s < set; s++) {
+      if (ctx->set_layouts[s] == NULL) {
+         dynamic_buffer_start_imm = -1;
+         break;
+      }
+
+      dynamic_buffer_start_imm += ctx->set_layouts[s]->dynamic_buffer_count;
+   }
+
+   if (dynamic_buffer_start_imm >= 0) {
+      return nir_imm_int(b, dynamic_buffer_start_imm);
+   } else {
+      uint32_t root_offset =
+         kk_root_descriptor_offset(set_dynamic_buffer_start) + set;
+
+      return nir_u2u32(b, load_root(b, 1, 8, nir_imm_int(b, root_offset), 1));
+   }
+}
+
+static nir_def *
+load_descriptor(nir_builder *b, unsigned num_components, unsigned bit_size,
+                uint32_t set, uint32_t binding, nir_def *index,
+                unsigned offset_B, const struct lower_descriptors_ctx *ctx)
+{
+   const struct kk_descriptor_set_binding_layout *binding_layout =
+      get_binding_layout(set, binding, ctx);
+
+   if (ctx->clamp_desc_array_bounds)
+      index =
+         nir_umin(b, index, nir_imm_int(b, binding_layout->array_size - 1));
+
+   switch (binding_layout->type) {
+   case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+   case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: {
+      /* Get the index in the root descriptor table dynamic_buffers array. */
+      nir_def *dynamic_buffer_start = load_dynamic_buffer_start(b, set, ctx);
+
+      index = nir_iadd(b, index,
+                       nir_iadd_imm(b, dynamic_buffer_start,
+                                    binding_layout->dynamic_buffer_index));
+
+      nir_def *root_desc_offset = nir_iadd_imm(
+         b, nir_imul_imm(b, index, sizeof(struct kk_buffer_address)),
+         kk_root_descriptor_offset(dynamic_buffers));
+
+      assert(num_components == 4 && bit_size == 32);
+      nir_def *desc = load_root(b, 4, 32, root_desc_offset, 16);
+
+      /* We know a priori that the the .w compnent (offset) is zero */
+      return nir_vector_insert_imm(b, desc, nir_imm_int(b, 0), 3);
+   }
+
+   case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK: {
+      nir_def *base_addr = nir_iadd_imm(
+         b, load_descriptor_set_addr(b, set, ctx), binding_layout->offset);
+
+      assert(binding_layout->stride == 1);
+      const uint32_t binding_size = binding_layout->array_size;
+
+      /* Convert it to nir_address_format_64bit_bounded_global */
+      assert(num_components == 4 && bit_size == 32);
+      return nir_vec4(b, nir_unpack_64_2x32_split_x(b, base_addr),
+                      nir_unpack_64_2x32_split_y(b, base_addr),
+                      nir_imm_int(b, binding_size), nir_imm_int(b, 0));
+   }
+
+   default: {
+      assert(binding_layout->stride > 0);
+      nir_def *desc_ubo_offset =
+         nir_iadd_imm(b, nir_imul_imm(b, index, binding_layout->stride),
+                      binding_layout->offset + offset_B);
+
+      unsigned desc_align_mul = (1 << (ffs(binding_layout->stride) - 1));
+      desc_align_mul = MIN2(desc_align_mul, 16);
+      unsigned desc_align_offset = binding_layout->offset + offset_B;
+      desc_align_offset %= desc_align_mul;
+
+      nir_def *desc;
+      nir_def *set_addr = load_descriptor_set_addr(b, set, ctx);
+      desc = nir_load_global_constant_offset(
+         b, num_components, bit_size, set_addr, desc_ubo_offset,
+         .align_mul = desc_align_mul, .align_offset = desc_align_offset,
+         .access = ACCESS_CAN_SPECULATE);
+
+      if (binding_layout->type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER ||
+          binding_layout->type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
+         /* We know a priori that the the .w compnent (offset) is zero */
+         assert(num_components == 4 && bit_size == 32);
+         desc = nir_vector_insert_imm(b, desc, nir_imm_int(b, 0), 3);
+      }
+      return desc;
+   }
+   }
+}
+
+static bool
+is_idx_intrin(nir_intrinsic_instr *intrin)
+{
+   while (intrin->intrinsic == nir_intrinsic_vulkan_resource_reindex) {
+      intrin = nir_src_as_intrinsic(intrin->src[0]);
+      if (intrin == NULL)
+         return false;
+   }
+
+   return intrin->intrinsic == nir_intrinsic_vulkan_resource_index;
+}
+
+static nir_def *
+load_descriptor_for_idx_intrin(nir_builder *b, nir_intrinsic_instr *intrin,
+                               const struct lower_descriptors_ctx *ctx)
+{
+   nir_def *index = nir_imm_int(b, 0);
+
+   while (intrin->intrinsic == nir_intrinsic_vulkan_resource_reindex) {
+      index = nir_iadd(b, index, intrin->src[1].ssa);
+      intrin = nir_src_as_intrinsic(intrin->src[0]);
+   }
+
+   assert(intrin->intrinsic == nir_intrinsic_vulkan_resource_index);
+   uint32_t set = nir_intrinsic_desc_set(intrin);
+   uint32_t binding = nir_intrinsic_binding(intrin);
+   index = nir_iadd(b, index, intrin->src[0].ssa);
+
+   return load_descriptor(b, 4, 32, set, binding, index, 0, ctx);
+}
+
+static bool
+try_lower_load_vulkan_descriptor(nir_builder *b, nir_intrinsic_instr *intrin,
+                                 const struct lower_descriptors_ctx *ctx)
+{
+   ASSERTED const VkDescriptorType desc_type = nir_intrinsic_desc_type(intrin);
+   b->cursor = nir_before_instr(&intrin->instr);
+
+   nir_intrinsic_instr *idx_intrin = nir_src_as_intrinsic(intrin->src[0]);
+   if (idx_intrin == NULL || !is_idx_intrin(idx_intrin)) {
+      assert(desc_type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER ||
+             desc_type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC);
+      return false;
+   }
+
+   nir_def *desc = load_descriptor_for_idx_intrin(b, idx_intrin, ctx);
+
+   nir_def_rewrite_uses(&intrin->def, desc);
+
+   return true;
+}
+
+static bool
+_lower_sysval_to_root_table(nir_builder *b, nir_intrinsic_instr *intrin,
+                            uint32_t root_table_offset)
+{
+   b->cursor = nir_instr_remove(&intrin->instr);
+   assert((root_table_offset & 3) == 0 && "aligned");
+
+   nir_def *val = load_root(b, intrin->def.num_components, intrin->def.bit_size,
+                            nir_imm_int(b, root_table_offset), 4);
+
+   nir_def_rewrite_uses(&intrin->def, val);
+
+   return true;
+}
+
+#define lower_sysval_to_root_table(b, intrin, member)                          \
+   _lower_sysval_to_root_table(b, intrin, kk_root_descriptor_offset(member))
+
+static bool
+lower_load_push_constant(nir_builder *b, nir_intrinsic_instr *load,
+                         const struct lower_descriptors_ctx *ctx)
+{
+   const uint32_t push_region_offset = kk_root_descriptor_offset(push);
+   const uint32_t base = nir_intrinsic_base(load);
+
+   b->cursor = nir_before_instr(&load->instr);
+
+   nir_def *offset =
+      nir_iadd_imm(b, load->src[0].ssa, push_region_offset + base);
+
+   nir_def *val = load_root(b, load->def.num_components, load->def.bit_size,
+                            offset, load->def.bit_size / 8);
+
+   nir_def_rewrite_uses(&load->def, val);
+
+   return true;
+}
+
+static void
+get_resource_deref_binding(nir_builder *b, nir_deref_instr *deref,
+                           uint32_t *set, uint32_t *binding, nir_def **index)
+{
+   if (deref->deref_type == nir_deref_type_array) {
+      *index = deref->arr.index.ssa;
+      deref = nir_deref_instr_parent(deref);
+   } else {
+      *index = nir_imm_int(b, 0);
+   }
+
+   assert(deref->deref_type == nir_deref_type_var);
+   nir_variable *var = deref->var;
+
+   *set = var->data.descriptor_set;
+   *binding = var->data.binding;
+}
+
+static nir_def *
+load_resource_addr(nir_builder *b, unsigned num_components, unsigned bit_size,
+                   nir_deref_instr *deref, unsigned offset_B,
+                   const struct lower_descriptors_ctx *ctx)
+{
+   uint32_t set, binding;
+   nir_def *index;
+   get_resource_deref_binding(b, deref, &set, &binding, &index);
+
+   const struct kk_descriptor_set_binding_layout *binding_layout =
+      get_binding_layout(set, binding, ctx);
+
+   if (ctx->clamp_desc_array_bounds)
+      index =
+         nir_umin(b, index, nir_imm_int(b, binding_layout->array_size - 1));
+
+   assert(binding_layout->stride > 0);
+   nir_def *desc_ubo_offset =
+      nir_iadd_imm(b, nir_imul_imm(b, index, binding_layout->stride),
+                   binding_layout->offset + offset_B);
+
+   return nir_iadd(b, load_descriptor_set_addr(b, set, ctx),
+                   nir_u2u64(b, desc_ubo_offset));
+}
+
+static nir_def *
+load_resource_deref_desc(nir_builder *b, unsigned num_components,
+                         unsigned bit_size, nir_deref_instr *deref,
+                         unsigned offset_B,
+                         const struct lower_descriptors_ctx *ctx)
+{
+   uint32_t set, binding;
+   nir_def *index;
+   get_resource_deref_binding(b, deref, &set, &binding, &index);
+   return load_descriptor(b, num_components, bit_size, set, binding, index,
+                          offset_B, ctx);
+}
+
+static bool
+lower_image_intrin(nir_builder *b, nir_intrinsic_instr *intr,
+                   const struct lower_descriptors_ctx *ctx)
+{
+   b->cursor = nir_before_instr(&intr->instr);
+   nir_deref_instr *deref = nir_src_as_deref(intr->src[0]);
+
+   /* Reads and queries use the texture descriptor; writes and atomics PBE. */
+   unsigned offs =
+      offsetof(struct kk_storage_image_descriptor, image_gpu_resource_id);
+
+   nir_def *resource_addr = load_resource_addr(b, 1, 64, deref, offs, ctx);
+
+   nir_alu_type type;
+   if (nir_intrinsic_has_atomic_op(intr)) {
+      type = nir_atomic_op_type(nir_intrinsic_atomic_op(intr));
+      type |= intr->src[3].ssa->bit_size;
+   } else if (nir_intrinsic_has_dest_type(intr)) {
+      type = nir_intrinsic_dest_type(intr);
+   } else if (nir_intrinsic_has_src_type(intr)) {
+      type = nir_intrinsic_src_type(intr);
+   } else {
+      type = nir_type_uint32;
+   }
+
+   nir_variable *var = nir_deref_instr_get_variable(deref);
+   nir_def *handle = nir_load_texture_handle_kk(
+      b, 1, 64, resource_addr, .dest_type = type,
+      .image_dim = nir_intrinsic_image_dim(intr),
+      .image_array = nir_intrinsic_image_array(intr),
+      .flags = msl_convert_access_flag(var->data.access));
+
+   nir_rewrite_image_intrinsic(intr, handle, true);
+
+   return true;
+}
+
+static bool
+try_lower_intrin(nir_builder *b, nir_intrinsic_instr *intrin,
+                 const struct lower_descriptors_ctx *ctx)
+{
+   switch (intrin->intrinsic) {
+   case nir_intrinsic_load_constant:
+      return lower_load_constant(b, intrin, ctx);
+
+   case nir_intrinsic_load_vulkan_descriptor:
+      return try_lower_load_vulkan_descriptor(b, intrin, ctx);
+
+   case nir_intrinsic_load_workgroup_size:
+      UNREACHABLE("Should have been lowered by nir_lower_cs_intrinsics()");
+
+   case nir_intrinsic_load_base_workgroup_id:
+      return lower_sysval_to_root_table(b, intrin, cs.base_group);
+
+   case nir_intrinsic_load_blend_const_color_rgba:
+      return lower_sysval_to_root_table(b, intrin, draw.blend_constant);
+
+   case nir_intrinsic_load_push_constant:
+      return lower_load_push_constant(b, intrin, ctx);
+
+   case nir_intrinsic_image_deref_load:
+   case nir_intrinsic_image_deref_sparse_load:
+   case nir_intrinsic_image_deref_store:
+   case nir_intrinsic_image_deref_atomic:
+   case nir_intrinsic_image_deref_atomic_swap:
+   case nir_intrinsic_image_deref_size:
+   case nir_intrinsic_image_deref_samples:
+   case nir_intrinsic_image_deref_store_block_agx:
+      return lower_image_intrin(b, intrin, ctx);
+
+   default:
+      return false;
+   }
+}
+
+static bool
+lower_tex(nir_builder *b, nir_tex_instr *tex,
+          const struct lower_descriptors_ctx *ctx)
+{
+   b->cursor = nir_before_instr(&tex->instr);
+
+   nir_def *texture = nir_steal_tex_src(tex, nir_tex_src_texture_deref);
+   nir_def *sampler = nir_steal_tex_src(tex, nir_tex_src_sampler_deref);
+   if (!texture) {
+      assert(!sampler);
+      return false;
+   }
+
+   nir_def *plane_ssa = nir_steal_tex_src(tex, nir_tex_src_plane);
+   const uint32_t plane =
+      plane_ssa ? nir_src_as_uint(nir_src_for_ssa(plane_ssa)) : 0;
+   const uint64_t plane_offset_B =
+      plane * sizeof(struct kk_sampled_image_descriptor);
+
+   /* LOD bias is passed in the descriptor set, rather than embedded into
+    * the sampler descriptor. There's no spot in the hardware descriptor,
+    * plus this saves on precious sampler heap spots.
+    */
+   if (tex->op == nir_texop_lod_bias) {
+      unsigned offs =
+         offsetof(struct kk_sampled_image_descriptor, lod_bias_fp16);
+
+      nir_def *bias = load_resource_deref_desc(
+         b, 1, 16, nir_src_as_deref(nir_src_for_ssa(sampler)),
+         plane_offset_B + offs, ctx);
+
+      nir_def_replace(&tex->def, bias);
+      return true;
+   }
+
+   // if (tex->op == nir_texop_image_min_lod_agx) {
+   //    assert(tex->dest_type == nir_type_float16 ||
+   //           tex->dest_type == nir_type_uint16);
+
+   //    unsigned offs =
+   //       tex->dest_type == nir_type_float16
+   //          ? offsetof(struct kk_sampled_image_descriptor, min_lod_fp16)
+   //          : offsetof(struct kk_sampled_image_descriptor, min_lod_uint16);
+
+   //    nir_def *min = load_resource_deref_desc(
+   //       b, 1, 16, nir_src_as_deref(nir_src_for_ssa(texture)),
+   //       plane_offset_B + offs, ctx);
+
+   //    nir_def_replace(&tex->def, min);
+   //    return true;
+   // }
+
+   // if (tex->op == nir_texop_has_custom_border_color_agx) {
+   //    unsigned offs = offsetof(struct kk_sampled_image_descriptor,
+   //                             clamp_0_sampler_index_or_negative);
+
+   //    nir_def *res = load_resource_deref_desc(
+   //       b, 1, 16, nir_src_as_deref(nir_src_for_ssa(sampler)),
+   //       plane_offset_B + offs, ctx);
+
+   //    nir_def_replace(&tex->def, nir_ige_imm(b, res, 0));
+   //    return true;
+   // }
+
+   if (tex->op == nir_texop_custom_border_color_agx) {
+      unsigned offs = offsetof(struct kk_sampled_image_descriptor, border);
+
+      nir_def *border = load_resource_deref_desc(
+         b, 4, 32, nir_src_as_deref(nir_src_for_ssa(sampler)),
+         plane_offset_B + offs, ctx);
+
+      nir_alu_type T = nir_alu_type_get_base_type(tex->dest_type);
+      border = nir_convert_to_bit_size(b, border, T, tex->def.bit_size);
+
+      nir_def_replace(&tex->def, border);
+      return true;
+   }
+
+   {
+      unsigned offs =
+         offsetof(struct kk_sampled_image_descriptor, image_gpu_resource_id);
+
+      nir_def *resource_addr = load_resource_addr(
+         b, 1, 64, nir_src_as_deref(nir_src_for_ssa(texture)),
+         plane_offset_B + offs, ctx);
+
+      nir_def *handle = NULL;
+      if (tex->is_shadow) {
+         handle = nir_load_depth_texture_kk(b, 1, 64, resource_addr,
+                                            .image_dim = tex->sampler_dim,
+                                            .image_array = tex->is_array);
+      } else {
+         handle = nir_load_texture_handle_kk(
+            b, 1, 64, resource_addr, .dest_type = tex->dest_type,
+            .image_dim = tex->sampler_dim, .image_array = tex->is_array);
+      }
+      nir_tex_instr_add_src(tex, nir_tex_src_texture_handle, handle);
+   }
+
+   if (sampler != NULL) {
+      unsigned offs =
+         offsetof(struct kk_sampled_image_descriptor, sampler_index);
+
+      nir_def *index = load_resource_deref_desc(
+         b, 1, 16, nir_src_as_deref(nir_src_for_ssa(sampler)),
+         plane_offset_B + offs, ctx);
+
+      nir_tex_instr_add_src(tex, nir_tex_src_sampler_handle,
+                            nir_load_sampler_handle_kk(b, index));
+   }
+
+   if (tex->op == nir_texop_lod) {
+      nir_def *lod_min = nir_f2f32(
+         b, load_resource_deref_desc(
+               b, 1, 16, nir_src_as_deref(nir_src_for_ssa(sampler)),
+               plane_offset_B +
+                  offsetof(struct kk_sampled_image_descriptor, lod_min_fp16),
+               ctx));
+      nir_def *lod_max = nir_f2f32(
+         b, load_resource_deref_desc(
+               b, 1, 16, nir_src_as_deref(nir_src_for_ssa(sampler)),
+               plane_offset_B +
+                  offsetof(struct kk_sampled_image_descriptor, lod_max_fp16),
+               ctx));
+
+      nir_tex_instr_add_src(tex, nir_tex_src_min_lod, lod_min);
+      nir_tex_instr_add_src(tex, nir_tex_src_max_lod_kk, lod_max);
+   }
+
+   return true;
+}
+
+static bool
+try_lower_descriptors_instr(nir_builder *b, nir_instr *instr, void *_data)
+{
+   const struct lower_descriptors_ctx *ctx = _data;
+
+   switch (instr->type) {
+   case nir_instr_type_tex:
+      return lower_tex(b, nir_instr_as_tex(instr), ctx);
+   case nir_instr_type_intrinsic:
+      return try_lower_intrin(b, nir_instr_as_intrinsic(instr), ctx);
+   default:
+      return false;
+   }
+}
+
+static bool
+lower_ssbo_resource_index(nir_builder *b, nir_intrinsic_instr *intrin,
+                          const struct lower_descriptors_ctx *ctx)
+{
+   const VkDescriptorType desc_type = nir_intrinsic_desc_type(intrin);
+   if (desc_type != VK_DESCRIPTOR_TYPE_STORAGE_BUFFER &&
+       desc_type != VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)
+      return false;
+
+   b->cursor = nir_instr_remove(&intrin->instr);
+
+   uint32_t set = nir_intrinsic_desc_set(intrin);
+   uint32_t binding = nir_intrinsic_binding(intrin);
+   nir_def *index = intrin->src[0].ssa;
+
+   const struct kk_descriptor_set_binding_layout *binding_layout =
+      get_binding_layout(set, binding, ctx);
+
+   nir_def *binding_addr;
+   uint8_t binding_stride;
+   switch (binding_layout->type) {
+   case VK_DESCRIPTOR_TYPE_MUTABLE_EXT:
+   case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: {
+      nir_def *set_addr = load_descriptor_set_addr(b, set, ctx);
+      binding_addr = nir_iadd_imm(b, set_addr, binding_layout->offset);
+      binding_stride = binding_layout->stride;
+      break;
+   }
+
+   case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: {
+      nir_def *root_desc_addr = nir_load_buffer_ptr_kk(b, 1, 64, .binding = 0);
+
+      nir_def *dynamic_buffer_start =
+         nir_iadd_imm(b, load_dynamic_buffer_start(b, set, ctx),
+                      binding_layout->dynamic_buffer_index);
+
+      nir_def *dynamic_binding_offset =
+         nir_iadd_imm(b,
+                      nir_imul_imm(b, dynamic_buffer_start,
+                                   sizeof(struct kk_buffer_address)),
+                      kk_root_descriptor_offset(dynamic_buffers));
+
+      binding_addr =
+         nir_iadd(b, root_desc_addr, nir_u2u64(b, dynamic_binding_offset));
+      binding_stride = sizeof(struct kk_buffer_address);
+      break;
+   }
+
+   default:
+      UNREACHABLE("Not an SSBO descriptor");
+   }
+
+   /* Tuck the stride in the top 8 bits of the binding address */
+   binding_addr = nir_ior_imm(b, binding_addr, (uint64_t)binding_stride << 56);
+
+   const uint32_t binding_size = binding_layout->array_size * binding_stride;
+   nir_def *offset_in_binding = nir_imul_imm(b, index, binding_stride);
+
+   nir_def *addr = nir_vec4(b, nir_unpack_64_2x32_split_x(b, binding_addr),
+                            nir_unpack_64_2x32_split_y(b, binding_addr),
+                            nir_imm_int(b, binding_size), offset_in_binding);
+
+   nir_def_rewrite_uses(&intrin->def, addr);
+
+   return true;
+}
+
+static bool
+lower_ssbo_resource_reindex(nir_builder *b, nir_intrinsic_instr *intrin,
+                            const struct lower_descriptors_ctx *ctx)
+{
+   const VkDescriptorType desc_type = nir_intrinsic_desc_type(intrin);
+   if (desc_type != VK_DESCRIPTOR_TYPE_STORAGE_BUFFER &&
+       desc_type != VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)
+      return false;
+
+   b->cursor = nir_instr_remove(&intrin->instr);
+
+   nir_def *addr = intrin->src[0].ssa;
+   nir_def *index = intrin->src[1].ssa;
+
+   nir_def *addr_high32 = nir_channel(b, addr, 1);
+   nir_def *stride = nir_ushr_imm(b, addr_high32, 24);
+   nir_def *offset = nir_imul(b, index, stride);
+
+   addr = nir_build_addr_iadd(b, addr, ctx->ssbo_addr_format, nir_var_mem_ssbo,
+                              offset);
+   nir_def_rewrite_uses(&intrin->def, addr);
+
+   return true;
+}
+
+static bool
+lower_load_ssbo_descriptor(nir_builder *b, nir_intrinsic_instr *intrin,
+                           const struct lower_descriptors_ctx *ctx)
+{
+   const VkDescriptorType desc_type = nir_intrinsic_desc_type(intrin);
+   if (desc_type != VK_DESCRIPTOR_TYPE_STORAGE_BUFFER &&
+       desc_type != VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)
+      return false;
+
+   b->cursor = nir_instr_remove(&intrin->instr);
+
+   nir_def *addr = intrin->src[0].ssa;
+
+   nir_def *desc;
+   switch (ctx->ssbo_addr_format) {
+   case nir_address_format_64bit_global_32bit_offset: {
+      nir_def *base = nir_pack_64_2x32(b, nir_trim_vector(b, addr, 2));
+      nir_def *offset = nir_channel(b, addr, 3);
+      /* Mask off the binding stride */
+      base = nir_iand_imm(b, base, BITFIELD64_MASK(56));
+      desc = nir_load_global_constant_offset(b, 4, 32, base, offset,
+                                             .align_mul = 16, .align_offset = 0,
+                                             .access = ACCESS_CAN_SPECULATE);
+      break;
+   }
+
+   case nir_address_format_64bit_bounded_global: {
+      nir_def *base = nir_pack_64_2x32(b, nir_trim_vector(b, addr, 2));
+      nir_def *size = nir_channel(b, addr, 2);
+      nir_def *offset = nir_channel(b, addr, 3);
+      /* Mask off the binding stride */
+      base = nir_iand_imm(b, base, BITFIELD64_MASK(56));
+      desc = nir_load_global_constant_bounded(
+         b, 4, 32, base, offset, size, .align_mul = 16, .align_offset = 0,
+         .access = ACCESS_CAN_SPECULATE);
+      break;
+   }
+
+   default:
+      UNREACHABLE("Unknown address mode");
+   }
+
+   nir_def_rewrite_uses(&intrin->def, desc);
+
+   return true;
+}
+
+static bool
+lower_ssbo_descriptor(nir_builder *b, nir_intrinsic_instr *intr, void *_data)
+{
+   const struct lower_descriptors_ctx *ctx = _data;
+
+   switch (intr->intrinsic) {
+   case nir_intrinsic_vulkan_resource_index:
+      return lower_ssbo_resource_index(b, intr, ctx);
+   case nir_intrinsic_vulkan_resource_reindex:
+      return lower_ssbo_resource_reindex(b, intr, ctx);
+   case nir_intrinsic_load_vulkan_descriptor:
+      return lower_load_ssbo_descriptor(b, intr, ctx);
+   default:
+      return false;
+   }
+}
+
+bool
+kk_nir_lower_descriptors(nir_shader *nir,
+                         const struct vk_pipeline_robustness_state *rs,
+                         uint32_t set_layout_count,
+                         struct vk_descriptor_set_layout *const *set_layouts)
+{
+   struct lower_descriptors_ctx ctx = {
+      .clamp_desc_array_bounds =
+         rs->storage_buffers !=
+            VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT ||
+         rs->uniform_buffers !=
+            VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT ||
+         rs->images != VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT,
+      .ssbo_addr_format = kk_buffer_addr_format(rs->storage_buffers),
+      .ubo_addr_format = kk_buffer_addr_format(rs->uniform_buffers),
+   };
+
+   assert(set_layout_count <= KK_MAX_SETS);
+   for (uint32_t s = 0; s < set_layout_count; s++) {
+      if (set_layouts[s] != NULL)
+         ctx.set_layouts[s] = vk_to_kk_descriptor_set_layout(set_layouts[s]);
+   }
+
+   /* First lower everything but complex SSBOs, then lower complex SSBOs.
+    *
+    * TODO: See if we can unify this, not sure if the fast path matters on
+    * Apple. This is inherited from NVK.
+    */
+   bool pass_lower_descriptors = nir_shader_instructions_pass(
+      nir, try_lower_descriptors_instr, nir_metadata_control_flow, &ctx);
+
+   bool pass_lower_ssbo = nir_shader_intrinsics_pass(
+      nir, lower_ssbo_descriptor, nir_metadata_control_flow, &ctx);
+
+   return pass_lower_descriptors || pass_lower_ssbo;
+}
diff --git a/src/kosmickrisp/vulkan/kk_nir_lower_multiview.c b/src/kosmickrisp/vulkan/kk_nir_lower_multiview.c
new file mode 100644
index 00000000000..f90e50339f2
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_nir_lower_multiview.c
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_shader.h"
+
+#include "nir.h"
+#include "nir_builder.h"
+
+/* View index maps to layer id in Metal */
+static bool
+replace_view_index_with_zero(nir_builder *b, nir_intrinsic_instr *instr,
+                             void *data)
+{
+   if (instr->intrinsic != nir_intrinsic_load_view_index)
+      return false;
+
+   b->cursor = nir_before_instr(&instr->instr);
+   nir_def *layer_id = nir_load_layer_id(b);
+   nir_def_replace(&instr->def, layer_id);
+   return true;
+}
+
+/* View index maps to layer id in Metal */
+static bool
+replace_view_index_with_layer_id(nir_builder *b, nir_intrinsic_instr *instr,
+                                 void *data)
+{
+   if (instr->intrinsic != nir_intrinsic_load_view_index)
+      return false;
+
+   b->cursor = nir_before_instr(&instr->instr);
+   nir_def *layer_id = nir_load_layer_id(b);
+   nir_def_replace(&instr->def, layer_id);
+   return true;
+}
+
+static bool
+replace_view_id_with_value(nir_builder *b, nir_intrinsic_instr *instr,
+                           void *data)
+{
+   if (instr->intrinsic != nir_intrinsic_load_view_index)
+      return false;
+
+   b->cursor = nir_before_instr(&instr->instr);
+   nir_def *view_index = (nir_def *)data;
+   nir_def_replace(&instr->def, view_index);
+   return true;
+}
+
+bool
+kk_nir_lower_vs_multiview(nir_shader *nir, uint32_t view_mask)
+{
+   assert(nir->info.stage == MESA_SHADER_VERTEX);
+
+   /* Embed view indices and return */
+   uint32_t view_count = util_bitcount(view_mask);
+   nir_function_impl *entrypoint = nir_shader_get_entrypoint(nir);
+   nir_builder b = nir_builder_at(nir_before_impl(entrypoint));
+
+   /* Create array and initialize */
+   nir_variable *view_indices = nir_local_variable_create(
+      entrypoint, glsl_array_type(glsl_uint_type(), view_count, 0),
+      "view_indices");
+   nir_deref_instr *view_indices_deref = nir_build_deref_var(&b, view_indices);
+   uint32_t count = 0u;
+   u_foreach_bit(index, view_mask) {
+      nir_store_deref(
+         &b, nir_build_deref_array_imm(&b, view_indices_deref, count++),
+         nir_imm_int(&b, index), 1);
+   }
+
+   /* Access array based on the amplification id */
+   nir_def *amplification_id = nir_load_amplification_id_kk(&b);
+   nir_def *view_index = nir_load_deref(
+      &b, nir_build_deref_array(&b, view_indices_deref, amplification_id));
+
+   bool progress = nir_shader_intrinsics_pass(
+      nir, replace_view_id_with_value, nir_metadata_control_flow, view_index);
+
+   if (progress) {
+      BITSET_SET(nir->info.system_values_read,
+                 SYSTEM_VALUE_AMPLIFICATION_ID_KK);
+   }
+
+   /* With a single view index, Metal's vertex amplification will disregard the
+    * render target offset. We need to apply it ourselves in shader */
+   if (view_count == 1u) {
+      nir_variable *layer_id = nir_create_variable_with_location(
+         nir, nir_var_shader_out, VARYING_SLOT_LAYER, glsl_uint_type());
+      nir_deref_instr *layer_id_deref = nir_build_deref_var(&b, layer_id);
+      nir_def *view_index = nir_imm_int(&b, util_last_bit(view_mask) - 1u);
+      nir_store_deref(&b, layer_id_deref, view_index, 0xFFFFFFFF);
+
+      nir->info.outputs_written |= BITFIELD64_BIT(VARYING_SLOT_LAYER);
+      progress = true;
+   }
+
+   return progress;
+}
+
+bool
+kk_nir_lower_fs_multiview(nir_shader *nir, uint32_t view_mask)
+{
+   if (view_mask == 0u)
+      return nir_shader_intrinsics_pass(nir, replace_view_index_with_zero,
+                                        nir_metadata_control_flow, NULL);
+
+   return nir_shader_intrinsics_pass(nir, replace_view_index_with_layer_id,
+                                     nir_metadata_control_flow, NULL);
+}
diff --git a/src/kosmickrisp/vulkan/kk_nir_lower_textures.c b/src/kosmickrisp/vulkan/kk_nir_lower_textures.c
new file mode 100644
index 00000000000..85339be414c
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_nir_lower_textures.c
@@ -0,0 +1,193 @@
+/*
+ * Copyright 2023 Valve Corporation
+ * Copyright 2021 Alyssa Rosenzweig
+ * Copyright 2020 Collabora Ltd.
+ * Copyright 2016 Broadcom
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+#include "kk_private.h"
+
+#include "kk_descriptor_types.h"
+#include "kk_shader.h"
+
+#include "nir.h"
+#include "nir_builder.h"
+
+#include "stdbool.h"
+
+static bool
+lower_texture_buffer_tex_instr(nir_builder *b, nir_tex_instr *tex)
+{
+   if (tex->sampler_dim != GLSL_SAMPLER_DIM_BUF)
+      return false;
+
+   nir_steal_tex_src(tex, nir_tex_src_lod);
+   return true;
+}
+
+static void
+lower_1d_image_intrin(nir_builder *b, nir_intrinsic_instr *intrin)
+{
+   nir_def *coord = intrin->src[1].ssa;
+   bool is_array = nir_intrinsic_image_array(intrin);
+   nir_def *zero = nir_imm_intN_t(b, 0, coord->bit_size);
+
+   if (is_array) {
+      assert(coord->num_components >= 2);
+      coord =
+         nir_vec3(b, nir_channel(b, coord, 0), zero, nir_channel(b, coord, 1));
+   } else {
+      assert(coord->num_components >= 1);
+      coord = nir_vec2(b, coord, zero);
+   }
+
+   nir_src_rewrite(&intrin->src[1], nir_pad_vector(b, coord, 4));
+   nir_intrinsic_set_image_dim(intrin, GLSL_SAMPLER_DIM_2D);
+}
+
+static nir_def *
+txs_for_image(nir_builder *b, nir_intrinsic_instr *intr,
+              unsigned num_components, unsigned bit_size, bool query_samples)
+{
+   nir_tex_instr *tex = nir_tex_instr_create(b->shader, query_samples ? 1 : 2);
+   tex->op = query_samples ? nir_texop_texture_samples : nir_texop_txs;
+   tex->is_array = nir_intrinsic_image_array(intr);
+   tex->dest_type = nir_type_uint32;
+   tex->sampler_dim = nir_intrinsic_image_dim(intr);
+
+   tex->src[0] =
+      nir_tex_src_for_ssa(nir_tex_src_texture_handle, intr->src[0].ssa);
+
+   if (!query_samples)
+      tex->src[1] = nir_tex_src_for_ssa(nir_tex_src_lod, intr->src[1].ssa);
+
+   nir_def_init(&tex->instr, &tex->def, num_components, bit_size);
+   nir_builder_instr_insert(b, &tex->instr);
+   nir_def *res = &tex->def;
+
+   /* Cube images are implemented as 2D arrays, so we need to divide here. */
+   if (tex->sampler_dim == GLSL_SAMPLER_DIM_CUBE && res->num_components > 2 &&
+       !query_samples) {
+      nir_def *divided = nir_udiv_imm(b, nir_channel(b, res, 2), 6);
+      res = nir_vector_insert_imm(b, res, divided, 2);
+   }
+
+   return res;
+}
+
+/* Cube textures need to be loaded as cube textures for sampling, but for
+ * storage we need to load them as 2d array since Metal does not support atomics
+ * on cube images. However, we don't know how the texture will be used when we
+ * load the handle so we need to do it when we actually use it. */
+static void
+lower_cube_load_handle_to_2d_array(nir_def *handle)
+{
+   nir_instr *handle_parent = handle->parent_instr;
+   assert(handle_parent->type == nir_instr_type_intrinsic);
+   nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(handle_parent);
+   assert(intrin->intrinsic == nir_intrinsic_load_texture_handle_kk);
+   assert(nir_intrinsic_image_dim(intrin) == GLSL_SAMPLER_DIM_CUBE);
+   nir_intrinsic_set_image_dim(intrin, GLSL_SAMPLER_DIM_2D);
+   nir_intrinsic_set_image_array(intrin, true);
+}
+
+static void
+lower_cube_image_intrin(nir_builder *b, nir_intrinsic_instr *intrin)
+{
+   assert(nir_intrinsic_image_dim(intrin) == GLSL_SAMPLER_DIM_CUBE);
+   nir_def *coord = intrin->src[1].ssa;
+   if (nir_intrinsic_image_array(intrin)) {
+      assert(coord->num_components >= 4);
+      nir_def *layer_index =
+         nir_iadd(b, nir_channel(b, coord, 2),
+                  nir_imul_imm(b, nir_channel(b, coord, 3), 6));
+      coord = nir_vec4(b, nir_channel(b, coord, 0), nir_channel(b, coord, 1),
+                       layer_index, nir_imm_intN_t(b, 0, coord->bit_size));
+   }
+   nir_src_rewrite(&intrin->src[1], nir_pad_vector(b, coord, 4));
+   nir_intrinsic_set_image_dim(intrin, GLSL_SAMPLER_DIM_2D);
+   nir_intrinsic_set_image_array(intrin, true);
+
+   lower_cube_load_handle_to_2d_array(intrin->src[0].ssa);
+}
+
+static bool
+lower_image_load_store(nir_builder *b, nir_intrinsic_instr *intrin)
+{
+   b->cursor = nir_before_instr(&intrin->instr);
+   switch (intrin->intrinsic) {
+   case nir_intrinsic_load_texture_handle_kk:
+      switch (nir_intrinsic_image_dim(intrin)) {
+      case GLSL_SAMPLER_DIM_1D:
+         nir_intrinsic_set_image_dim(intrin, GLSL_SAMPLER_DIM_2D);
+         return true;
+      default:
+         return false;
+      }
+   case nir_intrinsic_image_load:
+   case nir_intrinsic_image_store:
+   case nir_intrinsic_image_atomic:
+   case nir_intrinsic_image_atomic_swap:
+   case nir_intrinsic_bindless_image_load:
+   case nir_intrinsic_bindless_image_sparse_load:
+   case nir_intrinsic_bindless_image_store:
+   case nir_intrinsic_bindless_image_atomic:
+   case nir_intrinsic_bindless_image_atomic_swap:
+      switch (nir_intrinsic_image_dim(intrin)) {
+      case GLSL_SAMPLER_DIM_1D:
+         lower_1d_image_intrin(b, intrin);
+         return true;
+      case GLSL_SAMPLER_DIM_CUBE:
+         lower_cube_image_intrin(b, intrin);
+         return true;
+      default:
+         return false;
+      }
+   case nir_intrinsic_bindless_image_size:
+   case nir_intrinsic_bindless_image_samples:
+      nir_def_rewrite_uses(
+         &intrin->def,
+         txs_for_image(
+            b, intrin, intrin->def.num_components, intrin->def.bit_size,
+            intrin->intrinsic == nir_intrinsic_bindless_image_samples));
+      return true;
+   default:
+      return false;
+   }
+}
+
+static bool
+lower_image(nir_builder *b, nir_instr *instr)
+{
+   if (instr->type == nir_instr_type_tex) {
+      nir_tex_instr *tex = nir_instr_as_tex(instr);
+      return lower_texture_buffer_tex_instr(b, tex);
+   } else if (instr->type == nir_instr_type_intrinsic) {
+      nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
+      return lower_image_load_store(b, intrin);
+   }
+
+   return false;
+}
+
+/* Must go after descriptor lowering to ensure the instr we introduce are also
+ * lowered */
+bool
+kk_nir_lower_textures(nir_shader *nir)
+{
+   bool progress = false;
+   nir_foreach_function_impl(impl, nir) {
+      nir_foreach_block_safe(block, impl) {
+         nir_builder b = nir_builder_create(impl);
+         bool progress_impl = false;
+         nir_foreach_instr_safe(instr, block) {
+            progress_impl |= lower_image(&b, instr);
+         }
+         progress |=
+            nir_progress(progress_impl, impl, nir_metadata_control_flow);
+      }
+   }
+   return progress;
+}
diff --git a/src/kosmickrisp/vulkan/kk_nir_lower_vbo.c b/src/kosmickrisp/vulkan/kk_nir_lower_vbo.c
new file mode 100644
index 00000000000..7dc3764a6b2
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_nir_lower_vbo.c
@@ -0,0 +1,279 @@
+/*
+ * Copyright 2022 Alyssa Rosenzweig
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_nir_lower_vbo.h"
+
+#include "kk_cmd_buffer.h"
+
+#include "compiler/nir/nir_builder.h"
+#include "compiler/nir/nir_format_convert.h"
+#include "util/bitset.h"
+#include "util/u_math.h"
+#include "shader_enums.h"
+
+struct ctx {
+   struct kk_attribute *attribs;
+   bool requires_vertex_id;
+   bool requires_instance_id;
+   bool requires_base_instance;
+};
+
+static bool
+is_rgb10_a2(const struct util_format_description *desc)
+{
+   return desc->channel[0].shift == 0 && desc->channel[0].size == 10 &&
+          desc->channel[1].shift == 10 && desc->channel[1].size == 10 &&
+          desc->channel[2].shift == 20 && desc->channel[2].size == 10 &&
+          desc->channel[3].shift == 30 && desc->channel[3].size == 2;
+}
+
+static bool
+is_rg11_b10(const struct util_format_description *desc)
+{
+   return desc->channel[0].shift == 0 && desc->channel[0].size == 11 &&
+          desc->channel[1].shift == 11 && desc->channel[1].size == 11 &&
+          desc->channel[2].shift == 22 && desc->channel[2].size == 10;
+}
+
+static enum pipe_format
+kk_vbo_internal_format(enum pipe_format format)
+{
+   const struct util_format_description *desc = util_format_description(format);
+
+   /* RGB10A2 and RG11B10 require loading as uint and then unpack */
+   if (is_rgb10_a2(desc) || is_rg11_b10(desc))
+      return PIPE_FORMAT_R32_UINT;
+
+   /* R11G11B10F is native and special */
+   if (format == PIPE_FORMAT_R11G11B10_FLOAT)
+      return format;
+
+   /* No other non-array formats handled */
+   if (!desc->is_array)
+      return PIPE_FORMAT_NONE;
+
+   /* Otherwise look at one (any) channel */
+   int idx = util_format_get_first_non_void_channel(format);
+   if (idx < 0)
+      return PIPE_FORMAT_NONE;
+
+   /* We only handle RGB formats (we could do SRGB if we wanted though?) */
+   if ((desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB) ||
+       (desc->layout != UTIL_FORMAT_LAYOUT_PLAIN))
+      return PIPE_FORMAT_NONE;
+
+   /* We have native 8-bit and 16-bit normalized formats */
+   struct util_format_channel_description chan = desc->channel[idx];
+
+   /* Otherwise map to the corresponding integer format */
+   switch (chan.size) {
+   case 32:
+      return PIPE_FORMAT_R32_UINT;
+   case 16:
+      return PIPE_FORMAT_R16_UINT;
+   case 8:
+      return PIPE_FORMAT_R8_UINT;
+   default:
+      return PIPE_FORMAT_NONE;
+   }
+}
+
+bool
+kk_vbo_supports_format(enum pipe_format format)
+{
+   return kk_vbo_internal_format(format) != PIPE_FORMAT_NONE;
+}
+
+static nir_def *
+apply_swizzle_channel(nir_builder *b, nir_def *vec, unsigned swizzle,
+                      bool is_int)
+{
+   switch (swizzle) {
+   case PIPE_SWIZZLE_X:
+      return nir_channel(b, vec, 0);
+   case PIPE_SWIZZLE_Y:
+      return nir_channel(b, vec, 1);
+   case PIPE_SWIZZLE_Z:
+      return nir_channel(b, vec, 2);
+   case PIPE_SWIZZLE_W:
+      return nir_channel(b, vec, 3);
+   case PIPE_SWIZZLE_0:
+      return nir_imm_intN_t(b, 0, vec->bit_size);
+   case PIPE_SWIZZLE_1:
+      return is_int ? nir_imm_intN_t(b, 1, vec->bit_size)
+                    : nir_imm_floatN_t(b, 1.0, vec->bit_size);
+   default:
+      UNREACHABLE("Invalid swizzle channel");
+   }
+}
+
+static bool
+pass(struct nir_builder *b, nir_intrinsic_instr *intr, void *data)
+{
+   if (intr->intrinsic != nir_intrinsic_load_input)
+      return false;
+
+   struct ctx *ctx = data;
+   struct kk_attribute *attribs = ctx->attribs;
+   b->cursor = nir_instr_remove(&intr->instr);
+
+   nir_src *offset_src = nir_get_io_offset_src(intr);
+   assert(nir_src_is_const(*offset_src) && "no attribute indirects");
+   unsigned index = nir_intrinsic_base(intr) + nir_src_as_uint(*offset_src);
+
+   struct kk_attribute attrib = attribs[index];
+
+   const struct util_format_description *desc =
+      util_format_description(attrib.format);
+   int chan = util_format_get_first_non_void_channel(attrib.format);
+   assert(chan >= 0);
+
+   bool is_float = desc->channel[chan].type == UTIL_FORMAT_TYPE_FLOAT;
+   bool is_unsigned = desc->channel[chan].type == UTIL_FORMAT_TYPE_UNSIGNED;
+   bool is_signed = desc->channel[chan].type == UTIL_FORMAT_TYPE_SIGNED;
+   bool is_fixed = desc->channel[chan].type == UTIL_FORMAT_TYPE_FIXED;
+   bool is_int = util_format_is_pure_integer(attrib.format);
+
+   assert((is_float ^ is_unsigned ^ is_signed ^ is_fixed) && "Invalid format");
+
+   enum pipe_format interchange_format = kk_vbo_internal_format(attrib.format);
+   assert(interchange_format != PIPE_FORMAT_NONE);
+
+   unsigned interchange_align = util_format_get_blocksize(interchange_format);
+   unsigned interchange_comps = util_format_get_nr_components(attrib.format);
+
+   /* In the hardware, uint formats zero-extend and float formats convert.
+    * However, non-uint formats using a uint interchange format shouldn't be
+    * zero extended.
+    */
+   unsigned interchange_register_size =
+      util_format_is_pure_uint(interchange_format) ? (interchange_align * 8)
+                                                   : intr->def.bit_size;
+
+   /* Non-UNORM R10G10B10A2 loaded as a scalar and unpacked */
+   if (interchange_format == PIPE_FORMAT_R32_UINT && !desc->is_array)
+      interchange_comps = 1;
+
+   /* Calculate the element to fetch the vertex for. Divide the instance ID by
+    * the divisor for per-instance data. Divisor=0 specifies per-vertex data.
+    */
+   nir_def *el;
+   if (attrib.instanced) {
+      if (attrib.divisor > 0) {
+         /* Metal's instance_id has base_instance included */
+         nir_def *instance_id =
+            nir_isub(b, nir_load_instance_id(b), nir_load_base_instance(b));
+         el = nir_udiv_imm(b, instance_id, attrib.divisor);
+         ctx->requires_instance_id = true;
+      } else
+         el = nir_imm_int(b, 0);
+
+      el = nir_iadd(b, el, nir_load_base_instance(b));
+      ctx->requires_base_instance = true;
+
+      BITSET_SET(b->shader->info.system_values_read,
+                 SYSTEM_VALUE_BASE_INSTANCE);
+   } else {
+      el = nir_load_vertex_id(b);
+      ctx->requires_vertex_id = true;
+   }
+
+   /* Load the pointer of the buffer from the argument buffer */
+   nir_def *argbuf = nir_load_buffer_ptr_kk(b, 1, 64, .binding = 0);
+   uint64_t attrib_base_offset =
+      offsetof(struct kk_root_descriptor_table, draw.attrib_base[index]);
+   nir_def *base = nir_load_global_constant(
+      b, nir_iadd_imm(b, argbuf, attrib_base_offset), 8, 1, 64);
+
+   uint64_t buffer_stride_offset = offsetof(
+      struct kk_root_descriptor_table, draw.buffer_strides[attrib.binding]);
+   nir_def *stride = nir_load_global_constant(
+      b, nir_iadd_imm(b, argbuf, buffer_stride_offset), 4, 1, 32);
+   nir_def *stride_offset_el =
+      nir_imul(b, el, nir_udiv_imm(b, stride, interchange_align));
+
+   /* Load the raw vector */
+   nir_def *memory = nir_load_constant_agx(
+      b, interchange_comps, interchange_register_size, base, stride_offset_el,
+      .format = interchange_format, .base = 0u);
+
+   unsigned dest_size = intr->def.bit_size;
+   unsigned bits[] = {desc->channel[chan].size, desc->channel[chan].size,
+                      desc->channel[chan].size, desc->channel[chan].size};
+
+   /* Unpack non-native formats */
+   if (is_rg11_b10(desc)) {
+      memory = nir_format_unpack_11f11f10f(b, memory);
+   } else if (is_rgb10_a2(desc)) {
+      bits[0] = 10;
+      bits[1] = 10;
+      bits[2] = 10;
+      bits[3] = 2;
+      if (is_signed)
+         memory = nir_format_unpack_sint(b, memory, bits, 4);
+      else
+         memory = nir_format_unpack_uint(b, memory, bits, 4);
+   }
+
+   if (desc->channel[chan].normalized) {
+      if (is_signed)
+         memory = nir_format_snorm_to_float(b, memory, bits);
+      else
+         memory = nir_format_unorm_to_float(b, memory, bits);
+   } else if (desc->channel[chan].pure_integer) {
+      if (is_signed)
+         memory = nir_i2iN(b, memory, dest_size);
+      else
+         memory = nir_u2uN(b, memory, dest_size);
+   } else {
+      if (is_unsigned)
+         memory = nir_u2fN(b, memory, dest_size);
+      else if (is_signed || is_fixed)
+         memory = nir_i2fN(b, memory, dest_size);
+      else
+         memory = nir_f2fN(b, memory, dest_size);
+
+      /* 16.16 fixed-point weirdo GL formats need to be scaled */
+      if (is_fixed) {
+         assert(desc->is_array && desc->channel[chan].size == 32);
+         assert(dest_size == 32 && "overflow if smaller");
+         memory = nir_fmul_imm(b, memory, 1.0 / 65536.0);
+      }
+   }
+
+   /* We now have a properly formatted vector of the components in memory. Apply
+    * the format swizzle forwards to trim/pad/reorder as needed.
+    */
+   nir_def *channels[4] = {NULL};
+
+   for (unsigned i = 0; i < intr->num_components; ++i) {
+      unsigned c = nir_intrinsic_component(intr) + i;
+      channels[i] = apply_swizzle_channel(b, memory, desc->swizzle[c], is_int);
+   }
+
+   nir_def *logical = nir_vec(b, channels, intr->num_components);
+   nir_def_rewrite_uses(&intr->def, logical);
+   return true;
+}
+
+bool
+kk_nir_lower_vbo(nir_shader *nir, struct kk_attribute *attribs)
+{
+   assert(nir->info.stage == MESA_SHADER_VERTEX);
+
+   struct ctx ctx = {.attribs = attribs};
+   bool progress =
+      nir_shader_intrinsics_pass(nir, pass, nir_metadata_control_flow, &ctx);
+
+   if (ctx.requires_instance_id)
+      BITSET_SET(nir->info.system_values_read, SYSTEM_VALUE_INSTANCE_ID);
+   if (ctx.requires_base_instance)
+      BITSET_SET(nir->info.system_values_read, SYSTEM_VALUE_BASE_INSTANCE);
+   if (ctx.requires_vertex_id)
+      BITSET_SET(nir->info.system_values_read, SYSTEM_VALUE_VERTEX_ID);
+   return progress;
+}
diff --git a/src/kosmickrisp/vulkan/kk_nir_lower_vbo.h b/src/kosmickrisp/vulkan/kk_nir_lower_vbo.h
new file mode 100644
index 00000000000..436e070794a
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_nir_lower_vbo.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2022 Alyssa Rosenzweig
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "util/format/u_formats.h"
+#include "nir.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define KK_MAX_ATTRIBS (32)
+#define KK_MAX_VBUFS   (32)
+
+/* See pipe_vertex_element for justification on the sizes. This structure should
+ * be small so it can be embedded into a shader key.
+ */
+struct kk_attribute {
+   /* If instanced, Zero means all get the same value (Vulkan semantics). */
+   uint32_t divisor;
+   /* Buffer binding to load stride from root_table */
+   uint32_t binding;
+
+   /* pipe_format, all vertex formats should be <= 255 */
+   uint8_t format;
+
+   unsigned buf   : 7;
+   bool instanced : 1;
+};
+
+bool kk_nir_lower_vbo(nir_shader *shader, struct kk_attribute *attribs);
+
+bool kk_vbo_supports_format(enum pipe_format format);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
\ No newline at end of file
diff --git a/src/kosmickrisp/vulkan/kk_physical_device.c b/src/kosmickrisp/vulkan/kk_physical_device.c
new file mode 100644
index 00000000000..2f9ce537f6e
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_physical_device.c
@@ -0,0 +1,1032 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_physical_device.h"
+
+#include "kk_entrypoints.h"
+#include "kk_image.h"
+#include "kk_instance.h"
+#include "kk_nir_lower_vbo.h"
+#include "kk_sync.h"
+#include "kk_wsi.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+#include "util/disk_cache.h"
+#include "util/mesa-sha1.h"
+#include "git_sha1.h"
+
+#include "vulkan/wsi/wsi_common.h"
+#include "vk_device.h"
+#include "vk_drm_syncobj.h"
+#include "vk_shader_module.h"
+
+static uint32_t
+kk_get_vk_version()
+{
+   /* Version override takes priority */
+   const uint32_t version_override = vk_get_version_override();
+   if (version_override)
+      return version_override;
+
+   return VK_MAKE_VERSION(1, 3, VK_HEADER_VERSION);
+}
+
+static void
+kk_get_device_extensions(const struct kk_instance *instance,
+                         struct vk_device_extension_table *ext)
+{
+   *ext = (struct vk_device_extension_table){
+      /* Vulkan 1.1 */
+      .KHR_16bit_storage = true,
+      .KHR_bind_memory2 = true,
+      .KHR_dedicated_allocation = true,
+      .KHR_descriptor_update_template = true,
+      .KHR_device_group = true,
+      .KHR_external_fence = true,
+      .KHR_external_memory = true,
+      .KHR_external_semaphore = true,
+      .KHR_get_memory_requirements2 = true,
+      .KHR_maintenance1 = true,
+      .KHR_maintenance2 = true,
+      .KHR_maintenance3 = true,
+      .KHR_multiview = true,
+      .KHR_relaxed_block_layout = true,
+      .KHR_sampler_ycbcr_conversion = true,
+      .KHR_shader_draw_parameters = false,
+      .KHR_storage_buffer_storage_class = true,
+      .KHR_variable_pointers = true,
+
+      /* Vulkan 1.2 */
+      .KHR_8bit_storage = true,
+      .KHR_buffer_device_address = true, /* Required in Vulkan 1.3 */
+      .KHR_create_renderpass2 = true,
+      .KHR_depth_stencil_resolve = true,
+      .KHR_draw_indirect_count = false,
+      .KHR_driver_properties = true,
+      .KHR_image_format_list = true,
+      .KHR_imageless_framebuffer = true,
+      .KHR_sampler_mirror_clamp_to_edge = false,
+      .KHR_separate_depth_stencil_layouts = true,
+      .KHR_shader_atomic_int64 = false,
+      .KHR_shader_float16_int8 =
+         false, /* TODO_KOSMICKRISP shaderInt8 shaderFloat16 */
+      .KHR_shader_float_controls = true,
+      .KHR_shader_subgroup_extended_types = true,
+      .KHR_spirv_1_4 = true,
+      .KHR_timeline_semaphore = true,
+      .KHR_uniform_buffer_standard_layout = true,
+      .KHR_vulkan_memory_model = true, /* Required in Vulkan 1.3 */
+      .EXT_descriptor_indexing = true,
+      .EXT_host_query_reset = true,
+      .EXT_sampler_filter_minmax = false,
+      .EXT_scalar_block_layout = true,
+      .EXT_separate_stencil_usage = true,
+      .EXT_shader_viewport_index_layer = false,
+
+      /* Vulkan 1.3 */
+      .KHR_copy_commands2 = true,
+      .KHR_dynamic_rendering = true,
+      .KHR_format_feature_flags2 = true,
+      .KHR_maintenance4 = true,
+      .KHR_shader_integer_dot_product = true,
+      .KHR_shader_non_semantic_info = true,
+      .KHR_shader_terminate_invocation = true,
+      .KHR_synchronization2 = true,
+      .KHR_zero_initialize_workgroup_memory = true,
+      .EXT_4444_formats = false,
+      .EXT_extended_dynamic_state = true,
+      .EXT_extended_dynamic_state2 = false,
+      .EXT_image_robustness = true,
+      .EXT_inline_uniform_block = true,
+      .EXT_pipeline_creation_cache_control = true,
+      .EXT_pipeline_creation_feedback = true,
+      .EXT_private_data = true,
+      .EXT_shader_demote_to_helper_invocation = true,
+      .EXT_subgroup_size_control = true,
+      .EXT_texel_buffer_alignment = false,
+      .EXT_texture_compression_astc_hdr = false,
+      .EXT_tooling_info = true,
+      .EXT_ycbcr_2plane_444_formats = false,
+
+      /* Vulkan 1.4 */
+      .KHR_push_descriptor = true,
+
+   /* Optional extensions */
+#ifdef KK_USE_WSI_PLATFORM
+      .KHR_swapchain = true,
+      .KHR_swapchain_mutable_format = true,
+#endif
+      .EXT_external_memory_metal = true,
+      .EXT_mutable_descriptor_type = true,
+      .EXT_shader_replicated_composites = true,
+
+      .KHR_shader_expect_assume = true,
+      .KHR_shader_maximal_reconvergence = true,
+      .KHR_shader_relaxed_extended_instruction = true,
+      .KHR_shader_subgroup_uniform_control_flow = true,
+
+      .GOOGLE_decorate_string = true,
+      .GOOGLE_hlsl_functionality1 = true,
+      .GOOGLE_user_type = true,
+   };
+}
+
+static void
+kk_get_device_features(
+   const struct vk_device_extension_table *supported_extensions,
+   struct vk_features *features)
+{
+   *features = (struct vk_features){
+      /* Vulkan 1.0 */
+      .robustBufferAccess = true,
+      .depthClamp = true,
+      .drawIndirectFirstInstance = true,
+      /* TODO_KOSMICKRISP
+       * Enabling fragmentStoresAndAtomics fails the following CTS tests, need
+       * to investigate:
+       * dEQP-VK.fragment_operations.early_fragment.discard_no_early_fragment_tests_depth
+       * dEQP-VK.robustness.image_robustness.bind.notemplate.*i.unroll.nonvolatile.sampled_image.no_fmt_qual.img.samples_1.*d_array.frag
+       */
+      .fragmentStoresAndAtomics = false,
+      .imageCubeArray = true,
+      .shaderInt16 = true,
+      .shaderInt64 = true,
+      .shaderResourceMinLod = true,
+      /* TODO_KOSMICKRISP
+       * Disabled because the following test
+       * dEQP-VK.api.format_feature_flags2.r8_unorm and similars fail, need to
+       * set VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT and
+       * VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT for those formats.
+       * This may trigger more tests that haven't been run yet */
+      .shaderStorageImageReadWithoutFormat = false,
+      .shaderStorageImageWriteWithoutFormat = false,
+      .shaderUniformBufferArrayDynamicIndexing = true,
+      .shaderSampledImageArrayDynamicIndexing = true,
+      .shaderStorageBufferArrayDynamicIndexing = true,
+      .shaderStorageImageArrayDynamicIndexing = true,
+
+      /* Vulkan 1.1 */
+      .multiview = true,
+      .storageBuffer16BitAccess = true,
+      .storageInputOutput16 = false,
+      .storagePushConstant16 = true,
+      .variablePointersStorageBuffer = true,
+      .variablePointers = true,
+      .uniformAndStorageBuffer16BitAccess = true,
+
+      /* Vulkan 1.2 */
+      .descriptorBindingInlineUniformBlockUpdateAfterBind = true,
+      .descriptorBindingPartiallyBound = true,
+      .descriptorBindingSampledImageUpdateAfterBind = true,
+      .descriptorBindingStorageBufferUpdateAfterBind = true,
+      .descriptorBindingStorageImageUpdateAfterBind = true,
+      .descriptorBindingStorageTexelBufferUpdateAfterBind = true,
+      .descriptorBindingUniformBufferUpdateAfterBind = true,
+      .descriptorBindingUniformTexelBufferUpdateAfterBind = true,
+      .descriptorBindingUpdateUnusedWhilePending = true,
+      .descriptorBindingVariableDescriptorCount = true,
+      .descriptorIndexing = true,
+      .hostQueryReset = true,
+      .imagelessFramebuffer = true,
+      .runtimeDescriptorArray = true,
+      .scalarBlockLayout = true,
+      .separateDepthStencilLayouts = true,
+      /* TODO_KOSMICKRISP shaderFloat16
+       * Failing:
+       * dEQP-VK.spirv_assembly.instruction.compute.float16.opcompositeinsert.v4f16
+       * dEQP-VK.spirv_assembly.instruction.compute.float16.opcompositeinsert.v2f16arr5
+       * dEQP-VK.spirv_assembly.instruction.compute.float16.opcompositeinsert.v3f16arr5
+       * dEQP-VK.spirv_assembly.instruction.compute.float16.opcompositeinsert.v4f16arr3
+       * dEQP-VK.spirv_assembly.instruction.compute.float16.opcompositeinsert.struct16arr3
+       * dEQP-VK.spirv_assembly.instruction.graphics.float16.opcompositeinsert.v3f16_frag
+       * dEQP-VK.spirv_assembly.instruction.graphics.float16.opcompositeinsert.v4f16_frag
+       * dEQP-VK.spirv_assembly.instruction.graphics.float16.opcompositeinsert.v2f16arr5_frag
+       * dEQP-VK.spirv_assembly.instruction.graphics.float16.opcompositeinsert.v3f16arr5_frag
+       * dEQP-VK.spirv_assembly.instruction.graphics.float16.opcompositeinsert.v4f16arr3_frag
+       * dEQP-VK.spirv_assembly.instruction.graphics.float16.opcompositeinsert.struct16arr3_frag
+       * dEQP-VK.memory_model.shared.16bit.nested_structs_arrays.0
+       * dEQP-VK.memory_model.shared.16bit.nested_structs_arrays.4
+       */
+      .shaderFloat16 = false,
+      .shaderInputAttachmentArrayDynamicIndexing = true,
+      .shaderInputAttachmentArrayNonUniformIndexing = true,
+      /* TODO_KOSMICKRISP shaderInt8
+      * Multiple MSL compiler crashes if we enable shaderInt8, need to
+      * understand why and a workaround:
+      * dEQP-VK.memory_model.shared.8bit.vector_types.9
+      * dEQP-VK.memory_model.shared.8bit.basic_types.8
+      * dEQP-VK.memory_model.shared.8bit.basic_arrays.2
+      * dEQP-VK.memory_model.shared.8bit.arrays_of_arrays.1
+      * dEQP-VK.memory_model.shared.8bit.arrays_of_arrays.8
+      * Probably more
+      */
+      .shaderInt8 = false,
+      .shaderOutputViewportIndex = true,
+      .shaderOutputLayer = true,
+      .shaderSampledImageArrayNonUniformIndexing = true,
+      .shaderStorageBufferArrayNonUniformIndexing = true,
+      .shaderStorageTexelBufferArrayDynamicIndexing = true,
+      .shaderSubgroupExtendedTypes = true,
+      .shaderUniformTexelBufferArrayDynamicIndexing = true,
+      .shaderUniformTexelBufferArrayNonUniformIndexing = true,
+      .storageBuffer8BitAccess = true,
+      .storagePushConstant8 = true,
+      .subgroupBroadcastDynamicId = true,
+      .timelineSemaphore = true,
+      .uniformAndStorageBuffer8BitAccess = true,
+      .uniformBufferStandardLayout = true,
+
+      /* Vulkan 1.3 */
+      .bufferDeviceAddress = true,
+      .computeFullSubgroups = true,
+      .dynamicRendering = true,
+      .inlineUniformBlock = true,
+      .maintenance4 = true,
+      .pipelineCreationCacheControl = true,
+      .privateData = true,
+      .robustImageAccess = true,
+      .shaderDemoteToHelperInvocation = true,
+      .shaderIntegerDotProduct = true,
+      .shaderTerminateInvocation = true,
+      .shaderZeroInitializeWorkgroupMemory = true,
+      .subgroupSizeControl = true,
+      .synchronization2 = true,
+      .vulkanMemoryModel = true,
+      .vulkanMemoryModelDeviceScope = true,
+
+      /* Optional features */
+      .samplerAnisotropy = true,
+      .samplerYcbcrConversion = true,
+      .textureCompressionETC2 = true,
+      .textureCompressionASTC_LDR = true,
+
+      /* VK_EXT_mutable_descriptor_type */
+      .mutableDescriptorType = true,
+
+      /* VK_KHR_shader_expect_assume */
+      .shaderExpectAssume = true,
+
+      /* VK_KHR_shader_maximal_reconvergence */
+      .shaderMaximalReconvergence = true,
+
+      /* VK_KHR_shader_relaxed_extended_instruction */
+      .shaderRelaxedExtendedInstruction = true,
+
+      /* VK_EXT_shader_replicated_composites */
+      .shaderReplicatedComposites = true,
+
+      /* VK_KHR_shader_subgroup_uniform_control_flow */
+      .shaderSubgroupUniformControlFlow = true,
+   };
+}
+
+static void
+kk_get_device_properties(const struct kk_physical_device *pdev,
+                         const struct kk_instance *instance,
+                         struct vk_properties *properties)
+{
+   const VkSampleCountFlagBits sample_counts =
+      VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT |
+      // TODO_KOSMICKRISP Modify sample count based on what pdev supports
+      VK_SAMPLE_COUNT_4_BIT /* |
+       VK_SAMPLE_COUNT_8_BIT */
+      ;
+
+   assert(sample_counts <= (KK_MAX_SAMPLES << 1) - 1);
+
+   uint64_t os_page_size = 4096;
+   os_get_page_size(&os_page_size);
+
+   *properties = (struct vk_properties){
+      .apiVersion = kk_get_vk_version(),
+      .driverVersion = vk_get_driver_version(),
+      .vendorID = instance->force_vk_vendor != 0 ? instance->force_vk_vendor
+                                                 : 0x106b,
+      .deviceID = 100,
+      .deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
+
+      /* Vulkan 1.0 limits */
+      /* Values taken from Apple7
+         https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf */
+      .maxImageDimension1D = kk_image_max_dimension(VK_IMAGE_TYPE_2D),
+      .maxImageDimension2D = kk_image_max_dimension(VK_IMAGE_TYPE_2D),
+      .maxImageDimension3D = kk_image_max_dimension(VK_IMAGE_TYPE_3D),
+      .maxImageDimensionCube = 16384,
+      .maxImageArrayLayers = 2048,
+      .maxTexelBufferElements = 256 * 1024 * 1024,
+      .maxUniformBufferRange = 65536,
+      .maxStorageBufferRange = UINT32_MAX,
+      .maxPushConstantsSize = KK_MAX_PUSH_SIZE,
+      .maxMemoryAllocationCount = 4096,
+      .maxSamplerAllocationCount = 4000,
+      .bufferImageGranularity = 16,
+      .sparseAddressSpaceSize = KK_SPARSE_ADDR_SPACE_SIZE,
+      .maxBoundDescriptorSets = KK_MAX_SETS,
+      .maxPerStageDescriptorSamplers = KK_MAX_DESCRIPTORS,
+      .maxPerStageDescriptorUniformBuffers = KK_MAX_DESCRIPTORS,
+      .maxPerStageDescriptorStorageBuffers = KK_MAX_DESCRIPTORS,
+      .maxPerStageDescriptorSampledImages = KK_MAX_DESCRIPTORS,
+      .maxPerStageDescriptorStorageImages = KK_MAX_DESCRIPTORS,
+      .maxPerStageDescriptorInputAttachments = KK_MAX_DESCRIPTORS,
+      .maxPerStageResources = UINT32_MAX,
+      .maxDescriptorSetSamplers = KK_MAX_DESCRIPTORS,
+      .maxDescriptorSetUniformBuffers = KK_MAX_DESCRIPTORS,
+      .maxDescriptorSetUniformBuffersDynamic = KK_MAX_DYNAMIC_BUFFERS / 2,
+      .maxDescriptorSetStorageBuffers = KK_MAX_DESCRIPTORS,
+      .maxDescriptorSetStorageBuffersDynamic = KK_MAX_DYNAMIC_BUFFERS / 2,
+      .maxDescriptorSetSampledImages = KK_MAX_DESCRIPTORS,
+      .maxDescriptorSetStorageImages = KK_MAX_DESCRIPTORS,
+      .maxDescriptorSetInputAttachments = KK_MAX_DESCRIPTORS,
+      .maxVertexInputAttributes = KK_MAX_ATTRIBS,
+      .maxVertexInputBindings = KK_MAX_VBUFS,
+      .maxVertexInputAttributeOffset = 2047,
+      .maxVertexInputBindingStride = 2048,
+      .maxVertexOutputComponents = 128,
+      .maxTessellationGenerationLevel = 64,
+      .maxTessellationPatchSize = 32,
+      .maxTessellationControlPerVertexInputComponents = 128,
+      .maxTessellationControlPerVertexOutputComponents = 128,
+      .maxTessellationControlPerPatchOutputComponents = 120,
+      .maxTessellationControlTotalOutputComponents = 4216,
+      .maxTessellationEvaluationInputComponents = 128,
+      .maxTessellationEvaluationOutputComponents = 128,
+      .maxGeometryShaderInvocations = 32,
+      .maxGeometryInputComponents = 128,
+      .maxGeometryOutputComponents = 128,
+      .maxGeometryOutputVertices = 1024,
+      .maxGeometryTotalOutputComponents = 1024,
+      .maxFragmentInputComponents = 128,
+      .maxFragmentOutputAttachments = KK_MAX_RTS,
+      .maxFragmentDualSrcAttachments = 1,
+      .maxFragmentCombinedOutputResources = 16,
+      .maxComputeSharedMemorySize = KK_MAX_SHARED_SIZE,
+      .maxComputeWorkGroupCount = {0x7fffffff, 65535, 65535},
+      .maxComputeWorkGroupInvocations = pdev->info.max_workgroup_invocations,
+      .maxComputeWorkGroupSize = {pdev->info.max_workgroup_count[0],
+                                  pdev->info.max_workgroup_count[1],
+                                  pdev->info.max_workgroup_count[2]},
+      .subPixelPrecisionBits = 8,
+      .subTexelPrecisionBits = 8,
+      .mipmapPrecisionBits = 8,
+      .maxDrawIndexedIndexValue = UINT32_MAX,
+      .maxDrawIndirectCount = UINT32_MAX,
+      .maxSamplerLodBias = 15,
+      .maxSamplerAnisotropy = 16,
+      .maxViewports = KK_MAX_VIEWPORTS,
+      .maxViewportDimensions = {32768, 32768},
+      .viewportBoundsRange = {-65536, 65536},
+      .viewportSubPixelBits = 8,
+      .minMemoryMapAlignment = os_page_size,
+      .minTexelBufferOffsetAlignment = KK_MIN_TEXEL_BUFFER_ALIGNMENT,
+      .minUniformBufferOffsetAlignment = KK_MIN_UBO_ALIGNMENT,
+      .minStorageBufferOffsetAlignment = KK_MIN_SSBO_ALIGNMENT,
+      .minTexelOffset = -8,
+      .maxTexelOffset = 7,
+      .minTexelGatherOffset = -32,
+      .maxTexelGatherOffset = 31,
+      .minInterpolationOffset = -0.5,
+      .maxInterpolationOffset = 0.4375,
+      .subPixelInterpolationOffsetBits = 4,
+      .maxFramebufferHeight = 16384,
+      .maxFramebufferWidth = 16384,
+      .maxFramebufferLayers = 2048,
+      .framebufferColorSampleCounts = sample_counts,
+      .framebufferDepthSampleCounts = sample_counts,
+      .framebufferNoAttachmentsSampleCounts = sample_counts,
+      .framebufferStencilSampleCounts = sample_counts,
+      .maxColorAttachments = KK_MAX_RTS,
+      .sampledImageColorSampleCounts = sample_counts,
+      .sampledImageIntegerSampleCounts = sample_counts,
+      .sampledImageDepthSampleCounts = sample_counts,
+      .sampledImageStencilSampleCounts = sample_counts,
+      .storageImageSampleCounts = sample_counts,
+      .maxSampleMaskWords = 1,
+      .timestampComputeAndGraphics = false,
+      .timestampPeriod = 1,
+      .maxClipDistances = 8,
+      .maxCullDistances = 8,
+      .maxCombinedClipAndCullDistances = 8,
+      .discreteQueuePriorities = 2,
+      .pointSizeRange = {1.0f, 1.0f},
+      .lineWidthRange = {1.0f, 1.0f},
+      .pointSizeGranularity = 0.0f,
+      .lineWidthGranularity = 0.0f,
+      .strictLines = false,
+      .standardSampleLocations = true,
+      .optimalBufferCopyOffsetAlignment = 1,
+      .optimalBufferCopyRowPitchAlignment = 1,
+      .nonCoherentAtomSize = 64,
+
+      /* Vulkan 1.0 sparse properties */
+      .sparseResidencyNonResidentStrict = false,
+      .sparseResidencyAlignedMipSize = false,
+      .sparseResidencyStandard2DBlockShape = false,
+      .sparseResidencyStandard2DMultisampleBlockShape = false,
+      .sparseResidencyStandard3DBlockShape = false,
+
+      /* Vulkan 1.1 properties */
+      .subgroupSize = 32,
+      .subgroupSupportedStages =
+         VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
+      .subgroupSupportedOperations =
+         VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT |
+         VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT |
+         VK_SUBGROUP_FEATURE_SHUFFLE_BIT |
+         VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT |
+         VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR, // | TODO_KOSMICKRISP
+      // VK_SUBGROUP_FEATURE_ARITHMETIC_BIT |
+      // VK_SUBGROUP_FEATURE_CLUSTERED_BIT |
+      // VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR,
+      .subgroupQuadOperationsInAllStages = true,
+      .pointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
+      .maxMultiviewViewCount = KK_MAX_MULTIVIEW_VIEW_COUNT,
+      .maxMultiviewInstanceIndex = UINT32_MAX,
+      .maxPerSetDescriptors = UINT32_MAX,
+      .maxMemoryAllocationSize = (1u << 31),
+
+      /* Vulkan 1.2 properties */
+      .supportedDepthResolveModes =
+         VK_RESOLVE_MODE_SAMPLE_ZERO_BIT | VK_RESOLVE_MODE_AVERAGE_BIT |
+         VK_RESOLVE_MODE_MIN_BIT | VK_RESOLVE_MODE_MAX_BIT,
+      .supportedStencilResolveModes = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT |
+                                      VK_RESOLVE_MODE_MIN_BIT |
+                                      VK_RESOLVE_MODE_MAX_BIT,
+      .independentResolveNone = true,
+      .independentResolve = true,
+      .driverID = VK_DRIVER_ID_MESA_HONEYKRISP, // TODO_KOSMICKRISP Have our own
+      .conformanceVersion = (VkConformanceVersion){1, 4, 3, 2},
+      .denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE,
+      .roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE,
+      .shaderSignedZeroInfNanPreserveFloat16 = false,
+      .shaderSignedZeroInfNanPreserveFloat32 = false,
+      .shaderSignedZeroInfNanPreserveFloat64 = false,
+      .shaderDenormPreserveFloat16 = false,
+      .shaderDenormPreserveFloat32 = false,
+      .shaderDenormPreserveFloat64 = false,
+      .shaderDenormFlushToZeroFloat16 = false,
+      .shaderDenormFlushToZeroFloat32 = false,
+      .shaderDenormFlushToZeroFloat64 = false,
+      .shaderRoundingModeRTEFloat16 = false,
+      .shaderRoundingModeRTEFloat32 = false,
+      .shaderRoundingModeRTEFloat64 = false,
+      .shaderRoundingModeRTZFloat16 = false,
+      .shaderRoundingModeRTZFloat32 = false,
+      .shaderRoundingModeRTZFloat64 = false,
+      .maxUpdateAfterBindDescriptorsInAllPools = UINT32_MAX,
+      .shaderUniformBufferArrayNonUniformIndexingNative = true,
+      .shaderSampledImageArrayNonUniformIndexingNative = true,
+      .shaderStorageBufferArrayNonUniformIndexingNative = true,
+      .shaderStorageImageArrayNonUniformIndexingNative = true,
+      .shaderInputAttachmentArrayNonUniformIndexingNative = true,
+      .robustBufferAccessUpdateAfterBind = true,
+      .quadDivergentImplicitLod = false,
+      .maxPerStageDescriptorUpdateAfterBindSamplers = KK_MAX_DESCRIPTORS,
+      .maxPerStageDescriptorUpdateAfterBindUniformBuffers = KK_MAX_DESCRIPTORS,
+      .maxPerStageDescriptorUpdateAfterBindStorageBuffers = KK_MAX_DESCRIPTORS,
+      .maxPerStageDescriptorUpdateAfterBindSampledImages = KK_MAX_DESCRIPTORS,
+      .maxPerStageDescriptorUpdateAfterBindStorageImages = KK_MAX_DESCRIPTORS,
+      .maxPerStageDescriptorUpdateAfterBindInputAttachments =
+         KK_MAX_DESCRIPTORS,
+      .maxPerStageUpdateAfterBindResources = UINT32_MAX,
+      .maxDescriptorSetUpdateAfterBindSamplers = KK_MAX_DESCRIPTORS,
+      .maxDescriptorSetUpdateAfterBindUniformBuffers = KK_MAX_DESCRIPTORS,
+      .maxDescriptorSetUpdateAfterBindUniformBuffersDynamic =
+         KK_MAX_DYNAMIC_BUFFERS / 2,
+      .maxDescriptorSetUpdateAfterBindStorageBuffers = KK_MAX_DESCRIPTORS,
+      .maxDescriptorSetUpdateAfterBindStorageBuffersDynamic =
+         KK_MAX_DYNAMIC_BUFFERS / 2,
+      .maxDescriptorSetUpdateAfterBindSampledImages = KK_MAX_DESCRIPTORS,
+      .maxDescriptorSetUpdateAfterBindStorageImages = KK_MAX_DESCRIPTORS,
+      .maxDescriptorSetUpdateAfterBindInputAttachments = KK_MAX_DESCRIPTORS,
+      .filterMinmaxSingleComponentFormats = false,
+      .filterMinmaxImageComponentMapping = false,
+      .maxTimelineSemaphoreValueDifference = UINT64_MAX,
+      .framebufferIntegerColorSampleCounts = sample_counts,
+
+      /* Vulkan 1.3 properties */
+      .minSubgroupSize = 32,
+      .maxSubgroupSize = 32,
+      .maxComputeWorkgroupSubgroups = pdev->info.max_workgroup_invocations / 32,
+      .requiredSubgroupSizeStages = 0,
+      .maxInlineUniformBlockSize = 1 << 16,
+      .maxPerStageDescriptorInlineUniformBlocks = 32,
+      .maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = 32,
+      .maxDescriptorSetInlineUniformBlocks = 6 * 32,
+      .maxDescriptorSetUpdateAfterBindInlineUniformBlocks = 6 * 32,
+      .maxInlineUniformTotalSize = 1 << 16,
+      .integerDotProduct4x8BitPackedUnsignedAccelerated = false,
+      .integerDotProduct4x8BitPackedSignedAccelerated = false,
+      .integerDotProduct4x8BitPackedMixedSignednessAccelerated = false,
+      .storageTexelBufferOffsetAlignmentBytes = KK_MIN_TEXEL_BUFFER_ALIGNMENT,
+      .storageTexelBufferOffsetSingleTexelAlignment = false,
+      .uniformTexelBufferOffsetAlignmentBytes = KK_MIN_TEXEL_BUFFER_ALIGNMENT,
+      .uniformTexelBufferOffsetSingleTexelAlignment = false,
+      .maxBufferSize = KK_MAX_BUFFER_SIZE,
+
+      /* VK_KHR_push_descriptor */
+      .maxPushDescriptors = KK_MAX_PUSH_DESCRIPTORS,
+
+      /* VK_EXT_custom_border_color */
+      .maxCustomBorderColorSamplers = 4000,
+
+      /* VK_EXT_extended_dynamic_state3 */
+      .dynamicPrimitiveTopologyUnrestricted = false,
+
+      /* VK_EXT_graphics_pipeline_library */
+      .graphicsPipelineLibraryFastLinking = true,
+      .graphicsPipelineLibraryIndependentInterpolationDecoration = true,
+
+      /* VK_KHR_line_rasterization */
+      .lineSubPixelPrecisionBits = 8,
+
+      /* VK_KHR_maintenance5 */
+      .earlyFragmentMultisampleCoverageAfterSampleCounting = false,
+      .earlyFragmentSampleMaskTestBeforeSampleCounting = true,
+      .depthStencilSwizzleOneSupport = false,
+      .polygonModePointSize = false,
+      .nonStrictSinglePixelWideLinesUseParallelogram = false,
+      .nonStrictWideLinesUseParallelogram = false,
+
+      /* VK_KHR_maintenance6 */
+      .blockTexelViewCompatibleMultipleLayers = false,
+      .maxCombinedImageSamplerDescriptorCount = 3,
+      .fragmentShadingRateClampCombinerInputs = false, /* TODO */
+
+      /* VK_KHR_maintenance7 */
+      .robustFragmentShadingRateAttachmentAccess = false,
+      .separateDepthStencilAttachmentAccess = false,
+      .maxDescriptorSetTotalUniformBuffersDynamic = KK_MAX_DYNAMIC_BUFFERS / 2,
+      .maxDescriptorSetTotalStorageBuffersDynamic = KK_MAX_DYNAMIC_BUFFERS / 2,
+      .maxDescriptorSetTotalBuffersDynamic = KK_MAX_DYNAMIC_BUFFERS,
+      .maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic =
+         KK_MAX_DYNAMIC_BUFFERS / 2,
+      .maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic =
+         KK_MAX_DYNAMIC_BUFFERS / 2,
+      .maxDescriptorSetUpdateAfterBindTotalBuffersDynamic =
+         KK_MAX_DYNAMIC_BUFFERS,
+
+      /* VK_EXT_legacy_vertex_attributes */
+      .nativeUnalignedPerformance = true,
+
+      /* VK_EXT_map_memory_placed */
+      .minPlacedMemoryMapAlignment = os_page_size,
+
+      /* VK_EXT_multi_draw */
+      .maxMultiDrawCount = UINT32_MAX,
+
+      /* VK_EXT_nested_command_buffer */
+      .maxCommandBufferNestingLevel = UINT32_MAX,
+
+      /* VK_EXT_pipeline_robustness */
+      .defaultRobustnessStorageBuffers =
+         VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT,
+      .defaultRobustnessUniformBuffers =
+         VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT,
+      .defaultRobustnessVertexInputs =
+         VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT,
+      .defaultRobustnessImages =
+         VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT,
+
+      /* VK_EXT_physical_device_drm gets populated later */
+
+      /* VK_EXT_provoking_vertex */
+      .provokingVertexModePerPipeline = true,
+      .transformFeedbackPreservesTriangleFanProvokingVertex = true,
+
+      /* VK_EXT_robustness2 */
+      .robustStorageBufferAccessSizeAlignment = KK_SSBO_BOUNDS_CHECK_ALIGNMENT,
+      .robustUniformBufferAccessSizeAlignment = KK_MIN_UBO_ALIGNMENT,
+
+      /* VK_EXT_sample_locations */
+      .sampleLocationSampleCounts = sample_counts,
+      .maxSampleLocationGridSize = (VkExtent2D){1, 1},
+      .sampleLocationCoordinateRange[0] = 0.0f,
+      .sampleLocationCoordinateRange[1] = 0.9375f,
+      .sampleLocationSubPixelBits = 4,
+      .variableSampleLocations = false,
+
+      /* VK_EXT_shader_object */
+      .shaderBinaryVersion = 0,
+
+      /* VK_EXT_transform_feedback */
+      .maxTransformFeedbackStreams = 4,
+      .maxTransformFeedbackBuffers = 4,
+      .maxTransformFeedbackBufferSize = UINT32_MAX,
+      .maxTransformFeedbackStreamDataSize = 2048,
+      .maxTransformFeedbackBufferDataSize = 512,
+      .maxTransformFeedbackBufferDataStride = 2048,
+      .transformFeedbackQueries = true,
+      .transformFeedbackStreamsLinesTriangles = false,
+      .transformFeedbackRasterizationStreamSelect = true,
+      .transformFeedbackDraw = true,
+
+      /* VK_KHR_vertex_attribute_divisor */
+      .maxVertexAttribDivisor = UINT32_MAX,
+      .supportsNonZeroFirstInstance = true,
+
+      /* VK_KHR_fragment_shader_barycentric */
+      .triStripVertexOrderIndependentOfProvokingVertex = false,
+   };
+
+   char gpu_name[256u];
+   mtl_device_get_name(pdev->mtl_dev_handle, gpu_name);
+   snprintf(properties->deviceName, sizeof(properties->deviceName), "%s",
+            gpu_name);
+
+   /* Not sure if there are layout specific things, so for now just reporting
+    * all layouts from extensions.
+    */
+   static const VkImageLayout supported_layouts[] = {
+      VK_IMAGE_LAYOUT_GENERAL, /* this one is required by spec */
+      VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+      VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+      VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
+      VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+      VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+      VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+      VK_IMAGE_LAYOUT_PREINITIALIZED,
+      VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
+      VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
+      VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
+      VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL,
+      VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL,
+      VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,
+      VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL,
+      VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL,
+      VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT,
+      VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT,
+   };
+
+   properties->pCopySrcLayouts = (VkImageLayout *)supported_layouts;
+   properties->copySrcLayoutCount = ARRAY_SIZE(supported_layouts);
+   properties->pCopyDstLayouts = (VkImageLayout *)supported_layouts;
+   properties->copyDstLayoutCount = ARRAY_SIZE(supported_layouts);
+
+   STATIC_ASSERT(sizeof(instance->driver_build_sha) >= VK_UUID_SIZE);
+   memcpy(properties->optimalTilingLayoutUUID, instance->driver_build_sha,
+          VK_UUID_SIZE);
+
+   properties->identicalMemoryTypeRequirements = false;
+
+   /* VK_EXT_shader_module_identifier */
+   STATIC_ASSERT(sizeof(vk_shaderModuleIdentifierAlgorithmUUID) ==
+                 sizeof(properties->shaderModuleIdentifierAlgorithmUUID));
+   memcpy(properties->shaderModuleIdentifierAlgorithmUUID,
+          vk_shaderModuleIdentifierAlgorithmUUID,
+          sizeof(properties->shaderModuleIdentifierAlgorithmUUID));
+
+   const struct {
+      uint64_t registry_id;
+      uint64_t pad;
+   } dev_uuid = {
+      .registry_id = mtl_device_get_registry_id(pdev->mtl_dev_handle),
+   };
+   STATIC_ASSERT(sizeof(dev_uuid) == VK_UUID_SIZE);
+   memcpy(properties->deviceUUID, &dev_uuid, VK_UUID_SIZE);
+   STATIC_ASSERT(sizeof(instance->driver_build_sha) >= VK_UUID_SIZE);
+   memcpy(properties->driverUUID, instance->driver_build_sha, VK_UUID_SIZE);
+
+   snprintf(properties->driverName, VK_MAX_DRIVER_NAME_SIZE, "KosmicKrisp");
+   snprintf(properties->driverInfo, VK_MAX_DRIVER_INFO_SIZE,
+            "Mesa " PACKAGE_VERSION MESA_GIT_SHA1);
+}
+
+static void
+kk_physical_device_init_pipeline_cache(struct kk_physical_device *pdev)
+{
+   struct kk_instance *instance = kk_physical_device_instance(pdev);
+
+   struct mesa_sha1 sha_ctx;
+   _mesa_sha1_init(&sha_ctx);
+
+   _mesa_sha1_update(&sha_ctx, instance->driver_build_sha,
+                     sizeof(instance->driver_build_sha));
+
+   unsigned char sha[SHA1_DIGEST_LENGTH];
+   _mesa_sha1_final(&sha_ctx, sha);
+
+   STATIC_ASSERT(SHA1_DIGEST_LENGTH >= VK_UUID_SIZE);
+   memcpy(pdev->vk.properties.pipelineCacheUUID, sha, VK_UUID_SIZE);
+   memcpy(pdev->vk.properties.shaderBinaryUUID, sha, VK_UUID_SIZE);
+}
+
+static void
+kk_physical_device_free_disk_cache(struct kk_physical_device *pdev)
+{
+#ifdef ENABLE_SHADER_CACHE
+   if (pdev->vk.disk_cache) {
+      disk_cache_destroy(pdev->vk.disk_cache);
+      pdev->vk.disk_cache = NULL;
+   }
+#else
+   assert(pdev->vk.disk_cache == NULL);
+#endif
+}
+
+static uint64_t
+kk_get_sysmem_heap_size(void)
+{
+   uint64_t sysmem_size_B = 0;
+   if (!os_get_total_physical_memory(&sysmem_size_B))
+      return 0;
+
+   /* Use 3/4 of total size to avoid swapping */
+   return ROUND_DOWN_TO(sysmem_size_B * 3 / 4, 1 << 20);
+}
+
+static uint64_t
+kk_get_sysmem_heap_available(struct kk_physical_device *pdev)
+{
+   uint64_t sysmem_size_B = 0;
+   if (!os_get_available_system_memory(&sysmem_size_B)) {
+      vk_loge(VK_LOG_OBJS(pdev), "Failed to query available system memory");
+      return 0;
+   }
+
+   /* Use 3/4 of available to avoid swapping */
+   return ROUND_DOWN_TO(sysmem_size_B * 3 / 4, 1 << 20);
+}
+
+static void
+get_metal_limits(struct kk_physical_device *pdev)
+{
+   struct mtl_size workgroup_size =
+      mtl_device_max_threads_per_threadgroup(pdev->mtl_dev_handle);
+   pdev->info.max_workgroup_count[0] = workgroup_size.x;
+   pdev->info.max_workgroup_count[1] = workgroup_size.y;
+   pdev->info.max_workgroup_count[2] = workgroup_size.z;
+   pdev->info.max_workgroup_invocations =
+      MAX3(workgroup_size.x, workgroup_size.y, workgroup_size.z);
+}
+
+VkResult
+kk_enumerate_physical_devices(struct vk_instance *_instance)
+{
+   struct kk_instance *instance = (struct kk_instance *)_instance;
+   VkResult result;
+
+   struct kk_physical_device *pdev =
+      vk_zalloc(&instance->vk.alloc, sizeof(*pdev), 8,
+                VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+
+   if (pdev == NULL) {
+      return vk_error(instance, VK_ERROR_OUT_OF_HOST_MEMORY);
+   }
+
+   pdev->mtl_dev_handle = mtl_device_create();
+   if (!pdev->mtl_dev_handle) {
+      result = VK_SUCCESS;
+      goto fail_alloc;
+   }
+   get_metal_limits(pdev);
+
+   struct vk_physical_device_dispatch_table dispatch_table;
+   vk_physical_device_dispatch_table_from_entrypoints(
+      &dispatch_table, &kk_physical_device_entrypoints, true);
+   vk_physical_device_dispatch_table_from_entrypoints(
+      &dispatch_table, &wsi_physical_device_entrypoints, false);
+
+   struct vk_device_extension_table supported_extensions;
+   kk_get_device_extensions(instance, &supported_extensions);
+
+   struct vk_features supported_features;
+   kk_get_device_features(&supported_extensions, &supported_features);
+
+   struct vk_properties properties;
+   kk_get_device_properties(pdev, instance, &properties);
+
+   properties.drmHasRender = false;
+
+   result = vk_physical_device_init(&pdev->vk, &instance->vk,
+                                    &supported_extensions, &supported_features,
+                                    &properties, &dispatch_table);
+   if (result != VK_SUCCESS)
+      goto fail_mtl_dev;
+
+   uint64_t sysmem_size_B = kk_get_sysmem_heap_size();
+   if (sysmem_size_B == 0) {
+      result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
+                         "Failed to query total system memory");
+      goto fail_disk_cache;
+   }
+
+   uint32_t sysmem_heap_idx = pdev->mem_heap_count++;
+   pdev->mem_heaps[sysmem_heap_idx] = (struct kk_memory_heap){
+      .size = sysmem_size_B,
+      .flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
+      .available = kk_get_sysmem_heap_available,
+   };
+
+   pdev->mem_types[pdev->mem_type_count++] = (VkMemoryType){
+      .propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                       VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
+                       VK_MEMORY_PROPERTY_HOST_CACHED_BIT |
+                       VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+      .heapIndex = sysmem_heap_idx,
+   };
+
+   assert(pdev->mem_heap_count <= ARRAY_SIZE(pdev->mem_heaps));
+   assert(pdev->mem_type_count <= ARRAY_SIZE(pdev->mem_types));
+
+   pdev->queue_families[pdev->queue_family_count++] = (struct kk_queue_family){
+      .queue_flags =
+         VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT,
+      .queue_count = 1,
+   };
+   assert(pdev->queue_family_count <= ARRAY_SIZE(pdev->queue_families));
+
+   pdev->sync_binary_type = vk_sync_binary_get_type(&kk_sync_type);
+   unsigned st_idx = 0;
+   pdev->sync_types[st_idx++] = &kk_sync_type;
+   pdev->sync_types[st_idx++] = &pdev->sync_binary_type.sync;
+   pdev->sync_types[st_idx++] = NULL;
+   assert(st_idx <= ARRAY_SIZE(pdev->sync_types));
+   pdev->vk.supported_sync_types = pdev->sync_types;
+
+   result = kk_init_wsi(pdev);
+   if (result != VK_SUCCESS)
+      goto fail_disk_cache;
+
+   list_add(&pdev->vk.link, &instance->vk.physical_devices.list);
+
+   return VK_SUCCESS;
+
+fail_disk_cache:
+   vk_physical_device_finish(&pdev->vk);
+fail_mtl_dev:
+   mtl_release(pdev->mtl_dev_handle);
+fail_alloc:
+   vk_free(&instance->vk.alloc, pdev);
+   return result;
+}
+
+void
+kk_physical_device_destroy(struct vk_physical_device *vk_pdev)
+{
+   struct kk_physical_device *pdev =
+      container_of(vk_pdev, struct kk_physical_device, vk);
+
+   kk_finish_wsi(pdev);
+   kk_physical_device_free_disk_cache(pdev);
+   vk_physical_device_finish(&pdev->vk);
+   mtl_release(pdev->mtl_dev_handle);
+   vk_free(&pdev->vk.instance->alloc, pdev);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetPhysicalDeviceMemoryProperties2(
+   VkPhysicalDevice physicalDevice,
+   VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
+{
+   VK_FROM_HANDLE(kk_physical_device, pdev, physicalDevice);
+
+   pMemoryProperties->memoryProperties.memoryHeapCount = pdev->mem_heap_count;
+   for (int i = 0; i < pdev->mem_heap_count; i++) {
+      pMemoryProperties->memoryProperties.memoryHeaps[i] = (VkMemoryHeap){
+         .size = pdev->mem_heaps[i].size,
+         .flags = pdev->mem_heaps[i].flags,
+      };
+   }
+
+   pMemoryProperties->memoryProperties.memoryTypeCount = pdev->mem_type_count;
+   for (int i = 0; i < pdev->mem_type_count; i++) {
+      pMemoryProperties->memoryProperties.memoryTypes[i] = pdev->mem_types[i];
+   }
+
+   vk_foreach_struct(ext, pMemoryProperties->pNext) {
+      switch (ext->sType) {
+      case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
+         VkPhysicalDeviceMemoryBudgetPropertiesEXT *p = (void *)ext;
+
+         for (unsigned i = 0; i < pdev->mem_heap_count; i++) {
+            const struct kk_memory_heap *heap = &pdev->mem_heaps[i];
+            uint64_t used = p_atomic_read(&heap->used);
+
+            /* From the Vulkan 1.3.278 spec:
+             *
+             *    "heapUsage is an array of VK_MAX_MEMORY_HEAPS VkDeviceSize
+             *    values in which memory usages are returned, with one element
+             *    for each memory heap. A heap’s usage is an estimate of how
+             *    much memory the process is currently using in that heap."
+             *
+             * TODO: Include internal allocations?
+             */
+            p->heapUsage[i] = used;
+
+            uint64_t available = heap->size;
+            if (heap->available)
+               available = heap->available(pdev);
+
+            /* From the Vulkan 1.3.278 spec:
+             *
+             *    "heapBudget is an array of VK_MAX_MEMORY_HEAPS VkDeviceSize
+             *    values in which memory budgets are returned, with one
+             *    element for each memory heap. A heap’s budget is a rough
+             *    estimate of how much memory the process can allocate from
+             *    that heap before allocations may fail or cause performance
+             *    degradation. The budget includes any currently allocated
+             *    device memory."
+             *
+             * and
+             *
+             *    "The heapBudget value must be less than or equal to
+             *    VkMemoryHeap::size for each heap."
+             *
+             * available (queried above) is the total amount free memory
+             * system-wide and does not include our allocations so we need
+             * to add that in.
+             */
+            uint64_t budget = MIN2(available + used, heap->size);
+
+            /* Set the budget at 90% of available to avoid thrashing */
+            p->heapBudget[i] = ROUND_DOWN_TO(budget * 9 / 10, 1 << 20);
+         }
+
+         /* From the Vulkan 1.3.278 spec:
+          *
+          *    "The heapBudget and heapUsage values must be zero for array
+          *    elements greater than or equal to
+          *    VkPhysicalDeviceMemoryProperties::memoryHeapCount. The
+          *    heapBudget value must be non-zero for array elements less than
+          *    VkPhysicalDeviceMemoryProperties::memoryHeapCount."
+          */
+         for (unsigned i = pdev->mem_heap_count; i < VK_MAX_MEMORY_HEAPS; i++) {
+            p->heapBudget[i] = 0u;
+            p->heapUsage[i] = 0u;
+         }
+         break;
+      }
+      default:
+         vk_debug_ignored_stype(ext->sType);
+         break;
+      }
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetPhysicalDeviceQueueFamilyProperties2(
+   VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
+   VkQueueFamilyProperties2 *pQueueFamilyProperties)
+{
+   VK_FROM_HANDLE(kk_physical_device, pdev, physicalDevice);
+   VK_OUTARRAY_MAKE_TYPED(VkQueueFamilyProperties2, out, pQueueFamilyProperties,
+                          pQueueFamilyPropertyCount);
+
+   for (uint8_t i = 0; i < pdev->queue_family_count; i++) {
+      const struct kk_queue_family *queue_family = &pdev->queue_families[i];
+
+      vk_outarray_append_typed(VkQueueFamilyProperties2, &out, p)
+      {
+         p->queueFamilyProperties.queueFlags = queue_family->queue_flags;
+         p->queueFamilyProperties.queueCount = queue_family->queue_count;
+         p->queueFamilyProperties.timestampValidBits =
+            0; /* TODO_KOSMICKRISP Timestamp queries */
+         p->queueFamilyProperties.minImageTransferGranularity =
+            (VkExtent3D){1, 1, 1};
+      }
+   }
+}
+
+static const VkTimeDomainKHR kk_time_domains[] = {
+   VK_TIME_DOMAIN_DEVICE_KHR,
+   VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR,
+#ifdef CLOCK_MONOTONIC_RAW
+   VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR,
+#endif
+};
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_GetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice,
+                                                uint32_t *pTimeDomainCount,
+                                                VkTimeDomainKHR *pTimeDomains)
+{
+   VK_OUTARRAY_MAKE_TYPED(VkTimeDomainKHR, out, pTimeDomains, pTimeDomainCount);
+
+   for (int d = 0; d < ARRAY_SIZE(kk_time_domains); d++) {
+      vk_outarray_append_typed(VkTimeDomainKHR, &out, i)
+      {
+         *i = kk_time_domains[d];
+      }
+   }
+
+   return vk_outarray_status(&out);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_GetPhysicalDeviceMultisamplePropertiesEXT(
+   VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples,
+   VkMultisamplePropertiesEXT *pMultisampleProperties)
+{
+   VK_FROM_HANDLE(kk_physical_device, pdev, physicalDevice);
+
+   if (samples & pdev->vk.properties.sampleLocationSampleCounts) {
+      pMultisampleProperties->maxSampleLocationGridSize = (VkExtent2D){1, 1};
+   } else {
+      pMultisampleProperties->maxSampleLocationGridSize = (VkExtent2D){0, 0};
+   }
+}
diff --git a/src/kosmickrisp/vulkan/kk_physical_device.h b/src/kosmickrisp/vulkan/kk_physical_device.h
new file mode 100644
index 00000000000..9daf6dfbdcc
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_physical_device.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_PHYSICAL_DEVICE_H
+#define KK_PHYSICAL_DEVICE_H 1
+
+#include "kk_private.h"
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "vk_physical_device.h"
+#include "vk_sync.h"
+#include "vk_sync_binary.h"
+
+#include "wsi_common.h"
+
+#include <sys/types.h>
+
+struct kk_instance;
+struct kk_physical_device;
+
+struct kk_queue_family {
+   VkQueueFlags queue_flags;
+   uint32_t queue_count;
+};
+
+struct kk_memory_heap {
+   uint64_t size;
+   uint64_t used;
+   VkMemoryHeapFlags flags;
+   uint64_t (*available)(struct kk_physical_device *pdev);
+};
+
+struct kk_device_info {
+   uint32_t max_workgroup_count[3];
+   uint32_t max_workgroup_invocations;
+};
+
+struct kk_physical_device {
+   struct vk_physical_device vk;
+   mtl_device *mtl_dev_handle;
+   struct kk_device_info info;
+
+   struct wsi_device wsi_device;
+
+   uint8_t device_uuid[VK_UUID_SIZE];
+
+   // TODO: add mapable VRAM heap if possible
+   struct kk_memory_heap mem_heaps[3];
+   VkMemoryType mem_types[3];
+   uint8_t mem_heap_count;
+   uint8_t mem_type_count;
+
+   // Emulated binary sync type
+   struct vk_sync_binary_type sync_binary_type;
+   const struct vk_sync_type *sync_types[3];
+
+   struct kk_queue_family queue_families[3];
+   uint8_t queue_family_count;
+};
+
+static inline uint32_t
+kk_min_cbuf_alignment()
+{
+   /* Size of vec4 */
+   return 16;
+}
+
+VK_DEFINE_HANDLE_CASTS(kk_physical_device, vk.base, VkPhysicalDevice,
+                       VK_OBJECT_TYPE_PHYSICAL_DEVICE)
+
+static inline struct kk_instance *
+kk_physical_device_instance(struct kk_physical_device *pdev)
+{
+   return (struct kk_instance *)pdev->vk.instance;
+}
+
+VkResult kk_enumerate_physical_devices(struct vk_instance *_instance);
+void kk_physical_device_destroy(struct vk_physical_device *vk_device);
+
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR) ||                                    \
+   defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR) ||    \
+   defined(VK_USE_PLATFORM_DISPLAY_KHR) || defined(VK_USE_PLATFORM_METAL_EXT)
+#define KK_USE_WSI_PLATFORM
+#endif
+
+#endif // KK_PHYSICAL_DEVICE_H
diff --git a/src/kosmickrisp/vulkan/kk_private.h b/src/kosmickrisp/vulkan/kk_private.h
new file mode 100644
index 00000000000..d50481f6f8a
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_private.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright © 2024 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_PRIVATE_H
+#define KK_PRIVATE_H 1
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "vk_log.h"
+#include "vk_util.h"
+
+#include <assert.h>
+
+#define KK_MAX_SETS                   32
+#define KK_MAX_PUSH_SIZE              128
+#define KK_MAX_DYNAMIC_BUFFERS        64
+#define KK_MAX_RTS                    8
+#define KK_MAX_SAMPLES                8
+#define KK_MIN_SSBO_ALIGNMENT         16
+#define KK_MIN_TEXEL_BUFFER_ALIGNMENT 16
+#define KK_MIN_UBO_ALIGNMENT          64
+#define KK_MAX_VIEWPORTS              16
+#define KK_MAX_DESCRIPTOR_SIZE        64
+#define KK_MAX_PUSH_DESCRIPTORS       32
+#define KK_MAX_DESCRIPTOR_SET_SIZE    (1u << 30)
+#define KK_MAX_DESCRIPTORS            (1 << 20)
+#define KK_PUSH_DESCRIPTOR_SET_SIZE                                            \
+   (KK_MAX_PUSH_DESCRIPTORS * KK_MAX_DESCRIPTOR_SIZE)
+#define KK_SSBO_BOUNDS_CHECK_ALIGNMENT 4
+#define KK_MAX_MULTIVIEW_VIEW_COUNT    32
+#define KK_TEXTURE_BUFFER_WIDTH        (1u << 14)
+#define KK_MAX_OCCLUSION_QUERIES       (32768)
+
+#define KK_SPARSE_ADDR_SPACE_SIZE (1ull << 39)
+#define KK_MAX_BUFFER_SIZE        (1ull << 31)
+#define KK_MAX_SHARED_SIZE        (32 * 1024)
+
+/* Max size of a bound cbuf */
+#define KK_MAX_CBUF_SIZE (1u << 16)
+
+/* Metal related macros */
+#define KK_MTL_RESOURCE_OPTIONS                                                \
+   MTL_RESOURCE_STORAGE_MODE_SHARED |                                          \
+      MTL_RESOURCE_CPU_CACHE_MODE_DEFAULT_CACHE |                              \
+      MTL_RESOURCE_TRACKING_MODE_UNTRACKED
+
+#define KK_MAX_CMD_BUFFERS 256
+
+struct kk_addr_range {
+   uint64_t addr;
+   uint64_t range;
+};
+
+typedef enum kk_env_option_t {
+   KK_ENABLE_GPU_CAPTURE = 0,
+   KK_MAX_ENV_OPTIONS,
+} kk_env_option_t;
+
+struct kk_env_option {
+   const char *name;
+   bool value;
+};
+
+static struct kk_env_option KK_ENV_OPTIONS[KK_MAX_ENV_OPTIONS] = {
+   [KK_ENABLE_GPU_CAPTURE] =
+      {
+         .name = "MESA_KOSMICKRISP_ENABLE_GPU_CAPTURE",
+         .value = false,
+      },
+};
+
+static inline bool
+kk_get_environment_boolean(kk_env_option_t option)
+{
+   assert(option >= 0 && option < KK_MAX_ENV_OPTIONS);
+   struct kk_env_option *opt = &KK_ENV_OPTIONS[option];
+   const char *env_str = getenv(opt->name);
+   if (env_str) {
+      if (strncmp(env_str, "0", 1) != 0) {
+         opt->value = true;
+      } else {
+         opt->value = false;
+      }
+   }
+   return opt->value;
+}
+
+#define kk_debug_ignored_stype(sType)                                          \
+   mesa_logd("%s: ignored VkStructureType %u\n", __func__, (sType))
+
+#endif
diff --git a/src/kosmickrisp/vulkan/kk_query_pool.c b/src/kosmickrisp/vulkan/kk_query_pool.c
new file mode 100644
index 00000000000..c6653ba9d13
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_query_pool.c
@@ -0,0 +1,431 @@
+/*
+ * Copyright 2024 Valve Corporation
+ * Copyright 2024 Alyssa Rosenzweig
+ * Copyright 2022-2023 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_query_pool.h"
+
+#include "kk_bo.h"
+#include "kk_buffer.h"
+#include "kk_cmd_buffer.h"
+#include "kk_device.h"
+#include "kk_encoder.h"
+#include "kk_entrypoints.h"
+#include "kk_physical_device.h"
+#include "kk_query_table.h"
+#include "kkcl.h"
+
+struct kk_query_report {
+   uint64_t value;
+};
+
+static inline bool
+kk_has_available(const struct kk_query_pool *pool)
+{
+   return pool->vk.query_type != VK_QUERY_TYPE_TIMESTAMP;
+}
+
+uint16_t *
+kk_pool_oq_index_ptr(const struct kk_query_pool *pool)
+{
+   return (uint16_t *)((uint8_t *)pool->bo->cpu + pool->query_start);
+}
+
+static uint32_t
+kk_reports_per_query(struct kk_query_pool *pool)
+{
+   switch (pool->vk.query_type) {
+   case VK_QUERY_TYPE_OCCLUSION:
+   case VK_QUERY_TYPE_TIMESTAMP:
+   case VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT:
+      return 1;
+   case VK_QUERY_TYPE_PIPELINE_STATISTICS:
+      return util_bitcount(pool->vk.pipeline_statistics);
+   case VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT:
+      // Primitives succeeded and primitives needed
+      return 2;
+   default:
+      UNREACHABLE("Unsupported query type");
+   }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
+                   const VkAllocationCallbacks *pAllocator,
+                   VkQueryPool *pQueryPool)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   struct kk_query_pool *pool;
+   VkResult result = VK_SUCCESS;
+
+   pool =
+      vk_query_pool_create(&dev->vk, pCreateInfo, pAllocator, sizeof(*pool));
+   if (!pool)
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   bool occlusion = pCreateInfo->queryType == VK_QUERY_TYPE_OCCLUSION;
+   unsigned occlusion_queries = occlusion ? pCreateInfo->queryCount : 0;
+
+   /* We place the availability first and then data */
+   pool->query_start = 0;
+   if (kk_has_available(pool)) {
+      pool->query_start = align(pool->vk.query_count * sizeof(uint64_t),
+                                sizeof(struct kk_query_report));
+   }
+
+   uint32_t reports_per_query = kk_reports_per_query(pool);
+   pool->query_stride = reports_per_query * sizeof(struct kk_query_report);
+
+   if (pool->vk.query_count > 0) {
+      uint32_t bo_size = pool->query_start;
+
+      /* For occlusion queries, we stick the query index remapping here */
+      if (occlusion_queries)
+         bo_size += sizeof(uint16_t) * pool->vk.query_count;
+      else
+         bo_size += pool->query_stride * pool->vk.query_count;
+
+      result = kk_alloc_bo(dev, &dev->vk.base, bo_size, 8, &pool->bo);
+      if (result != VK_SUCCESS) {
+         kk_DestroyQueryPool(device, kk_query_pool_to_handle(pool), pAllocator);
+         return vk_error(dev, VK_ERROR_OUT_OF_DEVICE_MEMORY);
+      }
+
+      /* TODO_KOSMICKRISP Timestamps */
+   }
+
+   uint16_t *oq_index = kk_pool_oq_index_ptr(pool);
+
+   for (unsigned i = 0; i < occlusion_queries; ++i) {
+      uint64_t zero = 0;
+      unsigned index;
+
+      VkResult result =
+         kk_query_table_add(dev, &dev->occlusion_queries, zero, &index);
+
+      if (result != VK_SUCCESS) {
+         kk_DestroyQueryPool(device, kk_query_pool_to_handle(pool), pAllocator);
+         return vk_error(dev, VK_ERROR_OUT_OF_DEVICE_MEMORY);
+      }
+
+      /* We increment as we go so we can clean up properly if we run out */
+      assert(pool->oq_queries < occlusion_queries);
+      oq_index[pool->oq_queries++] = index;
+   }
+
+   *pQueryPool = kk_query_pool_to_handle(pool);
+
+   return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_DestroyQueryPool(VkDevice device, VkQueryPool queryPool,
+                    const VkAllocationCallbacks *pAllocator)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_query_pool, pool, queryPool);
+
+   if (!pool)
+      return;
+
+   uint16_t *oq_index = kk_pool_oq_index_ptr(pool);
+
+   for (unsigned i = 0; i < pool->oq_queries; ++i) {
+      kk_query_table_remove(dev, &dev->occlusion_queries, oq_index[i]);
+   }
+
+   kk_destroy_bo(dev, pool->bo);
+
+   vk_query_pool_destroy(&dev->vk, pAllocator, &pool->vk);
+}
+
+static uint64_t *
+kk_query_available_map(struct kk_query_pool *pool, uint32_t query)
+{
+   assert(kk_has_available(pool));
+   assert(query < pool->vk.query_count);
+   return (uint64_t *)pool->bo->cpu + query;
+}
+
+static uint64_t
+kk_query_offset(struct kk_query_pool *pool, uint32_t query)
+{
+   assert(query < pool->vk.query_count);
+   return pool->query_start + query * pool->query_stride;
+}
+
+static uint64_t
+kk_query_report_addr(struct kk_device *dev, struct kk_query_pool *pool,
+                     uint32_t query)
+{
+   if (pool->oq_queries) {
+      uint16_t *oq_index = kk_pool_oq_index_ptr(pool);
+      return dev->occlusion_queries.bo->gpu +
+             (oq_index[query] * sizeof(uint64_t));
+   } else {
+      return pool->bo->gpu + kk_query_offset(pool, query);
+   }
+}
+
+static uint64_t
+kk_query_available_addr(struct kk_query_pool *pool, uint32_t query)
+{
+   assert(kk_has_available(pool));
+   assert(query < pool->vk.query_count);
+   return pool->bo->gpu + query * sizeof(uint64_t);
+}
+
+static struct kk_query_report *
+kk_query_report_map(struct kk_device *dev, struct kk_query_pool *pool,
+                    uint32_t query)
+{
+   if (pool->oq_queries) {
+      uint64_t *queries = (uint64_t *)(dev->occlusion_queries.bo->cpu);
+      uint16_t *oq_index = kk_pool_oq_index_ptr(pool);
+
+      return (struct kk_query_report *)&queries[oq_index[query]];
+   } else {
+      return (void *)((char *)pool->bo->cpu + kk_query_offset(pool, query));
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_ResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+                  uint32_t queryCount)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_query_pool, pool, queryPool);
+   for (uint32_t i = 0; i < queryCount; i++) {
+      struct kk_query_report *reports =
+         kk_query_report_map(dev, pool, firstQuery + i);
+
+      uint64_t value = 0;
+      if (kk_has_available(pool)) {
+         uint64_t *available = kk_query_available_map(pool, firstQuery + i);
+         *available = 0u;
+      } else {
+         value = UINT64_MAX;
+      }
+
+      for (unsigned j = 0; j < kk_reports_per_query(pool); ++j) {
+         reports[j].value = value;
+      }
+   }
+}
+
+/**
+ * Goes through a series of consecutive query indices in the given pool,
+ * setting all element values to 0 and emitting them as available.
+ */
+static void
+emit_zero_queries(struct kk_cmd_buffer *cmd, struct kk_query_pool *pool,
+                  uint32_t first_index, uint32_t num_queries,
+                  bool set_available)
+{
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+   mtl_buffer *buffer = pool->bo->map;
+
+   for (uint32_t i = 0; i < num_queries; i++) {
+      uint64_t report = kk_query_report_addr(dev, pool, first_index + i);
+
+      uint64_t value = 0;
+      if (kk_has_available(pool)) {
+         uint64_t available = kk_query_available_addr(pool, first_index + i);
+         kk_cmd_write(cmd, buffer, available, set_available);
+      } else {
+         value = set_available ? 0u : UINT64_MAX;
+      }
+
+      /* XXX: is this supposed to happen on the begin? */
+      for (unsigned j = 0; j < kk_reports_per_query(pool); ++j) {
+         kk_cmd_write(cmd, buffer,
+                      report + (j * sizeof(struct kk_query_report)), value);
+      }
+   }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                     uint32_t firstQuery, uint32_t queryCount)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_query_pool, pool, queryPool);
+   emit_zero_queries(cmd, pool, firstQuery, queryCount, false);
+   /* If we are not mid encoder, just upload the writes */
+   if (cmd->encoder->main.last_used == KK_ENC_NONE)
+      upload_queue_writes(cmd);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdWriteTimestamp2(VkCommandBuffer commandBuffer,
+                      VkPipelineStageFlags2 stage, VkQueryPool queryPool,
+                      uint32_t query)
+{
+   /* TODO_KOSMICKRISP */
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                 uint32_t query, VkQueryControlFlags flags)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_query_pool, pool, queryPool);
+   cmd->state.gfx.occlusion.mode = flags & VK_QUERY_CONTROL_PRECISE_BIT
+                                      ? MTL_VISIBILITY_RESULT_MODE_COUNTING
+                                      : MTL_VISIBILITY_RESULT_MODE_BOOLEAN;
+   cmd->state.gfx.dirty |= KK_DIRTY_OCCLUSION;
+   uint16_t *oq_index = kk_pool_oq_index_ptr(pool);
+   cmd->state.gfx.occlusion.index = oq_index[query];
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+               uint32_t query)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_query_pool, pool, queryPool);
+   cmd->state.gfx.occlusion.mode = MTL_VISIBILITY_RESULT_MODE_DISABLED;
+   cmd->state.gfx.dirty |= KK_DIRTY_OCCLUSION;
+
+   /* Make the query available */
+   uint64_t addr = kk_query_available_addr(pool, query);
+   kk_cmd_write(cmd, pool->bo->map, addr, true);
+}
+
+static bool
+kk_query_is_available(struct kk_device *dev, struct kk_query_pool *pool,
+                      uint32_t query)
+{
+   if (kk_has_available(pool)) {
+      uint64_t *available = kk_query_available_map(pool, query);
+      return p_atomic_read(available) != 0;
+   } else {
+      const struct kk_query_report *report =
+         kk_query_report_map(dev, pool, query);
+
+      return report->value != UINT64_MAX;
+   }
+}
+
+#define KK_QUERY_TIMEOUT 2000000000ull
+
+static VkResult
+kk_query_wait_for_available(struct kk_device *dev, struct kk_query_pool *pool,
+                            uint32_t query)
+{
+   uint64_t abs_timeout_ns = os_time_get_absolute_timeout(KK_QUERY_TIMEOUT);
+
+   while (os_time_get_nano() < abs_timeout_ns) {
+      if (kk_query_is_available(dev, pool, query))
+         return VK_SUCCESS;
+
+      VkResult status = vk_device_check_status(&dev->vk);
+      if (status != VK_SUCCESS)
+         return status;
+   }
+
+   return vk_device_set_lost(&dev->vk, "query timeout");
+}
+
+static void
+cpu_write_query_result(void *dst, uint32_t idx, VkQueryResultFlags flags,
+                       uint64_t result)
+{
+   if (flags & VK_QUERY_RESULT_64_BIT) {
+      uint64_t *dst64 = dst;
+      dst64[idx] = result;
+   } else {
+      uint32_t *dst32 = dst;
+      dst32[idx] = result;
+   }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_GetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
+                       uint32_t firstQuery, uint32_t queryCount,
+                       size_t dataSize, void *pData, VkDeviceSize stride,
+                       VkQueryResultFlags flags)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_query_pool, pool, queryPool);
+
+   if (vk_device_is_lost(&dev->vk))
+      return VK_ERROR_DEVICE_LOST;
+
+   VkResult status = VK_SUCCESS;
+   for (uint32_t i = 0; i < queryCount; i++) {
+      const uint32_t query = firstQuery + i;
+
+      bool available = kk_query_is_available(dev, pool, query);
+
+      if (!available && (flags & VK_QUERY_RESULT_WAIT_BIT)) {
+         status = kk_query_wait_for_available(dev, pool, query);
+         if (status != VK_SUCCESS)
+            return status;
+
+         available = true;
+      }
+
+      bool write_results = available || (flags & VK_QUERY_RESULT_PARTIAL_BIT);
+
+      const struct kk_query_report *src = kk_query_report_map(dev, pool, query);
+      assert(i * stride < dataSize);
+      void *dst = (char *)pData + i * stride;
+
+      uint32_t reports = kk_reports_per_query(pool);
+      if (write_results) {
+         for (uint32_t j = 0; j < reports; j++) {
+            cpu_write_query_result(dst, j, flags, src[j].value);
+         }
+      }
+
+      if (!write_results)
+         status = VK_NOT_READY;
+
+      if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)
+         cpu_write_query_result(dst, reports, flags, available);
+   }
+
+   return status;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                           uint32_t firstQuery, uint32_t queryCount,
+                           VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                           VkDeviceSize stride, VkQueryResultFlags flags)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, commandBuffer);
+   VK_FROM_HANDLE(kk_query_pool, pool, queryPool);
+   VK_FROM_HANDLE(kk_buffer, dst_buf, dstBuffer);
+   struct kk_device *dev = kk_cmd_buffer_device(cmd);
+
+   struct kk_copy_query_pool_results_info info = {
+      .availability = kk_has_available(pool) ? pool->bo->gpu : 0,
+      .results = pool->oq_queries ? dev->occlusion_queries.bo->gpu
+                                  : pool->bo->gpu + pool->query_start,
+      .indices = pool->oq_queries ? pool->bo->gpu + pool->query_start : 0,
+      .dst_addr = dst_buf->vk.device_address + dstOffset,
+      .dst_stride = stride,
+      .first_query = firstQuery,
+      .flags = flags,
+      .reports_per_query = kk_reports_per_query(pool),
+      .query_count = queryCount,
+   };
+
+   util_dynarray_append(&cmd->encoder->copy_query_pool_result_infos,
+                        struct kk_copy_query_pool_results_info, info);
+   util_dynarray_append(&cmd->encoder->resident_buffers, mtl_buffer *,
+                        dst_buf->mtl_handle);
+   util_dynarray_append(&cmd->encoder->resident_buffers, mtl_buffer *,
+                        pool->bo->map);
+   util_dynarray_append(&cmd->encoder->resident_buffers, mtl_buffer *,
+                        dev->occlusion_queries.bo->map);
+   /* If we are not mid encoder, just upload the writes */
+   if (cmd->encoder->main.last_used == KK_ENC_NONE)
+      upload_queue_writes(cmd);
+}
diff --git a/src/kosmickrisp/vulkan/kk_query_pool.h b/src/kosmickrisp/vulkan/kk_query_pool.h
new file mode 100644
index 00000000000..509a564dcfa
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_query_pool.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_QUERY_POOL_H
+#define KK_QUERY_POOL_H 1
+
+#include "kk_private.h"
+
+#include "vulkan/runtime/vk_query_pool.h"
+
+struct kk_query_pool {
+   struct vk_query_pool vk;
+
+   struct kk_bo *bo;
+
+   uint32_t query_start;
+   uint32_t query_stride;
+
+   unsigned oq_queries;
+};
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_query_pool, vk.base, VkQueryPool,
+                               VK_OBJECT_TYPE_QUERY_POOL)
+
+uint16_t *kk_pool_oq_index_ptr(const struct kk_query_pool *pool);
+
+#endif /* KK_QUERY_POOL_H */
diff --git a/src/kosmickrisp/vulkan/kk_query_table.c b/src/kosmickrisp/vulkan/kk_query_table.c
new file mode 100644
index 00000000000..1ab205de0c2
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_query_table.c
@@ -0,0 +1,241 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_query_table.h"
+
+#include "kk_device.h"
+#include "kk_physical_device.h"
+
+static uint32_t query_size = sizeof(uint64_t);
+
+static VkResult
+kk_query_table_grow_locked(struct kk_device *dev, struct kk_query_table *table,
+                           uint32_t new_alloc)
+{
+   struct kk_bo *bo;
+   BITSET_WORD *new_in_use;
+   uint32_t *new_free_table;
+   VkResult result;
+
+   assert(new_alloc <= table->max_alloc);
+
+   const uint32_t new_mem_size = new_alloc * query_size;
+   result = kk_alloc_bo(dev, &dev->vk.base, new_mem_size, 256, &bo);
+   if (result != VK_SUCCESS)
+      return result;
+
+   /* We don't allow resize */
+   assert(table->bo == NULL);
+   table->bo = bo;
+
+   assert((new_alloc % BITSET_WORDBITS) == 0);
+   const size_t new_in_use_size = BITSET_WORDS(new_alloc) * sizeof(BITSET_WORD);
+   new_in_use =
+      vk_realloc(&dev->vk.alloc, table->in_use, new_in_use_size,
+                 sizeof(BITSET_WORD), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+   if (new_in_use == NULL) {
+      return vk_errorf(dev, VK_ERROR_OUT_OF_HOST_MEMORY,
+                       "Failed to allocate query in-use set");
+   }
+   memset((char *)new_in_use, 0, new_in_use_size);
+   table->in_use = new_in_use;
+
+   const size_t new_free_table_size = new_alloc * sizeof(uint32_t);
+   new_free_table =
+      vk_realloc(&dev->vk.alloc, table->free_table, new_free_table_size, 4,
+                 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+   if (new_free_table == NULL) {
+      return vk_errorf(dev, VK_ERROR_OUT_OF_HOST_MEMORY,
+                       "Failed to allocate query free table");
+   }
+   table->free_table = new_free_table;
+
+   return VK_SUCCESS;
+}
+
+VkResult
+kk_query_table_init(struct kk_device *dev, struct kk_query_table *table,
+                    uint32_t query_count)
+{
+   memset(table, 0, sizeof(*table));
+   VkResult result;
+
+   simple_mtx_init(&table->mutex, mtx_plain);
+
+   assert(util_is_power_of_two_nonzero(query_count));
+
+   table->max_alloc = query_count;
+   table->next_query = 0;
+   table->free_count = 0;
+
+   result = kk_query_table_grow_locked(dev, table, query_count);
+   if (result != VK_SUCCESS) {
+      kk_query_table_finish(dev, table);
+      return result;
+   }
+
+   return VK_SUCCESS;
+}
+
+void
+kk_query_table_finish(struct kk_device *dev, struct kk_query_table *table)
+{
+   if (table->bo != NULL)
+      kk_destroy_bo(dev, table->bo);
+   vk_free(&dev->vk.alloc, table->in_use);
+   vk_free(&dev->vk.alloc, table->free_table);
+   simple_mtx_destroy(&table->mutex);
+}
+
+static VkResult
+kk_query_table_alloc_locked(struct kk_device *dev, struct kk_query_table *table,
+                            uint32_t *index_out)
+{
+   while (1) {
+      uint32_t index;
+      if (table->free_count > 0) {
+         index = table->free_table[--table->free_count];
+      } else if (table->next_query < table->max_alloc) {
+         index = table->next_query++;
+      } else {
+         return vk_errorf(dev, VK_ERROR_OUT_OF_HOST_MEMORY,
+                          "Query table not large enough");
+      }
+
+      if (!BITSET_TEST(table->in_use, index)) {
+         BITSET_SET(table->in_use, index);
+         *index_out = index;
+         return VK_SUCCESS;
+      }
+   }
+}
+
+static VkResult
+kk_query_table_take_locked(struct kk_device *dev, struct kk_query_table *table,
+                           uint32_t index)
+{
+   if (index >= table->max_alloc) {
+      return vk_errorf(dev, VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
+                       "Query %u does not exist", index);
+   }
+
+   if (BITSET_TEST(table->in_use, index)) {
+      return vk_errorf(dev, VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
+                       "Query %u is already in use", index);
+   } else {
+      BITSET_SET(table->in_use, index);
+      return VK_SUCCESS;
+   }
+}
+
+static VkResult
+kk_query_table_add_locked(struct kk_device *dev, struct kk_query_table *table,
+                          uint64_t value, uint32_t *index_out)
+{
+   VkResult result = kk_query_table_alloc_locked(dev, table, index_out);
+   if (result != VK_SUCCESS)
+      return result;
+
+   uint64_t *map = (uint64_t *)table->bo->cpu + *index_out;
+   *map = value;
+
+   return VK_SUCCESS;
+}
+
+VkResult
+kk_query_table_add(struct kk_device *dev, struct kk_query_table *table,
+                   uint64_t value, uint32_t *index_out)
+{
+   simple_mtx_lock(&table->mutex);
+   VkResult result = kk_query_table_add_locked(dev, table, value, index_out);
+   simple_mtx_unlock(&table->mutex);
+
+   return result;
+}
+
+static VkResult
+kk_query_table_insert_locked(struct kk_device *dev,
+                             struct kk_query_table *table, uint32_t index,
+                             uint64_t value)
+{
+   VkResult result = kk_query_table_take_locked(dev, table, index);
+   if (result != VK_SUCCESS)
+      return result;
+
+   uint64_t *map = (uint64_t *)table->bo->cpu + index;
+   *map = value;
+
+   return result;
+}
+
+VkResult
+kk_query_table_insert(struct kk_device *dev, struct kk_query_table *table,
+                      uint32_t index, uint64_t value)
+{
+   simple_mtx_lock(&table->mutex);
+   VkResult result = kk_query_table_insert_locked(dev, table, index, value);
+   simple_mtx_unlock(&table->mutex);
+
+   return result;
+}
+
+static int
+compar_u32(const void *_a, const void *_b)
+{
+   const uint32_t *a = _a, *b = _b;
+   return *a - *b;
+}
+
+static void
+kk_query_table_compact_free_table(struct kk_query_table *table)
+{
+   if (table->free_count <= 1)
+      return;
+
+   qsort(table->free_table, table->free_count, sizeof(*table->free_table),
+         compar_u32);
+
+   uint32_t j = 1;
+   for (uint32_t i = 1; i < table->free_count; i++) {
+      if (table->free_table[i] == table->free_table[j - 1])
+         continue;
+
+      assert(table->free_table[i] > table->free_table[j - 1]);
+      table->free_table[j++] = table->free_table[i];
+   }
+
+   table->free_count = j;
+}
+
+void
+kk_query_table_remove(struct kk_device *dev, struct kk_query_table *table,
+                      uint32_t index)
+{
+   simple_mtx_lock(&table->mutex);
+
+   uint64_t *map = (uint64_t *)table->bo->cpu + index;
+   *map = 0u;
+
+   assert(BITSET_TEST(table->in_use, index));
+
+   /* There may be duplicate entries in the free table.  For most operations,
+    * this is fine as we always consult kk_query_table::in_use when
+    * allocating.  However, it does mean that there's nothing preventing our
+    * free table from growing larger than the memory we allocated for it.  In
+    * the unlikely event that we end up with more entries than we can fit in
+    * the allocated space, compact the table to ensure that the new entry
+    * we're about to add fits.
+    */
+   if (table->free_count >= table->max_alloc)
+      kk_query_table_compact_free_table(table);
+   assert(table->free_count < table->max_alloc);
+
+   BITSET_CLEAR(table->in_use, index);
+   table->free_table[table->free_count++] = index;
+
+   simple_mtx_unlock(&table->mutex);
+}
diff --git a/src/kosmickrisp/vulkan/kk_query_table.h b/src/kosmickrisp/vulkan/kk_query_table.h
new file mode 100644
index 00000000000..a7d0be2cb5a
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_query_table.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_QUERY_TABLE_H
+#define KK_QUERY_TABLE_H 1
+
+#include "kk_private.h"
+
+#include "kk_bo.h"
+
+#include "util/bitset.h"
+#include "util/simple_mtx.h"
+
+struct kk_device;
+
+struct kk_query_table {
+   simple_mtx_t mutex;
+
+   uint32_t max_alloc;  /**< Maximum possible number of queries */
+   uint32_t next_query; /**< Next unallocated query */
+   uint32_t free_count; /**< Size of free_table */
+
+   struct kk_bo *bo; /**< Memoery where queries are stored */
+
+   /* Bitset of all queries currently in use.  This is the single source
+    * of truth for what is and isn't free.  The free_table and next_query are
+    * simply hints to make finding a free descrptor fast.  Every free
+    * query will either be above next_query or in free_table but not
+    * everything which satisfies those two criteria is actually free.
+    */
+   BITSET_WORD *in_use;
+
+   /* Stack for free query elements */
+   uint32_t *free_table;
+};
+
+VkResult kk_query_table_init(struct kk_device *dev,
+                             struct kk_query_table *table,
+                             uint32_t query_count);
+
+void kk_query_table_finish(struct kk_device *dev, struct kk_query_table *table);
+
+VkResult kk_query_table_add(struct kk_device *dev, struct kk_query_table *table,
+                            uint64_t value, uint32_t *index_out);
+
+VkResult kk_query_table_insert(struct kk_device *dev,
+                               struct kk_query_table *table, uint32_t index,
+                               uint64_t value);
+
+void kk_query_table_remove(struct kk_device *dev, struct kk_query_table *table,
+                           uint32_t index);
+
+#endif /* KK_QUERY_TABLE_H */
diff --git a/src/kosmickrisp/vulkan/kk_queue.c b/src/kosmickrisp/vulkan/kk_queue.c
new file mode 100644
index 00000000000..3d112c21cae
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_queue.c
@@ -0,0 +1,114 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_queue.h"
+#include "kk_buffer.h"
+#include "kk_cmd_buffer.h"
+#include "kk_device.h"
+#include "kk_encoder.h"
+#include "kk_physical_device.h"
+#include "kk_sync.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+#include "vk_cmd_queue.h"
+
+static VkResult
+kk_queue_submit(struct vk_queue *vk_queue, struct vk_queue_submit *submit)
+{
+   struct kk_queue *queue = container_of(vk_queue, struct kk_queue, vk);
+   struct kk_device *dev = kk_queue_device(queue);
+
+   if (vk_queue_is_lost(&queue->vk))
+      return VK_ERROR_DEVICE_LOST;
+
+   struct kk_encoder *encoder;
+   VkResult result = kk_encoder_init(dev->mtl_handle, queue, &encoder);
+   if (result != VK_SUCCESS)
+      return result;
+
+   /* Chain with previous sumbission */
+   if (queue->wait_fence) {
+      util_dynarray_append(&encoder->main.fences, mtl_fence *,
+                           queue->wait_fence);
+      encoder->main.wait_fence = true;
+   }
+
+   for (struct vk_sync_wait *wait = submit->waits,
+                            *end = submit->waits + submit->wait_count;
+        wait != end; ++wait) {
+      struct kk_sync_timeline *sync =
+         container_of(wait->sync, struct kk_sync_timeline, base);
+      mtl_encode_wait_for_event(encoder->main.cmd_buffer, sync->mtl_handle,
+                                wait->wait_value);
+   }
+
+   for (uint32_t i = 0; i < submit->command_buffer_count; ++i) {
+      struct kk_cmd_buffer *cmd_buffer =
+         container_of(submit->command_buffers[i], struct kk_cmd_buffer, vk);
+      cmd_buffer->encoder = encoder;
+      /* TODO_KOSMICKRISP We need to release command buffer resources here for
+       * the following case: User records command buffers once and then reuses
+       * them multiple times. The resource release should be done at
+       * vkBeginCommandBuffer, but because we are recording all commands to
+       * later execute them at queue submission, the recording does not record
+       * the begin/end commands and jumps straight to the actual commands. */
+      kk_cmd_release_resources(dev, cmd_buffer);
+
+      vk_cmd_queue_execute(&cmd_buffer->vk.cmd_queue,
+                           kk_cmd_buffer_to_handle(cmd_buffer),
+                           &dev->vk.dispatch_table);
+      kk_encoder_end(cmd_buffer);
+      cmd_buffer->encoder = NULL;
+   }
+
+   for (uint32_t i = 0u; i < submit->signal_count; ++i) {
+      struct vk_sync_signal *signal = &submit->signals[i];
+      struct kk_sync_timeline *sync =
+         container_of(signal->sync, struct kk_sync_timeline, base);
+      mtl_encode_signal_event(encoder->main.cmd_buffer, sync->mtl_handle,
+                              signal->signal_value);
+   }
+
+   /* Steal the last fence to chain with the next submission */
+   if (util_dynarray_num_elements(&encoder->main.fences, mtl_fence *) > 0)
+      queue->wait_fence = util_dynarray_pop(&encoder->main.fences, mtl_fence *);
+   kk_encoder_submit(encoder);
+
+   return VK_SUCCESS;
+}
+
+VkResult
+kk_queue_init(struct kk_device *dev, struct kk_queue *queue,
+              const VkDeviceQueueCreateInfo *pCreateInfo,
+              uint32_t index_in_family)
+{
+   VkResult result;
+
+   result = vk_queue_init(&queue->vk, &dev->vk, pCreateInfo, index_in_family);
+   if (result != VK_SUCCESS)
+      return result;
+
+   queue->main.mtl_handle =
+      mtl_new_command_queue(dev->mtl_handle, KK_MAX_CMD_BUFFERS);
+   queue->pre_gfx.mtl_handle =
+      mtl_new_command_queue(dev->mtl_handle, KK_MAX_CMD_BUFFERS);
+
+   queue->vk.driver_submit = kk_queue_submit;
+
+   return VK_SUCCESS;
+}
+
+void
+kk_queue_finish(struct kk_device *dev, struct kk_queue *queue)
+{
+   if (queue->wait_fence)
+      mtl_release(queue->wait_fence);
+   mtl_release(queue->pre_gfx.mtl_handle);
+   mtl_release(queue->main.mtl_handle);
+   vk_queue_finish(&queue->vk);
+}
diff --git a/src/kosmickrisp/vulkan/kk_queue.h b/src/kosmickrisp/vulkan/kk_queue.h
new file mode 100644
index 00000000000..0633559d867
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_queue.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_QUEUE_H
+#define KK_QUEUE_H 1
+
+#include "kk_private.h"
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "vk_queue.h"
+
+struct kk_queue {
+   struct vk_queue vk;
+   /* We require one queue per command buffer no to lock. Main will handle all
+    * work, but if we are in a render pass and we require to massage inputs,
+    * then pre_gfx will be used to submit compute work that handles that so we
+    * don't have to break the render encoder. */
+   struct {
+      struct mtl_command_queue *mtl_handle;
+   } main, pre_gfx;
+
+   mtl_fence *wait_fence;
+};
+
+static inline struct kk_device *
+kk_queue_device(struct kk_queue *queue)
+{
+   return (struct kk_device *)queue->vk.base.device;
+}
+
+VkResult kk_queue_init(struct kk_device *dev, struct kk_queue *queue,
+                       const VkDeviceQueueCreateInfo *pCreateInfo,
+                       uint32_t index_in_family);
+
+void kk_queue_finish(struct kk_device *dev, struct kk_queue *queue);
+
+#endif
diff --git a/src/kosmickrisp/vulkan/kk_sampler.c b/src/kosmickrisp/vulkan/kk_sampler.c
new file mode 100644
index 00000000000..a555cc185c6
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_sampler.c
@@ -0,0 +1,217 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_sampler.h"
+
+#include "kk_entrypoints.h"
+#include "kk_physical_device.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+#include "kosmickrisp/bridge/vk_to_mtl_map.h"
+
+#include "vk_format.h"
+#include "vk_sampler.h"
+
+#include "util/bitpack_helpers.h"
+#include "util/format/format_utils.h"
+#include "util/format_srgb.h"
+
+static bool
+uses_border(const VkSamplerCreateInfo *info)
+{
+   return info->addressModeU == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER ||
+          info->addressModeV == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER ||
+          info->addressModeW == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
+}
+
+static bool
+is_border_color_custom(VkBorderColor color, bool workaround_rgba4)
+{
+   switch (color) {
+   case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
+      /* We may need to workaround RGBA4 UNORM issues with opaque black. This
+       * only affects float opaque black, there are no pure integer RGBA4
+       * formats to worry about.
+       */
+      return workaround_rgba4;
+
+   case VK_BORDER_COLOR_INT_CUSTOM_EXT:
+   case VK_BORDER_COLOR_FLOAT_CUSTOM_EXT:
+      return true;
+
+   default:
+      return false;
+   }
+}
+
+static struct mtl_sampler_packed
+pack_sampler_info(const struct VkSamplerCreateInfo *sampler_info)
+{
+   enum mtl_compare_function compare =
+      sampler_info->compareEnable
+         ? vk_compare_op_to_mtl_compare_function(sampler_info->compareOp)
+         : MTL_COMPARE_FUNCTION_ALWAYS;
+   enum mtl_sampler_mip_filter mip_filter =
+      sampler_info->unnormalizedCoordinates
+         ? MTL_SAMPLER_MIP_FILTER_NOT_MIP_MAPPED
+         : vk_sampler_mipmap_mode_to_mtl_sampler_mip_filter(
+              sampler_info->mipmapMode);
+   enum mtl_sampler_border_color border_color =
+      uses_border(sampler_info) ? vk_border_color_to_mtl_sampler_border_color(
+                                     sampler_info->borderColor)
+                                : MTL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE;
+   uint32_t max_anisotropy =
+      sampler_info->anisotropyEnable
+         ? util_next_power_of_two(MAX2(sampler_info->maxAnisotropy, 1))
+         : 1u;
+   return (struct mtl_sampler_packed){
+      .mode_u = vk_sampler_address_mode_to_mtl_sampler_address_mode(
+         sampler_info->addressModeU),
+      .mode_v = vk_sampler_address_mode_to_mtl_sampler_address_mode(
+         sampler_info->addressModeV),
+      .mode_w = vk_sampler_address_mode_to_mtl_sampler_address_mode(
+         sampler_info->addressModeW),
+      .border_color = border_color,
+      .min_filter =
+         vk_filter_to_mtl_sampler_min_mag_filter(sampler_info->minFilter),
+      .mag_filter =
+         vk_filter_to_mtl_sampler_min_mag_filter(sampler_info->magFilter),
+      .mip_filter = mip_filter,
+      .compare_func = compare,
+      .min_lod = sampler_info->minLod,
+      .max_lod = sampler_info->maxLod,
+      .max_anisotropy = max_anisotropy,
+      .normalized_coordinates = !sampler_info->unnormalizedCoordinates,
+   };
+}
+
+static mtl_sampler_descriptor *
+create_sampler_descriptor(const struct mtl_sampler_packed *packed)
+{
+   mtl_sampler_descriptor *descriptor = mtl_new_sampler_descriptor();
+   mtl_sampler_descriptor_set_normalized_coordinates(
+      descriptor, packed->normalized_coordinates);
+   mtl_sampler_descriptor_set_address_mode(descriptor, packed->mode_u,
+                                           packed->mode_v, packed->mode_w);
+   mtl_sampler_descriptor_set_border_color(descriptor, packed->border_color);
+   mtl_sampler_descriptor_set_filters(descriptor, packed->min_filter,
+                                      packed->mag_filter, packed->mip_filter);
+   mtl_sampler_descriptor_set_lod_clamp(descriptor, packed->min_lod,
+                                        packed->max_lod);
+   mtl_sampler_descriptor_set_max_anisotropy(descriptor,
+                                             packed->max_anisotropy);
+   mtl_sampler_descriptor_set_compare_function(descriptor,
+                                               packed->compare_func);
+   return descriptor;
+}
+
+mtl_sampler *
+kk_sampler_create(struct kk_device *dev,
+                  const struct mtl_sampler_packed *packed)
+{
+   mtl_sampler_descriptor *desc = create_sampler_descriptor(packed);
+   return mtl_new_sampler(dev->mtl_handle, desc);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+kk_CreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
+                 const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VkResult result = VK_SUCCESS;
+   struct kk_sampler *sampler;
+
+   sampler =
+      vk_sampler_create(&dev->vk, pCreateInfo, pAllocator, sizeof(*sampler));
+   if (!sampler)
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   struct mtl_sampler_packed packed = pack_sampler_info(pCreateInfo);
+   result = kk_sampler_heap_add(dev, packed, &sampler->planes[0].hw);
+   if (result != VK_SUCCESS) {
+      kk_DestroySampler(device, kk_sampler_to_handle(sampler), pAllocator);
+      return result;
+   }
+   sampler->plane_count = 1;
+
+   /* In order to support CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, we
+    * need multiple sampler planes: at minimum we will need one for luminance
+    * (the default), and one for chroma.  Each sampler plane needs its own
+    * sampler table entry.  However, sampler table entries are very rare on
+    * NVIDIA; we only have 4096 entries for the whole VkDevice, and each plane
+    * would burn one of those. So we make sure to allocate only the minimum
+    * amount that we actually need (i.e., either 1 or 2), and then just copy
+    * the last sampler plane out as far as we need to fill the number of image
+    * planes.
+    */
+
+   if (sampler->vk.ycbcr_conversion) {
+      const VkFilter chroma_filter =
+         sampler->vk.ycbcr_conversion->state.chroma_filter;
+      if (pCreateInfo->magFilter != chroma_filter ||
+          pCreateInfo->minFilter != chroma_filter) {
+         packed.min_filter = packed.mag_filter =
+            vk_filter_to_mtl_sampler_min_mag_filter(chroma_filter);
+         result = kk_sampler_heap_add(dev, packed, &sampler->planes[1].hw);
+         if (result != VK_SUCCESS) {
+            kk_DestroySampler(device, kk_sampler_to_handle(sampler),
+                              pAllocator);
+            return result;
+         }
+         sampler->plane_count = 2;
+      }
+   }
+
+   /* LOD data passed in the descriptor set */
+   sampler->lod_bias_fp16 = _mesa_float_to_half(pCreateInfo->mipLodBias);
+   sampler->lod_min_fp16 = _mesa_float_to_half(pCreateInfo->minLod);
+   sampler->lod_max_fp16 = _mesa_float_to_half(pCreateInfo->maxLod);
+
+   /* Border color passed in the descriptor */
+   sampler->has_border = uses_border(pCreateInfo) &&
+                         is_border_color_custom(pCreateInfo->borderColor, true);
+   if (sampler->has_border) {
+      /* We also need to record the border.
+       *
+       * If there is a border colour component mapping, we need to swizzle with
+       * it. Otherwise, we can assume there's nothing to do.
+       */
+      VkClearColorValue bc = sampler->vk.border_color_value;
+
+      const VkSamplerBorderColorComponentMappingCreateInfoEXT *swiz_info =
+         vk_find_struct_const(
+            pCreateInfo->pNext,
+            SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT);
+
+      if (swiz_info) {
+         const bool is_int = vk_border_color_is_int(pCreateInfo->borderColor);
+         bc = vk_swizzle_color_value(bc, swiz_info->components, is_int);
+      }
+
+      sampler->custom_border = bc;
+   }
+
+   *pSampler = kk_sampler_to_handle(sampler);
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+kk_DestroySampler(VkDevice device, VkSampler _sampler,
+                  const VkAllocationCallbacks *pAllocator)
+{
+   VK_FROM_HANDLE(kk_device, dev, device);
+   VK_FROM_HANDLE(kk_sampler, sampler, _sampler);
+
+   if (!sampler)
+      return;
+
+   for (uint8_t plane = 0; plane < sampler->plane_count; plane++)
+      kk_sampler_heap_remove(dev, sampler->planes[plane].hw);
+
+   vk_sampler_destroy(&dev->vk, pAllocator, &sampler->vk);
+}
diff --git a/src/kosmickrisp/vulkan/kk_sampler.h b/src/kosmickrisp/vulkan/kk_sampler.h
new file mode 100644
index 00000000000..15f3de9e582
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_sampler.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_SAMPLER_H
+#define KK_SAMPLER_H 1
+
+#include "kk_device.h"
+#include "kk_physical_device.h"
+#include "kk_private.h"
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "vk_sampler.h"
+#include "vk_ycbcr_conversion.h"
+
+#include "vk_format.h"
+
+struct kk_sampler {
+   struct vk_sampler vk;
+   VkClearColorValue custom_border;
+   bool has_border;
+
+   uint8_t plane_count;
+   uint16_t lod_bias_fp16;
+   uint16_t lod_min_fp16;
+   uint16_t lod_max_fp16;
+
+   struct {
+      struct kk_rc_sampler *hw;
+   } planes[2];
+};
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_sampler, vk.base, VkSampler,
+                               VK_OBJECT_TYPE_SAMPLER)
+
+#endif /* KK_SAMPLER_H */
diff --git a/src/kosmickrisp/vulkan/kk_shader.c b/src/kosmickrisp/vulkan/kk_shader.c
new file mode 100644
index 00000000000..2f723599655
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_shader.c
@@ -0,0 +1,1278 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_shader.h"
+
+#include "kk_cmd_buffer.h"
+#include "kk_descriptor_set_layout.h"
+#include "kk_debug.h"
+#include "kk_device.h"
+#include "kk_format.h"
+#include "kk_nir_lower_vbo.h"
+#include "kk_physical_device.h"
+#include "kk_sampler.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+#include "kosmickrisp/bridge/vk_to_mtl_map.h"
+#include "kosmickrisp/compiler/nir_to_msl.h"
+
+#include "nir_builder.h"
+#include "nir_lower_blend.h"
+
+#include "vk_blend.h"
+#include "vk_format.h"
+#include "vk_graphics_state.h"
+#include "vk_nir_convert_ycbcr.h"
+#include "vk_pipeline.h"
+
+static const nir_shader_compiler_options *
+kk_get_nir_options(struct vk_physical_device *vk_pdev, mesa_shader_stage stage,
+                   UNUSED const struct vk_pipeline_robustness_state *rs)
+{
+   static nir_shader_compiler_options options = {
+      .lower_fdph = true,
+      .has_fsub = true,
+      .has_isub = true,
+      .lower_extract_word = true,
+      .lower_extract_byte = true,
+      .lower_insert_word = true,
+      .lower_insert_byte = true,
+      .lower_fmod = true,
+      .discard_is_demote = true,
+      .instance_id_includes_base_index = true,
+      .lower_device_index_to_zero = true,
+      .lower_pack_64_2x32_split = true,
+      .lower_unpack_64_2x32_split = true,
+      .lower_pack_64_2x32 = true,
+      .lower_pack_half_2x16 = true,
+      .lower_pack_split = true,
+      .lower_unpack_half_2x16 = true,
+      .has_cs_global_id = true,
+      .lower_vector_cmp = true,
+      .lower_fquantize2f16 = true,
+      .lower_scmp = true,
+      .lower_ifind_msb = true,
+      .lower_ufind_msb = true,
+      .lower_find_lsb = true,
+      .has_uclz = true,
+      .lower_mul_2x32_64 = true,
+      .lower_uadd_carry = true,
+      .lower_usub_borrow = true,
+      /* Metal does not support double. */
+      .lower_doubles_options = (nir_lower_doubles_options)(~0),
+      .lower_int64_options =
+         nir_lower_ufind_msb64 | nir_lower_subgroup_shuffle64,
+   };
+   return &options;
+}
+
+static struct spirv_to_nir_options
+kk_get_spirv_options(struct vk_physical_device *vk_pdev,
+                     UNUSED mesa_shader_stage stage,
+                     const struct vk_pipeline_robustness_state *rs)
+{
+   return (struct spirv_to_nir_options){
+      .environment = NIR_SPIRV_VULKAN,
+      .ssbo_addr_format = nir_address_format_64bit_bounded_global,
+      .phys_ssbo_addr_format = nir_address_format_64bit_global,
+      .ubo_addr_format = nir_address_format_64bit_bounded_global,
+      .shared_addr_format = nir_address_format_32bit_offset,
+      .min_ssbo_alignment = KK_MIN_SSBO_ALIGNMENT,
+      .min_ubo_alignment = KK_MIN_UBO_ALIGNMENT,
+   };
+}
+
+static void
+kk_preprocess_nir(UNUSED struct vk_physical_device *vk_pdev, nir_shader *nir,
+                  UNUSED const struct vk_pipeline_robustness_state *rs)
+{
+   /* Gather info before preprocess_nir but after some general lowering, so
+    * inputs_read and system_values_read are accurately set.
+    */
+   nir_shader_gather_info(nir, nir_shader_get_entrypoint(nir));
+
+   /* nir_lower_io_to_temporaries is required before nir_lower_blend since the
+    * blending pass sinks writes to the end of the block where we may have a
+    * jump, which is illegal.
+    */
+   NIR_PASS(_, nir, nir_lower_io_vars_to_temporaries,
+            nir_shader_get_entrypoint(nir), true, false);
+
+   msl_preprocess_nir(nir);
+}
+
+struct kk_vs_key {
+   bool is_points;
+};
+
+static void
+kk_populate_vs_key(struct kk_vs_key *key,
+                   const struct vk_graphics_pipeline_state *state)
+{
+   memset(key, 0, sizeof(*key));
+   key->is_points =
+      (state->ia->primitive_topology == VK_PRIMITIVE_TOPOLOGY_POINT_LIST);
+}
+
+struct kk_fs_key {
+   VkFormat color_formats[MESA_VK_MAX_COLOR_ATTACHMENTS];
+   struct vk_color_blend_state color_blend;
+   uint32_t rasterization_samples;
+   uint16_t static_sample_mask;
+   bool has_depth;
+};
+
+static void
+kk_populate_fs_key(struct kk_fs_key *key,
+                   const struct vk_graphics_pipeline_state *state)
+{
+   memset(key, 0, sizeof(*key));
+
+   /* Required since we [de]serialize blend, and render target swizzle for
+    * non-native formats */
+   memcpy(key->color_formats, state->rp->color_attachment_formats,
+          sizeof(key->color_formats));
+
+   /* Blend state gets [de]serialized, so we need to hash it */
+   if (state->cb)
+      key->color_blend = *(state->cb);
+
+   if (state->ms) {
+      key->rasterization_samples = state->ms->rasterization_samples;
+      key->static_sample_mask = state->ms->sample_mask;
+   }
+
+   /* Depth writes are removed unless there's an actual attachment */
+   key->has_depth = state->rp->depth_attachment_format != VK_FORMAT_UNDEFINED;
+}
+
+static void
+kk_hash_graphics_state(struct vk_physical_device *device,
+                       const struct vk_graphics_pipeline_state *state,
+                       const struct vk_features *enabled_features,
+                       VkShaderStageFlags stages, blake3_hash blake3_out)
+{
+   struct mesa_blake3 blake3_ctx;
+   _mesa_blake3_init(&blake3_ctx);
+
+   if (stages & VK_SHADER_STAGE_VERTEX_BIT) {
+      struct kk_vs_key key;
+      kk_populate_vs_key(&key, state);
+      _mesa_blake3_update(&blake3_ctx, &key, sizeof(key));
+   }
+
+   if (stages & VK_SHADER_STAGE_FRAGMENT_BIT) {
+      struct kk_fs_key key;
+      kk_populate_fs_key(&key, state);
+      _mesa_blake3_update(&blake3_ctx, &key, sizeof(key));
+
+      _mesa_blake3_update(&blake3_ctx, &state->rp->view_mask,
+                          sizeof(state->rp->view_mask));
+   }
+
+   _mesa_blake3_final(&blake3_ctx, blake3_out);
+}
+
+static void
+shared_var_info(const struct glsl_type *type, unsigned *size, unsigned *align)
+{
+   assert(glsl_type_is_vector_or_scalar(type));
+
+   uint32_t comp_size =
+      glsl_type_is_boolean(type) ? 4 : glsl_get_bit_size(type) / 8;
+   unsigned length = glsl_get_vector_elements(type);
+   *size = comp_size * length, *align = comp_size;
+}
+
+struct lower_ycbcr_state {
+   uint32_t set_layout_count;
+   struct vk_descriptor_set_layout *const *set_layouts;
+};
+
+static const struct vk_ycbcr_conversion_state *
+lookup_ycbcr_conversion(const void *_state, uint32_t set, uint32_t binding,
+                        uint32_t array_index)
+{
+   const struct lower_ycbcr_state *state = _state;
+   assert(set < state->set_layout_count);
+   assert(state->set_layouts[set] != NULL);
+   const struct kk_descriptor_set_layout *set_layout =
+      vk_to_kk_descriptor_set_layout(state->set_layouts[set]);
+   assert(binding < set_layout->binding_count);
+
+   const struct kk_descriptor_set_binding_layout *bind_layout =
+      &set_layout->binding[binding];
+
+   if (bind_layout->immutable_samplers == NULL)
+      return NULL;
+
+   array_index = MIN2(array_index, bind_layout->array_size - 1);
+
+   const struct kk_sampler *sampler =
+      bind_layout->immutable_samplers[array_index];
+
+   return sampler && sampler->vk.ycbcr_conversion
+             ? &sampler->vk.ycbcr_conversion->state
+             : NULL;
+}
+
+static int
+type_size_vec4(const struct glsl_type *type, bool bindless)
+{
+   return glsl_count_attribute_slots(type, false);
+}
+
+static bool
+kk_nir_swizzle_fragment_output(nir_builder *b, nir_intrinsic_instr *intrin,
+                               void *data)
+{
+   if (intrin->intrinsic != nir_intrinsic_store_output &&
+       intrin->intrinsic != nir_intrinsic_load_output)
+      return false;
+
+   unsigned slot = nir_intrinsic_io_semantics(intrin).location;
+   if (slot < FRAG_RESULT_DATA0)
+      return false;
+
+   const struct vk_graphics_pipeline_state *state =
+      (const struct vk_graphics_pipeline_state *)data;
+   VkFormat vk_format =
+      state->rp->color_attachment_formats[slot - FRAG_RESULT_DATA0];
+   if (vk_format == VK_FORMAT_UNDEFINED)
+      return false;
+
+   enum pipe_format format = vk_format_to_pipe_format(vk_format);
+   const struct kk_va_format *supported_format = kk_get_va_format(format);
+
+   /* Check if we have to apply any swizzle */
+   if (!supported_format->is_native) {
+      unsigned channel_swizzle[] = {
+         supported_format->swizzle.red, supported_format->swizzle.green,
+         supported_format->swizzle.blue, supported_format->swizzle.alpha};
+
+      if (intrin->intrinsic == nir_intrinsic_store_output) {
+         b->cursor = nir_before_instr(&intrin->instr);
+         nir_def *to_replace = intrin->src[0].ssa;
+         nir_def *swizzled = nir_swizzle(b, to_replace, channel_swizzle,
+                                         to_replace->num_components);
+         nir_src_rewrite(&intrin->src[0], swizzled);
+      } else {
+         unsigned channel_unswizzle[4] = {0u};
+         for (uint32_t i = 0u; i < 4; ++i)
+            channel_unswizzle[channel_swizzle[i]] = i;
+
+         b->cursor = nir_after_instr(&intrin->instr);
+         nir_def *to_replace = &intrin->def;
+         nir_def *swizzled = nir_swizzle(b, to_replace, channel_unswizzle,
+                                         to_replace->num_components);
+         nir_def_rewrite_uses_after(to_replace, swizzled);
+      }
+      return true;
+   }
+
+   return false;
+}
+
+static void
+kk_lower_vs_vbo(nir_shader *nir, const struct vk_graphics_pipeline_state *state)
+{
+   assert(!(nir->info.inputs_read & BITFIELD64_MASK(VERT_ATTRIB_GENERIC0)) &&
+          "Fixed-function attributes not used in Vulkan");
+   NIR_PASS(_, nir, nir_recompute_io_bases, nir_var_shader_in);
+   /* the shader_out portion of this is load-bearing even for tess eval */
+   NIR_PASS(_, nir, nir_io_add_const_offset_to_base,
+            nir_var_shader_in | nir_var_shader_out);
+
+   struct kk_attribute attributes[KK_MAX_ATTRIBS] = {};
+   uint64_t attribs_read = nir->info.inputs_read >> VERT_ATTRIB_GENERIC0;
+   u_foreach_bit(i, state->vi->attributes_valid) {
+      const struct vk_vertex_attribute_state *attr = &state->vi->attributes[i];
+      assert(state->vi->bindings_valid & BITFIELD_BIT(attr->binding));
+      const struct vk_vertex_binding_state *binding =
+         &state->vi->bindings[attr->binding];
+
+      /* nir_assign_io_var_locations compacts vertex inputs, eliminating
+       * unused inputs. We need to do the same here to match the locations.
+       */
+      unsigned slot = util_bitcount64(attribs_read & BITFIELD_MASK(i));
+      attributes[slot].divisor = binding->divisor;
+      attributes[slot].binding = attr->binding;
+      attributes[slot].format = vk_format_to_pipe_format(attr->format);
+      attributes[slot].buf = attr->binding;
+      attributes[slot].instanced =
+         binding->input_rate == VK_VERTEX_INPUT_RATE_INSTANCE;
+   }
+   NIR_PASS(_, nir, kk_nir_lower_vbo, attributes);
+}
+
+static void
+kk_lower_vs(nir_shader *nir, const struct vk_graphics_pipeline_state *state)
+{
+   if (state->ia->primitive_topology != VK_PRIMITIVE_TOPOLOGY_POINT_LIST)
+      nir_shader_intrinsics_pass(nir, msl_nir_vs_remove_point_size_write,
+                                 nir_metadata_control_flow, NULL);
+
+   NIR_PASS(_, nir, msl_nir_layer_id_type);
+}
+
+static void
+kk_lower_fs_blend(nir_shader *nir,
+                  const struct vk_graphics_pipeline_state *state)
+{
+   nir_lower_blend_options opts = {
+      .scalar_blend_const = false,
+      .logicop_enable = state->cb->logic_op_enable,
+      .logicop_func = state->cb->logic_op,
+   };
+
+   static_assert(ARRAY_SIZE(opts.format) == 8, "max RTs out of sync");
+
+   for (unsigned i = 0; i < ARRAY_SIZE(opts.format); ++i) {
+      opts.format[i] =
+         vk_format_to_pipe_format(state->rp->color_attachment_formats[i]);
+      if (state->cb->attachments[i].blend_enable) {
+         opts.rt[i] = (nir_lower_blend_rt){
+            .rgb.src_factor = vk_blend_factor_to_pipe(
+               state->cb->attachments[i].src_color_blend_factor),
+            .rgb.dst_factor = vk_blend_factor_to_pipe(
+               state->cb->attachments[i].dst_color_blend_factor),
+            .rgb.func =
+               vk_blend_op_to_pipe(state->cb->attachments[i].color_blend_op),
+
+            .alpha.src_factor = vk_blend_factor_to_pipe(
+               state->cb->attachments[i].src_alpha_blend_factor),
+            .alpha.dst_factor = vk_blend_factor_to_pipe(
+               state->cb->attachments[i].dst_alpha_blend_factor),
+            .alpha.func =
+               vk_blend_op_to_pipe(state->cb->attachments[i].alpha_blend_op),
+
+            .colormask = state->cb->attachments[i].write_mask,
+         };
+      } else {
+         opts.rt[i] = (nir_lower_blend_rt){
+            .rgb.src_factor = PIPE_BLENDFACTOR_ONE,
+            .rgb.dst_factor = PIPE_BLENDFACTOR_ZERO,
+            .rgb.func = PIPE_BLEND_ADD,
+
+            .alpha.src_factor = PIPE_BLENDFACTOR_ONE,
+            .alpha.dst_factor = PIPE_BLENDFACTOR_ZERO,
+            .alpha.func = PIPE_BLEND_ADD,
+
+            .colormask = state->cb->attachments[i].write_mask,
+         };
+      }
+   }
+   NIR_PASS(_, nir, nir_io_add_const_offset_to_base, nir_var_shader_out);
+   NIR_PASS(_, nir, nir_lower_blend, &opts);
+}
+
+static bool
+lower_subpass_dim(nir_builder *b, nir_tex_instr *tex, UNUSED void *_data)
+{
+   if (tex->sampler_dim == GLSL_SAMPLER_DIM_SUBPASS)
+      tex->sampler_dim = GLSL_SAMPLER_DIM_2D;
+   else if (tex->sampler_dim == GLSL_SAMPLER_DIM_SUBPASS_MS)
+      tex->sampler_dim = GLSL_SAMPLER_DIM_MS;
+   else
+      return false;
+
+   return true;
+}
+
+static void
+kk_lower_fs(nir_shader *nir, const struct vk_graphics_pipeline_state *state)
+{
+   if (state->cb)
+      kk_lower_fs_blend(nir, state);
+
+   if (state->rp->depth_attachment_format == VK_FORMAT_UNDEFINED ||
+       nir->info.fs.early_fragment_tests)
+      NIR_PASS(_, nir, nir_shader_intrinsics_pass,
+               msl_nir_fs_remove_depth_write, nir_metadata_control_flow, NULL);
+
+   /* Input attachments are treated as 2D textures. Fixes sampler dimension */
+   NIR_PASS(_, nir, nir_shader_tex_pass, lower_subpass_dim, nir_metadata_all,
+            NULL);
+
+   /* Swizzle non-native formats' outputs */
+   NIR_PASS(_, nir, nir_shader_intrinsics_pass, kk_nir_swizzle_fragment_output,
+            nir_metadata_control_flow, (void *)state);
+
+   /* Metal's sample mask is uint. */
+   NIR_PASS(_, nir, msl_nir_sample_mask_type);
+
+   if (state->ms && state->ms->rasterization_samples &&
+       state->ms->sample_mask != UINT16_MAX)
+      NIR_PASS(_, nir, msl_lower_static_sample_mask, state->ms->sample_mask);
+   /* Check https://github.com/KhronosGroup/Vulkan-Portability/issues/54 for
+    * explanation on why we need this. */
+   else if (nir->info.fs.needs_full_quad_helper_invocations ||
+            nir->info.fs.needs_coarse_quad_helper_invocations)
+      NIR_PASS(_, nir, msl_lower_static_sample_mask, 0xFFFFFFFF);
+}
+
+static void
+kk_lower_nir(struct kk_device *dev, nir_shader *nir,
+             const struct vk_pipeline_robustness_state *rs,
+             uint32_t set_layout_count,
+             struct vk_descriptor_set_layout *const *set_layouts,
+             const struct vk_graphics_pipeline_state *state)
+{
+   /* Massage IO related variables to please Metal */
+   if (nir->info.stage == MESA_SHADER_VERTEX) {
+      NIR_PASS(_, nir, kk_nir_lower_vs_multiview, state->rp->view_mask);
+
+      /* kk_nir_lower_vs_multiview may create a temporary array to assign the
+       * correct view index. Since we don't handle derefs, we need to get rid of
+       * them. */
+      NIR_PASS(_, nir, nir_lower_vars_to_scratch, nir_var_function_temp, 0,
+               glsl_get_natural_size_align_bytes,
+               glsl_get_natural_size_align_bytes);
+
+      NIR_PASS(_, nir, msl_ensure_vertex_position_output);
+   } else if (nir->info.stage == MESA_SHADER_FRAGMENT) {
+      enum pipe_format rts[MAX_DRAW_BUFFERS] = {PIPE_FORMAT_NONE};
+      const struct vk_render_pass_state *rp = state->rp;
+      for (uint32_t i = 0u; i < MAX_DRAW_BUFFERS; ++i)
+         rts[i] = vk_format_to_pipe_format(rp->color_attachment_formats[i]);
+
+      NIR_PASS(_, nir, msl_nir_fs_force_output_signedness, rts);
+
+      NIR_PASS(_, nir, kk_nir_lower_fs_multiview, state->rp->view_mask);
+
+      if (state->rp->depth_attachment_format != VK_FORMAT_UNDEFINED &&
+          state->ial && state->ial->depth_att != MESA_VK_ATTACHMENT_NO_INDEX) {
+         NIR_PASS(_, nir, msl_ensure_depth_write);
+      }
+   }
+
+   const struct lower_ycbcr_state ycbcr_state = {
+      .set_layout_count = set_layout_count,
+      .set_layouts = set_layouts,
+   };
+   NIR_PASS(_, nir, nir_vk_lower_ycbcr_tex, lookup_ycbcr_conversion,
+            &ycbcr_state);
+
+   /* Common msl texture lowering needs to happen after ycbcr lowering and
+    * before descriptor lowering. */
+   NIR_PASS(_, nir, msl_lower_textures);
+
+   /* Lower push constants before lower_descriptors */
+   NIR_PASS(_, nir, nir_lower_explicit_io, nir_var_mem_push_const,
+            nir_address_format_32bit_offset);
+
+   NIR_PASS(_, nir, nir_lower_memory_model);
+
+   NIR_PASS(_, nir, nir_lower_explicit_io, nir_var_mem_global,
+            nir_address_format_64bit_global);
+   NIR_PASS(_, nir, nir_lower_explicit_io, nir_var_mem_ssbo,
+            nir_address_format_64bit_bounded_global);
+   NIR_PASS(_, nir, nir_lower_explicit_io, nir_var_mem_ubo,
+            nir_address_format_64bit_bounded_global);
+
+   NIR_PASS(_, nir, nir_lower_io, nir_var_shader_in | nir_var_shader_out,
+            type_size_vec4,
+            nir_lower_io_lower_64bit_to_32 |
+               nir_lower_io_use_interpolated_input_intrinsics);
+
+   if (!nir->info.shared_memory_explicit_layout) {
+      NIR_PASS(_, nir, nir_lower_vars_to_explicit_types, nir_var_mem_shared,
+               shared_var_info);
+   }
+   NIR_PASS(_, nir, nir_lower_explicit_io, nir_var_mem_shared,
+            nir_address_format_32bit_offset);
+
+   if (nir->info.zero_initialize_shared_memory && nir->info.shared_size > 0) {
+      /* QMD::SHARED_MEMORY_SIZE requires an alignment of 256B so it's safe to
+       * align everything up to 16B so we can write whole vec4s.
+       */
+      nir->info.shared_size = align(nir->info.shared_size, 16);
+      NIR_PASS(_, nir, nir_zero_initialize_shared_memory, nir->info.shared_size,
+               16);
+
+      /* We need to call lower_compute_system_values again because
+       * nir_zero_initialize_shared_memory generates load_invocation_id which
+       * has to be lowered to load_invocation_index.
+       */
+      NIR_PASS(_, nir, nir_lower_compute_system_values, NULL);
+   }
+
+   NIR_PASS(_, nir, nir_opt_dce);
+   NIR_PASS(_, nir, nir_lower_variable_initializers, ~nir_var_function_temp);
+   NIR_PASS(_, nir, nir_remove_dead_variables,
+            nir_var_shader_in | nir_var_shader_out | nir_var_system_value,
+            NULL);
+   nir->info.io_lowered = true;
+
+   /* Required before kk_nir_lower_vbo so load_input intrinsics' parents are
+    * load_const, otherwise the pass will complain */
+   NIR_PASS(_, nir, nir_opt_constant_folding);
+
+   /* These passes operate on lowered IO. */
+   if (nir->info.stage == MESA_SHADER_VERTEX) {
+      kk_lower_vs(nir, state);
+   } else if (nir->info.stage == MESA_SHADER_FRAGMENT) {
+      kk_lower_fs(nir, state);
+   }
+
+   /* Descriptor lowering needs to happen after lowering blend since we will
+    * generate a nir_intrinsic_load_blend_const_color_rgba which gets lowered by
+    * the lower descriptor pass
+    */
+   NIR_PASS(_, nir, kk_nir_lower_descriptors, rs, set_layout_count,
+            set_layouts);
+   NIR_PASS(_, nir, kk_nir_lower_textures);
+
+   NIR_PASS(_, nir, nir_lower_global_vars_to_local);
+}
+
+static const struct vk_shader_ops kk_shader_ops;
+
+static void
+kk_shader_destroy(struct vk_device *vk_dev, struct vk_shader *vk_shader,
+                  const VkAllocationCallbacks *pAllocator)
+{
+   struct kk_device *dev = container_of(vk_dev, struct kk_device, vk);
+   struct kk_shader *shader = container_of(vk_shader, struct kk_shader, vk);
+
+   if (shader->pipeline.cs) {
+      mtl_release(shader->pipeline.cs);
+   } else if (shader->pipeline.gfx.handle) {
+      mtl_release(shader->pipeline.gfx.handle);
+      if (shader->pipeline.gfx.mtl_depth_stencil_state_handle)
+         mtl_release(shader->pipeline.gfx.mtl_depth_stencil_state_handle);
+      shader->pipeline.gfx.handle = NULL;
+      shader->pipeline.gfx.mtl_depth_stencil_state_handle = NULL;
+   }
+
+   ralloc_free((void *)shader->msl_code);
+   ralloc_free((void *)shader->entrypoint_name);
+
+   vk_shader_free(&dev->vk, pAllocator, &shader->vk);
+}
+
+static bool
+gather_vs_inputs(nir_builder *b, nir_intrinsic_instr *intr, void *data)
+{
+   if (intr->intrinsic != nir_intrinsic_load_input)
+      return false;
+
+   struct nir_io_semantics io = nir_intrinsic_io_semantics(intr);
+   BITSET_WORD *attribs_read = data;
+   BITSET_SET(attribs_read, (io.location - VERT_ATTRIB_GENERIC0));
+   return false;
+}
+
+static void
+gather_shader_info(struct kk_shader *shader, nir_shader *nir,
+                   const struct vk_graphics_pipeline_state *state)
+{
+   shader->info.stage = nir->info.stage;
+   if (nir->info.stage == MESA_SHADER_VERTEX) {
+      nir_shader_intrinsics_pass(nir, gather_vs_inputs, nir_metadata_all,
+                                 &shader->info.vs.attribs_read);
+   } else if (nir->info.stage == MESA_SHADER_FRAGMENT) {
+      /* Some meta shaders like vk-meta-resolve will have depth_layout as NONE
+       * which is not a valid Metal layout */
+      if (nir->info.fs.depth_layout == FRAG_DEPTH_LAYOUT_NONE)
+         nir->info.fs.depth_layout = FRAG_DEPTH_LAYOUT_ANY;
+   } else if (nir->info.stage == MESA_SHADER_COMPUTE) {
+      shader->info.cs.local_size.x = nir->info.workgroup_size[0];
+      shader->info.cs.local_size.y = nir->info.workgroup_size[1];
+      shader->info.cs.local_size.z = nir->info.workgroup_size[2];
+   }
+}
+
+static void
+modify_nir_info(nir_shader *nir)
+{
+   nir_shader_gather_info(nir, nir_shader_get_entrypoint(nir));
+   if (nir->info.stage == MESA_SHADER_VERTEX) {
+      /* Vertex attribute fetch is done in shader through argument buffers. */
+      nir->info.inputs_read = 0u;
+   } else if (nir->info.stage == MESA_SHADER_FRAGMENT) {
+      /* Some meta shaders like vk-meta-resolve will have depth_layout as NONE
+       * which is not a valid Metal layout */
+      if (nir->info.fs.depth_layout == FRAG_DEPTH_LAYOUT_NONE)
+         nir->info.fs.depth_layout = FRAG_DEPTH_LAYOUT_ANY;
+
+      /* These values are part of the declaration and go with IO. We only
+       * require the instrunctions to understand interpolation mode. */
+      BITSET_CLEAR(nir->info.system_values_read,
+                   SYSTEM_VALUE_BARYCENTRIC_PERSP_PIXEL);
+      BITSET_CLEAR(nir->info.system_values_read,
+                   SYSTEM_VALUE_BARYCENTRIC_PERSP_SAMPLE);
+      BITSET_CLEAR(nir->info.system_values_read,
+                   SYSTEM_VALUE_BARYCENTRIC_PERSP_CENTROID);
+      BITSET_CLEAR(nir->info.system_values_read,
+                   SYSTEM_VALUE_BARYCENTRIC_LINEAR_PIXEL);
+      BITSET_CLEAR(nir->info.system_values_read,
+                   SYSTEM_VALUE_BARYCENTRIC_LINEAR_CENTROID);
+      BITSET_CLEAR(nir->info.system_values_read,
+                   SYSTEM_VALUE_BARYCENTRIC_LINEAR_SAMPLE);
+   }
+}
+
+static VkResult
+kk_compile_shader(struct kk_device *dev, struct vk_shader_compile_info *info,
+                  const struct vk_graphics_pipeline_state *state,
+                  const VkAllocationCallbacks *pAllocator,
+                  struct vk_shader **shader_out)
+{
+   struct kk_shader *shader;
+   VkResult result = VK_SUCCESS;
+
+   /* We consume the NIR, regardless of success or failure */
+   nir_shader *nir = info->nir;
+
+   shader = vk_shader_zalloc(&dev->vk, &kk_shader_ops, info->stage, pAllocator,
+                             sizeof(*shader));
+   if (shader == NULL) {
+      ralloc_free(nir);
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+   }
+
+   if (nir->info.io_lowered == false)
+      kk_lower_nir(dev, nir, info->robustness, info->set_layout_count,
+                   info->set_layouts, state);
+
+   gather_shader_info(shader, nir, state);
+
+   /* VBO lowering needs to go here otherwise, the linking step removes all
+    * inputs since we read vertex attributes from UBOs. */
+   if (info->stage == MESA_SHADER_VERTEX) {
+      kk_lower_vs_vbo(nir, state);
+   }
+   msl_optimize_nir(nir);
+   modify_nir_info(nir);
+   shader->msl_code = nir_to_msl(nir, NULL);
+   const char *entrypoint_name = nir_shader_get_entrypoint(nir)->function->name;
+
+   /* We need to steal so it doesn't get destroyed with the nir. Needs to happen
+    * after nir_to_msl since that's where we rename the entrypoint.
+    */
+   ralloc_steal(NULL, (void *)entrypoint_name);
+   shader->entrypoint_name = entrypoint_name;
+
+   if (KK_DEBUG(MSL))
+      mesa_logi("%s\n", shader->msl_code);
+
+   ralloc_free(nir);
+
+   *shader_out = &shader->vk;
+
+   return result;
+}
+
+static const struct vk_pipeline_robustness_state rs_none = {
+   .uniform_buffers = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT,
+   .storage_buffers = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT,
+   .images = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT,
+};
+
+VkResult
+kk_compile_nir_shader(struct kk_device *dev, nir_shader *nir,
+                      const VkAllocationCallbacks *alloc,
+                      struct kk_shader **shader_out)
+{
+   const struct kk_physical_device *pdev = kk_device_physical(dev);
+
+   assert(nir->info.stage == MESA_SHADER_COMPUTE);
+   if (nir->options == NULL)
+      nir->options = kk_get_nir_options((struct vk_physical_device *)&pdev->vk,
+                                        nir->info.stage, &rs_none);
+
+   struct vk_shader_compile_info info = {
+      .stage = nir->info.stage,
+      .nir = nir,
+      .robustness = &rs_none,
+   };
+
+   struct vk_shader *shader = NULL;
+   nir_shader_gather_info(nir, nir_shader_get_entrypoint(nir));
+   VkResult result = kk_compile_shader(dev, &info, NULL, alloc, &shader);
+   if (result != VK_SUCCESS)
+      return result;
+
+   *shader_out = container_of(shader, struct kk_shader, vk);
+
+   return VK_SUCCESS;
+}
+
+static void
+nir_opts(nir_shader *nir)
+{
+   bool progress;
+
+   do {
+      progress = false;
+
+      NIR_PASS(progress, nir, nir_opt_loop);
+      NIR_PASS(progress, nir, nir_copy_prop);
+      NIR_PASS(progress, nir, nir_opt_remove_phis);
+      NIR_PASS(progress, nir, nir_opt_dce);
+
+      NIR_PASS(progress, nir, nir_opt_if, 0);
+      NIR_PASS(progress, nir, nir_opt_dead_cf);
+      NIR_PASS(progress, nir, nir_opt_cse);
+
+      NIR_PASS(progress, nir, nir_opt_peephole_select,
+               &(nir_opt_peephole_select_options){
+                  .limit = 8,
+                  .expensive_alu_ok = true,
+                  .discard_ok = true,
+               });
+
+      NIR_PASS(progress, nir, nir_opt_phi_precision);
+      NIR_PASS(progress, nir, nir_opt_algebraic);
+      NIR_PASS(progress, nir, nir_opt_constant_folding);
+      NIR_PASS(progress, nir, nir_io_add_const_offset_to_base,
+               nir_var_shader_in | nir_var_shader_out);
+
+      NIR_PASS(progress, nir, nir_opt_undef);
+      NIR_PASS(progress, nir, nir_opt_loop_unroll);
+   } while (progress);
+}
+
+static nir_shader *
+get_empty_nir(struct kk_device *dev, mesa_shader_stage stage,
+              const struct vk_graphics_pipeline_state *state)
+{
+   nir_shader *nir = nir_shader_create(
+      NULL, stage,
+      kk_get_nir_options(&kk_device_physical(dev)->vk, stage, NULL));
+
+   nir_function *function = nir_function_create(nir, "main_entrypoint");
+   function->is_entrypoint = true;
+   nir_function_impl_create(function);
+
+   const struct vk_pipeline_robustness_state no_robustness = {
+      .storage_buffers = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED,
+      .uniform_buffers = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED,
+      .vertex_inputs = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED,
+      .images = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED,
+      .null_uniform_buffer_descriptor = false,
+      .null_storage_buffer_descriptor = false,
+   };
+   kk_lower_nir(dev, nir, &no_robustness, 0u, NULL, state);
+   nir_shader_gather_info(nir, nir_shader_get_entrypoint(nir));
+
+   return nir;
+}
+
+static VkResult
+kk_compile_compute_pipeline(struct kk_device *device, struct kk_shader *shader)
+{
+   uint32_t local_size_threads = shader->info.cs.local_size.x *
+                                 shader->info.cs.local_size.y *
+                                 shader->info.cs.local_size.z;
+   mtl_library *library = mtl_new_library(device->mtl_handle, shader->msl_code);
+   if (library == NULL)
+      return VK_ERROR_INVALID_SHADER_NV;
+
+   mtl_function *function =
+      mtl_new_function_with_name(library, shader->entrypoint_name);
+   shader->pipeline.cs = mtl_new_compute_pipeline_state(
+      device->mtl_handle, function, local_size_threads);
+   mtl_release(function);
+   mtl_release(library);
+
+   if (shader->pipeline.cs == NULL)
+      return VK_ERROR_INVALID_SHADER_NV;
+
+   return VK_SUCCESS;
+}
+
+static bool
+has_static_depth_stencil_state(const struct vk_graphics_pipeline_state *state)
+{
+   if (!state->ds)
+      return false;
+
+   return !(
+      BITSET_TEST(state->dynamic, MESA_VK_DYNAMIC_DS_DEPTH_TEST_ENABLE) |
+      BITSET_TEST(state->dynamic, MESA_VK_DYNAMIC_DS_DEPTH_WRITE_ENABLE) |
+      BITSET_TEST(state->dynamic, MESA_VK_DYNAMIC_DS_DEPTH_COMPARE_OP) |
+      BITSET_TEST(state->dynamic, MESA_VK_DYNAMIC_DS_STENCIL_TEST_ENABLE) |
+      BITSET_TEST(state->dynamic, MESA_VK_DYNAMIC_DS_STENCIL_OP) |
+      BITSET_TEST(state->dynamic, MESA_VK_DYNAMIC_DS_STENCIL_COMPARE_MASK) |
+      BITSET_TEST(state->dynamic, MESA_VK_DYNAMIC_DS_STENCIL_WRITE_MASK));
+}
+
+mtl_depth_stencil_state *
+kk_compile_depth_stencil_state(struct kk_device *device,
+                               const struct vk_depth_stencil_state *ds,
+                               bool has_depth, bool has_stencil)
+{
+   mtl_stencil_descriptor *front = NULL;
+   mtl_stencil_descriptor *back = NULL;
+   mtl_depth_stencil_descriptor *descriptor =
+      mtl_new_depth_stencil_descriptor();
+   if (has_depth && ds->depth.test_enable) {
+      mtl_depth_stencil_descriptor_set_depth_write_enabled(
+         descriptor, ds->depth.write_enable);
+      mtl_depth_stencil_descriptor_set_depth_compare_function(
+         descriptor, ds->depth.compare_op);
+   } else {
+      /* Only way to disable is to always pass */
+      mtl_depth_stencil_descriptor_set_depth_write_enabled(descriptor, false);
+      mtl_depth_stencil_descriptor_set_depth_compare_function(
+         descriptor, VK_COMPARE_OP_ALWAYS);
+   }
+
+   if (has_stencil && ds->stencil.test_enable) {
+      back = mtl_new_stencil_descriptor();
+      mtl_stencil_descriptor_set_depth_failure_operation(
+         back, ds->stencil.back.op.depth_fail);
+      mtl_stencil_descriptor_set_stencil_failure_operation(
+         back, ds->stencil.back.op.fail);
+      mtl_stencil_descriptor_set_depth_stencil_pass_operation(
+         back, ds->stencil.back.op.pass);
+      mtl_stencil_descriptor_set_stencil_compare_function(
+         back, ds->stencil.back.op.compare);
+      mtl_stencil_descriptor_set_read_mask(back, ds->stencil.back.compare_mask);
+      mtl_stencil_descriptor_set_write_mask(back, ds->stencil.back.write_mask);
+      mtl_depth_stencil_descriptor_set_back_face_stencil(descriptor, back);
+
+      front = mtl_new_stencil_descriptor();
+      mtl_stencil_descriptor_set_depth_failure_operation(
+         front, ds->stencil.front.op.depth_fail);
+      mtl_stencil_descriptor_set_stencil_failure_operation(
+         front, ds->stencil.front.op.fail);
+      mtl_stencil_descriptor_set_depth_stencil_pass_operation(
+         front, ds->stencil.front.op.pass);
+      mtl_stencil_descriptor_set_stencil_compare_function(
+         front, ds->stencil.front.op.compare);
+      mtl_stencil_descriptor_set_read_mask(front,
+                                           ds->stencil.front.compare_mask);
+      mtl_stencil_descriptor_set_write_mask(front,
+                                            ds->stencil.front.write_mask);
+      mtl_depth_stencil_descriptor_set_front_face_stencil(descriptor, front);
+   }
+
+   mtl_depth_stencil_state *state =
+      mtl_new_depth_stencil_state(device->mtl_handle, descriptor);
+
+   if (front)
+      mtl_release(front);
+   if (back)
+      mtl_release(back);
+   mtl_release(descriptor);
+
+   return state;
+}
+
+/* TODO_KOSMICKRISP For now we just support vertex and fragment */
+static VkResult
+kk_compile_graphics_pipeline(struct kk_device *device,
+                             struct kk_shader *vertex_shader,
+                             struct kk_shader *fragment_shader,
+                             const struct vk_graphics_pipeline_state *state)
+{
+   VkResult result = VK_SUCCESS;
+
+   assert(vertex_shader->info.stage == MESA_SHADER_VERTEX &&
+          fragment_shader->info.stage == MESA_SHADER_FRAGMENT);
+
+   mtl_library *vertex_library =
+      mtl_new_library(device->mtl_handle, vertex_shader->msl_code);
+   if (vertex_library == NULL)
+      return VK_ERROR_INVALID_SHADER_NV;
+
+   mtl_function *vertex_function = mtl_new_function_with_name(
+      vertex_library, vertex_shader->entrypoint_name);
+
+   mtl_library *fragment_library =
+      mtl_new_library(device->mtl_handle, fragment_shader->msl_code);
+   if (fragment_library == NULL) {
+      result = VK_ERROR_INVALID_SHADER_NV;
+      goto destroy_vertex;
+   }
+   mtl_function *fragment_function = mtl_new_function_with_name(
+      fragment_library, fragment_shader->entrypoint_name);
+
+   mtl_render_pipeline_descriptor *pipeline_descriptor =
+      mtl_new_render_pipeline_descriptor();
+   mtl_render_pipeline_descriptor_set_vertex_shader(pipeline_descriptor,
+                                                    vertex_function);
+   if (fragment_function)
+      mtl_render_pipeline_descriptor_set_fragment_shader(pipeline_descriptor,
+                                                         fragment_function);
+   /* Layered rendering in Metal requires setting primitive topology class */
+   mtl_render_pipeline_descriptor_set_input_primitive_topology(
+      pipeline_descriptor,
+      vk_primitive_topology_to_mtl_primitive_topology_class(
+         state->ia->primitive_topology));
+
+   for (uint8_t i = 0; i < state->rp->color_attachment_count; ++i) {
+      if (state->rp->color_attachment_formats[i] != VK_FORMAT_UNDEFINED)
+         mtl_render_pipeline_descriptor_set_color_attachment_format(
+            pipeline_descriptor, i,
+            vk_format_to_mtl_pixel_format(
+               state->rp->color_attachment_formats[i]));
+   }
+
+   if (state->rp->depth_attachment_format != VK_FORMAT_UNDEFINED)
+      mtl_render_pipeline_descriptor_set_depth_attachment_format(
+         pipeline_descriptor,
+         vk_format_to_mtl_pixel_format(state->rp->depth_attachment_format));
+
+   if (state->rp->stencil_attachment_format != VK_FORMAT_UNDEFINED)
+      mtl_render_pipeline_descriptor_set_stencil_attachment_format(
+         pipeline_descriptor,
+         vk_format_to_mtl_pixel_format(state->rp->stencil_attachment_format));
+
+   if (has_static_depth_stencil_state(state)) {
+      bool has_depth =
+         state->rp->depth_attachment_format != VK_FORMAT_UNDEFINED;
+      bool has_stencil =
+         state->rp->stencil_attachment_format != VK_FORMAT_UNDEFINED;
+      vertex_shader->pipeline.gfx.mtl_depth_stencil_state_handle =
+         kk_compile_depth_stencil_state(device, state->ds, has_depth,
+                                        has_stencil);
+   }
+
+   if (state->rp->view_mask) {
+      uint32_t max_amplification = util_bitcount(state->rp->view_mask);
+      mtl_render_pipeline_descriptor_set_max_vertex_amplification_count(
+         pipeline_descriptor, max_amplification);
+   }
+
+   if (state->ms) {
+      mtl_render_pipeline_descriptor_set_raster_sample_count(
+         pipeline_descriptor, state->ms->rasterization_samples);
+      mtl_render_pipeline_descriptor_set_alpha_to_coverage(
+         pipeline_descriptor, state->ms->alpha_to_coverage_enable);
+      mtl_render_pipeline_descriptor_set_alpha_to_one(
+         pipeline_descriptor, state->ms->alpha_to_one_enable);
+   }
+
+   vertex_shader->pipeline.gfx.handle =
+      mtl_new_render_pipeline(device->mtl_handle, pipeline_descriptor);
+   if (vertex_shader->pipeline.gfx.handle == NULL)
+      result = VK_ERROR_INVALID_SHADER_NV;
+   vertex_shader->pipeline.gfx.primitive_type =
+      vk_primitive_topology_to_mtl_primitive_type(
+         state->ia->primitive_topology);
+
+   mtl_release(pipeline_descriptor);
+   mtl_release(fragment_function);
+   mtl_release(fragment_library);
+destroy_vertex:
+   mtl_release(vertex_function);
+   mtl_release(vertex_library);
+
+   return result;
+}
+
+static VkResult
+kk_compile_shaders(struct vk_device *device, uint32_t shader_count,
+                   struct vk_shader_compile_info *infos,
+                   const struct vk_graphics_pipeline_state *state,
+                   const struct vk_features *enabled_features,
+                   const VkAllocationCallbacks *pAllocator,
+                   struct vk_shader **shaders_out)
+{
+   VkResult result = VK_SUCCESS;
+   struct kk_device *dev = container_of(device, struct kk_device, vk);
+
+   /* Vulkan doesn't enforce a fragment shader to build pipelines. We may need
+    * to create one. */
+   nir_shader *null_fs = NULL;
+   nir_shader *shaders[shader_count + 1u];
+
+   /* Lower shaders, notably lowering IO. This is a prerequisite for intershader
+    * optimization. */
+   for (uint32_t i = 0u; i < shader_count; ++i) {
+      const struct vk_shader_compile_info *info = &infos[i];
+      nir_shader *nir = info->nir;
+
+      kk_lower_nir(dev, nir, info->robustness, info->set_layout_count,
+                   info->set_layouts, state);
+
+      shaders[i] = nir;
+   }
+
+   /* Since we don't support GPL nor shader objects and Metal render pipelines
+    * require both vertex and fragment, we may need to provide a pass-through
+    * fragment. */
+   if (state &&
+       shaders[shader_count - 1u]->info.stage != MESA_SHADER_FRAGMENT) {
+      null_fs = get_empty_nir(dev, MESA_SHADER_FRAGMENT, state);
+      shaders[shader_count] = null_fs;
+   }
+
+   uint32_t total_shaders = null_fs ? shader_count + 1 : shader_count;
+   nir_opt_varyings_bulk(shaders, total_shaders, true, UINT32_MAX, UINT32_MAX,
+                         nir_opts);
+   /* Second pass is required because some dEQP-VK.glsl.matrix.sub.dynamic.*
+    * would fail otherwise due to vertex outputting vec4 while fragments reading
+    * vec3 when in reality only vec3 is needed. */
+   nir_opt_varyings_bulk(shaders, total_shaders, true, UINT32_MAX, UINT32_MAX,
+                         nir_opts);
+
+   for (uint32_t i = 0; i < shader_count; i++) {
+      result =
+         kk_compile_shader(dev, &infos[i], state, pAllocator, &shaders_out[i]);
+      if (result != VK_SUCCESS) {
+         /* Clean up all the shaders before this point */
+         for (uint32_t j = 0; j < i; j++)
+            kk_shader_destroy(&dev->vk, shaders_out[j], pAllocator);
+
+         /* Clean up all the NIR after this point */
+         for (uint32_t j = i + 1; j < shader_count; j++)
+            ralloc_free(shaders[j]);
+
+         if (null_fs)
+            ralloc_free(null_fs);
+
+         /* Memset the output array */
+         memset(shaders_out, 0, shader_count * sizeof(*shaders_out));
+
+         return result;
+      }
+   }
+
+   /* Compile pipeline:
+    * 1. Compute pipeline
+    * 2. Graphics with all stages (since we don't support GPL nor shader
+    * objects for now). This will be addressed later.
+    */
+   if (shaders_out[0]->stage == MESA_SHADER_COMPUTE) {
+      result = kk_compile_compute_pipeline(
+         dev, container_of(shaders_out[0], struct kk_shader, vk));
+   } else {
+      struct kk_shader *vs = container_of(shaders_out[0], struct kk_shader, vk);
+      struct kk_shader *fs =
+         container_of(shaders_out[shader_count - 1u], struct kk_shader, vk);
+      if (null_fs) {
+         struct vk_shader_compile_info info = {
+            .stage = MESA_SHADER_FRAGMENT,
+            .nir = null_fs,
+            .robustness = &rs_none,
+         };
+         struct vk_shader *frag_shader;
+         result =
+            kk_compile_shader(dev, &info, state, &dev->vk.alloc, &frag_shader);
+
+         if (result != VK_SUCCESS) {
+            for (uint32_t i = 0; i < shader_count; i++)
+               kk_shader_destroy(&dev->vk, shaders_out[i], pAllocator);
+
+            /* Memset the output array */
+            memset(shaders_out, 0, shader_count * sizeof(*shaders_out));
+
+            return result;
+         }
+         fs = container_of(frag_shader, struct kk_shader, vk);
+      }
+
+      result = kk_compile_graphics_pipeline(dev, vs, fs, state);
+
+      if (null_fs)
+         kk_shader_destroy(&dev->vk, &fs->vk, pAllocator);
+   }
+
+   return result;
+}
+
+static bool
+kk_shader_serialize(struct vk_device *vk_dev, const struct vk_shader *vk_shader,
+                    struct blob *blob)
+{
+   struct kk_shader *shader = container_of(vk_shader, struct kk_shader, vk);
+
+   blob_write_bytes(blob, &shader->info, sizeof(shader->info));
+   uint32_t entrypoint_length = strlen(shader->entrypoint_name) + 1;
+   blob_write_bytes(blob, &entrypoint_length, sizeof(entrypoint_length));
+   uint32_t code_length = strlen(shader->msl_code) + 1;
+   blob_write_bytes(blob, &code_length, sizeof(code_length));
+   blob_write_bytes(blob, shader->entrypoint_name, entrypoint_length);
+   blob_write_bytes(blob, shader->msl_code, code_length);
+   blob_write_bytes(blob, &shader->pipeline, sizeof(shader->pipeline));
+
+   /* We are building a new shader into the cache so we need to retain resources
+    */
+   if (shader->info.stage == MESA_SHADER_COMPUTE)
+      mtl_retain(shader->pipeline.cs);
+   else if (shader->info.stage == MESA_SHADER_VERTEX) {
+      mtl_retain(shader->pipeline.gfx.handle);
+      if (shader->pipeline.gfx.mtl_depth_stencil_state_handle)
+         mtl_retain(shader->pipeline.gfx.mtl_depth_stencil_state_handle);
+   }
+
+   return !blob->out_of_memory;
+}
+
+static VkResult
+kk_deserialize_shader(struct vk_device *vk_dev, struct blob_reader *blob,
+                      uint32_t binary_version,
+                      const VkAllocationCallbacks *pAllocator,
+                      struct vk_shader **shader_out)
+{
+   struct kk_device *dev = container_of(vk_dev, struct kk_device, vk);
+   struct kk_shader *shader;
+
+   struct kk_shader_info info;
+   blob_copy_bytes(blob, &info, sizeof(info));
+
+   const uint32_t entrypoint_length = blob_read_uint32(blob);
+   const uint32_t code_length = blob_read_uint32(blob);
+   if (blob->overrun)
+      return vk_error(dev, VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT);
+
+   shader = vk_shader_zalloc(&dev->vk, &kk_shader_ops, info.stage, pAllocator,
+                             sizeof(*shader));
+   if (shader == NULL)
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   shader->info = info;
+
+   shader->entrypoint_name = ralloc_array(NULL, char, entrypoint_length);
+   if (shader->entrypoint_name == NULL) {
+      kk_shader_destroy(&dev->vk, &shader->vk, pAllocator);
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+   }
+
+   shader->msl_code = ralloc_array(NULL, char, code_length);
+   if (shader->msl_code == NULL) {
+      kk_shader_destroy(&dev->vk, &shader->vk, pAllocator);
+      return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY);
+   }
+
+   blob_copy_bytes(blob, (void *)shader->entrypoint_name, entrypoint_length);
+   blob_copy_bytes(blob, (void *)shader->msl_code, code_length);
+   blob_copy_bytes(blob, &shader->pipeline, sizeof(shader->pipeline));
+   if (blob->overrun) {
+      kk_shader_destroy(&dev->vk, &shader->vk, pAllocator);
+      return vk_error(dev, VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT);
+   }
+
+   /* We are building a new shader so we need to retain resources */
+   if (info.stage == MESA_SHADER_COMPUTE)
+      mtl_retain(shader->pipeline.cs);
+   else if (info.stage == MESA_SHADER_VERTEX) {
+      mtl_retain(shader->pipeline.gfx.handle);
+      if (shader->pipeline.gfx.mtl_depth_stencil_state_handle)
+         mtl_retain(shader->pipeline.gfx.mtl_depth_stencil_state_handle);
+   }
+
+   *shader_out = &shader->vk;
+
+   return VK_SUCCESS;
+}
+
+static void
+kk_cmd_bind_compute_shader(struct kk_cmd_buffer *cmd, struct kk_shader *shader)
+{
+   cmd->state.cs.pipeline_state = shader->pipeline.cs;
+   cmd->state.cs.dirty |= KK_DIRTY_PIPELINE;
+   cmd->state.cs.local_size = shader->info.cs.local_size;
+}
+
+static void
+kk_cmd_bind_graphics_shader(struct kk_cmd_buffer *cmd,
+                            const mesa_shader_stage stage,
+                            struct kk_shader *shader)
+{
+   /* Relevant pipeline data is only stored in vertex shaders */
+   if (stage != MESA_SHADER_VERTEX)
+      return;
+
+   cmd->state.gfx.primitive_type = shader->pipeline.gfx.primitive_type;
+   cmd->state.gfx.pipeline_state = shader->pipeline.gfx.handle;
+   cmd->state.gfx.vb.attribs_read = shader->info.vs.attribs_read;
+
+   bool requires_dynamic_depth_stencil =
+      shader->pipeline.gfx.mtl_depth_stencil_state_handle == NULL;
+   if (cmd->state.gfx.is_depth_stencil_dynamic) {
+      /* If we are switching from dynamic to static, we need to clean up
+       * temporary state. Otherwise, leave the existing dynamic state
+       * untouched.
+       */
+      if (!requires_dynamic_depth_stencil) {
+         mtl_release(cmd->state.gfx.depth_stencil_state);
+         cmd->state.gfx.depth_stencil_state =
+            shader->pipeline.gfx.mtl_depth_stencil_state_handle;
+      }
+   } else
+      cmd->state.gfx.depth_stencil_state =
+         shader->pipeline.gfx.mtl_depth_stencil_state_handle;
+   cmd->state.gfx.is_depth_stencil_dynamic = requires_dynamic_depth_stencil;
+   cmd->state.gfx.dirty |= KK_DIRTY_PIPELINE;
+}
+
+static void
+kk_cmd_bind_shaders(struct vk_command_buffer *cmd_buffer, uint32_t stage_count,
+                    const mesa_shader_stage *stages,
+                    struct vk_shader **const shaders)
+{
+   struct kk_cmd_buffer *cmd =
+      container_of(cmd_buffer, struct kk_cmd_buffer, vk);
+
+   for (uint32_t i = 0; i < stage_count; i++) {
+      struct kk_shader *shader = container_of(shaders[i], struct kk_shader, vk);
+
+      if (stages[i] == MESA_SHADER_COMPUTE || stages[i] == MESA_SHADER_KERNEL)
+         kk_cmd_bind_compute_shader(cmd, shader);
+      else
+         kk_cmd_bind_graphics_shader(cmd, stages[i], shader);
+   }
+}
+
+static VkResult
+kk_shader_get_executable_properties(
+   UNUSED struct vk_device *device, const struct vk_shader *vk_shader,
+   uint32_t *executable_count, VkPipelineExecutablePropertiesKHR *properties)
+{
+   VK_OUTARRAY_MAKE_TYPED(VkPipelineExecutablePropertiesKHR, out, properties,
+                          executable_count);
+
+   return vk_outarray_status(&out);
+}
+
+static VkResult
+kk_shader_get_executable_statistics(
+   UNUSED struct vk_device *device, const struct vk_shader *vk_shader,
+   uint32_t executable_index, uint32_t *statistic_count,
+   VkPipelineExecutableStatisticKHR *statistics)
+{
+   /* TODO_KOSMICKRISP */
+   return VK_SUCCESS;
+}
+
+static VkResult
+kk_shader_get_executable_internal_representations(
+   UNUSED struct vk_device *device, const struct vk_shader *vk_shader,
+   uint32_t executable_index, uint32_t *internal_representation_count,
+   VkPipelineExecutableInternalRepresentationKHR *internal_representations)
+{
+   /* TODO_KOSMICKRISP */
+   return VK_SUCCESS;
+}
+
+static const struct vk_shader_ops kk_shader_ops = {
+   .destroy = kk_shader_destroy,
+   .serialize = kk_shader_serialize,
+   .get_executable_properties = kk_shader_get_executable_properties,
+   .get_executable_statistics = kk_shader_get_executable_statistics,
+   .get_executable_internal_representations =
+      kk_shader_get_executable_internal_representations,
+};
+
+const struct vk_device_shader_ops kk_device_shader_ops = {
+   .get_nir_options = kk_get_nir_options,
+   .get_spirv_options = kk_get_spirv_options,
+   .preprocess_nir = kk_preprocess_nir,
+   .hash_state = kk_hash_graphics_state,
+   .compile =
+      kk_compile_shaders, /* This will only generate the MSL string we need to
+                             use for actual library generation */
+   .deserialize = kk_deserialize_shader,
+   .cmd_set_dynamic_graphics_state = vk_cmd_set_dynamic_graphics_state,
+   .cmd_bind_shaders = kk_cmd_bind_shaders,
+};
\ No newline at end of file
diff --git a/src/kosmickrisp/vulkan/kk_shader.h b/src/kosmickrisp/vulkan/kk_shader.h
new file mode 100644
index 00000000000..6015d81815b
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_shader.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_SHADER_H
+#define KK_SHADER_H 1
+
+#include "kk_device_memory.h"
+#include "kk_private.h"
+
+#include "vk_pipeline_cache.h"
+
+#include "vk_shader.h"
+
+struct kk_shader_info {
+   mesa_shader_stage stage;
+   union {
+      struct {
+         uint32_t attribs_read;
+      } vs;
+
+      struct {
+         struct mtl_size local_size;
+      } cs;
+   };
+};
+
+struct kk_shader {
+   struct vk_shader vk;
+   const char *entrypoint_name;
+   const char *msl_code;
+
+   struct kk_shader_info info;
+
+   /* Pipeline resources. Only stored in compute or vertex shaders */
+   struct {
+      union {
+         struct {
+            mtl_render_pipeline_state *handle;
+            mtl_depth_stencil_state *mtl_depth_stencil_state_handle;
+            enum mtl_primitive_type primitive_type;
+         } gfx;
+         mtl_compute_pipeline_state *cs;
+      };
+   } pipeline;
+};
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(kk_shader, vk.base, VkShaderEXT,
+                               VK_OBJECT_TYPE_SHADER_EXT);
+
+extern const struct vk_device_shader_ops kk_device_shader_ops;
+
+static inline nir_address_format
+kk_buffer_addr_format(VkPipelineRobustnessBufferBehaviorEXT robustness)
+{
+   switch (robustness) {
+   case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT:
+      return nir_address_format_64bit_global_32bit_offset;
+   case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT:
+   case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT:
+      return nir_address_format_64bit_bounded_global;
+   default:
+      UNREACHABLE("Invalid robust buffer access behavior");
+   }
+}
+
+bool
+kk_nir_lower_descriptors(nir_shader *nir,
+                         const struct vk_pipeline_robustness_state *rs,
+                         uint32_t set_layout_count,
+                         struct vk_descriptor_set_layout *const *set_layouts);
+
+bool kk_nir_lower_textures(nir_shader *nir);
+
+bool kk_nir_lower_vs_multiview(nir_shader *nir, uint32_t view_mask);
+bool kk_nir_lower_fs_multiview(nir_shader *nir, uint32_t view_mask);
+
+VkResult kk_compile_nir_shader(struct kk_device *dev, nir_shader *nir,
+                               const VkAllocationCallbacks *alloc,
+                               struct kk_shader **shader_out);
+
+#endif /* KK_SHADER_H */
diff --git a/src/kosmickrisp/vulkan/kk_sync.c b/src/kosmickrisp/vulkan/kk_sync.c
new file mode 100644
index 00000000000..f44200c379e
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_sync.c
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_sync.h"
+
+#include "kk_device.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+static VkResult
+kk_timeline_init(struct vk_device *device, struct vk_sync *sync,
+                 uint64_t initial_value)
+{
+   struct kk_sync_timeline *timeline =
+      container_of(sync, struct kk_sync_timeline, base);
+
+   struct kk_device *dev = container_of(device, struct kk_device, vk);
+   timeline->mtl_handle = mtl_new_shared_event(dev->mtl_handle);
+   mtl_shared_event_set_signaled_value(timeline->mtl_handle, initial_value);
+
+   return VK_SUCCESS;
+}
+
+static void
+kk_timeline_finish(struct vk_device *device, struct vk_sync *sync)
+{
+   struct kk_sync_timeline *timeline =
+      container_of(sync, struct kk_sync_timeline, base);
+   mtl_release(timeline->mtl_handle);
+}
+
+static VkResult
+kk_timeline_signal(struct vk_device *device, struct vk_sync *sync,
+                   uint64_t value)
+{
+   struct kk_sync_timeline *timeline =
+      container_of(sync, struct kk_sync_timeline, base);
+   mtl_shared_event_set_signaled_value(timeline->mtl_handle, value);
+   return VK_SUCCESS;
+}
+
+static VkResult
+kk_timeline_get_value(struct vk_device *device, struct vk_sync *sync,
+                      uint64_t *value)
+{
+   struct kk_sync_timeline *timeline =
+      container_of(sync, struct kk_sync_timeline, base);
+   *value = mtl_shared_event_get_signaled_value(timeline->mtl_handle);
+   return VK_SUCCESS;
+}
+
+static VkResult
+kk_timeline_wait(struct vk_device *device, struct vk_sync *sync,
+                 uint64_t wait_value, enum vk_sync_wait_flags wait_flags,
+                 uint64_t abs_timeout_ns)
+{
+   struct kk_sync_timeline *timeline =
+      container_of(sync, struct kk_sync_timeline, base);
+
+   /* abs_timeout_ns is the point in time when we should stop waiting, not the
+    * absolute time in ns. Therefore, we need to compute the delta from now to
+    * when we should stop waiting and convert to ms for Metal to be happy
+    * (Similar to what dzn does).
+    */
+   uint64_t timeout_ms = 0u;
+   if (abs_timeout_ns == OS_TIMEOUT_INFINITE) {
+      timeout_ms = OS_TIMEOUT_INFINITE;
+   } else {
+      uint64_t cur_time = os_time_get_nano();
+      uint64_t rel_timeout_ns =
+         abs_timeout_ns > cur_time ? abs_timeout_ns - cur_time : 0;
+
+      timeout_ms =
+         (rel_timeout_ns / 1000000) + (rel_timeout_ns % 1000000 ? 1 : 0);
+   }
+   int completed = mtl_shared_event_wait_until_signaled_value(
+      timeline->mtl_handle, wait_value, timeout_ms);
+
+   return completed != 0 ? VK_SUCCESS : VK_TIMEOUT;
+}
+
+const struct vk_sync_type kk_sync_type = {
+   .size = sizeof(struct kk_sync_timeline),
+   .features = VK_SYNC_FEATURE_TIMELINE | VK_SYNC_FEATURE_GPU_WAIT |
+               VK_SYNC_FEATURE_CPU_WAIT | VK_SYNC_FEATURE_CPU_SIGNAL |
+               VK_SYNC_FEATURE_WAIT_PENDING |
+               VK_SYNC_FEATURE_WAIT_BEFORE_SIGNAL,
+   .init = kk_timeline_init,
+   .finish = kk_timeline_finish,
+   .signal = kk_timeline_signal,
+   .get_value = kk_timeline_get_value,
+   .reset = NULL,
+   .move = NULL,
+   .wait = kk_timeline_wait,
+   .wait_many = NULL,
+   .import_opaque_fd = NULL,
+   .export_opaque_fd = NULL,
+   .import_sync_file = NULL,
+   .export_sync_file = NULL,
+   .import_win32_handle = NULL,
+   .export_win32_handle = NULL,
+   .set_win32_export_params = NULL,
+};
diff --git a/src/kosmickrisp/vulkan/kk_sync.h b/src/kosmickrisp/vulkan/kk_sync.h
new file mode 100644
index 00000000000..da4f149918d
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_sync.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_SYNC_TYPES_H
+#define KK_SYNC_TYPES_H 1
+
+#include "kosmickrisp/bridge/mtl_types.h"
+
+#include "vk_sync.h"
+
+struct kk_queue;
+
+struct kk_sync_timeline {
+   struct vk_sync base;
+   mtl_shared_event *mtl_handle;
+};
+
+extern const struct vk_sync_type kk_sync_type;
+
+#endif
diff --git a/src/kosmickrisp/vulkan/kk_wsi.c b/src/kosmickrisp/vulkan/kk_wsi.c
new file mode 100644
index 00000000000..5912e151ef7
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_wsi.c
@@ -0,0 +1,114 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "kk_wsi.h"
+#include "kk_cmd_buffer.h"
+#include "kk_device.h"
+#include "kk_dispatch_trampolines.h"
+#include "kk_image.h"
+#include "kk_instance.h"
+#include "wsi_common.h"
+
+#include "kosmickrisp/bridge/mtl_bridge.h"
+
+static PFN_vkVoidFunction
+kk_instance_get_proc_addr_unchecked(const struct vk_instance *instance,
+                                    const char *name)
+{
+   PFN_vkVoidFunction func;
+
+   if (instance == NULL || name == NULL)
+      return NULL;
+
+   func = vk_instance_dispatch_table_get(&instance->dispatch_table, name);
+   if (func != NULL)
+      return func;
+
+   func = vk_physical_device_dispatch_table_get(&kk_physical_device_trampolines,
+                                                name);
+   if (func != NULL)
+      return func;
+
+   func = vk_device_dispatch_table_get(&kk_device_trampolines, name);
+   if (func != NULL)
+      return func;
+
+   return NULL;
+}
+
+static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+kk_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char *pName)
+{
+   VK_FROM_HANDLE(kk_physical_device, pdev, physicalDevice);
+   return kk_instance_get_proc_addr_unchecked(pdev->vk.instance, pName);
+}
+
+static VkResult
+kk_bind_drawable_to_vkimage(VkImage vk_image, void *drawable)
+{
+   VK_FROM_HANDLE(kk_image, image, vk_image);
+   mtl_texture *texture = mtl_drawable_get_texture(drawable);
+
+   /* This should only be called for swapchain binding. */
+   assert(image->plane_count == 1);
+   struct kk_image_plane *plane = &image->planes[0];
+   if (plane->mtl_handle)
+      mtl_release(plane->mtl_handle);
+   if (plane->mtl_handle_array)
+      mtl_release(plane->mtl_handle_array);
+   plane->mtl_handle = mtl_retain(texture);
+   plane->mtl_handle_array = NULL;
+   plane->addr = mtl_texture_get_gpu_resource_id(texture);
+
+   return VK_SUCCESS;
+}
+
+static void
+kk_encode_drawable_present(VkCommandBuffer vk_cmd, void *drawable)
+{
+   VK_FROM_HANDLE(kk_cmd_buffer, cmd, vk_cmd);
+   mtl_retain(drawable);
+   cmd->drawable = drawable;
+}
+
+static struct vk_queue *
+kk_get_blit_queue(VkDevice device)
+{
+   /* We only have one queue, so just return that one. */
+   VK_FROM_HANDLE(kk_device, dev, device);
+   return &dev->queue.vk;
+}
+
+VkResult
+kk_init_wsi(struct kk_physical_device *pdev)
+{
+   struct wsi_device_options wsi_options = {.sw_device = false};
+   struct wsi_device *wsi = &pdev->wsi_device;
+   VkResult result =
+      wsi_device_init(wsi, kk_physical_device_to_handle(pdev), kk_wsi_proc_addr,
+                      &pdev->vk.instance->alloc,
+                      0u,   // Not relevant for metal wsi
+                      NULL, // Not relevant for metal
+                      &wsi_options);
+   if (result != VK_SUCCESS)
+      return result;
+
+   wsi->metal.bind_drawable_to_vkimage = kk_bind_drawable_to_vkimage;
+   wsi->metal.encode_drawable_present = kk_encode_drawable_present;
+   wsi->get_blit_queue = kk_get_blit_queue;
+
+   pdev->vk.wsi_device = wsi;
+
+   return result;
+}
+
+void
+kk_finish_wsi(struct kk_physical_device *pdev)
+{
+   pdev->vk.wsi_device = NULL;
+   wsi_device_finish(&pdev->wsi_device, &pdev->vk.instance->alloc);
+}
diff --git a/src/kosmickrisp/vulkan/kk_wsi.h b/src/kosmickrisp/vulkan/kk_wsi.h
new file mode 100644
index 00000000000..0a9fbd214b3
--- /dev/null
+++ b/src/kosmickrisp/vulkan/kk_wsi.h
@@ -0,0 +1,16 @@
+/*
+ * Copyright © 2022 Collabora Ltd. and Red Hat Inc.
+ * Copyright 2025 LunarG, Inc.
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KK_WSI_H
+#define KK_WSI_H 1
+
+#include "kk_physical_device.h"
+
+VkResult kk_init_wsi(struct kk_physical_device *pdev);
+void kk_finish_wsi(struct kk_physical_device *pdev);
+
+#endif /* KK_WSI_H */
diff --git a/src/kosmickrisp/vulkan/meson.build b/src/kosmickrisp/vulkan/meson.build
new file mode 100644
index 00000000000..41cfa8a6fec
--- /dev/null
+++ b/src/kosmickrisp/vulkan/meson.build
@@ -0,0 +1,211 @@
+# Copyright 2025 LunarG, Inc.
+# Copyright 2025 Google LLC
+# SPDX-License-Identifier: MIT
+
+kk_device_dispatch_table_dependencies = declare_dependency(
+  sources : [
+    kk_dispatch_trampolines[1],
+  ],
+)
+
+# Unsure if needed, just making sure we don't royally mess up the dependencies
+kk_device_dispatch_table_dependencies_list = [
+  vulkan_lite_runtime_deps,
+  kk_device_dispatch_table_dependencies,
+  idep_nir,
+  idep_mesautil,
+  idep_vulkan_runtime,
+  idep_vulkan_util,
+  idep_vulkan_wsi,
+  idep_vulkan_wsi_headers,
+]
+
+libkk_device_dispatch_table = static_library(
+  'kk_device_dispatch_table',
+  kk_dispatch_trampolines,
+  include_directories : [inc_include, inc_src],
+  dependencies : kk_device_dispatch_table_dependencies_list,
+  c_args : c_msvc_compat_args,
+  gnu_symbol_visibility : 'hidden',
+  build_by_default : false,
+)
+
+idep_kk_device_dispatch_table = declare_dependency(
+  # Instruct users of this library to link with --whole-archive.  Otherwise,
+  # our weak function overloads may not resolve properly.
+  link_whole : [libkk_device_dispatch_table]
+)
+
+kk_files = files(
+  'kk_bo.h',
+  'kk_bo.c',
+  'kk_buffer_view.h',
+  'kk_buffer_view.c',
+  'kk_buffer.h',
+  'kk_buffer.c',
+  'kk_cmd_buffer.h',
+  'kk_cmd_buffer.c',
+  'kk_cmd_clear.c',
+  'kk_cmd_copy.c',
+  'kk_cmd_dispatch.c',
+  'kk_cmd_draw.c',
+  'kk_cmd_meta.c',
+  'kk_cmd_pool.h',
+  'kk_cmd_pool.c',
+  'kk_debug.h',
+  'kk_debug.c',
+  'kk_descriptor_set_layout.h',
+  'kk_descriptor_set_layout.c',
+  'kk_descriptor_set.h',
+  'kk_descriptor_set.c',
+  'kk_device_lib.c',
+  'kk_device_memory.h',
+  'kk_device_memory.c',
+  'kk_device.h',
+  'kk_device.c',
+  'kk_encoder.h',
+  'kk_encoder.c',
+  'kk_event.h',
+  'kk_event.c',
+  'kk_format.h',
+  'kk_format.c',
+  'kk_image_layout.h',
+  'kk_image_layout.c',
+  'kk_image_view.h',
+  'kk_image_view.c',
+  'kk_image.h',
+  'kk_image.c',
+  'kk_instance.h',
+  'kk_instance.c',
+  'kk_nir_lower_descriptors.c',
+  'kk_nir_lower_multiview.c',
+  'kk_nir_lower_textures.c',
+  'kk_nir_lower_vbo.h',
+  'kk_nir_lower_vbo.c',
+  'kk_physical_device.h',
+  'kk_physical_device.c',
+  'kk_query_pool.h',
+  'kk_query_pool.c',
+  'kk_query_table.h',
+  'kk_query_table.c',
+  'kk_queue.h',
+  'kk_queue.c',
+  'kk_sampler.h',
+  'kk_sampler.c',
+  'kk_shader.h',
+  'kk_shader.c',
+  'kk_sync.h',
+  'kk_sync.c',
+  'kk_wsi.h',
+  'kk_wsi.c',
+)
+
+kkcl_files = files(
+  'cl/kk_query.cl',
+  'cl/kk_triangle_fan.cl',
+)
+
+kk_entrypoints = custom_target(
+  'kk_entrypoints',
+  input : [vk_entrypoints_gen, vk_api_xml],
+  output : ['kk_entrypoints.h', 'kk_entrypoints.c'],
+  command : [
+    prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--proto', '--weak',
+    '--out-h', '@OUTPUT0@', '--out-c', '@OUTPUT1@', '--prefix', 'kk',
+    '--beta', with_vulkan_beta.to_string()
+  ],
+  depend_files : vk_entrypoints_gen_depend_files,
+)
+
+relative_dir = fs.relative_to(meson.global_source_root(), meson.global_build_root())
+
+kkcl_spv = custom_target(
+  input : kkcl_files,
+  output : 'kkcl.spv',
+  command : [
+    prog_mesa_clc, '-o', '@OUTPUT@', '--depfile', '@DEPFILE@', kkcl_files, '--',
+    '-I' + join_paths(meson.project_source_root(), 'src/compiler/libcl'),
+    '-I' + join_paths(meson.current_source_dir(), '.'),
+    '-I' + join_paths(meson.project_source_root(), 'src'),
+    cl_args,
+    ],
+  depfile : 'libkk_shaders.h.d',
+)
+
+kkcl = custom_target(
+  input : kkcl_spv,
+  output : ['kkcl.cpp', 'kkcl.h'],
+  command : [prog_vtn_bindgen2, '@INPUT@', '@OUTPUT@'],
+)
+
+kk_deps = [
+  idep_nir,
+  idep_mesautil,
+  idep_vulkan_runtime,
+  idep_vulkan_util,
+  idep_vulkan_wsi,
+  idep_vulkan_wsi_headers,
+  kk_device_dispatch_table_dependencies,
+  idep_kk_device_dispatch_table,
+  idep_msl_to_nir,
+  idep_mtl_bridge
+]
+
+libkk = static_library(
+  'kk',
+  [
+    kk_files,
+    kk_entrypoints,
+    kkcl,
+    sha1_h,
+  ],
+  include_directories : [
+    inc_include,
+    inc_src,
+  ],
+  dependencies : [kk_deps],
+  gnu_symbol_visibility : 'hidden',
+)
+
+# Happens with macOS ld linker:
+# "-Wl,-undefined,dynamic_lookup" required, otherwise, linker will complain about undefined symbols
+libvulkan_kosmickrisp = shared_library(
+  'vulkan_kosmickrisp',
+  link_whole: [libkk],
+  link_args: [ld_args_build_id, '-Wl,-undefined,dynamic_lookup'],
+  gnu_symbol_visibility : 'hidden',
+  install : true,
+)
+
+kosmickrisp_mesa_icd = custom_target(
+  'kosmickrisp_mesa_icd',
+  input : [vk_icd_gen, vk_api_xml],
+  output : 'kosmickrisp_mesa_icd.@0@.json'.format(host_machine.cpu()),
+  command : [
+    prog_python, '@INPUT0@',
+    '--api-version', '1.3', '--xml', '@INPUT1@',
+    '--lib-path', get_option('prefix') / get_option('libdir') / 'libvulkan_kosmickrisp.dylib',
+    '--out', '@OUTPUT@',
+  ],
+  build_by_default : true,
+  install_dir : with_vulkan_icd_dir,
+  install_tag : 'runtime',
+  install : true,
+)
+
+kosmickrisp_icd = custom_target(
+  'kosmickrisp_mesa_devenv_icd',
+  input : [vk_icd_gen, vk_api_xml],
+  output : 'kosmickrisp_mesa_devenv_icd.@0@.json'.format(host_machine.cpu()),
+  command : [
+    prog_python, '@INPUT0@',
+    '--api-version', '1.3', '--xml', '@INPUT1@',
+    '--lib-path', meson.current_build_dir() / 'libvulkan_kosmickrisp.dylib',
+    '--out', '@OUTPUT@',
+  ],
+  build_by_default : true,
+)
+
+devenv.append('VK_DRIVER_FILES', kosmickrisp_icd.full_path())
+# Deprecated: replaced by VK_DRIVER_FILES above
+devenv.append('VK_ICD_FILENAMES', kosmickrisp_icd.full_path())
diff --git a/src/meson.build b/src/meson.build
index d08e26466da..f27dae33631 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -114,6 +114,9 @@ endif
 if with_gallium_asahi or with_asahi_vk or with_tools.contains('asahi')
   subdir('asahi')
 endif
+if with_kosmickrisp_vk
+  subdir('kosmickrisp')
+endif
 if with_gallium
   subdir('mesa')
 endif