diff --git a/FEXCore/Source/Interface/Core/Dispatcher/Arm64Dispatcher.cpp b/FEXCore/Source/Interface/Core/Dispatcher/Arm64Dispatcher.cpp
index 8d052aa26e..991a731b5d 100644
--- a/FEXCore/Source/Interface/Core/Dispatcher/Arm64Dispatcher.cpp
+++ b/FEXCore/Source/Interface/Core/Dispatcher/Arm64Dispatcher.cpp
@@ -368,7 +368,8 @@ void Arm64Dispatcher::EmitDispatcher() {
     LoadConstant(ARMEmitter::Size::i64Bit, ARMEmitter::Reg::r0, CTX->X86CodeGen.CallbackReturn);
 
     ldr(ARMEmitter::XReg::x2, STATE_PTR(CpuStateFrame, State.gregs[X86State::REG_RSP]));
-    sub(ARMEmitter::Size::i64Bit, ARMEmitter::Reg::r2, ARMEmitter::Reg::r2, 16);
+    // TODO: Is this right for 32-bit?
+    sub(ARMEmitter::Size::i64Bit, ARMEmitter::Reg::r2, ARMEmitter::Reg::r2, CTX->Config.Is64BitMode ? 16 : 12);
     str(ARMEmitter::XReg::x2, STATE_PTR(CpuStateFrame, State.gregs[X86State::REG_RSP]));
 
     // Store the trampoline to the guest stack
diff --git a/FEXCore/Source/Interface/Core/GdbServer.cpp b/FEXCore/Source/Interface/Core/GdbServer.cpp
index ec16e2804d..0455fda925 100644
--- a/FEXCore/Source/Interface/Core/GdbServer.cpp
+++ b/FEXCore/Source/Interface/Core/GdbServer.cpp
@@ -247,9 +247,22 @@ void GdbServer::SendACK(std::ostream &stream, bool NACK) {
   }
 }
 
+constexpr std::array<std::string_view const, 8> RegNames32 = {
+  "eax",
+  "ecx",
+  "edx",
+  "ebx",
+  "esp",
+  "ebp",
+  "esi",
+  "edi",
+};
+
 struct FEX_PACKED GDBContextDefinition {
-  uint64_t gregs[Core::CPUState::NUM_GPRS];
-  uint64_t rip;
+//  uint64_t gregs[Core::CPUState::NUM_GPRS];
+//  uint64_t rip;
+  uint32_t gregs[8];
+  uint32_t rip;
   uint32_t eflags;
   uint32_t cs, ss, ds, es, fs, gs;
   X80SoftFloat mm[Core::CPUState::NUM_MMS];
@@ -284,8 +297,12 @@ fextl::string GdbServer::readRegs() {
   }
 
   // Encode the GDB context definition
-  memcpy(&GDB.gregs[0], &state.gregs[0], sizeof(GDB.gregs));
-  memcpy(&GDB.rip, &state.rip, sizeof(GDB.rip));
+//  memcpy(&GDB.gregs[0], &state.gregs[0], sizeof(GDB.gregs));
+for (int i = 0; i < std::size(RegNames32); ++i) {
+  memcpy(&GDB.gregs[i], &state.gregs[i], 4);
+}
+//  memcpy(&GDB.rip, &state.rip, sizeof(GDB.rip));
+  memcpy(&GDB.rip, &state.rip, 4);
 
   GDB.eflags = CTX->ReconstructCompactedEFLAGS(CurrentThread);
 
@@ -334,7 +351,7 @@ GdbServer::HandledPacketType GdbServer::readReg(const fextl::string& packet) {
     memcpy(&state, CTX->ParentThread->CurrentFrame, sizeof(state));
   }
 
-
+// TODO: 32 bit?
   if (addr >= offsetof(GDBContextDefinition, gregs[0]) &&
       addr < offsetof(GDBContextDefinition, gregs[16])) {
     return {encodeHex((unsigned char *)(&state.gregs[addr / sizeof(uint64_t)]), sizeof(uint64_t)), HandledPacketType::TYPE_ACK};
@@ -396,7 +413,8 @@ fextl::string buildTargetXML() {
   xml << "<?xml version='1.0'?>\n";
   xml << "<!DOCTYPE target SYSTEM 'gdb-target.dtd'>\n";
   xml << "<target>\n";
-  xml << "<architecture>i386:x86-64</architecture>\n";
+//  xml << "<architecture>i386:x86-64</architecture>\n";
+  xml << "<architecture>i386</architecture>\n";
   xml << "<osabi>GNU/Linux</osabi>\n";
     xml << "<feature name='org.gnu.gdb.i386.core'>\n";
 
@@ -421,11 +439,16 @@ fextl::string buildTargetXML() {
       // We want to just memcpy our x86 state to gdb, so we tell it the ordering.
 
       // GPRs
-      for (uint32_t i = 0; i < Core::CPUState::NUM_GPRS; i++) {
-        reg(FEXCore::Core::GetGRegName(i), "int64", 64);
+//      for (uint32_t i = 0; i < Core::CPUState::NUM_GPRS; i++) {
+//        reg(FEXCore::Core::GetGRegName(i), "int64", 64);
+//      }
+
+      for (uint32_t i = 0; i < std::size(RegNames32); i++) {
+        reg(RegNames32[i], "int32", 32);
       }
 
-      reg("rip", "code_ptr", 64);
+//      reg("rip", "code_ptr", 64);
+      reg("eip", "code_ptr", 32);
 
       reg("eflags", "fex_eflags", 32);
 
@@ -478,6 +501,7 @@ fextl::string buildTargetXML() {
         )";
 
       // SSE regs
+      // TODO: Only up to incl xmm7 on 32-bit?
       for (size_t i = 0; i < Core::CPUState::NUM_XMMS; i++) {
           reg(fextl::fmt::format("xmm{}", i), "vec128", 128);
       }
diff --git a/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp b/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp
index 0af9bc3ca9..4fa5bab992 100644
--- a/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp
+++ b/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp
@@ -50,7 +50,7 @@ static __attribute__((aligned(16), naked, section("HostToGuestTrampolineTemplate
     "jmpq *0f(%rip) \n"
     ".align 8 \n"
     "0: \n"
-    ".quad 0, 0, 0, 0 \n" // TrampolineInstanceInfo
+    ".quad 0, 0, 0, 0, 0 \n" // TrampolineInstanceInfo
   );
 #elif defined(_M_ARM_64)
   asm(
@@ -59,10 +59,9 @@ static __attribute__((aligned(16), naked, section("HostToGuestTrampolineTemplate
     "adr x11, 0f \n"
     "br x16 \n"
     // Manually align to the next 8-byte boundary
-    // NOTE: GCC over-aligns to a full page when using .align directives on ARM (last tested on GCC 11.2)
     "nop \n"
     "0: \n"
-    ".quad 0, 0, 0, 0 \n" // TrampolineInstanceInfo
+    ".quad 0, 0, 0, 0, 0 \n" // TrampolineInstanceInfo
   );
 #else
 #error Unsupported host architecture
@@ -81,6 +80,13 @@ namespace FEXCore {
 
   static thread_local FEXCore::Core::InternalThreadState *Thread;
 
+    struct AsyncCallbackState {
+      FEXCore::Core::InternalThreadState *Thread { nullptr };
+
+      std::mutex m;
+      std::condition_variable var;
+      std::atomic<bool> done { false };
+    };
 
     struct ExportEntry { uint8_t *sha256; ThunkedFunction* Fn; };
 
@@ -89,6 +95,7 @@ namespace FEXCore {
       uintptr_t CallCallback;
       uintptr_t GuestUnpacker;
       uintptr_t GuestTarget;
+      AsyncCallbackState *AsyncWorkerThread;
     };
 
     // Opaque type pointing to an instance of HostToGuestTrampolineTemplate and its
@@ -155,6 +162,16 @@ namespace FEXCore {
                 { 0x9b, 0xb2, 0xf4, 0xb4, 0x83, 0x7d, 0x28, 0x93, 0x40, 0xcb, 0xf4, 0x7a, 0x0b, 0x47, 0x85, 0x87, 0xf9, 0xbc, 0xb5, 0x27, 0xca, 0xa6, 0x93, 0xa5, 0xc0, 0x73, 0x27, 0x24, 0xae, 0xc8, 0xb8, 0x5a },
                 &AllocateHostTrampolineForGuestFunction
             },
+            {
+                // TODO: sha256(fex:register_async_worker_thread)
+                { 0x9c, 0xb2, 0xf4, 0xb4, 0x83, 0x7d, 0x28, 0x93, 0x40, 0xcb, 0xf4, 0x7a, 0x0b, 0x47, 0x85, 0x87, 0xf9, 0xbc, 0xb5, 0x27, 0xca, 0xa6, 0x93, 0xa5, 0xc0, 0x73, 0x27, 0x24, 0xae, 0xc8, 0xb8, 0x5a },
+                &RegisterAsyncWorkerThread
+            },
+            {
+                // TODO: sha256(fex:unregister_async_worker_thread)
+                { 0x9d, 0xb2, 0xf4, 0xb4, 0x83, 0x7d, 0x28, 0x93, 0x40, 0xcb, 0xf4, 0x7a, 0x0b, 0x47, 0x85, 0x87, 0xf9, 0xbc, 0xb5, 0x27, 0xca, 0xa6, 0x93, 0xa5, 0xc0, 0x73, 0x27, 0x24, 0xae, 0xc8, 0xb8, 0x5a },
+                &UnregisterAsyncWorkerThread
+            },
         };
 
         // Can't be a string_view. We need to keep a copy of the library name in-case string_view pointer goes away.
@@ -166,15 +183,111 @@ namespace FEXCore {
         uint8_t *HostTrampolineInstanceDataPtr;
         size_t HostTrampolineInstanceDataAvailable = 0;
 
+        std::unordered_map<unsigned, AsyncCallbackState> AsyncWorkerThreads;
+        std::mutex AsyncWorkerThreadsMutex;
+
+        /**
+         * Registers the calling thread as a worker thread for callback
+         * functions that are asynchronously invoked in a host context.
+         *
+         * Such a worker thread must be designated since otherwise there is no
+         * x86 context to run the callback in. Most importantly, this would
+         * prevent TLS from working.
+         *
+         * Before the worker thread shuts down, UnregisterAsyncWorkerThread
+         * must be called.
+         */
+        static void RegisterAsyncWorkerThread(void* argsv) {
+          struct args_t {
+              unsigned id;
+          } args = *reinterpret_cast<args_t*>(argsv);
+
+          auto ThunkHandler = reinterpret_cast<ThunkHandler_impl*>(static_cast<Context::ContextImpl*>(Thread->CTX)->ThunkHandler.get());
+
+          AsyncCallbackState *WorkerState = nullptr;
+          {
+            // Create and initialize new entry
+            std::unique_lock lock(ThunkHandler->AsyncWorkerThreadsMutex);
+            WorkerState = &ThunkHandler->AsyncWorkerThreads[args.id];
+            WorkerState->Thread = Thread;
+          }
+
+          pthread_setname_np(pthread_self(), "ThunkAsyncWorkerThread");
+
+          // Pause thread until woken up by UnregisterAsyncWorkerThread
+          {
+            std::unique_lock lock(WorkerState->m);
+            WorkerState->var.wait(lock, [WorkerState]() -> bool { return WorkerState->done; });
+            fprintf(stderr, "EXITING ASYNC THUNK WORKER THREAD\n");
+          }
+
+        }
+
+        static void UnregisterAsyncWorkerThread(void* argsv) {
+          struct args_t {
+              unsigned id;
+          } args = *reinterpret_cast<args_t*>(argsv);
+
+          auto ThunkHandler = reinterpret_cast<ThunkHandler_impl*>(static_cast<Context::ContextImpl*>(Thread->CTX)->ThunkHandler.get());
+
+          std::unique_lock lock(ThunkHandler->AsyncWorkerThreadsMutex);
+
+          auto WorkerState = ThunkHandler->AsyncWorkerThreads.find(args.id);
+
+          {
+            WorkerState->second.done = true;
+            WorkerState->second.var.notify_one();
+          }
 
-        /*
-            Set arg0/1 to arg regs, use CTX::HandleCallback to handle the callback
-        */
+          ThunkHandler->AsyncWorkerThreads.erase(WorkerState);
+        }
+
+        /**
+         * Set arg0/1 to arg regs, use CTX::HandleCallback to handle the callback.
+         *
+         * If the callback is called asynchronously from the host-side, a
+         * guest worker thread to inject the call into must be provided.
+         * Otherwise, this may only be used from a guest thread (including
+         * synchronous uses from the host-side).
+         */
         static void CallCallback(void *callback, void *arg0, void* arg1) {
-          Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RDI] = (uintptr_t)arg0;
-          Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RSI] = (uintptr_t)arg1;
+          if (true) {
+            auto CTX = static_cast<Context::ContextImpl*>(Thread->CTX);
+            if (CTX->Config.Is64BitMode) {
+              Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RDI] = (uintptr_t)arg0;
+              Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RSI] = (uintptr_t)arg1;
+              fprintf(stderr, "Calling guest callback %p with args %p\n", callback, arg1);
+            } else {
+              // Args was allocated on stack, so it's not actually in 32-bit address space... relocate it to an appropriate location here
+              // TODO: Use a location that's representable in the first place!
+              static void* local_args = []() -> void* {
+                return (uint8_t *)mmap(
+                    0, 1000,
+                    PROT_READ | PROT_WRITE | PROT_EXEC,
+                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+              }();
+
+              memcpy(local_args, arg1, 100);
+
+              Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RCX] = (uintptr_t)arg0;
+              Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RDX] = (uintptr_t)/*arg1*/ local_args;
+              fprintf(stderr, "Calling guest callback %p with args %p (-> %p)\n", callback, arg1, local_args);
+            }
+
+            Thread->CTX->HandleCallback(Thread, (uintptr_t)callback);
+          } else {
+            FEXCore::Core::InternalThreadState* ActiveThread = nullptr;
+            auto ThunksHandler = reinterpret_cast<ThunkHandler_impl*>(static_cast<Context::ContextImpl*>(ActiveThread->CTX)->ThunkHandler.get());
 
-          Thread->CTX->HandleCallback(Thread, (uintptr_t)callback);
+            std::unique_lock lock(ThunksHandler->AsyncWorkerThreadsMutex);
+            ActiveThread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RDI] = (uintptr_t)arg0;
+            ActiveThread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RSI] = (uintptr_t)arg1;
+
+            // TODO: Instead of registering new TLS state for this, re-use the TLS state from the asynchronous worker thread
+            static_cast<Context::ContextImpl*>(ActiveThread->CTX)->SignalDelegation->RegisterTLSState(ActiveThread);
+            ActiveThread->CTX->HandleCallback(ActiveThread, (uintptr_t)callback);
+            static_cast<Context::ContextImpl*>(ActiveThread->CTX)->SignalDelegation->UninstallTLSState(ActiveThread);
+          }
         }
 
         /**
@@ -220,7 +333,7 @@ namespace FEXCore {
                           emit->_StoreRegister(emit->_Constant(Entrypoint), false, offsetof(Core::CPUState, gregs[X86State::REG_R11]), IR::GPRClass, IR::GPRFixedClass, GPRSize);
                         }
                         else {
-                          emit->_StoreRegister(emit->_Constant(Entrypoint), false, offsetof(Core::CPUState, mm[0][0]), IR::GPRClass, IR::GPRFixedClass, GPRSize);
+                          emit->_StoreContext(GPRSize, IR::FPRClass, emit->_VCastFromGPR(8, 8, emit->_Constant(Entrypoint)), offsetof(Core::CPUState, mm[0][0]));
                         }
                         emit->_ExitFunction(emit->_Constant(GuestThunkEntrypoint));
                     }, CTX->ThunkHandler.get(), (void*)args->target_addr);
@@ -473,10 +586,24 @@ namespace FEXCore {
       }
     }
 
+    FEX_DEFAULT_VISIBILITY
+    void MakeHostTrampolineForGuestFunctionAsyncCallable(HostToGuestTrampolinePtr* TrampolineAddress, unsigned AsyncWorkerThreadId) {
+      if (!TrampolineAddress) {
+        return;
+      }
+
+      auto& Trampoline = GetInstanceInfo(TrampolineAddress);
+
+      LOGMAN_THROW_A_FMT(Trampoline.CallCallback == (uintptr_t)&ThunkHandler_impl::CallCallback,
+                        "Invalid trampoline at {} passed to {}", fmt::ptr(TrampolineAddress), __FUNCTION__);
+
+      auto ThunksHandler = reinterpret_cast<ThunkHandler_impl*>(static_cast<Context::ContextImpl*>(Thread->CTX)->ThunkHandler.get());
+      Trampoline.AsyncWorkerThread = &ThunksHandler->AsyncWorkerThreads.at(AsyncWorkerThreadId);
+    }
+
 #else
     fextl::unique_ptr<ThunkHandler> ThunkHandler::Create() {
       ERROR_AND_DIE_FMT("Unsupported");
     }
 #endif
-
 }
diff --git a/FEXCore/Source/Utils/Allocator.cpp b/FEXCore/Source/Utils/Allocator.cpp
index b4a4d55388..cd77066e4c 100644
--- a/FEXCore/Source/Utils/Allocator.cpp
+++ b/FEXCore/Source/Utils/Allocator.cpp
@@ -82,7 +82,7 @@ namespace FEXCore::Allocator {
   // so that when the sbrk syscall is used to allocate more memory, it fails with an ENOMEM since it runs in to the allocated guard page.
   //
   // glibc notices the sbrk failure and falls back to regular mmap based allocations when this occurs. Ensuring that memory can still be allocated.
-  void *DisableSBRKAllocations() {
+  extern "C" void *DisableSBRKAllocations() {
     void* INVALID_PTR = reinterpret_cast<void*>(~0ULL);
     // Get the starting sbrk pointer.
     void *StartingSBRK = sbrk(0);
@@ -121,10 +121,15 @@ namespace FEXCore::Allocator {
     }
   }
 
+extern "C" void BigYolo() {
+    Alloc64 = Alloc::OSAllocator::Create64BitAllocator();
+}
+
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   void SetupHooks() {
-    Alloc64 = Alloc::OSAllocator::Create64BitAllocator();
+//    Alloc64 = Alloc::OSAllocator::Create64BitAllocator();
+
 #ifdef ENABLE_JEMALLOC
     je___mmap_hook   = FEX_mmap;
     je___munmap_hook = FEX_munmap;
diff --git a/FEXCore/include/FEXCore/Utils/Allocator.h b/FEXCore/include/FEXCore/Utils/Allocator.h
index 73d287c38d..dcd84a6c4b 100644
--- a/FEXCore/include/FEXCore/Utils/Allocator.h
+++ b/FEXCore/include/FEXCore/Utils/Allocator.h
@@ -62,7 +62,7 @@ namespace FEXCore::Allocator {
 
   // Disable allocations through glibc's sbrk allocation method.
   // Returns a pointer at the end of the sbrk region.
-  FEX_DEFAULT_VISIBILITY void *DisableSBRKAllocations();
+  extern "C" FEX_DEFAULT_VISIBILITY void *DisableSBRKAllocations();
 
   // Allow sbrk again. Pass in the pointer returned by `DisableSBRKAllocations`
   FEX_DEFAULT_VISIBILITY void ReenableSBRKAllocations(void* Ptr);
diff --git a/Source/Tools/FEXLoader/FEXLoader.cpp b/Source/Tools/FEXLoader/FEXLoader.cpp
index 685bdaa956..1a371d91fe 100644
--- a/Source/Tools/FEXLoader/FEXLoader.cpp
+++ b/Source/Tools/FEXLoader/FEXLoader.cpp
@@ -249,7 +249,6 @@ namespace FEX::TSO {
 }
 
 int main(int argc, char **argv, char **const envp) {
-  auto SBRKPointer = FEXCore::Allocator::DisableSBRKAllocations();
   FEXCore::Allocator::GLIBCScopedFault GLIBFaultScope;
   const bool IsInterpreter = RanAsInterpreter(argv[0]);
 
@@ -566,7 +565,6 @@ int main(int argc, char **argv, char **const envp) {
   FEXCore::Telemetry::Shutdown(Program.ProgramName);
   FEXCore::Profiler::Shutdown();
 
-  FEXCore::Allocator::ReenableSBRKAllocations(SBRKPointer);
 
   if (ShutdownReason == FEXCore::Context::ExitReason::EXIT_SHUTDOWN) {
     return ProgramStatus;
diff --git a/Source/Tools/FEXLoader/VDSO_Emulation.cpp b/Source/Tools/FEXLoader/VDSO_Emulation.cpp
index 0572ec1483..ad16a5492c 100644
--- a/Source/Tools/FEXLoader/VDSO_Emulation.cpp
+++ b/Source/Tools/FEXLoader/VDSO_Emulation.cpp
@@ -45,7 +45,7 @@ namespace FEX::VDSO {
     // glibc handlers
     namespace glibc {
       static void time(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           time_t *a_0;
           uint64_t rv;
         } *args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
@@ -55,7 +55,7 @@ namespace FEX::VDSO {
       }
 
       static void gettimeofday(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           struct timeval *tv;
           struct timezone *tz;
           uint64_t rv;
@@ -66,7 +66,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_gettime(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           struct timespec *tp;
           uint64_t rv;
@@ -77,7 +77,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_getres(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           struct timespec *tp;
           uint64_t rv;
@@ -88,7 +88,7 @@ namespace FEX::VDSO {
       }
 
       static void getcpu(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           uint32_t *cpu;
           uint32_t *node;
           uint64_t rv;
@@ -102,7 +102,7 @@ namespace FEX::VDSO {
     namespace VDSO {
       // VDSO handlers
       static void time(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           time_t *a_0;
           uint64_t rv;
         } *args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
@@ -111,7 +111,7 @@ namespace FEX::VDSO {
       }
 
       static void gettimeofday(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           struct timeval *tv;
           struct timezone *tz;
           uint64_t rv;
@@ -121,7 +121,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_gettime(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           struct timespec *tp;
           uint64_t rv;
@@ -131,7 +131,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_getres(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           struct timespec *tp;
           uint64_t rv;
@@ -141,7 +141,7 @@ namespace FEX::VDSO {
       }
 
       static void getcpu(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           uint32_t *cpu;
           uint32_t *node;
           uint64_t rv;
@@ -168,7 +168,7 @@ namespace FEX::VDSO {
 
       // glibc handlers
       static void time(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           HLE::x32::compat_ptr<FEX::HLE::x32::old_time32_t> a_0;
           int rv;
         } *args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
@@ -182,7 +182,7 @@ namespace FEX::VDSO {
       }
 
       static void gettimeofday(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           HLE::x32::compat_ptr<FEX::HLE::x32::timeval32> tv;
           HLE::x32::compat_ptr<struct timezone> tz;
           int rv;
@@ -203,7 +203,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_gettime(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           HLE::x32::compat_ptr<HLE::x32::timespec32> tp;
           int rv;
@@ -219,7 +219,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_gettime64(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           HLE::x32::compat_ptr<struct timespec> tp;
           int rv;
@@ -230,7 +230,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_getres(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           HLE::x32::compat_ptr<HLE::x32::timespec32> tp;
           int rv;
@@ -247,7 +247,7 @@ namespace FEX::VDSO {
       }
 
       static void getcpu(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           HLE::x32::compat_ptr<uint32_t> cpu;
           HLE::x32::compat_ptr<uint32_t> node;
           int rv;
@@ -265,7 +265,7 @@ namespace FEX::VDSO {
 
       // VDSO handlers
       static void time(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           HLE::x32::compat_ptr<FEX::HLE::x32::old_time32_t> a_0;
           int rv;
         } *args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
@@ -279,7 +279,7 @@ namespace FEX::VDSO {
       }
 
       static void gettimeofday(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           HLE::x32::compat_ptr<FEX::HLE::x32::timeval32> tv;
           HLE::x32::compat_ptr<struct timezone> tz;
           int rv;
@@ -300,7 +300,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_gettime(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           HLE::x32::compat_ptr<HLE::x32::timespec32> tp;
           int rv;
@@ -316,7 +316,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_gettime64(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           HLE::x32::compat_ptr<struct timespec> tp;
           int rv;
@@ -326,7 +326,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_getres(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           HLE::x32::compat_ptr<HLE::x32::timespec32> tp;
           int rv;
@@ -343,7 +343,7 @@ namespace FEX::VDSO {
       }
 
       static void getcpu(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           HLE::x32::compat_ptr<uint32_t> cpu;
           HLE::x32::compat_ptr<uint32_t> node;
           int rv;
diff --git a/ThunkLibs/Generator/CMakeLists.txt b/ThunkLibs/Generator/CMakeLists.txt
index 55f27216b8..f628db6874 100644
--- a/ThunkLibs/Generator/CMakeLists.txt
+++ b/ThunkLibs/Generator/CMakeLists.txt
@@ -1,7 +1,7 @@
 find_package(Clang REQUIRED CONFIG)
 find_package(OpenSSL REQUIRED COMPONENTS Crypto)
 
-add_library(thunkgenlib analysis.cpp gen.cpp)
+add_library(thunkgenlib analysis.cpp data_layout.cpp gen.cpp)
 target_include_directories(thunkgenlib INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
 target_include_directories(thunkgenlib SYSTEM PUBLIC ${CLANG_INCLUDE_DIRS})
 target_link_libraries(thunkgenlib PUBLIC clang-cpp LLVM)
diff --git a/ThunkLibs/Generator/analysis.cpp b/ThunkLibs/Generator/analysis.cpp
index 39f02577c9..ecbbbaa86d 100644
--- a/ThunkLibs/Generator/analysis.cpp
+++ b/ThunkLibs/Generator/analysis.cpp
@@ -62,7 +62,6 @@ static NamespaceAnnotations GetNamespaceAnnotations(clang::ASTContext& context,
 enum class CallbackStrategy {
     Default,
     Stub,
-    Guest,
 };
 
 struct Annotations {
@@ -88,8 +87,6 @@ static Annotations GetAnnotations(clang::ASTContext& context, clang::CXXRecordDe
             ret.custom_host_impl = true;
         } else if (annotation == "fexgen::callback_stub") {
             ret.callback_strategy = CallbackStrategy::Stub;
-        } else if (annotation == "fexgen::callback_guest") {
-            ret.callback_strategy = CallbackStrategy::Guest;
         } else if (annotation == "fexgen::custom_guest_entrypoint") {
             ret.custom_guest_entrypoint = true;
         } else {
@@ -128,6 +125,7 @@ void AnalysisAction::ExecuteAction() {
 
     try {
         ParseInterface(context);
+        CoverReferencedTypes(context);
         EmitOutput(context);
     } catch (ClangDiagnosticAsException& exception) {
         exception.Report(context.getDiagnostics());
@@ -149,9 +147,62 @@ FindClassTemplateDeclByName(clang::DeclContext& decl_context, std::string_view s
     }
 }
 
+struct TypeAnnotations {
+    bool is_opaque = false;
+    bool assumed_compatible = false;
+};
+
+static TypeAnnotations GetTypeAnnotations(clang::ASTContext& context, clang::CXXRecordDecl* decl) {
+    if (!decl->hasDefinition()) {
+        return {};
+    }
+
+    ErrorReporter report_error { context };
+    TypeAnnotations ret;
+
+    for (const clang::CXXBaseSpecifier& base : decl->bases()) {
+        auto annotation = base.getType().getAsString();
+        if (annotation == "fexgen::opaque_type") {
+            ret.is_opaque = true;
+        } else if (annotation == "fexgen::assume_compatible_data_layout") {
+            ret.assumed_compatible = true;
+        } else {
+            throw report_error(base.getSourceRange().getBegin(), "Unknown type annotation");
+        }
+    }
+
+    return ret;
+}
+
+static ParameterAnnotations GetParameterAnnotations(clang::ASTContext& context, clang::CXXRecordDecl* decl) {
+    if (!decl->hasDefinition()) {
+        return {};
+    }
+
+    ErrorReporter report_error { context };
+    ParameterAnnotations ret;
+
+    for (const clang::CXXBaseSpecifier& base : decl->bases()) {
+        auto annotation = base.getType().getAsString();
+        if (annotation == "fexgen::ptr_passthrough") {
+            ret.is_passthrough = true;
+        } else if (annotation == "fexgen::assume_compatible_data_layout") {
+            // TODO: Rename?
+            ret.is_opaque = true;
+        } else {
+            throw report_error(base.getSourceRange().getBegin(), "Unknown parameter annotation");
+        }
+    }
+
+    return ret;
+}
+
 void AnalysisAction::ParseInterface(clang::ASTContext& context) {
     ErrorReporter report_error { context };
 
+    const std::unordered_map<unsigned, ParameterAnnotations> no_param_annotations {};
+
+    // TODO: Assert fex_gen_type is not declared at non-global namespaces
     if (auto template_decl = FindClassTemplateDeclByName(*context.getTranslationUnitDecl(), "fex_gen_type")) {
         for (auto* decl : template_decl->specializations()) {
             const auto& template_args = decl->getTemplateArgs();
@@ -161,8 +212,52 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
             //       named types (e.g. GLuint/GLenum) are represented by
             //       different Type instances. The canonical type they refer
             //       to is unique, however.
-            auto type = context.getCanonicalType(template_args[0].getAsType()).getTypePtr();
-            funcptr_types.insert(type);
+            clang::QualType type = context.getCanonicalType(template_args[0].getAsType());
+            type = type->getLocallyUnqualifiedSingleStepDesugaredType();
+
+            auto annotations = GetTypeAnnotations(context, decl);
+            if (annotations.is_opaque) {
+                auto [it, inserted] = types.emplace(context.getCanonicalType(type.getTypePtr()), RepackedType { true });
+                assert(inserted);
+            } else if (annotations.assumed_compatible) {
+                auto [it, inserted] = types.emplace(context.getCanonicalType(type.getTypePtr()), RepackedType { true, false });
+                assert(inserted);
+            } else {
+                if (type->isFunctionPointerType() || type->isFunctionType()) {
+                    funcptr_types["TODO_FUNC_NAME_FOR_ANNOTATED_TYPES_" + type.getAsString()] = std::pair { type.getTypePtr(), no_param_annotations };
+                } else {
+                    // TODO: Unify this with the is_opaque path above
+                    auto [it, inserted] = types.emplace(context.getCanonicalType(type.getTypePtr()), RepackedType { false });
+                    assert(inserted);
+                }
+            }
+        }
+    }
+
+    // Process function parameter annotations
+    std::unordered_map<const clang::FunctionDecl*, std::unordered_map<unsigned, ParameterAnnotations>> param_annotations;
+    for (auto& decl_context : decl_contexts) {
+        if (auto template_decl = FindClassTemplateDeclByName(*decl_context, "fex_gen_param")) {
+            for (auto* decl : template_decl->specializations()) {
+                const auto& template_args = decl->getTemplateArgs();
+                assert(/*template_args.size() == 2 || */template_args.size() == 3);
+
+                auto function = llvm::dyn_cast<clang::FunctionDecl>(template_args[0].getAsDecl())/*->getCanonicalDecl()*/;
+                auto param_idx = template_args[1].getAsIntegral().getZExtValue();
+                clang::QualType type = context.getCanonicalType(template_args[2].getAsType());
+                type = type->getLocallyUnqualifiedSingleStepDesugaredType();
+
+                if (param_idx >= function->getNumParams()) {
+                    throw report_error(decl->getTypeAsWritten()->getTypeLoc().getAs<clang::TemplateSpecializationTypeLoc>().getArgLoc(1).getLocation(), "Out-of-bounds parameter index passed to fex_gen_param");
+                }
+
+                if (!type->isVoidType() && !context.hasSameType(type, function->getParamDecl(param_idx)->getType())) {
+                    throw report_error(decl->getTypeAsWritten()->getTypeLoc().getAs<clang::TemplateSpecializationTypeLoc>().getArgLoc(2).getLocation(), "Type passed to fex_gen_param doesn't match the function signature")
+                              .addNote(report_error(function->getParamDecl(param_idx)->getTypeSourceInfo()->getTypeLoc().getBeginLoc(), "Expected this type instead"));
+                }
+
+                param_annotations[function][param_idx] = GetParameterAnnotations(context, decl);
+            }
         }
     }
 
@@ -204,6 +299,24 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
 
                 if (auto emitted_function = llvm::dyn_cast<clang::FunctionDecl>(template_args[0].getAsDecl())) {
                     // Process later
+                } else if (auto annotated_member = llvm::dyn_cast<clang::FieldDecl>(template_args[0].getAsDecl())) {
+                    {
+                        if (decl->getNumBases() != 1 || decl->bases_begin()->getType().getAsString() != "fexgen::custom_repack") {
+                            throw report_error(template_arg_loc, "Unsupported member annotation(s)");
+                        }
+                        // TODO: Check for fexgen::custom_repack annotation
+                        if (!annotated_member->getType()->isPointerType() && !annotated_member->getType()->isArrayType()) {
+                            throw report_error(template_arg_loc, "custom_repack annotation requires pointer member");
+                        }
+                    }
+
+                    // Get or add parent type to list of structure types
+                    auto repack_info_it = types.emplace(context.getCanonicalType(annotated_member->getParent()->getTypeForDecl()), RepackedType {}).first;
+                    if (repack_info_it->second.is_opaque) {
+                        throw report_error(template_arg_loc, "May not annotate members of opaque types");
+                    }
+                    // Add member to its list of members
+                    repack_info_it->second.custom_repacked_members.insert(annotated_member->getNameAsString());
                 } else {
                     throw report_error(template_arg_loc, "Cannot annotate this kind of symbol");
                 }
@@ -220,94 +333,228 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
 
                 const auto template_arg_loc = decl->getTypeAsWritten()->getTypeLoc().castAs<clang::TemplateSpecializationTypeLoc>().getArgLoc(0).getLocation();
 
-                auto emitted_function = llvm::dyn_cast<clang::FunctionDecl>(template_args[0].getAsDecl());
-                assert(emitted_function && "Argument is not a function");
-                auto return_type = emitted_function->getReturnType();
+                if (auto emitted_function = llvm::dyn_cast<clang::FunctionDecl>(template_args[0].getAsDecl())) {
+                    auto return_type = emitted_function->getReturnType();
 
-                const auto annotations = GetAnnotations(context, decl);
-                if (return_type->isFunctionPointerType() && !annotations.returns_guest_pointer) {
-                    throw report_error( template_arg_loc,
-                                        "Function pointer return types require explicit annotation\n");
-                }
+                    const auto annotations = GetAnnotations(context, decl);
+                    if (return_type->isFunctionPointerType() && !annotations.returns_guest_pointer) {
+                        throw report_error( template_arg_loc,
+                                            "Function pointer return types require explicit annotation\n");
+                    }
 
-                // TODO: Use the types as written in the signature instead?
-                ThunkedFunction data;
-                data.function_name = emitted_function->getName().str();
-                data.return_type = return_type;
-                data.is_variadic = emitted_function->isVariadic();
+                    // TODO: Use the types as written in the signature instead?
+                    ThunkedFunction data;
+                    data.function_name = emitted_function->getName().str();
+                    data.return_type = return_type;
+                    data.is_variadic = emitted_function->isVariadic();
 
-                data.decl = emitted_function;
+                    data.decl = emitted_function;
 
-                data.custom_host_impl = annotations.custom_host_impl;
+                    data.custom_host_impl = annotations.custom_host_impl;
 
-                for (std::size_t param_idx = 0; param_idx < emitted_function->param_size(); ++param_idx) {
-                    auto* param = emitted_function->getParamDecl(param_idx);
-                    data.param_types.push_back(param->getType());
+                    data.param_annotations = param_annotations[emitted_function];
 
-                    if (param->getType()->isFunctionPointerType()) {
-                        auto funcptr = param->getFunctionType()->getAs<clang::FunctionProtoType>();
-                        ThunkedCallback callback;
-                        callback.return_type = funcptr->getReturnType();
-                        for (auto& cb_param : funcptr->getParamTypes()) {
-                            callback.param_types.push_back(cb_param);
+                    const int retval_index = -1;
+                    for (int param_idx = retval_index; param_idx < (int)emitted_function->param_size(); ++param_idx) {
+                        auto param_type = param_idx == retval_index ? emitted_function->getReturnType() : emitted_function->getParamDecl(param_idx)->getType();
+                        auto param_loc = param_idx == retval_index ? emitted_function->getReturnTypeSourceRange().getBegin() : emitted_function->getParamDecl(param_idx)->getBeginLoc();
+
+                        if (param_idx != retval_index) {
+                            data.param_types.push_back(param_type);
+                        } else if (param_type->isVoidType()) {
+                            continue;
                         }
-                        callback.is_stub = annotations.callback_strategy == CallbackStrategy::Stub;
-                        callback.is_guest = annotations.callback_strategy == CallbackStrategy::Guest;
-                        callback.is_variadic = funcptr->isVariadic();
 
-                        if (callback.is_guest && !data.custom_host_impl) {
-                            throw report_error(template_arg_loc, "callback_guest can only be used with custom_host_impl");
+                        auto check_struct_type = [&](const clang::Type* type) {
+                            if (type->isIncompleteType()) {
+                                throw report_error(type->getAsTagDecl()->getBeginLoc(), "Unannotated pointer with incomplete struct type; consider using an opaque_type annotation")
+                                      .addNote(report_error(emitted_function->getNameInfo().getLoc(), "in function", clang::DiagnosticsEngine::Note))
+                                      .addNote(report_error(template_arg_loc, "used in annotation here", clang::DiagnosticsEngine::Note));
+                            }
+
+                            for (auto* member : type->getAsStructureType()->getDecl()->fields()) {
+                                auto annotated_type = types.find(type->getCanonicalTypeUnqualified().getTypePtr());
+                                if (annotated_type == types.end() || !annotated_type->second.UsesCustomRepackFor(member)) {
+                                    /*if (!member->getType()->isPointerType())*/ {
+                                        // TODO: Perform more elaborate validation for non-pointers to ensure ABI compatibility
+                                        continue;
+                                    }
+
+                                    throw report_error(member->getBeginLoc(), "Unannotated pointer member")
+                                          .addNote(report_error(param_loc, "in struct type", clang::DiagnosticsEngine::Note))
+                                          .addNote(report_error(template_arg_loc, "used in annotation here", clang::DiagnosticsEngine::Note));
+                                }
+                            }
+                        };
+
+                        if (param_type->isFunctionPointerType()) {
+                            if (param_idx == retval_index) {
+                                // TODO: We already rely on this in a few places...
+//                                throw report_error(template_arg_loc, "Support for returning function pointers is not implemented");
+                                continue;
+                            }
+                            auto funcptr = emitted_function->getParamDecl(param_idx)->getFunctionType()->getAs<clang::FunctionProtoType>();
+                            ThunkedCallback callback;
+                            callback.return_type = funcptr->getReturnType();
+                            for (auto& cb_param : funcptr->getParamTypes()) {
+                                callback.param_types.push_back(cb_param);
+                            }
+                            callback.is_stub = annotations.callback_strategy == CallbackStrategy::Stub;
+                            callback.is_variadic = funcptr->isVariadic();
+
+                            data.callbacks.emplace(param_idx, callback);
+                            if (!callback.is_stub && !data.custom_host_impl) {
+                                funcptr_types[emitted_function->getNameAsString() + "_cb" + std::to_string(param_idx)] = std::pair { context.getCanonicalType(funcptr), no_param_annotations };
+                            }
+
+                            if (data.callbacks.size() != 1) {
+                                throw report_error(template_arg_loc, "Support for more than one callback is untested");
+                            }
+                            if (funcptr->isVariadic() && !callback.is_stub) {
+                                throw report_error(template_arg_loc, "Variadic callbacks are not supported");
+                            }
+
+                            // Force treatment as passthrough-pointer
+                            data.param_annotations[param_idx].is_passthrough = true;
+                        } else if (param_type->isBuiltinType()) {
+                            // NOTE: Intentionally not using getCanonicalType here since that would turn e.g. size_t into platform-specific types
+                            // TODO: Still, we may want to de-duplicate some of these...
+                            types.emplace(param_type.getTypePtr(), RepackedType { });
+                        } else if (param_type->isEnumeralType()) {
+                            types.emplace(context.getCanonicalType(param_type.getTypePtr()), RepackedType { });
+                        } else if ( param_type->isStructureType() &&
+                                    !(types.contains(context.getCanonicalType(param_type.getTypePtr())) &&
+                                      LookupType(context, param_type.getTypePtr()).is_opaque)) {
+                            check_struct_type(param_type.getTypePtr());
+                            types.emplace(context.getCanonicalType(param_type.getTypePtr()), RepackedType { });
+                        } else if (param_type->isPointerType()) {
+                            auto pointee_type = param_type->getPointeeType()->getLocallyUnqualifiedSingleStepDesugaredType();
+                            if ((types.contains(context.getCanonicalType(pointee_type.getTypePtr())) && LookupType(context, pointee_type.getTypePtr()).is_opaque)) {
+                                // Nothing to do
+                                data.param_annotations[param_idx].is_opaque = true; // TODO: is having this member good design?
+                            } else if ( pointee_type->isStructureType() &&
+                                        !(types.contains(context.getCanonicalType(pointee_type.getTypePtr())) &&
+                                          LookupType(context, pointee_type.getTypePtr()).is_opaque)) {
+                                check_struct_type(pointee_type.getTypePtr());
+                                types.emplace(context.getCanonicalType(pointee_type.getTypePtr()), RepackedType { });
+                            } else if (data.param_annotations[param_idx].is_passthrough) {
+                                if (!data.custom_host_impl) {
+                                    throw report_error(param_loc, "Passthrough annotation requires custom host implementation");
+                                }
+
+                                // Nothing to do
+                            } else if (data.param_annotations[param_idx].is_opaque /* TODO: Actually is assume_compatible_data_layout'ed */) {
+                                // Nothing to do
+                            } else if (false /* TODO: Can't check if this is unsupported until data layout analysis is complete */) {
+                                fprintf(stderr, "NAME: %s\n", pointee_type.getAsString().c_str());
+                                throw report_error(param_loc, "Unsupported parameter type")
+                                              .addNote(report_error(emitted_function->getNameInfo().getLoc(), "in function", clang::DiagnosticsEngine::Note))
+                                              .addNote(report_error(template_arg_loc, "used in definition here", clang::DiagnosticsEngine::Note));
+                            }
+                        } else {
+                            // TODO: For non-pointer parameters, perform more elaborate validation to ensure ABI compatibility
                         }
+                    }
 
-                        data.callbacks.emplace(param_idx, callback);
-                        if (!callback.is_stub && !callback.is_guest) {
-                            funcptr_types.insert(context.getCanonicalType(funcptr));
+                    thunked_api.push_back(ThunkedAPIFunction { (const FunctionParams&)data, data.function_name, data.return_type,
+                                                                namespace_info.host_loader.empty() ? "dlsym_default" : namespace_info.host_loader,
+                                                                data.is_variadic || annotations.custom_guest_entrypoint,
+                                                                data.is_variadic,
+                                                                std::nullopt });
+                    if (namespace_info.generate_guest_symtable) {
+                        thunked_api.back().symtable_namespace = namespace_idx;
+                    }
+
+                    if (data.is_variadic) {
+                        if (!annotations.uniform_va_type) {
+                            throw report_error(decl->getBeginLoc(), "Variadic functions must be annotated with parameter type using uniform_va_type");
                         }
 
-                        if (data.callbacks.size() != 1) {
-                            throw report_error(template_arg_loc, "Support for more than one callback is untested");
+                        // Convert variadic argument list into a count + pointer pair
+                        data.param_types.push_back(context.getSizeType());
+                        data.param_types.push_back(context.getPointerType(*annotations.uniform_va_type));
+                        types.emplace(context.getSizeType()->getTypePtr(), RepackedType { });
+                        if (!annotations.uniform_va_type.value()->isVoidPointerType()) {
+                            types.emplace(annotations.uniform_va_type->getTypePtr(), RepackedType { });
                         }
-                        if (funcptr->isVariadic() && !callback.is_stub) {
-                            throw report_error(template_arg_loc, "Variadic callbacks are not supported");
+                    }
+
+                    if (data.is_variadic) {
+                        // This function is thunked through an "_internal" symbol since its signature
+                        // is different from the one in the native host/guest libraries.
+                        data.function_name = data.function_name + "_internal";
+                        if (data.custom_host_impl) {
+                            throw report_error(decl->getBeginLoc(), "Custom host impl requested but this is implied by the function signature already");
                         }
+                        data.custom_host_impl = true;
                     }
-                }
 
-                thunked_api.push_back(ThunkedAPIFunction { (const FunctionParams&)data, data.function_name, data.return_type,
-                                                            namespace_info.host_loader.empty() ? "dlsym_default" : namespace_info.host_loader,
-                                                            data.is_variadic || annotations.custom_guest_entrypoint,
-                                                            data.is_variadic,
-                                                            std::nullopt });
-                if (namespace_info.generate_guest_symtable) {
-                    thunked_api.back().symtable_namespace = namespace_idx;
+                    // For indirect calls, register the function signature as a function pointer type
+                    if (namespace_info.indirect_guest_calls) {
+                        funcptr_types[emitted_function->getNameAsString()] = std::pair { context.getCanonicalType(emitted_function->getFunctionType()), data.param_annotations };
+                    }
+
+                    thunks.push_back(std::move(data));
                 }
+            }
+        }
+    }
+}
 
-                if (data.is_variadic) {
-                    if (!annotations.uniform_va_type) {
-                        throw report_error(decl->getBeginLoc(), "Variadic functions must be annotated with parameter type using uniform_va_type");
-                    }
+void AnalysisAction::CoverReferencedTypes(clang::ASTContext& context) {
+    // Repeat until no more children are appended
+    for (bool changed = true; std::exchange(changed, false);) {
+        for ( auto next_type_it = types.begin(), type_it = next_type_it;
+              type_it != types.end();
+              type_it = next_type_it) {
+            ++next_type_it;
+            const auto& [type, type_repack_info] = *type_it;
+            if (!type->isStructureType()) {
+                continue;
+            }
+
+            if (type_repack_info.is_opaque) {
+                // If assumed compatible, we don't need the member definitions
+                continue;
+            }
 
-                    // Convert variadic argument list into a count + pointer pair
-                    data.param_types.push_back(context.getSizeType());
-                    data.param_types.push_back(context.getPointerType(*annotations.uniform_va_type));
+            for (auto* member : type->getAsStructureType()->getDecl()->fields()) {
+                auto member_type = member->getType().getTypePtr();
+                while (member_type->isArrayType()) {
+                    member_type = member_type->getArrayElementTypeNoTypeQual();
+                }
+                while (member_type->isPointerType()) {
+                    member_type = member_type->getPointeeType().getTypePtr();
                 }
 
-                if (data.is_variadic) {
-                    // This function is thunked through an "_internal" symbol since its signature
-                    // is different from the one in the native host/guest libraries.
-                    data.function_name = data.function_name + "_internal";
-                    if (data.custom_host_impl) {
-                        throw report_error(decl->getBeginLoc(), "Custom host impl requested but this is implied by the function signature already");
+                if (!member_type->isBuiltinType()) {
+                    member_type = context.getCanonicalType(member_type);
+                }
+                if (types.contains(member_type) && types.at(member_type).pointers_only) {
+                    if (member_type == context.getCanonicalType(member->getType().getTypePtr())) {
+                        throw std::runtime_error(fmt::format("\"{}\" references opaque type \"{}\" via non-pointer member \"{}\"",
+                                                             clang::QualType { type, 0 }.getAsString(),
+                                                             clang::QualType { member_type, 0 }.getAsString(),
+                                                             member->getNameAsString()));
                     }
-                    data.custom_host_impl = true;
+                    continue;
+                }
+                if (member_type->isUnionType() && !types.contains(member_type) && !type_repack_info.UsesCustomRepackFor(member)) {
+                    throw std::runtime_error(fmt::format("\"{}\" has unannotated member \"{}\" of union type \"{}\"",
+                                                         clang::QualType { type, 0 }.getAsString(),
+                                                         member->getNameAsString(),
+                                                         clang::QualType { member_type, 0 }.getAsString()));
                 }
 
-                // For indirect calls, register the function signature as a function pointer type
-                if (namespace_info.indirect_guest_calls) {
-                    funcptr_types.insert(context.getCanonicalType(emitted_function->getFunctionType()));
+                if (!member_type->isStructureType() && !(member_type->isBuiltinType() && !member_type->isVoidType()) && !member_type->isEnumeralType()) {
+                    continue;
                 }
 
-                thunks.push_back(std::move(data));
+                auto [new_type_it, inserted] = types.emplace(member_type, RepackedType { });
+                if (inserted) {
+                    changed = true;
+                    next_type_it = new_type_it;
+                }
             }
         }
     }
diff --git a/ThunkLibs/Generator/analysis.h b/ThunkLibs/Generator/analysis.h
index 7aeaa9d77a..9a7d50f7a4 100644
--- a/ThunkLibs/Generator/analysis.h
+++ b/ThunkLibs/Generator/analysis.h
@@ -17,10 +17,16 @@ struct ThunkedCallback : FunctionParams {
     clang::QualType return_type;
 
     bool is_stub = false;  // Callback will be replaced by a stub that calls std::abort
-    bool is_guest = false; // Callback will never be called on the host
     bool is_variadic = false;
 };
 
+struct ParameterAnnotations {
+    bool is_passthrough = false;
+    bool is_opaque = false;
+
+    bool operator==(const ParameterAnnotations&) const = default;
+};
+
 /**
  * Guest<->Host transition point.
  *
@@ -52,6 +58,10 @@ struct ThunkedFunction : FunctionParams {
     // Maps parameter index to ThunkedCallback
     std::unordered_map<unsigned, ThunkedCallback> callbacks;
 
+    // Maps parameter index to ParameterAnnotations
+    // TODO: Use index -1 for the return value?
+    std::unordered_map<unsigned, ParameterAnnotations> param_annotations;
+
     clang::FunctionDecl* decl;
 };
 
@@ -109,6 +119,9 @@ class AnalysisAction : public clang::ASTFrontendAction {
     // Build the internal API representation by processing fex_gen_config and other annotated entities
     void ParseInterface(clang::ASTContext&);
 
+    // Recursively extend the type set to include types of struct members
+    void CoverReferencedTypes(clang::ASTContext&);
+
     // Called from ExecuteAction() after parsing is complete
     virtual void EmitOutput(clang::ASTContext&) {};
 
@@ -116,8 +129,68 @@ class AnalysisAction : public clang::ASTFrontendAction {
 
     std::vector<ThunkedFunction> thunks;
     std::vector<ThunkedAPIFunction> thunked_api;
-    std::unordered_set<const clang::Type*> funcptr_types;
 
+    // TODO: Rename, since this is now not just per type but also per set of annotations
+    std::unordered_map<std::string, std::pair<const clang::Type*, std::unordered_map<unsigned, ParameterAnnotations>>> funcptr_types;
+
+public: // TODO: Remove, make only RepackedType public
+    struct RepackedType {
+        bool is_opaque = false; // opaque or assumed_compatible (TODO: Rename to the latter)
+        bool pointers_only = is_opaque; // if true, only pointers to this type may be used
+
+        // Set of members (identified by their field name) with custom repacking
+        std::unordered_set<std::string> custom_repacked_members;
+
+        bool UsesCustomRepackFor(const clang::FieldDecl* member) const {
+            return custom_repacked_members.contains(member->getNameAsString());
+        }
+        bool UsesCustomRepackFor(const std::string& member_name) const {
+            return custom_repacked_members.contains(member_name);
+        }
+    };
+
+    std::unordered_map<const clang::Type*, RepackedType> types;
     std::optional<unsigned> lib_version;
     std::vector<NamespaceInfo> namespaces;
+
+    RepackedType& LookupType(clang::ASTContext& context, const clang::Type* type) {
+      return types.at(context.getCanonicalType(type));
+    }
 };
+
+inline std::string get_type_name(const clang::ASTContext& context, const clang::Type* type) {
+    if (type->isBuiltinType()) {
+        // Skip canonicalization
+        return clang::QualType { type, 0 }.getAsString();
+    }
+
+    if (auto decl = type->getAsTagDecl()) {
+        // Replace unnamed types with a placeholder. This will fail to compile if referenced
+        // anywhere in generated code, but at least it will point to a useful location.
+        //
+        // A notable exception are C-style struct declarations like "typedef struct (unnamed) { ... } MyStruct;".
+        // A typedef name is associated with these for linking purposes, so
+        // getAsString() will produce a usable identifier.
+        // TODO: Consider turning this into a hard error instead of replacing the name
+        if (!decl->getDeclName() && !decl->getTypedefNameForAnonDecl()) {
+            auto loc = context.getSourceManager().getPresumedLoc(decl->getLocation());
+            std::string filename = loc.getFilename();
+            filename = std::move(filename).substr(filename.rfind("/"));
+            filename = std::move(filename).substr(1);
+            std::replace(filename.begin(), filename.end(), '.', '_');
+            return "unnamed_type_" + filename + "_" + std::to_string(loc.getLine());
+        }
+    }
+
+    auto type_name = clang::QualType { context.getCanonicalType(type), 0 }.getAsString();
+    if (type_name.starts_with("struct ")) {
+        type_name = type_name.substr(7);
+    }
+    if (type_name.starts_with("class ") || type_name.starts_with("union ")) {
+        type_name = type_name.substr(6);
+    }
+    if (type_name.starts_with("enum ")) {
+        type_name = type_name.substr(5);
+    }
+    return type_name;
+}
diff --git a/ThunkLibs/Generator/data_layout.cpp b/ThunkLibs/Generator/data_layout.cpp
new file mode 100644
index 0000000000..1739457c19
--- /dev/null
+++ b/ThunkLibs/Generator/data_layout.cpp
@@ -0,0 +1,386 @@
+#include "analysis.h"
+#include "data_layout.h"
+#include "interface.h"
+
+#include <fmt/format.h> // TODO: Drop
+
+#include <openssl/sha.h>
+
+// Visitor for gathering data layout information that can be passed across libclang invocations
+class AnalyzeDataLayoutAction : public AnalysisAction {
+    ABI& type_abi;
+
+    // TODO: Needs a different name now
+    void EmitOutput(clang::ASTContext&) override;
+
+public:
+    AnalyzeDataLayoutAction(ABI&);
+};
+
+AnalyzeDataLayoutAction::AnalyzeDataLayoutAction(ABI& abi_) : type_abi(abi_) {
+}
+
+std::unordered_map<const clang::Type*, TypeInfo> ComputeDataLayout(const clang::ASTContext& context, const std::unordered_map<const clang::Type*, AnalysisAction::RepackedType>& types) {
+    std::unordered_map<const clang::Type*, TypeInfo> layout;
+
+    // First, add all types directly used in function signatures of the library API to the meta set
+    for (const auto& [type, type_repack_info] : types) {
+        if (type_repack_info.is_opaque) {
+            auto [_, inserted] = layout.insert(std::pair { context.getCanonicalType(type), TypeInfo {} });
+            if (!inserted) {
+                throw std::runtime_error("Failed to gather type metadata: Opaque type \"" + clang::QualType { type, 0 }.getAsString() + "\" already registered");
+            }
+            continue;
+        }
+
+        if (type->isIncompleteType()) {
+            throw std::runtime_error("Cannot compute data layout of incomplete type \"" + clang::QualType { type, 0 }.getAsString() + "\". Did you forget any annotations?");
+        }
+
+        if (type->isStructureType()) {
+            StructInfo info;
+            info.size_bits = context.getTypeSize(type);
+            info.alignment_bits = context.getTypeAlign(type);
+
+            auto [_, inserted] = layout.insert(std::pair { context.getCanonicalType(type), info });
+            if (!inserted) {
+                throw std::runtime_error("Failed to gather type metadata: Type \"" + clang::QualType { type, 0 }.getAsString() + "\" already registered");
+            }
+        } else if (type->isBuiltinType() || type->isEnumeralType()) {
+            SimpleTypeInfo info;
+            info.size_bits = context.getTypeSize(type);
+            info.alignment_bits = context.getTypeAlign(type);
+
+            // NOTE: Non-enum types are intentionally not canonicalized since that would turn e.g. size_t into platform-specific types
+            auto [_, inserted] = layout.insert(std::pair { type->isEnumeralType() ? context.getCanonicalType(type) : type, info });
+            if (!inserted) {
+                throw std::runtime_error("Failed to gather type metadata: Type \"" + clang::QualType { type, 0 }.getAsString() + "\" already registered");
+            }
+        }
+    }
+
+    // Then, add information about members
+    for (const auto& [type, type_repack_info] : types) {
+        if (!type->isStructureType() || type_repack_info.is_opaque) {
+            continue;
+        }
+
+        auto& info = *layout.at(context.getCanonicalType(type)).get_if_struct();
+
+        for (auto* field : type->getAsStructureType()->getDecl()->fields()) {
+            auto field_type = field->getType().getTypePtr();
+            std::optional<uint64_t> array_size;
+            if (auto array_type = llvm::dyn_cast<clang::ConstantArrayType>(field->getType())) {
+                array_size = array_type->getSize().getZExtValue();
+                field_type = array_type->getElementType().getTypePtr();
+                if (llvm::isa<clang::ConstantArrayType>(field_type)) {
+                    throw std::runtime_error("Unsupported multi-dimensional array member \"" + field->getNameAsString() + "\" in type \"" + clang::QualType { type, 0 }.getAsString() + "\"");
+                }
+            }
+
+            StructInfo::MemberInfo member_info {
+                .size_bits = context.getTypeSize(field->getType()), // Total size even for arrays
+                .offset_bits = context.getFieldOffset(field),
+                .type_name = get_type_name(context, field_type),
+                .member_name = field->getNameAsString(),
+                .array_size = array_size,
+            };
+
+            // TODO: Process types in dependency-order. Currently we skip this
+            //       check if we haven't processed the member type already,
+            //       which is only safe since this is a consistency check
+            if (field_type->isStructureType() && layout.contains(context.getCanonicalType(field_type))) {
+                // Assert for self-consistency
+                auto field_meta = layout.at(context.getCanonicalType(field_type));
+                (void)types.at(context.getCanonicalType(field_type));
+                if (auto field_info = field_meta.get_if_simple_or_struct()) {
+                    if (field_info->size_bits != member_info.size_bits / member_info.array_size.value_or(1)) {
+                        throw std::runtime_error("Inconsistent type size detected");
+                    }
+                }
+            }
+
+            // Add built-in types, even if referenced through a pointer
+            for (auto* inner_field_type = field_type; inner_field_type; inner_field_type = inner_field_type->getPointeeType().getTypePtrOrNull()) {
+                if (inner_field_type->isBuiltinType() || inner_field_type->isEnumeralType()) {
+                    // The analysis pass doesn't explicitly register built-in types, so add them manually here
+                    SimpleTypeInfo info {
+                        .size_bits = context.getTypeSize(inner_field_type),
+                        .alignment_bits = context.getTypeAlign(inner_field_type),
+                    };
+                    if (!inner_field_type->isBuiltinType()) {
+                        inner_field_type = context.getCanonicalType(inner_field_type);
+                    }
+                    auto [prev, inserted] = layout.insert(std::pair { inner_field_type, info });
+//                    if (!inserted && prev->second != TypeInfo { info }) {
+//                        // TODO: Throw error since consistency check failed
+//                    }
+                }
+            }
+
+            info.members.push_back(member_info);
+        }
+    }
+
+    for (const auto& [type, info] : layout) {
+        auto basic_info = info.get_if_simple_or_struct();
+        if (!basic_info) {
+            continue;
+        }
+
+        fprintf(stderr, "  Host entry %s: %lu (%lu)\n", clang::QualType { type, 0 }.getAsString().c_str(), basic_info->size_bits / 8, basic_info->alignment_bits / 8);
+
+        if (auto struct_info = info.get_if_struct()) {
+            for (const auto& member : struct_info->members) {
+                fprintf(stderr, "    Offset %lu-%lu: %s %s%s\n", member.offset_bits / 8, (member.offset_bits + member.size_bits - 1) / 8, member.type_name.c_str(), member.member_name.c_str(), member.array_size ? fmt::format("[{}]", member.array_size.value()).c_str() : "");
+            }
+        }
+    }
+
+    return layout;
+}
+
+ABI GetStableLayout(const clang::ASTContext& context, const std::unordered_map<const clang::Type*, TypeInfo>& data_layout) {
+    ABI stable_layout;
+
+    for (auto [type, type_info] : data_layout) {
+        auto type_name = get_type_name(context, type);
+        auto [it, inserted] = stable_layout.insert(std::pair { type_name, type_info });
+        if (!inserted && it->second != type_info) {
+            throw std::runtime_error("Duplicate type information: Tried to re-register type \"" + type_name + "\"");
+        }
+    }
+
+    stable_layout.pointer_size = context.getTypeSize(context.getUIntPtrType()) / 8;
+
+    return stable_layout;
+}
+
+// TODO: Turn into static local function
+auto get_sha256 = [](const std::string& function_name) {
+    std::array<uint8_t, 32> sha256;
+    SHA256(reinterpret_cast<const unsigned char*>(function_name.data()),
+           function_name.size(),
+           sha256.data());
+    return sha256;
+};
+
+void AnalyzeDataLayoutAction::EmitOutput(clang::ASTContext& context) {
+    type_abi = GetStableLayout(context, ComputeDataLayout(context, types));
+
+    // Register functions that must be guest-callable through host function pointers
+    for (auto funcptr_type_it = funcptr_types.begin(); funcptr_type_it != funcptr_types.end(); ++funcptr_type_it) {
+        auto& funcptr_id = funcptr_type_it->first;
+        auto& [type, param_annotations] = funcptr_type_it->second;
+        auto func_type = type->getAs<clang::FunctionProtoType>();
+        std::string mangled_name = clang::QualType { type, 0 }.getAsString();
+        auto cb_sha256 = get_sha256("fexcallback_" + mangled_name);
+        FuncPtrInfo info = { cb_sha256 };
+
+        info.result = func_type->getReturnType().getAsString();
+        info.param_annotations = param_annotations;
+
+        // Heuristic approach to preserve data layout for arguments.
+        // We can re-use the string representation of most types without problems.
+        // Built-in types with differing size must be replaced with fixed-size integers.
+        // TODO: Instead of using these heuristics here, record the type name and its size.
+        //       Then, when emitting code, replace types with fixed-size integers only if the
+        //       sizes don't match
+        // TODO: Also apply these heuristics to the return type
+        // TODO: Respect param_annotations
+        for (auto arg : func_type->getParamTypes()) {
+            if (arg->isBuiltinType()) {
+                auto size = context.getTypeSize(arg);
+                info.args.push_back(fmt::format("uint{}_t", size));
+            } else if (arg->isPointerType() && arg->getPointeeType()->isBuiltinType() && context.getTypeSize(arg->getPointeeType()) >= 2 * 8) {
+                auto size = context.getTypeSize(arg->getPointeeType());
+                info.args.push_back(fmt::format("uint{}_t*", size));
+            } else {
+                info.args.push_back(arg.getAsString());
+            }
+        }
+        type_abi.funcptr_types[funcptr_id] = std::move(info);
+    }
+}
+
+TypeCompatibility DataLayoutCompareAction::GetTypeCompatibility(
+        const clang::ASTContext& context,
+        const clang::Type* type,
+        const std::unordered_map<const clang::Type*, TypeInfo> host_abi,
+        std::unordered_map<const clang::Type*, TypeCompatibility>& type_compat) {
+    assert(type->isCanonicalUnqualified() || type->isBuiltinType() || type->isEnumeralType());
+
+    {
+        // Reserve a slot to be filled later. The placeholder value is used
+        // to detect infinite recursions.
+        constexpr auto placeholder_compat = TypeCompatibility { 100 };
+        auto [existing_compat_it, is_new_type] = type_compat.emplace(type, placeholder_compat);
+        if (!is_new_type) {
+            if (existing_compat_it->second == placeholder_compat) {
+                throw std::runtime_error("Found recursive reference to type \"" + clang::QualType { type, 0 }.getAsString() + "\"");
+            }
+
+            return existing_compat_it->second;
+        }
+    }
+
+    // TODO: This is also used by the assume_compatible_data_layout path now
+    if (types.contains(type) && types.at(type).is_opaque) {
+        if (types.at(type).pointers_only && !type->isPointerType()) {
+            throw std::runtime_error("Tried to dereference opaque type \"" + clang::QualType { type, 0 }.getAsString() + "\" when querying data layout compatibility");
+        }
+        type_compat.at(type) = TypeCompatibility::Full;
+        return TypeCompatibility::Full;
+    }
+
+    const auto& guest_abi = abi;
+    auto type_name = get_type_name(context, type);
+    auto& guest_info = guest_abi.at(type_name);
+    auto& host_info = host_abi.at(type->isBuiltinType() ? type : context.getCanonicalType(type));
+
+    const bool is_32bit = (guest_abi.pointer_size == 4);
+
+    // Assume full compatibility, then downgrade as needed
+    auto compat = TypeCompatibility::Full;
+
+    if (guest_info != host_info) {
+        // Non-matching data layout... downgrade to Repackable
+        // TODO: Even for non-structs, this only works if the types are reasonably similar (e.g. uint32_t -> uint64_t)
+        compat = TypeCompatibility::Repackable;
+    }
+
+    if (auto guest_struct_info = guest_info.get_if_struct()) {
+        const AnalysisAction::RepackedType& type_repack_info = types.at(type);
+
+        std::vector<TypeCompatibility> member_compat;
+        for (std::size_t member_idx = 0; member_idx < guest_struct_info->members.size(); ++member_idx) {
+            // Look up the corresponding member in the host struct definition.
+            // The members may be listed in a different order, so we can't
+            // directly use member_idx for this
+            auto* host_member_field = [&]() -> clang::FieldDecl* {
+                auto struct_decl = type->getAsStructureType()->getDecl();
+                auto it = std::find_if(struct_decl->field_begin(), struct_decl->field_end(), [&](auto* field) {
+                    return field->getName() == guest_struct_info->members.at(member_idx).member_name;
+                });
+                if (it == struct_decl->field_end()) {
+                    return nullptr;
+                }
+                return *it;
+            }();
+            if (!host_member_field) {
+                // No corresponding host struct member
+                // TODO: Also detect host members that are missing from the guest struct
+                member_compat.push_back(TypeCompatibility::None);
+                break;
+            }
+
+            auto host_member_type = context.getCanonicalType(host_member_field->getType().getTypePtr());
+            if (auto array_type = llvm::dyn_cast<clang::ConstantArrayType>(host_member_type)) {
+                // Compare array element type only. The array size is already considered by the layout information of the containing struct.
+                host_member_type = context.getCanonicalType(array_type->getElementType().getTypePtr());
+            }
+
+            if (host_member_type->isPointerType()) {
+                // Automatic repacking of pointers to non-compatible types is only possible if:
+                // * Pointee is fully compatible, or
+                // * Pointer member is annotated
+                // TODO: Drop the Vulkan-specific workaround of ignoring "pNext" pointers
+                // TODO: Don't restrict this to structure types. it applies to pointers to builtin types too!
+                auto host_member_pointee_type = context.getCanonicalType(host_member_type->getPointeeType().getTypePtr());
+                if (type_repack_info.UsesCustomRepackFor(host_member_field)
+                    || (is_32bit && host_member_field->getNameAsString() == "pNext")
+                    ) {
+                    member_compat.push_back(TypeCompatibility::Repackable);
+                } else if (types.contains(host_member_pointee_type) && types.at(host_member_pointee_type).is_opaque) {
+                    // Pointee doesn't need repacking, but pointer needs extending on 32-bit
+                    member_compat.push_back(is_32bit ? TypeCompatibility::Repackable : TypeCompatibility::Full);
+                } else if (host_member_pointee_type->isPointerType()) {
+                    // This is a nested pointer, e.g. void**
+
+                    if (is_32bit) {
+                        // Nested pointers can't be repacked on 32-bit
+                        member_compat.push_back(TypeCompatibility::None);
+                    } else if (types.contains(host_member_pointee_type->getPointeeType().getTypePtr()) && types.at(host_member_pointee_type->getPointeeType().getTypePtr()).is_opaque) {
+                        // Pointers to opaque types are fine
+                        member_compat.push_back(TypeCompatibility::Full);
+                    } else {
+                        // Check the innermost type's compatibility on 64-bit
+                        auto pointee_pointee_type = host_member_pointee_type->getPointeeType().getTypePtr();
+                        // TODO: Not sure how to handle void here. Probably should require an annotation instead of "just working"
+                        auto pointee_pointee_compat = pointee_pointee_type->isVoidType() ? TypeCompatibility::Full : GetTypeCompatibility(context, pointee_pointee_type, host_abi, type_compat);
+                        if (pointee_pointee_compat == TypeCompatibility::Full) {
+                            member_compat.push_back(TypeCompatibility::Full);
+                        } else {
+                            member_compat.push_back(TypeCompatibility::None);
+                        }
+                    }
+                } else if (!host_member_pointee_type->isVoidType() && (host_member_pointee_type->isBuiltinType() || host_member_pointee_type->isEnumeralType())) {
+                    // TODO: What are good heuristics for this?
+                    // size_t should yield TypeCompatibility::Repackable
+                    // inconsistent types should probably default to TypeCompatibility::None
+                    // For now, just always assume compatible... (will degrade to Repackable below)
+                    member_compat.push_back(TypeCompatibility::Full);
+                } else if (!host_member_pointee_type->isVoidType() && (host_member_pointee_type->isStructureType() || types.contains(host_member_pointee_type))) {
+                    auto pointee_compat = GetTypeCompatibility(context, host_member_pointee_type, host_abi, type_compat);
+                    if (pointee_compat == TypeCompatibility::Full) {
+                        // Pointee is fully compatible, so automatic repacking only requires converting the pointers themselves
+                        member_compat.push_back(is_32bit ? TypeCompatibility::Repackable : TypeCompatibility::Full);
+                    } else {
+                        // If the pointee is incompatible (even if repackable), automatic repacking isn't possible
+                        member_compat.push_back(TypeCompatibility::None);
+                    }
+                } else if (!is_32bit && host_member_pointee_type->isVoidType()) {
+                    // TODO: Not sure how to handle void here. Probably should require an annotation instead of "just working"
+                    member_compat.push_back(TypeCompatibility::Full);
+                } else {
+                    member_compat.push_back(TypeCompatibility::None);
+                }
+                continue;
+            }
+
+            if (guest_abi.at(guest_struct_info->members[member_idx].type_name).get_if_struct()) {
+                auto host_type_info = host_abi.at(host_member_type);
+                member_compat.push_back(GetTypeCompatibility(context, host_member_type, host_abi, type_compat));
+            } else {
+                // Member was checked for size/alignment above already
+            }
+        }
+
+        if (std::all_of(member_compat.begin(), member_compat.end(), [](auto compat) { return compat == TypeCompatibility::Full; })) {
+            // TypeCompatibility::Full or ::Repackable
+        } else if (std::none_of(member_compat.begin(), member_compat.end(), [](auto compat) { return compat == TypeCompatibility::None; })) {
+            // Downgrade to Repackable
+            compat = TypeCompatibility::Repackable;
+        } else {
+            // Downgrade to None
+            compat = TypeCompatibility::None;
+        }
+    }
+
+    type_compat.at(type) = compat;
+    return compat;
+}
+
+FuncPtrInfo DataLayoutCompareAction::LookupGuestFuncPtrInfo(const char* funcptr_id) {
+    return abi.funcptr_types.at(funcptr_id);
+}
+
+DataLayoutCompareActionFactory::DataLayoutCompareActionFactory(const ABI& abi) : abi(abi) {
+
+}
+
+DataLayoutCompareActionFactory::~DataLayoutCompareActionFactory() = default;
+
+std::unique_ptr<clang::FrontendAction> DataLayoutCompareActionFactory::create() {
+    return std::make_unique<DataLayoutCompareAction>(abi);
+}
+
+AnalyzeDataLayoutActionFactory::AnalyzeDataLayoutActionFactory() : abi(std::make_unique<ABI>()) {
+
+}
+
+AnalyzeDataLayoutActionFactory::~AnalyzeDataLayoutActionFactory() = default;
+
+std::unique_ptr<clang::FrontendAction> AnalyzeDataLayoutActionFactory::create() {
+    return std::make_unique<AnalyzeDataLayoutAction>(*abi);
+}
diff --git a/ThunkLibs/Generator/data_layout.h b/ThunkLibs/Generator/data_layout.h
new file mode 100644
index 0000000000..dac58e7f1c
--- /dev/null
+++ b/ThunkLibs/Generator/data_layout.h
@@ -0,0 +1,123 @@
+#pragma once
+
+#include "analysis.h" // TODO: Drop include. Currently needed for ParameterAnnotations though
+
+#include <clang/Frontend/FrontendAction.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+struct SimpleTypeInfo {
+    uint64_t size_bits;
+    uint64_t alignment_bits;
+
+    bool operator==(const SimpleTypeInfo& other) const {
+        return  size_bits == other.size_bits &&
+                alignment_bits == other.alignment_bits;
+    }
+};
+
+struct StructInfo : SimpleTypeInfo {
+    struct MemberInfo {
+        uint64_t size_bits; // size of this member. For arrays, total size of all elements
+        uint64_t offset_bits;
+        std::string type_name;
+        std::string member_name;
+        std::optional<uint64_t> array_size;
+
+        bool operator==(const MemberInfo& other) const {
+            return  size_bits == other.size_bits &&
+                    offset_bits == other.offset_bits &&
+                    type_name == other.type_name &&
+                    member_name == other.member_name &&
+                    array_size == other.array_size;
+        }
+    };
+
+    std::vector<MemberInfo> members;
+
+    bool operator==(const StructInfo& other) const {
+        return (const SimpleTypeInfo&)*this == (const SimpleTypeInfo&)other &&
+                std::equal(members.begin(), members.end(), other.members.begin(), other.members.end());
+    }
+};
+
+struct TypeInfo : std::variant<std::monostate, SimpleTypeInfo, StructInfo> {
+    using Parent = std::variant<std::monostate, SimpleTypeInfo, StructInfo>;
+
+    TypeInfo() = default;
+    TypeInfo(const SimpleTypeInfo& info) : Parent(info) {}
+    TypeInfo(const StructInfo& info) : Parent(info) {}
+
+    // Opaque declaration with no full definition.
+    // Pointers to these can still be passed along ABI boundaries assuming
+    // implementation details are only ever accessed on one side.
+    bool is_opaque() const {
+        return std::holds_alternative<std::monostate>(*this);
+    }
+
+    const StructInfo* get_if_struct() const {
+        return std::get_if<StructInfo>(this);
+    }
+
+    StructInfo* get_if_struct() {
+        return std::get_if<StructInfo>(this);
+    }
+
+    const SimpleTypeInfo* get_if_simple_or_struct() const {
+        auto as_struct = std::get_if<StructInfo>(this);
+        if (as_struct) {
+            return as_struct;
+        }
+        return std::get_if<SimpleTypeInfo>(this);
+    }
+};
+
+struct FuncPtrInfo {
+    std::array<uint8_t, 32> sha256;
+    std::string result;
+    std::vector<std::string> args;
+
+    // TODO: Do we actually need these here? Instead, we can fixup the parameters in-place!
+    std::unordered_map<unsigned, ParameterAnnotations> param_annotations;
+};
+
+struct ABI : std::unordered_map<std::string, TypeInfo> {
+    std::unordered_map<std::string, FuncPtrInfo> funcptr_types;
+    int pointer_size; // in bytes
+};
+
+std::unordered_map<const clang::Type*, TypeInfo>
+ComputeDataLayout(const clang::ASTContext& context, const std::unordered_map<const clang::Type*, AnalysisAction::RepackedType>& types);
+
+// Convert the output of ComputeDataLayout to a format that isn't tied to a libclang session.
+// As a consequence, type information is indexed by type name instead of clang::Type.
+ABI GetStableLayout(const clang::ASTContext& context, const std::unordered_map<const clang::Type*, TypeInfo>& data_layout);
+
+enum class TypeCompatibility {
+    Full,       // Type has matching data layout across architectures
+    Repackable, // Type has different data layout but can be repacked automatically
+    None,       // Type has different data layout and cannot be repacked automatically
+};
+
+class DataLayoutCompareAction : public AnalysisAction {
+public:
+    DataLayoutCompareAction(const ABI& abi) : abi(abi) {
+    }
+
+    TypeCompatibility GetTypeCompatibility(
+            const clang::ASTContext&,
+            const clang::Type*,
+            const std::unordered_map<const clang::Type*, TypeInfo> host_abi,
+            std::unordered_map<const clang::Type*, TypeCompatibility>& type_compat);
+
+    FuncPtrInfo LookupGuestFuncPtrInfo(const char* funcptr_id);
+
+protected: // TODO: Should probably be private
+    // TODO: Make it clearer that this is the guest ABI
+    const ABI& abi;
+};
diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index bef050da23..cedc65e1e0 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -1,6 +1,7 @@
 #include "analysis.h"
+#include "data_layout.h"
+#include "diagnostics.h"
 #include "interface.h"
-
 #include <clang/Frontend/CompilerInstance.h>
 
 #include <fstream>
@@ -8,15 +9,16 @@
 #include <iostream>
 #include <string_view>
 #include <unordered_map>
+#include <variant>
 
 #include <fmt/format.h>
 #include <fmt/ostream.h>
 
 #include <openssl/sha.h>
 
-class GenerateThunkLibsAction : public AnalysisAction {
+class GenerateThunkLibsAction : public DataLayoutCompareAction {
 public:
-    GenerateThunkLibsAction(const std::string& libname, const OutputFilenames&);
+    GenerateThunkLibsAction(const std::string& libname, const OutputFilenames&, const ABI& abi);
 
 private:
     // Generate helper code for thunk libraries and write them to the output file
@@ -27,8 +29,8 @@ class GenerateThunkLibsAction : public AnalysisAction {
     const OutputFilenames& output_filenames;
 };
 
-GenerateThunkLibsAction::GenerateThunkLibsAction(const std::string& libname_, const OutputFilenames& output_filenames_)
-    : libfilename(libname_), libname(libname_), output_filenames(output_filenames_) {
+GenerateThunkLibsAction::GenerateThunkLibsAction(const std::string& libname_, const OutputFilenames& output_filenames_, const ABI& abi)
+    : DataLayoutCompareAction(abi), libfilename(libname_), libname(libname_), output_filenames(output_filenames_) {
     for (auto& c : libname) {
         if (c == '-') {
             c = '_';
@@ -47,7 +49,108 @@ static std::string format_function_args(const FunctionParams& params, Fn&& forma
     return ret;
 };
 
+// Custom sort algorithm that works with partial orders.
+//
+// In contrast, std::sort requires that any two different elements A and B of
+// the input range compare either A<B or B<A. This requirement is violated e.g.
+// for dependency relations: Elements A and B might not depend on each other,
+// but they both might depend on some third element C. BubbleSort then ensures
+// C preceeds both A and B in the sorted range, while leaving the relative
+// order of A and B undetermined. In effect when iterating over the sorted
+// range, each dependency is visited before any of its dependees.
+template<std::forward_iterator It>
+void BubbleSort(It begin, It end,
+                std::relation<std::iter_value_t<It>, std::iter_value_t<It>> auto compare) {
+    repeat:
+    while (true) {
+        bool fixpoint = true;
+        for (auto it = begin; it != end; ++it) {
+            for (auto it2 = std::next(it); it2 != end; ++it2) {
+                if (compare(*it2, *it)) {
+                    std::swap(*it, *it2);
+                    fixpoint = false;
+                    goto repeat; // TODO: Drop. Instead, wind back to it
+                }
+            }
+        }
+
+        if (fixpoint) {
+            return;
+        }
+    }
+}
+
+// Compares such that A < B if B contains A as a member and requires A to be completely defined (i.e. non-pointer/non-reference).
+// This applies recursively to structs contained by B.
+struct compare_by_struct_dependency {
+    clang::ASTContext& context;
+
+    bool operator()(const std::pair<const clang::Type*, GenerateThunkLibsAction::RepackedType>& a,
+                    const std::pair<const clang::Type*, GenerateThunkLibsAction::RepackedType>& b) const {
+      return (*this)(a.first, b.first);
+    }
+
+    bool operator()(const clang::Type* a, const clang::Type* b) const {
+        auto* b_as_array = llvm::dyn_cast<clang::ConstantArrayType>(b);
+        if (b_as_array) {
+            // TODO: Why do we register array types like VkMemoryHeap[16] to begin with?
+            return context.hasSameType(b_as_array->getArrayElementTypeNoTypeQual(), a);
+        }
+
+        auto* b_as_struct = b->getAsStructureType();
+        if (!b_as_struct) {
+            // Not a struct => no dependency
+            return false;
+        }
+
+        for (auto* child : b_as_struct->getDecl()->fields()) {
+            if (child->getType()->isPointerType()) {
+                // Pointers don't need the definition to be available
+                continue;
+            }
+
+            auto element_type = a->isArrayType() ? a->getArrayElementTypeNoTypeQual() : a;
+            if (context.hasSameType(child->getType().getTypePtr(), element_type)) {
+                return true;
+            }
+
+//            if (context.hasSameType(child->getType().getTypePtr(), b)) {
+//                // Pointer to the struct itself, no need to recurse
+//                continue;
+//            }
+
+//                    // If this is a pointer (and not a fixed-size array), we don't need a complete definition
+//                    if (!child.pointer_chain.empty() && std::none_of(child.pointer_chain.begin(), child.pointer_chain.end(),
+//                                                                      [](const PointerInfo& ptr) { return ptr.array_size.has_value(); })) {
+//                         continue;
+//                    }
+
+            if ((*this)(a, child->getType().getTypePtr())) {
+                // Child depends on A => transitive dependency
+                return true;
+            }
+        }
+
+        // No dependency found
+        return false;
+    }
+};
+
 void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
+    ErrorReporter report_error { context };
+
+    // Compute data layout differences between host and guest
+    auto type_compat = [&]() {
+        std::unordered_map<const clang::Type*, TypeCompatibility> ret;
+        const auto host_abi = ComputeDataLayout(context, types);
+        for (const auto& [type, type_repack_info] : types) {
+            if (!type_repack_info.pointers_only) {
+                GetTypeCompatibility(context, type, host_abi, ret);
+            }
+        }
+        return ret;
+    }();
+
     static auto format_decl = [](clang::QualType type, const std::string_view& name) {
         clang::QualType innermostPointee = type;
         while (innermostPointee->isPointerType()) {
@@ -104,8 +207,8 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
         return ret;
     };
 
-    auto get_sha256 = [this](const std::string& function_name) {
-        std::string sha256_message = libname + ":" + function_name;
+    auto get_sha256 = [this](const std::string& function_name, bool include_libname) {
+        std::string sha256_message = (include_libname ? libname + ":" : "") + function_name;
         std::vector<unsigned char> sha256(SHA256_DIGEST_LENGTH);
         SHA256(reinterpret_cast<const unsigned char*>(sha256_message.data()),
                sha256_message.size(),
@@ -125,18 +228,26 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
         file << "extern \"C\" {\n";
         for (auto& thunk : thunks) {
             const auto& function_name = thunk.function_name;
-            auto sha256 = get_sha256(function_name);
+            auto sha256 = get_sha256(function_name, true);
             fmt::print( file, "MAKE_THUNK({}, {}, \"{:#02x}\")\n",
                         libname, function_name, fmt::join(sha256, ", "));
         }
         file << "}\n";
 
         // Guest->Host transition points for invoking runtime host-function pointers based on their signature
+        std::vector<std::vector<unsigned char>> sha256s;
         for (auto type_it = funcptr_types.begin(); type_it != funcptr_types.end(); ++type_it) {
-            auto* type = *type_it;
+            auto* type = type_it->second.first;
             std::string funcptr_signature = clang::QualType { type, 0 }.getAsString();
 
-            auto cb_sha256 = get_sha256("fexcallback_" + funcptr_signature);
+            auto cb_sha256 = get_sha256("fexcallback_" + funcptr_signature, false);
+            auto it = std::find(sha256s.begin(), sha256s.end(), cb_sha256);
+            if (it != sha256s.end()) {
+                // TODO: Avoid this ugly way of avoiding duplicates
+                continue;
+            } else {
+                sha256s.push_back(cb_sha256);
+            }
 
             // Thunk used for guest-side calls to host function pointers
             file << "  // " << funcptr_signature << "\n";
@@ -157,7 +268,7 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             }
             // Using trailing return type as it makes handling function pointer returns much easier
             file << ") -> " << data.return_type.getAsString() << " {\n";
-            file << "  struct {\n";
+            file << "  struct __attribute__((packed)) {\n";
             for (std::size_t idx = 0; idx < data.param_types.size(); ++idx) {
                 auto& type = data.param_types[idx];
                 file << "    " << format_decl(type.getUnqualifiedType(), fmt::format("a_{}", idx)) << ";\n";
@@ -174,7 +285,7 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                 auto cb = data.callbacks.find(idx);
 
                 file << "  args.a_" << idx << " = ";
-                if (cb == data.callbacks.end() || cb->second.is_stub || cb->second.is_guest) {
+                if (cb == data.callbacks.end() || cb->second.is_stub) {
                     file << "a_" << idx << ";\n";
                 } else {
                     // Before passing guest function pointers to the host, wrap them in a host-callable trampoline
@@ -224,6 +335,210 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
     if (!output_filenames.host.empty()) {
         std::ofstream file(output_filenames.host);
 
+    // TODO: Move to dedicated function
+    {
+        fmt::print(file, "template<auto PMD>\n");
+        fmt::print(file, "static inline void fex_custom_repack(host_layout<typename pmd_traits<decltype(PMD)>::parent_t>& into, const guest_layout<typename pmd_traits<decltype(PMD)>::parent_t>& from);\n");
+
+        fmt::print(file, "template<auto PMD>\n");
+        fmt::print(file, "static inline void fex_custom_repack_postcall(const typename pmd_traits<decltype(PMD)>::member_t& from);\n\n");
+
+        // Sort struct types by dependency so that repacking code is emitted in an order that compiles file
+        auto& types2 = types;
+        std::vector<std::pair<const clang::Type*, RepackedType>> types { types2.begin(), types2.end() };
+        BubbleSort(types.begin(), types.end(), compare_by_struct_dependency { context });
+
+        for (const auto& [type, type_repack_info] : types) {
+            auto struct_name = get_type_name(context, type);
+
+            // Opaque types don't need layout definitions
+            if (type_repack_info.is_opaque && type_repack_info.pointers_only) {
+                if (abi.pointer_size != 4) {
+                    fmt::print(file, "template<> inline constexpr bool has_compatible_data_layout<{}*> = true;\n", struct_name);
+                }
+                continue;
+            } else if (type_repack_info.is_opaque) {
+                // TODO: Handle more cleanly
+                type_compat[type] = TypeCompatibility::Full;
+            }
+
+            // These must be handled later since they are not canonicalized and hence must be de-duplicated first
+            if (type->isBuiltinType() && !type->isEnumeralType()) {
+                continue;
+            }
+
+            // TODO: Instead, map these names back to *some* type that's named?
+            if (struct_name.starts_with("unnamed_")) {
+                continue;
+            }
+
+            if (type->isEnumeralType()) {
+                fmt::print(file, "template<>\nstruct __attribute__((packed)) guest_layout<{}> {{\n", struct_name);
+                fmt::print(file, "  using type = {}int{}_t;\n",
+                           type->isUnsignedIntegerOrEnumerationType() ? "u" : "",
+                           abi.at(struct_name).get_if_simple_or_struct()->size_bits);
+                fmt::print(file, "  type data;\n");
+                fmt::print(file, "}};\n");
+                continue;
+            }
+
+            // Guest layout definition
+            // NOTE: uint64_t has lower alignment requirements on 32-bit than on 64-bit, so we require tightly packed structs
+            // TODO: Now we must emit padding bytes explicitly, though!
+            fmt::print(file, "template<>\nstruct __attribute__((packed)) guest_layout<{}> {{\n", struct_name);
+            if (type_compat.at(type) == TypeCompatibility::Full) {
+                fmt::print(file, "  using type = {};\n", struct_name);
+            } else {
+                fmt::print(file, "  struct type {{\n");
+                for (auto& member : abi.at(struct_name).get_if_struct()->members) {
+                    // sizeof(size_t) is 4 on 32-bit but 8 on 64-bit. Turn it into a fixed-size type to resolve the difference.
+                    // TODO: Actually use 64 bits on 64 bit guests...
+                    // TODO: Auto-detect type size differences instead
+                    bool is_size_t = member.type_name == "size_t";
+                    fmt::print( file, "    guest_layout<{}{}> {};\n",
+                                is_size_t ? "uint32_t" : member.type_name,
+                                member.array_size ? fmt::format("[{}]", member.array_size.value()) : "",
+                                member.member_name);
+                }
+                fmt::print(file, "  }};\n");
+            }
+            fmt::print(file, "  type data;\n");
+            fmt::print(file, "}};\n");
+
+            fmt::print(file, "template<>\nstruct guest_layout<const {}> : guest_layout<{}> {{\n", struct_name, struct_name);
+            fmt::print(file, "  guest_layout& operator=(const guest_layout<{}>& other) {{ memcpy(this, &other, sizeof(other)); return *this; }}\n", struct_name);
+            fmt::print(file, "}};\n");
+
+            // Host layout definition
+            fmt::print(file, "template<>\n");
+            fmt::print(file, "struct host_layout<{}> {{\n", struct_name);
+            fmt::print(file, "  using type = {};\n", struct_name);
+            fmt::print(file, "  type data;\n");
+            fmt::print(file, "\n");
+            fmt::print(file, "  host_layout(const guest_layout<{}>& from) ", struct_name);
+            if (type_compat.at(type) == TypeCompatibility::Full) {
+                fmt::print(file, ":\n");
+                fmt::print(file, "    data {{ from.data }} {{\n");
+                fmt::print(file, "  }}\n");
+            } else if (type_compat.at(type) == TypeCompatibility::Repackable) {
+                fmt::print(file, ":\n");
+                fmt::print(file, "    data {{\n");
+                fmt::print(file, "      // Constructor performs layout repacking.\n");
+                fmt::print(file, "      // Each initializer itself is wrapped in host_layout<> to enable recursive layout repacking\n");
+                auto map_field = [&file](clang::FieldDecl* member, bool skip_arrays) {
+                    auto decl_name = member->getNameAsString();
+                    auto type_name = member->getType().getAsString();
+                    auto array_type = llvm::dyn_cast<clang::ConstantArrayType>(member->getType());
+                    if (!array_type && skip_arrays) {
+                        fmt::print(file, "      .{} = host_layout<{}> {{ from.data.{} }}.data,\n", decl_name, type_name, decl_name);
+                    } else if (array_type && !skip_arrays) {
+                        // Copy element-wise below
+                        fmt::print(file, "      for (size_t i = 0; i < {}; ++i) {{\n", array_type->getSize().getZExtValue());
+                        fmt::print(file, "        data.{}[i] = host_layout<{}> {{ from.data.{} }}.data[i];\n", decl_name, type_name, decl_name);
+                        fmt::print(file, "      }}\n");
+                    }
+                };
+                // Prefer initialization via the constructor's initializer list if possible (to detect unintended narrowing), otherwise initialize in the body
+                for (auto* member : type->getAsStructureType()->getDecl()->fields()) {
+                    if (!type_repack_info.UsesCustomRepackFor(member)) {
+                        map_field(member, true);
+                    } else {
+                      // Leave field uninitialized
+                    }
+                }
+                fmt::print(file, "    }} {{\n");
+                for (auto* member : type->getAsStructureType()->getDecl()->fields()) {
+                    if (!type_repack_info.UsesCustomRepackFor(member)) {
+                        map_field(member, false);
+                    } else {
+                      // Leave field uninitialized
+                    }
+                }
+                fmt::print(file, "  }}\n");
+            } else {
+                fmt::print(file, "= delete;\n");
+            }
+            fmt::print(file, "}};\n\n");
+
+            fmt::print(file, "// Constructor performs layout repacking.\n");
+            fmt::print(file, "// Each initializer itself is wrapped in host_layout<> to enable recursive layout repacking\n");
+            fmt::print(file, "inline guest_layout<{}> to_guest(const host_layout<{}>& from) ", struct_name, struct_name);
+            if (type_compat.at(type) == TypeCompatibility::Full) {
+                fmt::print(file, "{{\n");
+                fmt::print(file, "  guest_layout<{}> ret;\n", struct_name);
+                fmt::print(file, "  static_assert(sizeof(from) == sizeof(ret));\n");
+                fmt::print(file, "  memcpy(&ret, &from, sizeof(from));\n");
+                fmt::print(file, "  return ret;\n");
+                fmt::print(file, "}}\n\n");
+            } else if (type_compat.at(type) == TypeCompatibility::Repackable) {
+                fmt::print(file, "{{\n");
+                fmt::print(file, "  guest_layout<{}> ret {{ .data {{\n", struct_name);
+                auto map_field2 = [&file](const StructInfo::MemberInfo& member, bool skip_arrays) {
+                    auto& decl_name = member.member_name;
+                    auto& array_size = member.array_size;
+                    if (!array_size && skip_arrays) {
+                        fmt::print(file, "    .{} = to_guest(to_host_layout(from.data.{})),\n", decl_name, decl_name);
+                    } else if (array_size && !skip_arrays) {
+                        // Copy element-wise below
+                        fmt::print(file, "    for (size_t i = 0; i < {}; ++i) {{\n", array_size.value());
+                        fmt::print(file, "      ret.data.{}.data[i] = to_guest(to_host_layout(from.data.{}[i]));\n", decl_name, decl_name);
+                        fmt::print(file, "    }}\n");
+                    }
+                };
+
+                // Prefer initialization via the constructor's initializer list if possible (to detect unintended narrowing), otherwise initialize in the body
+                for (auto& member : abi.at(struct_name).get_if_struct()->members) {
+                    if (!type_repack_info.UsesCustomRepackFor(member.member_name)) {
+                        map_field2(member, true);
+                    } else {
+                      // Leave field uninitialized
+                    }
+                }
+                fmt::print(file, "  }} }};\n");
+                for (auto& member : abi.at(struct_name).get_if_struct()->members) {
+                    if (!type_repack_info.UsesCustomRepackFor(member.member_name)) {
+                        map_field2(member, false);
+                    } else {
+                      // Leave field uninitialized
+                    }
+                }
+                fmt::print(file, "  return ret;\n");
+                fmt::print(file, "}}\n\n");
+            } else {
+                fmt::print(file, "= delete;\n\n");
+            }
+
+            // Forward-declare user-provided repacking functions
+            for (const auto& member_name : type_repack_info.custom_repacked_members) {
+                fmt::print(file, "template<>\n");
+                fmt::print(file, "void fex_custom_repack<&{}::{}>(host_layout<{}>& into, const guest_layout<{}>& from);\n",
+                           struct_name, member_name, struct_name, struct_name);
+                fmt::print(file, "template<>\n");
+                // TODO: Consider adapting the fex_custom_repack interface changes to this function, too
+                fmt::print(file, "void fex_custom_repack_postcall<&{}::{}>(const typename pmd_traits<decltype(&{}::{})>::member_t& from);\n\n",
+                           struct_name, member_name, struct_name, member_name);
+            }
+
+            // TODO: Generate wrappers to call all custom repack functions for children
+            fmt::print(file, "void fex_apply_custom_repacking(host_layout<{}>& source, const guest_layout<{}>& from) {{\n", struct_name, struct_name);
+            for (const auto& member_name : type_repack_info.custom_repacked_members) {
+                fmt::print(file, "  fex_custom_repack<&{}::{}>(source, from);\n",
+                           /*member_name, */struct_name, member_name);
+            }
+            fmt::print(file, "}}\n");
+            fmt::print(file, "void fex_apply_custom_repacking_postcall(host_layout<{}>& source) {{\n", struct_name);
+            for (const auto& member_name : type_repack_info.custom_repacked_members) {
+                fmt::print(file, "  fex_custom_repack_postcall<&{}::{}>(source.data.{});\n",
+                           struct_name, member_name, member_name);
+            }
+            fmt::print(file, "}}\n");
+
+            if (type_compat.at(type) == TypeCompatibility::Full) {
+                fmt::print(file, "template<> inline constexpr bool has_compatible_data_layout<{}> = true;\n", struct_name);
+            }
+        }
+    }
+
         // Forward declarations for symbols loaded from the native host library
         for (auto& import : thunked_api) {
             const auto& function_name = import.function_name;
@@ -259,25 +574,53 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
 
                     file << (idx == 0 ? "" : ", ");
 
-                    auto cb = thunk.callbacks.find(idx);
-                    if (cb != thunk.callbacks.end() && cb->second.is_guest) {
-                        file << "fex_guest_function_ptr a_" << idx;
+                    if (thunk.param_annotations[idx].is_passthrough) {
+                        fmt::print(file, "guest_layout<{}> a_{}", type.getAsString(), idx);
                     } else {
-                      file << format_decl(type, fmt::format("a_{}", idx));
+                        file << format_decl(type, fmt::format("a_{}", idx));
                     }
                 }
                 // Using trailing return type as it makes handling function pointer returns much easier
                 file << ") -> " << thunk.return_type.getAsString() << ";\n";
             }
 
+            // Check data layout compatibility of parameter types
+            // TODO: Also check non-struct/non-pointer types
+            // TODO: Also check return type
+            for (size_t param_idx = 0; param_idx != thunk.param_types.size(); ++param_idx) {
+                const auto& param_type = thunk.param_types[param_idx];
+                if (!param_type->isPointerType() || !param_type->getPointeeType()->isStructureType()) {
+                    continue;
+                }
+                auto type = param_type->getPointeeType();
+                if (!types.at(context.getCanonicalType(type.getTypePtr())).is_opaque && type_compat.at(context.getCanonicalType(type.getTypePtr())) == TypeCompatibility::None) {
+                    // TODO: Factor in "assume_compatible_layout" annotations here
+                    //       That annotation should cause the type to be treated as TypeCompatibility::Full
+                    if (!thunk.param_annotations[param_idx].is_passthrough) {
+                        throw report_error(thunk.decl->getLocation(), "Unsupported parameter type %0").AddTaggedVal(param_type);
+                    }
+                }
+            }
+
             // Packed argument structs used in fexfn_unpack_*
-            auto GeneratePackedArgs = [&](const auto &function_name, const auto &thunk) -> std::string {
+            auto GeneratePackedArgs = [&](const auto &function_name, const ThunkedFunction &thunk) -> std::string {
                 std::string struct_name = "fexfn_packed_args_" + libname + "_" + function_name;
-                file << "struct " << struct_name << " {\n";
+                file << "struct __attribute__((packed)) " << struct_name << " {\n";
 
-                file << format_struct_members(thunk, "  ");
+                auto get_type_name = [this](clang::QualType type) {
+                    if (type->isBuiltinType() && !type->isFloatingType()) {
+                        auto size = abi.at(type.getUnqualifiedType().getAsString()).get_if_simple_or_struct()->size_bits;
+                        return fmt::format("{}int{}_t", !type->isSignedIntegerType() ? "u" : "", size);
+                    } else {
+                        return type.getUnqualifiedType().getAsString();
+                    }
+                };
+
+                for (std::size_t idx = 0; idx < thunk.param_types.size(); ++idx) {
+                    fmt::print(file, "  guest_layout<{}> a_{};\n", get_type_name(thunk.param_types[idx]), idx);
+                }
                 if (!thunk.return_type->isVoidType()) {
-                    file << "  " << format_decl(thunk.return_type, "rv") << ";\n";
+                    fmt::print(file, "  guest_layout<{}> rv;\n", get_type_name(thunk.return_type));
                 } else if (thunk.param_types.size() == 0) {
                     // Avoid "empty struct has size 0 in C, size 1 in C++" warning
                     file << "    char force_nonempty;\n";
@@ -294,27 +637,121 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             }
 
             file << "static void fexfn_unpack_" << libname << "_" << function_name << "(" << struct_name << "* args) {\n";
-            file << (thunk.return_type->isVoidType() ? "  " : "  args->rv = ") << function_to_call << "(";
+
+            for (unsigned param_idx = 0; param_idx != thunk.param_types.size(); ++param_idx) {
+                if (thunk.callbacks.contains(param_idx) && thunk.callbacks.at(param_idx).is_stub) {
+                    continue;
+                }
+
+                auto& param_type = thunk.param_types[param_idx];
+                const bool is_opaque = param_type->isPointerType() &&
+                          (thunk.param_annotations[param_idx].is_opaque || ((param_type->getPointeeType()->isStructureType() || (param_type->getPointeeType()->isPointerType() && param_type->getPointeeType()->getPointeeType()->isStructureType())) &&
+                          (types.contains(context.getCanonicalType(param_type->getPointeeType()->getLocallyUnqualifiedSingleStepDesugaredType().getTypePtr())) && LookupType(context, context.getCanonicalType(param_type->getPointeeType()->getLocallyUnqualifiedSingleStepDesugaredType().getTypePtr())).is_opaque)));
+
+                std::optional<TypeCompatibility> pointee_compat;
+                if (param_type->isPointerType()) {
+                    // Get TypeCompatibility from existing entry, or register TypeCompatibility::None if no entry exists
+                    // TODO: Currently needs TypeCompatibility::Full workaround...
+                    pointee_compat = type_compat.emplace(context.getCanonicalType(param_type->getPointeeType().getTypePtr()), TypeCompatibility::Full).first->second;
+                }
+
+                if (thunk.param_annotations[param_idx].is_passthrough) {
+                    // args are passed directly to function, no need to use `unpacked` wrappers
+                    continue;
+                }
+
+                // Layout repacking happens here
+                if (!param_type->isPointerType() || (is_opaque || pointee_compat == TypeCompatibility::Full) ||
+                    param_type->getPointeeType()->isBuiltinType() /* TODO: handle size_t. Actually, properly check for data layout compatibility */) {
+                    // Fully compatible
+                    fmt::print(file, "  host_layout<{}> a_{} {{ args->a_{} }};\n", get_type_name(context, param_type.getTypePtr()), param_idx, param_idx);
+                } else if (pointee_compat == TypeCompatibility::Repackable) {
+                    // TODO: Require opt-in for this to be emitted since it's single-element only; otherwise, pointers-to-arrays arguments will cause stack trampling
+                    // TODO: Rename to repacked_arg
+                    auto get_type_name_with_nonconst_pointee = [&](clang::QualType type) {
+                        type = type.getLocalUnqualifiedType();
+                        if (type->isPointerType()) {
+                            // Strip away "const" from pointee type
+                            type = context.getPointerType(type->getPointeeType().getLocalUnqualifiedType());
+                        }
+                        return get_type_name(context, type.getTypePtr());
+                    };
+                    fmt::print(file, "  unpacked_arg_with_storage<{}> a_{} {{ args->a_{} }};\n", get_type_name_with_nonconst_pointee(param_type), param_idx, param_idx);
+                } else {
+                    throw report_error(thunk.decl->getLocation(), "Cannot generate unpacking function for function %0 with unannotated pointer parameter %1").AddString(function_name).AddTaggedVal(param_type);
+                }
+
+                // Custom repacking happens here
+                if (param_type->isPointerType() && param_type->getPointeeType()->isStructureType() &&
+                    !is_opaque && pointee_compat != TypeCompatibility::Full) {
+                    fmt::print(file, "  if (args->a_{}.get_pointer()) {{\n", param_idx);
+                    fmt::print(file, "    fex_apply_custom_repacking(*a_{}.data, *args->a_{}.get_pointer());\n", param_idx, param_idx);
+                    fmt::print(file, "  }}\n");
+                }
+            }
+
+            if (!thunk.return_type->isVoidType()) {
+                fmt::print(file, "  args->rv = ");
+                if (!thunk.return_type->isFunctionPointerType()) {
+                    fmt::print(file, "to_guest(to_host_layout<{}>(", thunk.return_type.getAsString());
+                }
+            }
+            fmt::print(file, "{}(", function_to_call);
             {
                 auto format_param = [&](std::size_t idx) {
                     auto cb = thunk.callbacks.find(idx);
                     if (cb != thunk.callbacks.end() && cb->second.is_stub) {
                         return "fexfn_unpack_" + get_callback_name(function_name, cb->first) + "_stub";
-                    } else if (cb != thunk.callbacks.end() && cb->second.is_guest) {
-                        return fmt::format("fex_guest_function_ptr {{ args->a_{} }}", idx);
                     } else if (cb != thunk.callbacks.end()) {
-                        auto arg_name = fmt::format("args->a_{}", idx);
+                        auto arg_name = fmt::format("args->a_{}", idx); // Use parameter directly
                         // Use comma operator to inject a function call before returning the argument
-                        return "(FinalizeHostTrampolineForGuestFunction(" + arg_name + "), " + arg_name + ")";
-
-                    } else {
+                        // TODO: Avoid casting away the guest_layout
+                        if (thunk.custom_host_impl) {
+                            return fmt::format("(FinalizeHostTrampolineForGuestFunction({}), {})", arg_name, arg_name);
+                        } else {
+                            return fmt::format("(FinalizeHostTrampolineForGuestFunction({}), ({})(uint64_t {{ {}.data }}))", arg_name, get_type_name(context, thunk.param_types[idx].getTypePtr()), arg_name);
+                        }
+                    } else if (thunk.param_annotations[idx].is_passthrough) {
+                        // Pass raw guest_layout<T*>
                         return fmt::format("args->a_{}", idx);
+                    } else {
+                        // Unwrap host_layout/unpacked_arg_with_storage layer
+                        return fmt::format("unwrap_host(a_{})", idx);
                     }
                 };
 
-                file << format_function_args(thunk, format_param);
+                fmt::print(file, "{}", format_function_args(thunk, format_param));
+            }
+            if (!thunk.return_type->isVoidType() && !thunk.return_type->isFunctionPointerType()) {
+                fmt::print(file, "))");
+            }
+            fmt::print(file, ");\n");
+
+            for (unsigned param_idx = 0; param_idx != thunk.param_types.size(); ++param_idx) {
+                if (thunk.callbacks.contains(param_idx) && thunk.callbacks.at(param_idx).is_stub) {
+                    continue;
+                }
+
+                auto& param_type = thunk.param_types[param_idx];
+
+                const bool is_compatible = param_type->isPointerType() && type_compat.at(context.getCanonicalType(param_type->getPointeeType().getTypePtr())) == TypeCompatibility::Full;
+
+                if (thunk.param_annotations[param_idx].is_passthrough) {
+                    // args are passed directly to function, no need to use `unpacked` wrappers
+                    continue;
+                }
+
+                if (param_type->isPointerType() && param_type->getPointeeType()->isStructureType() &&
+                      !is_compatible &&
+                      !LookupType(context, param_type->getPointeeType()->getLocallyUnqualifiedSingleStepDesugaredType().getTypePtr()).is_opaque &&
+                      !param_type->getPointeeType().isConstQualified()) {
+                    fmt::print(file, "  if (a_{}.data) {{\n", param_idx);
+                    fmt::print(file, "    *args->a_{}.get_pointer() = to_guest(*a_{}.data);\n", param_idx, param_idx); // TODO: Only if annotated as out-parameter
+                    fmt::print(file, "    fex_apply_custom_repacking_postcall(*a_{}.data);\n", param_idx);
+                    fmt::print(file, "  }}\n");
+                }
             }
-            file << ");\n";
+
             file << "}\n";
         }
         file << "}\n";
@@ -323,18 +760,67 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
         file << "static ExportEntry exports[] = {\n";
         for (auto& thunk : thunks) {
             const auto& function_name = thunk.function_name;
-            auto sha256 = get_sha256(function_name);
+            auto sha256 = get_sha256(function_name, true);
             fmt::print( file, "  {{(uint8_t*)\"\\x{:02x}\", (void(*)(void *))&fexfn_unpack_{}_{}}}, // {}:{}\n",
                         fmt::join(sha256, "\\x"), libname, function_name, libname, function_name);
         }
 
         // Endpoints for Guest->Host invocation of runtime host-function pointers
-        for (auto& type : funcptr_types) {
+        // NOTE: The function parameters may differ slightly between guest and host,
+        //       e.g. due to differing sizes or due to data layout differences.
+        //       Hence, two separate parameter lists are managed here.
+        for (auto& host_funcptr_entry : funcptr_types) {
+            auto& [type, param_annotations] = host_funcptr_entry.second;
+            auto func_type = type->getAs<clang::FunctionProtoType>();
             std::string mangled_name = clang::QualType { type, 0 }.getAsString();
-            auto cb_sha256 = get_sha256("fexcallback_" + mangled_name);
-            fmt::print( file, "  {{(uint8_t*)\"\\x{:02x}\", (void(*)(void *))&CallbackUnpack<{}>::ForIndirectCall}},\n",
-                        fmt::join(cb_sha256, "\\x"), mangled_name);
+            FuncPtrInfo info = { };
+
+            info.result = func_type->getReturnType().getAsString();
+            info.param_annotations = param_annotations;
+
+            // Heuristic approach to preserve data layout for arguments.
+            // We can re-use the string representation of most types without problems.
+            // Built-in types with differing size must be replaced with fixed-size integers.
+            // TODO: Instead of using these heuristics here, record the type name and its size.
+            //       Then, when emitting code, replace types with fixed-size integers only if the
+            //       sizes don't match
+            // TODO: Also apply these heuristics to the return type
+            // TODO: Respect param_annotations
+            for (auto arg : func_type->getParamTypes()) {
+                if (arg->isBuiltinType()) {
+                    auto size = context.getTypeSize(arg);
+                    info.args.push_back(fmt::format("uint{}_t", size));
+                } else if (arg->isPointerType() && arg->getPointeeType()->isBuiltinType() && context.getTypeSize(arg->getPointeeType()) >= 2 * 8) {
+                    auto size = context.getTypeSize(arg->getPointeeType());
+                    info.args.push_back(fmt::format("uint{}_t*", size));
+                } else {
+                    info.args.push_back(arg.getAsString());
+                }
+            }
+
+            std::string annotations;
+            for (int param_idx = 0; param_idx < info.args.size(); ++param_idx) {
+                if (param_idx != 0) {
+                    annotations += ", ";
+                }
+
+                annotations += "ParameterAnnotations {";
+                if (param_annotations.contains(param_idx) && param_annotations.at(param_idx).is_passthrough) {
+                    // TODO: Rename annotation in Host.h?
+                    annotations += ".is_passthrough=true,";
+                }
+                if (param_annotations.contains(param_idx) && param_annotations.at(param_idx).is_opaque) {
+                    // TODO: Rename annotation in Host.h?
+                    annotations += ".is_opaque=true,";
+                }
+                annotations += "}";
+            }
+            auto guest_info = LookupGuestFuncPtrInfo(host_funcptr_entry.first.c_str());
+            // TODO: Consider differences in guest/host return types
+            fmt::print( file, "  {{(uint8_t*)\"\\x{:02x}\", (void(*)(void *))&GuestWrapperForHostFunction<{}({}){}{}>::Call<{}>}}, // {}\n",
+                        fmt::join(guest_info.sha256, "\\x"), guest_info.result, fmt::join(info.args, ", "), guest_info.args.empty() ? "" : ", ", fmt::join(guest_info.args, ", "), annotations, host_funcptr_entry.first);
         }
+
         file << "  { nullptr, nullptr }\n";
         file << "};\n";
 
@@ -371,7 +857,7 @@ bool GenerateThunkLibsActionFactory::runInvocation(
   Compiler.setInvocation(std::move(Invocation));
   Compiler.setFileManager(Files);
 
-  GenerateThunkLibsAction Action(libname, output_filenames);
+  GenerateThunkLibsAction Action(libname, output_filenames, abi);
 
   Compiler.createDiagnostics(DiagConsumer, false);
   if (!Compiler.hasDiagnostics())
diff --git a/ThunkLibs/Generator/interface.h b/ThunkLibs/Generator/interface.h
index 62883670ac..86768d34f4 100644
--- a/ThunkLibs/Generator/interface.h
+++ b/ThunkLibs/Generator/interface.h
@@ -8,10 +8,38 @@ struct OutputFilenames {
     std::string guest;
 };
 
+class AnalyzeDataLayoutActionFactory : public clang::tooling::FrontendActionFactory {
+    std::unique_ptr<struct ABI> abi;
+
+public:
+    AnalyzeDataLayoutActionFactory();
+    ~AnalyzeDataLayoutActionFactory();
+
+    std::unique_ptr<clang::FrontendAction> create() override;
+
+    const ABI& GetDataLayout() {
+        return *abi;
+    }
+
+    std::unique_ptr<ABI> TakeDataLayout() {
+        return std::move(abi);
+    }
+};
+
+class DataLayoutCompareActionFactory : public clang::tooling::FrontendActionFactory {
+    const ABI& abi;
+
+public:
+    DataLayoutCompareActionFactory(const ABI&);
+    ~DataLayoutCompareActionFactory();
+
+    std::unique_ptr<clang::FrontendAction> create() override;
+};
+
 class GenerateThunkLibsActionFactory : public clang::tooling::ToolAction {
 public:
-    GenerateThunkLibsActionFactory(std::string_view libname_, OutputFilenames output_filenames_)
-        : libname(std::move(libname_)), output_filenames(std::move(output_filenames_)) {
+    GenerateThunkLibsActionFactory(std::string_view libname_, OutputFilenames output_filenames_, const ABI& abi_)
+        : libname(std::move(libname_)), output_filenames(std::move(output_filenames_)), abi(abi_) {
     }
 
     bool runInvocation(
@@ -22,4 +50,5 @@ class GenerateThunkLibsActionFactory : public clang::tooling::ToolAction {
 private:
     std::string libname;
     OutputFilenames output_filenames;
+    const ABI& abi;
 };
diff --git a/ThunkLibs/Generator/main.cpp b/ThunkLibs/Generator/main.cpp
index ecc32bd684..726e5cbfa4 100644
--- a/ThunkLibs/Generator/main.cpp
+++ b/ThunkLibs/Generator/main.cpp
@@ -14,10 +14,10 @@ void print_usage(const char* program_name) {
     std::cerr << "Usage: " << program_name << " <filename> <libname> <gen_target> <output_filename> -- <clang_flags>\n";
 }
 
-int main(int argc, char* argv[]) {
+int main(int argc, char* const argv[]) {
     llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
 
-    if (argc < 6) {
+    if (argc < 5) {
         print_usage(argv[0]);
         return EXIT_FAILURE;
     }
@@ -32,12 +32,12 @@ int main(int argc, char* argv[]) {
     }
 
     // Process arguments before the "--" separator
-    if (argc != 5) {
+    if (argc != 5 && argc != 6) {
         print_usage(argv[0]);
         return EXIT_FAILURE;
     }
 
-    char** arg = argv + 1;
+    char* const* arg = argv + 1;
     const auto filename = *arg++;
     const std::string libname = *arg++;
     const std::string target_abi = *arg++;
@@ -62,5 +62,29 @@ int main(int argc, char* argv[]) {
         };
         Tool.appendArgumentsAdjuster(set_resource_directory);
     }
-    return Tool.run(std::make_unique<GenerateThunkLibsActionFactory>(std::move(libname), std::move(output_filenames)).get());
+
+    ClangTool GuestTool = Tool;
+
+    {
+        const bool is_32bit_guest = (argv[5] == std::string_view { "-for-32bit-guest" });
+        auto append_guest_args = [is_32bit_guest](const clang::tooling::CommandLineArguments &Args, clang::StringRef) {
+            clang::tooling::CommandLineArguments AdjustedArgs = Args;
+            const char* platform = is_32bit_guest ? "i686" : "x86_64";
+            if (is_32bit_guest) {
+                AdjustedArgs.push_back("-m32");
+                AdjustedArgs.push_back("-DIS_32BIT_THUNK");
+            }
+            AdjustedArgs.push_back(std::string { "--target=" } + platform + "-linux-unknown");
+            AdjustedArgs.push_back("-isystem");
+            AdjustedArgs.push_back(std::string { "/usr/" } + platform + "-linux-gnu/include/");
+            return AdjustedArgs;
+        };
+        GuestTool.appendArgumentsAdjuster(append_guest_args);
+    }
+
+    auto data_layout_analysis_factory = std::make_unique<AnalyzeDataLayoutActionFactory>();
+    GuestTool.run(data_layout_analysis_factory.get());
+    auto& data_layout = data_layout_analysis_factory->GetDataLayout();
+
+    return Tool.run(std::make_unique<GenerateThunkLibsActionFactory>(std::move(libname), std::move(output_filenames), data_layout).get());
 }
diff --git a/ThunkLibs/GuestLibs/CMakeLists.txt b/ThunkLibs/GuestLibs/CMakeLists.txt
index 69223e8a4d..fc84fd8742 100644
--- a/ThunkLibs/GuestLibs/CMakeLists.txt
+++ b/ThunkLibs/GuestLibs/CMakeLists.txt
@@ -17,7 +17,7 @@ endif()
 
 if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
   # We've been included using ExternalProject_add, so set up the actual thunk libraries to be cross-compiled
-  set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD 20)
 
   # This gets passed in from the main cmake project
   set (DATA_DIRECTORY "${CMAKE_INSTALL_PREFIX}/share/fex-emu" CACHE PATH "global data directory")
@@ -52,6 +52,9 @@ function(generate NAME SOURCE_FILE)
   add_library(${NAME}-guest-deps INTERFACE)
   target_include_directories(${NAME}-guest-deps INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/../include")
   target_compile_definitions(${NAME}-guest-deps INTERFACE GUEST_THUNK_LIBRARY)
+  if (BITNESS EQUAL 32)
+    target_compile_definitions(${NAME}-guest-deps INTERFACE IS_32BIT_THUNK)
+  endif ()
   # Shorthand for the include directories added after calling this function.
   # This is not evaluated directly, hence directories added after return are still picked up
   set(prop "$<TARGET_PROPERTY:${NAME}-guest-deps,INTERFACE_INCLUDE_DIRECTORIES>")
@@ -64,16 +67,18 @@ function(generate NAME SOURCE_FILE)
   file(MAKE_DIRECTORY "${OUTFOLDER}")
 
   if (BITNESS EQUAL 32)
-    set (BITNESS_FLAGS "-m32" "--target=i686-linux-unknown" "-isystem" "/usr/i686-linux-gnu/include/")
+    set (BITNESS_FLAGS "-for-32bit-guest")
+    set (BITNESS_FLAGS2 "-m32" "--target=i686-linux-unknown" "-isystem" "/usr/i686-linux-gnu/include/")
   else()
-    set (BITNESS_FLAGS "--target=x86_64-linux-unknown" "-isystem" "/usr/x86_64-linux-gnu/include/")
+    set (BITNESS_FLAGS "")
+    set (BITNESS_FLAGS2 "--target=x86_64-linux-unknown" "-isystem" "/usr/x86_64-linux-gnu/include/")
   endif()
 
   add_custom_command(
     OUTPUT "${OUTFILE}"
     DEPENDS "${GENERATOR_EXE}"
     DEPENDS "${SOURCE_FILE}"
-    COMMAND "${GENERATOR_EXE}" "${SOURCE_FILE}" "${NAME}" "-guest" "${OUTFILE}" -- -std=c++17 ${BITNESS_FLAGS}
+    COMMAND "${GENERATOR_EXE}" "${SOURCE_FILE}" "${NAME}" "-guest" "${OUTFILE}" ${BITNESS_FLAGS} -- -std=c++20 ${BITNESS_FLAGS2}
       # Expand compile definitions to space-separated list of -D parameters
       "$<$<BOOL:${compile_prop}>:;-D$<JOIN:${compile_prop},;-D>>"
       # Expand include directories to space-separated list of -isystem parameters
@@ -213,10 +218,6 @@ if (BITNESS EQUAL 64)
   generate(libXfixes ${CMAKE_CURRENT_SOURCE_DIR}/../libXfixes/libXfixes_interface.cpp)
   add_guest_lib(Xfixes "libXfixes.so.3")
 
-  generate(libvulkan ${CMAKE_CURRENT_SOURCE_DIR}/../libvulkan/libvulkan_interface.cpp)
-  target_include_directories(libvulkan-guest-deps INTERFACE ${FEX_PROJECT_SOURCE_DIR}/External/Vulkan-Headers/include/)
-  add_guest_lib(vulkan "libvulkan.so.1")
-
   find_package(PkgConfig)
   pkg_search_module(XCB REQUIRED xcb)
   version_to_variables(${XCB_VERSION} XCB)
@@ -228,9 +229,6 @@ if (BITNESS EQUAL 64)
   target_compile_definitions(libxcb-guest-deps INTERFACE -DXCB_VERSION_MINOR=${XCB_VERSION_MINOR})
   target_compile_definitions(libxcb-guest-deps INTERFACE -DXCB_VERSION_PATCH=${XCB_VERSION_PATCH})
 
-  generate(libwayland-client ${CMAKE_CURRENT_SOURCE_DIR}/../libwayland-client/libwayland-client_interface.cpp)
-  add_guest_lib(wayland-client "libwayland-client.so.0.20.0")
-
   generate(libxcb-dri2 ${CMAKE_CURRENT_SOURCE_DIR}/../libxcb-dri2/libxcb-dri2_interface.cpp)
   add_guest_lib(xcb-dri2 "libxcb-dri2.so.0")
 
@@ -294,3 +292,10 @@ endif()
 
 generate(libfex_thunk_test ${CMAKE_CURRENT_SOURCE_DIR}/../libfex_thunk_test/libfex_thunk_test_interface.cpp)
 add_guest_lib(fex_thunk_test "libfex_thunk_test.so")
+
+generate(libwayland-client ${CMAKE_CURRENT_SOURCE_DIR}/../libwayland-client/libwayland-client_interface.cpp)
+add_guest_lib(wayland-client "libwayland-client.so.0.20.0")
+
+generate(libvulkan ${CMAKE_CURRENT_SOURCE_DIR}/../libvulkan/libvulkan_interface.cpp)
+target_include_directories(libvulkan-guest-deps INTERFACE ${FEX_PROJECT_SOURCE_DIR}/External/Vulkan-Headers/include/)
+add_guest_lib(vulkan "libvulkan.so.1")
diff --git a/ThunkLibs/HostLibs/CMakeLists.txt b/ThunkLibs/HostLibs/CMakeLists.txt
index cc2a5dceef..f536d5cad3 100644
--- a/ThunkLibs/HostLibs/CMakeLists.txt
+++ b/ThunkLibs/HostLibs/CMakeLists.txt
@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.14)
 project(host-thunks)
 include(${FEX_PROJECT_SOURCE_DIR}/CMakeFiles/version_to_variables.cmake)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set (HOSTLIBS_DATA_DIRECTORY "${CMAKE_INSTALL_PREFIX}/lib/fex-emu" CACHE PATH "global data directory")
 option(ENABLE_CLANG_THUNKS "Enable building thunks with clang" FALSE)
 
@@ -20,7 +20,9 @@ function(generate NAME SOURCE_FILE GUEST_BITNESS)
   # Interface target for the user to add include directories
   add_library(${NAME}-${GUEST_BITNESS}-deps INTERFACE)
   target_include_directories(${NAME}-${GUEST_BITNESS}-deps INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/../include")
-  target_link_libraries(${NAME}-${GUEST_BITNESS}-deps INTERFACE FEXLoader)
+  if (GUEST_BITNESS EQUAL 32)
+    target_compile_definitions(${NAME}-${GUEST_BITNESS}-deps INTERFACE IS_32BIT_THUNK)
+  endif ()
   # Shorthand for the include directories added after calling this function.
   # This is not evaluated directly, hence directories added after return are still picked up
   set(prop "$<TARGET_PROPERTY:${NAME}-${GUEST_BITNESS}-deps,INTERFACE_INCLUDE_DIRECTORIES>")
@@ -41,11 +43,16 @@ function(generate NAME SOURCE_FILE GUEST_BITNESS)
 
   file(MAKE_DIRECTORY "${OUTFOLDER}")
 
+  set (BITNESS_FLAGS "")
+  if (GUEST_BITNESS EQUAL 32)
+    set (BITNESS_FLAGS "-for-32bit-guest")
+  endif()
+
   add_custom_command(
     OUTPUT "${OUTFILE}"
     DEPENDS "${SOURCE_FILE}"
     DEPENDS thunkgen
-    COMMAND thunkgen "${SOURCE_FILE}" "${NAME}" "-host" "${OUTFILE}" -- -std=c++17
+    COMMAND thunkgen "${SOURCE_FILE}" "${NAME}" "-host" "${OUTFILE}" ${BITNESS_FLAGS} -- -std=c++20
       # Expand compile definitions to space-separated list of -D parameters
       "$<$<BOOL:${compile_prop}>:;-D$<JOIN:${compile_prop},;-D>>"
       # Expand include directories to space-separated list of -isystem parameters
@@ -75,6 +82,7 @@ function(add_host_lib NAME GUEST_BITNESS)
   target_include_directories(${NAME}-host-${GUEST_BITNESS} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/gen_${GUEST_BITNESS}/")
   target_link_libraries(${NAME}-host-${GUEST_BITNESS} PRIVATE dl)
   target_link_libraries(${NAME}-host-${GUEST_BITNESS} PRIVATE lib${NAME}-${GUEST_BITNESS}-deps)
+  target_link_libraries(${NAME}-host-${GUEST_BITNESS} PRIVATE FEXLoader)
   ## Make signed overflow well defined 2's complement overflow
   target_compile_options(${NAME}-host-${GUEST_BITNESS} PRIVATE -fwrapv)
 
@@ -90,6 +98,7 @@ endfunction()
 
 set (BITNESS_LIST "32;64")
 foreach(GUEST_BITNESS IN LISTS BITNESS_LIST)
+if (GUEST_BITNESS EQUAL 64)
   #add_host_lib(fex_malloc_symbols ${GUEST_BITNESS})
 
   #generate(libfex_malloc)
@@ -136,11 +145,16 @@ foreach(GUEST_BITNESS IN LISTS BITNESS_LIST)
 
   generate(libXfixes ${CMAKE_CURRENT_SOURCE_DIR}/../libXfixes/libXfixes_interface.cpp ${GUEST_BITNESS})
   add_host_lib(Xfixes ${GUEST_BITNESS})
+endif()
 
   generate(libvulkan ${CMAKE_CURRENT_SOURCE_DIR}/../libvulkan/libvulkan_interface.cpp ${GUEST_BITNESS})
   target_include_directories(libvulkan-${GUEST_BITNESS}-deps INTERFACE ${FEX_PROJECT_SOURCE_DIR}/External/Vulkan-Headers/include/)
   add_host_lib(vulkan ${GUEST_BITNESS})
 
+  generate(libwayland-client ${CMAKE_CURRENT_SOURCE_DIR}/../libwayland-client/libwayland-client_interface.cpp ${GUEST_BITNESS})
+  add_host_lib(wayland-client ${GUEST_BITNESS})
+
+if (GUEST_BITNESS EQUAL 64)
   find_package(PkgConfig)
   pkg_search_module(XCB REQUIRED xcb)
   version_to_variables(${XCB_VERSION} XCB)
@@ -152,9 +166,6 @@ foreach(GUEST_BITNESS IN LISTS BITNESS_LIST)
   target_compile_definitions(libxcb-${GUEST_BITNESS}-deps INTERFACE -DXCB_VERSION_MINOR=${XCB_VERSION_MINOR})
   target_compile_definitions(libxcb-${GUEST_BITNESS}-deps INTERFACE -DXCB_VERSION_PATCH=${XCB_VERSION_PATCH})
 
-  generate(libwayland-client ${CMAKE_CURRENT_SOURCE_DIR}/../libwayland-client/libwayland-client_interface.cpp ${GUEST_BITNESS})
-  add_host_lib(wayland-client ${GUEST_BITNESS})
-
   generate(libxcb-dri2 ${CMAKE_CURRENT_SOURCE_DIR}/../libxcb-dri2/libxcb-dri2_interface.cpp ${GUEST_BITNESS})
   add_host_lib(xcb-dri2 ${GUEST_BITNESS})
 
@@ -186,6 +197,7 @@ foreach(GUEST_BITNESS IN LISTS BITNESS_LIST)
   target_include_directories(libdrm-${GUEST_BITNESS}-deps INTERFACE /usr/include/drm/)
   target_include_directories(libdrm-${GUEST_BITNESS}-deps INTERFACE /usr/include/libdrm/)
   add_host_lib(drm ${GUEST_BITNESS})
+endif()
 
   generate(libfex_thunk_test ${CMAKE_CURRENT_SOURCE_DIR}/../libfex_thunk_test/libfex_thunk_test_interface.cpp ${GUEST_BITNESS})
   add_host_lib(fex_thunk_test ${GUEST_BITNESS})
diff --git a/ThunkLibs/include/common/CrossArchEvent.h b/ThunkLibs/include/common/CrossArchEvent.h
deleted file mode 100644
index d2b92c17ac..0000000000
--- a/ThunkLibs/include/common/CrossArchEvent.h
+++ /dev/null
@@ -1,119 +0,0 @@
-#pragma once
-
-#include <linux/futex.h>
-#include <sys/syscall.h>
-#include <atomic>
-#include <condition_variable>
-#include <mutex>
-#include <unistd.h>
-
-struct CrossArchEvent final {
-  std::atomic<uint32_t> Futex;
-};
-
-static void WaitForWorkFunc(CrossArchEvent *Event) {
-
-  // Wait for Futex value to become 1
-  while (true) {
-
-    // First step compare it with 1 already and see if we can early out
-    uint32_t One = 1;
-    if (Event->Futex.compare_exchange_strong(One, 0)) {
-      return;
-    }
-
-    int Op = FUTEX_WAIT | FUTEX_PRIVATE_FLAG;
-    [[maybe_unused]] int Res = syscall(SYS_futex,
-        &Event->Futex,
-        Op,
-        nullptr, // Timeout
-        nullptr, // Addr
-        0);
-  }
-}
-
-static void NotifyWorkFunc(CrossArchEvent *Event) {
-  uint32_t Zero = 0;
-  if (Event->Futex.compare_exchange_strong(Zero, 1)) {
-    int Op = FUTEX_WAKE | FUTEX_PRIVATE_FLAG;
-    syscall(SYS_futex,
-      &Event->Futex,
-      Op,
-      nullptr, // Timeout
-      nullptr, // Addr
-      0);
-  }
-}
-
-//class CrossArchEvent final {
-//  private:
-//  /**
-//   * @brief Literally just an atomic bool that we are using for this class
-//   */
-//  class Flag final {
-//  public:
-//    bool TestAndSet(bool SetValue = true) {
-//      bool Expected = !SetValue;
-//      return Value.compare_exchange_strong(Expected, SetValue);
-//    }
-//
-//    bool TestAndClear() {
-//      return TestAndSet(false);
-//    }
-//
-//    bool Get() {
-//      return Value.load();
-//    }
-//
-//  private:
-//    std::atomic_bool Value {false};
-//  };
-//
-//  public:
-//    ~CrossArchEvent() {
-//      NotifyAll();
-//    }
-//    void NotifyOne() {
-//      if (FlagObject.TestAndSet()) {
-//        std::lock_guard<std::mutex> lk(MutexObject);
-//        CondObject.notify_one();
-//      }
-//    }
-//
-//    void NotifyAll() {
-//      if (FlagObject.TestAndSet()) {
-//        std::lock_guard<std::mutex> lk(MutexObject);
-//        CondObject.notify_all();
-//      }
-//    }
-//
-//    void Wait() {
-//      // Have we signaled before we started waiting?
-//      if (FlagObject.TestAndClear())
-//        return;
-//
-//      std::unique_lock<std::mutex> lk(MutexObject);
-//      CondObject.wait(lk, [this]{ return FlagObject.TestAndClear(); });
-//    }
-//
-//    template<class Rep, class Period>
-//    bool WaitFor(std::chrono::duration<Rep, Period> const& time) {
-//      // Have we signaled before we started waiting?
-//      if (FlagObject.TestAndClear())
-//        return true;
-//
-//      std::unique_lock<std::mutex> lk(MutexObject);
-//      bool DidSignal = CondObject.wait_for(lk, time, [this]{ return FlagObject.TestAndClear(); });
-//      return DidSignal;
-//    }
-//    void BusyWaitForWork() {
-//      while (!FlagObject.Get());
-//    }
-//
-//  private:
-//    std::mutex MutexObject;
-//    std::condition_variable CondObject;
-//    Flag FlagObject;
-//};
-
-
diff --git a/ThunkLibs/include/common/GeneratorInterface.h b/ThunkLibs/include/common/GeneratorInterface.h
index f3cd082db9..e367644827 100644
--- a/ThunkLibs/include/common/GeneratorInterface.h
+++ b/ThunkLibs/include/common/GeneratorInterface.h
@@ -11,6 +11,25 @@ struct callback_annotation_base {
     bool prevent_multiple;
 };
 struct callback_stub : callback_annotation_base {};
-struct callback_guest : callback_annotation_base {};
+
+// If used, fex_custom_repack must be specialized for the annotated struct member
+struct custom_repack {};
+
+struct type_annotation_base { bool prevent_multiple; };
+
+// Pointers to types annotated with this will be passed through without change
+struct opaque_type : type_annotation_base {};
+
+// Function parameter annotation.
+// Pointers are passed through to host (extending to 64-bit if needed) without modifying the pointee.
+// The type passed to Host is guest_layout<PointeeType>*.
+// TODO: Update description. "The raw guest_layout<type>* will be passed to the host"
+struct ptr_passthrough {};
+
+// Type / Function parameter annotation.
+// Assume objects of the given type are compatible across architectures,
+// even if the generator can't automatically prove this. For pointers, this refers to the pointee type.
+// NOTE: In contrast to opaque_type, this allows for non-pointer members with the annotated type to be repacked automatically.
+struct assume_compatible_data_layout : type_annotation_base {};
 
 } // namespace fexgen
diff --git a/ThunkLibs/include/common/Guest.h b/ThunkLibs/include/common/Guest.h
index 9954c197de..27bfa19997 100644
--- a/ThunkLibs/include/common/Guest.h
+++ b/ThunkLibs/include/common/Guest.h
@@ -10,7 +10,8 @@
 #ifdef __clang__
 #define THUNK_ABI __fastcall
 #else
-#define THUNK_ABI [[gnu::fastcall]]
+// TODO: [[gnu::fastcall]] doesn't seem to work?
+#define THUNK_ABI __attribute__((fastcall)) // [[gnu::fastcall]]
 #endif
 #endif
 
@@ -61,13 +62,20 @@ MAKE_THUNK(fex, is_lib_loaded, "0xee, 0x57, 0xba, 0x0c, 0x5f, 0x6e, 0xef, 0x2a,
 MAKE_THUNK(fex, is_host_heap_allocation, "0xf5, 0x77, 0x68, 0x43, 0xbb, 0x6b, 0x28, 0x18, 0x40, 0xb0, 0xdb, 0x8a, 0x66, 0xfb, 0x0e, 0x2d, 0x98, 0xc2, 0xad, 0xe2, 0x5a, 0x18, 0x5a, 0x37, 0x2e, 0x13, 0xc9, 0xe7, 0xb9, 0x8c, 0xa9, 0x3e")
 MAKE_THUNK(fex, link_address_to_function, "0xe6, 0xa8, 0xec, 0x1c, 0x7b, 0x74, 0x35, 0x27, 0xe9, 0x4f, 0x5b, 0x6e, 0x2d, 0xc9, 0xa0, 0x27, 0xd6, 0x1f, 0x2b, 0x87, 0x8f, 0x2d, 0x35, 0x50, 0xea, 0x16, 0xb8, 0xc4, 0x5e, 0x42, 0xfd, 0x77")
 MAKE_THUNK(fex, allocate_host_trampoline_for_guest_function, "0x9b, 0xb2, 0xf4, 0xb4, 0x83, 0x7d, 0x28, 0x93, 0x40, 0xcb, 0xf4, 0x7a, 0x0b, 0x47, 0x85, 0x87, 0xf9, 0xbc, 0xb5, 0x27, 0xca, 0xa6, 0x93, 0xa5, 0xc0, 0x73, 0x27, 0x24, 0xae, 0xc8, 0xb8, 0x5a")
+MAKE_THUNK(fex, register_async_worker_thread, "0x9c, 0xb2, 0xf4, 0xb4, 0x83, 0x7d, 0x28, 0x93, 0x40, 0xcb, 0xf4, 0x7a, 0x0b, 0x47, 0x85, 0x87, 0xf9, 0xbc, 0xb5, 0x27, 0xca, 0xa6, 0x93, 0xa5, 0xc0, 0x73, 0x27, 0x24, 0xae, 0xc8, 0xb8, 0x5a")
+MAKE_THUNK(fex, unregister_async_worker_thread, "0x9d, 0xb2, 0xf4, 0xb4, 0x83, 0x7d, 0x28, 0x93, 0x40, 0xcb, 0xf4, 0x7a, 0x0b, 0x47, 0x85, 0x87, 0xf9, 0xbc, 0xb5, 0x27, 0xca, 0xa6, 0x93, 0xa5, 0xc0, 0x73, 0x27, 0x24, 0xae, 0xc8, 0xb8, 0x5a")
 
 #define LOAD_LIB_BASE(name, init_fn) \
   __attribute__((constructor)) static void loadlib() \
   { \
+    static bool inited = false; \
+    if (inited) { \
+      return; \
+    } \
     LoadlibArgs args =  { #name }; \
     fexthunks_fex_loadlib(&args); \
     if ((init_fn)) ((void(*)())init_fn)(); \
+    inited = true; \
   }
 
 #define LOAD_LIB(name) LOAD_LIB_BASE(name, nullptr)
@@ -75,8 +83,8 @@ MAKE_THUNK(fex, allocate_host_trampoline_for_guest_function, "0x9b, 0xb2, 0xf4,
 
 inline void LinkAddressToFunction(uintptr_t addr, uintptr_t target) {
     struct args_t {
-        uintptr_t original_callee;
-        uintptr_t target_addr; // Function to call when branching to replaced_addr
+        uint64_t original_callee;
+        uint64_t target_addr; // Function to call when branching to replaced_addr
     };
     args_t args = { addr, target };
     fexthunks_fex_link_address_to_function(&args);
@@ -126,14 +134,17 @@ inline Result CallHostFunction(Args... args) {
   // Use mm0 to pass in host_addr (chosen to avoid conflicts with vectorcall).
   // Note this register overlaps the x87 st(0) register (used to return float values),
   // so applications that expect this register to be preserved could run into problems.
-  register uintptr_t host_addr asm ("mm0");
-  asm volatile("" : "=r" (host_addr));
+//  register uintptr_t host_addr asm ("mm0");
+//  asm volatile("" : "=r" (host_addr));
+
+    uintptr_t host_addr; \
+    asm volatile("movd %%mm0, %0" : "=r" (host_addr));
 #endif
 #else
   uintptr_t host_addr = 0;
 #endif
 
-  PackedArguments<Result, Args..., uintptr_t> packed_args = {
+  PackedArguments<Result, Args..., uint64_t> packed_args = {
     args...,
     host_addr
     // Return value not explicitly initialized since an initializer would fail to compile for the void case
@@ -162,20 +173,20 @@ inline void MakeHostFunctionGuestCallable(THUNK_ABI Result (*host_func)(Args...)
 }
 
 template<typename Target>
-inline Target *AllocateHostTrampolineForGuestFunction(void (*GuestUnpacker)(uintptr_t, void*), Target *GuestTarget) {
+inline Target* AllocateHostTrampolineForGuestFunction(void THUNK_ABI (*GuestUnpacker)(uintptr_t, void*), Target *GuestTarget) {
   if (!GuestTarget) {
-    return nullptr;
+    return 0;
   }
 
   struct {
-    uintptr_t GuestUnpacker;
-    uintptr_t GuestTarget;
-    uintptr_t rv;
+    uint64_t GuestUnpacker;
+    uint64_t GuestTarget;
+    uint64_t rv;
   } argsrv = { (uintptr_t)GuestUnpacker, (uintptr_t)GuestTarget };
 
   fexthunks_fex_allocate_host_trampoline_for_guest_function((void*)&argsrv);
 
-  return (Target *)argsrv.rv;
+  return (Target*)argsrv.rv;
 }
 
 template<typename F>
@@ -183,7 +194,7 @@ struct CallbackUnpack;
 
 template<typename Result, typename... Args>
 struct CallbackUnpack<Result(Args...)> {
-    static void Unpack(uintptr_t cb, void* argsv) {
+    static void THUNK_ABI Unpack(uintptr_t cb, void* argsv) {
         using fn_t = Result(Args...);
         auto callback = reinterpret_cast<fn_t*>(cb);
         auto args = reinterpret_cast<PackedArguments<Result, Args...>*>(argsv);
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index f4fa32c414..2e7b2a3d89 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -5,9 +5,11 @@ category: thunklibs ~ These are generated + glue logic 1:1 thunks unless noted o
 */
 
 #pragma once
+#include <array>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
+#include <cstring>
 #include <dlfcn.h>
 
 #include "PackedArguments.h"
@@ -27,6 +29,9 @@ namespace FEXCore {
   __attribute__((weak))
   HostToGuestTrampolinePtr*
   FinalizeHostTrampolineForGuestFunction(HostToGuestTrampolinePtr*, void* HostPacker);
+
+  __attribute__((weak))
+  void MakeHostTrampolineForGuestFunctionAsyncCallable(HostToGuestTrampolinePtr*, unsigned AsyncWorkerThreadId);
 }
 
 template<typename Fn>
@@ -48,27 +53,6 @@ struct ExportEntry { uint8_t* sha256; void(*fn)(void *); };
 
 typedef void fex_call_callback_t(uintptr_t callback, void *arg0, void* arg1);
 
-/**
- * Opaque wrapper around a guest function pointer.
- *
- * This prevents accidental calls to foreign function pointers while still
- * allowing us to label function pointers as such.
- */
-struct fex_guest_function_ptr {
-private:
-    void* value = nullptr;
-
-public:
-    fex_guest_function_ptr() = default;
-
-    template<typename Ret, typename... Args>
-    fex_guest_function_ptr(Ret (*ptr)(Args...)) : value(reinterpret_cast<void*>(ptr)) {}
-
-    inline operator bool() const {
-      return value != nullptr;
-    }
-};
-
 #define EXPORTS(name) \
   extern "C" { \
     ExportEntry* fexthunks_exports_##name() { \
@@ -85,11 +69,13 @@ struct fex_guest_function_ptr {
     init_fn (); \
   }
 
+// Same as TrampolineInstanceInfo in Thunks.cpp
 struct GuestcallInfo {
   uintptr_t HostPacker;
   void (*CallCallback)(uintptr_t GuestUnpacker, uintptr_t GuestTarget, void* argsrv);
   uintptr_t GuestUnpacker;
   uintptr_t GuestTarget;
+  uintptr_t AsyncWorkerThread;
 };
 
 // Helper macro for reading an internal argument passed through the `r11`
@@ -103,27 +89,490 @@ struct GuestcallInfo {
   asm volatile("mov %0, x11" : "=r" (target_variable))
 #endif
 
+struct ParameterAnnotations {
+    bool is_passthrough = false;
+    bool is_opaque = false;
+};
+
+// Generator emits specializations for this for each type that has compatible layout
+template<typename T>
+inline constexpr bool has_compatible_data_layout =
+  std::is_integral_v<T> || std::is_enum_v<T> || std::is_floating_point_v<T>
+#ifndef IS_32BIT_THUNK
+  // If none of the previous predicates matched, the thunk generator did *not* emit a specialization for T.
+  // This should not happen on 64-bit with the currently thunked libraries, since their types
+  // * either have fully consistent data layout across 64-bit architectures.
+  // * or use custom repacking, in which case has_compatible_data_layout isn't used
+  //
+  // Throwing a fake exception here will trigger a build failure.
+  || (throw "Instantiated on a type that was expected to be compatible", true)
+#endif
+;
+
+#ifndef IS_32BIT_THUNK
+// Pointers have the same size, hence data layout compatibility only depends on the pointee type
+template<typename T>
+inline constexpr bool has_compatible_data_layout<T*> = has_compatible_data_layout<std::remove_cv_t<T>>;
+template<typename T>
+inline constexpr bool has_compatible_data_layout<T* const> = has_compatible_data_layout<std::remove_cv_t<T>*>;
+
+// void* and void** are assumed to be compatible to simplify handling of libraries that use them ubiquitously
+template<> inline constexpr bool has_compatible_data_layout<void*> = true;
+template<> inline constexpr bool has_compatible_data_layout<const void*> = true;
+template<> inline constexpr bool has_compatible_data_layout<void**> = true;
+template<> inline constexpr bool has_compatible_data_layout<const void**> = true;
+#endif
+
+// Placeholder type to indicate the given data is in guest-layout
+template<typename T>
+struct __attribute__((packed)) guest_layout {
+  static_assert(!std::is_class_v<T>, "No guest layout defined for this non-opaque struct type. This may be a bug in the thunk generator.");
+  static_assert(!std::is_union_v<T>, "No guest layout defined for this non-opaque union type. This may be a bug in the thunk generator.");
+  static_assert(!std::is_enum_v<T>, "No guest layout defined for this enum type. This is a bug in the thunk generator.");
+  static_assert(!std::is_void_v<T>, "Attempted to get guest layout of void. Missing annotation for void pointer?");
+
+  static_assert(std::is_fundamental_v<T> || has_compatible_data_layout<T>, "Default guest_layout may not be used for non-compatible data");
+
+  using type = std::enable_if_t<!std::is_pointer_v<T>, T>;
+  type data;
+
+  // TODO: Make this conversion explicit
+  guest_layout& operator=(const T from) {
+    data = from;
+    return *this;
+  }
+
+  // Allow conversion of integral types of same size and sign to each other.
+  // This is useful for handling "long"/"long long" on 64-bit, as well as uint8_t/char.
+  // TODO: Make this conversion explicit
+  template<typename U>
+  guest_layout& operator=(const guest_layout<U>& from) requires (std::is_integral_v<U> && sizeof(U) == sizeof(T) && std::is_convertible_v<T, U> && std::is_signed_v<T> == std::is_signed_v<U>) {
+    data = static_cast<T>(from.data);
+    return *this;
+  }
+};
+
+#if IS_32BIT_THUNK
+// Specialized for uint32_t so that members annotated as "size_t" can automatically be converted from 64-bit to 32-bit
+template<>
+struct __attribute__((packed)) guest_layout<uint32_t> {
+  using type = uint32_t;
+  type data;
+
+  // TODO: Make this conversion explicit
+  guest_layout& operator=(const uint32_t from) {
+    data = from;
+    return *this;
+  }
+  guest_layout& operator=(const guest_layout<size_t>& from) {
+    if (from.data > 0xffffffff) {
+      fprintf(stderr, "ERROR: Tried to truncate large size_t value passed across thunk boundaries\n");
+      std::abort();
+    }
+    data = (uint32_t)from.data;
+    return *this;
+  }
+
+  guest_layout() = default;
+  guest_layout(const guest_layout<size_t>& from) {
+    if (from.data > 0xffffffff) {
+      fprintf(stderr, "ERROR: Tried to truncate large size_t value passed across thunk boundaries\n");
+      std::abort();
+    }
+    data = (uint32_t)from.data;
+  }
+  guest_layout(const guest_layout& from) : data { from.data } {
+  }
+  guest_layout(uint32_t from) : data { from } {
+  }
+};
+#endif
+
+template<typename T, std::size_t N>
+struct __attribute__((packed)) guest_layout<T[N]> {
+  // TODO: Check that the underlying type is ABI compatible
+//  static_assert(!std::is_class_v<T>, "No guest layout defined for this non-opaque struct type. This may be a bug in the thunk generator.");
+
+  using type = std::enable_if_t<!std::is_pointer_v<T>, T>;
+  std::array<guest_layout<type>, N> data;
+};
+
+template<typename T>
+struct guest_layout<T*> {
+#ifdef IS_32BIT_THUNK
+  using type = uint32_t;
+#else
+  using type = uint64_t;
+#endif
+  type data;
+
+  // TODO: Make this conversion explicit
+  guest_layout& operator=(const T* from) {
+    // TODO: Assert upper 32 bits are zero
+    data = reinterpret_cast<uintptr_t>(from);
+    return *this;
+  }
+
+  guest_layout<T>* get_pointer() {
+    return reinterpret_cast<guest_layout<T>*>(uintptr_t { data });
+  }
+
+  const guest_layout<T>* get_pointer() const {
+    return reinterpret_cast<const guest_layout<T>*>(uintptr_t { data });
+  }
+};
+
+template<typename T>
+struct guest_layout<T* const> {
+#ifdef IS_32BIT_THUNK
+  using type = uint32_t;
+#else
+  using type = uint64_t;
+#endif
+  type data;
+
+  // TODO: Make this conversion explicit
+  guest_layout& operator=(const T* from) {
+    // TODO: Assert upper 32 bits are zero
+    data = reinterpret_cast<uintptr_t>(from);
+    return *this;
+  }
+
+  guest_layout<T>* get_pointer() {
+    return reinterpret_cast<guest_layout<T>*>(uintptr_t { data });
+  }
+
+  const guest_layout<T>* get_pointer() const {
+    return reinterpret_cast<const guest_layout<T>*>(uintptr_t { data });
+  }
+};
+
+// Make guest_layout of "long long" and "long" interoperable, since they are
+// the same type as far as data layout is concerned.
+template<>
+struct guest_layout<unsigned long long> : guest_layout<unsigned long> {
+  using guest_layout<unsigned long>::guest_layout;
+
+  static_assert(sizeof(long long) == sizeof(long));
+};
+template<>
+struct guest_layout<unsigned long long*> : guest_layout<unsigned long*> {
+  using guest_layout<unsigned long*>::guest_layout;
+};
+template<>
+struct guest_layout<const unsigned long long*> : guest_layout<const unsigned long*> {
+  using guest_layout<const unsigned long*>::guest_layout;
+  guest_layout(guest_layout<const unsigned long*> oth) : guest_layout<const unsigned long*>(oth) { }
+};
+
+template<typename T>
+struct host_layout;
+
+template<typename T>
+struct host_layout {
+  static_assert(!std::is_class_v<T>, "No host_layout specialization generated for struct/class type");
+  static_assert(!std::is_union_v<T>, "No host_layout specialization generated for union type");
+  static_assert(!std::is_void_v<T>, "Attempted to get host layout of void. Missing annotation for void pointer?");
+
+  // TODO: This generic implementation shouldn't be needed. Instead, auto-specialize host_layout for all types used as members.
+
+  T data;
+
+  host_layout(const guest_layout<T>& from) requires (!std::is_enum_v<T>) : data { from.data } {
+    // NOTE: This is not strictly neccessary since differently sized types may
+    //       be used across architectures. It's important that the host type
+    //       can represent all guest values without loss, however.
+    static_assert(sizeof(data) == sizeof(from));
+  }
+
+  host_layout(const guest_layout<T>& from) requires (std::is_enum_v<T>) : data { static_cast<T>(from.data) } {
+  }
+
+  // Allow conversion of integral types of same size and sign to each other.
+  // This is useful for handling "long"/"long long" on 64-bit, as well as uint8_t/char.
+  template<typename U>
+  host_layout(const guest_layout<U>& from) requires (std::is_integral_v<U> && sizeof(U) == sizeof(T) && std::is_convertible_v<T, U> && std::is_signed_v<T> == std::is_signed_v<U>) : data { static_cast<T>(from.data) } {
+  }
+
+  host_layout(T from) requires (std::is_enum_v<T>) : data { from } {
+  }
+};
+
+// Explicitly turn a host type into its corresponding host_layout
+template<typename T>
+const host_layout<T>& to_host_layout(const T& t) {
+  static_assert(std::is_same_v<decltype(host_layout<T>::data), T>);
+  return reinterpret_cast<const host_layout<T>&>(t);
+}
+
+// Specialization for size_t, which is 64-bit on 64-bit but 32-bit on 32-bit
+template<>
+struct host_layout<size_t> {
+  size_t data;
+
+  host_layout(const guest_layout<uint32_t>& from) : data { from.data } {
+  }
+
+  // TODO: Shouldn't be needed
+  host_layout(const guest_layout<size_t>& from) : data { from.data } {
+  }
+};
+
+template<typename T, size_t N>
+struct host_layout<T[N]> {
+  std::array<T, N> data;
+
+  host_layout(const guest_layout<T[N]>& from) {
+    for (size_t i = 0; i < N; ++i) {
+      data[i] = host_layout<T> { from.data[i] }.data;
+    }
+  }
+};
+
+template<typename T>
+struct host_layout<T*> {
+  T* data;
+
+  static_assert(!std::is_function_v<T>, "Function types must be handled separately");
+
+  // Assume underlying data is compatible and just convert the guest-sized pointer to 64-bit
+  host_layout(const guest_layout<T*>& from) : data { (T*)(uintptr_t)from.data } {
+  }
+
+  // TODO: Make this explicit?
+  host_layout() = default;
+};
+
+template<typename T>
+struct host_layout<T* const> {
+  T* data;
+
+  static_assert(!std::is_function_v<T>, "Function types must be handled separately");
+
+  // Assume underlying data is compatible and just convert the guest-sized pointer to 64-bit
+  host_layout(const guest_layout<T* const>& from) : data { (T*)(uintptr_t)from.data } {
+  }
+};
+
+// Storage for unpacked parameters. May carry additional data for aiding conversion (such as short-lived, stack-allocated data instances to repoint pointer arguments to).
+// Not suitable for nested struct repacking
+// TODO: Update this comment. Originally it was written for unpacked_arg!
+template<typename T>
+struct unpacked_arg_base;
+template<typename T>
+struct unpacked_arg_base<T*> {
+  unpacked_arg_base(host_layout<T>* data_) : data(data_) {
+  }
+
+  unpacked_arg_base(host_layout<const T>* data_) : data(data_) {
+  }
+
+  T* get() {
+    static_assert(sizeof(T) == sizeof(host_layout<T>));
+    static_assert(alignof(T) == alignof(host_layout<T>));
+    return &data->data;
+  }
+
+  host_layout<T>* data;
+};
+
+// TODO: This shouldn't hold temporary storage for pointers that don't need repacking!
+template<typename T>
+struct unpacked_arg_with_storage;
+template<typename T>
+struct unpacked_arg_with_storage<T*> : unpacked_arg_base<T*> {
+  // Silence -Wuninitialized warning from taking a pointer to opt
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wuninitialized"
+  unpacked_arg_with_storage(const guest_layout<T*>& data_) : unpacked_arg_base<T*>(data_.get_pointer() ? &opt.extra : nullptr),
+    opt {
+      data_.get_pointer() ? Opt { *data_.get_pointer() }
+      : Opt { .uninit = {} }
+    } {
+  }
+
+  unpacked_arg_with_storage(const guest_layout<const T*>& data_) : unpacked_arg_base<T*>(data_.get_pointer() ? &opt.extra : nullptr),
+  #pragma GCC diagnostic pop
+    opt {
+      data_.get_pointer() ? Opt { *data_.get_pointer() }
+      : Opt { .uninit = {} }
+    } {
+  }
+
+  // NOTE: Copying/moving this type would invalidate the reference to opt.extra,
+  //       so disallow these operations altogether.
+  unpacked_arg_with_storage(const unpacked_arg_with_storage& other) = delete;
+  unpacked_arg_with_storage(unpacked_arg_with_storage&&) = delete;
+  unpacked_arg_with_storage& operator=(const unpacked_arg_with_storage&) = delete;
+  unpacked_arg_with_storage& operator=(unpacked_arg_with_storage&&) = delete;
+
+  // Crude hack to allow leaving this uninitialized for nullptrs
+  // NOTE: We can't use std::optional here since the storage must always be valid (even before initialization)
+  union Opt {
+    host_layout<T> extra; // Temporary storage for layout-repacked data
+    char uninit;
+  } opt;
+};
+
+
+template<>
+struct unpacked_arg_with_storage<char*> {
+  using type = char*;
+
+  unpacked_arg_with_storage(/*const */guest_layout<const char*>& data) : data(reinterpret_cast<uint64_t>(data.get_pointer())) {
+  }
+  unpacked_arg_with_storage(/*const */guest_layout<char*>& data) : data(reinterpret_cast<uint64_t>(data.get_pointer())) {
+  }
+
+  type get() {
+    return reinterpret_cast<type>(data);
+  }
+
+  uint64_t data;
+};
+
+template<typename T>
+T& unwrap_host(host_layout<T>& val) {
+  return val.data;
+}
+
+template<typename T>
+T* unwrap_host(unpacked_arg_base<T*>& val) {
+  return val.get();
+}
+
+template<typename T>
+inline guest_layout<T> to_guest(const host_layout<T>& from) requires(!std::is_pointer_v<T>) {
+  if constexpr (std::is_enum_v<T>) {
+    // enums are represented by fixed-size integers in guest_layout, so explicitly cast them
+    return guest_layout<T> { static_cast<std::underlying_type_t<T>>(from.data) };
+  } else if constexpr (std::is_same_v<T, uint32_t>) {
+    // Handle guest_layout<uint32_t> separately, since it's specialized and uses custom constructors
+    return guest_layout<uint32_t> { from.data };
+  } else {
+    guest_layout<T> ret { .data = from.data };
+    return ret;
+  }
+}
+
+template<typename T>
+inline guest_layout<T*> to_guest(const host_layout<T*>& from) {
+  guest_layout<T*> ret;
+  ret = from.data;
+  return ret;
+}
+
 template<typename>
 struct CallbackUnpack;
 
+// Helper to extract information from a pointer-to-member (e.g. &MyClass::data_member)
+template<typename>
+struct pmd_traits;
+template<typename Parent, typename Data>
+struct pmd_traits<Data Parent::*> {
+    using parent_t = Parent;
+    using member_t = Data;
+};
+
+// Wrapper around unpacked_arg (for on-stack repacked argument structs) that implicitly converts to the represented type
+template<typename T, typename GuestT>
+struct unpacked_arg_wrapper {
+  static_assert(std::is_pointer_v<T>);
+
+  // Strip "const" from pointee type. Managing const-correctness would be a pain otherwise.
+  using ActualT = std::add_pointer_t<std::remove_cv_t<std::remove_pointer_t<T>>>;
+
+  unpacked_arg_with_storage<ActualT> data;
+  guest_layout<T>& orig_arg;
+
+  unpacked_arg_wrapper(guest_layout<GuestT>& orig_arg_) : data(orig_arg_), orig_arg(orig_arg_) {
+    if (data.data && !std::is_enum_v<T>) {
+      constexpr bool is_compatible = has_compatible_data_layout<T> && std::is_same_v<T, GuestT>;
+      if constexpr (!is_compatible && std::is_class_v<std::remove_pointer_t<T>>) {
+        fex_apply_custom_repacking(*data.data, *orig_arg_.get_pointer());
+      }
+    }
+  }
+
+  ~unpacked_arg_wrapper() {
+    // TODO: Properly detect opaque types
+    if constexpr (requires(guest_layout<T> t, decltype(data) h) { t.get_pointer(); (bool)h.data; *data.data; }) {
+      if constexpr (!std::is_const_v<std::remove_pointer_t<T>>) { // Skip exit-repacking for const pointees
+        if (data.data) {
+          constexpr bool is_compatible = has_compatible_data_layout<T> && std::is_same_v<T, GuestT>;
+          if constexpr (!is_compatible && std::is_class_v<std::remove_pointer_t<T>>) {
+            *orig_arg.get_pointer() = to_guest(*data.data); // TODO: Only if annotated as out-parameter
+            fex_apply_custom_repacking_postcall(*data.data);
+          }
+        }
+      }
+    }
+  }
+
+  operator ActualT() {
+    return data.get();
+  }
+};
+
+template<typename T, ParameterAnnotations Annotation>
+constexpr bool IsCompatible() {
+  if constexpr (Annotation.is_opaque) {
+    return true;
+  } else if constexpr (has_compatible_data_layout<T>) {
+    return true;
+  } else {
+    if constexpr (std::is_pointer_v<T>) {
+      return has_compatible_data_layout<std::remove_cv_t<std::remove_pointer_t<T>>>;
+    } else {
+      return false;
+    }
+  }
+}
+
+template<ParameterAnnotations Annotation, typename HostT, typename T>
+auto Projection(guest_layout<T>& data) {
+  constexpr bool is_compatible = IsCompatible<T, Annotation>() && std::is_same_v<T, HostT>;
+  if constexpr (Annotation.is_passthrough) {
+    return data;
+  } else if constexpr (is_compatible || !std::is_pointer_v<T>) {
+    return host_layout<HostT> { data }.data;
+  } else {
+    // This argument requires temporary storage for repacked data
+    // *and* it needs to call custom repack functions (if any)
+    return unpacked_arg_wrapper<HostT, T> { data };
+  }
+}
+
 template<typename Result, typename... Args>
 struct CallbackUnpack<Result(Args...)> {
   static Result CallGuestPtr(Args... args) {
     GuestcallInfo *guestcall;
     LOAD_INTERNAL_GUESTPTR_VIA_CUSTOM_ABI(guestcall);
 
-    PackedArguments<Result, Args...> packed_args = {
-      args...
+    PackedArguments<Result, guest_layout<Args>...> packed_args = {
+      { to_guest(to_host_layout(args)) }...
     };
     guestcall->CallCallback(guestcall->GuestUnpacker, guestcall->GuestTarget, &packed_args);
     if constexpr (!std::is_void_v<Result>) {
       return packed_args.rv;
     }
   }
+};
+
+template<typename, typename...>
+struct GuestWrapperForHostFunction;
+
+template<typename Result, typename... Args, typename... GuestArgs>
+struct GuestWrapperForHostFunction<Result(Args...), GuestArgs...> {
+  // Host functions called from Guest
+  // NOTE: GuestArgs typically matches up with Args, however there may be exceptions (e.g. size_t)
+  template<ParameterAnnotations... Annotations>
+  static void Call(void* argsv) {
+    static_assert(sizeof...(Annotations) == sizeof...(Args));
+    static_assert(sizeof...(GuestArgs) == sizeof...(Args));
 
-  static void ForIndirectCall(void* argsv) {
-    auto args = reinterpret_cast<PackedArguments<Result, Args..., uintptr_t>*>(argsv);
-    constexpr auto CBIndex = sizeof...(Args);
+    auto args = reinterpret_cast<PackedArguments<Result, guest_layout<GuestArgs>..., uintptr_t>*>(argsv);
+    constexpr auto CBIndex = sizeof...(GuestArgs);
     uintptr_t cb;
     static_assert(CBIndex <= 18 || CBIndex == 23);
     if constexpr(CBIndex == 0) {
@@ -168,11 +617,26 @@ struct CallbackUnpack<Result(Args...)> {
       cb = args->a23;
     }
 
-    auto callback = reinterpret_cast<Result(*)(Args..., uintptr_t)>(cb);
-    Invoke(callback, *args);
+    // This is almost the same type as "Result func(Args..., uintptr_t)", but
+    // individual parameters annotated as passthrough are replaced by guest_layout<GuestArgs>
+    auto callback = reinterpret_cast<Result(*)(std::conditional_t<Annotations.is_passthrough, guest_layout<GuestArgs>, Args>..., uintptr_t)>(cb);
+
+    auto f = [&callback](guest_layout<GuestArgs>... args, uintptr_t target) -> Result {
+      // Fold over each of Annotations, Args, and args. This will match up the elements in triplets.
+      return callback(Projection<Annotations, Args>(args)..., target);
+    };
+    Invoke(f, *args);
   }
 };
 
+// TODO: Move?
+template<typename F>
+void FinalizeHostTrampolineForGuestFunction(const guest_layout<F*>& PreallocatedTrampolineForGuestFunction) {
+  FEXCore::FinalizeHostTrampolineForGuestFunction(
+      (FEXCore::HostToGuestTrampolinePtr*)PreallocatedTrampolineForGuestFunction.data,
+      (void*)&CallbackUnpack<F>::CallGuestPtr);
+}
+
 template<typename FuncType>
 void MakeHostTrampolineForGuestFunctionAt(uintptr_t GuestTarget, uintptr_t GuestUnpacker, FuncType **Func) {
     *Func = (FuncType*)FEXCore::MakeHostTrampolineForGuestFunction(
diff --git a/ThunkLibs/include/common/PackedArguments.h b/ThunkLibs/include/common/PackedArguments.h
index 14531db2ac..16f0f258ab 100644
--- a/ThunkLibs/include/common/PackedArguments.h
+++ b/ThunkLibs/include/common/PackedArguments.h
@@ -5,45 +5,45 @@
 #include <utility>
 
 template<typename Result, typename... Args>
-struct PackedArguments;
+struct __attribute__((packed)) PackedArguments;
 
 template<typename R>
-struct PackedArguments<R> { R rv; };
+struct __attribute__((packed)) PackedArguments<R> { R rv; };
 template<typename R, typename A0>
-struct PackedArguments<R, A0> { A0 a0; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0> { A0 a0; R rv; };
 template<typename R, typename A0, typename A1>
-struct PackedArguments<R, A0, A1> { A0 a0; A1 a1; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1> { A0 a0; A1 a1; R rv; };
 template<typename R, typename A0, typename A1, typename A2>
-struct PackedArguments<R, A0, A1, A2> { A0 a0; A1 a1; A2 a2; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2> { A0 a0; A1 a1; A2 a2; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3>
-struct PackedArguments<R, A0, A1, A2, A3> { A0 a0; A1 a1; A2 a2; A3 a3; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3> { A0 a0; A1 a1; A2 a2; A3 a3; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
-struct PackedArguments<R, A0, A1, A2, A3, A4> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; R rv; };
 
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9,
          typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19,
          typename A20, typename A21, typename A22>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
                        A10, A11, A12, A13, A14, A15, A16, A17, A18, A19,
                        A20, A21, A22> {
     A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9;
@@ -54,7 +54,7 @@ struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9,
          typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19,
          typename A20, typename A21, typename A22, typename A23>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
                        A10, A11, A12, A13, A14, A15, A16, A17, A18, A19,
                        A20, A21, A22, A23> {
     A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9;
@@ -63,45 +63,45 @@ struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
 };
 
 template<>
-struct PackedArguments<void> { };
+struct __attribute__((packed)) PackedArguments<void> { };
 template<typename A0>
-struct PackedArguments<void, A0> { A0 a0; };
+struct __attribute__((packed)) PackedArguments<void, A0> { A0 a0; };
 template<typename A0, typename A1>
-struct PackedArguments<void, A0, A1> { A0 a0; A1 a1; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1> { A0 a0; A1 a1; };
 template<typename A0, typename A1, typename A2>
-struct PackedArguments<void, A0, A1, A2> { A0 a0; A1 a1; A2 a2; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2> { A0 a0; A1 a1; A2 a2; };
 template<typename A0, typename A1, typename A2, typename A3>
-struct PackedArguments<void, A0, A1, A2, A3> { A0 a0; A1 a1; A2 a2; A3 a3; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3> { A0 a0; A1 a1; A2 a2; A3 a3; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4>
-struct PackedArguments<void, A0, A1, A2, A3, A4> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; A16 a16; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; A16 a16; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; A16 a16; A17 a17; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; A16 a16; A17 a17; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; A16 a16; A17 a17; A18 a18; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; A16 a16; A17 a17; A18 a18; };
 
 // Helper struct that allows assigning the result of a function to a variable, even if that result is a void type.
 //
@@ -113,8 +113,8 @@ T&& operator,(T&& t, Regularize) {
     return std::forward<T>(t);
 }
 
-template<typename Result, typename... Args>
-void Invoke(Result(*func)(Args...), PackedArguments<Result, Args...>& args) {
+template<typename Result, typename... Args, typename Func>
+void Invoke(Func&& func, PackedArguments<Result, Args...>& args) requires(std::is_invocable_r_v<Result, Func, Args...>) {
     constexpr auto NumArgs = sizeof...(Args);
     static_assert(NumArgs <= 19 || NumArgs == 24);
 
diff --git a/ThunkLibs/libGL/libGL_interface.cpp b/ThunkLibs/libGL/libGL_interface.cpp
index e292b2e053..c01f3808fb 100644
--- a/ThunkLibs/libGL/libGL_interface.cpp
+++ b/ThunkLibs/libGL/libGL_interface.cpp
@@ -11,6 +11,8 @@
 #undef GL_ARB_viewport_array
 #include "glcorearb.h"
 
+#include <type_traits>
+
 template<auto>
 struct fex_gen_config {
     unsigned version = 1;
@@ -18,6 +20,25 @@ struct fex_gen_config {
 
 template<> struct fex_gen_config<glXGetProcAddress> : fexgen::custom_guest_entrypoint, fexgen::returns_guest_pointer {};
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<std::remove_pointer_t<GLXContext>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<std::remove_pointer_t<GLXFBConfig>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<std::remove_pointer_t<GLsync>> : fexgen::opaque_type {};
+
+// NOTE: These should be opaque, but actually aren't because the respective libraries aren't thunked
+template<> struct fex_gen_type<_cl_context> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_cl_event> : fexgen::opaque_type {};
+
+// Opaque for the purpose of libGL
+template<> struct fex_gen_type<_XDisplay> : fexgen::opaque_type {};
+
+#ifndef IS_32BIT_THUNK
+// TODO: These are largely compatible, *but* contain function pointer members that need adjustment!
+template<> struct fex_gen_type<XExtData> : fexgen::assume_compatible_data_layout {};
+#endif
+
 // Symbols queryable through glXGetProcAddr
 namespace internal {
 template<auto>
@@ -88,7 +109,7 @@ template<> struct fex_gen_config<glXDestroyGLXPixmap> {};
 template<> struct fex_gen_config<glXDestroyPbuffer> {};
 template<> struct fex_gen_config<glXDestroyPixmap> {};
 template<> struct fex_gen_config<glXDestroyWindow> {};
-template<> struct fex_gen_config<glXFreeMemoryNV> {};
+//template<> struct fex_gen_config<glXFreeMemoryNV> {};
 template<> struct fex_gen_config<glXGetSelectedEvent> {};
 template<> struct fex_gen_config<glXQueryDrawable> {};
 template<> struct fex_gen_config<glXSelectEvent> {};
@@ -698,9 +719,9 @@ template<> struct fex_gen_config<glCullFace> {};
 template<> struct fex_gen_config<glCullParameterdvEXT> {};
 template<> struct fex_gen_config<glCullParameterfvEXT> {};
 template<> struct fex_gen_config<glCurrentPaletteMatrixARB> {};
-template<> struct fex_gen_config<glDebugMessageCallbackAMD> : fexgen::callback_stub {};
-template<> struct fex_gen_config<glDebugMessageCallbackARB> : fexgen::callback_stub {};
-template<> struct fex_gen_config<glDebugMessageCallback> : fexgen::callback_stub {};
+//template<> struct fex_gen_config<glDebugMessageCallbackAMD> : fexgen::callback_stub {};
+//template<> struct fex_gen_config<glDebugMessageCallbackARB> : fexgen::callback_stub {};
+//template<> struct fex_gen_config<glDebugMessageCallback> : fexgen::callback_stub {};
 template<> struct fex_gen_config<glDebugMessageControlARB> {};
 template<> struct fex_gen_config<glDebugMessageControl> {};
 template<> struct fex_gen_config<glDebugMessageEnableAMD> {};
@@ -2379,10 +2400,10 @@ template<> struct fex_gen_config<glTexCoord4sv> {};
 template<> struct fex_gen_config<glTexCoord4xOES> {};
 template<> struct fex_gen_config<glTexCoord4xvOES> {};
 template<> struct fex_gen_config<glTexCoordFormatNV> {};
-template<> struct fex_gen_config<glTexCoordPointerEXT> {};
-template<> struct fex_gen_config<glTexCoordPointer> {};
-template<> struct fex_gen_config<glTexCoordPointerListIBM> {};
-template<> struct fex_gen_config<glTexCoordPointervINTEL> {};
+//template<> struct fex_gen_config<glTexCoordPointerEXT> {};
+//template<> struct fex_gen_config<glTexCoordPointer> {};
+//template<> struct fex_gen_config<glTexCoordPointerListIBM> {};
+//template<> struct fex_gen_config<glTexCoordPointervINTEL> {};
 template<> struct fex_gen_config<glTexEnvf> {};
 template<> struct fex_gen_config<glTexEnvfv> {};
 template<> struct fex_gen_config<glTexEnvi> {};
diff --git a/ThunkLibs/libX11/libX11_Guest.cpp b/ThunkLibs/libX11/libX11_Guest.cpp
index b32ad9228a..3a2547a769 100644
--- a/ThunkLibs/libX11/libX11_Guest.cpp
+++ b/ThunkLibs/libX11/libX11_Guest.cpp
@@ -14,6 +14,8 @@ extern "C" {
 #include <X11/Xproto.h>
 #include <X11/XKBlib.h>
 
+#include <X11/extensions/extutil.h>
+
 // Include Xlibint.h and undefine some of its macros that clash with the standard library
 #include <X11/Xlibint.h>
 #undef min
diff --git a/ThunkLibs/libX11/libX11_Host.cpp b/ThunkLibs/libX11/libX11_Host.cpp
index c73d7a6ea4..568543a708 100644
--- a/ThunkLibs/libX11/libX11_Host.cpp
+++ b/ThunkLibs/libX11/libX11_Host.cpp
@@ -20,12 +20,20 @@ extern "C" {
 #undef min
 #undef max
 
+#define XTRANS_SEND_FDS 1
+#include <X11/Xtrans/Xtransint.h>
+
 #include <X11/Xutil.h>
+#include <X11/Xregion.h>
 #include <X11/Xresource.h>
 
 #include <X11/Xproto.h>
 
+#include <X11/extensions/extutil.h>
 #include <X11/extensions/XKBstr.h>
+#include <X11/extensions/XKBgeom.h>
+
+#include <X11/Xtrans/Xtransint.h>
 }
 
 #include "common/Host.h"
diff --git a/ThunkLibs/libX11/libX11_interface.cpp b/ThunkLibs/libX11/libX11_interface.cpp
index 188826056c..15675e4fc5 100644
--- a/ThunkLibs/libX11/libX11_interface.cpp
+++ b/ThunkLibs/libX11/libX11_interface.cpp
@@ -10,11 +10,15 @@ extern "C" {
 
 #include <X11/ImUtil.h>
 
+#include <X11/extensions/extutil.h>
 #include <X11/extensions/Xext.h>
+#include <X11/extensions/XKBgeom.h>
 
 #include <X11/Xlibint.h>
 #include <X11/XKBlib.h>
 
+#include <X11/Xtrans/Xtransint.h>
+
 #include <X11/Xutil.h>
 }
 
@@ -28,6 +32,10 @@ struct fex_gen_config {
 template<typename>
 struct fex_gen_type {};
 
+// Function, parameter index, parameter type [optional]
+template<auto, int, typename = void>
+struct fex_gen_param {};
+
 template<> struct fex_gen_type<XID(Display*)> {}; // XDisplay::resource_alloc
 
 // NOTE: only indirect calls to this are allowed
@@ -54,6 +62,61 @@ template<> struct fex_gen_type<unsigned long(XImage*, int, int)> {};      // XIm
 template<> struct fex_gen_type<int(XImage*, int, int, unsigned long)> {}; // XImage::f.put_pixel
 template<> struct fex_gen_type<int(XImage*, long)> {};                    // XImage::f.add_pixel
 
+template<> struct fex_gen_type<std::remove_pointer_t<XIC>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<std::remove_pointer_t<XIM>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<std::remove_pointer_t<XOC>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<std::remove_pointer_t<XOM>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XrmHashBucketRec> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XkbInfoRec> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XContextDB> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XDisplayAtoms> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XLockInfo> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XIMFilter> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XErrorThreadInfo> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XKeytrans> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_X11XCBPrivate> : fexgen::opaque_type {};
+
+
+#ifndef IS_32BIT_THUNK
+// This has a public definition but is used as an opaque type in most APIs
+template<> struct fex_gen_type<std::remove_pointer_t<Region>> : fexgen::assume_compatible_data_layout {};
+
+// Union types
+template<> struct fex_gen_type<XEvent> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<xEvent> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<XkbDoodadRec> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<xReply> : fexgen::assume_compatible_data_layout {};
+
+// Union type of all sorts of different X objects... Further, XEHeadOfExtensionList casts this to XExtData**.
+// This is likely highly unsafe to assume compatible.
+template<> struct fex_gen_type<XEDataObject> : fexgen::assume_compatible_data_layout {};
+
+// Linked-list types
+template<> struct fex_gen_type<_XtransConnFd> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XkbDeviceLedChanges> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XQEvent> : fexgen::assume_compatible_data_layout {};
+
+// Contains nontrivial circular pointer relationships
+template<> struct fex_gen_type<XkbOverlayRec> : fexgen::assume_compatible_data_layout {};
+
+// TODO: These are largely compatible, *but* contain function pointer members that need adjustment!
+template<> struct fex_gen_type<_XConnWatchInfo> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<XExtData> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XLockPtrs> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XFreeFuncRec> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XExtension> : fexgen::assume_compatible_data_layout {}; // Also contains linked-list pointers
+template<> struct fex_gen_type<_XConnectionInfo> : fexgen::assume_compatible_data_layout {}; // Also contains linked-list pointers
+template<> struct fex_gen_type<_XInternalAsync> : fexgen::assume_compatible_data_layout {}; // Also contains linked-list pointers
+template<> struct fex_gen_type<_XDisplay> : fexgen::assume_compatible_data_layout {};
+
+// TODO: This contains a nested struct type of function pointer members
+template<> struct fex_gen_type<XImage> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<XExtensionHooks> : fexgen::assume_compatible_data_layout {};
+#endif
+
+// Union type (each member is defined in terms of char members)
+template<> struct fex_gen_type<XkbAction> : fexgen::assume_compatible_data_layout {};
+
 // Xlibint
 template<> struct fex_gen_config<_XGetRequest> {};
 template<> struct fex_gen_config<_XFlushGCCache> {};
diff --git a/ThunkLibs/libXext/libXext_Guest.cpp b/ThunkLibs/libXext/libXext_Guest.cpp
index 0db7e4dab7..e8684b83fb 100644
--- a/ThunkLibs/libXext/libXext_Guest.cpp
+++ b/ThunkLibs/libXext/libXext_Guest.cpp
@@ -35,6 +35,8 @@ extern "C" {
 #include <X11/extensions/syncconst.h>
 #include <X11/extensions/syncproto.h>
 //#include <X11/extensions/XTest.h>
+#undef min
+#undef max
 
 
 #include "common/Guest.h"
diff --git a/ThunkLibs/libXext/libXext_Host.cpp b/ThunkLibs/libXext/libXext_Host.cpp
index 94caa6be09..076087b806 100644
--- a/ThunkLibs/libXext/libXext_Host.cpp
+++ b/ThunkLibs/libXext/libXext_Host.cpp
@@ -8,6 +8,7 @@ tags: thunklibs|X11
 
 #include <X11/Xlib.h>
 #include <X11/Xlibint.h>
+#include <X11/Xregion.h>
 #include <X11/Xutil.h>
 #include <X11/Xproto.h>
 #include <X11/extensions/Xext.h>
@@ -38,6 +39,12 @@ extern "C" {
 #include <X11/extensions/syncproto.h>
 //#include <X11/extensions/XTest.h>
 
+#define XTRANS_SEND_FDS 1
+#include <X11/Xtrans/Xtransint.h>
+
+#undef min
+#undef max
+
 #include "common/Host.h"
 #include <dlfcn.h>
 
diff --git a/ThunkLibs/libXext/libXext_interface.cpp b/ThunkLibs/libXext/libXext_interface.cpp
index 87b0666bb5..18f6ccf1e4 100644
--- a/ThunkLibs/libXext/libXext_interface.cpp
+++ b/ThunkLibs/libXext/libXext_interface.cpp
@@ -2,6 +2,7 @@
 
 #include <X11/Xlib.h>
 #include <X11/Xlibint.h>
+#include <X11/Xregion.h>
 #include <X11/extensions/Xext.h>
 #include <X11/extensions/dpms.h>
 #include <X11/extensions/XEVI.h>
@@ -16,12 +17,52 @@
 extern "C" {
 #include <X11/extensions/extutil.h>
 }
+#include <X11/Xtrans/Xtransint.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 6;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<_X11XCBPrivate> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XContextDB> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XDisplayAtoms> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XErrorThreadInfo> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XIMFilter> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XkbInfoRec> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XKeytrans> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XLockInfo> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XrmHashBucketRec> : fexgen::opaque_type {};
+
+#ifndef IS_32BIT_THUNK
+// Union types
+template<> struct fex_gen_type<XEvent> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<xEvent> : fexgen::assume_compatible_data_layout {};
+
+// Linked-list types
+template<> struct fex_gen_type<_XtransConnFd> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XQEvent> : fexgen::assume_compatible_data_layout {};
+
+// TODO: These are largely compatible, *but* contain function pointer members that need adjustment!
+template<> struct fex_gen_type<_XConnectionInfo> : fexgen::assume_compatible_data_layout {}; // Also contains linked-list pointers
+template<> struct fex_gen_type<_XConnWatchInfo> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XDisplay> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<XExtData> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<XExtDisplayInfo> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XExtension> : fexgen::assume_compatible_data_layout {}; // Also contains linked-list pointers
+template<> struct fex_gen_type<_XInternalAsync> : fexgen::assume_compatible_data_layout {}; // Also contains linked-list pointers
+
+// Contains nontrivial circular pointer relationships
+template<> struct fex_gen_type<Screen> : fexgen::assume_compatible_data_layout {};
+
+// TODO: This contains a nested struct type of function pointer members
+template<> struct fex_gen_type<XImage> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<XExtensionHooks> : fexgen::assume_compatible_data_layout {};
+#endif
+
 template<> struct fex_gen_config<DPMSCapable> {};
 template<> struct fex_gen_config<DPMSDisable> {};
 template<> struct fex_gen_config<DPMSEnable> {};
diff --git a/ThunkLibs/libXfixes/libXfixes_Host.cpp b/ThunkLibs/libXfixes/libXfixes_Host.cpp
index b6a0a5ca92..0712fb90a7 100644
--- a/ThunkLibs/libXfixes/libXfixes_Host.cpp
+++ b/ThunkLibs/libXfixes/libXfixes_Host.cpp
@@ -6,9 +6,14 @@ tags: thunklibs|X11
 
 #include <stdio.h>
 
+extern "C" {
 #include <X11/Xlib.h>
+#include <X11/Xlibint.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xfixes.h>
+}
+#undef min
+#undef max
 
 #include "common/Host.h"
 #include <dlfcn.h>
diff --git a/ThunkLibs/libXfixes/libXfixes_interface.cpp b/ThunkLibs/libXfixes/libXfixes_interface.cpp
index 1bd6df682a..24c2227a4b 100644
--- a/ThunkLibs/libXfixes/libXfixes_interface.cpp
+++ b/ThunkLibs/libXfixes/libXfixes_interface.cpp
@@ -1,12 +1,24 @@
 #include <common/GeneratorInterface.h>
 
+extern "C" {
 #include <X11/extensions/Xfixes.h>
+#include <X11/Xlibint.h>
+}
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 3;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+#ifndef IS_32BIT_THUNK
+// TODO: These are largely compatible, *but* contain function pointer members that need adjustment!
+template<> struct fex_gen_type<XExtData> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XDisplay> : fexgen::assume_compatible_data_layout {};
+#endif
+
 template<> struct fex_gen_config<XFixesGetCursorName> {};
 template<> struct fex_gen_config<XFixesQueryExtension> {};
 template<> struct fex_gen_config<XFixesQueryVersion> {};
diff --git a/ThunkLibs/libXrender/libXrender_Host.cpp b/ThunkLibs/libXrender/libXrender_Host.cpp
index 49d01d88c8..04dbb4a778 100644
--- a/ThunkLibs/libXrender/libXrender_Host.cpp
+++ b/ThunkLibs/libXrender/libXrender_Host.cpp
@@ -6,9 +6,15 @@ tags: thunklibs|X11
 
 #include <stdio.h>
 
+extern "C" {
 #include <X11/Xlib.h>
+#include <X11/Xlibint.h>
+#include <X11/Xregion.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xrender.h>
+}
+#undef min
+#undef max
 
 #include "common/Host.h"
 #include <dlfcn.h>
diff --git a/ThunkLibs/libXrender/libXrender_interface.cpp b/ThunkLibs/libXrender/libXrender_interface.cpp
index e884c286e6..12424de422 100644
--- a/ThunkLibs/libXrender/libXrender_interface.cpp
+++ b/ThunkLibs/libXrender/libXrender_interface.cpp
@@ -2,11 +2,28 @@
 
 #include <X11/extensions/Xrender.h>
 
+#include <type_traits>
+
 template<auto>
 struct fex_gen_config {
     unsigned version = 1;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+// Struct with multi-dimensional array member. Compatible data layout across all architectures
+template<> struct fex_gen_type<_XTransform> : fexgen::assume_compatible_data_layout {};
+
+#ifndef IS_32BIT_THUNK
+// This has a public definition but is used as an opaque type in most APIs
+template<> struct fex_gen_type<std::remove_pointer_t<Region>> : fexgen::assume_compatible_data_layout {};
+
+// TODO: These are largely compatible, *but* contain function pointer members that need adjustment!
+template<> struct fex_gen_type<XExtData> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XDisplay> : fexgen::assume_compatible_data_layout {};
+#endif
+
 template<> struct fex_gen_config<XRenderCreateAnimCursor> {};
 template<> struct fex_gen_config<XRenderCreateCursor> {};
 template<> struct fex_gen_config<XRenderCreateGlyphSet> {};
diff --git a/ThunkLibs/libasound/libasound_interface.cpp b/ThunkLibs/libasound/libasound_interface.cpp
index 7e34d5ce47..a5fe6647a1 100644
--- a/ThunkLibs/libasound/libasound_interface.cpp
+++ b/ThunkLibs/libasound/libasound_interface.cpp
@@ -3,11 +3,94 @@
 #include <alsa/asoundlib.h>
 #include <alsa/version.h>
 
+#include <type_traits>
+
 template<auto>
 struct fex_gen_config {
     unsigned version = 2;
 };
 
+// Function, parameter index, parameter type [optional]
+template<auto, int, typename = void>
+struct fex_gen_param {};
+
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<snd_pcm_status_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_shm_area> : fexgen::opaque_type {};
+
+template<> struct fex_gen_type<snd_async_handler_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<std::remove_pointer_t<snd_config_iterator_t>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_config_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_config_update_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_card_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_elem_id_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_elem_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_elem_list_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_elem_value_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_event_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_devname_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_hctl_elem_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_hctl_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_hwdep_dsp_image_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_hwdep_dsp_status_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_hwdep_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_hwdep_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_input_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_midi_event_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_mixer_class_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_mixer_elem_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_mixer_selem_id_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_mixer_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_output_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_access_mask_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_format_mask_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_hook_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_hw_params_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_scope_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_subformat_mask_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_sw_params_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_rawmidi_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_rawmidi_params_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_rawmidi_status_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_rawmidi_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_sctl_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_client_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_client_pool_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_ev_ext_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_port_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_port_subscribe_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_query_subscribe_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_queue_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_queue_status_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_queue_tempo_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_queue_timer_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_remove_events_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_system_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_ginfo_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_gparams_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_gstatus_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_id_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_params_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_query_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_status_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timestamp_t> : fexgen::opaque_type {};
+
+template<> struct fex_gen_type<FILE> : fexgen::opaque_type {};
+
+// Union types with compatible data layout
+template<> struct fex_gen_type<snd_pcm_sync_id_t> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<snd_seq_timestamp> : fexgen::assume_compatible_data_layout {};
+// Has anonymous union member
+template<> struct fex_gen_type<snd_seq_event> : fexgen::assume_compatible_data_layout {};
+
 template<> struct fex_gen_config<snd_asoundlib_version> {};
 #if SND_LIB_VERSION < ((1 << 16) | (2 << 8) | (6))
 // Exists on 1.2.6
@@ -445,7 +528,7 @@ template<> struct fex_gen_config<snd_pcm_meter_get_boundary> {};
 template<> struct fex_gen_config<snd_pcm_meter_add_scope> {};
 template<> struct fex_gen_config<snd_pcm_meter_search_scope> {};
 template<> struct fex_gen_config<snd_pcm_scope_malloc> {};
-template<> struct fex_gen_config<snd_pcm_scope_set_ops> {};
+//template<> struct fex_gen_config<snd_pcm_scope_set_ops> {}; // TODO: Support snd_pcm_scope_ops_t vtable
 template<> struct fex_gen_config<snd_pcm_scope_set_name> {};
 template<> struct fex_gen_config<snd_pcm_scope_get_name> {};
 template<> struct fex_gen_config<snd_pcm_scope_get_callback_private> {};
diff --git a/ThunkLibs/libdrm/libdrm_interface.cpp b/ThunkLibs/libdrm/libdrm_interface.cpp
index a8075531eb..42128e3e3a 100644
--- a/ThunkLibs/libdrm/libdrm_interface.cpp
+++ b/ThunkLibs/libdrm/libdrm_interface.cpp
@@ -7,6 +7,18 @@ struct fex_gen_config {
     unsigned version = 2;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+#ifndef IS_32BIT_THUNK
+// Union types with compatible data layout
+template<> struct fex_gen_type<drmDevice> : fexgen::assume_compatible_data_layout {};
+
+// Anonymous sub-structs
+template<> struct fex_gen_type<drmStatsT> : fexgen::assume_compatible_data_layout {};
+
+#endif
+
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
 
@@ -14,7 +26,8 @@ template<> struct fex_gen_config<FEX_usable_size> : fexgen::custom_host_impl, fe
 template<> struct fex_gen_config<FEX_free_on_host> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint {};
 template<> struct fex_gen_config<drmIoctl> {};
 template<> struct fex_gen_config<drmGetHashTable> {};
-template<> struct fex_gen_config<drmGetEntry> {};
+// TODO: returns struct containing a function pointer
+//template<> struct fex_gen_config<drmGetEntry> {};
 template<> struct fex_gen_config<drmAvailable> {};
 template<> struct fex_gen_config<drmOpen> {};
 template<> struct fex_gen_config<drmOpenWithType> {};
@@ -76,7 +89,8 @@ template<> struct fex_gen_config<drmGetContextPrivateMapping> {};
 template<> struct fex_gen_config<drmScatterGatherAlloc> {};
 template<> struct fex_gen_config<drmScatterGatherFree> {};
 template<> struct fex_gen_config<drmWaitVBlank> {};
-template<> struct fex_gen_config<drmSetServerInfo> {};
+// TODO: Needs vtable support
+//template<> struct fex_gen_config<drmSetServerInfo> {};
 template<> struct fex_gen_config<drmError> {};
 template<> struct fex_gen_config<drmMalloc> {};
 template<> struct fex_gen_config<drmFree> {};
@@ -106,7 +120,8 @@ template<> struct fex_gen_config<drmCloseOnce> {};
 template<> struct fex_gen_config<drmSetMaster> {};
 template<> struct fex_gen_config<drmDropMaster> {};
 template<> struct fex_gen_config<drmIsMaster> {};
-template<> struct fex_gen_config<drmHandleEvent> {};
+// TODO: Needs vtable support
+//template<> struct fex_gen_config<drmHandleEvent> {};
 template<> struct fex_gen_config<drmGetDeviceNameFromFd> : fexgen::custom_guest_entrypoint {};
 template<> struct fex_gen_config<drmGetDeviceNameFromFd2> : fexgen::custom_guest_entrypoint {};
 
diff --git a/ThunkLibs/libfex_thunk_test/Host.cpp b/ThunkLibs/libfex_thunk_test/Host.cpp
index ab90519145..1b28b2c4bf 100644
--- a/ThunkLibs/libfex_thunk_test/Host.cpp
+++ b/ThunkLibs/libfex_thunk_test/Host.cpp
@@ -13,4 +13,22 @@ tags: thunklibs|fex_thunk_test
 
 #include "thunkgen_host_libfex_thunk_test.inl"
 
+static uint32_t fexfn_impl_libfex_thunk_test_QueryOffsetOf(guest_layout<ReorderingType*> data, int index) {
+    if (index == 0) {
+        return offsetof(guest_layout<ReorderingType>::type, a);
+    } else {
+        return offsetof(guest_layout<ReorderingType>::type, b);
+    }
+}
+
+template<>
+void fex_custom_repack<&CustomRepackedType::data>(host_layout<CustomRepackedType>& to, guest_layout<CustomRepackedType> const& from) {
+  to.data.custom_repack_invoked = 1;
+}
+
+template<>
+void fex_custom_repack_postcall<&CustomRepackedType::data>(ReorderingType* const&) {
+
+}
+
 EXPORTS(libfex_thunk_test)
diff --git a/ThunkLibs/libfex_thunk_test/api.h b/ThunkLibs/libfex_thunk_test/api.h
index 293ba29451..6f1729c3a8 100644
--- a/ThunkLibs/libfex_thunk_test/api.h
+++ b/ThunkLibs/libfex_thunk_test/api.h
@@ -10,4 +10,70 @@ extern "C" {
 
 uint32_t GetDoubledValue(uint32_t);
 
+
+/// Interfaces used to test opaque_type and assume_compatible_data_layout annotations
+
+struct OpaqueType;
+
+OpaqueType* MakeOpaqueType(uint32_t data);
+uint32_t ReadOpaqueTypeData(OpaqueType*);
+void DestroyOpaqueType(OpaqueType*);
+
+union UnionType {
+    uint32_t a;
+    int32_t b;
+    uint8_t c[4];
+};
+
+UnionType MakeUnionType(uint8_t a, uint8_t b, uint8_t c, uint8_t d);
+uint32_t GetUnionTypeA(UnionType*);
+
+/// Interfaces used to test automatic struct repacking
+
+// A simple struct with data layout that differs between guest and host.
+// The thunk generator should emit code that swaps the member data into
+// correct position.
+struct ReorderingType {
+#if defined(__aarch64__) || defined(_M_ARM64) // TODO: Use proper host check
+    uint32_t a;
+    uint32_t b;
+#else
+    uint32_t b;
+    uint32_t a;
+#endif
+};
+
+ReorderingType MakeReorderingType(uint32_t a, uint32_t b);
+uint32_t GetReorderingTypeMember(const ReorderingType*, int index);
+void ModifyReorderingTypeMembers(ReorderingType* data);
+uint32_t QueryOffsetOf(ReorderingType*, int index);
+
+// Uses assume_compatible_data_layout to skip repacking
+uint32_t GetReorderingTypeMemberWithoutRepacking(const ReorderingType*, int index);
+
+/// Interfaces used to test assisted struct repacking
+
+// We enable custom repacking on the "data" member, with repacking code that
+// sets the first bit of "custom_repack_invoked" to 1 on entry.
+struct CustomRepackedType {
+    ReorderingType* data;
+    int custom_repack_invoked;
+};
+
+// Should return true if the custom repacker set "custom_repack_invoked" to true
+int RanCustomRepack(CustomRepackedType*);
+
+/// Interface used to check that function arguments with different integer size
+/// get forwarded correctly
+/// TODO: Also test signatures that differ through the underlying type of a
+///       type alias. Currently, the thunk generator still requires a dedicated
+///       type to detect differences.
+
+#if defined(__aarch64__) || defined(_M_ARM64) // TODO: Use proper host check
+enum DivType : uint8_t {};
+#else
+enum DivType : uint32_t {};
+#endif
+int FunctionWithDivergentSignature(DivType, DivType, DivType, DivType);
+
 }
diff --git a/ThunkLibs/libfex_thunk_test/lib.cpp b/ThunkLibs/libfex_thunk_test/lib.cpp
index 2e6354b8e1..0fbe9a1c10 100644
--- a/ThunkLibs/libfex_thunk_test/lib.cpp
+++ b/ThunkLibs/libfex_thunk_test/lib.cpp
@@ -6,4 +6,57 @@ uint32_t GetDoubledValue(uint32_t input) {
   return 2 * input;
 }
 
+struct OpaqueType {
+  uint32_t data;
+};
+
+OpaqueType* MakeOpaqueType(uint32_t data) {
+  return new OpaqueType { data };
+}
+
+uint32_t ReadOpaqueTypeData(OpaqueType* value) {
+  return value->data;
+}
+
+void DestroyOpaqueType(OpaqueType* value) {
+  delete value;
+}
+
+UnionType MakeUnionType(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
+  return UnionType { .c = { a, b, c, d } };
+}
+
+uint32_t GetUnionTypeA(UnionType* value) {
+  return value->a;
+}
+
+ReorderingType MakeReorderingType(uint32_t a, uint32_t b) {
+  return ReorderingType { .a = a, .b = b };
+}
+
+uint32_t GetReorderingTypeMember(const ReorderingType* data, int index) {
+  if (index == 0) {
+    return data->a;
+  } else {
+    return data->b;
+  }
+}
+
+uint32_t GetReorderingTypeMemberWithoutRepacking(const ReorderingType* data, int index) {
+  return GetReorderingTypeMember(data, index);
+}
+
+void ModifyReorderingTypeMembers(ReorderingType* data) {
+  data->a += 1;
+  data->b += 2;
+}
+
+int RanCustomRepack(CustomRepackedType* data) {
+  return data->custom_repack_invoked;
+}
+
+int FunctionWithDivergentSignature(DivType a, DivType b, DivType c, DivType d) {
+  return ((uint8_t)a << 24) | ((uint8_t)b << 16) | ((uint8_t)c << 8) | (uint8_t)d;
+}
+
 } // extern "C"
diff --git a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
index 7fedaa415d..8923722f36 100644
--- a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
+++ b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
@@ -12,3 +12,26 @@ template<auto, int, typename>
 struct fex_gen_param {};
 
 template<> struct fex_gen_config<GetDoubledValue> {};
+
+template<> struct fex_gen_type<OpaqueType> : fexgen::opaque_type {};
+template<> struct fex_gen_config<MakeOpaqueType> {};
+template<> struct fex_gen_config<ReadOpaqueTypeData> {};
+template<> struct fex_gen_config<DestroyOpaqueType> {};
+
+template<> struct fex_gen_type<UnionType> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_config<MakeUnionType> {};
+template<> struct fex_gen_config<GetUnionTypeA> {};
+
+template<> struct fex_gen_config<MakeReorderingType> {};
+template<> struct fex_gen_config<GetReorderingTypeMember> {};
+template<> struct fex_gen_config<GetReorderingTypeMemberWithoutRepacking> {};
+template<> struct fex_gen_param<GetReorderingTypeMemberWithoutRepacking, 0, const ReorderingType*> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_config<ModifyReorderingTypeMembers> {};
+
+template<> struct fex_gen_config<QueryOffsetOf> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<QueryOffsetOf, 0, ReorderingType*> : fexgen::ptr_passthrough {};
+
+template<> struct fex_gen_config<&CustomRepackedType::data> : fexgen::custom_repack {};
+template<> struct fex_gen_config<RanCustomRepack> {};
+
+template<> struct fex_gen_config<FunctionWithDivergentSignature> {};
diff --git a/ThunkLibs/libvulkan/Guest.cpp b/ThunkLibs/libvulkan/Guest.cpp
index 066e1a6b42..cbad026a19 100644
--- a/ThunkLibs/libvulkan/Guest.cpp
+++ b/ThunkLibs/libvulkan/Guest.cpp
@@ -4,6 +4,8 @@ tags: thunklibs|Vulkan
 $end_info$
 */
 
+#define VK_USE_64_BIT_PTR_DEFINES 0
+
 #define VK_USE_PLATFORM_XLIB_XRANDR_EXT
 #define VK_USE_PLATFORM_XLIB_KHR
 #define VK_USE_PLATFORM_XCB_KHR
diff --git a/ThunkLibs/libvulkan/Host.cpp b/ThunkLibs/libvulkan/Host.cpp
index deda37d3d4..fe087338db 100644
--- a/ThunkLibs/libvulkan/Host.cpp
+++ b/ThunkLibs/libvulkan/Host.cpp
@@ -4,6 +4,8 @@ tags: thunklibs|Vulkan
 $end_info$
 */
 
+#define VK_USE_64_BIT_PTR_DEFINES 0
+
 #define VK_USE_PLATFORM_XLIB_XRANDR_EXT
 #define VK_USE_PLATFORM_XLIB_KHR
 #define VK_USE_PLATFORM_XCB_KHR
@@ -15,6 +17,7 @@ tags: thunklibs|Vulkan
 #include <cstring>
 #include <mutex>
 #include <unordered_map>
+#include <vector>
 
 #include <dlfcn.h>
 
@@ -48,6 +51,7 @@ static void DoSetupWithInstance(VkInstance instance) {
 
 #define FEXFN_IMPL(fn) fexfn_impl_libvulkan_##fn
 
+#if 0
 // Functions with callbacks are overridden to ignore the guest-side callbacks
 
 static VkResult FEXFN_IMPL(vkCreateShaderModule)(VkDevice a_0, const VkShaderModuleCreateInfo* a_1, const VkAllocationCallbacks* a_2, VkShaderModule* a_3) {
@@ -59,8 +63,9 @@ static VkBool32 DummyVkDebugReportCallback(VkDebugReportFlagsEXT, VkDebugReportO
                                            int32_t, const char*, const char*, void*) {
   return VK_FALSE;
 }
+#endif
 
-static VkResult FEXFN_IMPL(vkCreateInstance)(const VkInstanceCreateInfo* a_0, const VkAllocationCallbacks* a_1, VkInstance* a_2) {
+static VkResult FEXFN_IMPL(vkCreateInstance)(const VkInstanceCreateInfo* a_0, const VkAllocationCallbacks* a_1, guest_layout<VkInstance*> a_2) {
   const VkInstanceCreateInfo* vk_struct_base = a_0;
   for (const VkBaseInStructure* vk_struct = reinterpret_cast<const VkBaseInStructure*>(vk_struct_base); vk_struct->pNext; vk_struct = vk_struct->pNext) {
     // Override guest callbacks used for VK_EXT_debug_report
@@ -74,11 +79,17 @@ static VkResult FEXFN_IMPL(vkCreateInstance)(const VkInstanceCreateInfo* a_0, co
     }
   }
 
-  return LDR_PTR(vkCreateInstance)(vk_struct_base, nullptr, a_2);
+  VkInstance out;
+  auto ret = LDR_PTR(vkCreateInstance)(vk_struct_base, nullptr, &out);
+  *a_2.get_pointer() = out;
+  return ret;
 }
 
-static VkResult FEXFN_IMPL(vkCreateDevice)(VkPhysicalDevice a_0, const VkDeviceCreateInfo* a_1, const VkAllocationCallbacks* a_2, VkDevice* a_3){
-  return LDR_PTR(vkCreateDevice)(a_0, a_1, nullptr, a_3);
+static VkResult FEXFN_IMPL(vkCreateDevice)(VkPhysicalDevice a_0, const VkDeviceCreateInfo* a_1, const VkAllocationCallbacks* a_2, guest_layout<VkDevice*> a_3) {
+  VkDevice out;
+  auto ret = LDR_PTR(vkCreateDevice)(a_0, a_1, nullptr, &out);
+  *a_3.get_pointer() = out;
+  return ret;
 }
 
 static VkResult FEXFN_IMPL(vkAllocateMemory)(VkDevice a_0, const VkMemoryAllocateInfo* a_1, const VkAllocationCallbacks* a_2, VkDeviceMemory* a_3){
@@ -91,6 +102,7 @@ static void FEXFN_IMPL(vkFreeMemory)(VkDevice a_0, VkDeviceMemory a_1, const VkA
   LDR_PTR(vkFreeMemory)(a_0, a_1, nullptr);
 }
 
+#if 0
 static VkResult FEXFN_IMPL(vkCreateDebugReportCallbackEXT)(VkInstance a_0, const VkDebugReportCallbackCreateInfoEXT* a_1, const VkAllocationCallbacks* a_2, VkDebugReportCallbackEXT* a_3) {
   VkDebugReportCallbackCreateInfoEXT overridden_callback = *a_1;
   overridden_callback.pfnCallback = DummyVkDebugReportCallback;
@@ -102,15 +114,145 @@ static void FEXFN_IMPL(vkDestroyDebugReportCallbackEXT)(VkInstance a_0, VkDebugR
   (void*&)LDR_PTR(vkDestroyDebugReportCallbackEXT) = (void*)LDR_PTR(vkGetInstanceProcAddr)(a_0, "vkDestroyDebugReportCallbackEXT");
   LDR_PTR(vkDestroyDebugReportCallbackEXT)(a_0, a_1, nullptr);
 }
+#endif
+
+#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] = 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;
+  fexldr_ptr_libvulkan_vkGetDeviceQueue(device, family_index, queue_index, &out);
+  *queue.get_pointer() = out;
+}
+
+VkResult fexfn_impl_libvulkan_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* info, guest_layout<VkCommandBuffer*> buffers) {
+  std::vector<VkCommandBuffer> out(info->commandBufferCount);
+  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] = 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;
+  auto ret = fexldr_ptr_libvulkan_vkMapMemory(device, memory, offset, size, flags, &mapped);
+  fprintf(stderr, "%s: Mapped %p\n", __FUNCTION__, mapped);
+  if (ret == VK_SUCCESS) {
+    host_data.data = mapped;
+    *data.get_pointer() = to_guest(host_data);
+  }
+  return ret;
+}
+
+void fexfn_impl_libvulkan_vkUpdateDescriptorSets(
+    VkDevice_T* device, unsigned int descriptorWriteCount,
+    guest_layout<const VkWriteDescriptorSet*> pDescriptorWrites,
+    unsigned int descriptorCopyCount, VkCopyDescriptorSet const* pDescriptorCopies) {
+
+  VkWriteDescriptorSet* HostDescriptorWrites;
+  if (!descriptorWriteCount || !descriptorWriteCount) {
+    HostDescriptorWrites = nullptr;
+  } else {
+    HostDescriptorWrites = new VkWriteDescriptorSet[descriptorWriteCount];
+    for (size_t i = 0; i < descriptorWriteCount; ++i) {
+      auto src = host_layout<VkWriteDescriptorSet> { pDescriptorWrites.get_pointer()[i] };
+      fex_apply_custom_repacking(src, pDescriptorWrites.get_pointer()[i]);
+      static_assert(sizeof(src.data) == sizeof(HostDescriptorWrites[i]));
+      memcpy((void*)&HostDescriptorWrites[i], &src.data, sizeof(src.data));
+    }
+  }
+
+// TODO: Is this needed?
+//  if (!from.data.pDescriptorCopies.get_pointer() || !from.data.descriptorCopyCount.data) {
+//    into.data.pDescriptorCopies = nullptr;
+//    return;
+//  }
+//  into.data.pDescriptorCopies = new VkCopyDescriptorSet[from.data.descriptorCopyCount.data];
+//  for (size_t i = 0; i < from.data.descriptorCopyCount.data; ++i) {
+//    auto src = host_layout<VkCopyDescriptorSet> { from.data.pDescriptorCopies.get_pointer()[i] }.data;
+//    static_assert(sizeof(src) == sizeof(into.data.pDescriptorCopies[i]));
+//    memcpy((void*)&into.data.pDescriptorCopies[i], &src, sizeof(src));
+//  }
+//  delete[] info;
+
+
+  fexldr_ptr_libvulkan_vkUpdateDescriptorSets(device, descriptorWriteCount, HostDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+
+  delete[] HostDescriptorWrites;
+}
+
+VkResult fexfn_impl_libvulkan_vkQueueSubmit(VkQueue queue, uint32_t submit_count,
+                                            guest_layout<const VkSubmitInfo*> submit_infos, VkFence fence) {
+
+  VkSubmitInfo* HostSubmitInfos = nullptr;
+  if (submit_count) {
+    HostSubmitInfos = new VkSubmitInfo[submit_count];
+    for (size_t i = 0; i < submit_count; ++i) {
+      auto src = host_layout<VkSubmitInfo> { submit_infos.get_pointer()[i] };
+      fex_apply_custom_repacking(src, submit_infos.get_pointer()[i]);
+      static_assert(sizeof(src.data) == sizeof(HostSubmitInfos[i]));
+      memcpy((void*)&HostSubmitInfos[i], &src.data, sizeof(src.data));
+    }
+  }
+
+  auto ret = fexldr_ptr_libvulkan_vkQueueSubmit(queue, submit_count, HostSubmitInfos, fence);
+
+  delete[] HostSubmitInfos;
+
+  return ret;
+}
+
+void fexfn_impl_libvulkan_vkFreeCommandBuffers(VkDevice device, VkCommandPool pool, uint32_t num_buffers,
+                                            guest_layout<const VkCommandBuffer*> buffers) {
+
+  VkCommandBuffer* HostBuffers = nullptr;
+  if (num_buffers) {
+    HostBuffers = new VkCommandBuffer[num_buffers];
+    for (size_t i = 0; i < num_buffers; ++i) {
+      auto src = host_layout<VkCommandBuffer_T*> { (const guest_layout<VkCommandBuffer_T *>&)buffers.get_pointer()[i] };
+      static_assert(sizeof(src.data) == sizeof(HostBuffers[i]));
+      memcpy((void*)&HostBuffers[i], &src.data, sizeof(src.data));
+    }
+  }
+
+  fexldr_ptr_libvulkan_vkFreeCommandBuffers(device, pool, num_buffers, HostBuffers);
+
+  delete[] HostBuffers;
+}
+
+VkResult fexfn_impl_libvulkan_vkGetPipelineCacheData(VkDevice device, VkPipelineCache cache, guest_layout<size_t*> guest_data_size, void* data) {
+  size_t data_size = guest_data_size.get_pointer()->data;
+  auto ret = fexldr_ptr_libvulkan_vkGetPipelineCacheData(device, cache, &data_size, data);
+  *guest_data_size.get_pointer() = data_size;
+  return ret;
+}
+
+#endif
 
 static PFN_vkVoidFunction FEXFN_IMPL(vkGetDeviceProcAddr)(VkDevice a_0, const char* a_1) {
   // Just return the host facing function pointer
   // The guest will handle mapping if this exists
 
-  // Check for functions with stubbed callbacks first
-  if (std::strcmp(a_1, "vkCreateShaderModule") == 0) {
+  // Check for functions with custom implementations first
+  /*if (std::strcmp(a_1, "vkCreateShaderModule") == 0) {
       return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkCreateShaderModule;
-  } else if (std::strcmp(a_1, "vkCreateInstance") == 0) {
+  } else */if (std::strcmp(a_1, "vkCreateInstance") == 0) {
       return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkCreateInstance;
   } else if (std::strcmp(a_1, "vkCreateDevice") == 0) {
       return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkCreateDevice;
@@ -118,6 +260,24 @@ static PFN_vkVoidFunction FEXFN_IMPL(vkGetDeviceProcAddr)(VkDevice a_0, const ch
       return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkAllocateMemory;
   } else if (std::strcmp(a_1, "vkFreeMemory") == 0) {
       return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkFreeMemory;
+#ifdef IS_32BIT_THUNK
+  } else if (std::strcmp(a_1, "vkEnumeratePhysicalDevices") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkEnumeratePhysicalDevices;
+  } else if (std::strcmp(a_1, "vkGetDeviceQueue") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkGetDeviceQueue;
+  } else if (std::strcmp(a_1, "vkAllocateCommandBuffers") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkAllocateCommandBuffers;
+  } else if (std::strcmp(a_1, "vkMapMemory") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkMapMemory;
+  } else if (std::strcmp(a_1, "vkUpdateDescriptorSets") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkUpdateDescriptorSets;
+  } else if (std::strcmp(a_1, "vkQueueSubmit") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkQueueSubmit;
+  } else if (std::strcmp(a_1, "vkFreeCommandBuffers") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkFreeCommandBuffers;
+  } else if (std::strcmp(a_1, "vkGetPipelineCacheData") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkGetPipelineCacheData;
+#endif
   }
 
   auto ret = LDR_PTR(vkGetDeviceProcAddr)(a_0, a_1);
@@ -135,4 +295,793 @@ static PFN_vkVoidFunction FEXFN_IMPL(vkGetInstanceProcAddr)(VkInstance a_0, cons
   return ret;
 }
 
+#ifdef IS_32BIT_THUNK
+template<VkStructureType TypeIndex, typename Type>
+static const VkBaseOutStructure* convert(const VkBaseOutStructure* source) {
+    // Using malloc here since no easily available type information is available at the time of destruction
+    auto child = (host_layout<Type>*)malloc(sizeof(host_layout<Type>));
+    new (child) host_layout<Type> { *reinterpret_cast<guest_layout<Type>*>((void*)(source)) }; // TODO: Use proper cast?
+
+    // TODO: Trigger *full* custom repack for children, not just the Next member
+    fex_custom_repack<&Type::pNext>(*child, *reinterpret_cast<guest_layout<Type>*>((void*)(source)));
+
+    return (const VkBaseOutStructure*)child; // TODO: Use proper cast?
+}
+
+template<VkStructureType TypeIndex, typename Type>
+inline constexpr std::pair<VkStructureType, const VkBaseOutStructure*(*)(const VkBaseOutStructure*)> converters =
+  { TypeIndex, convert<TypeIndex, Type> };
+
+
+static std::unordered_map<VkStructureType, const VkBaseOutStructure*(*)(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>,
+};
+
+// Normally, we would implement fex_custom_repack individually for each customized struct.
+// In this case, they all need the same repacking, so we just implement it once and alias all fex_custom_repack instances
+extern "C" void default_fex_custom_repack(/*host_layout<*/VkBaseOutStructure/*>*/& into, /* guest_layout<VkBaseOutStructure>& */void* from) {
+  struct guest_vk_struct {
+    VkStructureType sType;
+    guest_layout<struct VkBaseOutStructure*> pNext;
+  };
+
+  auto* typed_source = reinterpret_cast<guest_vk_struct*>(from);
+  if (!typed_source->pNext.get_pointer()) {
+  fprintf(stderr, "  CUSTOM REPACK: no more pNext\n");
+      into.pNext = nullptr;
+      return;
+  }
+  typed_source = reinterpret_cast<guest_vk_struct*>(typed_source->pNext.get_pointer());
+
+  auto next_handler = next_handlers.find(typed_source->sType);
+  if (next_handler == next_handlers.end()) {
+    fprintf(stderr, "ERROR: Unrecognized VkStructureType %u referenced by pNext\n", typed_source->sType);
+    std::abort();
+  }
+  // TODO: Avoid redundant cast to VkBaseOutStructure...
+  const_cast<const VkBaseOutStructure*&>(into.pNext) = next_handler->second((const VkBaseOutStructure*)typed_source);
+}
+
+template<>
+void fex_custom_repack<&VkInstanceCreateInfo::pNext>(host_layout<VkInstanceCreateInfo>& into, const guest_layout<VkInstanceCreateInfo>& from) {
+  // TODO
+  default_fex_custom_repack((VkBaseOutStructure&)into.data, (void*)&from);
+}
+
+template<>
+void fex_custom_repack_postcall<&VkInstanceCreateInfo::pNext>(const void* const&) {
+  // TODO
+}
+
+#define CREATE_INFO_DEFAULT_CUSTOM_REPACK(name) \
+template<> \
+void fex_custom_repack<&name::pNext>(host_layout<name>& into, const guest_layout<name>& from) { \
+fprintf(stderr, "CUSTOM REPACK: %s\n", __PRETTY_FUNCTION__);\
+  default_fex_custom_repack((VkBaseOutStructure&)into.data, (void*)&from); \
+} \
+\
+template<> \
+void fex_custom_repack_postcall<&name::pNext>(decltype(std::declval<name>().pNext) const&) { \
+  /* TODO */ \
+}
+
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkAttachmentDescription2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkAttachmentReference2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkBaseOutStructure)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkBufferMemoryBarrier2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkDependencyInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkDescriptorUpdateTemplateCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkGraphicsPipelineCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkImageFormatListCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkImageMemoryBarrier2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkImageMemoryRequirementsInfo2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkMemoryAllocateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkMemoryAllocateFlagsInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkMemoryBarrier2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkMemoryDedicatedAllocateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkMemoryDedicatedRequirements)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkMemoryRequirements2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkPipelineRenderingCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkRenderPassAttachmentBeginInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkRenderPassBeginInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkRenderPassCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkRenderPassCreateInfo2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSemaphoreCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSemaphoreTypeCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSemaphoreWaitInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSubmitInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSubpassBeginInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSubpassDependency2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSubpassDescription2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSwapchainCreateInfoKHR)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkTimelineSemaphoreSubmitInfo)
+
+template<>
+void fex_custom_repack<&VkInstanceCreateInfo::pApplicationInfo>(host_layout<VkInstanceCreateInfo>& into, const guest_layout<VkInstanceCreateInfo>& from) {
+  auto HostApplicationInfo = new host_layout<VkApplicationInfo> { *from.data.pApplicationInfo.get_pointer() };
+  fex_apply_custom_repacking(*HostApplicationInfo, *from.data.pApplicationInfo.get_pointer());
+  into.data.pApplicationInfo = &HostApplicationInfo->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkInstanceCreateInfo::pApplicationInfo>(const VkApplicationInfo* const& pApplicationInfo) {
+  delete pApplicationInfo;
+}
+
+template<>
+void fex_custom_repack<&VkInstanceCreateInfo::ppEnabledExtensionNames>(host_layout<VkInstanceCreateInfo>& into, const guest_layout<VkInstanceCreateInfo>& from) {
+  auto extension_count = from.data.enabledExtensionCount.data;
+  fprintf(stderr, "  Repacking %d ppEnabledExtensionNames\n", extension_count);
+  into.data.ppEnabledExtensionNames = new const char*[extension_count];
+
+  for (uint32_t i = 0; i < extension_count; ++i) {
+    const guest_layout<const char* const>& ExtensionName = from.data.ppEnabledExtensionNames.get_pointer()[i];
+    fprintf(stderr, "    EXT %p[%d]: %p %s\n", from.data.ppEnabledExtensionNames.get_pointer(), i, (void*)(uintptr_t)ExtensionName.data, (const char*)(uintptr_t)ExtensionName.data);
+    const_cast<const char*&>(into.data.ppEnabledExtensionNames[i]) = host_layout<const char* const> { ExtensionName }.data;
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkInstanceCreateInfo::ppEnabledExtensionNames>(const char* const* const& data) {
+  delete[] data;
+}
+
+template<>
+void fex_custom_repack<&VkInstanceCreateInfo::ppEnabledLayerNames>(host_layout<VkInstanceCreateInfo>& into, const guest_layout<VkInstanceCreateInfo>& from) {
+  auto layer_count = from.data.enabledLayerCount.data;
+  fprintf(stderr, "  Repacking %d ppEnabledLayerNames\n", layer_count);
+  into.data.ppEnabledLayerNames = new const char*[layer_count];
+
+  for (uint32_t i = 0; i < layer_count; ++i) {
+    const guest_layout<const char* const>& LayerName = from.data.ppEnabledLayerNames.get_pointer()[i];
+    fprintf(stderr, "    EXT %p[%d]: %p %s\n", from.data.ppEnabledLayerNames.get_pointer(), i, (void*)(uintptr_t)LayerName.data, (const char*)(uintptr_t)LayerName.data);
+    const_cast<const char*&>(into.data.ppEnabledLayerNames[i]) = host_layout<const char* const> { LayerName }.data;
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkInstanceCreateInfo::ppEnabledLayerNames>(const char* const* const& data) {
+  delete[] data;
+}
+
+template<>
+void fex_custom_repack<&VkApplicationInfo::pNext>(host_layout<VkApplicationInfo>& into, const guest_layout<VkApplicationInfo>& from) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack_postcall<&VkApplicationInfo::pNext>(const void* const&) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkDeviceQueueCreateInfo::pNext>(host_layout<VkDeviceQueueCreateInfo>& into, const guest_layout<VkDeviceQueueCreateInfo>& from) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDeviceQueueCreateInfo::pNext>(const void* const&) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkDeviceCreateInfo::pNext>(host_layout<VkDeviceCreateInfo>& into, const guest_layout<VkDeviceCreateInfo>& from) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDeviceCreateInfo::pNext>(const void* const&) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkDeviceCreateInfo::pQueueCreateInfos>(host_layout<VkDeviceCreateInfo>& into, const guest_layout<VkDeviceCreateInfo>& from) {
+  auto HostQueueCreateInfo = new host_layout<VkDeviceQueueCreateInfo> { *from.data.pQueueCreateInfos.get_pointer() };
+  fex_apply_custom_repacking(*HostQueueCreateInfo, *from.data.pQueueCreateInfos.get_pointer());
+  into.data.pQueueCreateInfos = &HostQueueCreateInfo->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDeviceCreateInfo::pQueueCreateInfos>(const VkDeviceQueueCreateInfo* const& pQueueCreateInfos) {
+  delete pQueueCreateInfos;
+}
+
+template<>
+void fex_custom_repack<&VkDeviceCreateInfo::ppEnabledExtensionNames>(host_layout<VkDeviceCreateInfo>& into, const guest_layout<VkDeviceCreateInfo>& from) {
+  auto extension_count = from.data.enabledExtensionCount.data;
+  fprintf(stderr, "  Repacking %d ppEnabledExtensionNames\n", extension_count);
+  into.data.ppEnabledExtensionNames = new const char*[extension_count];
+
+  for (uint32_t i = 0; i < extension_count; ++i) {
+    const guest_layout<const char* const>& ExtensionName = from.data.ppEnabledExtensionNames.get_pointer()[i];
+    fprintf(stderr, "    EXT %p[%d]: %p %s\n", from.data.ppEnabledExtensionNames.get_pointer(), i, (const char*)(uintptr_t)ExtensionName.data, (const char*)(uintptr_t)ExtensionName.data);
+    const_cast<const char*&>(into.data.ppEnabledExtensionNames[i]) = host_layout<const char* const> { ExtensionName }.data;
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDeviceCreateInfo::ppEnabledExtensionNames>(const char* const* const& data) {
+  delete[] data;
+}
+
+template<>
+void fex_custom_repack<&VkDeviceCreateInfo::ppEnabledLayerNames>(host_layout<VkDeviceCreateInfo>& into, const guest_layout<VkDeviceCreateInfo>& from) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDeviceCreateInfo::ppEnabledLayerNames>(const char* const* const& data) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkImageViewCreateInfo::pNext>(host_layout<VkImageViewCreateInfo>& into, const guest_layout<VkImageViewCreateInfo>& from) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack_postcall<&VkImageViewCreateInfo::pNext>(const void* const&) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkDescriptorSetLayoutCreateInfo::pNext>(host_layout<VkDescriptorSetLayoutCreateInfo>& into, const guest_layout<VkDescriptorSetLayoutCreateInfo>& from) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDescriptorSetLayoutCreateInfo::pNext>(const void* const&) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkDescriptorSetLayoutCreateInfo::pBindings>(host_layout<VkDescriptorSetLayoutCreateInfo>& into, const guest_layout<VkDescriptorSetLayoutCreateInfo>& from) {
+  if (!from.data.bindingCount.data) {
+    into.data.pBindings = nullptr;
+    return;
+  }
+
+  into.data.pBindings = new VkDescriptorSetLayoutBinding[from.data.bindingCount.data];
+  for (size_t i = 0; i < from.data.bindingCount.data; ++i) {
+    auto in_data = host_layout<VkDescriptorSetLayoutBinding> { from.data.pBindings.get_pointer()[i] }.data;
+    memcpy((void*)&into.data.pBindings[i], &in_data, sizeof(VkDescriptorSetLayoutBinding));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDescriptorSetLayoutCreateInfo::pBindings>(const VkDescriptorSetLayoutBinding* const& bindings) {
+  delete[] bindings;
+}
+
+template<>
+void fex_custom_repack<&VkRenderPassCreateInfo::pSubpasses>(host_layout<VkRenderPassCreateInfo>& into, const guest_layout<VkRenderPassCreateInfo>& from) {
+  if (from.data.subpassCount.data == 0) {
+    into.data.pSubpasses = nullptr;
+    return;
+  }
+
+  into.data.pSubpasses = new VkSubpassDescription[from.data.subpassCount.data];
+  for (size_t i = 0; i < from.data.subpassCount.data; ++i) {
+    auto in_data = host_layout<VkSubpassDescription> { from.data.pSubpasses.get_pointer()[i] }.data;
+    memcpy((void*)&into.data.pSubpasses[i], &in_data, sizeof(VkSubpassDescription));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderPassCreateInfo::pSubpasses>(const VkSubpassDescription* const& subpasses) {
+  delete[] subpasses;
+}
+
+template<>
+void fex_custom_repack<&VkRenderPassCreateInfo2::pAttachments>(host_layout<VkRenderPassCreateInfo2>& into, const guest_layout<VkRenderPassCreateInfo2>& from) {
+  if (from.data.attachmentCount.data == 0) {
+    into.data.pAttachments = nullptr;
+    return;
+  }
+
+  into.data.pAttachments = new VkAttachmentDescription2[from.data.attachmentCount.data];
+  for (size_t i = 0; i < from.data.attachmentCount.data; ++i) {
+    auto in_data = host_layout<VkAttachmentDescription2> { from.data.pAttachments.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pAttachments.get_pointer()[i]);
+    memcpy((void*)&into.data.pAttachments[i], &in_data.data, sizeof(VkAttachmentDescription2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderPassCreateInfo2::pAttachments>(const VkAttachmentDescription2* const& attachments) {
+  delete[] attachments;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkRenderPassCreateInfo2::pSubpasses>(host_layout<VkRenderPassCreateInfo2>& into, const guest_layout<VkRenderPassCreateInfo2>& from) {
+  if (from.data.subpassCount.data == 0) {
+    into.data.pSubpasses = nullptr;
+    return;
+  }
+
+  into.data.pSubpasses = new VkSubpassDescription2[from.data.subpassCount.data];
+  for (size_t i = 0; i < from.data.subpassCount.data; ++i) {
+    auto in_data = host_layout<VkSubpassDescription2> { from.data.pSubpasses.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pSubpasses.get_pointer()[i]);
+    memcpy((void*)&into.data.pSubpasses[i], &in_data.data, sizeof(VkSubpassDescription2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderPassCreateInfo2::pSubpasses>(const VkSubpassDescription2* const& subpasses) {
+  delete[] subpasses;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkRenderPassCreateInfo2::pDependencies>(host_layout<VkRenderPassCreateInfo2>& into, const guest_layout<VkRenderPassCreateInfo2>& from) {
+  if (from.data.dependencyCount.data == 0) {
+    into.data.pDependencies = nullptr;
+    return;
+  }
+
+  into.data.pDependencies = new VkSubpassDependency2[from.data.dependencyCount.data];
+  for (size_t i = 0; i < from.data.dependencyCount.data; ++i) {
+    auto in_data = host_layout<VkSubpassDependency2> { from.data.pDependencies.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pDependencies.get_pointer()[i]);
+    memcpy((void*)&into.data.pDependencies[i], &in_data.data, sizeof(VkSubpassDependency2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderPassCreateInfo2::pDependencies>(const VkSubpassDependency2* const& dependencies) {
+  delete[] dependencies;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkSubpassDescription2::pInputAttachments>(host_layout<VkSubpassDescription2>& into, const guest_layout<VkSubpassDescription2>& from) {
+  if (from.data.inputAttachmentCount.data == 0) {
+    into.data.pInputAttachments = nullptr;
+    return;
+  }
+
+  into.data.pInputAttachments = new VkAttachmentReference2[from.data.inputAttachmentCount.data];
+  for (size_t i = 0; i < from.data.inputAttachmentCount.data; ++i) {
+    auto in_data = host_layout<VkAttachmentReference2> { from.data.pInputAttachments.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pInputAttachments.get_pointer()[i]);
+    memcpy((void*)&into.data.pInputAttachments[i], &in_data.data, sizeof(VkAttachmentReference2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkSubpassDescription2::pInputAttachments>(const VkAttachmentReference2* const& references) {
+  delete[] references;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkSubpassDescription2::pColorAttachments>(host_layout<VkSubpassDescription2>& into, const guest_layout<VkSubpassDescription2>& from) {
+  if (from.data.colorAttachmentCount.data == 0) {
+    into.data.pColorAttachments = nullptr;
+    return;
+  }
+
+  into.data.pColorAttachments = new VkAttachmentReference2[from.data.colorAttachmentCount.data];
+  for (size_t i = 0; i < from.data.colorAttachmentCount.data; ++i) {
+    auto in_data = host_layout<VkAttachmentReference2> { from.data.pColorAttachments.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pColorAttachments.get_pointer()[i]);
+    memcpy((void*)&into.data.pColorAttachments[i], &in_data.data, sizeof(VkAttachmentReference2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkSubpassDescription2::pColorAttachments>(const VkAttachmentReference2* const& references) {
+  delete[] references;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkSubpassDescription2::pResolveAttachments>(host_layout<VkSubpassDescription2>& into, const guest_layout<VkSubpassDescription2>& from) {
+  if (from.data.colorAttachmentCount.data == 0 || from.data.pResolveAttachments.get_pointer() == nullptr) {
+    into.data.pResolveAttachments = nullptr;
+    return;
+  }
+
+  into.data.pResolveAttachments = new VkAttachmentReference2[from.data.colorAttachmentCount.data];
+  for (size_t i = 0; i < from.data.colorAttachmentCount.data; ++i) {
+    auto in_data = host_layout<VkAttachmentReference2> { from.data.pResolveAttachments.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pResolveAttachments.get_pointer()[i]);
+    memcpy((void*)&into.data.pResolveAttachments[i], &in_data.data, sizeof(VkAttachmentReference2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkSubpassDescription2::pResolveAttachments>(const VkAttachmentReference2* const& references) {
+  delete[] references;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkSubpassDescription2::pDepthStencilAttachment>(host_layout<VkSubpassDescription2>& into, const guest_layout<VkSubpassDescription2>& from) {
+  if (from.data.pDepthStencilAttachment.data == 0) {
+    into.data.pDepthStencilAttachment = nullptr;
+    return;
+  }
+
+  into.data.pDepthStencilAttachment = new VkAttachmentReference2;
+  auto in_data = host_layout<VkAttachmentReference2> { *from.data.pDepthStencilAttachment.get_pointer() };
+  fex_apply_custom_repacking(in_data, *from.data.pDepthStencilAttachment.get_pointer());
+  memcpy((void*)into.data.pDepthStencilAttachment, &in_data.data, sizeof(VkAttachmentReference2));
+}
+
+template<>
+void fex_custom_repack_postcall<&VkSubpassDescription2::pDepthStencilAttachment>(const VkAttachmentReference2* const& references) {
+  delete[] references;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkRenderingInfo::pColorAttachments>(host_layout<VkRenderingInfo>& into, const guest_layout<VkRenderingInfo>& from) {
+  if (from.data.colorAttachmentCount.data == 0) {
+    into.data.pColorAttachments = nullptr;
+    return;
+  }
+
+  into.data.pColorAttachments = new VkRenderingAttachmentInfo[from.data.colorAttachmentCount.data];
+  for (size_t i = 0; i < from.data.colorAttachmentCount.data; ++i) {
+    auto in_data = host_layout<VkRenderingAttachmentInfo> { from.data.pColorAttachments.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pColorAttachments.get_pointer()[i]);
+    memcpy((void*)&into.data.pColorAttachments[i], &in_data.data, sizeof(VkRenderingAttachmentInfo));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderingInfo::pColorAttachments>(const VkRenderingAttachmentInfo* const& info) {
+  delete[] info;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkRenderingInfo::pDepthAttachment>(host_layout<VkRenderingInfo>& into, const guest_layout<VkRenderingInfo>& from) {
+  if (from.data.pDepthAttachment.get_pointer() == nullptr) {
+    into.data.pDepthAttachment = nullptr;
+    return;
+  }
+
+  into.data.pDepthAttachment = new VkRenderingAttachmentInfo;
+  auto in_data = host_layout<VkRenderingAttachmentInfo> { *from.data.pDepthAttachment.get_pointer() };
+  fex_apply_custom_repacking(in_data, *from.data.pDepthAttachment.get_pointer());
+  memcpy((void*)into.data.pDepthAttachment, &in_data.data, sizeof(VkRenderingAttachmentInfo));
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderingInfo::pDepthAttachment>(const VkRenderingAttachmentInfo* const& info) {
+  delete info;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkRenderingInfo::pStencilAttachment>(host_layout<VkRenderingInfo>& into, const guest_layout<VkRenderingInfo>& from) {
+  if (from.data.pStencilAttachment.get_pointer() == nullptr) {
+    into.data.pStencilAttachment = nullptr;
+    return;
+  }
+
+  into.data.pStencilAttachment = new VkRenderingAttachmentInfo;
+  auto in_data = host_layout<VkRenderingAttachmentInfo> { *from.data.pStencilAttachment.get_pointer() };
+  fex_apply_custom_repacking(in_data, *from.data.pStencilAttachment.get_pointer());
+  memcpy((void*)into.data.pStencilAttachment, &in_data.data, sizeof(VkRenderingAttachmentInfo));
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderingInfo::pStencilAttachment>(const VkRenderingAttachmentInfo* const& info) {
+  delete info;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkDependencyInfo::pMemoryBarriers>(host_layout<VkDependencyInfo>& into, const guest_layout<VkDependencyInfo>& from) {
+  if (from.data.memoryBarrierCount.data == 0) {
+    into.data.pMemoryBarriers = nullptr;
+    return;
+  }
+
+  into.data.pMemoryBarriers = new VkMemoryBarrier2[from.data.memoryBarrierCount.data];
+  for (size_t i = 0; i < from.data.memoryBarrierCount.data; ++i) {
+    auto in_data = host_layout<VkMemoryBarrier2> { from.data.pMemoryBarriers.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pMemoryBarriers.get_pointer()[i]);
+    memcpy((void*)&into.data.pMemoryBarriers[i], &in_data.data, sizeof(VkMemoryBarrier2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDependencyInfo::pMemoryBarriers>(const VkMemoryBarrier2* const& barriers) {
+  delete[] barriers;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkDependencyInfo::pBufferMemoryBarriers>(host_layout<VkDependencyInfo>& into, const guest_layout<VkDependencyInfo>& from) {
+  if (from.data.bufferMemoryBarrierCount.data == 0) {
+    into.data.pBufferMemoryBarriers = nullptr;
+    return;
+  }
+
+  into.data.pBufferMemoryBarriers = new VkBufferMemoryBarrier2[from.data.bufferMemoryBarrierCount.data];
+  for (size_t i = 0; i < from.data.bufferMemoryBarrierCount.data; ++i) {
+    auto in_data = host_layout<VkBufferMemoryBarrier2> { from.data.pBufferMemoryBarriers.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pBufferMemoryBarriers.get_pointer()[i]);
+    memcpy((void*)&into.data.pBufferMemoryBarriers[i], &in_data.data, sizeof(VkBufferMemoryBarrier2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDependencyInfo::pBufferMemoryBarriers>(const VkBufferMemoryBarrier2* const& barriers) {
+  delete[] barriers;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkDependencyInfo::pImageMemoryBarriers>(host_layout<VkDependencyInfo>& into, const guest_layout<VkDependencyInfo>& from) {
+  if (from.data.imageMemoryBarrierCount.data == 0) {
+    into.data.pImageMemoryBarriers = nullptr;
+    return;
+  }
+
+  into.data.pImageMemoryBarriers = new VkImageMemoryBarrier2[from.data.imageMemoryBarrierCount.data];
+  for (size_t i = 0; i < from.data.imageMemoryBarrierCount.data; ++i) {
+    auto in_data = host_layout<VkImageMemoryBarrier2> { from.data.pImageMemoryBarriers.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pImageMemoryBarriers.get_pointer()[i]);
+    memcpy((void*)&into.data.pImageMemoryBarriers[i], &in_data.data, sizeof(VkImageMemoryBarrier2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDependencyInfo::pImageMemoryBarriers>(const VkImageMemoryBarrier2* const& barriers) {
+  delete[] barriers;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkDescriptorUpdateTemplateCreateInfo::pDescriptorUpdateEntries>(host_layout<VkDescriptorUpdateTemplateCreateInfo>& into, const guest_layout<VkDescriptorUpdateTemplateCreateInfo>& from) {
+  if (from.data.descriptorUpdateEntryCount.data == 0) {
+    into.data.pDescriptorUpdateEntries = nullptr;
+    return;
+  }
+
+  into.data.pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[from.data.descriptorUpdateEntryCount.data];
+  for (size_t i = 0; i < from.data.descriptorUpdateEntryCount.data; ++i) {
+    auto in_data = host_layout<VkDescriptorUpdateTemplateEntry> { from.data.pDescriptorUpdateEntries.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pDescriptorUpdateEntries.get_pointer()[i]);
+    memcpy((void*)&into.data.pDescriptorUpdateEntries[i], &in_data.data, sizeof(VkDescriptorUpdateTemplateEntry));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDescriptorUpdateTemplateCreateInfo::pDescriptorUpdateEntries>(const VkDescriptorUpdateTemplateEntry* const& entries) {
+  delete[] entries;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkPipelineShaderStageCreateInfo::pSpecializationInfo>(host_layout<VkPipelineShaderStageCreateInfo>& into, const guest_layout<VkPipelineShaderStageCreateInfo>& from) {
+  if (from.data.pSpecializationInfo.get_pointer()) {
+    fprintf(stderr, "ERROR: Cannot repack non-null VkPipelineShaderStageCreateInfo::pSpecializationInfo yet");
+    std::abort();
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkPipelineShaderStageCreateInfo::pSpecializationInfo>(const VkSpecializationInfo* const&) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pStages>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.stageCount.data) {
+    into.data.pStages = nullptr;
+    return;
+  }
+  auto host_stages = new VkPipelineShaderStageCreateInfo[from.data.stageCount.data];
+  for (size_t i = 0; i < from.data.stageCount.data; ++i) {
+     host_stages[i] = host_layout<VkPipelineShaderStageCreateInfo> { from.data.pStages.get_pointer()[i] }.data;
+  }
+  into.data.pStages = host_stages;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pStages>(const VkPipelineShaderStageCreateInfo* const& stages) {
+  delete[] stages;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pVertexInputState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pVertexInputState.get_pointer()) {
+    into.data.pVertexInputState = nullptr;
+    return;
+  }
+  into.data.pVertexInputState = &(new host_layout<VkPipelineVertexInputStateCreateInfo> { *from.data.pVertexInputState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pVertexInputState>(const VkPipelineVertexInputStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pInputAssemblyState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pInputAssemblyState.get_pointer()) {
+    into.data.pInputAssemblyState = nullptr;
+    return;
+  }
+  into.data.pInputAssemblyState = &(new host_layout<VkPipelineInputAssemblyStateCreateInfo> { *from.data.pInputAssemblyState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pInputAssemblyState>(const VkPipelineInputAssemblyStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pTessellationState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pTessellationState.get_pointer()) {
+    into.data.pTessellationState = nullptr;
+    return;
+  }
+  into.data.pTessellationState = &(new host_layout<VkPipelineTessellationStateCreateInfo> { *from.data.pTessellationState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pTessellationState>(const VkPipelineTessellationStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pViewportState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pViewportState.get_pointer()) {
+    into.data.pViewportState = nullptr;
+    return;
+  }
+  into.data.pViewportState = &(new host_layout<VkPipelineViewportStateCreateInfo> { *from.data.pViewportState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pViewportState>(const VkPipelineViewportStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pRasterizationState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pRasterizationState.get_pointer()) {
+    into.data.pRasterizationState = nullptr;
+    return;
+  }
+  into.data.pRasterizationState = &(new host_layout<VkPipelineRasterizationStateCreateInfo> { *from.data.pRasterizationState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pRasterizationState>(const VkPipelineRasterizationStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pMultisampleState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pMultisampleState.get_pointer()) {
+    into.data.pMultisampleState = nullptr;
+    return;
+  }
+  into.data.pMultisampleState = &(new host_layout<VkPipelineMultisampleStateCreateInfo> { *from.data.pMultisampleState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pMultisampleState>(const VkPipelineMultisampleStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pDepthStencilState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pDepthStencilState.get_pointer()) {
+    into.data.pDepthStencilState = nullptr;
+    return;
+  }
+  into.data.pDepthStencilState = &(new host_layout<VkPipelineDepthStencilStateCreateInfo> { *from.data.pDepthStencilState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pDepthStencilState>(const VkPipelineDepthStencilStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pColorBlendState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pColorBlendState.get_pointer()) {
+    into.data.pColorBlendState = nullptr;
+    return;
+  }
+  into.data.pColorBlendState = &(new host_layout<VkPipelineColorBlendStateCreateInfo> { *from.data.pColorBlendState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pColorBlendState>(const VkPipelineColorBlendStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pDynamicState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pDynamicState.get_pointer()) {
+    into.data.pDynamicState = nullptr;
+    return;
+  }
+  into.data.pDynamicState = &(new host_layout<VkPipelineDynamicStateCreateInfo> { *from.data.pDynamicState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pDynamicState>(const VkPipelineDynamicStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkSubmitInfo::pCommandBuffers>(host_layout<VkSubmitInfo>& into, const guest_layout<VkSubmitInfo>& from) {
+  if (!from.data.pCommandBuffers.get_pointer() || !from.data.commandBufferCount.data) {
+    into.data.pCommandBuffers = nullptr;
+    return;
+  }
+  into.data.pCommandBuffers = new VkCommandBuffer[from.data.commandBufferCount.data];
+  for (size_t i = 0; i < from.data.commandBufferCount.data; ++i) {
+    auto src = host_layout<VkCommandBuffer_T*> { (const guest_layout<VkCommandBuffer_T *>&)from.data.pCommandBuffers.get_pointer()[i] }.data;
+    static_assert(sizeof(src) == sizeof(into.data.pCommandBuffers[i]));
+    memcpy((void*)&into.data.pCommandBuffers[i], &src, sizeof(src));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkSubmitInfo::pCommandBuffers>(const VkCommandBuffer* const& buffers) {
+  delete[] buffers;
+}
+
+template<>
+void fex_custom_repack<&VkCommandBufferBeginInfo::pInheritanceInfo>(host_layout<VkCommandBufferBeginInfo>& into, const guest_layout<VkCommandBufferBeginInfo>& 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));
+}
+
+template<>
+void fex_custom_repack_postcall<&VkCommandBufferBeginInfo::pInheritanceInfo>(const VkCommandBufferInheritanceInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkPipelineCacheCreateInfo::pInitialData>(host_layout<VkPipelineCacheCreateInfo>& into, const guest_layout<VkPipelineCacheCreateInfo>& from) {
+  // Same underlying layout, so there's nothing to do
+  into.data.pInitialData = from.data.pInitialData.get_pointer();
+}
+
+template<>
+void fex_custom_repack_postcall<&VkPipelineCacheCreateInfo::pInitialData>(const void* const&) {
+  // Nothing to do
+}
+
+template<>
+void fex_custom_repack<&VkRenderPassBeginInfo::pClearValues>(host_layout<VkRenderPassBeginInfo>& into, const guest_layout<VkRenderPassBeginInfo>& from) {
+  // Same underlying layout, so there's nothing to do
+  into.data.pClearValues = reinterpret_cast<const VkClearValue*>(from.data.pClearValues.get_pointer());
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderPassBeginInfo::pClearValues>(const VkClearValue* const&) {
+  // Nothing to do
+}
+#endif
+
+
 EXPORTS(libvulkan)
diff --git a/ThunkLibs/libvulkan/libvulkan_interface.cpp b/ThunkLibs/libvulkan/libvulkan_interface.cpp
index ea307856d2..a4e0f04bd3 100644
--- a/ThunkLibs/libvulkan/libvulkan_interface.cpp
+++ b/ThunkLibs/libvulkan/libvulkan_interface.cpp
@@ -1,10 +1,19 @@
 #include <common/GeneratorInterface.h>
 
+#include <type_traits>
+
 template<auto>
 struct fex_gen_config {
     unsigned version = 1;
 };
 
+// Some of Vulkan's handle types are so-called "non-dispatchable handles".
+// On 64-bit, these are defined as dedicated types by default, which makes
+// annotating these handle types unnecessarily complicated. Instead, setting
+// the following define will make the Vulkan headers alias all handle types
+// to uint64_t.
+#define VK_USE_64_BIT_PTR_DEFINES 0
+
 #define VK_USE_PLATFORM_XLIB_XRANDR_EXT
 #define VK_USE_PLATFORM_XLIB_KHR
 #define VK_USE_PLATFORM_XCB_KHR
@@ -14,18 +23,178 @@ struct fex_gen_config {
 template<> struct fex_gen_config<vkGetDeviceProcAddr> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint, fexgen::returns_guest_pointer {};
 template<> struct fex_gen_config<vkGetInstanceProcAddr> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint, fexgen::returns_guest_pointer {};
 
+template<typename>
+struct fex_gen_type {};
+
+// So-called "dispatchable" handles are represented as opaque pointers.
+// In addition to marking them as such, API functions that create these objects
+// need special care since they wrap these handles in another pointer, which
+// the thunk generator can't automatically handle.
+//
+// So-called "non-dispatchable" handles don't need this extra treatment, since
+// they are uint64_t IDs on both 32-bit and 64-bit systems.
+template<> struct fex_gen_type<VkCommandBuffer_T> : fexgen::opaque_type {};
+template<> struct fex_gen_type<VkDevice_T> : fexgen::opaque_type {};
+template<> struct fex_gen_type<VkInstance_T> : fexgen::opaque_type {};
+template<> struct fex_gen_type<VkPhysicalDevice_T> : fexgen::opaque_type {};
+template<> struct fex_gen_type<VkQueue_T> : fexgen::opaque_type {};
+
+// Mark union types with compatible layout as such
+// TODO: These may still have different alignment requirements!
+template<> struct fex_gen_type<VkClearValue> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<VkClearColorValue> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<VkPipelineExecutableStatisticValueKHR> : fexgen::assume_compatible_data_layout {};
+
+#ifdef IS_32BIT_THUNK
+// TODO: These are nested structures that should be detected automatically
+//template<> struct fex_gen_type<VkApplicationInfo> {};
+template<> struct fex_gen_config<&VkApplicationInfo::pNext> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkInstanceCreateInfo::pNext> : 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<&VkDeviceQueueCreateInfo::pNext> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkDeviceCreateInfo::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<&VkSemaphoreCreateInfo::pNext> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkSemaphoreTypeCreateInfo::pNext> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkImageViewCreateInfo::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_config<&VkBaseOutStructure::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferMemoryBarrier2::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<&VkGraphicsPipelineCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageMemoryBarrier2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageFormatListCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageMemoryRequirementsInfo2::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<&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<&VkDescriptorSetLayoutCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorSetLayoutCreateInfo::pBindings> : 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::assume_compatible_data_layout {};
+//template<> struct fex_gen_config<&VkSubpassDescription2::pColorAttachments> : fexgen::assume_compatible_data_layout {};
+//template<> struct fex_gen_config<&VkSubpassDescription2::pResolveAttachments> : fexgen::assume_compatible_data_layout {};
+//template<> struct fex_gen_config<&VkSubpassDescription2::pDepthStencilAttachment> : fexgen::assume_compatible_data_layout {};
+
+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 {};
+#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 {};
+#endif
+
+
+// TODO: Should not be opaque, but it's usually NULL anyway. Supporting the contained function pointers will need more work.
+template<> struct fex_gen_type<VkAllocationCallbacks> : fexgen::opaque_type {};
+
+// X11 interop
+template<> struct fex_gen_type<Display> : fexgen::opaque_type {};
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
+// Wayland interop
+template<> struct fex_gen_type<wl_display> : fexgen::opaque_type {};
+template<> struct fex_gen_type<wl_surface> : fexgen::opaque_type {};
+
 namespace internal {
 
+// Function, parameter index, parameter type [optional]
+template<auto, int, typename = void>
+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<&VkInstanceCreateInfo::pNext> : fexgen::custom_repack {};
+
+//template<> struct fex_gen_config<&VkCommandBufferBeginInfo::pNext> : fexgen::custom_repack {};
+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<> struct fex_gen_config<vkGetPhysicalDeviceFormatProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceImageFormatProperties> {};
+// TODO: Output parameter must repack on exit!
 template<> struct fex_gen_config<vkGetPhysicalDeviceProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceQueueFamilyProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceMemoryProperties> {};
@@ -33,36 +202,60 @@ template<> struct fex_gen_config<vkGetPhysicalDeviceMemoryProperties> {};
 // template<> struct fex_gen_config<vkGetInstanceProcAddr> {};
 // template<> struct fex_gen_config<vkGetDeviceProcAddr> {};
 template<> struct fex_gen_config<vkCreateDevice> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkCreateDevice, 3, VkDevice*> : fexgen::ptr_passthrough {};
 template<> struct fex_gen_config<vkDestroyDevice> {};
 template<> struct fex_gen_config<vkEnumerateInstanceExtensionProperties> {};
 template<> struct fex_gen_config<vkEnumerateDeviceExtensionProperties> {};
 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<> struct fex_gen_config<vkDeviceWaitIdle> {};
 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<> struct fex_gen_config<vkBindImageMemory> {};
 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<> struct fex_gen_config<vkDestroyEvent> {};
 template<> struct fex_gen_config<vkGetEventStatus> {};
@@ -71,6 +264,8 @@ template<> struct fex_gen_config<vkResetEvent> {};
 template<> struct fex_gen_config<vkCreateQueryPool> {};
 template<> struct fex_gen_config<vkDestroyQueryPool> {};
 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<> struct fex_gen_config<vkDestroyBuffer> {};
 template<> struct fex_gen_config<vkCreateBufferView> {};
@@ -80,14 +275,25 @@ template<> struct fex_gen_config<vkDestroyImage> {};
 template<> struct fex_gen_config<vkGetImageSubresourceLayout> {};
 template<> struct fex_gen_config<vkCreateImageView> {};
 template<> struct fex_gen_config<vkDestroyImageView> {};
-template<> struct fex_gen_config<vkCreateShaderModule> : fexgen::custom_host_impl {};
+template<> struct fex_gen_config<vkCreateShaderModule> /*: fexgen::custom_host_impl*/ {};
 template<> struct fex_gen_config<vkDestroyShaderModule> {};
 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<> struct fex_gen_config<vkCreatePipelineLayout> {};
 template<> struct fex_gen_config<vkDestroyPipelineLayout> {};
@@ -100,7 +306,12 @@ template<> struct fex_gen_config<vkDestroyDescriptorPool> {};
 template<> struct fex_gen_config<vkResetDescriptorPool> {};
 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 {};
+#endif
 template<> struct fex_gen_config<vkCreateFramebuffer> {};
 template<> struct fex_gen_config<vkDestroyFramebuffer> {};
 template<> struct fex_gen_config<vkCreateRenderPass> {};
@@ -109,8 +320,19 @@ template<> struct fex_gen_config<vkGetRenderAreaGranularity> {};
 template<> struct fex_gen_config<vkCreateCommandPool> {};
 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<> struct fex_gen_config<vkEndCommandBuffer> {};
 template<> struct fex_gen_config<vkResetCommandBuffer> {};
@@ -128,6 +350,7 @@ template<> struct fex_gen_config<vkCmdBindDescriptorSets> {};
 template<> struct fex_gen_config<vkCmdBindIndexBuffer> {};
 template<> struct fex_gen_config<vkCmdBindVertexBuffers> {};
 template<> struct fex_gen_config<vkCmdDraw> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdDrawIndexed> {};
 template<> struct fex_gen_config<vkCmdDrawIndirect> {};
 template<> struct fex_gen_config<vkCmdDrawIndexedIndirect> {};
@@ -136,42 +359,60 @@ template<> struct fex_gen_config<vkCmdDispatchIndirect> {};
 template<> struct fex_gen_config<vkCmdCopyBuffer> {};
 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<> struct fex_gen_config<vkCmdSetEvent> {};
 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<> struct fex_gen_config<vkCmdEndQuery> {};
 template<> struct fex_gen_config<vkCmdResetQueryPool> {};
 template<> struct fex_gen_config<vkCmdWriteTimestamp> {};
 template<> 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<> struct fex_gen_config<vkBindImageMemory2> {};
 template<> struct fex_gen_config<vkGetDeviceGroupPeerMemoryFeatures> {};
 template<> struct fex_gen_config<vkCmdSetDeviceMask> {};
 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<> struct fex_gen_config<vkGetPhysicalDeviceProperties2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceFormatProperties2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceImageFormatProperties2> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetPhysicalDeviceQueueFamilyProperties2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceMemoryProperties2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceSparseImageFormatProperties2> {};
@@ -179,22 +420,31 @@ template<> struct fex_gen_config<vkTrimCommandPool> {};
 template<> struct fex_gen_config<vkGetDeviceQueue2> {};
 template<> struct fex_gen_config<vkCreateSamplerYcbcrConversion> {};
 template<> struct fex_gen_config<vkDestroySamplerYcbcrConversion> {};
+#endif
 template<> struct fex_gen_config<vkCreateDescriptorUpdateTemplate> {};
 template<> struct fex_gen_config<vkDestroyDescriptorUpdateTemplate> {};
 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<> struct fex_gen_config<vkCmdNextSubpass2> {};
 template<> struct fex_gen_config<vkCmdEndRenderPass2> {};
 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<> struct fex_gen_config<vkGetBufferDeviceAddress> {};
 template<> struct fex_gen_config<vkGetBufferOpaqueCaptureAddress> {};
@@ -207,7 +457,9 @@ template<> struct fex_gen_config<vkGetPrivateData> {};
 template<> struct fex_gen_config<vkCmdSetEvent2> {};
 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<> struct fex_gen_config<vkQueueSubmit2> {};
 template<> struct fex_gen_config<vkCmdCopyBuffer2> {};
@@ -216,8 +468,10 @@ template<> struct fex_gen_config<vkCmdCopyBufferToImage2> {};
 template<> struct fex_gen_config<vkCmdCopyImageToBuffer2> {};
 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<> struct fex_gen_config<vkCmdSetFrontFace> {};
 template<> struct fex_gen_config<vkCmdSetPrimitiveTopology> {};
@@ -236,16 +490,18 @@ template<> struct fex_gen_config<vkCmdSetPrimitiveRestartEnable> {};
 template<> struct fex_gen_config<vkGetDeviceBufferMemoryRequirements> {};
 template<> struct fex_gen_config<vkGetDeviceImageMemoryRequirements> {};
 template<> struct fex_gen_config<vkGetDeviceImageSparseMemoryRequirements> {};
+#endif
 template<> struct fex_gen_config<vkDestroySurfaceKHR> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceSurfaceSupportKHR> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceSurfaceCapabilitiesKHR> {};
-template<> struct fex_gen_config<vkGetPhysicalDeviceSurfaceFormatsKHR> {};
+template<> 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<> struct fex_gen_config<vkCreateSwapchainKHR> {};
 template<> struct fex_gen_config<vkDestroySwapchainKHR> {};
 template<> struct fex_gen_config<vkGetSwapchainImagesKHR> {};
 template<> struct fex_gen_config<vkAcquireNextImageKHR> {};
 template<> struct fex_gen_config<vkQueuePresentKHR> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetDeviceGroupPresentCapabilitiesKHR> {};
 template<> struct fex_gen_config<vkGetDeviceGroupSurfacePresentModesKHR> {};
 template<> struct fex_gen_config<vkGetPhysicalDevicePresentRectanglesKHR> {};
@@ -279,11 +535,17 @@ template<> struct fex_gen_config<vkGetPhysicalDeviceExternalSemaphorePropertiesK
 template<> struct fex_gen_config<vkImportSemaphoreFdKHR> {};
 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<> struct fex_gen_config<vkCmdNextSubpass2KHR> {};
 template<> struct fex_gen_config<vkCmdEndRenderPass2KHR> {};
@@ -346,8 +608,11 @@ template<> struct fex_gen_config<vkCmdTraceRaysIndirect2KHR> {};
 template<> struct fex_gen_config<vkGetDeviceBufferMemoryRequirementsKHR> {};
 template<> struct fex_gen_config<vkGetDeviceImageMemoryRequirementsKHR> {};
 template<> struct fex_gen_config<vkGetDeviceImageSparseMemoryRequirementsKHR> {};
+#if TODO_FUNCPTRS
+// Pointee structs contain function pointers. We should be able to use ptr_passthrough on individual members
 template<> struct fex_gen_config<vkCreateDebugReportCallbackEXT> : fexgen::custom_host_impl {};
 template<> struct fex_gen_config<vkDestroyDebugReportCallbackEXT> : fexgen::custom_host_impl {};
+#endif
 template<> struct fex_gen_config<vkDebugReportMessageEXT> {};
 template<> struct fex_gen_config<vkDebugMarkerSetObjectTagEXT> {};
 template<> struct fex_gen_config<vkDebugMarkerSetObjectNameEXT> {};
@@ -370,6 +635,7 @@ template<> struct fex_gen_config<vkGetImageViewAddressNVX> {};
 template<> struct fex_gen_config<vkCmdDrawIndirectCountAMD> {};
 template<> struct fex_gen_config<vkCmdDrawIndexedIndirectCountAMD> {};
 template<> struct fex_gen_config<vkGetShaderInfoAMD> {};
+template<> struct fex_gen_param<vkGetShaderInfoAMD, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceExternalImageFormatPropertiesNV> {};
 template<> struct fex_gen_config<vkCmdBeginConditionalRenderingEXT> {};
 template<> struct fex_gen_config<vkCmdEndConditionalRenderingEXT> {};
@@ -392,7 +658,10 @@ template<> struct fex_gen_config<vkQueueInsertDebugUtilsLabelEXT> {};
 template<> struct fex_gen_config<vkCmdBeginDebugUtilsLabelEXT> {};
 template<> struct fex_gen_config<vkCmdEndDebugUtilsLabelEXT> {};
 template<> struct fex_gen_config<vkCmdInsertDebugUtilsLabelEXT> {};
+#if TODO_FUNCPTRS
+// Pointee structs contain function pointers. We should be able to use ptr_passthrough on individual members
 template<> struct fex_gen_config<vkCreateDebugUtilsMessengerEXT> {};
+#endif
 template<> struct fex_gen_config<vkDestroyDebugUtilsMessengerEXT> {};
 template<> struct fex_gen_config<vkSubmitDebugUtilsMessageEXT> {};
 template<> struct fex_gen_config<vkCmdSetSampleLocationsEXT> {};
@@ -402,6 +671,7 @@ template<> struct fex_gen_config<vkCreateValidationCacheEXT> {};
 template<> struct fex_gen_config<vkDestroyValidationCacheEXT> {};
 template<> struct fex_gen_config<vkMergeValidationCachesEXT> {};
 template<> struct fex_gen_config<vkGetValidationCacheDataEXT> {};
+template<> struct fex_gen_param<vkGetValidationCacheDataEXT, 3, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdBindShadingRateImageNV> {};
 template<> struct fex_gen_config<vkCmdSetViewportShadingRatePaletteNV> {};
 template<> struct fex_gen_config<vkCmdSetCoarseSampleOrderNV> {};
@@ -414,19 +684,26 @@ template<> struct fex_gen_config<vkCmdCopyAccelerationStructureNV> {};
 template<> struct fex_gen_config<vkCmdTraceRaysNV> {};
 template<> struct fex_gen_config<vkCreateRayTracingPipelinesNV> {};
 template<> struct fex_gen_config<vkGetRayTracingShaderGroupHandlesKHR> {};
+template<> struct fex_gen_param<vkGetRayTracingShaderGroupHandlesKHR, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkGetRayTracingShaderGroupHandlesNV> {};
+template<> struct fex_gen_param<vkGetRayTracingShaderGroupHandlesNV, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkGetAccelerationStructureHandleNV> {};
+template<> struct fex_gen_param<vkGetAccelerationStructureHandleNV, 3, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdWriteAccelerationStructuresPropertiesNV> {};
 template<> struct fex_gen_config<vkCompileDeferredNV> {};
 template<> struct fex_gen_config<vkGetMemoryHostPointerPropertiesEXT> {};
+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<vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetCalibratedTimestampsEXT> {};
 template<> struct fex_gen_config<vkCmdDrawMeshTasksNV> {};
 template<> struct fex_gen_config<vkCmdDrawMeshTasksIndirectNV> {};
 template<> struct fex_gen_config<vkCmdDrawMeshTasksIndirectCountNV> {};
 template<> struct fex_gen_config<vkCmdSetExclusiveScissorNV> {};
 template<> struct fex_gen_config<vkCmdSetCheckpointNV> {};
+template<> struct fex_gen_param<vkCmdSetCheckpointNV, 1, const void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkGetQueueCheckpointDataNV> {};
 template<> struct fex_gen_config<vkInitializePerformanceApiINTEL> {};
 template<> struct fex_gen_config<vkUninitializePerformanceApiINTEL> {};
@@ -436,7 +713,9 @@ template<> struct fex_gen_config<vkCmdSetPerformanceOverrideINTEL> {};
 template<> struct fex_gen_config<vkAcquirePerformanceConfigurationINTEL> {};
 template<> struct fex_gen_config<vkReleasePerformanceConfigurationINTEL> {};
 template<> struct fex_gen_config<vkQueueSetPerformanceConfigurationINTEL> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkPerformanceValueDataINTEL
 template<> struct fex_gen_config<vkGetPerformanceParameterINTEL> {};
+#endif
 template<> struct fex_gen_config<vkSetLocalDimmingAMD> {};
 template<> struct fex_gen_config<vkGetBufferDeviceAddressEXT> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceToolPropertiesEXT> {};
@@ -478,30 +757,44 @@ template<> struct fex_gen_config<vkCmdSetVertexInputEXT> {};
 template<> struct fex_gen_config<vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI> {};
 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<> struct fex_gen_config<vkCmdSetPatchControlPointsEXT> {};
 template<> struct fex_gen_config<vkCmdSetRasterizerDiscardEnableEXT> {};
 template<> struct fex_gen_config<vkCmdSetDepthBiasEnableEXT> {};
 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<> struct fex_gen_config<vkCmdDrawMultiIndexedEXT> {};
 template<> struct fex_gen_config<vkCreateMicromapEXT> {};
 template<> struct fex_gen_config<vkDestroyMicromapEXT> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkCmdBuildMicromapsEXT> {};
 template<> struct fex_gen_config<vkBuildMicromapsEXT> {};
+#endif
 template<> struct fex_gen_config<vkCopyMicromapEXT> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkCopyMicromapToMemoryEXT> {};
 template<> struct fex_gen_config<vkCopyMemoryToMicromapEXT> {};
+#endif
 template<> struct fex_gen_config<vkWriteMicromapsPropertiesEXT> {};
+template<> struct fex_gen_param<vkWriteMicromapsPropertiesEXT, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdCopyMicromapEXT> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkCmdCopyMicromapToMemoryEXT> {};
 template<> struct fex_gen_config<vkCmdCopyMemoryToMicromapEXT> {};
+#endif
 template<> struct fex_gen_config<vkCmdWriteMicromapsPropertiesEXT> {};
 template<> struct fex_gen_config<vkGetDeviceMicromapCompatibilityEXT> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkGetMicromapBuildSizesEXT> {};
+#endif
 template<> struct fex_gen_config<vkSetDeviceMemoryPriorityEXT> {};
 template<> struct fex_gen_config<vkGetDescriptorSetLayoutHostMappingInfoVALVE> {};
 template<> struct fex_gen_config<vkGetDescriptorSetHostMappingVALVE> {};
@@ -547,23 +840,33 @@ template<> struct fex_gen_config<vkGetFramebufferTilePropertiesQCOM> {};
 template<> struct fex_gen_config<vkGetDynamicRenderingTilePropertiesQCOM> {};
 template<> struct fex_gen_config<vkCreateAccelerationStructureKHR> {};
 template<> struct fex_gen_config<vkDestroyAccelerationStructureKHR> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkCmdBuildAccelerationStructuresKHR> {};
 template<> struct fex_gen_config<vkCmdBuildAccelerationStructuresIndirectKHR> {};
 template<> struct fex_gen_config<vkBuildAccelerationStructuresKHR> {};
+#endif
 template<> struct fex_gen_config<vkCopyAccelerationStructureKHR> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkCopyAccelerationStructureToMemoryKHR> {};
 template<> struct fex_gen_config<vkCopyMemoryToAccelerationStructureKHR> {};
+#endif
 template<> struct fex_gen_config<vkWriteAccelerationStructuresPropertiesKHR> {};
+template<> struct fex_gen_param<vkWriteAccelerationStructuresPropertiesKHR, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdCopyAccelerationStructureKHR> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkCmdCopyAccelerationStructureToMemoryKHR> {};
 template<> struct fex_gen_config<vkCmdCopyMemoryToAccelerationStructureKHR> {};
+#endif
 template<> struct fex_gen_config<vkGetAccelerationStructureDeviceAddressKHR> {};
 template<> struct fex_gen_config<vkCmdWriteAccelerationStructuresPropertiesKHR> {};
 template<> struct fex_gen_config<vkGetDeviceAccelerationStructureCompatibilityKHR> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkGetAccelerationStructureBuildSizesKHR> {};
+#endif
 template<> struct fex_gen_config<vkCmdTraceRaysKHR> {};
 template<> struct fex_gen_config<vkCreateRayTracingPipelinesKHR> {};
 template<> struct fex_gen_config<vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> {};
+template<> struct fex_gen_param<vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdTraceRaysIndirectKHR> {};
 template<> struct fex_gen_config<vkGetRayTracingShaderGroupStackSizeKHR> {};
 template<> struct fex_gen_config<vkCmdSetRayTracingPipelineStackSizeKHR> {};
@@ -576,7 +879,9 @@ template<> struct fex_gen_config<vkAcquireXlibDisplayEXT> {};
 template<> struct fex_gen_config<vkGetRandROutputDisplayEXT> {};
 
 // vulkan_wayland.h
+#endif
 template<> struct fex_gen_config<vkCreateWaylandSurfaceKHR> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetPhysicalDeviceWaylandPresentationSupportKHR> {};
 
 // vulkan_xcb.h
@@ -586,4 +891,5 @@ template<> struct fex_gen_config<vkGetPhysicalDeviceXcbPresentationSupportKHR> {
 // vulkan_xlib.h
 template<> struct fex_gen_config<vkCreateXlibSurfaceKHR> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceXlibPresentationSupportKHR> {};
+#endif
 } // namespace internal
diff --git a/ThunkLibs/libwayland-client/Guest.cpp b/ThunkLibs/libwayland-client/Guest.cpp
index 5f8fb7e996..067f586b5f 100644
--- a/ThunkLibs/libwayland-client/Guest.cpp
+++ b/ThunkLibs/libwayland-client/Guest.cpp
@@ -14,14 +14,14 @@ tags: thunklibs|wayland-client
 //       initializers. There is a workaround to enable late initialization anyway in OnInit.
 // NOTE: We only need to do this for interfaces exported by libwayland-client itself. Interfaces
 //       defined by external libraries work fine.
-extern "C" const wl_interface wl_output_interface {};
-extern "C" const wl_interface wl_shm_pool_interface {};
-extern "C" const wl_interface wl_pointer_interface {};
-extern "C" const wl_interface wl_compositor_interface {};
-extern "C" const wl_interface wl_shm_interface {};
-extern "C" const wl_interface wl_registry_interface {};
-extern "C" const wl_interface wl_buffer_interface {};
-extern "C" const wl_interface wl_seat_interface {};
+extern "C" const wl_interface wl_output_interface{};
+extern "C" const wl_interface wl_shm_pool_interface{};
+extern "C" const wl_interface wl_pointer_interface{};
+extern "C" const wl_interface wl_compositor_interface{};
+extern "C" const wl_interface wl_shm_interface{};
+extern "C" const wl_interface wl_registry_interface{};
+extern "C" const wl_interface wl_buffer_interface{};
+extern "C" const wl_interface wl_seat_interface{};
 extern "C" const wl_interface wl_surface_interface {};
 extern "C" const wl_interface wl_keyboard_interface {};
 extern "C" const wl_interface wl_callback_interface {};
@@ -37,12 +37,13 @@ extern "C" const wl_interface wl_callback_interface {};
 
 #include "common/Guest.h"
 
-#include "thunkgen_guest_libwayland-client.inl"
+#include <map>
 
-struct wl_proxy_private {
-  wl_interface* interface;
-  // Other data members omitted
-};
+#include <stdarg.h>
+
+#include <sys/mman.h>
+
+#include "thunkgen_guest_libwayland-client.inl"
 
 // See wayland-util.h for documentation on protocol message signatures
 template<char> struct ArgType;
@@ -56,37 +57,31 @@ template<> struct ArgType<'f'> { using type = wl_fixed_t; };
 template<> struct ArgType<'h'> { using type = int32_t; }; // fd?
 
 template<char... Signature>
-static void* WaylandAllocateHostTrampolineForGuestListener(void (*callback)()) {
+static uint64_t WaylandAllocateHostTrampolineForGuestListener(void (*callback)()) {
   using cb = void(void*, wl_proxy*, typename ArgType<Signature>::type...);
-  return (void*)AllocateHostTrampolineForGuestFunction((cb*)callback);
+  return (uint64_t)(uintptr_t)(void*)AllocateHostTrampolineForGuestFunction((cb*)callback);
 }
 
 #define WL_CLOSURE_MAX_ARGS 20
 
-// Per-proxy list of callbacks set up via wl_proxy_add_listener.
-// These tables store the host-callable trampolines to the actual listener
-// callbacks provided by the guest application.
-// NOTE: There can only be one listener per proxy. Wayland will return an error
-//       if wl_proxy_add_listener is called twice.
-// NOTE: Entries should be removed in wl_destroy_proxy. Since proxy wrappers do
-//       not use their own listeners, wl_proxy_wrapper_destroy does not need to
-//       be customized.
-static std::unordered_map<wl_proxy*, std::array<void*, WL_CLOSURE_MAX_ARGS>> proxy_listeners;
-
 extern "C" int wl_proxy_add_listener(wl_proxy *proxy,
       void (**callback)(void), void *data) {
-  auto interface = ((wl_proxy_private*)proxy)->interface;
 
-  // NOTE: This table must remain valid past the return of this function.
-  auto& host_callbacks = proxy_listeners[proxy];
+  // NOTE: This pointer must remain valid past the return of this function.
+  // TODO: What's a good way to manage the lifetime of this?
+  auto& host_callbacks = *new std::array<uint64_t, WL_CLOSURE_MAX_ARGS>;
+
 
-  for (int i = 0; i < ((wl_proxy_private*)proxy)->interface->event_count; ++i) {
-    auto signature_view = std::string_view { interface->events[i].signature };
+// TODO: Fixup for 32-bit...
+  for (int i = 0; i < fex_wl_get_interface_event_count(proxy); ++i) {
+    char event_signature[16];
+    fex_wl_get_interface_event_signature(proxy, i, event_signature);
+    auto signature2 = std::string_view { event_signature };
 
     // A leading number indicates the minimum protocol version
     uint32_t since_version = 0;
-    auto [ptr, res] = std::from_chars(signature_view.begin(), signature_view.end(), since_version, 10);
-    std::string signature { ptr, &*signature_view.end() };
+    auto [ptr, res] = std::from_chars(signature2.begin(), signature2.end(), since_version, 10);
+    auto signature = std::string { signature2.substr(ptr - signature2.begin()) };
 
     // ? just indicates that the argument may be null, so it doesn't change the signature
     signature.erase(std::remove(signature.begin(), signature.end(), '?'), signature.end());
@@ -185,7 +180,7 @@ extern "C" int wl_proxy_add_listener(wl_proxy *proxy,
       // E.g. zwp_text_input_v3::preedit_string
       host_callbacks[i] = WaylandAllocateHostTrampolineForGuestListener<'s', 'i', 'i'>(callback[i]);
     } else {
-      fprintf(stderr, "Unknown wayland signature descriptor \"%s\" for event \"%s\" in interface \"%s\"\n", signature.data(), interface->events[i].name, interface->name);
+      fprintf(stderr, "TODO: Unknown wayland event signature descriptor %s\n", signature.data());
       std::abort();
     }
   }
@@ -193,15 +188,15 @@ extern "C" int wl_proxy_add_listener(wl_proxy *proxy,
   return fexfn_pack_wl_proxy_add_listener(proxy, (void(**)())host_callbacks.data(), data);
 }
 
-extern "C" void wl_proxy_destroy(struct wl_proxy *proxy) {
-  proxy_listeners.erase(proxy);
-  return fexfn_pack_wl_proxy_destroy(proxy);
-}
+struct argument_details {
+  char type;
+  int nullable;
+};
 
-// Adapted from the Wayland sources
-static const char* get_next_argument_type(const char *signature, char &type)
+static const char* get_next_argument(const char *signature, argument_details *details)
 {
-  for (; *signature; ++signature) {
+  details->nullable = 0;
+  for(; *signature; ++signature) {
     switch(*signature) {
     case 'i':
     case 'u':
@@ -211,26 +206,27 @@ static const char* get_next_argument_type(const char *signature, char &type)
     case 'n':
     case 'a':
     case 'h':
-      type = *signature;
+      details->type = *signature;
       return signature + 1;
-
-    default:
-      continue;
+    case '?':
+      details->nullable = 1;
     }
   }
-  type = 0;
+  details->type = '\0';
   return signature;
 }
 
 static void wl_argument_from_va_list(const char *signature, wl_argument *args,
                                      int count, va_list ap) {
+  int i;
+  const char *sig_iter;
+  argument_details arg;
 
-  auto sig_iter = signature;
-  for (int i = 0; i < count; i++) {
-    char arg_type;
-    sig_iter = get_next_argument_type(sig_iter, arg_type);
+  sig_iter = signature;
+  for (i = 0; i < count; i++) {
+    sig_iter = get_next_argument(sig_iter, &arg);
 
-    switch (arg_type) {
+    switch (arg.type) {
     case 'i':
       args[i].i = va_arg(ap, int32_t);
       break;
@@ -266,18 +262,48 @@ extern "C" void wl_proxy_marshal(wl_proxy *proxy, uint32_t opcode, ...) {
   va_list ap;
 
   va_start(ap, opcode);
-#ifdef IS_32BIT_THUNK
-// Must extract signature from host due to different data layout on 32-bit
-#error Not implemented
-#else
-  wl_argument_from_va_list(((wl_proxy_private*)proxy)->interface->methods[opcode].signature,
-                           args, WL_CLOSURE_MAX_ARGS, ap);
-#endif
+  // This is equivalent to reading ((wl_proxy_private*)proxy)->interface->methods[opcode].signature on 64-bit.
+  // On 32-bit, the data layout differs between host and guest however, so we let the host extract the data.
+  char signature[64];
+  fex_wl_get_method_signature(proxy, opcode, signature);
+  wl_argument_from_va_list(signature, args, WL_CLOSURE_MAX_ARGS, ap);
   va_end(ap);
 
   wl_proxy_marshal_array(proxy, opcode, args);
 }
 
+extern "C" wl_proxy *wl_proxy_marshal_constructor(wl_proxy *proxy, uint32_t opcode,
+           const wl_interface *interface, ...) {
+  wl_argument args[WL_CLOSURE_MAX_ARGS];
+  va_list ap;
+
+  va_start(ap, interface);
+  // This is equivalent to reading ((wl_proxy_private*)proxy)->interface->methods[opcode].signature on 64-bit.
+  // On 32-bit, the data layout differs between host and guest however, so we let the host extract the data.
+  char signature[64];
+  fex_wl_get_method_signature(proxy, opcode, signature);
+  wl_argument_from_va_list(signature, args, WL_CLOSURE_MAX_ARGS, ap);
+  va_end(ap);
+
+  return wl_proxy_marshal_array_constructor(proxy, opcode, args, interface);
+}
+
+extern "C" wl_proxy *wl_proxy_marshal_constructor_versioned(wl_proxy *proxy, uint32_t opcode,
+           const wl_interface *interface, uint32_t version, ...) {
+  wl_argument args[WL_CLOSURE_MAX_ARGS];
+  va_list ap;
+
+  va_start(ap, version);
+  // This is equivalent to reading ((wl_proxy_private*)proxy)->interface->methods[opcode].signature on 64-bit.
+  // On 32-bit, the data layout differs between host and guest however, so we let the host extract the data.
+  char signature[64];
+  fex_wl_get_method_signature(proxy, opcode, signature);
+  wl_argument_from_va_list(signature, args, WL_CLOSURE_MAX_ARGS, ap);
+  va_end(ap);
+
+  return wl_proxy_marshal_array_constructor_versioned(proxy, opcode, args, interface, version);
+}
+
 extern "C" wl_proxy *wl_proxy_marshal_flags(wl_proxy *proxy, uint32_t opcode,
            const wl_interface *interface,
            uint32_t version,
@@ -286,24 +312,21 @@ extern "C" wl_proxy *wl_proxy_marshal_flags(wl_proxy *proxy, uint32_t opcode,
   va_list ap;
 
   va_start(ap, flags);
-#ifdef IS_32BIT_THUNK
-// Must extract signature from host due to different data layout on 32-bit
-#error Not implemented
-#else
-  wl_argument_from_va_list(((wl_proxy_private*)proxy)->interface->methods[opcode].signature,
-                           args, WL_CLOSURE_MAX_ARGS, ap);
-#endif
+  // This is equivalent to reading ((wl_proxy_private*)proxy)->interface->methods[opcode].signature on 64-bit.
+  // On 32-bit, the data layout differs between host and guest however, so we let the host extract the data.
+  char signature[64];
+  fex_wl_get_method_signature(proxy, opcode, signature);
+  wl_argument_from_va_list(signature, args, WL_CLOSURE_MAX_ARGS, ap);
   va_end(ap);
 
-  // wl_proxy_marshal_array_flags is only available starting from Wayland 1.19.91
-#if WAYLAND_VERSION_MAJOR * 10000 + WAYLAND_VERSION_MINOR * 100 + WAYLAND_VERSION_MICRO >= 11991
   return wl_proxy_marshal_array_flags(proxy, opcode, interface, version, flags, args);
-#else
-  fprintf(stderr, "Host Wayland version is too old to support FEX thunking\n");
-  __builtin_trap();
-#endif
 }
 
+extern "C" void wl_log_set_handler_client(wl_log_func_t handler) {
+  // Ignore
+}
+
+
 void OnInit() {
   fex_wl_exchange_interface_pointer(const_cast<wl_interface*>(&wl_output_interface), "wl_output");
   fex_wl_exchange_interface_pointer(const_cast<wl_interface*>(&wl_shm_pool_interface), "wl_shm_pool");
diff --git a/ThunkLibs/libwayland-client/Host.cpp b/ThunkLibs/libwayland-client/Host.cpp
index 84ba5e5571..8c471bb908 100644
--- a/ThunkLibs/libwayland-client/Host.cpp
+++ b/ThunkLibs/libwayland-client/Host.cpp
@@ -5,6 +5,7 @@ tags: thunklibs|wayland-client
 */
 
 #include <string_view>
+#include <unordered_map>
 #include <wayland-client.h>
 
 #include <stdio.h>
@@ -21,13 +22,286 @@ tags: thunklibs|wayland-client
 #include <map>
 #include <string>
 
+#include <ranges>
+
+template<>
+struct guest_layout<wl_argument> {
+#ifdef IS_32BIT_THUNK
+  using type = uint32_t;
+#else
+  using type = wl_argument;
+#endif
+  type data;
+
+  // TODO: Make this conversion explicit
+  guest_layout& operator=(const wl_argument from) {
+#ifdef IS_32BIT_THUNK
+    data = from.u;
+#else
+    data = from;
+#endif
+    return *this;
+  }
+};
+
+
 #include "thunkgen_host_libwayland-client.inl"
 
+// Maps guest interface to host_interfaces
+static std::map<void*, wl_interface*> guest_to_host_interface;
+
 struct wl_proxy_private {
   wl_interface* interface;
   // Other data members omitted
 };
 
+static wl_interface* lookup_wl_interface(const wl_interface* interface);
+
+#ifdef IS_32BIT_THUNK
+static void repack_guest_wl_interface_to_host(const wl_interface* guest_interface, wl_interface* host_interface) {
+  struct guest_wl_message {
+    guest_layout<char*> name;
+    guest_layout<char*> signature;
+    guest_layout<wl_interface**> types;
+  };
+
+  // Name pointer (offset 0) can safely be zero-extended
+  host_interface->name = (const char*)(uintptr_t)(uint32_t)reinterpret_cast<uintptr_t>(guest_interface->name);
+  memcpy(&host_interface->version, reinterpret_cast<const char*>(guest_interface) + 4, 4);
+  memcpy(&host_interface->method_count, reinterpret_cast<const char*>(guest_interface) + 8, 4);
+  // TODO: Manage lifetime of this memory?
+  host_interface->methods = new wl_message[host_interface->method_count];
+  memset((void*)host_interface->methods, 0, sizeof(wl_message) * host_interface->method_count);
+  for (int i = 0; i < host_interface->method_count; ++i) {
+    auto guest_method = &((*(guest_wl_message**)(reinterpret_cast<const char*>(guest_interface) + 12))[i]);
+    guest_method = (guest_wl_message*)((uintptr_t)guest_method & 0xffffffff);
+    // Sign-extend these pointers
+    auto name_ptr = guest_method->name.get_pointer();
+    memcpy((void*)&host_interface->methods[i].name, &name_ptr, sizeof(name_ptr));
+    auto sig_ptr = guest_method->signature.get_pointer();
+    memcpy((void*)&host_interface->methods[i].signature, &sig_ptr, sizeof(sig_ptr));
+
+    // TODO: Handle zero-argument case... can't use new with 0 elements!
+    auto num_types = std::ranges::count_if(std::string_view { host_interface->methods[i].signature }, [](char c) { return std::isalpha(c); });
+    auto types = new wl_interface*[num_types];
+    for (int type = 0; type < num_types; ++type) {
+      uintptr_t guest_interface_addr = ((uint32_t*)(uintptr_t)guest_method->types.data)[type];
+      types[type] = guest_interface_addr ? lookup_wl_interface(reinterpret_cast<const wl_interface*>(guest_interface_addr)) : nullptr;
+      fprintf(stderr, "  METHOD %d type %d: %p\n", i, type, types[type]);
+    }
+    memcpy((void*)&host_interface->methods[i].types, &types, sizeof(types));
+  }
+
+  memcpy(&host_interface->event_count, reinterpret_cast<const char*>(guest_interface) + 16, sizeof(host_interface->event_count));
+  // TODO: Manage lifetime of this memory?
+  host_interface->events = new wl_message[host_interface->event_count];
+  memset((void*)host_interface->events, 0, sizeof(wl_message) * host_interface->event_count);
+  for (int i = 0; i < host_interface->event_count; ++i) {
+    auto guest_event = &((*(guest_wl_message**)(reinterpret_cast<const char*>(guest_interface) + 20))[i]);
+    guest_event = (guest_wl_message*)((uintptr_t)guest_event & 0xffffffff);
+    // Sign-extend these pointers
+    auto name_ptr = guest_event->name.get_pointer();
+    memcpy((void*)&host_interface->events[i].name, &name_ptr, sizeof(name_ptr));
+    auto sig_ptr = guest_event->signature.get_pointer();
+    memcpy((void*)&host_interface->events[i].signature, &sig_ptr, sizeof(sig_ptr));
+
+    auto num_types = std::ranges::count_if(std::string_view { host_interface->events[i].signature }, [](char c) { return std::isalpha(c); });
+    auto types = new wl_interface*[num_types];
+    for (int type = 0; type < num_types; ++type) {
+      uintptr_t guest_interface_addr = ((uint32_t*)(uintptr_t)guest_event->types.data)[type];
+      types[type] = guest_interface_addr ? lookup_wl_interface(reinterpret_cast<const wl_interface*>(guest_interface_addr)) : nullptr;
+    }
+    memcpy((void*)&host_interface->events[i].types, &types, sizeof(types));
+  }
+}
+#endif
+
+// Maps guest interface pointers to host pointers
+wl_interface* lookup_wl_interface(const wl_interface* interface) {
+  // Used e.g. for wl_shm_pool_destroy
+  if (interface == nullptr) {
+    return nullptr;
+  }
+
+  if (!guest_to_host_interface.count((void*)interface)) {
+  bool is_host = (uint32_t)interface->method_count < 0x1000 && (uint32_t)interface->event_count < 0x1000;
+    fprintf(stderr, "Unknown wayland interface %p, adding to registry (as %s)\n", interface, is_host ? "host" : "guest");
+    auto [host_interface_it, inserted] = guest_to_host_interface.emplace((void*)interface, new wl_interface);
+#ifdef IS_32BIT_THUNK
+if ((uint32_t)interface->method_count < 0x1000 && (uint32_t)interface->event_count < 0x1000) {
+  // This is actually a host interface somehow reaching this function (otherwise the "method" pointer would bleed into method_count). This doesn't need repacking.
+  // TODO: Investigate if this can be avoided
+  memcpy(host_interface_it->second, interface, sizeof(wl_interface));
+} else {
+  wl_interface* host_interface = host_interface_it->second;
+  repack_guest_wl_interface_to_host(interface, host_interface);
+}
+#else
+    memcpy(host_interface_it->second, interface, sizeof(wl_interface));
+#endif
+  }
+
+  return guest_to_host_interface.at((void*)interface);
+}
+
+// TODO: Reduce code duplication between this and its _flags variant
+extern "C" void
+fexfn_impl_libwayland_client_wl_proxy_marshal_array(
+            wl_proxy *proxy, uint32_t opcode,
+            guest_layout<wl_argument*> args) {
+#define WL_CLOSURE_MAX_ARGS 20
+  std::array<wl_argument, WL_CLOSURE_MAX_ARGS> host_args;
+  for (int i = 0; i < host_args.size(); ++i) {
+    // NOTE: wl_argument can store a pointer argument, so for 32-bit guests
+    //       we need to make sure the upper 32-bits are explicitly zeroed
+    std::memset(&host_args[i], 0, sizeof(host_args[i]));
+    std::memcpy(&host_args[i], &args.get_pointer()[i], sizeof(args.get_pointer()[i]));
+  }
+
+  fexldr_ptr_libwayland_client_wl_proxy_marshal_array(proxy, opcode, host_args.data());
+}
+
+extern "C" wl_proxy*
+fexfn_impl_libwayland_client_wl_proxy_marshal_array_constructor_versioned(
+            wl_proxy *proxy, uint32_t opcode,
+            guest_layout<wl_argument*> args,
+            const wl_interface *interface,
+            uint32_t version) {
+  interface = lookup_wl_interface(interface);
+
+  // NOTE: "interface" and "name" are the first members of their respective parent structs, so this is safe to read even on 32-bit
+  if (((wl_proxy_private*)proxy)->interface->name == std::string_view { "wl_registry" }) {
+    auto& host_interface = guest_to_host_interface[(void*)interface];
+    if (!host_interface) {
+      host_interface = new wl_interface;
+#ifdef IS_32BIT_THUNK
+      if ((uint32_t)interface->method_count < 0x1000 && (uint32_t)interface->event_count < 0x1000) {
+        // This is actually a host interface somehow reaching this function (otherwise the "method" pointer would bleed into method_count). This doesn't need repacking.
+        // TODO: Investigate if this can be avoided
+        memcpy(host_interface, interface, sizeof(wl_interface));
+      } else {
+        repack_guest_wl_interface_to_host(interface, host_interface);
+      }
+#else
+      memcpy(host_interface, interface, sizeof(wl_interface));
+#endif
+    }
+  }
+
+#define WL_CLOSURE_MAX_ARGS 20
+  std::array<wl_argument, WL_CLOSURE_MAX_ARGS> host_args;
+  for (int i = 0; i < host_args.size(); ++i) {
+    // NOTE: wl_argument can store a pointer argument, so for 32-bit guests
+    //       we need to make sure the upper 32-bits are explicitly zeroed
+    std::memset(&host_args[i], 0, sizeof(host_args[i]));
+    std::memcpy(&host_args[i], &args.get_pointer()[i], sizeof(args.get_pointer()[i]));
+  }
+
+  return fexldr_ptr_libwayland_client_wl_proxy_marshal_array_constructor_versioned(proxy, opcode, host_args.data(), interface, version);
+}
+
+extern "C" wl_proxy*
+fexfn_impl_libwayland_client_wl_proxy_marshal_array_constructor(
+            wl_proxy *proxy, uint32_t opcode,
+            guest_layout<wl_argument*> args,
+            const wl_interface *interface) {
+  interface = lookup_wl_interface(interface);
+
+  // NOTE: "interface" and "name" are the first members of their respective parent structs, so this is safe to read even on 32-bit
+  if (((wl_proxy_private*)proxy)->interface->name == std::string_view { "wl_registry" }) {
+    auto& host_interface = guest_to_host_interface[(void*)interface];
+    if (!host_interface) {
+      host_interface = new wl_interface;
+#ifdef IS_32BIT_THUNK
+      if ((uint32_t)interface->method_count < 0x1000 && (uint32_t)interface->event_count < 0x1000) {
+        // This is actually a host interface somehow reaching this function (otherwise the "method" pointer would bleed into method_count). This doesn't need repacking.
+        // TODO: Investigate if this can be avoided
+        memcpy(host_interface, interface, sizeof(wl_interface));
+      } else {
+        repack_guest_wl_interface_to_host(interface, host_interface);
+      }
+#else
+      memcpy(host_interface, interface, sizeof(wl_interface));
+#endif
+    }
+  }
+
+#define WL_CLOSURE_MAX_ARGS 20
+  std::array<wl_argument, WL_CLOSURE_MAX_ARGS> host_args;
+  for (int i = 0; i < host_args.size(); ++i) {
+    // NOTE: wl_argument can store a pointer argument, so for 32-bit guests
+    //       we need to make sure the upper 32-bits are explicitly zeroed
+    std::memset(&host_args[i], 0, sizeof(host_args[i]));
+    std::memcpy(&host_args[i], &args.get_pointer()[i], sizeof(args.get_pointer()[i]));
+  }
+
+  return fexldr_ptr_libwayland_client_wl_proxy_marshal_array_constructor(proxy, opcode, host_args.data(), interface);
+}
+
+extern "C" wl_proxy*
+fexfn_impl_libwayland_client_wl_proxy_marshal_array_flags(
+            wl_proxy *proxy, uint32_t opcode,
+            const wl_interface *interface,
+            uint32_t version, uint32_t flags,
+            guest_layout<wl_argument*> args) {
+  interface = lookup_wl_interface(interface);
+
+  // NOTE: "interface" and "name" are the first members of their respective parent structs, so this is safe to read even on 32-bit
+  if (((wl_proxy_private*)proxy)->interface->name == std::string_view { "wl_registry" }) {
+    auto& host_interface = guest_to_host_interface[(void*)interface];
+    if (!host_interface) {
+      host_interface = new wl_interface;
+#ifdef IS_32BIT_THUNK
+      if ((uint32_t)interface->method_count < 0x1000 && (uint32_t)interface->event_count < 0x1000) {
+        // This is actually a host interface somehow reaching this function (otherwise the "method" pointer would bleed into method_count). This doesn't need repacking.
+        // TODO: Investigate if this can be avoided
+        memcpy(host_interface, interface, sizeof(wl_interface));
+      } else {
+        repack_guest_wl_interface_to_host(interface, host_interface);
+      }
+#else
+      memcpy(host_interface, interface, sizeof(wl_interface));
+#endif
+    }
+  }
+
+#define WL_CLOSURE_MAX_ARGS 20
+  std::array<wl_argument, WL_CLOSURE_MAX_ARGS> host_args;
+  for (int i = 0; i < host_args.size(); ++i) {
+    // NOTE: wl_argument can store a pointer argument, so for 32-bit guests
+    //       we need to make sure the upper 32-bits are explicitly zeroed
+    std::memset(&host_args[i], 0, sizeof(host_args[i]));
+    std::memcpy(&host_args[i], &args.get_pointer()[i], sizeof(args.get_pointer()[i]));
+  }
+
+  return fexldr_ptr_libwayland_client_wl_proxy_marshal_array_flags(proxy, opcode, interface, version, flags, host_args.data());
+}
+
+// Generalization of CallbackUnpack::CallGuestPtr that repacks an wl_array parameter
+// TODO: Provide a generic solution for this...
+template<typename Result, typename... Args>
+static auto CallGuestPtrWithWaylandArray(Args... args, struct wl_array *array) -> Result {
+  GuestcallInfo *guestcall;
+  LOAD_INTERNAL_GUESTPTR_VIA_CUSTOM_ABI(guestcall);
+
+  // TODO: What lifetime does this have? Can it be stack-allocated instead?
+  // TODO: Cleanup memory if heap allocation is indeed necessary
+  guest_layout<wl_array>* guest_array = new guest_layout<wl_array>;
+  guest_array->data.size = array->size;
+  guest_array->data.alloc = array->alloc;
+  guest_array->data.data = array->data;
+  guest_layout<wl_array*> guest_array_ptr = { .data = static_cast<guest_layout<wl_array*>::type>(reinterpret_cast<uintptr_t>(guest_array)) };
+
+  PackedArguments<Result, guest_layout<Args>..., guest_layout<wl_array*>> packed_args = {
+    to_guest(to_host_layout(args))..., guest_array_ptr
+  };
+  guestcall->CallCallback(guestcall->GuestUnpacker, guestcall->GuestTarget, &packed_args);
+
+  if constexpr (!std::is_void_v<Result>) {
+    return packed_args.rv;
+  }
+}
+
 // See wayland-util.h for documentation on protocol message signatures
 template<char> struct ArgType;
 template<> struct ArgType<'s'> { using type = const char*; };
@@ -46,8 +320,13 @@ static void WaylandFinalizeHostTrampolineForGuestListener(void (*callback)()) {
 }
 
 extern "C" int fexfn_impl_libwayland_client_wl_proxy_add_listener(struct wl_proxy *proxy,
-      void (**callback)(void), void *data) {
-  auto guest_interface = ((wl_proxy_private*)proxy)->interface;
+      guest_layout<void (**)(void)> callback, guest_layout<void *> data) {
+
+  auto guest_interface = lookup_wl_interface(((wl_proxy_private*)proxy)->interface);
+
+  // Drop upper 32-bits, since they are likely garbage... TODO: Let the repacker do this, or check if it's already done even
+//  auto callback2 = (uint32_t*)(uintptr_t)(uint32_t)(uintptr_t)callback;
+  auto callback2 = (void(**)(void))callback.get_pointer();
 
   for (int i = 0; i < guest_interface->event_count; ++i) {
     auto signature_view = std::string_view { guest_interface->events[i].signature };
@@ -55,116 +334,140 @@ extern "C" int fexfn_impl_libwayland_client_wl_proxy_add_listener(struct wl_prox
     // A leading number indicates the minimum protocol version
     uint32_t since_version = 0;
     auto [ptr, res] = std::from_chars(signature_view.begin(), signature_view.end(), since_version, 10);
-    std::string signature { ptr, &*signature_view.end() };
+    auto signature = std::string { signature_view.substr(ptr - signature_view.begin()) };
 
     // ? just indicates that the argument may be null, so it doesn't change the signature
     signature.erase(std::remove(signature.begin(), signature.end(), '?'), signature.end());
 
+    auto callback = callback2[i];
+
     if (signature == "") {
       // E.g. xdg_toplevel::close
-      WaylandFinalizeHostTrampolineForGuestListener<>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<>(callback);
     } else if (signature == "a") {
       // E.g. xdg_toplevel::wm_capabilities
-      WaylandFinalizeHostTrampolineForGuestListener<'a'>(callback[i]);
+      FEXCore::FinalizeHostTrampolineForGuestFunction(
+          (FEXCore::HostToGuestTrampolinePtr*)callback,
+          (void*)CallGuestPtrWithWaylandArray<void, void*, wl_proxy*>);
     } else if (signature == "hu") {
       // E.g. zwp_linux_dmabuf_feedback_v1::format_table
-      WaylandFinalizeHostTrampolineForGuestListener<'h', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'h', 'u'>(callback);
     } else if (signature == "i") {
       // E.g. wl_output_listener::scale
-      WaylandFinalizeHostTrampolineForGuestListener<'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'i'>(callback);
     } else if (signature == "if") {
       // E.g. wl_touch_listener::orientation
-      WaylandFinalizeHostTrampolineForGuestListener<'i', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'i', 'f'>(callback);
     } else if (signature == "iff") {
       // E.g. wl_touch_listener::shape
-      WaylandFinalizeHostTrampolineForGuestListener<'i', 'f', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'i', 'f', 'f'>(callback);
     } else if (signature == "ii") {
       // E.g. xdg_toplevel::configure_bounds
-      WaylandFinalizeHostTrampolineForGuestListener<'i', 'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'i', 'i'>(callback);
     } else if (signature == "iia") {
       // E.g. xdg_toplevel::configure
-      WaylandFinalizeHostTrampolineForGuestListener<'i', 'i', 'a'>(callback[i]);
+      FEXCore::FinalizeHostTrampolineForGuestFunction(
+          (FEXCore::HostToGuestTrampolinePtr*)callback,
+          (void*)CallGuestPtrWithWaylandArray<void, void*, wl_proxy*, int32_t, int32_t>);
     } else if (signature == "iiiiissi") {
       // E.g. wl_output_listener::geometry
-      WaylandFinalizeHostTrampolineForGuestListener<'i', 'i', 'i', 'i', 'i', 's', 's', 'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'i', 'i', 'i', 'i', 'i', 's', 's', 'i'>(callback);
     } else if (signature == "n") {
       // E.g. wl_data_device_listener::data_offer
-      WaylandFinalizeHostTrampolineForGuestListener<'n'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'n'>(callback);
     } else if (signature == "o") {
       // E.g. wl_data_device_listener::selection
-      WaylandFinalizeHostTrampolineForGuestListener<'o'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'o'>(callback);
     } else if (signature == "u") {
       // E.g. wl_registry::global_remove
-      WaylandFinalizeHostTrampolineForGuestListener<'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u'>(callback);
     } else if (signature == "uff") {
       // E.g. wl_pointer_listener::motion
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'f', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'f', 'f'>(callback);
     } else if (signature == "uhu") {
       // E.g. wl_keyboard_listener::keymap
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'h', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'h', 'u'>(callback);
     } else if (signature == "ui") {
       // E.g. wl_pointer_listener::axis_discrete
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'i'>(callback);
     } else if (signature == "uiff") {
       // E.g. wl_touch_listener::motion
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'i', 'f', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'i', 'f', 'f'>(callback);
     } else if (signature == "uiii") {
       // E.g. wl_output_listener::mode
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'i', 'i', 'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'i', 'i', 'i'>(callback);
     } else if (signature == "uo") {
       // E.g. wl_pointer_listener::leave
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o'>(callback);
     } else if (signature == "uoa") {
       // E.g. wl_keyboard_listener::enter
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'a'>(callback[i]);
+      FEXCore::FinalizeHostTrampolineForGuestFunction(
+          (FEXCore::HostToGuestTrampolinePtr*)callback,
+          (void*)CallGuestPtrWithWaylandArray<void, void*, wl_proxy*, uint32_t, wl_surface*>);
     } else if (signature == "uoff") {
       // E.g. wl_pointer_listener::enter
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'f', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'f', 'f'>(callback);
     } else if (signature == "uoffo") {
       // E.g. wl_data_device_listener::enter
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'f', 'f', 'o'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'f', 'f', 'o'>(callback);
     } else if (signature == "usu") {
       // E.g. wl_registry::global
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 's', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 's', 'u'>(callback);
     } else if (signature == "uu") {
       // E.g. wl_pointer_listener::axis_stop
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u'>(callback);
     } else if (signature == "uuf") {
       // E.g. wl_pointer_listener::axis
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'f'>(callback);
     } else if (signature == "uui") {
       // E.g. wl_touch_listener::up
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'i'>(callback);
     } else if (signature == "uuoiff") {
       // E.g. wl_touch_listener::down
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'o', 'i', 'f', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'o', 'i', 'f', 'f'>(callback);
     } else if (signature == "uuu") {
       // E.g. zwp_linux_dmabuf_v1::modifier
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'u'>(callback);
     } else if (signature == "uuuu") {
       // E.g. wl_pointer_listener::button
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'u', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'u', 'u'>(callback);
     } else if (signature == "uuuuu") {
       // E.g. wl_keyboard_listener::modifiers
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'u', 'u', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'u', 'u', 'u'>(callback);
     } else if (signature == "s") {
       // E.g. wl_seat::name
-      WaylandFinalizeHostTrampolineForGuestListener<'s'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'s'>(callback);
     } else if (signature == "sii") {
       // E.g. zwp_text_input_v3::preedit_string
-      WaylandFinalizeHostTrampolineForGuestListener<'s', 'i', 'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'s', 'i', 'i'>(callback);
     } else {
       fprintf(stderr, "TODO: Unknown wayland event signature descriptor %s\n", signature.data());
       std::abort();
     }
+
+// TODO: Is this needed?
+//    MakeHostTrampolineForGuestFunctionAsyncCallable(registry_listener.global_remove, 1);
   }
 
   // Pass the original function pointer table to the host wayland library. This ensures the table is valid until the listener is unregistered.
-  return fexldr_ptr_libwayland_client_wl_proxy_add_listener(proxy, callback, data);
+  return fexldr_ptr_libwayland_client_wl_proxy_add_listener(proxy, callback2, (void*)(uintptr_t)data.data);
+}
+
+void* fexfn_impl_libwayland_client_wl_proxy_create_wrapper(guest_layout<void*> void_proxy) {
+  guest_layout<wl_proxy*> proxy;
+  memcpy(&proxy, &void_proxy, sizeof(void_proxy));
+  return fexldr_ptr_libwayland_client_wl_proxy_create_wrapper(host_layout<wl_proxy*> { proxy }.data);
 }
 
-wl_interface* fexfn_impl_libwayland_client_fex_wl_exchange_interface_pointer(wl_interface* guest_interface, char const* name) {
-  auto host_interface = reinterpret_cast<wl_interface*>(dlsym(fexldr_ptr_libwayland_client_so, (std::string { name } + "_interface").c_str()));
+void fexfn_impl_libwayland_client_wl_proxy_wrapper_destroy(guest_layout<void*> void_proxy) {
+  guest_layout<wl_proxy*> proxy;
+  memcpy(&proxy, &void_proxy, sizeof(void_proxy));
+  return fexldr_ptr_libwayland_client_wl_proxy_wrapper_destroy(host_layout<wl_proxy*> { proxy }.data);
+}
+
+wl_interface* fexfn_impl_libwayland_client_fex_wl_exchange_interface_pointer(wl_interface* guest_interface, guest_layout<char const*> name) {
+  auto& host_interface = guest_to_host_interface[(void*)guest_interface];
+  host_interface = reinterpret_cast<wl_interface*>(dlsym(fexldr_ptr_libwayland_client_so, (std::string { (const char*)name.get_pointer() } + "_interface").c_str()));
   if (!host_interface) {
     fprintf(stderr, "Could not find host interface corresponding to %p (%s)\n", guest_interface, name);
     std::abort();
@@ -181,8 +484,36 @@ wl_interface* fexfn_impl_libwayland_client_fex_wl_exchange_interface_pointer(wl_
   }
 
 #ifdef IS_32BIT_THUNK
-// Requires struct repacking for wl_interface
-#error Not implemented
+  // TODO: Do wl_interface symbols from host get allocated in 32-bit memory space? At least add an assert for this!
+  memcpy(guest_interface, host_interface, 4); // name
+  memcpy(reinterpret_cast<char*>(guest_interface) + 4, &host_interface->version, 4);
+  memcpy(reinterpret_cast<char*>(guest_interface) + 8, &host_interface->method_count, 4);
+
+  struct guest_wl_message {
+    guest_layout<char*> name;
+    guest_layout<char*> signature;
+    guest_layout<wl_interface**> types;
+  };
+
+  // TODO: Manage lifetime of this memory?
+  auto guest_methods = new guest_wl_message[host_interface->method_count];
+  for (int i = 0; i < host_interface->method_count; ++i) {
+    guest_methods[i].name.data = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_interface->methods[i].name));
+    guest_methods[i].signature.data = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_interface->methods[i].signature));
+    // TODO: Ugh, this will require more sophisticated fixups...
+    guest_methods[i].types.data = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_interface->methods[i].types));
+  }
+  memcpy(reinterpret_cast<char*>(guest_interface) + 12, &guest_methods, 4);
+
+  auto guest_events = new guest_wl_message[host_interface->event_count];
+  for (int i = 0; i < host_interface->event_count; ++i) {
+    guest_events[i].name.data = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_interface->events[i].name));
+    guest_events[i].signature.data = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_interface->events[i].signature));
+    // TODO: Ugh, this will require more sophisticated fixups...
+    guest_events[i].types.data = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_interface->events[i].types));
+  }
+  memcpy(reinterpret_cast<char*>(guest_interface) + 16, &host_interface->event_count, sizeof(host_interface->event_count));
+  memcpy(reinterpret_cast<char*>(guest_interface) + 20, &guest_events, 4);
 #else
   memcpy(guest_interface, host_interface, sizeof(wl_interface));
 #endif
@@ -193,4 +524,31 @@ wl_interface* fexfn_impl_libwayland_client_fex_wl_exchange_interface_pointer(wl_
   return host_interface;
 }
 
+static wl_interface* get_proxy_interface(wl_proxy* proxy) {
+  // TODO: Use guest_layout/host_layout to do this dance instead
+  uintptr_t interface_addr = reinterpret_cast<uintptr_t>(((wl_proxy_private*)proxy)->interface);
+#ifdef IS_32BIT_THUNK
+  // The pointer has size 4 Zero out upper 4 bytes that might leak in
+  interface_addr &= 0xffffffff;
+#endif
+  return reinterpret_cast<wl_interface*>(interface_addr);
+}
+
+void fexfn_impl_libwayland_client_fex_wl_get_method_signature(wl_proxy* proxy, uint32_t opcode, char* out) {
+  // TODO: Assert proxy comes from the host library
+  strcpy(out, get_proxy_interface(proxy)->methods[opcode].signature);
+}
+
+int fexfn_impl_libwayland_client_fex_wl_get_interface_event_count(wl_proxy* proxy) {
+  return get_proxy_interface(proxy)->event_count;
+}
+
+void fexfn_impl_libwayland_client_fex_wl_get_interface_event_name(wl_proxy* proxy, int i, char* out) {
+  strcpy(out, get_proxy_interface(proxy)->events[i].name);
+}
+
+void fexfn_impl_libwayland_client_fex_wl_get_interface_event_signature(wl_proxy* proxy, int i, char* out) {
+  strcpy(out, ((wl_proxy_private*)proxy)->interface->events[i].signature);
+}
+
 EXPORTS(libwayland_client)
diff --git a/ThunkLibs/libwayland-client/libwayland-client_interface.cpp b/ThunkLibs/libwayland-client/libwayland-client_interface.cpp
index 7371653bc7..f64aaeaae5 100644
--- a/ThunkLibs/libwayland-client/libwayland-client_interface.cpp
+++ b/ThunkLibs/libwayland-client/libwayland-client_interface.cpp
@@ -10,43 +10,86 @@ struct fex_gen_config {
 template<typename>
 struct fex_gen_type {};
 
-template<> struct fex_gen_config<wl_proxy_destroy> : fexgen::custom_guest_entrypoint {};
+// Function, parameter index, parameter type [optional]
+template<auto, int, typename = void>
+struct fex_gen_param {};
+
+template<> struct fex_gen_type<wl_display> : fexgen::opaque_type {};
+template<> struct fex_gen_type<wl_proxy> : fexgen::opaque_type {};
+template<> struct fex_gen_type<wl_interface> : fexgen::opaque_type {};
+
+template<> struct fex_gen_type<wl_event_queue> : fexgen::opaque_type {};
+
+// Passed over Wayland's wire protocol for some functions
+template<> struct fex_gen_type<wl_array> {};
+
+
+template<> struct fex_gen_config<wl_proxy_destroy> {};
 
-template<> struct fex_gen_config<wl_display_cancel_read> {};
 template<> struct fex_gen_config<wl_display_connect> {};
+template<> struct fex_gen_config<wl_display_flush> {};
+template<> struct fex_gen_config<wl_display_cancel_read> {};
 template<> struct fex_gen_config<wl_display_create_queue> {};
 template<> struct fex_gen_config<wl_display_disconnect> {};
 template<> struct fex_gen_config<wl_display_dispatch> {};
 template<> struct fex_gen_config<wl_display_dispatch_pending> {};
 template<> struct fex_gen_config<wl_display_dispatch_queue> {};
 template<> struct fex_gen_config<wl_display_dispatch_queue_pending> {};
-template<> struct fex_gen_config<wl_display_flush> {};
+template<> struct fex_gen_config<wl_display_get_error> {};
 template<> struct fex_gen_config<wl_display_prepare_read> {};
 template<> struct fex_gen_config<wl_display_prepare_read_queue> {};
 template<> struct fex_gen_config<wl_display_read_events> {};
 template<> struct fex_gen_config<wl_display_roundtrip> {};
 template<> struct fex_gen_config<wl_display_roundtrip_queue> {};
+template<> struct fex_gen_config<wl_display_connect_to_fd> {};
 template<> struct fex_gen_config<wl_display_get_fd> {};
 
 template<> struct fex_gen_config<wl_event_queue_destroy> {};
 
 template<> struct fex_gen_config<wl_proxy_add_listener> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint {};
+template<> struct fex_gen_param<wl_proxy_add_listener, 1, void(**)()> : fexgen::ptr_passthrough {};
+// TODO: Assume compatible
+template<> struct fex_gen_param<wl_proxy_add_listener, 2, void*> : fexgen::ptr_passthrough {};
 template<> struct fex_gen_config<wl_proxy_create> {};
-template<> struct fex_gen_config<wl_proxy_create_wrapper> {};
+template<> struct fex_gen_config<wl_proxy_create_wrapper> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<wl_proxy_create_wrapper, 0, void*> : fexgen::ptr_passthrough {}; // Actually a wl_proxy* => convert manually
+template<> struct fex_gen_config<wl_proxy_get_class> {};
+template<> struct fex_gen_config<wl_proxy_get_id> {};
 template<> struct fex_gen_config<wl_proxy_get_tag> {};
 template<> struct fex_gen_config<wl_proxy_get_user_data> {};
+template<> struct fex_gen_config<wl_proxy_set_tag> {};
 template<> struct fex_gen_config<wl_proxy_get_version> {};
 template<> struct fex_gen_config<wl_proxy_set_queue> {};
+//template<> struct fex_gen_param<wl_proxy_set_queue, 1, wl_event_queue *> : fexgen::ptr_passthrough {};
 template<> struct fex_gen_config<wl_proxy_set_tag> {};
+// TODO: This has a void* parameter. Why does 32-bit accept this without annotations?
 template<> struct fex_gen_config<wl_proxy_set_user_data> {};
-template<> struct fex_gen_config<wl_proxy_wrapper_destroy> {};
+template<> struct fex_gen_config<wl_proxy_wrapper_destroy> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<wl_proxy_wrapper_destroy, 0, void*> : fexgen::ptr_passthrough {}; // Actually a wl_proxy* => convert manually
 
-template<> struct fex_gen_config<wl_proxy_marshal_array> {};
-// wl_proxy_marshal_array_flags is only available starting from Wayland 1.19.91
-#if WAYLAND_VERSION_MAJOR * 10000 + WAYLAND_VERSION_MINOR * 100 + WAYLAND_VERSION_MICRO >= 11991
-template<> struct fex_gen_config<wl_proxy_marshal_array_flags> {};
-#endif
+template<> struct fex_gen_config<wl_proxy_marshal_array> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<wl_proxy_marshal_array, 2, wl_argument*> : fexgen::ptr_passthrough {};
+template<> struct fex_gen_config<wl_proxy_marshal_array_constructor> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<wl_proxy_marshal_array_constructor, 2, wl_argument*> : fexgen::ptr_passthrough {};
+template<> struct fex_gen_config<wl_proxy_marshal_array_constructor_versioned> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<wl_proxy_marshal_array_constructor_versioned, 2, wl_argument*> : fexgen::ptr_passthrough {};
+template<> struct fex_gen_config<wl_proxy_marshal_array_flags> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<wl_proxy_marshal_array_flags, 5, wl_argument*> : fexgen::ptr_passthrough {};
 
 // Guest notifies host about its interface. Host returns its corresponding interface pointer
 wl_interface* fex_wl_exchange_interface_pointer(wl_interface*, const char* name);
-template<> struct fex_gen_config<fex_wl_exchange_interface_pointer> : fexgen::custom_host_impl {};
+template<> struct fex_gen_config<fex_wl_exchange_interface_pointer> : fexgen::custom_host_impl/*, fexgen::custom_guest_entrypoint*/ {};
+//template<> struct fex_gen_param<fex_wl_exchange_interface_pointer, 0, wl_interface*> : fexgen::ptr_passthrough {};
+template<> struct fex_gen_param<fex_wl_exchange_interface_pointer, 1, const char*> : fexgen::ptr_passthrough {};
+
+// This is equivalent to reading ((wl_proxy_private*)proxy)->interface->methods[opcode].signature on 64-bit.
+// On 32-bit, the data layout differs between host and guest however, so we let the host extract the data.
+void fex_wl_get_method_signature(wl_proxy*, uint32_t opcode, char*);
+template<> struct fex_gen_config<fex_wl_get_method_signature> : fexgen::custom_host_impl {};
+
+int fex_wl_get_interface_event_count(wl_proxy*);
+template<> struct fex_gen_config<fex_wl_get_interface_event_count> : fexgen::custom_host_impl {};
+void fex_wl_get_interface_event_name(wl_proxy*, int, char*);
+template<> struct fex_gen_config<fex_wl_get_interface_event_name> : fexgen::custom_host_impl {};
+void fex_wl_get_interface_event_signature(wl_proxy*, int, char*);
+template<> struct fex_gen_config<fex_wl_get_interface_event_signature> : fexgen::custom_host_impl {};
diff --git a/ThunkLibs/libxcb-dri2/libxcb-dri2_interface.cpp b/ThunkLibs/libxcb-dri2/libxcb-dri2_interface.cpp
index 07f93f48d3..5a3349c557 100644
--- a/ThunkLibs/libxcb-dri2/libxcb-dri2_interface.cpp
+++ b/ThunkLibs/libxcb-dri2/libxcb-dri2_interface.cpp
@@ -1,12 +1,18 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/dri2.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
 void FEX_xcb_dri2_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-dri3/libxcb-dri3_interface.cpp b/ThunkLibs/libxcb-dri3/libxcb-dri3_interface.cpp
index 0708baf232..07d20da645 100644
--- a/ThunkLibs/libxcb-dri3/libxcb-dri3_interface.cpp
+++ b/ThunkLibs/libxcb-dri3/libxcb-dri3_interface.cpp
@@ -1,12 +1,18 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/dri3.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
 void FEX_xcb_dri3_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-glx/libxcb-glx_interface.cpp b/ThunkLibs/libxcb-glx/libxcb-glx_interface.cpp
index 28f76fccee..64160def59 100644
--- a/ThunkLibs/libxcb-glx/libxcb-glx_interface.cpp
+++ b/ThunkLibs/libxcb-glx/libxcb-glx_interface.cpp
@@ -1,12 +1,18 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/glx.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
 void FEX_xcb_glx_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-present/libxcb-present_interface.cpp b/ThunkLibs/libxcb-present/libxcb-present_interface.cpp
index b1e32b7557..69481998b4 100644
--- a/ThunkLibs/libxcb-present/libxcb-present_interface.cpp
+++ b/ThunkLibs/libxcb-present/libxcb-present_interface.cpp
@@ -1,12 +1,18 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/present.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
 void FEX_xcb_present_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-randr/libxcb-randr_interface.cpp b/ThunkLibs/libxcb-randr/libxcb-randr_interface.cpp
index 4f00b47133..f8eb585cea 100644
--- a/ThunkLibs/libxcb-randr/libxcb-randr_interface.cpp
+++ b/ThunkLibs/libxcb-randr/libxcb-randr_interface.cpp
@@ -1,12 +1,23 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/randr.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
+// Union type (includes pointers, so only compatible across 64-bit architectures)
+#ifndef IS_32BIT_THUNK
+template<> struct fex_gen_type<xcb_randr_notify_data_t> : fexgen::assume_compatible_data_layout {};
+#endif
+
 void FEX_xcb_randr_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-shm/libxcb-shm_interface.cpp b/ThunkLibs/libxcb-shm/libxcb-shm_interface.cpp
index 246c0abee4..46ab5d4fdf 100644
--- a/ThunkLibs/libxcb-shm/libxcb-shm_interface.cpp
+++ b/ThunkLibs/libxcb-shm/libxcb-shm_interface.cpp
@@ -1,12 +1,19 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/shm.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+//template<> struct fex_gen_type<xcb_extension_t> : fexgen::opaque_type {};
+
 void FEX_xcb_shm_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-sync/libxcb-sync_interface.cpp b/ThunkLibs/libxcb-sync/libxcb-sync_interface.cpp
index e810ec0195..5fe072f760 100644
--- a/ThunkLibs/libxcb-sync/libxcb-sync_interface.cpp
+++ b/ThunkLibs/libxcb-sync/libxcb-sync_interface.cpp
@@ -1,12 +1,18 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/sync.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 1;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
 void FEX_xcb_sync_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-xfixes/libxcb-xfixes_interface.cpp b/ThunkLibs/libxcb-xfixes/libxcb-xfixes_interface.cpp
index 3f5c9c1fc1..947da6c19e 100644
--- a/ThunkLibs/libxcb-xfixes/libxcb-xfixes_interface.cpp
+++ b/ThunkLibs/libxcb-xfixes/libxcb-xfixes_interface.cpp
@@ -1,12 +1,18 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/xfixes.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
 void FEX_xcb_xfixes_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb/WorkEventData.h b/ThunkLibs/libxcb/WorkEventData.h
deleted file mode 100644
index c2c09b8e58..0000000000
--- a/ThunkLibs/libxcb/WorkEventData.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-#include <cstdint>
-
-#ifndef GUEST_THUNK_LIBRARY
-#include "../include/common/Host.h"
-#endif
-
-struct CBWork {
-#ifdef GUEST_THUNK_LIBRARY
-  uintptr_t cb;
-#else
-  fex_guest_function_ptr cb;
-#endif
-  void *argsv;
-};
-
diff --git a/ThunkLibs/libxcb/libxcb_Guest.cpp b/ThunkLibs/libxcb/libxcb_Guest.cpp
index c9add3c72c..0241e3068f 100644
--- a/ThunkLibs/libxcb/libxcb_Guest.cpp
+++ b/ThunkLibs/libxcb/libxcb_Guest.cpp
@@ -21,85 +21,12 @@ tags: thunklibs|xcb
 #include <sys/syscall.h>
 
 #include "common/Guest.h"
-#include "WorkEventData.h"
-#include "common/CrossArchEvent.h"
 
 #include <stdarg.h>
 
 #include "thunkgen_guest_libxcb.inl"
 
-static std::thread CBThread{};
-static std::atomic<bool> CBDone{false};
-static std::mutex CBThreadMutex;
-static uint32_t ScreenRefCount;
-
-static CrossArchEvent WaitForWork{};
-static CrossArchEvent WorkDone{};
-static CBWork CBWorkData{};
-
-void FEX_Helper_GiveEvents() {
-  struct {
-    CrossArchEvent *WaitForWork;
-    CrossArchEvent *WorkDone;
-    CBWork *Work;
-  } args;
-
-  args.WaitForWork = &WaitForWork;
-  args.WorkDone = &WorkDone;
-  args.Work = &CBWorkData;
-
-  fexthunks_libxcb_FEX_GiveEvents(&args);
-}
-
-static void CallbackThreadFunc() {
-  // Set the thread name to make it easy to know what thread this is
-  pthread_setname_np(pthread_self(), "xcb:take_socket");
-
-  // Hand the host our helpers
-  FEX_Helper_GiveEvents();
-  while (!CBDone) {
-    WaitForWorkFunc(&WaitForWork);
-    if (CBDone) {
-      return;
-    }
-    typedef void take_xcb_fn_t (void* a_0);
-    auto callback = reinterpret_cast<take_xcb_fn_t*>(CBWorkData.cb);
-
-    // On shutdown then callback can change to nullptr
-    if (callback) {
-      callback(CBWorkData.argsv);
-    }
-    NotifyWorkFunc(&WorkDone);
-  }
-}
-
 extern "C" {
-  void CreateCallback() {
-    std::unique_lock lk{CBThreadMutex};
-    ++ScreenRefCount;
-
-    // Start a guest side thread that allows us to do callbacks from xcb safely
-    if (!CBThread.joinable()) {
-      CBDone = false;
-      CBThread = std::thread(CallbackThreadFunc);
-    }
-  }
-
-  void RemoveCallback() {
-    std::unique_lock lk{CBThreadMutex};
-    --ScreenRefCount;
-
-    // If the new value is 0 then shutdown the work thread.
-    if (ScreenRefCount == 0) {
-      if (CBThread.joinable()) {
-        CBDone = true;
-        NotifyWorkFunc(&WaitForWork);
-        NotifyWorkFunc(&WorkDone);
-        CBThread.join();
-      }
-    }
-  }
-
   xcb_extension_t xcb_big_requests_id = {
     .name = "BIG-REQUESTS",
     .global_id = 0,
@@ -134,7 +61,7 @@ extern "C" {
     if (xcb_get_file_descriptor(ret) != -1) {
       // Only create callback on valid xcb connections.
       // Checking for FD is the easiest way to do this.
-      CreateCallback();
+      //CreateCallback();
     }
     InitializeExtensions(ret);
     return ret;
@@ -142,33 +69,17 @@ extern "C" {
 
   xcb_connection_t * xcb_connect(const char * a_0,int * a_1){
     auto ret = fexfn_pack_xcb_connect(a_0, a_1);
-
-    if (xcb_get_file_descriptor(ret) != -1) {
-      // Only create callback on valid xcb connections.
-      // Checking for FD is the easiest way to do this.
-      CreateCallback();
-    }
     InitializeExtensions(ret);
     return ret;
   }
 
   xcb_connection_t * xcb_connect_to_display_with_auth_info(const char * a_0,xcb_auth_info_t * a_1,int * a_2){
     auto ret = fexfn_pack_xcb_connect_to_display_with_auth_info(a_0, a_1, a_2);
-    if (xcb_get_file_descriptor(ret) != -1) {
-      // Only create callback on valid xcb connections.
-      // Checking for FD is the easiest way to do this.
-      CreateCallback();
-    }
     InitializeExtensions(ret);
     return ret;
   }
 
   void xcb_disconnect(xcb_connection_t * a_0){
-    if (a_0 != nullptr && xcb_get_file_descriptor(a_0) != -1) {
-      // Only decrement callback reference on valid displays.
-      // Checking for FD and nullptr is the easiest way to do this.
-      RemoveCallback();
-    }
     fexfn_pack_xcb_disconnect(a_0);
   }
 
diff --git a/ThunkLibs/libxcb/libxcb_Host.cpp b/ThunkLibs/libxcb/libxcb_Host.cpp
index d634725f1c..8d5083f089 100644
--- a/ThunkLibs/libxcb/libxcb_Host.cpp
+++ b/ThunkLibs/libxcb/libxcb_Host.cpp
@@ -16,33 +16,15 @@ tags: thunklibs|xcb
 #include <xcb/xcb.h>
 #include <xcb/xcbext.h>
 
-#include "common/CrossArchEvent.h"
 #include "common/Host.h"
 #include <dlfcn.h>
 #include <unordered_map>
 
-#include "WorkEventData.h"
-
 #include "thunkgen_host_libxcb.inl"
 
 static void fexfn_impl_libxcb_FEX_xcb_init_extension(xcb_connection_t*, xcb_extension_t*);
 static size_t fexfn_impl_libxcb_FEX_usable_size(void*);
 static void fexfn_impl_libxcb_FEX_free_on_host(void*);
-static void fexfn_impl_libxcb_FEX_GiveEvents(CrossArchEvent*, CrossArchEvent*, CBWork*);
-
-static int fexfn_impl_libxcb_xcb_take_socket(xcb_connection_t * a_0, fex_guest_function_ptr a_1, void * a_2, int a_3, uint64_t * a_4);
-
-struct xcb_take_socket_CB_args {
-  xcb_connection_t * conn;
-  fex_guest_function_ptr CBFunction;
-  void *closure;
-};
-
-CrossArchEvent *WaitForWork{};
-CrossArchEvent *WorkDone{};
-CBWork *Work{};
-
-static std::unordered_map<xcb_connection_t*, xcb_take_socket_CB_args> CBArgs{};
 
 static size_t fexfn_impl_libxcb_FEX_usable_size(void *a_0){
   return malloc_usable_size(a_0);
@@ -52,41 +34,6 @@ static void fexfn_impl_libxcb_FEX_free_on_host(void *a_0){
   free(a_0);
 }
 
-static void fexfn_impl_libxcb_FEX_GiveEvents(CrossArchEvent* a_0, CrossArchEvent* a_1, CBWork* a_2){
-  WaitForWork = a_0;
-  WorkDone = a_1;
-  Work = a_2;
-}
-
-static void xcb_take_socket_cb(void *closure) {
-  xcb_take_socket_CB_args *Args = (xcb_take_socket_CB_args *)closure;
-
-  // Signalling to the guest thread like this allows us to call the callback function from any thread without
-  // creating spurious thread objects inside of FEX
-  Work->cb = Args->CBFunction;
-  Work->argsv = Args->closure;
-  // Tell the thread it has work
-  NotifyWorkFunc(WaitForWork);
-  // Wait for the work to be done
-  WaitForWorkFunc(WorkDone);
-}
-
-static int fexfn_impl_libxcb_xcb_take_socket(xcb_connection_t * a_0, fex_guest_function_ptr a_1, void * a_2, int a_3, uint64_t * a_4){
-  xcb_take_socket_CB_args Args{};
-  Args.conn = a_0;
-  Args.CBFunction = a_1;
-  Args.closure = a_2;
-
-  auto Res = CBArgs.insert_or_assign(a_0, Args);
-
-  return fexldr_ptr_libxcb_xcb_take_socket
-    (a_0,
-     xcb_take_socket_cb,
-     &Res.first->second,
-     a_3,
-     a_4);
-}
-
 static void fexfn_impl_libxcb_FEX_xcb_init_extension(xcb_connection_t * a_0, xcb_extension_t * a_1){
   xcb_extension_t *ext{};
 
diff --git a/ThunkLibs/libxcb/libxcb_interface.cpp b/ThunkLibs/libxcb/libxcb_interface.cpp
index feeff49407..6ac46b0ee0 100644
--- a/ThunkLibs/libxcb/libxcb_interface.cpp
+++ b/ThunkLibs/libxcb/libxcb_interface.cpp
@@ -3,23 +3,27 @@
 #include <xcb/xcb.h>
 #include <xcb/xcbext.h>
 
-#include <common/CrossArchEvent.h>
-#include "WorkEventData.h"
-
 template<auto>
 struct fex_gen_config {
     unsigned version = 1;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<xcb_special_event> : fexgen::opaque_type {};
+
+// Union type with consistent data layout across host/x86/x86-64
+template<> struct fex_gen_type<xcb_client_message_data_t> : fexgen::assume_compatible_data_layout {};
+
 void FEX_xcb_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
-void FEX_GiveEvents(CrossArchEvent*, CrossArchEvent*, CBWork*);
 
 template<> struct fex_gen_config<FEX_xcb_init_extension> : fexgen::custom_host_impl {};
 template<> struct fex_gen_config<FEX_usable_size> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint {};
 template<> struct fex_gen_config<FEX_free_on_host> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint {};
-template<> struct fex_gen_config<FEX_GiveEvents> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint {};
 
 template<> struct fex_gen_config<xcb_flush> {};
 template<> struct fex_gen_config<xcb_get_maximum_request_length> {};
@@ -62,7 +66,7 @@ template<> struct fex_gen_config<xcb_send_request_with_fds> {};
 template<> struct fex_gen_config<xcb_send_request64> {};
 template<> struct fex_gen_config<xcb_send_request_with_fds64> {};
 template<> struct fex_gen_config<xcb_send_fd> {};
-template<> struct fex_gen_config<xcb_take_socket> : fexgen::callback_guest, fexgen::custom_host_impl {};
+template<> struct fex_gen_config<xcb_take_socket> {};
 
 template<> struct fex_gen_config<xcb_writev> {};
 template<> struct fex_gen_config<xcb_wait_for_reply> : fexgen::custom_guest_entrypoint {};
diff --git a/ThunkLibs/libxshmfence/libxshmfence_interface.cpp b/ThunkLibs/libxshmfence/libxshmfence_interface.cpp
index cf396ef6d0..5b2433da4f 100644
--- a/ThunkLibs/libxshmfence/libxshmfence_interface.cpp
+++ b/ThunkLibs/libxshmfence/libxshmfence_interface.cpp
@@ -9,6 +9,11 @@ struct fex_gen_config {
     unsigned version = 1;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xshmfence> : fexgen::opaque_type {};
+
 template<> struct fex_gen_config<xshmfence_trigger> {};
 template<> struct fex_gen_config<xshmfence_await> {};
 template<> struct fex_gen_config<xshmfence_query> {};
diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt
index eee4941f23..fa937b1229 100644
--- a/unittests/CMakeLists.txt
+++ b/unittests/CMakeLists.txt
@@ -1,8 +1,8 @@
 if (NOT MINGW_BUILD)
   add_subdirectory(APITests/)
   add_subdirectory(IR/)
-  add_subdirectory(POSIX/)
-  add_subdirectory(gvisor-tests/)
+  #add_subdirectory(POSIX/)
+  #add_subdirectory(gvisor-tests/)
   add_subdirectory(gcc-target-tests-32/)
   add_subdirectory(gcc-target-tests-64/)
   add_subdirectory(Utilities/)
@@ -17,8 +17,8 @@ if (NOT MINGW_BUILD)
   endif()
 endif()
 
-add_subdirectory(ASM/)
-add_subdirectory(32Bit_ASM/)
+#add_subdirectory(ASM/)
+#add_subdirectory(32Bit_ASM/)
 if (ENABLE_VIXL_DISASSEMBLER AND (ENABLE_JIT_ARM64 OR CMAKE_SYSTEM_PROCESSOR MATCHES "^aarch64|^arm64|^armv8\.*") AND NOT ENABLE_JIT_X86_64)
   # Tests are only valid to run if the vixl disassembler is enabled and the active JIT is the ARM64 JIT.
   add_subdirectory(InstructionCountCI/)
diff --git a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
index 4fc742db2f..dcac39b7e0 100644
--- a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
+++ b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
@@ -17,8 +17,73 @@ struct Fixture {
 
 #define GET_SYMBOL(name) decltype(&::name) name = (decltype(name))dlsym(lib, #name)
   GET_SYMBOL(GetDoubledValue);
+
+  GET_SYMBOL(MakeOpaqueType);
+  GET_SYMBOL(ReadOpaqueTypeData);
+  GET_SYMBOL(DestroyOpaqueType);
+
+  GET_SYMBOL(MakeUnionType);
+  GET_SYMBOL(GetUnionTypeA);
+
+  GET_SYMBOL(MakeReorderingType);
+  GET_SYMBOL(GetReorderingTypeMember);
+  GET_SYMBOL(GetReorderingTypeMemberWithoutRepacking);
+  GET_SYMBOL(ModifyReorderingTypeMembers);
+  GET_SYMBOL(QueryOffsetOf);
+
+  GET_SYMBOL(RanCustomRepack);
+
+  GET_SYMBOL(FunctionWithDivergentSignature);
 };
 
 TEST_CASE_METHOD(Fixture, "Trivial") {
   CHECK(GetDoubledValue(10) == 20);
 }
+
+TEST_CASE_METHOD(Fixture, "Opaque data types") {
+  {
+    auto data = MakeOpaqueType(0x1234);
+    CHECK(ReadOpaqueTypeData(data) == 0x1234);
+    DestroyOpaqueType(data);
+  }
+
+  {
+    auto data = MakeUnionType(0x1, 0x2, 0x3, 0x4);
+    CHECK(GetUnionTypeA(&data) == 0x04030201);
+  }
+}
+
+TEST_CASE_METHOD(Fixture, "Automatic struct repacking") {
+  {
+    // Test repacking of return values
+    ReorderingType test_struct = MakeReorderingType(0x1234, 0x5678);
+    REQUIRE(test_struct.a == 0x1234);
+    REQUIRE(test_struct.b == 0x5678);
+
+    // Test offsets of the host-side guest_layout wrapper match the guest-side ones
+    CHECK(QueryOffsetOf(&test_struct, 0) == offsetof(ReorderingType, a));
+    CHECK(QueryOffsetOf(&test_struct, 1) == offsetof(ReorderingType, b));
+
+    // Test repacking of input pointers
+    CHECK(GetReorderingTypeMember(&test_struct, 0) == 0x1234);
+    CHECK(GetReorderingTypeMember(&test_struct, 1) == 0x5678);
+
+    // Test that we can force reinterpreting the data in guest layout as host layout
+    CHECK(GetReorderingTypeMemberWithoutRepacking(&test_struct, 0) == 0x5678);
+    CHECK(GetReorderingTypeMemberWithoutRepacking(&test_struct, 1) == 0x1234);
+
+    // Test repacking of output pointers
+    ModifyReorderingTypeMembers(&test_struct);
+    CHECK(GetReorderingTypeMember(&test_struct, 0) == 0x1235);
+    CHECK(GetReorderingTypeMember(&test_struct, 1) == 0x567a);
+  };
+}
+
+TEST_CASE_METHOD(Fixture, "Assisted struct repacking") {
+  CustomRepackedType data {};
+  CHECK(RanCustomRepack(&data) == 1);
+}
+
+TEST_CASE_METHOD(Fixture, "Function signature with differing parameter sizes") {
+  CHECK(FunctionWithDivergentSignature(DivType{1}, DivType{2}, DivType{3}, DivType{4}) == 0x01020304);
+}
diff --git a/unittests/ThunkLibs/CMakeLists.txt b/unittests/ThunkLibs/CMakeLists.txt
index f05b641599..c5a6c14ebe 100644
--- a/unittests/ThunkLibs/CMakeLists.txt
+++ b/unittests/ThunkLibs/CMakeLists.txt
@@ -1,5 +1,6 @@
-add_executable(thunkgentest generator.cpp)
+add_executable(thunkgentest generator.cpp abi.cpp)
 target_link_libraries(thunkgentest PRIVATE Catch2::Catch2WithMain)
+target_link_libraries(thunkgentest PRIVATE fmt::fmt)
 target_link_libraries(thunkgentest PRIVATE thunkgenlib)
 catch_discover_tests(thunkgentest TEST_SUFFIX ".ThunkGen")
 
diff --git a/unittests/ThunkLibs/abi.cpp b/unittests/ThunkLibs/abi.cpp
new file mode 100644
index 0000000000..8ecb843af5
--- /dev/null
+++ b/unittests/ThunkLibs/abi.cpp
@@ -0,0 +1,801 @@
+#include <clang/Frontend/CompilerInstance.h>
+#include <catch2/catch.hpp>
+
+#include <data_layout.h>
+#include <interface.h>
+#include "common.h"
+
+#include <fmt/format.h>
+
+#include <string_view>
+
+inline std::ostream& operator<<(std::ostream& os, TypeCompatibility compat) {
+    if (compat == TypeCompatibility::Full) {
+        os << "Compatible";
+    } else if (compat == TypeCompatibility::Repackable) {
+        os << "Repackable";
+    } else if (compat == TypeCompatibility::None) {
+        os << "Incompatible";
+    } else {
+        os << "(INVALID)";
+    }
+    return os;
+}
+
+class DataLayoutCompareActionForTest;
+
+namespace {
+
+struct Fixture {
+    Fixture() {
+    }
+
+    ~Fixture() {
+    }
+
+    /**
+     * Parses annotations from the input source and generates data layout descriptions from it.
+     *
+     * Input code with common definitions (types, functions, ...) should be specified in "prelude".
+     * It will be prepended to "code" before processing and also to the generator output.
+     */
+    std::unique_ptr<DataLayoutCompareActionForTest> compute_data_layout(std::string_view prelude, std::string_view code, GuestABI);
+};
+
+}
+
+class DataLayoutCompareActionForTest : public DataLayoutCompareAction {
+    std::unordered_map<const clang::Type*, TypeCompatibility> type_compat_cache;
+
+    // Persistent reference taken to enable accessing the ASTContext after CompilerInstance::ExecuteAction returns
+    llvm::IntrusiveRefCntPtr<clang::ASTContext> ast_context;
+
+public:
+    DataLayoutCompareActionForTest(std::unique_ptr<ABI> guest_layout) : DataLayoutCompareAction(*guest_layout), guest_layout(std::move(guest_layout)) {
+    }
+
+    void ExecuteAction() override {
+        AnalysisAction::ExecuteAction();
+
+        ast_context = &getCompilerInstance().getASTContext();
+        host_layout = ComputeDataLayout(*ast_context, types);
+    }
+
+    std::unique_ptr<ABI> guest_layout;
+    std::unordered_map<const clang::Type*, TypeInfo> host_layout;
+
+    TypeCompatibility GetTypeCompatibility(std::string_view type_name) {
+        for (const auto& [type, _] : host_layout) {
+            if (clang::QualType { type, 0 }.getAsString() == type_name) {
+                return DataLayoutCompareAction::GetTypeCompatibility(*ast_context, type, host_layout, type_compat_cache);
+            }
+        }
+
+        throw std::runtime_error("No data layout information recorded for type \"" + std::string { type_name } + "\"");
+    }
+};
+
+/**
+ * Same as clang::FrontendActionFactory but takes an external FrontendAction
+ * reference instead of constructing an internal one. Since the FrontendAction
+ * lifetime may extend past this ToolAction, state captured by the
+ * FrontendAction can be accessed after the ToolAction returns.
+ */
+class ThunkTestToolAction : public clang::tooling::ToolAction {
+public:
+    clang::FrontendAction& ScopedToolAction;
+
+public:
+    ThunkTestToolAction(clang::FrontendAction& action) : ScopedToolAction(action) {
+    }
+    ~ThunkTestToolAction() = default;
+
+    // Same as FrontendActionFactory but keeps ScopedToolAction alive when returning
+    bool runInvocation( std::shared_ptr<clang::CompilerInvocation> invocation, clang::FileManager *files,
+                        std::shared_ptr<clang::PCHContainerOperations> pch,
+                        clang::DiagnosticConsumer *diag_consumer) override {
+
+        auto diagnostics = clang::CompilerInstance::createDiagnostics(&invocation->getDiagnosticOpts(), diag_consumer, false);
+
+        clang::CompilerInstance Compiler(std::move(pch));
+        Compiler.setInvocation(std::move(invocation));
+        Compiler.setFileManager(files);
+        Compiler.createDiagnostics(diag_consumer, false);
+        if (!Compiler.hasDiagnostics())
+          return false;
+        Compiler.createSourceManager(*files);
+
+        const bool Success = Compiler.ExecuteAction(ScopedToolAction);
+
+        files->clearStatCache();
+        return Success;
+    }
+};
+
+std::unique_ptr<DataLayoutCompareActionForTest> Fixture::compute_data_layout(std::string_view prelude, std::string_view code, GuestABI guest_abi) {
+    const std::string full_code = std::string { prelude } + std::string { code };
+
+    // Compute guest data layout
+    auto data_layout_analysis_factory = std::make_unique<AnalyzeDataLayoutActionFactory>();
+    run_tool(*data_layout_analysis_factory, full_code, false, guest_abi);
+
+    // Compute host data layout
+    auto ScopedToolAction = std::make_unique<DataLayoutCompareActionForTest>(data_layout_analysis_factory->TakeDataLayout());
+    run_tool(std::make_unique<ThunkTestToolAction>(*ScopedToolAction), full_code, false, std::nullopt);
+
+    return ScopedToolAction;
+}
+
+static std::string FormatDataLayout(const std::unordered_map<const clang::Type*, TypeInfo>& layout) {
+     std::string ret;
+
+    for (const auto& [type, info] : layout) {
+        auto basic_info = info.get_if_simple_or_struct();
+        if (!basic_info) {
+            continue;
+        }
+
+        ret += fmt::format("  Host entry {}: {} ({})\n", clang::QualType { type, 0 }.getAsString().c_str(), basic_info->size_bits / 8, basic_info->alignment_bits / 8);
+
+        if (auto struct_info = info.get_if_struct()) {
+            for (const auto& member : struct_info->members) {
+                ret += fmt::format("    Offset {}-{}: {} {}{}\n", member.offset_bits / 8, (member.offset_bits + member.size_bits - 1) / 8, member.type_name.c_str(), member.member_name.c_str(), member.array_size ? fmt::format("[{}]", member.array_size.value()).c_str() : "");
+            }
+        }
+    }
+
+    return ret;
+}
+
+TEST_CASE_METHOD(Fixture, "DataLayout") {
+    auto guest_abi = GENERATE(GuestABI::X86_32, GuestABI::X86_64);
+    INFO(guest_abi);
+
+    SECTION("Trivial") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n",
+            "struct A { int a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        REQUIRE(action->guest_layout->contains("A"));
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+    }
+
+    SECTION("Builtin types") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n",
+            "struct A { char a; short b; int c; float d; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        REQUIRE(action->guest_layout->contains("A"));
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("char") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("short") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("int") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("float") == TypeCompatibility::Full);
+    }
+
+    SECTION("Padding after int16_t") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int16_t a; int32_t b; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+    }
+
+    SECTION("Array of int16_t") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int16_t a[64]; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+    }
+
+    const auto compat_full64_repackable32 = (guest_abi == GuestABI::X86_32 ? TypeCompatibility::Repackable : TypeCompatibility::Full);
+
+    SECTION("Type with platform-dependent size (size_t)") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdlib>\n",
+            "struct A { size_t a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == (guest_abi == GuestABI::X86_32 ? TypeCompatibility::Repackable : TypeCompatibility::Full));
+    }
+
+    SECTION("int64_t has stricter alignment requirements on 64-bit platforms") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int64_t a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->alignment_bits == (guest_abi == GuestABI::X86_32 ? 32 : 64));
+        CHECK(action->GetTypeCompatibility("struct A") == (guest_abi == GuestABI::X86_32 ? TypeCompatibility::Repackable : TypeCompatibility::Full));
+    }
+
+    SECTION("Array of int64_t") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int64_t a[64]; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+    }
+
+// TODO: Currently unsupported by the generator
+//    SECTION("int64_t with explicit alignment specification") {
+//        auto action = compute_data_layout(
+//            "#include <thunks_common.h>\n"
+//            "#include <cstdint>\n",
+//            "struct alignas(8) A { int64_t a; };\n"
+//            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+//        INFO(FormatDataLayout(action->host_layout));
+
+//        REQUIRE(action->guest_layout->contains("A"));
+//        CHECK(action->guest_layout->at("A").get_if_struct()->alignment_bits == 64);
+//        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+//    }
+
+    SECTION("int64_t alignment requirements propagate to parent struct") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int32_t a; int32_t b; int64_t c; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->alignment_bits == (guest_abi == GuestABI::X86_32 ? 32 : 64));
+        CHECK(action->GetTypeCompatibility("struct A") == (guest_abi == GuestABI::X86_32 ? TypeCompatibility::Repackable : TypeCompatibility::Full));
+    }
+
+    SECTION("Padding before int64_t member") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int32_t a; int64_t b; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->members[1].offset_bits == (guest_abi == GuestABI::X86_32 ? 32 : 64));
+
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+    }
+
+    SECTION("Padding at end of struct due to int64_t alignment (like VkMemoryHeap)") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int64_t a; int32_t b; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->size_bits == (guest_abi == GuestABI::X86_32 ? 96 : 128));
+
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+    }
+
+    SECTION("Different struct definition between guest and host; different member order") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct A { int32_t a; int32_t b; };\n"
+            "#else\n"
+            "struct A { int32_t b; int32_t a; };\n"
+            "#endif\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->members.at(0).member_name == "b");
+        CHECK(action->guest_layout->at("A").get_if_struct()->members.at(1).member_name == "a");
+
+        REQUIRE(!action->host_layout.empty());
+        CHECK(action->host_layout.begin()->second.get_if_struct()->members.at(0).member_name == "a");
+        CHECK(action->host_layout.begin()->second.get_if_struct()->members.at(1).member_name == "b");
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+    }
+
+    SECTION("Different struct definition between guest and host; different member size") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct A { int32_t a; int32_t b; };\n"
+            "#else\n"
+            "struct A { int32_t a; int64_t b; };\n"
+            "#endif\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->members.at(0).size_bits == 32);
+        CHECK(action->guest_layout->at("A").get_if_struct()->members.at(1).size_bits == 64);
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+    }
+
+    SECTION("Different struct definition between guest and host; completely different members") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct A { int32_t a; int32_t b; };\n"
+            "#else\n"
+            "struct A { int32_t c; int32_t d; };\n"
+            "#endif\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
+    }
+
+if (false) // TODO: Currently fails
+    SECTION("Different struct definition between guest and host; member missing from guest") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct A { int32_t a; int32_t b; };\n"
+            "#else\n"
+            "struct A { int32_t a; };\n"
+            "#endif\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
+    }
+
+    SECTION("Different struct definition between guest and host; member missing from host") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct A { int32_t a; };\n"
+            "#else\n"
+            "struct A { int32_t a; int32_t b; };\n"
+            "#endif\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
+    }
+
+    SECTION("Nesting structs of consistent data layout") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct C { int32_t a; int16_t b; };\n"
+            "struct B { C a; int16_t b; };\n"
+            "struct A { int32_t a; B b; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        REQUIRE(action->guest_layout->contains("B"));
+        REQUIRE(action->guest_layout->contains("C"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->members.at(0).size_bits == 32);
+
+        CHECK(action->GetTypeCompatibility("struct C") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+    }
+
+    SECTION("Nesting repackable structs by embedding") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct C { int32_t a; int32_t b; };\n"
+            "#else\n"
+            "struct C { int32_t b; int32_t a; };\n"
+            "#endif\n"
+            "struct B { C a; int16_t b; };\n"
+            "struct A { int32_t a; B b; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        REQUIRE(action->guest_layout->contains("B"));
+        REQUIRE(action->guest_layout->contains("C"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->size_bits == 128);
+        CHECK(action->guest_layout->at("A").get_if_struct()->alignment_bits == 32);
+
+        CHECK(action->GetTypeCompatibility("struct C") == TypeCompatibility::Repackable);
+        CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::Repackable);
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+    }
+
+    SECTION("Embedded union type (like VkRenderingAttachmentInfo)") {
+        SECTION("without annotation") {
+            CHECK_THROWS_WITH(compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "union B { int32_t a; uint32_t b; };\n"
+                "struct A { B a; };\n"
+                "template<> struct fex_gen_type<A> {};\n", guest_abi),
+                Catch::Contains("unannotated member") && Catch::Contains("union type"));
+        }
+
+        SECTION("with annotation") {
+            auto action = compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "union B { int32_t a; uint32_t b; };\n"
+                "struct A { B a; };\n"
+                "template<> struct fex_gen_type<B> : fexgen::assume_compatible_data_layout {};\n"
+                "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+            INFO(FormatDataLayout(action->host_layout));
+
+            REQUIRE(action->guest_layout->contains("A"));
+            CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+        }
+    }
+}
+
+TEST_CASE_METHOD(Fixture, "DataLayoutPointers") {
+    auto guest_abi = GENERATE(GuestABI::X86_32, GuestABI::X86_64);
+    INFO(guest_abi);
+
+    const auto compat_full64_repackable32 = (guest_abi == GuestABI::X86_32 ? TypeCompatibility::Repackable : TypeCompatibility::Full);
+
+    SECTION("Pointer to data with consistent layout") {
+        std::string type = GENERATE("char", "short", "int", "float", "struct B { int a; }");
+        INFO(type);
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { " + type + "* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        // The pointer itself needs repacking on 32-bit. On 64-bit, no repacking is needed at all.
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+        if (!type.starts_with("struct B")) {
+            CHECK(action->GetTypeCompatibility(type) == TypeCompatibility::Full);
+        }
+    }
+
+    SECTION("Pointer to struct with consistent layout") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct B { int32_t a; };\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("B"));
+        CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::Full);
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+    }
+
+    SECTION("Unannotated pointer to incomplete type") {
+        CHECK_THROWS_WITH(compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct B;\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi),
+            Catch::Contains("incomplete type"));
+    }
+
+    SECTION("Unannotated pointer to repackable type") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct B { int32_t a; int32_t b; };\n"
+            "#else\n"
+            "struct B { int32_t a; int64_t b; };\n"
+            "#endif\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
+    }
+
+    SECTION("Nesting repackable structs by pointers") {
+        SECTION("Innermost struct is compatible") {
+            auto action = compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "struct C { int32_t a; int32_t b; };\n"
+                "struct B { C* a; int16_t b; };\n"
+                "struct A { int32_t a; B b; };\n"
+                "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+            INFO(FormatDataLayout(action->host_layout));
+
+            REQUIRE(action->guest_layout->contains("A"));
+            REQUIRE(action->guest_layout->contains("B"));
+            REQUIRE(action->guest_layout->contains("C"));
+
+            // 64-bit is fully compatible, but 32-bit needs to zero-extend the pointer itself
+            CHECK(action->GetTypeCompatibility("struct C") == TypeCompatibility::Full);
+            CHECK(action->GetTypeCompatibility("struct B") == compat_full64_repackable32);
+            CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+        }
+
+        SECTION("Innermost struct is incompatible") {
+            auto action = compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "#ifdef HOST\n"
+                "struct C { int32_t a; int32_t b; };\n"
+                "#else\n"
+                "struct C { int32_t b; int32_t a; };\n"
+                "#endif\n"
+                "struct B { C* a; int16_t b; };\n"
+                "struct A { int32_t a; B b; };\n"
+                "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+            INFO(FormatDataLayout(action->host_layout));
+
+            REQUIRE(action->guest_layout->contains("A"));
+            REQUIRE(action->guest_layout->contains("B"));
+            REQUIRE(action->guest_layout->contains("C"));
+
+            CHECK(action->GetTypeCompatibility("struct C") == TypeCompatibility::Repackable);
+            CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::None);
+            CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
+        }
+
+        SECTION("Innermost struct is incompatible but the pointer member is annotated") {
+            auto action = compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "#ifdef HOST\n"
+                "struct C { int32_t a; int32_t b; };\n"
+                "#else\n"
+                "struct C { int32_t b; int32_t a; };\n"
+                "#endif\n"
+                "struct B { C* a; int16_t b; };\n"
+                "struct A { int32_t a; B b; };\n"
+                "template<> struct fex_gen_config<&B::a> : fexgen::custom_repack {};\n"
+                "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+            INFO(FormatDataLayout(action->host_layout));
+
+            REQUIRE(action->guest_layout->contains("A"));
+            REQUIRE(action->guest_layout->contains("B"));
+            REQUIRE(action->guest_layout->contains("C"));
+
+            CHECK(action->GetTypeCompatibility("struct C") == TypeCompatibility::Repackable);
+            CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::Repackable);
+            CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+        }
+    }
+
+    SECTION("Unannotated pointer to union type") {
+        CHECK_THROWS_WITH(compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "union B { int32_t a; uint32_t b; };\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi),
+            Catch::Contains("unannotated member") && Catch::Contains("union type"));
+    }
+
+    SECTION("Pointer to union type with assume_compatible_data_layout annotation") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "union B { int32_t a; uint32_t b; };\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_type<B> : fexgen::assume_compatible_data_layout {};\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+    }
+
+    SECTION("Pointer to union type with custom_repack annotation") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "union B { int32_t a; uint32_t b; };\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+    }
+
+    SECTION("Pointer to opaque type") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct B;\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_type<B> : fexgen::opaque_type {};\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+    }
+
+    SECTION("Pointer member with custom repacking code") {
+        // Data layout analysis only needs to know about the custom_repack
+        // annotation. The actual custom repacking code isn't needed for the
+        // test.
+
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct B { int32_t a; };\n"
+            "#else\n"
+            "struct B { int32_t b; };\n"
+            "#endif\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        REQUIRE(action->guest_layout->contains("B"));
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+        CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::None);
+    }
+
+    SECTION("Custom repacking induces repacking requirement") {
+        // Data layout analysis only needs to know about the custom_repack
+        // annotation. The actual custom repacking code isn't needed for the
+        // test.
+
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct B {};\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        REQUIRE(action->guest_layout->contains("B"));
+        CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+    }
+
+    SECTION("Self-referencing struct (like VkBaseOutStructure)") {
+        // Without annotation
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { A* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK_THROWS_WITH(action->GetTypeCompatibility("struct A"), Catch::Contains("recursive reference"));
+
+        // With annotation
+        if (guest_abi == GuestABI::X86_64) {
+            auto action = compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "struct A { A* a; };\n"
+                "template<> struct fex_gen_type<A> : fexgen::assume_compatible_data_layout {};\n", guest_abi);
+
+            INFO(FormatDataLayout(action->host_layout));
+
+            REQUIRE(action->guest_layout->contains("A"));
+            CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+        }
+    }
+
+    SECTION("Circularly referencing structs") {
+        // Without annotation
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct B;\n"
+            "struct A { B* a; };\n"
+            "struct B { A* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        REQUIRE(action->guest_layout->contains("B"));
+        CHECK_THROWS_WITH(action->GetTypeCompatibility("struct A"), Catch::Contains("recursive reference"));
+        CHECK_THROWS_WITH(action->GetTypeCompatibility("struct B"), Catch::Contains("recursive reference"));
+
+        // With annotation
+        if (guest_abi == GuestABI::X86_64) {
+            auto action = compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "struct B;\n"
+                "struct A { B* a; };\n"
+                "struct B { A* a; };\n"
+                "template<> struct fex_gen_type<B> : fexgen::assume_compatible_data_layout {};\n", guest_abi);
+
+            INFO(FormatDataLayout(action->host_layout));
+
+            REQUIRE(action->guest_layout->contains("B"));
+            CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::Full);
+        }
+    }
+
+    // TODO: Double pointers to compatible data: struct B { int a ; }; struct A { B** b; };
+
+if (guest_abi == GuestABI::X86_32) // TODO
+    SECTION("TODO") {
+        // Without annotation
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { void* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
+    }
+}
diff --git a/unittests/ThunkLibs/common.h b/unittests/ThunkLibs/common.h
index 47c83bd9bd..b67a73fb59 100644
--- a/unittests/ThunkLibs/common.h
+++ b/unittests/ThunkLibs/common.h
@@ -42,24 +42,83 @@ class TestDiagnosticConsumer : public clang::TextDiagnosticPrinter {
     }
 };
 
+enum class GuestABI {
+    X86_32,
+    X86_64,
+};
+
+inline std::ostream& operator<<(std::ostream& os, GuestABI abi) {
+    if (abi == GuestABI::X86_32) {
+        os << "X86_32";
+    } else if (abi == GuestABI::X86_64) {
+        os << "X86_64";
+    }
+    return os;
+}
+
 /**
  * Run the given ToolAction on the input code.
  *
  * The "silent" parameter is used to suppress non-fatal diagnostics in tests that expect failure
  */
-inline void run_tool(clang::tooling::ToolAction& action, std::string_view code, bool silent = false) {
+inline void run_tool(clang::tooling::ToolAction& action, std::string_view code, bool silent = false, std::optional<GuestABI> guest_abi = std::nullopt) {
     const char* memory_filename = "gen_input.cpp";
     auto adjuster = clang::tooling::getClangStripDependencyFileAdjuster();
-    std::vector<std::string> args = { "clang-tool", "-fsyntax-only", "-std=c++17", "-Werror", "-I.", memory_filename };
+    std::vector<std::string> args = { "clang-tool", "-fsyntax-only", "-std=c++20", "-Werror", "-I.", memory_filename };
+    if (guest_abi == GuestABI::X86_64) {
+        args.push_back("-target");
+        args.push_back("x86_64-linux-gnu");
+    } else if (guest_abi == GuestABI::X86_32) {
+        args.push_back("-target");
+        args.push_back("i686-linux-gnu");
+    } else {
+        args.push_back("-DHOST");
+    }
 
     // Corresponds to the content of GeneratorInterface.h
     const char* common_header_code = R"(namespace fexgen {
-struct returns_guest_pointer {};
+// function annotations: fex_gen_config<MyFunc>
+struct returns_guest_pointer {}; // TODO: Deprecate in favor of pointer_passthrough
 struct custom_host_impl {};
 struct callback_annotation_base { bool prevent_multiple; };
 struct callback_stub : callback_annotation_base {};
-struct callback_guest : callback_annotation_base {};
+
+// type annotations: fex_gen_config<MyStruct>
+//struct opaque_to_guest {};
+//struct opaque_to_host {};
+
+// If used, fex_custom_repack must be specialized for the annotated struct member
+struct custom_repack {};
+
+// Pointers to types annotated with this will be passed through without change
+struct opaque_type {};
+
+struct assume_compatible_data_layout {};
+
+struct ptr_passthrough {};
+
+// struct member annotations: fex_gen_config<&MyStruct::member>
+struct is_padding_member {};
+
+// function parameter annotations: fex_gen_config<fexgen::annotate_parameter<MyFunc, 2>>
+struct ptr_in {};
+struct ptr_out {};
+struct ptr_inout {};
+struct ptr_pointer_passthrough {};
+struct ptr_is_untyped_address {};
+
+template<auto, int, typename = decltype(nullptr)>
+struct annotate_parameter {};
 } // namespace fexgen
+
+template<typename> struct fex_gen_type {};
+template<auto, int, typename = void> struct fex_gen_param {};
+
+template<typename>
+struct fex_gen_type;
+template<auto>
+struct fex_gen_config;
+
 )";
 
     llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> overlay_fs(new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem()));
@@ -80,6 +139,6 @@ struct callback_guest : callback_annotation_base {};
     }
 }
 
-inline void run_tool(std::unique_ptr<clang::tooling::ToolAction> action, std::string_view code, bool silent = false) {
-    return run_tool(*action, code, silent);
+inline void run_tool(std::unique_ptr<clang::tooling::ToolAction> action, std::string_view code, bool silent = false, std::optional<GuestABI> guest_abi = std::nullopt) {
+    return run_tool(*action, code, silent, guest_abi);
 }
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 4958d957eb..2f6c9b636e 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -73,7 +73,7 @@ struct Fixture {
      * It will be prepended to "code" before processing and also to the generator output.
      */
     SourceWithAST run_thunkgen_guest(std::string_view prelude, std::string_view code, bool silent = false);
-    SourceWithAST run_thunkgen_host(std::string_view prelude, std::string_view code, bool silent = false);
+    SourceWithAST run_thunkgen_host(std::string_view prelude, std::string_view code, GuestABI = GuestABI::X86_64, bool silent = false);
     GenOutput run_thunkgen(std::string_view prelude, std::string_view code, bool silent = false);
 
     const std::string libname = "libtest";
@@ -202,7 +202,14 @@ SourceWithAST::SourceWithAST(std::string_view input) : code(input) {
  */
 SourceWithAST Fixture::run_thunkgen_guest(std::string_view prelude, std::string_view code, bool silent) {
     const std::string full_code = std::string { prelude } + std::string { code };
-    run_tool(std::make_unique<GenerateThunkLibsActionFactory>(libname, output_filenames), full_code, silent);
+
+    // These tests don't deal with data layout differences, so just run data
+    // layout analysis with host configuration
+    auto data_layout_analysis_factory = std::make_unique<AnalyzeDataLayoutActionFactory>();
+    run_tool(*data_layout_analysis_factory, full_code, silent);
+    auto& data_layout = data_layout_analysis_factory->GetDataLayout();
+
+    run_tool(std::make_unique<GenerateThunkLibsActionFactory>(libname, output_filenames, data_layout), full_code, silent);
 
     std::string result =
         "#include <cstdint>\n"
@@ -229,13 +236,23 @@ SourceWithAST Fixture::run_thunkgen_guest(std::string_view prelude, std::string_
 /**
  * Generates host thunk library code from the given input
  */
-SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_view code, bool silent) {
+SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_view code, GuestABI guest_abi, bool silent) {
     const std::string full_code = std::string { prelude } + std::string { code };
-    run_tool(std::make_unique<GenerateThunkLibsActionFactory>(libname, output_filenames), full_code, silent);
+
+    // These tests don't deal with data layout differences, so just run data
+    // layout analysis with host configuration
+    auto data_layout_analysis_factory = std::make_unique<AnalyzeDataLayoutActionFactory>();
+    run_tool(*data_layout_analysis_factory, full_code, silent, guest_abi);
+    auto& data_layout = data_layout_analysis_factory->GetDataLayout();
+
+    run_tool(std::make_unique<GenerateThunkLibsActionFactory>(libname, output_filenames, data_layout), full_code, silent);
 
     std::string result =
+        "#include <array>\n"
         "#include <cstdint>\n"
+        "#include <cstring>\n"
         "#include <dlfcn.h>\n"
+        "#include <type_traits>\n"
         "template<typename Fn>\n"
         "struct function_traits;\n"
         "template<typename Result, typename Arg>\n"
@@ -256,29 +273,194 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "  uintptr_t GuestUnpacker;\n"
         "  uintptr_t GuestTarget;\n"
         "};\n"
-        "template<typename>\n"
-        "struct CallbackUnpack {\n"
-        "  static void ForIndirectCall(void* argsv);\n"
+        "struct ParameterAnnotations {\n"
+        "    bool is_passthrough = false;\n"
+        "    bool is_opaque = false;\n"
+        "};\n"
+        "template<typename, typename...>\n"
+        "struct GuestWrapperForHostFunction {\n"
+        "  template<ParameterAnnotations...> static void Call(void*);\n"
         "};\n"
-        "template<typename F>\n"
-        "void FinalizeHostTrampolineForGuestFunction(F*);\n"
         "struct ExportEntry { uint8_t* sha256; void(*fn)(void *); };\n"
-        "void *dlsym_default(void* handle, const char* symbol);\n";
+        "void *dlsym_default(void* handle, const char* symbol);\n"
+        "template<typename>\n"
+        "struct pmd_traits;\n"
+        "template<typename Parent, typename Data>\n"
+        "struct pmd_traits<Data Parent::*> {\n"
+        "    using parent_t = Parent;\n"
+        "    using member_t = Data;\n"
+        "};\n"
+        "template<typename T> inline constexpr bool has_compatible_data_layout = std::is_integral_v<T> || std::is_enum_v<T>;\n"
+        "template<typename T>\n"
+        "struct guest_layout {\n"
+        "  static_assert(!std::is_class_v<T>, \"No guest layout defined for this non-opaque struct type. This may be a bug in the thunk generator.\");\n"
+        "  static_assert(!std::is_union_v<T>, \"No guest layout defined for this non-opaque union type. This may be a bug in the thunk generator.\");\n"
+        "\n"
+        "  using type = std::enable_if_t<!std::is_pointer_v<T>, T>;\n"
+        "  type data;\n"
+        "\n"
+        "  guest_layout& operator=(const T from);\n"
+        "};\n"
+        "\n"
+        "template<typename T, std::size_t N>\n"
+        "struct guest_layout<T[N]> {\n"
+        "  using type = std::enable_if_t<!std::is_pointer_v<T>, T>;\n"
+        "  std::array<guest_layout<type>, N> data;\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct host_layout;\n"
+        "\n"
+        "template<typename T>\n"
+        "struct guest_layout<T*> {\n"
+        "#ifdef IS_32BIT_THUNK\n"
+        "  using type = uint32_t;\n"
+        "#else\n"
+        "  using type = uint64_t;\n"
+        "#endif\n"
+        "  type data;\n"
+        "\n"
+        "  guest_layout& operator=(const T* from);\n"
+        "  guest_layout<T>* get_pointer();\n"
+        "  const guest_layout<T>* get_pointer() const;\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct guest_layout<T* const> {\n"
+        "#ifdef IS_32BIT_THUNK\n"
+        "  using type = uint32_t;\n"
+        "#else\n"
+        "  using type = uint64_t;\n"
+        "#endif\n"
+        "  type data;\n"
+        "\n"
+        "  guest_layout& operator=(const T* from);\n"
+        "\n"
+        "  guest_layout<T>* get_pointer();\n"
+        "  const guest_layout<T>* get_pointer() const;\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct host_layout {\n"
+        "  T data;\n"
+        "\n"
+        "  template<typename U>\n"
+        "  host_layout(const guest_layout<U>& from) requires(!std::is_integral_v<T> || sizeof(T) == sizeof(U));\n"
+        "};\n"
+        "\n"
+        "// Specialization for size_t, which is 64-bit on 64-bit but 32-bit on 32-bit\n"
+        "template<>\n"
+        "struct host_layout<size_t> {\n"
+        "  size_t data;\n"
+        "\n"
+        "  host_layout(const guest_layout<uint32_t>& from);\n"
+        "  host_layout(const guest_layout<size_t>& from);\n"
+        "};\n"
+        "\n"
+        "template<typename T, size_t N>\n"
+        "struct host_layout<T[N]> {\n"
+        "  std::array<T, N> data;\n"
+        "  host_layout(const guest_layout<T[N]>& from);\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct host_layout<T*> {\n"
+        "  T* data;\n"
+        "\n"
+        "  static_assert(!std::is_function_v<T>, \"Function types must be handled separately\");\n"
+        "\n"
+        "  host_layout(const guest_layout<T*>& from);\n"
+        "\n"
+        "  host_layout() = default;\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct host_layout<T* const> {\n"
+        "  T* data;\n"
+        "\n"
+        "  static_assert(!std::is_function_v<T>, \"Function types must be handled separately\");\n"
+        "\n"
+        "  // Assume underlying data is compatible and just convert the guest-sized pointer to 64-bit\n"
+        "  host_layout(const guest_layout<T* const>& from);\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct unpacked_arg {\n"
+        "  using type = std::enable_if_t<!std::is_pointer_v<T>, T>;\n"
+        "  host_layout<type> data;\n"
+        "  type get();\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct unpacked_arg<T*> {\n"
+        "  unpacked_arg(const guest_layout<T*>&);\n"
+        "  unpacked_arg(const guest_layout<const T*>&);\n"
+        "\n"
+        "  T* get();\n"
+        "  host_layout<T*> data;\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct unpacked_arg_base;\n"
+        "template<typename T>\n"
+        "struct unpacked_arg_base<T*> {\n"
+        "  unpacked_arg_base(host_layout<T>*);\n"
+        "  unpacked_arg_base(host_layout<const T>*);\n"
+        "\n"
+        "  T* get();\n"
+        "  host_layout<T>* data;\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct unpacked_arg_with_storage;\n"
+        "template<typename T>\n"
+        "struct unpacked_arg_with_storage<T*> : unpacked_arg_base<T*> {\n"
+        "  unpacked_arg_with_storage(const guest_layout<T*>&);\n"
+        "  unpacked_arg_with_storage(const guest_layout<const T*>&);\n"
+        "};\n"
+        "template<>\n"
+        "struct unpacked_arg_with_storage<char*> {\n"
+        "  using type = char*;\n"
+        "\n"
+        "  unpacked_arg_with_storage(guest_layout<const char*>& data);\n"
+        "  unpacked_arg_with_storage(guest_layout<char*>& data);\n"
+        "\n"
+        "  type get();\n"
+        "  uint64_t data;\n"
+        "};\n"
+        "\n"
+        "template<typename T> guest_layout<T> to_guest(const host_layout<T>& from) requires(!std::is_pointer_v<T>);\n"
+        "template<typename T> guest_layout<T*> to_guest(const host_layout<T*>& from);\n"
+        "template<typename F> void FinalizeHostTrampolineForGuestFunction(F*);\n"
+        "template<typename F> void FinalizeHostTrampolineForGuestFunction(const guest_layout<F*>&);\n"
+        "template<typename T> T& unwrap_host(host_layout<T>&);\n"
+        "template<typename T> T* unwrap_host(unpacked_arg_base<T*>&);\n"
+        "template<typename T> const host_layout<T>& to_host_layout(const T& t);\n";
 
     auto& filename = output_filenames.host;
     {
         std::ifstream file(filename);
-        const auto current_size = result.size();
+        const auto prelude_size = result.size();
         const auto new_data_size = std::filesystem::file_size(filename);
         result.resize(result.size() + new_data_size);
-        file.read(result.data() + current_size, result.size());
+        file.read(result.data() + prelude_size, result.size());
+
+        // Force all functions to be non-static, since having to define them
+        // would add a lot of noise to simple tests.
+        while (true) {
+            auto pos = result.find("static ", prelude_size);
+            if (pos == std::string::npos) {
+                break;
+            }
+            result.replace(pos, 6, "      "); // Replace "static" with 6 spaces (avoiding reallocation)
+        }
     }
     return SourceWithAST { std::string { prelude } + result };
 }
 
 Fixture::GenOutput Fixture::run_thunkgen(std::string_view prelude, std::string_view code, bool silent) {
     return { run_thunkgen_guest(prelude, code, silent),
-             run_thunkgen_host(prelude, code, silent) };
+             run_thunkgen_host(prelude, code, GuestABI::X86_64, silent) };
 }
 
 TEST_CASE_METHOD(Fixture, "Trivial") {
@@ -353,10 +535,10 @@ TEST_CASE_METHOD(Fixture, "FunctionPointerViaType") {
         matches(varDecl(
             hasName("exports"),
             hasType(constantArrayType(hasElementType(asString("struct ExportEntry")), hasSize(2))),
-            hasInitializer(hasDescendant(declRefExpr(to(cxxMethodDecl(hasName("ForIndirectCall"), ofClass(hasName("CallbackUnpack"))).bind("funcptr")))))
+            hasInitializer(hasDescendant(declRefExpr(to(cxxMethodDecl(hasName("Call"), ofClass(hasName("GuestWrapperForHostFunction"))).bind("funcptr")))))
             )).check_binding("funcptr", +[](const clang::CXXMethodDecl* decl) {
                 auto parent = llvm::cast<clang::ClassTemplateSpecializationDecl>(decl->getParent());
-                return parent->getTemplateArgs().get(0).getAsType().getAsString() == "int (char, char)";
+                return parent->getTemplateArgs().get(0).getAsType().getAsString() == "int (unsigned char, unsigned char)";
             }));
 }
 
@@ -383,7 +565,7 @@ TEST_CASE_METHOD(Fixture, "FunctionPointerParameter") {
             hasDescendant(callExpr(callee(functionDecl(hasName("FinalizeHostTrampolineForGuestFunction"))), hasArgument(0, expr().bind("funcptr"))))
         )).check_binding("funcptr", +[](const clang::Expr* funcptr) {
             // Check that the argument type matches the function pointer
-            return funcptr->getType().getAsString() == "int (*)(char, char)";
+            return funcptr->getType().getAsString() == "guest_layout<int (*)(char, char)>";
         }));
 
     // Host should export the unpacking function for function pointer arguments
@@ -391,33 +573,7 @@ TEST_CASE_METHOD(Fixture, "FunctionPointerParameter") {
         matches(varDecl(
             hasName("exports"),
             hasType(constantArrayType(hasElementType(asString("struct ExportEntry")), hasSize(3))),
-            hasInitializer(hasDescendant(declRefExpr(to(cxxMethodDecl(hasName("ForIndirectCall"), ofClass(hasName("CallbackUnpack")))))))
-            )));
-}
-
-// Parameter is a guest function pointer
-TEST_CASE_METHOD(Fixture, "GuestFunctionPointerParameter") {
-    const std::string prelude =
-        "struct fex_guest_function_ptr { int (*x)(char,char); };\n"
-        "static void fexfn_impl_libtest_func(fex_guest_function_ptr) {}\n";
-    const auto output = run_thunkgen(prelude,
-        "#include <thunks_common.h>\n"
-        "void func(int (*funcptr)(char, char));\n"
-        "template<auto> struct fex_gen_config {};\n"
-        "template<> struct fex_gen_config<func> : fexgen::callback_guest, fexgen::custom_host_impl {};\n");
-
-    CHECK_THAT(output.guest,
-        matches(functionDecl(
-            hasName("fexfn_pack_func"),
-            returns(asString("void")),
-            parameterCountIs(1),
-            hasParameter(0, hasType(asString("int (*)(char, char)")))
-        )));
-
-    // Host-side implementation only sees an opaque type that it can't call
-    CHECK_THAT(output.host,
-        matches(callExpr(callee(functionDecl(hasName("fexfn_impl_libtest_func"))),
-                         hasArgument(0, hasType(asString("struct fex_guest_function_ptr")))
+            hasInitializer(hasDescendant(declRefExpr(to(cxxMethodDecl(hasName("Call"), ofClass(hasName("GuestWrapperForHostFunction")))))))
             )));
 }
 
@@ -461,10 +617,10 @@ TEST_CASE_METHOD(Fixture, "MultipleParameters") {
             parameterCountIs(1),
             hasParameter(0, hasType(pointerType(pointee(
                 recordType(hasDeclaration(decl(
-                    has(fieldDecl(hasType(asString("int")))),
-                    has(fieldDecl(hasType(asString("char")))),
-                    has(fieldDecl(hasType(asString("unsigned long")))),
-                    has(fieldDecl(hasType(asString("struct TestStruct"))))
+                    has(fieldDecl(hasType(asString("guest_layout<int32_t>")))),
+                    has(fieldDecl(hasType(asString("guest_layout<uint8_t>")))),
+                    has(fieldDecl(hasType(asString("guest_layout<uint64_t>")))),
+                    has(fieldDecl(hasType(asString("guest_layout<struct TestStruct>"))))
                     )))))))
             )));
 }
@@ -511,3 +667,138 @@ TEST_CASE_METHOD(Fixture, "VariadicFunctionsWithoutAnnotation") {
         "template<auto> struct fex_gen_config {};\n"
         "template<> struct fex_gen_config<func> {};\n", true));
 }
+
+TEST_CASE_METHOD(Fixture, "StructRepacking") {
+    auto guest_abi = GENERATE(GuestABI::X86_32, GuestABI::X86_64);
+    INFO(guest_abi);
+
+    // All tests use the same function, but the prelude defining its parameter type "A" varies
+    const std::string code =
+        "#include <thunks_common.h>\n"
+        "void func(A*);\n"
+        "template<auto> struct fex_gen_config {};\n"
+        "template<> struct fex_gen_config<func> : fexgen::custom_host_impl {};\n";
+
+    SECTION("Pointer to struct with consistent data layout") {
+        // TODO: NOTHROW
+        auto output = run_thunkgen_host("struct A { int a; };\n", code, guest_abi);
+    }
+
+    SECTION("Pointer to struct with unannotated pointer member with inconsistent data layout") {
+        // TODO: Should B have incompatible data layout?
+        const auto prelude =
+            "#ifdef HOST\n"
+            "struct B { int a; };\n"
+            "#else\n"
+            "struct B { int b; };\n"
+            "#endif\n"
+            "struct A { B* a; };\n";
+
+        SECTION("Parameter unannotated") {
+            CHECK_THROWS(run_thunkgen_host(prelude, code, guest_abi, true));
+        }
+
+
+//        SECTION("Parameter annotated as ptr_passthrough") {
+              // TODO: NOTHROW
+//            auto output = run_thunkgen_host(prelude, code + "template<> struct fex_gen_param<func, 0, A*> : fexgen::ptr_passthrough {};\n", guest_abi);
+//        }
+
+//        SECTION("Struct member annotated as custom_repack") {
+              // TODO: NOTHROW
+//            auto output = run_thunkgen_host("struct A { void* a; };\n",
+//                  code + "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n", guest_abi);
+//        }
+    }
+
+    SECTION("Pointer to struct with pointer member of consistent data layout") {
+        std::string type = GENERATE("char", "short", "int", "float");
+        REQUIRE_NOTHROW(run_thunkgen_host("struct A { " + type + "* a; };\n", code, guest_abi));
+    }
+
+    SECTION("Pointer to struct with pointer member of opaque type") {
+        const auto prelude =
+            "struct B;\n"
+            "struct A { B* a; };\n";
+
+        // Unannotated
+        REQUIRE_THROWS_WITH(run_thunkgen_host(prelude, code, guest_abi), Catch::Contains("incomplete type"));
+
+        // Annotated as opaque_type
+        auto output = run_thunkgen_host(prelude,
+              code + "template<> struct fex_gen_type<B> : fexgen::opaque_type {};\n", guest_abi);
+    }
+
+    // TODO: Array arguments (ints, floats, enum, compatible structs)
+
+    // TODO: Check that the right repacking code gets emitted for each type of data layout compatibility:
+        // TODO: Check that fully compatible types use unpacked_arg, and that to_guest isn't called
+        // TODO: Check that repackable types use unpacked_arg_with_storage
+        // TODO: Check that custom_repack annotations cause fex_apply_custom_repacking(_postcall) to be called
+
+    // TODO: "assume compatible" annotations (and they should repack the pointer on 32-bit, without modifying the data!)
+        // TODO: assume_compatible annotations (void* arguments)
+
+    // TODO: Determine if we can do similar tests for calls through function pointers
+}
+
+TEST_CASE_METHOD(Fixture, "VoidPointerParameter") {
+    auto guest_abi = GENERATE(GuestABI::X86_32, GuestABI::X86_64);
+    INFO(guest_abi);
+
+    SECTION("Unannotated") {
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(void*);\n"
+            "template<> struct fex_gen_config<func> {};\n";
+        if (guest_abi == GuestABI::X86_32) {
+//            CHECK_THROWS_WITH(run_thunkgen_host("", code, guest_abi, true), Catch::Contains("unsupported parameter type", Catch::CaseSensitive::No));
+        } else {
+            // Pointee data is assumed to be compatible on 64-bit
+            CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
+        }
+    }
+
+    SECTION("Passthrough") {
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(void*);\n"
+            "template<> struct fex_gen_config<func> : fexgen::custom_host_impl {};\n"
+            "template<> struct fex_gen_param<func, 0, void*> : fexgen::ptr_passthrough {};\n";
+        CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
+    }
+
+    SECTION("Assumed compatible") {
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(void*);\n"
+            "template<> struct fex_gen_config<func> {};\n"
+            "template<> struct fex_gen_param<func, 0, void*> : fexgen::assume_compatible_data_layout {};\n";
+        CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
+    }
+
+    SECTION("Unannotated in struct") {
+        const char* prelude =
+            "struct A { void* a; };\n";
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(A*);\n"
+            "template<> struct fex_gen_config<func> {};\n";
+        if (guest_abi == GuestABI::X86_32) {
+            CHECK_THROWS_WITH(run_thunkgen_host(prelude, code, guest_abi, true), Catch::Contains("unsupported parameter type", Catch::CaseSensitive::No));
+        } else {
+            CHECK_NOTHROW(run_thunkgen_host(prelude, code, guest_abi));
+        }
+    }
+
+    SECTION("Custom repack in struct") {
+        const char* prelude =
+            "struct A { void* a; };\n";
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(A*);\n"
+            "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n"
+            "template<> struct fex_gen_config<func> {};\n";
+        CHECK_NOTHROW(run_thunkgen_host(prelude, code, guest_abi));
+    }
+}