diff --git a/examples/graphics_context.zig b/examples/graphics_context.zig
index 651c3f5..1817d51 100644
--- a/examples/graphics_context.zig
+++ b/examples/graphics_context.zig
@@ -108,7 +108,7 @@ pub const GraphicsContext = struct {
             .api_version = vk.API_VERSION_1_2,
         };
 
-        self.instance = try self.vkb.createInstance(.{
+        self.instance = try self.vkb.createInstance(&.{
             .flags = .{},
             .p_application_info = &app_info,
             .enabled_layer_count = 0,
@@ -160,7 +160,7 @@ pub const GraphicsContext = struct {
     }
 
     pub fn allocate(self: GraphicsContext, requirements: vk.MemoryRequirements, flags: vk.MemoryPropertyFlags) !vk.DeviceMemory {
-        return try self.vkd.allocateMemory(self.dev, .{
+        return try self.vkd.allocateMemory(self.dev, &.{
             .allocation_size = requirements.size,
             .memory_type_index = try self.findMemoryTypeIndex(requirements.memory_type_bits, flags),
         }, null);
@@ -210,7 +210,7 @@ fn initializeCandidate(vki: InstanceDispatch, candidate: DeviceCandidate) !vk.De
     else
         2;
 
-    return try vki.createDevice(candidate.pdev, .{
+    return try vki.createDevice(candidate.pdev, &.{
         .flags = .{},
         .queue_create_info_count = queue_count,
         .p_queue_create_infos = &qci,
diff --git a/examples/swapchain.zig b/examples/swapchain.zig
index 2043770..10dd61c 100644
--- a/examples/swapchain.zig
+++ b/examples/swapchain.zig
@@ -40,10 +40,13 @@ pub const Swapchain = struct {
             image_count = std.math.min(image_count, caps.max_image_count);
         }
 
-        const concurrent = gc.graphics_queue.family != gc.present_queue.family;
         const qfi = [_]u32{ gc.graphics_queue.family, gc.present_queue.family };
+        const sharing_mode: vk.SharingMode = if (gc.graphics_queue.family != gc.present_queue.family)
+            .concurrent
+        else
+            .exclusive;
 
-        const handle = try gc.vkd.createSwapchainKHR(gc.dev, .{
+        const handle = try gc.vkd.createSwapchainKHR(gc.dev, &.{
             .flags = .{},
             .surface = gc.surface,
             .min_image_count = image_count,
@@ -52,7 +55,7 @@ pub const Swapchain = struct {
             .image_extent = actual_extent,
             .image_array_layers = 1,
             .image_usage = .{ .color_attachment_bit = true, .transfer_dst_bit = true },
-            .image_sharing_mode = if (concurrent) .concurrent else .exclusive,
+            .image_sharing_mode = sharing_mode,
             .queue_family_index_count = qfi.len,
             .p_queue_family_indices = &qfi,
             .pre_transform = caps.current_transform,
@@ -71,7 +74,7 @@ pub const Swapchain = struct {
         const swap_images = try initSwapchainImages(gc, handle, surface_format.format, allocator);
         errdefer for (swap_images) |si| si.deinit(gc);
 
-        var next_image_acquired = try gc.vkd.createSemaphore(gc.dev, .{ .flags = .{} }, null);
+        var next_image_acquired = try gc.vkd.createSemaphore(gc.dev, &.{ .flags = .{} }, null);
         errdefer gc.vkd.destroySemaphore(gc.dev, next_image_acquired, null);
 
         const result = try gc.vkd.acquireNextImageKHR(gc.dev, handle, std.math.maxInt(u64), next_image_acquired, .null_handle);
@@ -159,7 +162,7 @@ pub const Swapchain = struct {
         }}, current.frame_fence);
 
         // Step 3: Present the current frame
-        _ = try self.gc.vkd.queuePresentKHR(self.gc.present_queue.handle, .{
+        _ = try self.gc.vkd.queuePresentKHR(self.gc.present_queue.handle, &.{
             .wait_semaphore_count = 1,
             .p_wait_semaphores = @ptrCast([*]const vk.Semaphore, &current.render_finished),
             .swapchain_count = 1,
@@ -196,7 +199,7 @@ const SwapImage = struct {
     frame_fence: vk.Fence,
 
     fn init(gc: *const GraphicsContext, image: vk.Image, format: vk.Format) !SwapImage {
-        const view = try gc.vkd.createImageView(gc.dev, .{
+        const view = try gc.vkd.createImageView(gc.dev, &.{
             .flags = .{},
             .image = image,
             .view_type = .@"2d",
@@ -212,13 +215,13 @@ const SwapImage = struct {
         }, null);
         errdefer gc.vkd.destroyImageView(gc.dev, view, null);
 
-        const image_acquired = try gc.vkd.createSemaphore(gc.dev, .{ .flags = .{} }, null);
+        const image_acquired = try gc.vkd.createSemaphore(gc.dev, &.{ .flags = .{} }, null);
         errdefer gc.vkd.destroySemaphore(gc.dev, image_acquired, null);
 
-        const render_finished = try gc.vkd.createSemaphore(gc.dev, .{ .flags = .{} }, null);
+        const render_finished = try gc.vkd.createSemaphore(gc.dev, &.{ .flags = .{} }, null);
         errdefer gc.vkd.destroySemaphore(gc.dev, image_acquired, null);
 
-        const frame_fence = try gc.vkd.createFence(gc.dev, .{ .flags = .{ .signaled_bit = true } }, null);
+        const frame_fence = try gc.vkd.createFence(gc.dev, &.{ .flags = .{ .signaled_bit = true } }, null);
         errdefer gc.vkd.destroyFence(gc.dev, frame_fence, null);
 
         return SwapImage{
diff --git a/examples/triangle.zig b/examples/triangle.zig
index 61889bb..06ff6ca 100644
--- a/examples/triangle.zig
+++ b/examples/triangle.zig
@@ -66,7 +66,7 @@ pub fn main() !void {
     var swapchain = try Swapchain.init(&gc, allocator, extent);
     defer swapchain.deinit();
 
-    const pipeline_layout = try gc.vkd.createPipelineLayout(gc.dev, .{
+    const pipeline_layout = try gc.vkd.createPipelineLayout(gc.dev, &.{
         .flags = .{},
         .set_layout_count = 0,
         .p_set_layouts = undefined,
@@ -84,13 +84,13 @@ pub fn main() !void {
     var framebuffers = try createFramebuffers(&gc, allocator, render_pass, swapchain);
     defer destroyFramebuffers(&gc, allocator, framebuffers);
 
-    const pool = try gc.vkd.createCommandPool(gc.dev, .{
+    const pool = try gc.vkd.createCommandPool(gc.dev, &.{
         .flags = .{},
         .queue_family_index = gc.graphics_queue.family,
     }, null);
     defer gc.vkd.destroyCommandPool(gc.dev, pool, null);
 
-    const buffer = try gc.vkd.createBuffer(gc.dev, .{
+    const buffer = try gc.vkd.createBuffer(gc.dev, &.{
         .flags = .{},
         .size = @sizeOf(@TypeOf(vertices)),
         .usage = .{ .transfer_dst_bit = true, .vertex_buffer_bit = true },
@@ -158,7 +158,7 @@ pub fn main() !void {
 }
 
 fn uploadVertices(gc: *const GraphicsContext, pool: vk.CommandPool, buffer: vk.Buffer) !void {
-    const staging_buffer = try gc.vkd.createBuffer(gc.dev, .{
+    const staging_buffer = try gc.vkd.createBuffer(gc.dev, &.{
         .flags = .{},
         .size = @sizeOf(@TypeOf(vertices)),
         .usage = .{ .transfer_src_bit = true },
@@ -187,14 +187,14 @@ fn uploadVertices(gc: *const GraphicsContext, pool: vk.CommandPool, buffer: vk.B
 
 fn copyBuffer(gc: *const GraphicsContext, pool: vk.CommandPool, dst: vk.Buffer, src: vk.Buffer, size: vk.DeviceSize) !void {
     var cmdbuf: vk.CommandBuffer = undefined;
-    try gc.vkd.allocateCommandBuffers(gc.dev, .{
+    try gc.vkd.allocateCommandBuffers(gc.dev, &.{
         .command_pool = pool,
         .level = .primary,
         .command_buffer_count = 1,
     }, @ptrCast([*]vk.CommandBuffer, &cmdbuf));
     defer gc.vkd.freeCommandBuffers(gc.dev, pool, 1, @ptrCast([*]const vk.CommandBuffer, &cmdbuf));
 
-    try gc.vkd.beginCommandBuffer(cmdbuf, .{
+    try gc.vkd.beginCommandBuffer(cmdbuf, &.{
         .flags = .{ .one_time_submit_bit = true },
         .p_inheritance_info = null,
     });
@@ -234,7 +234,14 @@ fn createCommandBuffers(
     const cmdbufs = try allocator.alloc(vk.CommandBuffer, framebuffers.len);
     errdefer allocator.free(cmdbufs);
 
-    try gc.vkd.allocateCommandBuffers(gc.dev, .{
+    _ = pipeline;
+    _ = render_pass;
+    _ = extent;
+    _ = buffer;
+    _ = pool;
+    _ = gc;
+
+    try gc.vkd.allocateCommandBuffers(gc.dev, &.{
         .command_pool = pool,
         .level = .primary,
         .command_buffer_count = @truncate(u32, cmdbufs.len),
@@ -260,7 +267,8 @@ fn createCommandBuffers(
     };
 
     for (cmdbufs) |cmdbuf, i| {
-        try gc.vkd.beginCommandBuffer(cmdbuf, .{
+        _ = i;
+        try gc.vkd.beginCommandBuffer(cmdbuf, &.{
             .flags = .{},
             .p_inheritance_info = null,
         });
@@ -268,13 +276,16 @@ fn createCommandBuffers(
         gc.vkd.cmdSetViewport(cmdbuf, 0, 1, @ptrCast([*]const vk.Viewport, &viewport));
         gc.vkd.cmdSetScissor(cmdbuf, 0, 1, @ptrCast([*]const vk.Rect2D, &scissor));
 
-        gc.vkd.cmdBeginRenderPass(cmdbuf, .{
+        // This needs to be a separate definition - see https://github.com/ziglang/zig/issues/7627.
+        const render_area = vk.Rect2D{
+            .offset = .{ .x = 0, .y = 0 },
+            .extent = extent,
+        };
+
+        gc.vkd.cmdBeginRenderPass(cmdbuf, &.{
             .render_pass = render_pass,
             .framebuffer = framebuffers[i],
-            .render_area = .{
-                .offset = .{ .x = 0, .y = 0 },
-                .extent = extent,
-            },
+            .render_area = render_area,
             .clear_value_count = 1,
             .p_clear_values = @ptrCast([*]const vk.ClearValue, &clear),
         }, .@"inline");
@@ -304,7 +315,7 @@ fn createFramebuffers(gc: *const GraphicsContext, allocator: Allocator, render_p
     errdefer for (framebuffers[0..i]) |fb| gc.vkd.destroyFramebuffer(gc.dev, fb, null);
 
     for (framebuffers) |*fb| {
-        fb.* = try gc.vkd.createFramebuffer(gc.dev, .{
+        fb.* = try gc.vkd.createFramebuffer(gc.dev, &.{
             .flags = .{},
             .render_pass = render_pass,
             .attachment_count = 1,
@@ -355,7 +366,7 @@ fn createRenderPass(gc: *const GraphicsContext, swapchain: Swapchain) !vk.Render
         .p_preserve_attachments = undefined,
     };
 
-    return try gc.vkd.createRenderPass(gc.dev, .{
+    return try gc.vkd.createRenderPass(gc.dev, &.{
         .flags = .{},
         .attachment_count = 1,
         .p_attachments = @ptrCast([*]const vk.AttachmentDescription, &color_attachment),
@@ -371,14 +382,14 @@ fn createPipeline(
     layout: vk.PipelineLayout,
     render_pass: vk.RenderPass,
 ) !vk.Pipeline {
-    const vert = try gc.vkd.createShaderModule(gc.dev, .{
+    const vert = try gc.vkd.createShaderModule(gc.dev, &.{
         .flags = .{},
         .code_size = resources.triangle_vert.len,
         .p_code = @ptrCast([*]const u32, resources.triangle_vert),
     }, null);
     defer gc.vkd.destroyShaderModule(gc.dev, vert, null);
 
-    const frag = try gc.vkd.createShaderModule(gc.dev, .{
+    const frag = try gc.vkd.createShaderModule(gc.dev, &.{
         .flags = .{},
         .code_size = resources.triangle_frag.len,
         .p_code = @ptrCast([*]const u32, resources.triangle_frag),
diff --git a/generator/vulkan/render.zig b/generator/vulkan/render.zig
index f754257..23f060b 100644
--- a/generator/vulkan/render.zig
+++ b/generator/vulkan/render.zig
@@ -453,7 +453,8 @@ fn Renderer(comptime WriterType: type) type {
                     \\pub fn symbol(self: {s}Command) [:0]const u8 {{
                     \\    return switch (self) {{
                     \\
-                    , .{dispatch_type_name}
+                ,
+                    .{dispatch_type_name},
                 );
 
                 for (self.registry.decls) |decl| {
@@ -465,7 +466,7 @@ fn Renderer(comptime WriterType: type) type {
                     if (classifyCommandDispatch(decl.name, command) == dispatch_type) {
                         try self.writer.writeAll(".");
                         try self.writeIdentifierWithCase(.camel, trimVkNamespace(decl.name));
-                        try self.writer.print(" => \"{s}\",\n", .{ decl.name });
+                        try self.writer.print(" => \"{s}\",\n", .{decl.name});
                     }
                 }
 
@@ -478,7 +479,8 @@ fn Renderer(comptime WriterType: type) type {
                     \\pub fn PfnType(comptime self: {s}Command) type {{
                     \\    return switch (self) {{
                     \\
-                    , .{dispatch_type_name}
+                ,
+                    .{dispatch_type_name},
                 );
 
                 for (self.registry.decls) |decl| {
@@ -1087,26 +1089,14 @@ fn Renderer(comptime WriterType: type) type {
             try self.writer.writeAll("(self: Self, ");
 
             for (command.params) |param| {
-                switch (try self.classifyParam(param)) {
-                    .in_pointer => {
-                        // Remove one pointer level
-                        try self.writeIdentifierWithCase(.snake, derefName(param.name));
-                        try self.writer.writeAll(": ");
-                        try self.renderTypeInfo(param.param_type.pointer.child.*);
-                    },
-                    .out_pointer => continue, // Return value
-                    .in_out_pointer,
-                    .bitflags, // Special stuff handled in renderWrapperCall
-                    .buffer_len,
-                    .mut_buffer_len,
-                    .other,
-                    => {
-                        try self.writeIdentifierWithCase(.snake, param.name);
-                        try self.writer.writeAll(": ");
-                        try self.renderTypeInfo(param.param_type);
-                    },
+                // This parameter is returned instead.
+                if ((try self.classifyParam(param)) == .out_pointer) {
+                    continue;
                 }
 
+                try self.writeIdentifierWithCase(.snake, param.name);
+                try self.writer.writeAll(": ");
+                try self.renderTypeInfo(param.param_type);
                 try self.writer.writeAll(", ");
             }
 
@@ -1133,10 +1123,6 @@ fn Renderer(comptime WriterType: type) type {
 
             for (command.params) |param| {
                 switch (try self.classifyParam(param)) {
-                    .in_pointer => {
-                        try self.writer.writeByte('&');
-                        try self.writeIdentifierWithCase(.snake, derefName(param.name));
-                    },
                     .out_pointer => {
                         try self.writer.writeByte('&');
                         if (returns.len > 1) {
@@ -1148,7 +1134,7 @@ fn Renderer(comptime WriterType: type) type {
                         try self.writeIdentifierWithCase(.snake, param.name);
                         try self.writer.writeAll(".toInt()");
                     },
-                    .in_out_pointer, .buffer_len, .mut_buffer_len, .other => {
+                    .in_pointer, .in_out_pointer, .buffer_len, .mut_buffer_len, .other => {
                         try self.writeIdentifierWithCase(.snake, param.name);
                     },
                 }