diff --git a/ThunkLibs/libvulkan/Host.cpp b/ThunkLibs/libvulkan/Host.cpp
index 591a0f2d2..e61b397da 100644
--- a/ThunkLibs/libvulkan/Host.cpp
+++ b/ThunkLibs/libvulkan/Host.cpp
@@ -16,7 +16,10 @@ $end_info$
 
 #include <cstring>
 #include <mutex>
+#include <span>
 #include <string_view>
+#include <unordered_map>
+#include <vector>
 
 #include "thunkgen_host_libvulkan.inl"
 
@@ -141,9 +144,7 @@ static VkResult FEXFN_IMPL(vkCreateInstance)(const VkInstanceCreateInfo* a_0, co
 
   VkInstance out;
   auto ret = LDR_PTR(vkCreateInstance)(vk_struct_base, nullptr, &out);
-  if (ret == VK_SUCCESS) {
-    *a_2.get_pointer() = to_guest(to_host_layout(out));
-  }
+  *a_2.get_pointer() = to_guest(to_host_layout(out));
   return ret;
 }
 
@@ -151,9 +152,7 @@ static VkResult FEXFN_IMPL(vkCreateDevice)(VkPhysicalDevice a_0, const VkDeviceC
                                            guest_layout<VkDevice*> a_3) {
   VkDevice out;
   auto ret = LDR_PTR(vkCreateDevice)(a_0, a_1, nullptr, &out);
-  if (ret == VK_SUCCESS) {
-    *a_3.get_pointer() = to_guest(to_host_layout(out));
-  }
+  *a_3.get_pointer() = to_guest(to_host_layout(out));
   return ret;
 }
 
@@ -193,6 +192,115 @@ static VkResult FEXFN_IMPL(vkCreateDebugUtilsMessengerEXT)(VkInstance_T* a_0, gu
   return LDR_PTR(vkCreateDebugUtilsMessengerEXT)(a_0, &overridden_callback, nullptr, a_3);
 }
 
+#ifdef IS_32BIT_THUNK
+VkResult fexfn_impl_libvulkan_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* count, guest_layout<VkPhysicalDevice*> devices) {
+  if (!devices.get_pointer()) {
+    return fexldr_ptr_libvulkan_vkEnumeratePhysicalDevices(instance, count, nullptr);
+  }
+
+  auto input_count = *count;
+  std::vector<VkPhysicalDevice> out(input_count);
+  auto ret = fexldr_ptr_libvulkan_vkEnumeratePhysicalDevices(instance, count, out.data());
+  for (size_t i = 0; i < std::min(input_count, *count); ++i) {
+    devices.get_pointer()[i] = to_guest(to_host_layout(out[i]));
+  }
+  return ret;
+}
+
+void fexfn_impl_libvulkan_vkGetDeviceQueue(VkDevice device, uint32_t family_index, uint32_t queue_index, guest_layout<VkQueue*> queue) {
+  VkQueue out;
+  (void*&)fexldr_ptr_libvulkan_vkGetDeviceQueue = (void*)LDR_PTR(vkGetDeviceProcAddr)(device, "vkGetDeviceQueue");
+  fexldr_ptr_libvulkan_vkGetDeviceQueue(device, family_index, queue_index, &out);
+  *queue.get_pointer() = to_guest(to_host_layout(out));
+}
+
+VkResult fexfn_impl_libvulkan_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* info,
+                                                       guest_layout<VkCommandBuffer*> buffers) {
+  std::vector<VkCommandBuffer> out(info->commandBufferCount);
+  (void*&)fexldr_ptr_libvulkan_vkAllocateCommandBuffers = (void*)LDR_PTR(vkGetDeviceProcAddr)(device, "vkAllocateCommandBuffers");
+  auto ret = fexldr_ptr_libvulkan_vkAllocateCommandBuffers(device, info, out.data());
+  if (ret == VK_SUCCESS) {
+    for (size_t i = 0; i < info->commandBufferCount; ++i) {
+      buffers.get_pointer()[i] = to_guest(to_host_layout(out[i]));
+    }
+  }
+  return ret;
+}
+
+VkResult fexfn_impl_libvulkan_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size,
+                                          VkMemoryMapFlags flags, guest_layout<void**> data) {
+  host_layout<void*> host_data {};
+  void* mapped;
+  (void*&)fexldr_ptr_libvulkan_vkMapMemory = (void*)LDR_PTR(vkGetDeviceProcAddr)(device, "vkMapMemory");
+  auto ret = fexldr_ptr_libvulkan_vkMapMemory(device, memory, offset, size, flags, &mapped);
+  if (ret == VK_SUCCESS) {
+    host_data.data = mapped;
+    *data.get_pointer() = to_guest(host_data);
+  }
+  return ret;
+}
+
+// Allocates storage on the heap that must be de-allocated using delete[]
+template<bool NeedsRepack = true, typename T>
+std::span<std::remove_cv_t<T>> RepackStructArray(uint32_t Count, const guest_layout<T*> GuestData) {
+  if (!GuestData.get_pointer() || Count == 0) {
+    return {};
+  }
+
+  auto HostData = new std::remove_cv_t<T>[Count];
+  for (size_t i = 0; i < Count; ++i) {
+    auto& GuestElement = (const guest_layout<std::remove_cv_t<T>>&)GuestData.get_pointer()[i];
+    auto Element = host_layout<std::remove_cv_t<T>> {GuestElement};
+    if constexpr (NeedsRepack) {
+      fex_apply_custom_repacking_entry(Element, GuestElement);
+    }
+    HostData[i] = Element.data;
+  }
+  return {HostData, Count};
+}
+
+void fexfn_impl_libvulkan_vkUpdateDescriptorSets(VkDevice device, unsigned int descriptorWriteCount,
+                                                 guest_layout<const VkWriteDescriptorSet*> pDescriptorWrites, unsigned int descriptorCopyCount,
+                                                 guest_layout<const VkCopyDescriptorSet*> pDescriptorCopies) {
+
+  auto HostDescriptorWrites = RepackStructArray(descriptorWriteCount, pDescriptorWrites);
+  auto HostDescriptorCopies = RepackStructArray(descriptorCopyCount, pDescriptorCopies);
+
+  (void*&)fexldr_ptr_libvulkan_vkUpdateDescriptorSets = (void*)LDR_PTR(vkGetDeviceProcAddr)(device, "vkUpdateDescriptorSets");
+  fexldr_ptr_libvulkan_vkUpdateDescriptorSets(device, descriptorWriteCount, HostDescriptorWrites.data(), descriptorCopyCount,
+                                              HostDescriptorCopies.data());
+
+  delete[] HostDescriptorCopies.data();
+  delete[] HostDescriptorWrites.data();
+}
+
+VkResult fexfn_impl_libvulkan_vkQueueSubmit(VkQueue queue, uint32_t submit_count, guest_layout<const VkSubmitInfo*> submit_infos, VkFence fence) {
+
+  auto HostSubmitInfos = RepackStructArray(submit_count, submit_infos);
+  auto ret = fexldr_ptr_libvulkan_vkQueueSubmit(queue, submit_count, HostSubmitInfos.data(), fence);
+  delete[] HostSubmitInfos.data();
+  return ret;
+}
+
+void fexfn_impl_libvulkan_vkFreeCommandBuffers(VkDevice device, VkCommandPool pool, uint32_t num_buffers,
+                                               guest_layout<const VkCommandBuffer*> buffers) {
+
+  auto HostBuffers = RepackStructArray<false>(num_buffers, buffers);
+  (void*&)fexldr_ptr_libvulkan_vkFreeCommandBuffers = (void*)LDR_PTR(vkGetDeviceProcAddr)(device, "vkFreeCommandBuffers");
+  fexldr_ptr_libvulkan_vkFreeCommandBuffers(device, pool, num_buffers, HostBuffers.data());
+  delete[] HostBuffers.data();
+}
+
+VkResult fexfn_impl_libvulkan_vkGetPipelineCacheData(VkDevice device, VkPipelineCache cache, guest_layout<uint32_t*> guest_data_size, void* data) {
+  size_t data_size = guest_data_size.get_pointer()->data;
+  (void*&)fexldr_ptr_libvulkan_vkGetPipelineCacheData = (void*)LDR_PTR(vkGetDeviceProcAddr)(device, "vkGetPipelineCacheData");
+  auto ret = fexldr_ptr_libvulkan_vkGetPipelineCacheData(device, cache, &data_size, data);
+  *guest_data_size.get_pointer() = data_size;
+  return ret;
+}
+
+#endif
+
 static PFN_vkVoidFunction LookupCustomVulkanFunction(const char* a_1) {
   using namespace std::string_view_literals;
 
@@ -206,6 +314,7 @@ static PFN_vkVoidFunction LookupCustomVulkanFunction(const char* a_1) {
     return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkAllocateMemory;
   } else if (a_1 == "vkFreeMemory"sv) {
     return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkFreeMemory;
+    // TODO: Review if 32-bit changes are needed
   } else if (a_1 == "vkAcquireXlibDisplayEXT"sv) {
     return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkAcquireXlibDisplayEXT;
   } else if (a_1 == "vkGetRandROutputDisplayEXT"sv) {
@@ -214,6 +323,24 @@ static PFN_vkVoidFunction LookupCustomVulkanFunction(const char* a_1) {
     return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkGetPhysicalDeviceXcbPresentationSupportKHR;
   } else if (a_1 == "vkGetPhysicalDeviceXlibPresentationSupportKHR"sv) {
     return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkGetPhysicalDeviceXlibPresentationSupportKHR;
+#ifdef IS_32BIT_THUNK
+  } else if (a_1 == "vkAllocateCommandBuffers"sv) {
+    return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkAllocateCommandBuffers;
+  } else if (a_1 == "vkEnumeratePhysicalDevices"sv) {
+    return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkEnumeratePhysicalDevices;
+  } else if (a_1 == "vkFreeCommandBuffers"sv) {
+    return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkFreeCommandBuffers;
+  } else if (a_1 == "vkGetDeviceQueue"sv) {
+    return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkGetDeviceQueue;
+  } else if (a_1 == "vkGetPipelineCacheData"sv) {
+    return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkGetPipelineCacheData;
+  } else if (a_1 == "vkMapMemory"sv) {
+    return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkMapMemory;
+  } else if (a_1 == "vkQueueSubmit"sv) {
+    return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkQueueSubmit;
+  } else if (a_1 == "vkUpdateDescriptorSets"sv) {
+    return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkUpdateDescriptorSets;
+#endif
   }
   return nullptr;
 }
@@ -265,4 +392,450 @@ static PFN_vkVoidFunction FEXFN_IMPL(vkGetInstanceProcAddr)(VkInstance a_0, cons
   return LDR_PTR(vkGetInstanceProcAddr)(a_0, a_1);
 }
 
+#ifdef IS_32BIT_THUNK
+template<VkStructureType TypeIndex, typename Type>
+static VkBaseOutStructure* convert(const guest_layout<VkBaseOutStructure>* source) {
+  // Using malloc here since no easily available type information is available at the time of destruction.
+  auto typed_source = reinterpret_cast<const guest_layout<Type>*>(source);
+  auto child_mem = (char*)aligned_alloc(alignof(host_layout<Type>), sizeof(host_layout<Type>));
+  auto child = new (child_mem) host_layout<Type> {*typed_source};
+
+  fex_custom_repack_entry(*child, *typed_source);
+
+  return reinterpret_cast<VkBaseOutStructure*>(&child->data);
+}
+
+template<VkStructureType TypeIndex, typename Type>
+static void convert_to_guest(void* into, const VkBaseOutStructure* from) {
+  auto typed_into = reinterpret_cast<guest_layout<Type>*>(into);
+  auto oldNext = typed_into->data.pNext; // TODO: This assumes Vulkan never modifies pNext internally
+  *typed_into = to_guest(to_host_layout(*(Type*)from));
+  typed_into->data.pNext = oldNext;
+
+  fex_custom_repack_exit(*typed_into, to_host_layout(*(Type*)from));
+}
+
+template<VkStructureType TypeIndex, typename Type>
+inline constexpr std::pair<VkStructureType, std::pair<VkBaseOutStructure* (*)(const guest_layout<VkBaseOutStructure>*), void (*)(void*, const VkBaseOutStructure*)>>
+  converters = {TypeIndex, {convert<TypeIndex, Type>, convert_to_guest<TypeIndex, Type>}};
+
+// NOTE: Not all Vulkan structures with pNext members are listed here. This is because excluding structs exclusively used as top-level entries is useful to detect repacking bugs.
+static std::unordered_map<VkStructureType, std::pair<VkBaseOutStructure* (*)(const guest_layout<VkBaseOutStructure>*), void (*)(void*, const VkBaseOutStructure*)>> next_handlers {
+  converters<VkStructureType::VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, VkSemaphoreTypeCreateInfo>,
+  converters<VkStructureType::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, VkMemoryDedicatedRequirements>,
+  converters<VkStructureType::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, VkMemoryDedicatedAllocateInfo>,
+  converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VkImageFormatListCreateInfo>,
+  converters<VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, VkRenderPassAttachmentBeginInfo>,
+  converters<VkStructureType::VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, VkTimelineSemaphoreSubmitInfo>,
+  converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, VkPipelineRenderingCreateInfo>,
+  converters<VkStructureType::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, VkMemoryAllocateFlagsInfo>,
+};
+
+static void default_fex_custom_repack_entry(VkBaseOutStructure& into, const guest_layout<VkBaseOutStructure>* from) {
+  if (!from->data.pNext.get_pointer()) {
+    into.pNext = nullptr;
+    return;
+  }
+  auto typed_source = reinterpret_cast<const guest_layout<VkBaseOutStructure>*>(from->data.pNext.get_pointer());
+
+  auto next_handler = next_handlers.find(static_cast<VkStructureType>(typed_source->data.sType.data));
+  if (next_handler == next_handlers.end()) {
+    fprintf(stderr, "ERROR: Unrecognized VkStructureType %u referenced by pNext\n", typed_source->data.sType.data);
+    std::abort();
+  }
+
+  into.pNext = next_handler->second.first(typed_source);
+}
+
+template<typename T>
+void default_fex_custom_repack_entry(host_layout<T>& into, const guest_layout<T>& from) {
+  default_fex_custom_repack_entry(*(VkBaseOutStructure*)&into.data, reinterpret_cast<const guest_layout<VkBaseOutStructure>*>(&from));
+}
+
+static void default_fex_custom_repack_reverse(guest_layout<VkBaseOutStructure>& into, const VkBaseOutStructure* from) {
+  auto pNextHost = from->pNext;
+  if (!pNextHost) {
+    return;
+  }
+
+  auto next_handler = next_handlers.find(static_cast<VkStructureType>(into.data.pNext.get_pointer()->data.sType.data));
+  if (next_handler == next_handlers.end()) {
+    fprintf(stderr, "ERROR: Unrecognized VkStructureType %u referenced by pNext when converting to guest\n", from->sType);
+    std::abort();
+  }
+  next_handler->second.second((void*)into.data.pNext.get_pointer(), from->pNext);
+
+  free(pNextHost);
+}
+
+// Default repacking functions that only traverses and repacks the pNext chain.
+// If other members need to be repacked, use VULKAN_NONDEFAULT_CUSTOM_REPACK instead
+#define VULKAN_DEFAULT_CUSTOM_REPACK(name)                                                             \
+  void fex_custom_repack_entry(host_layout<name>& into, const guest_layout<name>& from) {              \
+    default_fex_custom_repack_entry(reinterpret_cast<VkBaseOutStructure&>(into.data),                  \
+                                    &reinterpret_cast<const guest_layout<VkBaseOutStructure>&>(from)); \
+  }                                                                                                    \
+                                                                                                       \
+  bool fex_custom_repack_exit(guest_layout<name>& into, const host_layout<name>& from) {               \
+    auto prev_next = into.data.pNext;                                                                  \
+    default_fex_custom_repack_reverse(*reinterpret_cast<guest_layout<VkBaseOutStructure>*>(&into),     \
+                                      &reinterpret_cast<const VkBaseOutStructure&>(from.data));        \
+    into = to_guest(from);                                                                             \
+    into.data.pNext = prev_next;                                                                       \
+    return true;                                                                                       \
+  }
+
+// Intentionally left empty. This macro doesn't automate anything, but it
+// helps ensure we don't forget any Vulkan types in the list. The actual
+// repacking functions are defined manually later
+#define VULKAN_NONDEFAULT_CUSTOM_REPACK(name)
+
+VULKAN_DEFAULT_CUSTOM_REPACK(VkApplicationInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAttachmentDescription2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAttachmentReference2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferMemoryBarrier2)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkDependencyInfo)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkDescriptorUpdateTemplateCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceQueueCreateInfo)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkGraphicsPipelineCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageFormatListCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageMemoryBarrier2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageMemoryRequirementsInfo2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageViewCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryAllocateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryAllocateFlagsInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryBarrier2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryDedicatedAllocateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryDedicatedRequirements)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryRequirements2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineRenderingCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderPassAttachmentBeginInfo)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkRenderPassBeginInfo)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkRenderPassCreateInfo)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkRenderPassCreateInfo2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSemaphoreCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSemaphoreTypeCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSemaphoreWaitInfo)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkSubmitInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSubpassBeginInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSubpassDependency2)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkSubpassDescription2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSwapchainCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkTimelineSemaphoreSubmitInfo)
+
+
+void fex_custom_repack_entry(host_layout<VkInstanceCreateInfo>& into, const guest_layout<VkInstanceCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  auto HostApplicationInfo = new host_layout<VkApplicationInfo> {*from.data.pApplicationInfo.get_pointer()};
+  fex_apply_custom_repacking_entry(*HostApplicationInfo, *from.data.pApplicationInfo.get_pointer());
+
+  into.data.pApplicationInfo = &HostApplicationInfo->data;
+
+  auto extension_count = from.data.enabledExtensionCount.data;
+  into.data.ppEnabledExtensionNames = RepackStructArray<false>(extension_count, from.data.ppEnabledExtensionNames).data();
+
+  auto layer_count = from.data.enabledLayerCount.data;
+  into.data.ppEnabledLayerNames = RepackStructArray<false>(layer_count, from.data.ppEnabledLayerNames).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkInstanceCreateInfo>& into, const host_layout<VkInstanceCreateInfo>& from) {
+  delete from.data.pApplicationInfo;
+  delete[] from.data.ppEnabledExtensionNames;
+  delete[] from.data.ppEnabledLayerNames;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkDeviceCreateInfo>& into, const guest_layout<VkDeviceCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  auto HostQueueCreateInfo = new host_layout<VkDeviceQueueCreateInfo> {*from.data.pQueueCreateInfos.get_pointer()};
+  fex_apply_custom_repacking_entry(*HostQueueCreateInfo, *from.data.pQueueCreateInfos.get_pointer());
+  into.data.pQueueCreateInfos = &HostQueueCreateInfo->data;
+
+  auto layer_count = from.data.enabledExtensionCount.data;
+  fprintf(stderr, "  Repacking %d ppEnabledLayerNames\n", layer_count);
+  into.data.ppEnabledLayerNames = RepackStructArray<false>(layer_count, from.data.ppEnabledLayerNames).data();
+
+  auto extension_count = from.data.enabledExtensionCount.data;
+  fprintf(stderr, "  Repacking %d ppEnabledExtensionNames\n", extension_count);
+  into.data.ppEnabledExtensionNames = RepackStructArray<false>(extension_count, from.data.ppEnabledExtensionNames).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkDeviceCreateInfo>& into, const host_layout<VkDeviceCreateInfo>& from) {
+  delete from.data.pQueueCreateInfos;
+  delete[] from.data.ppEnabledExtensionNames;
+  delete[] from.data.ppEnabledLayerNames;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkDescriptorSetLayoutCreateInfo>& into, const guest_layout<VkDescriptorSetLayoutCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pBindings = RepackStructArray(from.data.bindingCount.data, from.data.pBindings).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkDescriptorSetLayoutCreateInfo>& into, const host_layout<VkDescriptorSetLayoutCreateInfo>& from) {
+  delete[] from.data.pBindings;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkRenderPassCreateInfo>& into, const guest_layout<VkRenderPassCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pSubpasses = RepackStructArray(from.data.subpassCount.data, from.data.pSubpasses).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkRenderPassCreateInfo>& into, const host_layout<VkRenderPassCreateInfo>& from) {
+  delete[] from.data.pSubpasses;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkRenderPassCreateInfo2>& into, const guest_layout<VkRenderPassCreateInfo2>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pAttachments = RepackStructArray(from.data.attachmentCount.data, from.data.pAttachments).data();
+  into.data.pSubpasses = RepackStructArray(from.data.subpassCount.data, from.data.pSubpasses).data();
+  into.data.pDependencies = RepackStructArray(from.data.dependencyCount.data, from.data.pDependencies).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkRenderPassCreateInfo2>& into, const host_layout<VkRenderPassCreateInfo2>& from) {
+  delete[] from.data.pAttachments;
+  // TODO: Run custom exit-repacking
+  delete[] from.data.pSubpasses;
+  // TODO: Run custom exit-repacking
+  delete[] from.data.pDependencies;
+  // TODO: Run custom exit-repacking
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkSubpassDescription2>& into, const guest_layout<VkSubpassDescription2>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pInputAttachments = RepackStructArray(from.data.inputAttachmentCount.data, from.data.pInputAttachments).data();
+  into.data.pColorAttachments = RepackStructArray(from.data.colorAttachmentCount.data, from.data.pColorAttachments).data();
+  into.data.pResolveAttachments = RepackStructArray(from.data.colorAttachmentCount.data, from.data.pResolveAttachments).data();
+
+  if (from.data.pDepthStencilAttachment.data == 0) {
+    into.data.pDepthStencilAttachment = nullptr;
+  } else {
+    into.data.pDepthStencilAttachment = new VkAttachmentReference2;
+    auto in_data = host_layout<VkAttachmentReference2> {*from.data.pDepthStencilAttachment.get_pointer()};
+    fex_apply_custom_repacking_entry(in_data, *from.data.pDepthStencilAttachment.get_pointer());
+    memcpy((void*)into.data.pDepthStencilAttachment, &in_data.data, sizeof(VkAttachmentReference2));
+  }
+}
+
+bool fex_custom_repack_exit(guest_layout<VkSubpassDescription2>& into, const host_layout<VkSubpassDescription2>& from) {
+  delete[] from.data.pInputAttachments;
+  // TODO: Run custom exit-repacking
+  delete[] from.data.pColorAttachments;
+  // TODO: Run custom exit-repacking
+  delete[] from.data.pResolveAttachments;
+  // TODO: Run custom exit-repacking
+  delete /*[]*/ from.data.pDepthStencilAttachment;
+  // TODO: Run custom exit-repacking
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkRenderingInfo>& into, const guest_layout<VkRenderingInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  into.data.pColorAttachments = RepackStructArray(from.data.colorAttachmentCount.data, from.data.pColorAttachments).data();
+
+  if (from.data.pDepthAttachment.get_pointer() == nullptr) {
+    into.data.pDepthAttachment = nullptr;
+  } else {
+    into.data.pDepthAttachment = new VkRenderingAttachmentInfo;
+    auto in_data = host_layout<VkRenderingAttachmentInfo> {*from.data.pDepthAttachment.get_pointer()};
+    fex_apply_custom_repacking_entry(in_data, *from.data.pDepthAttachment.get_pointer());
+    memcpy((void*)into.data.pDepthAttachment, &in_data.data, sizeof(VkRenderingAttachmentInfo));
+  }
+
+  if (from.data.pStencilAttachment.get_pointer() == nullptr) {
+    into.data.pStencilAttachment = nullptr;
+  } else {
+    into.data.pStencilAttachment = new VkRenderingAttachmentInfo;
+    auto in_data = host_layout<VkRenderingAttachmentInfo> {*from.data.pStencilAttachment.get_pointer()};
+    fex_apply_custom_repacking_entry(in_data, *from.data.pStencilAttachment.get_pointer());
+    memcpy((void*)into.data.pStencilAttachment, &in_data.data, sizeof(VkRenderingAttachmentInfo));
+  }
+}
+
+bool fex_custom_repack_exit(guest_layout<VkRenderingInfo>& into, const host_layout<VkRenderingInfo>& from) {
+  delete[] from.data.pColorAttachments;
+  // TODO: Run custom exit-repacking
+  delete from.data.pDepthAttachment;
+  // TODO: Run custom exit-repacking
+  delete from.data.pStencilAttachment;
+  // TODO: Run custom exit-repacking
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkDependencyInfo>& into, const guest_layout<VkDependencyInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pMemoryBarriers = RepackStructArray(from.data.memoryBarrierCount.data, from.data.pMemoryBarriers).data();
+  into.data.pImageMemoryBarriers = RepackStructArray(from.data.imageMemoryBarrierCount.data, from.data.pImageMemoryBarriers).data();
+  into.data.pBufferMemoryBarriers = RepackStructArray(from.data.bufferMemoryBarrierCount.data, from.data.pBufferMemoryBarriers).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkDependencyInfo>& into, const host_layout<VkDependencyInfo>& from) {
+  delete[] from.data.pMemoryBarriers;
+  // TODO: Run custom exit-repacking
+  delete[] from.data.pBufferMemoryBarriers;
+  // TODO: Run custom exit-repacking
+  delete[] from.data.pImageMemoryBarriers;
+  // TODO: Run custom exit-repacking
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkDescriptorUpdateTemplateCreateInfo>& into,
+                             const guest_layout<VkDescriptorUpdateTemplateCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pDescriptorUpdateEntries = RepackStructArray(from.data.descriptorUpdateEntryCount.data, from.data.pDescriptorUpdateEntries).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkDescriptorUpdateTemplateCreateInfo>& into, const host_layout<VkDescriptorUpdateTemplateCreateInfo>& from) {
+  delete[] from.data.pDescriptorUpdateEntries;
+  // TODO: Run custom exit-repacking
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkPipelineShaderStageCreateInfo>& into, const guest_layout<VkPipelineShaderStageCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  if (from.data.pSpecializationInfo.get_pointer()) {
+    fprintf(stderr, "ERROR: Cannot repack non-null VkPipelineShaderStageCreateInfo::pSpecializationInfo yet");
+    std::abort();
+  }
+}
+
+bool fex_custom_repack_exit(guest_layout<VkPipelineShaderStageCreateInfo>& into, const host_layout<VkPipelineShaderStageCreateInfo>& from) {
+  // TODO
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pStages = RepackStructArray(from.data.stageCount.data, from.data.pStages).data();
+
+  if (!from.data.pVertexInputState.get_pointer()) {
+    into.data.pVertexInputState = nullptr;
+  } else {
+    into.data.pVertexInputState = &(new host_layout<VkPipelineVertexInputStateCreateInfo> {*from.data.pVertexInputState.get_pointer()})->data;
+  }
+
+  if (!from.data.pInputAssemblyState.get_pointer()) {
+    into.data.pInputAssemblyState = nullptr;
+  } else {
+    into.data.pInputAssemblyState =
+      &(new host_layout<VkPipelineInputAssemblyStateCreateInfo> {*from.data.pInputAssemblyState.get_pointer()})->data;
+  }
+
+  if (!from.data.pTessellationState.get_pointer()) {
+    into.data.pTessellationState = nullptr;
+  } else {
+    into.data.pTessellationState = &(new host_layout<VkPipelineTessellationStateCreateInfo> {*from.data.pTessellationState.get_pointer()})->data;
+  }
+
+  if (!from.data.pViewportState.get_pointer()) {
+    into.data.pViewportState = nullptr;
+  } else {
+    into.data.pViewportState = &(new host_layout<VkPipelineViewportStateCreateInfo> {*from.data.pViewportState.get_pointer()})->data;
+  }
+
+  if (!from.data.pRasterizationState.get_pointer()) {
+    into.data.pRasterizationState = nullptr;
+  } else {
+    into.data.pRasterizationState =
+      &(new host_layout<VkPipelineRasterizationStateCreateInfo> {*from.data.pRasterizationState.get_pointer()})->data;
+  }
+
+  if (!from.data.pMultisampleState.get_pointer()) {
+    into.data.pMultisampleState = nullptr;
+  } else {
+    into.data.pMultisampleState = &(new host_layout<VkPipelineMultisampleStateCreateInfo> {*from.data.pMultisampleState.get_pointer()})->data;
+  }
+
+  if (!from.data.pDepthStencilState.get_pointer()) {
+    into.data.pDepthStencilState = nullptr;
+  } else {
+    into.data.pDepthStencilState = &(new host_layout<VkPipelineDepthStencilStateCreateInfo> {*from.data.pDepthStencilState.get_pointer()})->data;
+  }
+
+  if (!from.data.pColorBlendState.get_pointer()) {
+    into.data.pColorBlendState = nullptr;
+  } else {
+    into.data.pColorBlendState = &(new host_layout<VkPipelineColorBlendStateCreateInfo> {*from.data.pColorBlendState.get_pointer()})->data;
+  }
+
+  if (!from.data.pDynamicState.get_pointer()) {
+    into.data.pDynamicState = nullptr;
+  } else {
+    into.data.pDynamicState = &(new host_layout<VkPipelineDynamicStateCreateInfo> {*from.data.pDynamicState.get_pointer()})->data;
+  }
+}
+
+bool fex_custom_repack_exit(guest_layout<VkGraphicsPipelineCreateInfo>& into, const host_layout<VkGraphicsPipelineCreateInfo>& from) {
+  delete[] from.data.pStages;
+  delete from.data.pVertexInputState;
+  delete from.data.pInputAssemblyState;
+  delete from.data.pTessellationState;
+  delete from.data.pViewportState;
+  delete from.data.pRasterizationState;
+  delete from.data.pMultisampleState;
+  delete from.data.pDepthStencilState;
+  delete from.data.pColorBlendState;
+  delete from.data.pDynamicState;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkSubmitInfo>& into, const guest_layout<VkSubmitInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pCommandBuffers = RepackStructArray<false>(from.data.commandBufferCount.data, from.data.pCommandBuffers).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkSubmitInfo>& into, const host_layout<VkSubmitInfo>& from) {
+  delete[] from.data.pCommandBuffers;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkCommandBufferBeginInfo>& into, const guest_layout<VkCommandBufferBeginInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  if (!from.data.pInheritanceInfo.get_pointer() || !from.data.pInheritanceInfo.data) {
+    into.data.pInheritanceInfo = nullptr;
+    return;
+  }
+  into.data.pInheritanceInfo = new VkCommandBufferInheritanceInfo;
+  auto src = host_layout<VkCommandBufferInheritanceInfo> {*from.data.pInheritanceInfo.get_pointer()}.data;
+  static_assert(sizeof(src) == sizeof(*into.data.pInheritanceInfo));
+  memcpy((void*)into.data.pInheritanceInfo, &src, sizeof(src));
+}
+
+bool fex_custom_repack_exit(guest_layout<VkCommandBufferBeginInfo>& into, const host_layout<VkCommandBufferBeginInfo>& from) {
+  delete from.data.pInheritanceInfo;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkPipelineCacheCreateInfo>& into, const guest_layout<VkPipelineCacheCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  // Same underlying layout, so there's nothing to do
+  into.data.pInitialData = from.data.pInitialData.get_pointer();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkPipelineCacheCreateInfo>& into, const host_layout<VkPipelineCacheCreateInfo>& from) {
+  // Nothing to do
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkRenderPassBeginInfo>& into, const guest_layout<VkRenderPassBeginInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  // Same underlying layout, so there's nothing to do
+  into.data.pClearValues = reinterpret_cast<const VkClearValue*>(from.data.pClearValues.get_pointer());
+}
+
+bool fex_custom_repack_exit(guest_layout<VkRenderPassBeginInfo>& into, const host_layout<VkRenderPassBeginInfo>& from) {
+  // Nothing to do
+  return false;
+}
+#endif
+
 EXPORTS(libvulkan)
diff --git a/ThunkLibs/libvulkan/libvulkan_interface.cpp b/ThunkLibs/libvulkan/libvulkan_interface.cpp
index 41e320ced..c5f21875f 100644
--- a/ThunkLibs/libvulkan/libvulkan_interface.cpp
+++ b/ThunkLibs/libvulkan/libvulkan_interface.cpp
@@ -95,7 +95,171 @@ struct fex_gen_type<VkDebugReportCallbackCreateInfoEXT> : fexgen::emit_layout_wr
 template<>
 struct fex_gen_type<VkDebugUtilsMessengerCreateInfoEXT> : fexgen::emit_layout_wrappers {};
 
-#ifndef IS_32BIT_THUNK
+#ifdef IS_32BIT_THUNK
+// Register structs with an extension point (pNext). Any other members that need customization are listed below.
+template<>
+struct fex_gen_config<&VkApplicationInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkAttachmentDescription2::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkAttachmentReference2::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_type<VkBaseOutStructure> : fexgen::emit_layout_wrappers {};
+template<>
+struct fex_gen_config<&VkBufferMemoryBarrier2::pNext> : fexgen::custom_repack {};
+// template<> struct fex_gen_config<&VkCommandBufferBeginInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkDependencyInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkDescriptorUpdateTemplateCreateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkDeviceCreateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkDeviceQueueCreateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkImageFormatListCreateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkImageMemoryBarrier2::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkImageMemoryRequirementsInfo2::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkImageViewCreateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkInstanceCreateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkMemoryAllocateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkMemoryAllocateFlagsInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkMemoryBarrier2::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkMemoryDedicatedAllocateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkMemoryDedicatedRequirements::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkMemoryRequirements2::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkPipelineRenderingCreateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkRenderPassAttachmentBeginInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkRenderPassBeginInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkRenderPassCreateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkRenderPassCreateInfo2::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkSemaphoreCreateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkSemaphoreTypeCreateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkSemaphoreWaitInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkSubmitInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkSubpassBeginInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkSubpassDependency2::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkSubpassDescription2::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkSwapchainCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkTimelineSemaphoreSubmitInfo::pNext> : fexgen::custom_repack {};
+
+
+template<>
+struct fex_gen_config<&VkDeviceCreateInfo::pQueueCreateInfos> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkDeviceCreateInfo::ppEnabledLayerNames> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkDeviceCreateInfo::ppEnabledExtensionNames> : fexgen::custom_repack {};
+
+template<>
+struct fex_gen_config<&VkDescriptorSetLayoutCreateInfo::pNext> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkDescriptorSetLayoutCreateInfo::pBindings> : fexgen::custom_repack {};
+
+template<>
+struct fex_gen_config<&VkInstanceCreateInfo::pApplicationInfo> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkInstanceCreateInfo::ppEnabledLayerNames> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkInstanceCreateInfo::ppEnabledExtensionNames> : fexgen::custom_repack {};
+
+template<>
+struct fex_gen_config<&VkRenderPassCreateInfo::pSubpasses> : fexgen::custom_repack {};
+// NOTE: pDependencies and pAttachments point to ABI-compatible data
+
+template<>
+struct fex_gen_config<&VkRenderPassCreateInfo2::pAttachments> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkRenderPassCreateInfo2::pSubpasses> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkRenderPassCreateInfo2::pDependencies> : fexgen::custom_repack {};
+
+template<>
+struct fex_gen_config<&VkPipelineShaderStageCreateInfo::pSpecializationInfo> : fexgen::custom_repack {};
+// template<> struct fex_gen_config<&VkSpecializationInfo::pMapEntries> : fexgen::custom_repack {};
+
+
+template<>
+struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pStages> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pVertexInputState> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pInputAssemblyState> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pTessellationState> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pViewportState> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pRasterizationState> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pMultisampleState> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pDepthStencilState> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pColorBlendState> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pDynamicState> : fexgen::custom_repack {};
+
+// Command buffers are dispatchable handles, so on 32-bit they need to be repacked
+template<>
+struct fex_gen_config<&VkSubmitInfo::pCommandBuffers> : fexgen::custom_repack {};
+
+template<>
+struct fex_gen_config<&VkRenderingInfo::pColorAttachments> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkRenderingInfo::pDepthAttachment> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkRenderingInfo::pStencilAttachment> : fexgen::custom_repack {};
+
+template<>
+struct fex_gen_config<&VkSubpassDescription2::pInputAttachments> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkSubpassDescription2::pColorAttachments> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkSubpassDescription2::pResolveAttachments> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkSubpassDescription2::pDepthStencilAttachment> : fexgen::custom_repack {};
+
+template<>
+struct fex_gen_config<&VkDependencyInfo::pMemoryBarriers> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkDependencyInfo::pBufferMemoryBarriers> : fexgen::custom_repack {};
+template<>
+struct fex_gen_config<&VkDependencyInfo::pImageMemoryBarriers> : fexgen::custom_repack {};
+
+template<>
+struct fex_gen_config<&VkDescriptorUpdateTemplateCreateInfo::pDescriptorUpdateEntries> : fexgen::custom_repack {};
+
+// These types have incompatible data layout but we use their layout wrappers elsewhere
+template<>
+struct fex_gen_type<VkWriteDescriptorSet> : fexgen::emit_layout_wrappers {};
+#else
 // The pNext member of this is a pointer to another VkBaseOutStructure, so data layout compatibility can't be inferred automatically
 template<>
 struct fex_gen_type<VkBaseOutStructure> : fexgen::assume_compatible_data_layout {};
@@ -127,14 +291,36 @@ struct fex_gen_param {};
 template<auto>
 struct fex_gen_config : fexgen::generate_guest_symtable, fexgen::indirect_guest_calls {};
 
+#ifdef IS_32BIT_THUNK
+template<>
+struct fex_gen_config<&VkCommandBufferBeginInfo::pInheritanceInfo> : fexgen::custom_repack {};
+
+// TODO: Should have per-member compatibility annotation
+template<>
+struct fex_gen_config<&VkPipelineCacheCreateInfo::pInitialData> : fexgen::custom_repack {};
+
+// TODO: Should have per-member compatibility annotation
+template<>
+struct fex_gen_config<&VkRenderPassBeginInfo::pClearValues> : fexgen::custom_repack {};
+#endif
+
 template<>
 struct fex_gen_config<vkCreateInstance> : fexgen::custom_host_impl {};
 template<>
 struct fex_gen_param<vkCreateInstance, 2, VkInstance*> : fexgen::ptr_passthrough {};
 template<>
 struct fex_gen_config<vkDestroyInstance> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkEnumeratePhysicalDevices> {};
+#else
+template<>
+struct fex_gen_config<vkEnumeratePhysicalDevices> : fexgen::custom_host_impl {};
+template<>
+struct fex_gen_param<vkEnumeratePhysicalDevices, 2, VkPhysicalDevice*> : fexgen::ptr_passthrough {};
+#endif
+
+
 template<>
 struct fex_gen_config<vkGetPhysicalDeviceFeatures> {};
 template<>
@@ -162,10 +348,25 @@ template<>
 struct fex_gen_config<vkEnumerateInstanceLayerProperties> {};
 template<>
 struct fex_gen_config<vkEnumerateDeviceLayerProperties> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkGetDeviceQueue> {};
+#else
+template<>
+struct fex_gen_config<vkGetDeviceQueue> : fexgen::custom_host_impl {};
+template<>
+struct fex_gen_param<vkGetDeviceQueue, 3, VkQueue*> : fexgen::ptr_passthrough {};
+#endif
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkQueueSubmit> {};
+#else
+// Needs array repacking for multiple submit infos
+template<>
+struct fex_gen_config<vkQueueSubmit> : fexgen::custom_host_impl {};
+template<>
+struct fex_gen_param<vkQueueSubmit, 2, const VkSubmitInfo*> : fexgen::ptr_passthrough {};
+#endif
 template<>
 struct fex_gen_config<vkQueueWaitIdle> {};
 template<>
@@ -174,16 +375,25 @@ template<>
 struct fex_gen_config<vkAllocateMemory> : fexgen::custom_host_impl {};
 template<>
 struct fex_gen_config<vkFreeMemory> : fexgen::custom_host_impl {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkMapMemory> {};
+#else
+template<>
+struct fex_gen_config<vkMapMemory> : fexgen::custom_host_impl {};
+template<>
+struct fex_gen_param<vkMapMemory, 5, void**> : fexgen::ptr_passthrough {};
+#endif
 template<>
 struct fex_gen_config<vkUnmapMemory> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkFlushMappedMemoryRanges> {};
 template<>
 struct fex_gen_config<vkInvalidateMappedMemoryRanges> {};
 template<>
 struct fex_gen_config<vkGetDeviceMemoryCommitment> {};
+#endif
 template<>
 struct fex_gen_config<vkBindBufferMemory> {};
 template<>
@@ -192,26 +402,31 @@ template<>
 struct fex_gen_config<vkGetBufferMemoryRequirements> {};
 template<>
 struct fex_gen_config<vkGetImageMemoryRequirements> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkGetImageSparseMemoryRequirements> {};
 template<>
 struct fex_gen_config<vkGetPhysicalDeviceSparseImageFormatProperties> {};
 template<>
 struct fex_gen_config<vkQueueBindSparse> {};
+#endif
 template<>
 struct fex_gen_config<vkCreateFence> {};
 template<>
 struct fex_gen_config<vkDestroyFence> {};
 template<>
 struct fex_gen_config<vkResetFences> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkGetFenceStatus> {};
+#endif
 template<>
 struct fex_gen_config<vkWaitForFences> {};
 template<>
 struct fex_gen_config<vkCreateSemaphore> {};
 template<>
 struct fex_gen_config<vkDestroySemaphore> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCreateEvent> {};
 template<>
@@ -230,6 +445,7 @@ template<>
 struct fex_gen_config<vkGetQueryPoolResults> {};
 template<>
 struct fex_gen_param<vkGetQueryPoolResults, 5, void*> : fexgen::assume_compatible_data_layout {};
+#endif
 template<>
 struct fex_gen_config<vkCreateBuffer> {};
 template<>
@@ -256,14 +472,28 @@ template<>
 struct fex_gen_config<vkCreatePipelineCache> {};
 template<>
 struct fex_gen_config<vkDestroyPipelineCache> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkGetPipelineCacheData> {};
+#else
+template<>
+struct fex_gen_config<vkGetPipelineCacheData> : fexgen::custom_host_impl {};
+template<>
+struct fex_gen_param<vkGetPipelineCacheData, 2, size_t*> : fexgen::ptr_passthrough {};
+#endif
+template<>
+struct fex_gen_param<vkGetPipelineCacheData, 3, void*> : fexgen::assume_compatible_data_layout {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkMergePipelineCaches> {};
+#endif
+// TODO: Should be custom_host_impl since there may be more than one VkGraphicsPipelineCreateInfo and more than one output pipeline
 template<>
 struct fex_gen_config<vkCreateGraphicsPipelines> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCreateComputePipelines> {};
+#endif
 template<>
 struct fex_gen_config<vkDestroyPipeline> {};
 template<>
@@ -288,8 +518,17 @@ template<>
 struct fex_gen_config<vkAllocateDescriptorSets> {};
 template<>
 struct fex_gen_config<vkFreeDescriptorSets> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkUpdateDescriptorSets> {};
+#else
+template<>
+struct fex_gen_config<vkUpdateDescriptorSets> : fexgen::custom_host_impl {};
+template<>
+struct fex_gen_param<vkUpdateDescriptorSets, 2, const VkWriteDescriptorSet*> : fexgen::ptr_passthrough {};
+template<>
+struct fex_gen_param<vkUpdateDescriptorSets, 4, const VkCopyDescriptorSet*> : fexgen::ptr_passthrough {};
+#endif
 template<>
 struct fex_gen_config<vkCreateFramebuffer> {};
 template<>
@@ -306,10 +545,25 @@ template<>
 struct fex_gen_config<vkDestroyCommandPool> {};
 template<>
 struct fex_gen_config<vkResetCommandPool> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkAllocateCommandBuffers> {};
+#else
+template<>
+struct fex_gen_config<vkAllocateCommandBuffers> : fexgen::custom_host_impl {};
+template<>
+struct fex_gen_param<vkAllocateCommandBuffers, 2, VkCommandBuffer*> : fexgen::ptr_passthrough {};
+#endif
+
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkFreeCommandBuffers> {};
+#else
+template<>
+struct fex_gen_config<vkFreeCommandBuffers> : fexgen::custom_host_impl {};
+template<>
+struct fex_gen_param<vkFreeCommandBuffers, 3, const VkCommandBuffer*> : fexgen::ptr_passthrough {};
+#endif
 template<>
 struct fex_gen_config<vkBeginCommandBuffer> {};
 template<>
@@ -344,6 +598,7 @@ template<>
 struct fex_gen_config<vkCmdBindVertexBuffers> {};
 template<>
 struct fex_gen_config<vkCmdDraw> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCmdDrawIndexed> {};
 template<>
@@ -360,20 +615,26 @@ template<>
 struct fex_gen_config<vkCmdCopyImage> {};
 template<>
 struct fex_gen_config<vkCmdBlitImage> {};
+#endif
 template<>
 struct fex_gen_config<vkCmdCopyBufferToImage> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCmdCopyImageToBuffer> {};
 template<>
 struct fex_gen_config<vkCmdUpdateBuffer> {};
 template<>
+struct fex_gen_param<vkCmdUpdateBuffer, 4, const void*> : fexgen::assume_compatible_data_layout {};
+template<>
 struct fex_gen_config<vkCmdFillBuffer> {};
 template<>
 struct fex_gen_config<vkCmdClearColorImage> {};
 template<>
 struct fex_gen_config<vkCmdClearDepthStencilImage> {};
+#endif
 template<>
 struct fex_gen_config<vkCmdClearAttachments> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCmdResolveImage> {};
 template<>
@@ -382,8 +643,10 @@ template<>
 struct fex_gen_config<vkCmdResetEvent> {};
 template<>
 struct fex_gen_config<vkCmdWaitEvents> {};
+#endif
 template<>
 struct fex_gen_config<vkCmdPipelineBarrier> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCmdBeginQuery> {};
 template<>
@@ -397,15 +660,23 @@ struct fex_gen_config<vkCmdCopyQueryPoolResults> {};
 template<>
 struct fex_gen_config<vkCmdPushConstants> {};
 template<>
+struct fex_gen_param<vkCmdPushConstants, 5, const void*> : fexgen::assume_compatible_data_layout {};
+#endif
+template<>
 struct fex_gen_config<vkCmdBeginRenderPass> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCmdNextSubpass> {};
+#endif
 template<>
 struct fex_gen_config<vkCmdEndRenderPass> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCmdExecuteCommands> {};
+#endif
 template<>
 struct fex_gen_config<vkEnumerateInstanceVersion> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkBindBufferMemory2> {};
 template<>
@@ -418,12 +689,15 @@ template<>
 struct fex_gen_config<vkCmdDispatchBase> {};
 template<>
 struct fex_gen_config<vkEnumeratePhysicalDeviceGroups> {};
+#endif
 template<>
 struct fex_gen_config<vkGetImageMemoryRequirements2> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkGetBufferMemoryRequirements2> {};
 template<>
 struct fex_gen_config<vkGetImageSparseMemoryRequirements2> {};
+#endif
 template<>
 struct fex_gen_config<vkGetPhysicalDeviceFeatures2> {};
 template<>
@@ -432,6 +706,7 @@ template<>
 struct fex_gen_config<vkGetPhysicalDeviceFormatProperties2> {};
 template<>
 struct fex_gen_config<vkGetPhysicalDeviceImageFormatProperties2> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkGetPhysicalDeviceQueueFamilyProperties2> {};
 template<>
@@ -446,6 +721,7 @@ template<>
 struct fex_gen_config<vkCreateSamplerYcbcrConversion> {};
 template<>
 struct fex_gen_config<vkDestroySamplerYcbcrConversion> {};
+#endif
 template<>
 struct fex_gen_config<vkCreateDescriptorUpdateTemplate> {};
 template<>
@@ -454,20 +730,25 @@ template<>
 struct fex_gen_config<vkUpdateDescriptorSetWithTemplate> {};
 template<>
 struct fex_gen_param<vkUpdateDescriptorSetWithTemplate, 3, const void*> : fexgen::assume_compatible_data_layout {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkGetPhysicalDeviceExternalBufferProperties> {};
 template<>
 struct fex_gen_config<vkGetPhysicalDeviceExternalFenceProperties> {};
 template<>
 struct fex_gen_config<vkGetPhysicalDeviceExternalSemaphoreProperties> {};
+#endif
 template<>
 struct fex_gen_config<vkGetDescriptorSetLayoutSupport> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCmdDrawIndirectCount> {};
 template<>
 struct fex_gen_config<vkCmdDrawIndexedIndirectCount> {};
+#endif
 template<>
 struct fex_gen_config<vkCreateRenderPass2> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCmdBeginRenderPass2> {};
 template<>
@@ -478,8 +759,10 @@ template<>
 struct fex_gen_config<vkResetQueryPool> {};
 template<>
 struct fex_gen_config<vkGetSemaphoreCounterValue> {};
+#endif
 template<>
 struct fex_gen_config<vkWaitSemaphores> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkSignalSemaphore> {};
 template<>
@@ -504,8 +787,10 @@ template<>
 struct fex_gen_config<vkCmdResetEvent2> {};
 template<>
 struct fex_gen_config<vkCmdWaitEvents2> {};
+#endif
 template<>
 struct fex_gen_config<vkCmdPipelineBarrier2> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCmdWriteTimestamp2> {};
 template<>
@@ -522,10 +807,12 @@ template<>
 struct fex_gen_config<vkCmdBlitImage2> {};
 template<>
 struct fex_gen_config<vkCmdResolveImage2> {};
+#endif
 template<>
 struct fex_gen_config<vkCmdBeginRendering> {};
 template<>
 struct fex_gen_config<vkCmdEndRendering> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCmdSetCullMode> {};
 template<>
@@ -562,6 +849,7 @@ template<>
 struct fex_gen_config<vkGetDeviceImageMemoryRequirements> {};
 template<>
 struct fex_gen_config<vkGetDeviceImageSparseMemoryRequirements> {};
+#endif
 template<>
 struct fex_gen_config<vkCmdSetLineStipple> {};
 template<>
@@ -609,7 +897,7 @@ struct fex_gen_config<vkGetPhysicalDeviceSurfaceSupportKHR> {};
 template<>
 struct fex_gen_config<vkGetPhysicalDeviceSurfaceCapabilitiesKHR> {};
 template<>
-struct fex_gen_config<vkGetPhysicalDeviceSurfaceFormatsKHR> {};
+struct fex_gen_config<vkGetPhysicalDeviceSurfaceFormatsKHR> {}; // TODO: Need to figure out how *not* to repack the last parameter on input...
 template<>
 struct fex_gen_config<vkGetPhysicalDeviceSurfacePresentModesKHR> {};
 template<>
@@ -622,6 +910,7 @@ template<>
 struct fex_gen_config<vkAcquireNextImageKHR> {};
 template<>
 struct fex_gen_config<vkQueuePresentKHR> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkGetDeviceGroupPresentCapabilitiesKHR> {};
 template<>
@@ -714,20 +1003,24 @@ template<>
 struct fex_gen_config<vkGetSemaphoreFdKHR> {};
 template<>
 struct fex_gen_config<vkCmdPushDescriptorSetKHR> {};
+#endif
 template<>
 struct fex_gen_config<vkCmdPushDescriptorSetWithTemplateKHR> {};
 template<>
 struct fex_gen_param<vkCmdPushDescriptorSetWithTemplateKHR, 4, const void*> : fexgen::assume_compatible_data_layout {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCreateDescriptorUpdateTemplateKHR> {};
 template<>
 struct fex_gen_config<vkDestroyDescriptorUpdateTemplateKHR> {};
+#endif
 template<>
 struct fex_gen_config<vkUpdateDescriptorSetWithTemplateKHR> {};
 template<>
 struct fex_gen_param<vkUpdateDescriptorSetWithTemplateKHR, 3, const void*> : fexgen::assume_compatible_data_layout {};
 template<>
 struct fex_gen_config<vkCreateRenderPass2KHR> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCmdBeginRenderPass2KHR> {};
 template<>
@@ -900,12 +1193,14 @@ template<>
 struct fex_gen_config<vkCmdSetDescriptorBufferOffsets2EXT> {};
 template<>
 struct fex_gen_config<vkCmdBindDescriptorBufferEmbeddedSamplers2EXT> {};
+#endif
 template<>
 struct fex_gen_config<vkCreateDebugReportCallbackEXT> : fexgen::custom_host_impl {};
 template<>
 struct fex_gen_param<vkCreateDebugReportCallbackEXT, 1, const VkDebugReportCallbackCreateInfoEXT*> : fexgen::ptr_passthrough {};
 template<>
 struct fex_gen_config<vkDestroyDebugReportCallbackEXT> : fexgen::custom_host_impl {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkDebugReportMessageEXT> {};
 template<>
@@ -1002,12 +1297,14 @@ template<>
 struct fex_gen_config<vkCmdEndDebugUtilsLabelEXT> {};
 template<>
 struct fex_gen_config<vkCmdInsertDebugUtilsLabelEXT> {};
+#endif
 template<>
 struct fex_gen_config<vkCreateDebugUtilsMessengerEXT> : fexgen::custom_host_impl {};
 template<>
 struct fex_gen_param<vkCreateDebugUtilsMessengerEXT, 1, const VkDebugUtilsMessengerCreateInfoEXT*> : fexgen::ptr_passthrough {};
 template<>
 struct fex_gen_config<vkDestroyDebugUtilsMessengerEXT> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkSubmitDebugUtilsMessageEXT> {};
 template<>
@@ -1070,10 +1367,12 @@ template<>
 struct fex_gen_param<vkGetMemoryHostPointerPropertiesEXT, 2, const void*> : fexgen::assume_compatible_data_layout {};
 template<>
 struct fex_gen_config<vkCmdWriteBufferMarkerAMD> {};
+#endif
 template<>
 struct fex_gen_config<vkCmdWriteBufferMarker2AMD> {};
 template<>
 struct fex_gen_config<vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkGetCalibratedTimestampsEXT> {};
 template<>
@@ -1236,8 +1535,11 @@ template<>
 struct fex_gen_config<vkCmdSubpassShadingHUAWEI> {};
 template<>
 struct fex_gen_config<vkCmdBindInvocationMaskHUAWEI> {};
+#ifndef IS_32BIT_THUNK
+// VkRemoteAddressNV* expands to void**, so it needs custom repacking on on 32-bit
 template<>
 struct fex_gen_config<vkGetMemoryRemoteAddressNV> {};
+#endif
 template<>
 struct fex_gen_config<vkGetPipelinePropertiesEXT> {};
 template<>
@@ -1250,8 +1552,10 @@ template<>
 struct fex_gen_config<vkCmdSetLogicOpEXT> {};
 template<>
 struct fex_gen_config<vkCmdSetPrimitiveRestartEnableEXT> {};
+#endif
 template<>
 struct fex_gen_config<vkCmdSetColorWriteEnableEXT> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkCmdDrawMultiEXT> {};
 template<>
@@ -1514,8 +1818,10 @@ template<>
 struct fex_gen_param<vkGetRandROutputDisplayEXT, 1, Display*> : fexgen::ptr_passthrough {};
 
 // vulkan_wayland.h
+#endif
 template<>
 struct fex_gen_config<vkCreateWaylandSurfaceKHR> {};
+#ifndef IS_32BIT_THUNK
 template<>
 struct fex_gen_config<vkGetPhysicalDeviceWaylandPresentationSupportKHR> {};
 
@@ -1534,5 +1840,5 @@ template<>
 struct fex_gen_config<vkGetPhysicalDeviceXlibPresentationSupportKHR> : fexgen::custom_host_impl {};
 template<>
 struct fex_gen_param<vkGetPhysicalDeviceXlibPresentationSupportKHR, 2, Display*> : fexgen::ptr_passthrough {};
-
+#endif
 } // namespace internal