diff --git a/src/xrt/auxiliary/vk/vk_bundle_init.c b/src/xrt/auxiliary/vk/vk_bundle_init.c
index e941bcf3e..ac5b66fe6 100644
--- a/src/xrt/auxiliary/vk/vk_bundle_init.c
+++ b/src/xrt/auxiliary/vk/vk_bundle_init.c
@@ -1239,7 +1239,7 @@ vk_create_device(struct vk_bundle *vk,
 	vk->vkGetDeviceQueue(vk->device, vk->queue_family_index, 0, &vk->queue);
 
 	// Need to do this after functions have been gotten.
-	VK_NAME_OBJECT(vk, DEVICE, vk->device, "vk_bundle device");
+	VK_NAME_DEVICE(vk, vk->device, "vk_bundle device");
 
 	return ret;
 
diff --git a/src/xrt/auxiliary/vk/vk_cmd.c b/src/xrt/auxiliary/vk/vk_cmd.c
index d8e67b3cf..fc6116f31 100644
--- a/src/xrt/auxiliary/vk/vk_cmd.c
+++ b/src/xrt/auxiliary/vk/vk_cmd.c
@@ -118,7 +118,7 @@ vk_cmd_end_submit_wait_and_free_cmd_buffer_locked(struct vk_bundle *vk, VkComman
 	}
 
 	// Shortlived, but name for debugging.
-	VK_NAME_OBJECT(vk, FENCE, fence, "VK Submit And Wait");
+	VK_NAME_FENCE(vk, fence, "VK Submit And Wait");
 
 	// Do the submit.
 	VkSubmitInfo submitInfo = {
diff --git a/src/xrt/auxiliary/vk/vk_helpers.h b/src/xrt/auxiliary/vk/vk_helpers.h
index 994031074..d7cd46abb 100644
--- a/src/xrt/auxiliary/vk/vk_helpers.h
+++ b/src/xrt/auxiliary/vk/vk_helpers.h
@@ -630,21 +630,56 @@ vk_name_object(struct vk_bundle *vk, VkObjectType type, uint64_t object, const c
  *
  * @ingroup aux_vk
  */
-#define VK_NAME_OBJECT(VK, TYPE, OBJ, NAME)                                                                            \
+#define VK_NAME_OBJ(VK, TYPE, SUFFIX, OBJ, NAME)                                                                       \
 	do {                                                                                                           \
 		if ((VK)->has_EXT_debug_utils) {                                                                       \
-			vk_name_object(VK, VK_OBJECT_TYPE_##TYPE, (uint64_t)OBJ, NAME);                                \
+			TYPE _thing = OBJ;                                                                             \
+			vk_name_object(VK, VK_OBJECT_TYPE_##SUFFIX, (uint64_t)_thing, NAME);                           \
 		}                                                                                                      \
 	} while (false)
 
+
 #else
 
-#define VK_NAME_OBJECT(vk, TYPE, obj name)                                                                             \
+#define VK_NAME_OBJ(VK, TYPE, SUFFIX, OBJ, NAME)                                                                       \
 	do {                                                                                                           \
+		XRT_MAYBE_UNUSED TYPE _thing = OBJ;                                                                    \
 	} while (false)
 
 #endif
 
+// clang-format off
+#define VK_NAME_INSTANCE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkInstance, INSTANCE, OBJ, NAME)
+#define VK_NAME_PHYSICAL_DEVICE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkPhysicalDevice, PHYSICAL_DEVICE, OBJ, NAME)
+#define VK_NAME_DEVICE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkDevice, DEVICE, OBJ, NAME)
+#define VK_NAME_QUEUE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkQueue, QUEUE, OBJ, NAME)
+#define VK_NAME_SEMAPHORE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkSemaphore, SEMAPHORE, OBJ, NAME)
+#define VK_NAME_COMMAND_BUFFER(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkCommandBuffer, COMMAND_BUFFER, OBJ, NAME)
+#define VK_NAME_FENCE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkFence, FENCE, OBJ, NAME)
+#define VK_NAME_DEVICE_MEMORY(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkDeviceMemory, DEVICE_MEMORY, OBJ, NAME)
+#define VK_NAME_BUFFER(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkBuffer, BUFFER, OBJ, NAME)
+#define VK_NAME_IMAGE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkImage, IMAGE, OBJ, NAME)
+#define VK_NAME_EVENT(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkEvent, EVENT, OBJ, NAME)
+#define VK_NAME_QUERY_POOL(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkQueryPool, QUERY_POOL, OBJ, NAME)
+#define VK_NAME_BUFFER_VIEW(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkBufferView, BUFFER_VIEW, OBJ, NAME)
+#define VK_NAME_IMAGE_VIEW(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkImageView, IMAGE_VIEW, OBJ, NAME)
+#define VK_NAME_SHADER_MODULE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkShaderModule, SHADER_MODULE, OBJ, NAME)
+#define VK_NAME_PIPELINE_CACHE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkPipelineCache, PIPELINE_CACHE, OBJ, NAME)
+#define VK_NAME_PIPELINE_LAYOUT(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkPipelineLayout, PIPELINE_LAYOUT, OBJ, NAME)
+#define VK_NAME_RENDER_PASS(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkRenderPass, RENDER_PASS, OBJ, NAME)
+#define VK_NAME_PIPELINE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkPipeline, PIPELINE, OBJ, NAME)
+#define VK_NAME_DESCRIPTOR_SET_LAYOUT(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkDescriptorSetLayout, DESCRIPTOR_SET_LAYOUT, OBJ, NAME)
+#define VK_NAME_SAMPLER(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkSampler, SAMPLER, OBJ, NAME)
+#define VK_NAME_DESCRIPTOR_POOL(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkDescriptorPool, DESCRIPTOR_POOL, OBJ, NAME)
+#define VK_NAME_DESCRIPTOR_SET(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkDescriptorSet, DESCRIPTOR_SET, OBJ, NAME)
+#define VK_NAME_FRAMEBUFFER(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkFramebuffer, FRAMEBUFFER, OBJ, NAME)
+#define VK_NAME_COMMAND_POOL(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkCommandPool, COMMAND_POOL, OBJ, NAME)
+
+#define VK_NAME_SURFACE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkSurfaceKHR, SURFACE_KHR, OBJ, NAME)
+#define VK_NAME_SWAPCHAIN(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkSwapchainKHR, SWAPCHAIN_KHR, OBJ, NAME)
+// clang-format on
+
+
 /*
  *
  * Printing helpers, in the vk_print.c file.
diff --git a/src/xrt/auxiliary/vk/vk_image_allocator.c b/src/xrt/auxiliary/vk/vk_image_allocator.c
index 67a38d2f4..43ddf396a 100644
--- a/src/xrt/auxiliary/vk/vk_image_allocator.c
+++ b/src/xrt/auxiliary/vk/vk_image_allocator.c
@@ -308,8 +308,8 @@ vk_ic_allocate(struct vk_bundle *vk,
 			break;
 		}
 
-		VK_NAME_OBJECT(vk, IMAGE, out_vkic->images[i].handle, "vk_image_collection image");
-		VK_NAME_OBJECT(vk, DEVICE_MEMORY, out_vkic->images[i].memory, "vk_image_collection device_memory");
+		VK_NAME_IMAGE(vk, out_vkic->images[i].handle, "vk_image_collection image");
+		VK_NAME_DEVICE_MEMORY(vk, out_vkic->images[i].memory, "vk_image_collection device_memory");
 	}
 
 	// Set the fields.
@@ -375,8 +375,8 @@ vk_ic_from_natives(struct vk_bundle *vk,
 			break;
 		}
 
-		VK_NAME_OBJECT(vk, IMAGE, out_vkic->images[i].handle, "vk_image_collection image");
-		VK_NAME_OBJECT(vk, DEVICE_MEMORY, out_vkic->images[i].memory, "vk_image_collection device_memory");
+		VK_NAME_IMAGE(vk, out_vkic->images[i].handle, "vk_image_collection image");
+		VK_NAME_DEVICE_MEMORY(vk, out_vkic->images[i].memory, "vk_image_collection device_memory");
 
 		native_images[i].handle = buf;
 	}
diff --git a/src/xrt/auxiliary/vk/vk_image_readback_to_xf_pool.c b/src/xrt/auxiliary/vk/vk_image_readback_to_xf_pool.c
index 3ed5365e8..86a6904e9 100644
--- a/src/xrt/auxiliary/vk/vk_image_readback_to_xf_pool.c
+++ b/src/xrt/auxiliary/vk/vk_image_readback_to_xf_pool.c
@@ -69,8 +69,8 @@ vk_xf_readback_pool_try_create_new_frame(struct vk_bundle *vk, struct vk_image_r
 	    &memory,                             //
 	    &image);                             //
 
-	VK_NAME_OBJECT(vk, DEVICE_MEMORY, memory, "vk_image_readback_to_xf_pool device memory");
-	VK_NAME_OBJECT(vk, IMAGE, image, "vk_image_readback_to_xf_pool image");
+	VK_NAME_DEVICE_MEMORY(vk, memory, "vk_image_readback_to_xf_pool device memory");
+	VK_NAME_IMAGE(vk, image, "vk_image_readback_to_xf_pool image");
 
 	(void)res;
 
diff --git a/src/xrt/auxiliary/vk/vk_sync_objects.c b/src/xrt/auxiliary/vk/vk_sync_objects.c
index d671019b8..cec3bf83d 100644
--- a/src/xrt/auxiliary/vk/vk_sync_objects.c
+++ b/src/xrt/auxiliary/vk/vk_sync_objects.c
@@ -135,7 +135,7 @@ vk_create_and_submit_fence_native(struct vk_bundle *vk, xrt_graphics_sync_handle
 	}
 
 	// Won't be returned, but name for debbuging.
-	VK_NAME_OBJECT(vk, FENCE, fence, "VK Create Submit Sync");
+	VK_NAME_FENCE(vk, fence, "VK Create Submit Sync");
 
 
 	/*
@@ -352,7 +352,7 @@ vk_create_fence_sync_from_native(struct vk_bundle *vk, xrt_graphics_sync_handle_
 	}
 
 	// Should be overwritten by caller, but name here for debugging.
-	VK_NAME_OBJECT(vk, FENCE, fence, "VK Import");
+	VK_NAME_FENCE(vk, fence, "VK Import");
 
 
 #ifdef XRT_GRAPHICS_SYNC_HANDLE_IS_FD
diff --git a/src/xrt/compositor/client/comp_vk_client.c b/src/xrt/compositor/client/comp_vk_client.c
index e871eeab4..2ad837849 100644
--- a/src/xrt/compositor/client/comp_vk_client.c
+++ b/src/xrt/compositor/client/comp_vk_client.c
@@ -119,7 +119,7 @@ setup_semaphore(struct client_vk_compositor *c)
 		return XRT_ERROR_VULKAN;
 	}
 
-	VK_NAME_OBJECT(vk, SEMAPHORE, semaphore, "timeline semaphore");
+	VK_NAME_SEMAPHORE(vk, semaphore, "timeline semaphore");
 
 	c->sync.semaphore = semaphore;
 	c->sync.xcsem = xcsem; // No need to reference.
@@ -672,8 +672,8 @@ client_vk_swapchain_create(struct xrt_compositor *xc,
 			return XRT_ERROR_VULKAN;
 		}
 
-		VK_NAME_OBJECT(vk, IMAGE, sc->base.images[i], "vk_image_collection image");
-		VK_NAME_OBJECT(vk, DEVICE_MEMORY, sc->mems[i], "vk_image_collection device_memory");
+		VK_NAME_IMAGE(vk, sc->base.images[i], "vk_image_collection image");
+		VK_NAME_DEVICE_MEMORY(vk, sc->mems[i], "vk_image_collection device_memory");
 	}
 
 	vk_cmd_pool_lock(&c->pool);
@@ -686,13 +686,13 @@ client_vk_swapchain_create(struct xrt_compositor *xc,
 			vk_cmd_pool_unlock(&c->pool);
 			return XRT_ERROR_VULKAN;
 		}
-		VK_NAME_OBJECT(vk, COMMAND_BUFFER, sc->acquire[i], "client_vk_swapchain acquire command buffer");
+		VK_NAME_COMMAND_BUFFER(vk, sc->acquire[i], "client_vk_swapchain acquire command buffer");
 		ret = vk_cmd_pool_create_and_begin_cmd_buffer_locked(vk, &c->pool, flags, &sc->release[i]);
 		if (ret != VK_SUCCESS) {
 			vk_cmd_pool_unlock(&c->pool);
 			return XRT_ERROR_VULKAN;
 		}
-		VK_NAME_OBJECT(vk, COMMAND_BUFFER, sc->release[i], "client_vk_swapchain release command buffer");
+		VK_NAME_COMMAND_BUFFER(vk, sc->release[i], "client_vk_swapchain release command buffer");
 
 		VkImageSubresourceRange subresource_range = {
 		    .aspectMask = barrier_aspect_mask,
@@ -846,7 +846,7 @@ client_vk_compositor_create(struct xrt_compositor_native *xcn,
 		goto err_mutex;
 	}
 
-	VK_NAME_OBJECT(&c->vk, COMMAND_POOL, c->pool.pool, "client_vk_compositor command pool");
+	VK_NAME_COMMAND_POOL(&c->vk, c->pool.pool, "client_vk_compositor command pool");
 
 #ifdef VK_KHR_timeline_semaphore
 	if (vk_can_import_and_export_timeline_semaphore(&c->vk)) {
diff --git a/src/xrt/compositor/main/comp_mirror_to_debug_gui.c b/src/xrt/compositor/main/comp_mirror_to_debug_gui.c
index b535e0998..58d12425c 100644
--- a/src/xrt/compositor/main/comp_mirror_to_debug_gui.c
+++ b/src/xrt/compositor/main/comp_mirror_to_debug_gui.c
@@ -184,7 +184,7 @@ ensure_scratch(struct comp_mirror_to_debug_gui *m, struct vk_bundle *vk)
 		return false;
 	}
 
-	VK_NAME_OBJECT(vk, IMAGE_VIEW, m->bounce.unorm_view, "comp_mirror_debug_to_gui image view bounce.unorm_view");
+	VK_NAME_IMAGE_VIEW(vk, m->bounce.unorm_view, "comp_mirror_debug_to_gui image view bounce.unorm_view");
 
 	return true;
 }
@@ -299,7 +299,7 @@ comp_mirror_init(struct comp_mirror_to_debug_gui *m,
 		return ret;
 	}
 
-	VK_NAME_OBJECT(vk, COMMAND_POOL, m->cmd_pool.pool, "comp_mirror_to_debug_gui command pool");
+	VK_NAME_COMMAND_POOL(vk, m->cmd_pool.pool, "comp_mirror_to_debug_gui command pool");
 
 	struct vk_descriptor_pool_info blit_pool_info = {
 	    .uniform_per_descriptor_count = 0,
@@ -315,23 +315,23 @@ comp_mirror_init(struct comp_mirror_to_debug_gui *m,
 	    &blit_pool_info,            // info
 	    &m->blit.descriptor_pool)); // out_descriptor_pool
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_POOL, m->blit.descriptor_pool, "comp_mirror_to_debug_ui blit descriptor pool");
+	VK_NAME_DESCRIPTOR_POOL(vk, m->blit.descriptor_pool, "comp_mirror_to_debug_ui blit descriptor pool");
 
 	C(vk_create_pipeline_cache(vk, &m->blit.pipeline_cache));
 
-	VK_NAME_OBJECT(vk, PIPELINE_CACHE, m->blit.pipeline_cache, "comp_mirror_to_debug_ui blit pipeline cache");
+	VK_NAME_PIPELINE_CACHE(vk, m->blit.pipeline_cache, "comp_mirror_to_debug_ui blit pipeline cache");
 
 	C(create_blit_descriptor_set_layout(vk, &m->blit.descriptor_set_layout));
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, m->blit.descriptor_set_layout,
-	               "comp_mirror_to_debug_ui blit descriptor set layout");
+	VK_NAME_DESCRIPTOR_SET_LAYOUT(vk, m->blit.descriptor_set_layout,
+	                              "comp_mirror_to_debug_ui blit descriptor set layout");
 
 	C(create_blit_pipeline_layout(     //
 	    vk,                            // vk_bundle
 	    m->blit.descriptor_set_layout, // descriptor_set_layout
 	    &m->blit.pipeline_layout));    // out_pipeline_layout
 
-	VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, m->blit.pipeline_layout, "comp_mirror_to_debug_ui blit pipeline layout");
+	VK_NAME_PIPELINE_LAYOUT(vk, m->blit.pipeline_layout, "comp_mirror_to_debug_ui blit pipeline layout");
 
 	C(vk_create_compute_pipeline( //
 	    vk,                       // vk_bundle
@@ -341,7 +341,7 @@ comp_mirror_init(struct comp_mirror_to_debug_gui *m,
 	    NULL,                     // specialization_info
 	    &m->blit.pipeline));      // out_compute_pipeline
 
-	VK_NAME_OBJECT(vk, PIPELINE, m->blit.pipeline, "comp_mirror_to_debug_ui blit pipeline");
+	VK_NAME_PIPELINE(vk, m->blit.pipeline, "comp_mirror_to_debug_ui blit pipeline");
 
 	return VK_SUCCESS;
 }
@@ -446,7 +446,7 @@ comp_mirror_do_blit(struct comp_mirror_to_debug_gui *m,
 		return;
 	}
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_SET, descriptor_set, "comp_mirror_to_debug_ui blit descriptor set");
+	VK_NAME_DESCRIPTOR_SET(vk, descriptor_set, "comp_mirror_to_debug_ui blit descriptor set");
 
 	struct vk_cmd_pool *pool = &m->cmd_pool;
 
@@ -461,7 +461,7 @@ comp_mirror_do_blit(struct comp_mirror_to_debug_gui *m,
 		return;
 	}
 
-	VK_NAME_OBJECT(vk, COMMAND_BUFFER, cmd, "comp_mirror_to_debug_ui command buffer");
+	VK_NAME_COMMAND_BUFFER(vk, cmd, "comp_mirror_to_debug_ui command buffer");
 
 	// Barrier arguments.
 	VkImageSubresourceRange first_color_level_subresource_range = {
diff --git a/src/xrt/compositor/main/comp_renderer.c b/src/xrt/compositor/main/comp_renderer.c
index fdfaf2526..aeab6d4e5 100644
--- a/src/xrt/compositor/main/comp_renderer.c
+++ b/src/xrt/compositor/main/comp_renderer.c
@@ -363,7 +363,7 @@ renderer_create_renderings_and_fences(struct comp_renderer *r)
 
 		char buf[] = "Comp Renderer X_XXXX_XXXX";
 		snprintf(buf, ARRAY_SIZE(buf), "Comp Renderer %u", i);
-		VK_NAME_OBJECT(vk, FENCE, r->fences[i], buf);
+		VK_NAME_FENCE(vk, r->fences[i], buf);
 	}
 }
 
diff --git a/src/xrt/compositor/main/comp_target_swapchain.c b/src/xrt/compositor/main/comp_target_swapchain.c
index 7c9cfcd85..bc3cd15b1 100644
--- a/src/xrt/compositor/main/comp_target_swapchain.c
+++ b/src/xrt/compositor/main/comp_target_swapchain.c
@@ -131,7 +131,7 @@ create_image_views(struct comp_target_swapchain *cts)
 		    &cts->base.images[i].view); // out_view
 
 
-		VK_NAME_OBJECT(vk, IMAGE_VIEW, cts->base.images[i].view, "comp_target_swapchain image view");
+		VK_NAME_IMAGE_VIEW(vk, cts->base.images[i].view, "comp_target_swapchain image view");
 	}
 
 	free(images);
@@ -452,7 +452,7 @@ vblank_event_func(struct comp_target *ct, uint64_t *out_timestamp_ns)
 	}
 
 	// Name for debugging.
-	VK_NAME_OBJECT(vk, FENCE, vblank_event_fence, "Comp VBlank");
+	VK_NAME_FENCE(vk, vblank_event_fence, "Comp VBlank");
 
 	// Not scoped to not effect timing.
 	COMP_TRACE_IDENT(vblank);
@@ -604,8 +604,8 @@ target_init_semaphores(struct comp_target_swapchain *cts)
 		COMP_ERROR(cts->base.c, "vkCreateSemaphore: %s", vk_result_string(ret));
 	}
 
-	VK_NAME_OBJECT(vk, SEMAPHORE, cts->base.semaphores.present_complete,
-	               "comp_target_swapchain semaphore present complete");
+	VK_NAME_SEMAPHORE(vk, cts->base.semaphores.present_complete,
+	                  "comp_target_swapchain semaphore present complete");
 
 	cts->base.semaphores.render_complete_is_timeline = false;
 	ret = vk->vkCreateSemaphore(vk->device, &info, NULL, &cts->base.semaphores.render_complete);
@@ -613,8 +613,7 @@ target_init_semaphores(struct comp_target_swapchain *cts)
 		COMP_ERROR(cts->base.c, "vkCreateSemaphore: %s", vk_result_string(ret));
 	}
 
-	VK_NAME_OBJECT(vk, SEMAPHORE, cts->base.semaphores.render_complete,
-	               "comp_target_swapchain semaphore render complete");
+	VK_NAME_SEMAPHORE(vk, cts->base.semaphores.render_complete, "comp_target_swapchain semaphore render complete");
 }
 
 
@@ -791,7 +790,7 @@ comp_target_swapchain_create_images(struct comp_target *ct,
 		return;
 	}
 
-	VK_NAME_OBJECT(vk, SWAPCHAIN_KHR, cts->swapchain.handle, "comp_target_swapchain swapchain");
+	VK_NAME_SWAPCHAIN(vk, cts->swapchain.handle, "comp_target_swapchain swapchain");
 
 	/*
 	 * Set target info.
diff --git a/src/xrt/compositor/main/comp_window_android.c b/src/xrt/compositor/main/comp_window_android.c
index 8f98a1a5e..6b01c2d4f 100644
--- a/src/xrt/compositor/main/comp_window_android.c
+++ b/src/xrt/compositor/main/comp_window_android.c
@@ -125,7 +125,7 @@ comp_window_android_create_surface(struct comp_window_android *cwa,
 		return ret;
 	}
 
-	VK_NAME_OBJECT(vk, SURFACE_KHR, surface, "comp_window_android surface");
+	VK_NAME_SURFACE(vk, surface, "comp_window_android surface");
 	*out_surface = surface;
 
 	return VK_SUCCESS;
diff --git a/src/xrt/compositor/main/comp_window_direct.c b/src/xrt/compositor/main/comp_window_direct.c
index 3cda95125..92d4449a0 100644
--- a/src/xrt/compositor/main/comp_window_direct.c
+++ b/src/xrt/compositor/main/comp_window_direct.c
@@ -268,7 +268,7 @@ comp_window_direct_create_surface(struct comp_target_swapchain *cts,
 		return ret;
 	}
 
-	VK_NAME_OBJECT(get_vk(cts), SURFACE_KHR, surface, "comp_target_swapchain direct surface");
+	VK_NAME_SURFACE(vk, surface, "comp_target_swapchain direct surface");
 	cts->surface.handle = surface;
 
 	return VK_SUCCESS;
diff --git a/src/xrt/compositor/main/comp_window_mswin.c b/src/xrt/compositor/main/comp_window_mswin.c
index 63c334a5d..0377f0ab1 100644
--- a/src/xrt/compositor/main/comp_window_mswin.c
+++ b/src/xrt/compositor/main/comp_window_mswin.c
@@ -167,7 +167,7 @@ comp_window_mswin_create_surface(struct comp_window_mswin *w, VkSurfaceKHR *out_
 		return ret;
 	}
 
-	VK_NAME_OBJECT(vk, SURFACE_KHR, surface, "comp_window_mswin surface");
+	VK_NAME_SURFACE(vk, surface, "comp_window_mswin surface");
 	*out_surface = surface;
 
 	return VK_SUCCESS;
diff --git a/src/xrt/compositor/main/comp_window_peek.c b/src/xrt/compositor/main/comp_window_peek.c
index a713600b0..e5db2ca26 100644
--- a/src/xrt/compositor/main/comp_window_peek.c
+++ b/src/xrt/compositor/main/comp_window_peek.c
@@ -152,7 +152,7 @@ comp_window_peek_create(struct comp_compositor *c)
 		goto err_free;
 	}
 
-	VK_NAME_OBJECT(vk, COMMAND_POOL, w->pool.pool, "comp_window_peek command pool");
+	VK_NAME_COMMAND_POOL(vk, w->pool.pool, "comp_window_peek command pool");
 
 	ret = vk_cmd_pool_create_cmd_buffer(vk, &w->pool, &w->cmd);
 	if (ret != VK_SUCCESS) {
@@ -160,7 +160,7 @@ comp_window_peek_create(struct comp_compositor *c)
 		goto err_pool;
 	}
 
-	VK_NAME_OBJECT(vk, COMMAND_BUFFER, w->cmd, "comp_window_peek command buffer");
+	VK_NAME_COMMAND_BUFFER(vk, w->cmd, "comp_window_peek command buffer");
 
 
 	/*
diff --git a/src/xrt/compositor/main/comp_window_wayland.c b/src/xrt/compositor/main/comp_window_wayland.c
index eebda8fb1..96b1216f2 100644
--- a/src/xrt/compositor/main/comp_window_wayland.c
+++ b/src/xrt/compositor/main/comp_window_wayland.c
@@ -238,7 +238,7 @@ comp_window_wayland_create_surface(struct comp_window_wayland *w, VkSurfaceKHR *
 		return ret;
 	}
 
-	VK_NAME_OBJECT(vk, SURFACE_KHR, surface, "comp_window_wayland surface");
+	VK_NAME_SURFACE(vk, surface, "comp_window_wayland surface");
 	*out_surface = surface;
 
 	return VK_SUCCESS;
diff --git a/src/xrt/compositor/main/comp_window_xcb.c b/src/xrt/compositor/main/comp_window_xcb.c
index a8732d096..08056d12a 100644
--- a/src/xrt/compositor/main/comp_window_xcb.c
+++ b/src/xrt/compositor/main/comp_window_xcb.c
@@ -423,7 +423,7 @@ comp_window_xcb_create_surface(struct comp_window_xcb *w, VkSurfaceKHR *out_surf
 		return ret;
 	}
 
-	VK_NAME_OBJECT(vk, SURFACE_KHR, surface, "comp_window_xcb surface");
+	VK_NAME_SURFACE(vk, surface, "comp_window_xcb surface");
 	*out_surface = surface;
 
 	return VK_SUCCESS;
diff --git a/src/xrt/compositor/render/render_compute.c b/src/xrt/compositor/render/render_compute.c
index 839a2cfb9..31236b94b 100644
--- a/src/xrt/compositor/render/render_compute.c
+++ b/src/xrt/compositor/render/render_compute.c
@@ -328,8 +328,7 @@ render_compute_init(struct render_compute *crc, struct render_resources *r)
 		    &crc->layer_descriptor_sets[i]);        // descriptor_set
 		VK_CHK_WITH_RET(ret, "vk_create_descriptor_set", false);
 
-		VK_NAME_OBJECT(vk, DESCRIPTOR_SET, crc->layer_descriptor_sets[i],
-		               "render_compute layer descriptor set");
+		VK_NAME_DESCRIPTOR_SET(vk, crc->layer_descriptor_sets[i], "render_compute layer descriptor set");
 	}
 
 	ret = vk_create_descriptor_set(                  //
@@ -339,7 +338,7 @@ render_compute_init(struct render_compute *crc, struct render_resources *r)
 	    &crc->shared_descriptor_set);                // descriptor_set
 	VK_CHK_WITH_RET(ret, "vk_create_descriptor_set", false);
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_SET, crc->shared_descriptor_set, "render_compute shared descriptor set");
+	VK_NAME_DESCRIPTOR_SET(vk, crc->shared_descriptor_set, "render_compute shared descriptor set");
 
 	return true;
 }
diff --git a/src/xrt/compositor/render/render_distortion.c b/src/xrt/compositor/render/render_distortion.c
index fc8e465d9..f7096a5b0 100644
--- a/src/xrt/compositor/render/render_distortion.c
+++ b/src/xrt/compositor/render/render_distortion.c
@@ -47,8 +47,8 @@ create_distortion_image_and_view(struct vk_bundle *vk,
 	    &image);                                                      // out_image
 	VK_CHK_AND_RET(ret, "vk_create_image_simple");
 
-	VK_NAME_OBJECT(vk, DEVICE_MEMORY, device_memory, "distortion device_memory");
-	VK_NAME_OBJECT(vk, IMAGE, image, "distortion image");
+	VK_NAME_DEVICE_MEMORY(vk, device_memory, "distortion device_memory");
+	VK_NAME_IMAGE(vk, image, "distortion image");
 
 	VkImageSubresourceRange subresource_range = {
 	    .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
@@ -67,7 +67,7 @@ create_distortion_image_and_view(struct vk_bundle *vk,
 	    &image_view);      // out_image_view
 	VK_CHK_WITH_GOTO(ret, "vk_create_view", err_free);
 
-	VK_NAME_OBJECT(vk, IMAGE_VIEW, image_view, "distortion image view");
+	VK_NAME_IMAGE_VIEW(vk, image_view, "distortion image view");
 
 	*out_device_memory = device_memory;
 	*out_image = image;
@@ -221,13 +221,13 @@ create_and_fill_in_distortion_buffer_for_view(struct vk_bundle *vk,
 
 	ret = render_buffer_init(vk, r_buffer, usage_flags, properties, size);
 	VK_CHK_WITH_GOTO(ret, "render_buffer_init", err_buffers);
-	VK_NAME_OBJECT(vk, BUFFER, r_buffer->buffer, "distortion r_buffer");
+	VK_NAME_BUFFER(vk, r_buffer->buffer, "distortion r_buffer");
 	ret = render_buffer_init(vk, g_buffer, usage_flags, properties, size);
 	VK_CHK_WITH_GOTO(ret, "render_buffer_init", err_buffers);
-	VK_NAME_OBJECT(vk, BUFFER, g_buffer->buffer, "distortion g_buffer");
+	VK_NAME_BUFFER(vk, g_buffer->buffer, "distortion g_buffer");
 	ret = render_buffer_init(vk, b_buffer, usage_flags, properties, size);
 	VK_CHK_WITH_GOTO(ret, "render_buffer_init", err_buffers);
-	VK_NAME_OBJECT(vk, BUFFER, b_buffer->buffer, "distortion b_buffer");
+	VK_NAME_BUFFER(vk, b_buffer->buffer, "distortion b_buffer");
 
 	ret = render_buffer_map(vk, r_buffer);
 	VK_CHK_WITH_GOTO(ret, "render_buffer_map", err_buffers);
@@ -324,7 +324,7 @@ render_distortion_buffer_init(struct render_resources *r,
 
 	ret = vk_cmd_pool_create_and_begin_cmd_buffer_locked(vk, pool, 0, &upload_buffer);
 	VK_CHK_WITH_GOTO(ret, "vk_cmd_pool_create_and_begin_cmd_buffer_locked", err_unlock);
-	VK_NAME_OBJECT(vk, COMMAND_BUFFER, upload_buffer, "render_resources distortion command buffer");
+	VK_NAME_COMMAND_BUFFER(vk, upload_buffer, "render_resources distortion command buffer");
 
 	for (uint32_t i = 0; i < RENDER_DISTORTION_NUM_IMAGES; i++) {
 		ret = create_and_queue_upload_locked( //
diff --git a/src/xrt/compositor/render/render_gfx.c b/src/xrt/compositor/render/render_gfx.c
index e3cce6c38..7c9e15246 100644
--- a/src/xrt/compositor/render/render_gfx.c
+++ b/src/xrt/compositor/render/render_gfx.c
@@ -714,7 +714,7 @@ render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp,
 	    final_layout,                  // final_layout
 	    &rgrp->render_pass);           // out_render_pass
 	VK_CHK_WITH_RET(ret, "create_implicit_render_pass", false);
-	VK_NAME_OBJECT(vk, RENDER_PASS, rgrp->render_pass, "render_gfx_render_pass render pass");
+	VK_NAME_RENDER_PASS(vk, rgrp->render_pass, "render_gfx_render_pass render pass");
 
 	struct mesh_params simple_params = {
 	    .do_timewarp = false,
@@ -733,7 +733,7 @@ render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp,
 	    r->shaders->mesh_frag,     // mesh_frag
 	    &rgrp->mesh.pipeline);     // out_mesh_pipeline
 	VK_CHK_WITH_RET(ret, "create_mesh_pipeline", false);
-	VK_NAME_OBJECT(vk, PIPELINE, rgrp->mesh.pipeline, "render_gfx_render_pass mesh pipeline");
+	VK_NAME_PIPELINE(vk, rgrp->mesh.pipeline, "render_gfx_render_pass mesh pipeline");
 
 	struct mesh_params timewarp_params = {
 	    .do_timewarp = true,
@@ -752,7 +752,7 @@ render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp,
 	    r->shaders->mesh_frag,          // mesh_frag
 	    &rgrp->mesh.pipeline_timewarp); // out_mesh_pipeline
 	VK_CHK_WITH_RET(ret, "create_mesh_pipeline", false);
-	VK_NAME_OBJECT(vk, PIPELINE, rgrp->mesh.pipeline_timewarp, "render_gfx_render_pass mesh pipeline timewarp");
+	VK_NAME_PIPELINE(vk, rgrp->mesh.pipeline_timewarp, "render_gfx_render_pass mesh pipeline timewarp");
 
 	const VkBlendFactor blend_factor_premultiplied_alpha = VK_BLEND_FACTOR_ONE;
 	const VkBlendFactor blend_factor_unpremultiplied_alpha = VK_BLEND_FACTOR_SRC_ALPHA;
@@ -768,8 +768,8 @@ render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp,
 	    r->shaders->layer_cylinder_frag,            // module_frag
 	    &rgrp->layer.cylinder_premultiplied_alpha); // out_pipeline
 	VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
-	VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.cylinder_premultiplied_alpha,
-	               "render_gfx_render_pass cylinder premultiplied alpha");
+	VK_NAME_PIPELINE(vk, rgrp->layer.cylinder_premultiplied_alpha,
+	                 "render_gfx_render_pass cylinder premultiplied alpha");
 
 	ret = create_layer_pipeline(                      //
 	    vk,                                           // vk
@@ -781,8 +781,8 @@ render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp,
 	    r->shaders->layer_cylinder_frag,              // module_frag
 	    &rgrp->layer.cylinder_unpremultiplied_alpha); // out_pipeline
 	VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
-	VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.cylinder_unpremultiplied_alpha,
-	               "render_gfx_render_pass cylinder unpremultiplied alpha");
+	VK_NAME_PIPELINE(vk, rgrp->layer.cylinder_unpremultiplied_alpha,
+	                 "render_gfx_render_pass cylinder unpremultiplied alpha");
 
 	// Equirect2
 	ret = create_layer_pipeline(                     //
@@ -795,8 +795,8 @@ render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp,
 	    r->shaders->layer_equirect2_frag,            // module_frag
 	    &rgrp->layer.equirect2_premultiplied_alpha); // out_pipeline
 	VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
-	VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.equirect2_premultiplied_alpha,
-	               "render_gfx_render_pass equirect2 premultiplied alpha");
+	VK_NAME_PIPELINE(vk, rgrp->layer.equirect2_premultiplied_alpha,
+	                 "render_gfx_render_pass equirect2 premultiplied alpha");
 
 	ret = create_layer_pipeline(                       //
 	    vk,                                            // vk
@@ -808,8 +808,8 @@ render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp,
 	    r->shaders->layer_equirect2_frag,              // module_frag
 	    &rgrp->layer.equirect2_unpremultiplied_alpha); // out_pipeline
 	VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
-	VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.equirect2_unpremultiplied_alpha,
-	               "render_gfx_render_pass equirect2 unpremultiplied alpha");
+	VK_NAME_PIPELINE(vk, rgrp->layer.equirect2_unpremultiplied_alpha,
+	                 "render_gfx_render_pass equirect2 unpremultiplied alpha");
 
 	// Projection.
 	ret = create_layer_pipeline(                //
@@ -822,8 +822,8 @@ render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp,
 	    r->shaders->layer_shared_frag,          // module_frag
 	    &rgrp->layer.proj_premultiplied_alpha); // out_pipeline
 	VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
-	VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.proj_premultiplied_alpha,
-	               "render_gfx_render_pass projection premultiplied alpha");
+	VK_NAME_PIPELINE(vk, rgrp->layer.proj_premultiplied_alpha,
+	                 "render_gfx_render_pass projection premultiplied alpha");
 
 	ret = create_layer_pipeline(                  //
 	    vk,                                       // vk
@@ -835,8 +835,8 @@ render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp,
 	    r->shaders->layer_shared_frag,            // module_frag
 	    &rgrp->layer.proj_unpremultiplied_alpha); // out_pipeline
 	VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
-	VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.proj_unpremultiplied_alpha,
-	               "render_gfx_render_pass projection unpremultiplied alpha");
+	VK_NAME_PIPELINE(vk, rgrp->layer.proj_unpremultiplied_alpha,
+	                 "render_gfx_render_pass projection unpremultiplied alpha");
 
 	// Quad
 	ret = create_layer_pipeline(                //
@@ -849,8 +849,7 @@ render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp,
 	    r->shaders->layer_shared_frag,          // module_frag
 	    &rgrp->layer.quad_premultiplied_alpha); // out_pipeline
 	VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
-	VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.quad_premultiplied_alpha,
-	               "render_gfx_render_pass quad premultiplied alpha");
+	VK_NAME_PIPELINE(vk, rgrp->layer.quad_premultiplied_alpha, "render_gfx_render_pass quad premultiplied alpha");
 
 	ret = create_layer_pipeline(                  //
 	    vk,                                       // vk
@@ -862,8 +861,8 @@ render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp,
 	    r->shaders->layer_shared_frag,            // module_frag
 	    &rgrp->layer.quad_unpremultiplied_alpha); // out_pipeline
 	VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
-	VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.quad_unpremultiplied_alpha,
-	               "render_gfx_render_pass quad unpremultiplied alpha");
+	VK_NAME_PIPELINE(vk, rgrp->layer.quad_unpremultiplied_alpha,
+	                 "render_gfx_render_pass quad unpremultiplied alpha");
 
 	// Set fields.
 	rgrp->r = r;
@@ -922,7 +921,7 @@ render_gfx_target_resources_init(struct render_gfx_target_resources *rtr,
 	    extent.height,        // height,
 	    &rtr->framebuffer);   // out_external_framebuffer
 	VK_CHK_WITH_RET(ret, "create_framebuffer", false);
-	VK_NAME_OBJECT(vk, FRAMEBUFFER, rtr->framebuffer, "render_gfx_target_resources framebuffer");
+	VK_NAME_FRAMEBUFFER(vk, rtr->framebuffer, "render_gfx_target_resources framebuffer");
 
 	// Set fields.
 	rtr->rgrp = rgrp;
diff --git a/src/xrt/compositor/render/render_resources.c b/src/xrt/compositor/render/render_resources.c
index f497be400..a59d74e8c 100644
--- a/src/xrt/compositor/render/render_resources.c
+++ b/src/xrt/compositor/render/render_resources.c
@@ -108,7 +108,7 @@ init_mesh_vertex_buffers(struct vk_bundle *vk,
 	    memory_property_flags, // memory_property_flags
 	    vbo_size);             // size
 	VK_CHK_WITH_RET(ret, "render_buffer_init", false);
-	VK_NAME_OBJECT(vk, BUFFER, vbo->buffer, "mesh vbo");
+	VK_NAME_BUFFER(vk, vbo->buffer, "mesh vbo");
 
 	ret = render_buffer_write( //
 	    vk,                    // vk_bundle
@@ -130,7 +130,7 @@ init_mesh_vertex_buffers(struct vk_bundle *vk,
 	    memory_property_flags, // memory_property_flags
 	    ibo_size);             // size
 	VK_CHK_WITH_RET(ret, "render_buffer_init", false);
-	VK_NAME_OBJECT(vk, BUFFER, ibo->buffer, "mesh ibo");
+	VK_NAME_BUFFER(vk, ibo->buffer, "mesh ibo");
 
 	ret = render_buffer_write( //
 	    vk,                    // vk_bundle
@@ -161,7 +161,7 @@ init_mesh_ubo_buffers(struct vk_bundle *vk, struct render_buffer *l_ubo, struct
 	                         memory_property_flags, //
 	                         ubo_size);             // size
 	VK_CHK_WITH_RET(ret, "render_buffer_init", false);
-	VK_NAME_OBJECT(vk, BUFFER, l_ubo->buffer, "mesh l_ubo");
+	VK_NAME_BUFFER(vk, l_ubo->buffer, "mesh l_ubo");
 
 	ret = render_buffer_map(vk, l_ubo);
 	VK_CHK_WITH_RET(ret, "render_buffer_map", false);
@@ -172,7 +172,7 @@ init_mesh_ubo_buffers(struct vk_bundle *vk, struct render_buffer *l_ubo, struct
 	                         memory_property_flags, //
 	                         ubo_size);             // size
 	VK_CHK_WITH_RET(ret, "render_buffer_init", false);
-	VK_NAME_OBJECT(vk, BUFFER, r_ubo->buffer, "mesh r_ubo");
+	VK_NAME_BUFFER(vk, r_ubo->buffer, "mesh r_ubo");
 
 	ret = render_buffer_map(vk, r_ubo);
 	VK_CHK_WITH_RET(ret, "render_buffer_map", false);
@@ -452,8 +452,8 @@ create_scratch_image_and_view(struct vk_bundle *vk, VkExtent2D extent, struct re
 	    &image);                        // out_image
 	VK_CHK_WITH_RET(ret, "vk_create_image_mutable_rgba", false);
 
-	VK_NAME_OBJECT(vk, DEVICE_MEMORY, device_memory, "render_scratch_color_image device_memory");
-	VK_NAME_OBJECT(vk, IMAGE, image, "render_scratch_color_image image");
+	VK_NAME_DEVICE_MEMORY(vk, device_memory, "render_scratch_color_image device_memory");
+	VK_NAME_IMAGE(vk, image, "render_scratch_color_image image");
 
 	VkImageSubresourceRange subresource_range = {
 	    .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
@@ -473,7 +473,7 @@ create_scratch_image_and_view(struct vk_bundle *vk, VkExtent2D extent, struct re
 	    &srgb_view);            // out_image_view
 	VK_CHK_WITH_RET(ret, "vk_create_view_usage", false);
 
-	VK_NAME_OBJECT(vk, IMAGE_VIEW, srgb_view, "render_scratch_color_image image view srgb");
+	VK_NAME_IMAGE_VIEW(vk, srgb_view, "render_scratch_color_image image view srgb");
 
 	ret = vk_create_view_usage( //
 	    vk,                     // vk_bundle
@@ -485,7 +485,7 @@ create_scratch_image_and_view(struct vk_bundle *vk, VkExtent2D extent, struct re
 	    &unorm_view);           // out_image_view
 	VK_CHK_WITH_RET(ret, "vk_create_view_usage", false);
 
-	VK_NAME_OBJECT(vk, IMAGE_VIEW, unorm_view, "render_scratch_color_image image view unorm");
+	VK_NAME_IMAGE_VIEW(vk, unorm_view, "render_scratch_color_image image view unorm");
 
 	rsci->device_memory = device_memory;
 	rsci->image = image;
@@ -564,7 +564,7 @@ render_resources_init(struct render_resources *r,
 	    &r->samplers.mock);                    // out_sampler
 	VK_CHK_WITH_RET(ret, "vk_create_sampler", false);
 
-	VK_NAME_OBJECT(vk, SAMPLER, r->samplers.mock, "render_resources sampler mock");
+	VK_NAME_SAMPLER(vk, r->samplers.mock, "render_resources sampler mock");
 
 	ret = vk_create_sampler(            //
 	    vk,                             // vk_bundle
@@ -572,7 +572,7 @@ render_resources_init(struct render_resources *r,
 	    &r->samplers.repeat);           // out_sampler
 	VK_CHK_WITH_RET(ret, "vk_create_sampler", false);
 
-	VK_NAME_OBJECT(vk, SAMPLER, r->samplers.repeat, "render_resources sampler repeat");
+	VK_NAME_SAMPLER(vk, r->samplers.repeat, "render_resources sampler repeat");
 
 	ret = vk_create_sampler(                   //
 	    vk,                                    // vk_bundle
@@ -580,7 +580,7 @@ render_resources_init(struct render_resources *r,
 	    &r->samplers.clamp_to_edge);           // out_sampler
 	VK_CHK_WITH_RET(ret, "vk_create_sampler", false);
 
-	VK_NAME_OBJECT(vk, SAMPLER, r->samplers.clamp_to_edge, "render_resources sampler clamp_to_edge");
+	VK_NAME_SAMPLER(vk, r->samplers.clamp_to_edge, "render_resources sampler clamp_to_edge");
 
 	ret = vk_create_sampler(                     //
 	    vk,                                      // vk_bundle
@@ -588,8 +588,7 @@ render_resources_init(struct render_resources *r,
 	    &r->samplers.clamp_to_border_black);     // out_sampler
 	VK_CHK_WITH_RET(ret, "vk_create_sampler", false);
 
-	VK_NAME_OBJECT(vk, SAMPLER, r->samplers.clamp_to_border_black,
-	               "render_resources sampler clamp_to_border_black");
+	VK_NAME_SAMPLER(vk, r->samplers.clamp_to_border_black, "render_resources sampler clamp_to_border_black");
 
 
 	/*
@@ -599,7 +598,7 @@ render_resources_init(struct render_resources *r,
 	ret = vk_cmd_pool_init(vk, &r->distortion_pool, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT);
 	VK_CHK_WITH_RET(ret, "vk_cmd_pool_init", false);
 
-	VK_NAME_OBJECT(vk, COMMAND_POOL, r->distortion_pool.pool, "render_resources distortion command pool");
+	VK_NAME_COMMAND_POOL(vk, r->distortion_pool.pool, "render_resources distortion command pool");
 
 	VkCommandPoolCreateInfo command_pool_info = {
 	    .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
@@ -610,7 +609,7 @@ render_resources_init(struct render_resources *r,
 	ret = vk->vkCreateCommandPool(vk->device, &command_pool_info, NULL, &r->cmd_pool);
 	VK_CHK_WITH_RET(ret, "vkCreateCommandPool", false);
 
-	VK_NAME_OBJECT(vk, COMMAND_POOL, r->cmd_pool, "render_resources command pool");
+	VK_NAME_COMMAND_POOL(vk, r->cmd_pool, "render_resources command pool");
 
 
 	/*
@@ -639,8 +638,8 @@ render_resources_init(struct render_resources *r,
 		    &r->mock.color.image);    // out_image
 		VK_CHK_WITH_RET(ret, "vk_create_image_simple", false);
 
-		VK_NAME_OBJECT(vk, DEVICE_MEMORY, r->mock.color.memory, "render_resources mock color device memory");
-		VK_NAME_OBJECT(vk, IMAGE, r->mock.color.image, "render_resources mock color image");
+		VK_NAME_DEVICE_MEMORY(vk, r->mock.color.memory, "render_resources mock color device memory");
+		VK_NAME_IMAGE(vk, r->mock.color.image, "render_resources mock color image");
 
 		ret = vk_create_view(           //
 		    vk,                         // vk_bundle
@@ -651,14 +650,14 @@ render_resources_init(struct render_resources *r,
 		    &r->mock.color.image_view); // out_view
 		VK_CHK_WITH_RET(ret, "vk_create_view", false);
 
-		VK_NAME_OBJECT(vk, IMAGE_VIEW, r->mock.color.image_view, "render_resources mock color image view");
+		VK_NAME_IMAGE_VIEW(vk, r->mock.color.image_view, "render_resources mock color image view");
 
 
 		VkCommandBuffer cmd = VK_NULL_HANDLE;
 		ret = vk_cmd_create_and_begin_cmd_buffer_locked(vk, r->cmd_pool, 0, &cmd);
 		VK_CHK_WITH_RET(ret, "vk_cmd_create_and_begin_cmd_buffer_locked", false);
 
-		VK_NAME_OBJECT(vk, COMMAND_BUFFER, cmd, "render_resources mock command buffer");
+		VK_NAME_COMMAND_BUFFER(vk, cmd, "render_resources mock command buffer");
 
 		ret = prepare_mock_image_locked( //
 		    vk,                          // vk_bundle
@@ -680,7 +679,7 @@ render_resources_init(struct render_resources *r,
 	ret = vk_create_pipeline_cache(vk, &r->pipeline_cache);
 	VK_CHK_WITH_RET(ret, "vk_create_pipeline_cache", false);
 
-	VK_NAME_OBJECT(vk, PIPELINE_CACHE, r->pipeline_cache, "render_resources pipeline cache");
+	VK_NAME_PIPELINE_CACHE(vk, r->pipeline_cache, "render_resources pipeline cache");
 
 	VkCommandBufferAllocateInfo cmd_buffer_info = {
 	    .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
@@ -695,7 +694,7 @@ render_resources_init(struct render_resources *r,
 	    &r->cmd);                       // pCommandBuffers
 	VK_CHK_WITH_RET(ret, "vkAllocateCommandBuffers", false);
 
-	VK_NAME_OBJECT(vk, COMMAND_BUFFER, r->cmd, "render_resources command buffer");
+	VK_NAME_COMMAND_BUFFER(vk, r->cmd, "render_resources command buffer");
 
 
 	/*
@@ -724,8 +723,8 @@ render_resources_init(struct render_resources *r,
 		    &r->gfx.ubo_and_src_descriptor_pool); // out_descriptor_pool
 		VK_CHK_WITH_RET(ret, "vk_create_descriptor_pool", false);
 
-		VK_NAME_OBJECT(vk, DESCRIPTOR_POOL, r->gfx.ubo_and_src_descriptor_pool,
-		               "render_resources ubo and src descriptor pool");
+		VK_NAME_DESCRIPTOR_POOL(vk, r->gfx.ubo_and_src_descriptor_pool,
+		                        "render_resources ubo and src descriptor pool");
 
 		VkBufferUsageFlags usage_flags = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
 		VkMemoryPropertyFlags memory_property_flags = //
@@ -753,7 +752,7 @@ render_resources_init(struct render_resources *r,
 		    memory_property_flags, // memory_property_flags
 		    size);                 // size
 		VK_CHK_WITH_RET(ret, "render_buffer_init", false);
-		VK_NAME_OBJECT(vk, BUFFER, r->gfx.shared_ubo.buffer, "render_resources gfx shared ubo");
+		VK_NAME_BUFFER(vk, r->gfx.shared_ubo.buffer, "render_resources gfx shared ubo");
 
 		ret = render_buffer_map( //
 		    vk,                  // vk_bundle
@@ -773,8 +772,8 @@ render_resources_init(struct render_resources *r,
 	    &r->gfx.layer.shared.descriptor_set_layout);    // out_descriptor_set_layout
 	VK_CHK_WITH_RET(ret, "create_gfx_ubo_and_src_descriptor_set_layout", false);
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, r->gfx.layer.shared.descriptor_set_layout,
-	               "render_resources gfx layer shared descriptor set layout");
+	VK_NAME_DESCRIPTOR_SET_LAYOUT(vk, r->gfx.layer.shared.descriptor_set_layout,
+	                              "render_resources gfx layer shared descriptor set layout");
 
 	ret = vk_create_pipeline_layout(               //
 	    vk,                                        // vk_bundle
@@ -782,8 +781,8 @@ render_resources_init(struct render_resources *r,
 	    &r->gfx.layer.shared.pipeline_layout);     // out_pipeline_layout
 	VK_CHK_WITH_RET(ret, "vk_create_pipeline_layout", false);
 
-	VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, r->gfx.layer.shared.pipeline_layout,
-	               "render_resources gfx layer shared pipeline layout");
+	VK_NAME_PIPELINE_LAYOUT(vk, r->gfx.layer.shared.pipeline_layout,
+	                        "render_resources gfx layer shared pipeline layout");
 
 
 	/*
@@ -797,8 +796,7 @@ render_resources_init(struct render_resources *r,
 	    &r->mesh.descriptor_set_layout);                // out_mesh_descriptor_set_layout
 	VK_CHK_WITH_RET(ret, "create_gfx_ubo_and_src_descriptor_set_layout", false);
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, r->mesh.descriptor_set_layout,
-	               "render_resources mesh descriptor set layout");
+	VK_NAME_DESCRIPTOR_SET_LAYOUT(vk, r->mesh.descriptor_set_layout, "render_resources mesh descriptor set layout");
 
 	ret = vk_create_pipeline_layout(   //
 	    vk,                            // vk_bundle
@@ -806,7 +804,7 @@ render_resources_init(struct render_resources *r,
 	    &r->mesh.pipeline_layout);     // out_pipeline_layout
 	VK_CHK_WITH_RET(ret, "vk_create_pipeline_layout", false);
 
-	VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, r->mesh.pipeline_layout, "render_resources mesh pipeline layout");
+	VK_NAME_PIPELINE_LAYOUT(vk, r->mesh.pipeline_layout, "render_resources mesh pipeline layout");
 
 	bret = init_mesh_vertex_buffers(     //
 	    vk,                              //
@@ -858,7 +856,7 @@ render_resources_init(struct render_resources *r,
 	    &r->compute.descriptor_pool); // out_descriptor_pool
 	VK_CHK_WITH_RET(ret, "vk_create_descriptor_pool", false);
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_POOL, r->compute.descriptor_pool, "render_resources compute descriptor pool");
+	VK_NAME_DESCRIPTOR_POOL(vk, r->compute.descriptor_pool, "render_resources compute descriptor pool");
 
 	/*
 	 * Layer pipeline
@@ -873,8 +871,8 @@ render_resources_init(struct render_resources *r,
 	    &r->compute.layer.descriptor_set_layout);     // out_descriptor_set_layout
 	VK_CHK_WITH_RET(ret, "create_compute_layer_descriptor_set_layout", false);
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, r->compute.layer.descriptor_set_layout,
-	               "render_resources compute layer descriptor set layout");
+	VK_NAME_DESCRIPTOR_SET_LAYOUT(vk, r->compute.layer.descriptor_set_layout,
+	                              "render_resources compute layer descriptor set layout");
 
 	ret = vk_create_pipeline_layout(            //
 	    vk,                                     // vk_bundle
@@ -882,8 +880,7 @@ render_resources_init(struct render_resources *r,
 	    &r->compute.layer.pipeline_layout);     // out_pipeline_layout
 	VK_CHK_WITH_RET(ret, "vk_create_pipeline_layout", false);
 
-	VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, r->compute.layer.pipeline_layout,
-	               "render_resources compute layer pipeline layout");
+	VK_NAME_PIPELINE_LAYOUT(vk, r->compute.layer.pipeline_layout, "render_resources compute layer pipeline layout");
 
 	struct compute_layer_params layer_params = {
 	    .do_timewarp = false,
@@ -901,8 +898,8 @@ render_resources_init(struct render_resources *r,
 	    &r->compute.layer.non_timewarp_pipeline); // out_compute_pipeline
 	VK_CHK_WITH_RET(ret, "create_compute_layer_pipeline", false);
 
-	VK_NAME_OBJECT(vk, PIPELINE, r->compute.layer.non_timewarp_pipeline,
-	               "render_resources compute layer non timewarp pipeline");
+	VK_NAME_PIPELINE(vk, r->compute.layer.non_timewarp_pipeline,
+	                 "render_resources compute layer non timewarp pipeline");
 
 	struct compute_layer_params layer_timewarp_params = {
 	    .do_timewarp = true,
@@ -920,8 +917,7 @@ render_resources_init(struct render_resources *r,
 	    &r->compute.layer.timewarp_pipeline); // out_compute_pipeline
 	VK_CHK_WITH_RET(ret, "create_compute_layer_pipeline", false);
 
-	VK_NAME_OBJECT(vk, PIPELINE, r->compute.layer.timewarp_pipeline,
-	               "render_resources compute layer timewarp pipeline");
+	VK_NAME_PIPELINE(vk, r->compute.layer.timewarp_pipeline, "render_resources compute layer timewarp pipeline");
 
 	size_t layer_ubo_size = sizeof(struct render_compute_layer_ubo_data);
 
@@ -933,7 +929,7 @@ render_resources_init(struct render_resources *r,
 		    memory_property_flags,     // memory_property_flags
 		    layer_ubo_size);           // size
 		VK_CHK_WITH_RET(ret, "render_buffer_init", false);
-		VK_NAME_OBJECT(vk, BUFFER, r->compute.layer.ubos[i].buffer, "render_resources compute layer ubo");
+		VK_NAME_BUFFER(vk, r->compute.layer.ubos[i].buffer, "render_resources compute layer ubo");
 
 		ret = render_buffer_map(        //
 		    vk,                         // vk_bundle
@@ -955,8 +951,8 @@ render_resources_init(struct render_resources *r,
 	    &r->compute.distortion.descriptor_set_layout);     // out_descriptor_set_layout
 	VK_CHK_WITH_RET(ret, "create_compute_distortion_descriptor_set_layout", false);
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, r->compute.distortion.descriptor_set_layout,
-	               "render_resources compute distortion descriptor set layout");
+	VK_NAME_DESCRIPTOR_SET_LAYOUT(vk, r->compute.distortion.descriptor_set_layout,
+	                              "render_resources compute distortion descriptor set layout");
 
 	ret = vk_create_pipeline_layout(                 //
 	    vk,                                          // vk_bundle
@@ -964,8 +960,8 @@ render_resources_init(struct render_resources *r,
 	    &r->compute.distortion.pipeline_layout);     // out_pipeline_layout
 	VK_CHK_WITH_RET(ret, "vk_create_pipeline_layout", false);
 
-	VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, r->compute.distortion.pipeline_layout,
-	               "render_resources compute distortion pipeline layout");
+	VK_NAME_PIPELINE_LAYOUT(vk, r->compute.distortion.pipeline_layout,
+	                        "render_resources compute distortion pipeline layout");
 
 	struct compute_distortion_params distortion_params = {
 	    .distortion_texel_count = RENDER_DISTORTION_IMAGE_DIMENSIONS,
@@ -981,7 +977,7 @@ render_resources_init(struct render_resources *r,
 	    &r->compute.distortion.pipeline);      // out_compute_pipeline
 	VK_CHK_WITH_RET(ret, "create_compute_distortion_pipeline", false);
 
-	VK_NAME_OBJECT(vk, PIPELINE, r->compute.distortion.pipeline, "render_resources compute distortion pipeline");
+	VK_NAME_PIPELINE(vk, r->compute.distortion.pipeline, "render_resources compute distortion pipeline");
 
 	struct compute_distortion_params distortion_timewarp_params = {
 	    .distortion_texel_count = RENDER_DISTORTION_IMAGE_DIMENSIONS,
@@ -997,8 +993,8 @@ render_resources_init(struct render_resources *r,
 	    &r->compute.distortion.timewarp_pipeline); // out_compute_pipeline
 	VK_CHK_WITH_RET(ret, "create_compute_distortion_pipeline", false);
 
-	VK_NAME_OBJECT(vk, PIPELINE, r->compute.distortion.timewarp_pipeline,
-	               "render_resources compute distortion timewarp pipeline");
+	VK_NAME_PIPELINE(vk, r->compute.distortion.timewarp_pipeline,
+	                 "render_resources compute distortion timewarp pipeline");
 
 	size_t distortion_ubo_size = sizeof(struct render_compute_distortion_ubo_data);
 
@@ -1009,7 +1005,7 @@ render_resources_init(struct render_resources *r,
 	    memory_property_flags,      // memory_property_flags
 	    distortion_ubo_size);       // size
 	VK_CHK_WITH_RET(ret, "render_buffer_init", false);
-	VK_NAME_OBJECT(vk, BUFFER, r->compute.distortion.ubo.buffer, "render_resources compute distortion ubo");
+	VK_NAME_BUFFER(vk, r->compute.distortion.ubo.buffer, "render_resources compute distortion ubo");
 	ret = render_buffer_map(         //
 	    vk,                          // vk_bundle
 	    &r->compute.distortion.ubo); // buffer
@@ -1029,7 +1025,7 @@ render_resources_init(struct render_resources *r,
 	    &r->compute.clear.pipeline);           // out_compute_pipeline
 	VK_CHK_WITH_RET(ret, "vk_create_compute_pipeline", false);
 
-	VK_NAME_OBJECT(vk, PIPELINE, r->compute.clear.pipeline, "render_resources compute clear pipeline");
+	VK_NAME_PIPELINE(vk, r->compute.clear.pipeline, "render_resources compute clear pipeline");
 
 	size_t clear_ubo_size = sizeof(struct render_compute_distortion_ubo_data);
 
@@ -1040,7 +1036,7 @@ render_resources_init(struct render_resources *r,
 	    memory_property_flags, // memory_property_flags
 	    clear_ubo_size);       // size
 	VK_CHK_WITH_RET(ret, "render_buffer_init", false);
-	VK_NAME_OBJECT(vk, BUFFER, r->compute.clear.ubo.buffer, "render_resources compute clear ubo");
+	VK_NAME_BUFFER(vk, r->compute.clear.ubo.buffer, "render_resources compute clear ubo");
 
 	ret = render_buffer_map(    //
 	    vk,                     // vk_bundle
@@ -1082,7 +1078,7 @@ render_resources_init(struct render_resources *r,
 	    NULL,              // pAllocator
 	    &r->query_pool);   // pQueryPool
 
-	VK_NAME_OBJECT(vk, QUERY_POOL, r->query_pool, "render_resources query pool");
+	VK_NAME_QUERY_POOL(vk, r->query_pool, "render_resources query pool");
 
 	/*
 	 * Done
diff --git a/src/xrt/compositor/render/render_shaders.c b/src/xrt/compositor/render/render_shaders.c
index 64c3a89b9..b5fa0a9f1 100644
--- a/src/xrt/compositor/render/render_shaders.c
+++ b/src/xrt/compositor/render/render_shaders.c
@@ -70,7 +70,7 @@
 			render_shaders_close(s, vk);                                                                   \
 			return false;                                                                                  \
 		}                                                                                                      \
-		VK_NAME_OBJECT(vk, SHADER_MODULE, s->SHADER, #SHADER);                                                 \
+		VK_NAME_SHADER_MODULE(vk, s->SHADER, #SHADER);                                                         \
 	} while (false)
 
 
diff --git a/src/xrt/compositor/util/comp_render_gfx.c b/src/xrt/compositor/util/comp_render_gfx.c
index d95e5376f..4ad4f80d4 100644
--- a/src/xrt/compositor/util/comp_render_gfx.c
+++ b/src/xrt/compositor/util/comp_render_gfx.c
@@ -220,7 +220,7 @@ do_cylinder_layer(struct render_gfx *rr,
 	    &descriptor_set);                            // out_descriptor_set
 	VK_CHK_AND_RET(ret, "render_gfx_layer_quad_alloc_and_write");
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_SET, descriptor_set, "render_gfx layer quad descriptor set");
+	VK_NAME_DESCRIPTOR_SET(vk, descriptor_set, "render_gfx layer quad descriptor set");
 
 	add_layer(state, layer_data, descriptor_set);
 
@@ -284,7 +284,7 @@ do_equirect2_layer(struct render_gfx *rr,
 	    &descriptor_set);                             // out_descriptor_set
 	VK_CHK_AND_RET(ret, "render_gfx_layer_quad_alloc_and_write");
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_SET, descriptor_set, "render_gfx layer quad descriptor set");
+	VK_NAME_DESCRIPTOR_SET(vk, descriptor_set, "render_gfx layer quad descriptor set");
 
 	add_layer(state, layer_data, descriptor_set);
 
@@ -346,7 +346,7 @@ do_projection_layer(struct render_gfx *rr,
 	    &descriptor_set);                              // out_descriptor_set
 	VK_CHK_AND_RET(ret, "render_gfx_layer_projection_alloc_and_write");
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_SET, descriptor_set, "render_gfx layer quad descriptor set");
+	VK_NAME_DESCRIPTOR_SET(vk, descriptor_set, "render_gfx layer quad descriptor set");
 
 	add_layer(state, layer_data, descriptor_set);
 
@@ -397,7 +397,7 @@ do_quad_layer(struct render_gfx *rr,
 	    &descriptor_set);                        // out_descriptor_set
 	VK_CHK_AND_RET(ret, "render_gfx_layer_quad_alloc_and_write");
 
-	VK_NAME_OBJECT(vk, DESCRIPTOR_SET, descriptor_set, "render_gfx layer quad descriptor set");
+	VK_NAME_DESCRIPTOR_SET(vk, descriptor_set, "render_gfx layer quad descriptor set");
 
 	add_layer(state, layer_data, descriptor_set);
 
@@ -638,7 +638,7 @@ do_mesh(struct render_gfx *rr,
 		    &descriptor_sets[i]);              //
 		VK_CHK_WITH_GOTO(ret, "render_gfx_mesh_alloc", err_no_memory);
 
-		VK_NAME_OBJECT(vk, DESCRIPTOR_SET, descriptor_sets[i], "render_gfx mesh descriptor sets");
+		VK_NAME_DESCRIPTOR_SET(vk, descriptor_sets[i], "render_gfx mesh descriptor sets");
 	}
 
 
diff --git a/src/xrt/compositor/util/comp_semaphore.c b/src/xrt/compositor/util/comp_semaphore.c
index 71571f1dc..5563d1b7c 100644
--- a/src/xrt/compositor/util/comp_semaphore.c
+++ b/src/xrt/compositor/util/comp_semaphore.c
@@ -97,7 +97,7 @@ comp_semaphore_create(struct vk_bundle *vk,
 		return XRT_ERROR_VULKAN;
 	}
 
-	VK_NAME_OBJECT(vk, SEMAPHORE, semaphore, "comp_semaphore timeline");
+	VK_NAME_SEMAPHORE(vk, semaphore, "comp_semaphore timeline");
 
 	struct comp_semaphore *csem = U_TYPED_CALLOC(struct comp_semaphore);
 
diff --git a/src/xrt/compositor/util/comp_swapchain.c b/src/xrt/compositor/util/comp_swapchain.c
index d118527d9..00d937b9a 100644
--- a/src/xrt/compositor/util/comp_swapchain.c
+++ b/src/xrt/compositor/util/comp_swapchain.c
@@ -292,8 +292,7 @@ do_post_create_vulkan_setup(struct vk_bundle *vk,
 			    subresource_range,                  // subresource_range
 			    &sc->images[i].views.alpha[layer]); // out_view
 
-			VK_NAME_OBJECT(vk, IMAGE_VIEW, sc->images[i].views.alpha[layer],
-			               "comp_swapchain views alpha layer");
+			VK_NAME_IMAGE_VIEW(vk, sc->images[i].views.alpha[layer], "comp_swapchain views alpha layer");
 
 			vk_create_view_swizzle(                    //
 			    vk,                                    // vk
@@ -304,8 +303,8 @@ do_post_create_vulkan_setup(struct vk_bundle *vk,
 			    components,                            // components
 			    &sc->images[i].views.no_alpha[layer]); // out_view
 
-			VK_NAME_OBJECT(vk, IMAGE_VIEW, sc->images[i].views.no_alpha[layer],
-			               "comp_swapchain views no alpha layer");
+			VK_NAME_IMAGE_VIEW(vk, sc->images[i].views.no_alpha[layer],
+			                   "comp_swapchain views no alpha layer");
 		}
 	}
 
@@ -335,7 +334,7 @@ do_post_create_vulkan_setup(struct vk_bundle *vk,
 		return;
 	}
 
-	VK_NAME_OBJECT(vk, COMMAND_BUFFER, cmd_buffer, "comp_swapchain command buffer");
+	VK_NAME_COMMAND_BUFFER(vk, cmd_buffer, "comp_swapchain command buffer");
 
 	VkImageAspectFlagBits image_barrier_aspect = vk_csci_get_barrier_aspect_mask(image_view_format);
 
diff --git a/src/xrt/compositor/util/comp_sync.c b/src/xrt/compositor/util/comp_sync.c
index 9652a389a..6a4ffb833 100644
--- a/src/xrt/compositor/util/comp_sync.c
+++ b/src/xrt/compositor/util/comp_sync.c
@@ -109,7 +109,7 @@ comp_fence_import(struct vk_bundle *vk, xrt_graphics_sync_handle_t handle, struc
 	}
 
 	// Name for debugging.
-	VK_NAME_OBJECT(vk, FENCE, fence, "Comp Sync");
+	VK_NAME_FENCE(vk, fence, "Comp Sync");
 
 	struct fence *f = U_TYPED_CALLOC(struct fence);
 	f->base.wait = fence_wait;
diff --git a/src/xrt/compositor/util/comp_vulkan.c b/src/xrt/compositor/util/comp_vulkan.c
index e384ac6dd..f90943cc0 100644
--- a/src/xrt/compositor/util/comp_vulkan.c
+++ b/src/xrt/compositor/util/comp_vulkan.c
@@ -232,7 +232,7 @@ create_instance(struct vk_bundle *vk, const struct comp_vulkan_arguments *vk_arg
 		return ret;
 	}
 
-	VK_NAME_OBJECT(vk, INSTANCE, vk->instance, "monado vulkan instance");
+	VK_NAME_INSTANCE(vk, vk->instance, "monado vulkan instance");
 
 	/*
 	 * Post creation setup of Vulkan bundle.