diff --git a/scripts/templates/ldrddi.cpp.mako b/scripts/templates/ldrddi.cpp.mako
index 1d64f345..e5c3600b 100644
--- a/scripts/templates/ldrddi.cpp.mako
+++ b/scripts/templates/ldrddi.cpp.mako
@@ -710,11 +710,19 @@ ${tbl['export']['name']}(
         else
         {
             // return pointers directly to driver's DDIs
-            %if namespace != "zes":
-            *pDdiTable = loader::context->zeDrivers.front().dditable.${n}.${tbl['name']};
-            %else:
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.${n}.${tbl['name']};
+            %for obj in tbl['functions']:
+            if (version >= ${th.get_version(obj)}) {
+            %if 'condition' in obj:
+        #if ${th.subt(n, tags, obj['condition'])}
+            %endif
+                pDdiTable->${th.append_ws(th.make_pfn_name(n, tags, obj), 43)} = firstDriver->dditable.${n}.${tbl['name']}.${th.make_pfn_name(n, tags, obj)};
+            %if 'condition' in obj:
+        #else
+                pDdiTable->${th.append_ws(th.make_pfn_name(n, tags, obj), 43)} = nullptr;
+        #endif
             %endif
+            }
+            %endfor
         }
     }
 
diff --git a/source/loader/ze_ldrddi.cpp b/source/loader/ze_ldrddi.cpp
index e3959a9c..7188fb32 100644
--- a/source/loader/ze_ldrddi.cpp
+++ b/source/loader/ze_ldrddi.cpp
@@ -8833,7 +8833,12 @@ zeGetGlobalProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Global;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnInit                                     = firstDriver->dditable.ze.Global.pfnInit;
+            }
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnInitDrivers                              = firstDriver->dditable.ze.Global.pfnInitDrivers;
+            }
         }
     }
 
@@ -8947,7 +8952,21 @@ zeGetRTASBuilderProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.RTASBuilder;
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnCreateExt                                = firstDriver->dditable.ze.RTASBuilder.pfnCreateExt;
+            }
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnGetBuildPropertiesExt                    = firstDriver->dditable.ze.RTASBuilder.pfnGetBuildPropertiesExt;
+            }
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnBuildExt                                 = firstDriver->dditable.ze.RTASBuilder.pfnBuildExt;
+            }
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnCommandListAppendCopyExt                 = firstDriver->dditable.ze.RTASBuilder.pfnCommandListAppendCopyExt;
+            }
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnDestroyExt                               = firstDriver->dditable.ze.RTASBuilder.pfnDestroyExt;
+            }
         }
     }
 
@@ -9054,7 +9073,18 @@ zeGetRTASBuilderExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.RTASBuilderExp;
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnCreateExp                                = firstDriver->dditable.ze.RTASBuilderExp.pfnCreateExp;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnGetBuildPropertiesExp                    = firstDriver->dditable.ze.RTASBuilderExp.pfnGetBuildPropertiesExp;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnBuildExp                                 = firstDriver->dditable.ze.RTASBuilderExp.pfnBuildExp;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnDestroyExp                               = firstDriver->dditable.ze.RTASBuilderExp.pfnDestroyExp;
+            }
         }
     }
 
@@ -9161,7 +9191,18 @@ zeGetRTASParallelOperationProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.RTASParallelOperation;
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnCreateExt                                = firstDriver->dditable.ze.RTASParallelOperation.pfnCreateExt;
+            }
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnGetPropertiesExt                         = firstDriver->dditable.ze.RTASParallelOperation.pfnGetPropertiesExt;
+            }
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnJoinExt                                  = firstDriver->dditable.ze.RTASParallelOperation.pfnJoinExt;
+            }
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnDestroyExt                               = firstDriver->dditable.ze.RTASParallelOperation.pfnDestroyExt;
+            }
         }
     }
 
@@ -9268,7 +9309,18 @@ zeGetRTASParallelOperationExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.RTASParallelOperationExp;
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnCreateExp                                = firstDriver->dditable.ze.RTASParallelOperationExp.pfnCreateExp;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnGetPropertiesExp                         = firstDriver->dditable.ze.RTASParallelOperationExp.pfnGetPropertiesExp;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnJoinExp                                  = firstDriver->dditable.ze.RTASParallelOperationExp.pfnJoinExp;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnDestroyExp                               = firstDriver->dditable.ze.RTASParallelOperationExp.pfnDestroyExp;
+            }
         }
     }
 
@@ -9406,7 +9458,33 @@ zeGetDriverProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Driver;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGet                                      = firstDriver->dditable.ze.Driver.pfnGet;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetApiVersion                            = firstDriver->dditable.ze.Driver.pfnGetApiVersion;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.ze.Driver.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetIpcProperties                         = firstDriver->dditable.ze.Driver.pfnGetIpcProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetExtensionProperties                   = firstDriver->dditable.ze.Driver.pfnGetExtensionProperties;
+            }
+            if (version >= ZE_API_VERSION_1_1) {
+                pDdiTable->pfnGetExtensionFunctionAddress              = firstDriver->dditable.ze.Driver.pfnGetExtensionFunctionAddress;
+            }
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnRTASFormatCompatibilityCheckExt          = firstDriver->dditable.ze.Driver.pfnRTASFormatCompatibilityCheckExt;
+            }
+            if (version >= ZE_API_VERSION_1_14) {
+                pDdiTable->pfnGetDefaultContext                        = firstDriver->dditable.ze.Driver.pfnGetDefaultContext;
+            }
+            if (version >= ZE_API_VERSION_1_6) {
+                pDdiTable->pfnGetLastErrorDescription                  = firstDriver->dditable.ze.Driver.pfnGetLastErrorDescription;
+            }
         }
     }
 
@@ -9492,7 +9570,9 @@ zeGetDriverExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.DriverExp;
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnRTASFormatCompatibilityCheckExp          = firstDriver->dditable.ze.DriverExp.pfnRTASFormatCompatibilityCheckExp;
+            }
         }
     }
 
@@ -9739,7 +9819,78 @@ zeGetDeviceProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Device;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGet                                      = firstDriver->dditable.ze.Device.pfnGet;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetSubDevices                            = firstDriver->dditable.ze.Device.pfnGetSubDevices;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.ze.Device.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetComputeProperties                     = firstDriver->dditable.ze.Device.pfnGetComputeProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetModuleProperties                      = firstDriver->dditable.ze.Device.pfnGetModuleProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetCommandQueueGroupProperties           = firstDriver->dditable.ze.Device.pfnGetCommandQueueGroupProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetMemoryProperties                      = firstDriver->dditable.ze.Device.pfnGetMemoryProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetMemoryAccessProperties                = firstDriver->dditable.ze.Device.pfnGetMemoryAccessProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetCacheProperties                       = firstDriver->dditable.ze.Device.pfnGetCacheProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetImageProperties                       = firstDriver->dditable.ze.Device.pfnGetImageProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetExternalMemoryProperties              = firstDriver->dditable.ze.Device.pfnGetExternalMemoryProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetP2PProperties                         = firstDriver->dditable.ze.Device.pfnGetP2PProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCanAccessPeer                            = firstDriver->dditable.ze.Device.pfnCanAccessPeer;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetStatus                                = firstDriver->dditable.ze.Device.pfnGetStatus;
+            }
+            if (version >= ZE_API_VERSION_1_1) {
+                pDdiTable->pfnGetGlobalTimestamps                      = firstDriver->dditable.ze.Device.pfnGetGlobalTimestamps;
+            }
+            if (version >= ZE_API_VERSION_1_12) {
+                pDdiTable->pfnImportExternalSemaphoreExt               = firstDriver->dditable.ze.Device.pfnImportExternalSemaphoreExt;
+            }
+            if (version >= ZE_API_VERSION_1_12) {
+                pDdiTable->pfnReleaseExternalSemaphoreExt              = firstDriver->dditable.ze.Device.pfnReleaseExternalSemaphoreExt;
+            }
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnGetVectorWidthPropertiesExt              = firstDriver->dditable.ze.Device.pfnGetVectorWidthPropertiesExt;
+            }
+            if (version >= ZE_API_VERSION_1_14) {
+                pDdiTable->pfnSynchronize                              = firstDriver->dditable.ze.Device.pfnSynchronize;
+            }
+            if (version >= ZE_API_VERSION_1_15) {
+                pDdiTable->pfnGetAggregatedCopyOffloadIncrementValue   = firstDriver->dditable.ze.Device.pfnGetAggregatedCopyOffloadIncrementValue;
+            }
+            if (version >= ZE_API_VERSION_1_2) {
+                pDdiTable->pfnReserveCacheExt                          = firstDriver->dditable.ze.Device.pfnReserveCacheExt;
+            }
+            if (version >= ZE_API_VERSION_1_2) {
+                pDdiTable->pfnSetCacheAdviceExt                        = firstDriver->dditable.ze.Device.pfnSetCacheAdviceExt;
+            }
+            if (version >= ZE_API_VERSION_1_3) {
+                pDdiTable->pfnPciGetPropertiesExt                      = firstDriver->dditable.ze.Device.pfnPciGetPropertiesExt;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnGetRootDevice                            = firstDriver->dditable.ze.Device.pfnGetRootDevice;
+            }
         }
     }
 
@@ -9825,7 +9976,9 @@ zeGetDeviceExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.DeviceExp;
+            if (version >= ZE_API_VERSION_1_4) {
+                pDdiTable->pfnGetFabricVertexExp                       = firstDriver->dditable.ze.DeviceExp.pfnGetFabricVertexExp;
+            }
         }
     }
 
@@ -9967,7 +10120,33 @@ zeGetContextProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Context;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.ze.Context.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.ze.Context.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetStatus                                = firstDriver->dditable.ze.Context.pfnGetStatus;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSystemBarrier                            = firstDriver->dditable.ze.Context.pfnSystemBarrier;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnMakeMemoryResident                       = firstDriver->dditable.ze.Context.pfnMakeMemoryResident;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEvictMemory                              = firstDriver->dditable.ze.Context.pfnEvictMemory;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnMakeImageResident                        = firstDriver->dditable.ze.Context.pfnMakeImageResident;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEvictImage                               = firstDriver->dditable.ze.Context.pfnEvictImage;
+            }
+            if (version >= ZE_API_VERSION_1_1) {
+                pDdiTable->pfnCreateEx                                 = firstDriver->dditable.ze.Context.pfnCreateEx;
+            }
         }
     }
 
@@ -10088,7 +10267,24 @@ zeGetCommandQueueProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.CommandQueue;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.ze.CommandQueue.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.ze.CommandQueue.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnExecuteCommandLists                      = firstDriver->dditable.ze.CommandQueue.pfnExecuteCommandLists;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSynchronize                              = firstDriver->dditable.ze.CommandQueue.pfnSynchronize;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetOrdinal                               = firstDriver->dditable.ze.CommandQueue.pfnGetOrdinal;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetIndex                                 = firstDriver->dditable.ze.CommandQueue.pfnGetIndex;
+            }
         }
     }
 
@@ -10433,7 +10629,120 @@ zeGetCommandListProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.CommandList;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.ze.CommandList.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreateImmediate                          = firstDriver->dditable.ze.CommandList.pfnCreateImmediate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.ze.CommandList.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnClose                                    = firstDriver->dditable.ze.CommandList.pfnClose;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnReset                                    = firstDriver->dditable.ze.CommandList.pfnReset;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendWriteGlobalTimestamp               = firstDriver->dditable.ze.CommandList.pfnAppendWriteGlobalTimestamp;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendBarrier                            = firstDriver->dditable.ze.CommandList.pfnAppendBarrier;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendMemoryRangesBarrier                = firstDriver->dditable.ze.CommandList.pfnAppendMemoryRangesBarrier;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendMemoryCopy                         = firstDriver->dditable.ze.CommandList.pfnAppendMemoryCopy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendMemoryFill                         = firstDriver->dditable.ze.CommandList.pfnAppendMemoryFill;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendMemoryCopyRegion                   = firstDriver->dditable.ze.CommandList.pfnAppendMemoryCopyRegion;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendMemoryCopyFromContext              = firstDriver->dditable.ze.CommandList.pfnAppendMemoryCopyFromContext;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendImageCopy                          = firstDriver->dditable.ze.CommandList.pfnAppendImageCopy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendImageCopyRegion                    = firstDriver->dditable.ze.CommandList.pfnAppendImageCopyRegion;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendImageCopyToMemory                  = firstDriver->dditable.ze.CommandList.pfnAppendImageCopyToMemory;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendImageCopyFromMemory                = firstDriver->dditable.ze.CommandList.pfnAppendImageCopyFromMemory;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendMemoryPrefetch                     = firstDriver->dditable.ze.CommandList.pfnAppendMemoryPrefetch;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendMemAdvise                          = firstDriver->dditable.ze.CommandList.pfnAppendMemAdvise;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendSignalEvent                        = firstDriver->dditable.ze.CommandList.pfnAppendSignalEvent;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendWaitOnEvents                       = firstDriver->dditable.ze.CommandList.pfnAppendWaitOnEvents;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendEventReset                         = firstDriver->dditable.ze.CommandList.pfnAppendEventReset;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendQueryKernelTimestamps              = firstDriver->dditable.ze.CommandList.pfnAppendQueryKernelTimestamps;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendLaunchKernel                       = firstDriver->dditable.ze.CommandList.pfnAppendLaunchKernel;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendLaunchCooperativeKernel            = firstDriver->dditable.ze.CommandList.pfnAppendLaunchCooperativeKernel;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendLaunchKernelIndirect               = firstDriver->dditable.ze.CommandList.pfnAppendLaunchKernelIndirect;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendLaunchMultipleKernelsIndirect      = firstDriver->dditable.ze.CommandList.pfnAppendLaunchMultipleKernelsIndirect;
+            }
+            if (version >= ZE_API_VERSION_1_12) {
+                pDdiTable->pfnAppendSignalExternalSemaphoreExt         = firstDriver->dditable.ze.CommandList.pfnAppendSignalExternalSemaphoreExt;
+            }
+            if (version >= ZE_API_VERSION_1_12) {
+                pDdiTable->pfnAppendWaitExternalSemaphoreExt           = firstDriver->dditable.ze.CommandList.pfnAppendWaitExternalSemaphoreExt;
+            }
+            if (version >= ZE_API_VERSION_1_14) {
+                pDdiTable->pfnAppendLaunchKernelWithParameters         = firstDriver->dditable.ze.CommandList.pfnAppendLaunchKernelWithParameters;
+            }
+            if (version >= ZE_API_VERSION_1_14) {
+                pDdiTable->pfnAppendLaunchKernelWithArguments          = firstDriver->dditable.ze.CommandList.pfnAppendLaunchKernelWithArguments;
+            }
+            if (version >= ZE_API_VERSION_1_3) {
+                pDdiTable->pfnAppendImageCopyToMemoryExt               = firstDriver->dditable.ze.CommandList.pfnAppendImageCopyToMemoryExt;
+            }
+            if (version >= ZE_API_VERSION_1_3) {
+                pDdiTable->pfnAppendImageCopyFromMemoryExt             = firstDriver->dditable.ze.CommandList.pfnAppendImageCopyFromMemoryExt;
+            }
+            if (version >= ZE_API_VERSION_1_6) {
+                pDdiTable->pfnHostSynchronize                          = firstDriver->dditable.ze.CommandList.pfnHostSynchronize;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetDeviceHandle                          = firstDriver->dditable.ze.CommandList.pfnGetDeviceHandle;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetContextHandle                         = firstDriver->dditable.ze.CommandList.pfnGetContextHandle;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetOrdinal                               = firstDriver->dditable.ze.CommandList.pfnGetOrdinal;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnImmediateGetIndex                        = firstDriver->dditable.ze.CommandList.pfnImmediateGetIndex;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnIsImmediate                              = firstDriver->dditable.ze.CommandList.pfnIsImmediate;
+            }
         }
     }
 
@@ -10568,7 +10877,30 @@ zeGetCommandListExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.CommandListExp;
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnGetNextCommandIdWithKernelsExp           = firstDriver->dditable.ze.CommandListExp.pfnGetNextCommandIdWithKernelsExp;
+            }
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnUpdateMutableCommandKernelsExp           = firstDriver->dditable.ze.CommandListExp.pfnUpdateMutableCommandKernelsExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnCreateCloneExp                           = firstDriver->dditable.ze.CommandListExp.pfnCreateCloneExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnImmediateAppendCommandListsExp           = firstDriver->dditable.ze.CommandListExp.pfnImmediateAppendCommandListsExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetNextCommandIdExp                      = firstDriver->dditable.ze.CommandListExp.pfnGetNextCommandIdExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnUpdateMutableCommandsExp                 = firstDriver->dditable.ze.CommandListExp.pfnUpdateMutableCommandsExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnUpdateMutableCommandSignalEventExp       = firstDriver->dditable.ze.CommandListExp.pfnUpdateMutableCommandSignalEventExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnUpdateMutableCommandWaitEventsExp        = firstDriver->dditable.ze.CommandListExp.pfnUpdateMutableCommandWaitEventsExp;
+            }
         }
     }
 
@@ -10759,7 +11091,54 @@ zeGetEventProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Event;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.ze.Event.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.ze.Event.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnHostSignal                               = firstDriver->dditable.ze.Event.pfnHostSignal;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnHostSynchronize                          = firstDriver->dditable.ze.Event.pfnHostSynchronize;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnQueryStatus                              = firstDriver->dditable.ze.Event.pfnQueryStatus;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnHostReset                                = firstDriver->dditable.ze.Event.pfnHostReset;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnQueryKernelTimestamp                     = firstDriver->dditable.ze.Event.pfnQueryKernelTimestamp;
+            }
+            if (version >= ZE_API_VERSION_1_15) {
+                pDdiTable->pfnCounterBasedCreate                       = firstDriver->dditable.ze.Event.pfnCounterBasedCreate;
+            }
+            if (version >= ZE_API_VERSION_1_15) {
+                pDdiTable->pfnCounterBasedGetIpcHandle                 = firstDriver->dditable.ze.Event.pfnCounterBasedGetIpcHandle;
+            }
+            if (version >= ZE_API_VERSION_1_15) {
+                pDdiTable->pfnCounterBasedOpenIpcHandle                = firstDriver->dditable.ze.Event.pfnCounterBasedOpenIpcHandle;
+            }
+            if (version >= ZE_API_VERSION_1_15) {
+                pDdiTable->pfnCounterBasedCloseIpcHandle               = firstDriver->dditable.ze.Event.pfnCounterBasedCloseIpcHandle;
+            }
+            if (version >= ZE_API_VERSION_1_15) {
+                pDdiTable->pfnCounterBasedGetDeviceAddress             = firstDriver->dditable.ze.Event.pfnCounterBasedGetDeviceAddress;
+            }
+            if (version >= ZE_API_VERSION_1_6) {
+                pDdiTable->pfnQueryKernelTimestampsExt                 = firstDriver->dditable.ze.Event.pfnQueryKernelTimestampsExt;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetEventPool                             = firstDriver->dditable.ze.Event.pfnGetEventPool;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetSignalScope                           = firstDriver->dditable.ze.Event.pfnGetSignalScope;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetWaitScope                             = firstDriver->dditable.ze.Event.pfnGetWaitScope;
+            }
         }
     }
 
@@ -10845,7 +11224,9 @@ zeGetEventExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.EventExp;
+            if (version >= ZE_API_VERSION_1_2) {
+                pDdiTable->pfnQueryTimestampsExp                       = firstDriver->dditable.ze.EventExp.pfnQueryTimestampsExp;
+            }
         }
     }
 
@@ -10980,7 +11361,30 @@ zeGetEventPoolProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.EventPool;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.ze.EventPool.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.ze.EventPool.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetIpcHandle                             = firstDriver->dditable.ze.EventPool.pfnGetIpcHandle;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOpenIpcHandle                            = firstDriver->dditable.ze.EventPool.pfnOpenIpcHandle;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCloseIpcHandle                           = firstDriver->dditable.ze.EventPool.pfnCloseIpcHandle;
+            }
+            if (version >= ZE_API_VERSION_1_6) {
+                pDdiTable->pfnPutIpcHandle                             = firstDriver->dditable.ze.EventPool.pfnPutIpcHandle;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetContextHandle                         = firstDriver->dditable.ze.EventPool.pfnGetContextHandle;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetFlags                                 = firstDriver->dditable.ze.EventPool.pfnGetFlags;
+            }
         }
     }
 
@@ -11094,7 +11498,21 @@ zeGetFenceProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Fence;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.ze.Fence.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.ze.Fence.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnHostSynchronize                          = firstDriver->dditable.ze.Fence.pfnHostSynchronize;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnQueryStatus                              = firstDriver->dditable.ze.Fence.pfnQueryStatus;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnReset                                    = firstDriver->dditable.ze.Fence.pfnReset;
+            }
         }
     }
 
@@ -11208,7 +11626,21 @@ zeGetImageProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Image;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.ze.Image.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.ze.Image.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.ze.Image.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_3) {
+                pDdiTable->pfnGetAllocPropertiesExt                    = firstDriver->dditable.ze.Image.pfnGetAllocPropertiesExt;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnViewCreateExt                            = firstDriver->dditable.ze.Image.pfnViewCreateExt;
+            }
         }
     }
 
@@ -11308,7 +11740,15 @@ zeGetImageExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.ImageExp;
+            if (version >= ZE_API_VERSION_1_2) {
+                pDdiTable->pfnGetMemoryPropertiesExp                   = firstDriver->dditable.ze.ImageExp.pfnGetMemoryPropertiesExp;
+            }
+            if (version >= ZE_API_VERSION_1_2) {
+                pDdiTable->pfnViewCreateExp                            = firstDriver->dditable.ze.ImageExp.pfnViewCreateExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetDeviceOffsetExp                       = firstDriver->dditable.ze.ImageExp.pfnGetDeviceOffsetExp;
+            }
         }
     }
 
@@ -11471,7 +11911,42 @@ zeGetKernelProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Kernel;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.ze.Kernel.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.ze.Kernel.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetCacheConfig                           = firstDriver->dditable.ze.Kernel.pfnSetCacheConfig;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetGroupSize                             = firstDriver->dditable.ze.Kernel.pfnSetGroupSize;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSuggestGroupSize                         = firstDriver->dditable.ze.Kernel.pfnSuggestGroupSize;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSuggestMaxCooperativeGroupCount          = firstDriver->dditable.ze.Kernel.pfnSuggestMaxCooperativeGroupCount;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetArgumentValue                         = firstDriver->dditable.ze.Kernel.pfnSetArgumentValue;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetIndirectAccess                        = firstDriver->dditable.ze.Kernel.pfnSetIndirectAccess;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetIndirectAccess                        = firstDriver->dditable.ze.Kernel.pfnGetIndirectAccess;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetSourceAttributes                      = firstDriver->dditable.ze.Kernel.pfnGetSourceAttributes;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.ze.Kernel.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetName                                  = firstDriver->dditable.ze.Kernel.pfnGetName;
+            }
         }
     }
 
@@ -11578,7 +12053,18 @@ zeGetKernelExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.KernelExp;
+            if (version >= ZE_API_VERSION_1_1) {
+                pDdiTable->pfnSetGlobalOffsetExp                       = firstDriver->dditable.ze.KernelExp.pfnSetGlobalOffsetExp;
+            }
+            if (version >= ZE_API_VERSION_1_11) {
+                pDdiTable->pfnGetBinaryExp                             = firstDriver->dditable.ze.KernelExp.pfnGetBinaryExp;
+            }
+            if (version >= ZE_API_VERSION_1_14) {
+                pDdiTable->pfnGetAllocationPropertiesExp               = firstDriver->dditable.ze.KernelExp.pfnGetAllocationPropertiesExp;
+            }
+            if (version >= ZE_API_VERSION_1_2) {
+                pDdiTable->pfnSchedulingHintExp                        = firstDriver->dditable.ze.KernelExp.pfnSchedulingHintExp;
+            }
         }
     }
 
@@ -11748,7 +12234,45 @@ zeGetMemProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Mem;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAllocShared                              = firstDriver->dditable.ze.Mem.pfnAllocShared;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAllocDevice                              = firstDriver->dditable.ze.Mem.pfnAllocDevice;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAllocHost                                = firstDriver->dditable.ze.Mem.pfnAllocHost;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnFree                                     = firstDriver->dditable.ze.Mem.pfnFree;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetAllocProperties                       = firstDriver->dditable.ze.Mem.pfnGetAllocProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetAddressRange                          = firstDriver->dditable.ze.Mem.pfnGetAddressRange;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetIpcHandle                             = firstDriver->dditable.ze.Mem.pfnGetIpcHandle;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOpenIpcHandle                            = firstDriver->dditable.ze.Mem.pfnOpenIpcHandle;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCloseIpcHandle                           = firstDriver->dditable.ze.Mem.pfnCloseIpcHandle;
+            }
+            if (version >= ZE_API_VERSION_1_15) {
+                pDdiTable->pfnGetIpcHandleWithProperties               = firstDriver->dditable.ze.Mem.pfnGetIpcHandleWithProperties;
+            }
+            if (version >= ZE_API_VERSION_1_3) {
+                pDdiTable->pfnFreeExt                                  = firstDriver->dditable.ze.Mem.pfnFreeExt;
+            }
+            if (version >= ZE_API_VERSION_1_6) {
+                pDdiTable->pfnPutIpcHandle                             = firstDriver->dditable.ze.Mem.pfnPutIpcHandle;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetPitchFor2dImage                       = firstDriver->dditable.ze.Mem.pfnGetPitchFor2dImage;
+            }
         }
     }
 
@@ -11855,7 +12379,18 @@ zeGetMemExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.MemExp;
+            if (version >= ZE_API_VERSION_1_6) {
+                pDdiTable->pfnGetIpcHandleFromFileDescriptorExp        = firstDriver->dditable.ze.MemExp.pfnGetIpcHandleFromFileDescriptorExp;
+            }
+            if (version >= ZE_API_VERSION_1_6) {
+                pDdiTable->pfnGetFileDescriptorFromIpcHandleExp        = firstDriver->dditable.ze.MemExp.pfnGetFileDescriptorFromIpcHandleExp;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnSetAtomicAccessAttributeExp              = firstDriver->dditable.ze.MemExp.pfnSetAtomicAccessAttributeExp;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnGetAtomicAccessAttributeExp              = firstDriver->dditable.ze.MemExp.pfnGetAtomicAccessAttributeExp;
+            }
         }
     }
 
@@ -11997,7 +12532,33 @@ zeGetModuleProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Module;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.ze.Module.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.ze.Module.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDynamicLink                              = firstDriver->dditable.ze.Module.pfnDynamicLink;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetNativeBinary                          = firstDriver->dditable.ze.Module.pfnGetNativeBinary;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetGlobalPointer                         = firstDriver->dditable.ze.Module.pfnGetGlobalPointer;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetKernelNames                           = firstDriver->dditable.ze.Module.pfnGetKernelNames;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.ze.Module.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetFunctionPointer                       = firstDriver->dditable.ze.Module.pfnGetFunctionPointer;
+            }
+            if (version >= ZE_API_VERSION_1_3) {
+                pDdiTable->pfnInspectLinkageExt                        = firstDriver->dditable.ze.Module.pfnInspectLinkageExt;
+            }
         }
     }
 
@@ -12090,7 +12651,12 @@ zeGetModuleBuildLogProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.ModuleBuildLog;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.ze.ModuleBuildLog.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetString                                = firstDriver->dditable.ze.ModuleBuildLog.pfnGetString;
+            }
         }
     }
 
@@ -12190,7 +12756,15 @@ zeGetPhysicalMemProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.PhysicalMem;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.ze.PhysicalMem.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.ze.PhysicalMem.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_15) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.ze.PhysicalMem.pfnGetProperties;
+            }
         }
     }
 
@@ -12283,7 +12857,12 @@ zeGetSamplerProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Sampler;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.ze.Sampler.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.ze.Sampler.pfnDestroy;
+            }
         }
     }
 
@@ -12411,7 +12990,27 @@ zeGetVirtualMemProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.VirtualMem;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnReserve                                  = firstDriver->dditable.ze.VirtualMem.pfnReserve;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnFree                                     = firstDriver->dditable.ze.VirtualMem.pfnFree;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnQueryPageSize                            = firstDriver->dditable.ze.VirtualMem.pfnQueryPageSize;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnMap                                      = firstDriver->dditable.ze.VirtualMem.pfnMap;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnUnmap                                    = firstDriver->dditable.ze.VirtualMem.pfnUnmap;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetAccessAttribute                       = firstDriver->dditable.ze.VirtualMem.pfnSetAccessAttribute;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetAccessAttribute                       = firstDriver->dditable.ze.VirtualMem.pfnGetAccessAttribute;
+            }
         }
     }
 
@@ -12511,7 +13110,15 @@ zeGetFabricEdgeExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.FabricEdgeExp;
+            if (version >= ZE_API_VERSION_1_4) {
+                pDdiTable->pfnGetExp                                   = firstDriver->dditable.ze.FabricEdgeExp.pfnGetExp;
+            }
+            if (version >= ZE_API_VERSION_1_4) {
+                pDdiTable->pfnGetVerticesExp                           = firstDriver->dditable.ze.FabricEdgeExp.pfnGetVerticesExp;
+            }
+            if (version >= ZE_API_VERSION_1_4) {
+                pDdiTable->pfnGetPropertiesExp                         = firstDriver->dditable.ze.FabricEdgeExp.pfnGetPropertiesExp;
+            }
         }
     }
 
@@ -12618,7 +13225,18 @@ zeGetFabricVertexExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.ze.FabricVertexExp;
+            if (version >= ZE_API_VERSION_1_4) {
+                pDdiTable->pfnGetExp                                   = firstDriver->dditable.ze.FabricVertexExp.pfnGetExp;
+            }
+            if (version >= ZE_API_VERSION_1_4) {
+                pDdiTable->pfnGetSubVerticesExp                        = firstDriver->dditable.ze.FabricVertexExp.pfnGetSubVerticesExp;
+            }
+            if (version >= ZE_API_VERSION_1_4) {
+                pDdiTable->pfnGetPropertiesExp                         = firstDriver->dditable.ze.FabricVertexExp.pfnGetPropertiesExp;
+            }
+            if (version >= ZE_API_VERSION_1_4) {
+                pDdiTable->pfnGetDeviceExp                             = firstDriver->dditable.ze.FabricVertexExp.pfnGetDeviceExp;
+            }
         }
     }
 
diff --git a/source/loader/zer_ldrddi.cpp b/source/loader/zer_ldrddi.cpp
index 0855eca4..6af3ceb8 100644
--- a/source/loader/zer_ldrddi.cpp
+++ b/source/loader/zer_ldrddi.cpp
@@ -241,7 +241,18 @@ zerGetGlobalProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zer.Global;
+            if (version >= ZE_API_VERSION_1_14) {
+                pDdiTable->pfnGetLastErrorDescription                  = firstDriver->dditable.zer.Global.pfnGetLastErrorDescription;
+            }
+            if (version >= ZE_API_VERSION_1_14) {
+                pDdiTable->pfnTranslateDeviceHandleToIdentifier        = firstDriver->dditable.zer.Global.pfnTranslateDeviceHandleToIdentifier;
+            }
+            if (version >= ZE_API_VERSION_1_14) {
+                pDdiTable->pfnTranslateIdentifierToDeviceHandle        = firstDriver->dditable.zer.Global.pfnTranslateIdentifierToDeviceHandle;
+            }
+            if (version >= ZE_API_VERSION_1_14) {
+                pDdiTable->pfnGetDefaultContext                        = firstDriver->dditable.zer.Global.pfnGetDefaultContext;
+            }
         }
     }
 
diff --git a/source/loader/zes_ldrddi.cpp b/source/loader/zes_ldrddi.cpp
index 2c2c1ef1..61ce3983 100644
--- a/source/loader/zes_ldrddi.cpp
+++ b/source/loader/zes_ldrddi.cpp
@@ -5729,7 +5729,9 @@ zesGetGlobalProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Global;
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnInit                                     = firstDriver->dditable.zes.Global.pfnInit;
+            }
         }
     }
 
@@ -6058,7 +6060,120 @@ zesGetDeviceProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Device;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Device.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetState                                 = firstDriver->dditable.zes.Device.pfnGetState;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnReset                                    = firstDriver->dditable.zes.Device.pfnReset;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnProcessesGetState                        = firstDriver->dditable.zes.Device.pfnProcessesGetState;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnPciGetProperties                         = firstDriver->dditable.zes.Device.pfnPciGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnPciGetState                              = firstDriver->dditable.zes.Device.pfnPciGetState;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnPciGetBars                               = firstDriver->dditable.zes.Device.pfnPciGetBars;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnPciGetStats                              = firstDriver->dditable.zes.Device.pfnPciGetStats;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumDiagnosticTestSuites                 = firstDriver->dditable.zes.Device.pfnEnumDiagnosticTestSuites;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumEngineGroups                         = firstDriver->dditable.zes.Device.pfnEnumEngineGroups;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEventRegister                            = firstDriver->dditable.zes.Device.pfnEventRegister;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumFabricPorts                          = firstDriver->dditable.zes.Device.pfnEnumFabricPorts;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumFans                                 = firstDriver->dditable.zes.Device.pfnEnumFans;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumFirmwares                            = firstDriver->dditable.zes.Device.pfnEnumFirmwares;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumFrequencyDomains                     = firstDriver->dditable.zes.Device.pfnEnumFrequencyDomains;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumLeds                                 = firstDriver->dditable.zes.Device.pfnEnumLeds;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumMemoryModules                        = firstDriver->dditable.zes.Device.pfnEnumMemoryModules;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumPerformanceFactorDomains             = firstDriver->dditable.zes.Device.pfnEnumPerformanceFactorDomains;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumPowerDomains                         = firstDriver->dditable.zes.Device.pfnEnumPowerDomains;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetCardPowerDomain                       = firstDriver->dditable.zes.Device.pfnGetCardPowerDomain;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumPsus                                 = firstDriver->dditable.zes.Device.pfnEnumPsus;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumRasErrorSets                         = firstDriver->dditable.zes.Device.pfnEnumRasErrorSets;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumSchedulers                           = firstDriver->dditable.zes.Device.pfnEnumSchedulers;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumStandbyDomains                       = firstDriver->dditable.zes.Device.pfnEnumStandbyDomains;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEnumTemperatureSensors                   = firstDriver->dditable.zes.Device.pfnEnumTemperatureSensors;
+            }
+            if (version >= ZE_API_VERSION_1_15) {
+                pDdiTable->pfnPciLinkSpeedUpdateExt                    = firstDriver->dditable.zes.Device.pfnPciLinkSpeedUpdateExt;
+            }
+            if (version >= ZE_API_VERSION_1_4) {
+                pDdiTable->pfnEccAvailable                             = firstDriver->dditable.zes.Device.pfnEccAvailable;
+            }
+            if (version >= ZE_API_VERSION_1_4) {
+                pDdiTable->pfnEccConfigurable                          = firstDriver->dditable.zes.Device.pfnEccConfigurable;
+            }
+            if (version >= ZE_API_VERSION_1_4) {
+                pDdiTable->pfnGetEccState                              = firstDriver->dditable.zes.Device.pfnGetEccState;
+            }
+            if (version >= ZE_API_VERSION_1_4) {
+                pDdiTable->pfnSetEccState                              = firstDriver->dditable.zes.Device.pfnSetEccState;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGet                                      = firstDriver->dditable.zes.Device.pfnGet;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnSetOverclockWaiver                       = firstDriver->dditable.zes.Device.pfnSetOverclockWaiver;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGetOverclockDomains                      = firstDriver->dditable.zes.Device.pfnGetOverclockDomains;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGetOverclockControls                     = firstDriver->dditable.zes.Device.pfnGetOverclockControls;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnResetOverclockSettings                   = firstDriver->dditable.zes.Device.pfnResetOverclockSettings;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnReadOverclockState                       = firstDriver->dditable.zes.Device.pfnReadOverclockState;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnEnumOverclockDomains                     = firstDriver->dditable.zes.Device.pfnEnumOverclockDomains;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnResetExt                                 = firstDriver->dditable.zes.Device.pfnResetExt;
+            }
         }
     }
 
@@ -6142,7 +6257,15 @@ zesGetDeviceExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.DeviceExp;
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnEnumEnabledVFExp                         = firstDriver->dditable.zes.DeviceExp.pfnEnumEnabledVFExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetSubDevicePropertiesExp                = firstDriver->dditable.zes.DeviceExp.pfnGetSubDevicePropertiesExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnEnumActiveVFExp                          = firstDriver->dditable.zes.DeviceExp.pfnEnumActiveVFExp;
+            }
         }
     }
 
@@ -6236,7 +6359,21 @@ zesGetDriverProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Driver;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnEventListen                              = firstDriver->dditable.zes.Driver.pfnEventListen;
+            }
+            if (version >= ZE_API_VERSION_1_1) {
+                pDdiTable->pfnEventListenEx                            = firstDriver->dditable.zes.Driver.pfnEventListenEx;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGet                                      = firstDriver->dditable.zes.Driver.pfnGet;
+            }
+            if (version >= ZE_API_VERSION_1_8) {
+                pDdiTable->pfnGetExtensionProperties                   = firstDriver->dditable.zes.Driver.pfnGetExtensionProperties;
+            }
+            if (version >= ZE_API_VERSION_1_8) {
+                pDdiTable->pfnGetExtensionFunctionAddress              = firstDriver->dditable.zes.Driver.pfnGetExtensionFunctionAddress;
+            }
         }
     }
 
@@ -6306,7 +6443,9 @@ zesGetDriverExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.DriverExp;
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetDeviceByUuidExp                       = firstDriver->dditable.zes.DriverExp.pfnGetDeviceByUuidExp;
+            }
         }
     }
 
@@ -6390,7 +6529,15 @@ zesGetDiagnosticsProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Diagnostics;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Diagnostics.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetTests                                 = firstDriver->dditable.zes.Diagnostics.pfnGetTests;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnRunTests                                 = firstDriver->dditable.zes.Diagnostics.pfnRunTests;
+            }
         }
     }
 
@@ -6474,7 +6621,15 @@ zesGetEngineProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Engine;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Engine.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnGetActivity                              = firstDriver->dditable.zes.Engine.pfnGetActivity;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnGetActivityExt                           = firstDriver->dditable.zes.Engine.pfnGetActivityExt;
+            }
         }
     }
 
@@ -6593,7 +6748,30 @@ zesGetFabricPortProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.FabricPort;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.FabricPort.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetLinkType                              = firstDriver->dditable.zes.FabricPort.pfnGetLinkType;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetConfig                                = firstDriver->dditable.zes.FabricPort.pfnGetConfig;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetConfig                                = firstDriver->dditable.zes.FabricPort.pfnSetConfig;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetState                                 = firstDriver->dditable.zes.FabricPort.pfnGetState;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetThroughput                            = firstDriver->dditable.zes.FabricPort.pfnGetThroughput;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnGetFabricErrorCounters                   = firstDriver->dditable.zes.FabricPort.pfnGetFabricErrorCounters;
+            }
+            if (version >= ZE_API_VERSION_1_7) {
+                pDdiTable->pfnGetMultiPortThroughput                   = firstDriver->dditable.zes.FabricPort.pfnGetMultiPortThroughput;
+            }
         }
     }
 
@@ -6698,7 +6876,24 @@ zesGetFanProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Fan;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Fan.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetConfig                                = firstDriver->dditable.zes.Fan.pfnGetConfig;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetDefaultMode                           = firstDriver->dditable.zes.Fan.pfnSetDefaultMode;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetFixedSpeedMode                        = firstDriver->dditable.zes.Fan.pfnSetFixedSpeedMode;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetSpeedTableMode                        = firstDriver->dditable.zes.Fan.pfnSetSpeedTableMode;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetState                                 = firstDriver->dditable.zes.Fan.pfnGetState;
+            }
         }
     }
 
@@ -6789,7 +6984,18 @@ zesGetFirmwareProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Firmware;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Firmware.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnFlash                                    = firstDriver->dditable.zes.Firmware.pfnFlash;
+            }
+            if (version >= ZE_API_VERSION_1_8) {
+                pDdiTable->pfnGetFlashProgress                         = firstDriver->dditable.zes.Firmware.pfnGetFlashProgress;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetConsoleLogs                           = firstDriver->dditable.zes.Firmware.pfnGetConsoleLogs;
+            }
         }
     }
 
@@ -6866,7 +7072,12 @@ zesGetFirmwareExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.FirmwareExp;
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetSecurityVersionExp                    = firstDriver->dditable.zes.FirmwareExp.pfnGetSecurityVersionExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnSetSecurityVersionExp                    = firstDriver->dditable.zes.FirmwareExp.pfnSetSecurityVersionExp;
+            }
         }
     }
 
@@ -7048,7 +7259,57 @@ zesGetFrequencyProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Frequency;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Frequency.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetAvailableClocks                       = firstDriver->dditable.zes.Frequency.pfnGetAvailableClocks;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetRange                                 = firstDriver->dditable.zes.Frequency.pfnGetRange;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetRange                                 = firstDriver->dditable.zes.Frequency.pfnSetRange;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetState                                 = firstDriver->dditable.zes.Frequency.pfnGetState;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetThrottleTime                          = firstDriver->dditable.zes.Frequency.pfnGetThrottleTime;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOcGetCapabilities                        = firstDriver->dditable.zes.Frequency.pfnOcGetCapabilities;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOcGetFrequencyTarget                     = firstDriver->dditable.zes.Frequency.pfnOcGetFrequencyTarget;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOcSetFrequencyTarget                     = firstDriver->dditable.zes.Frequency.pfnOcSetFrequencyTarget;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOcGetVoltageTarget                       = firstDriver->dditable.zes.Frequency.pfnOcGetVoltageTarget;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOcSetVoltageTarget                       = firstDriver->dditable.zes.Frequency.pfnOcSetVoltageTarget;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOcSetMode                                = firstDriver->dditable.zes.Frequency.pfnOcSetMode;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOcGetMode                                = firstDriver->dditable.zes.Frequency.pfnOcGetMode;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOcGetIccMax                              = firstDriver->dditable.zes.Frequency.pfnOcGetIccMax;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOcSetIccMax                              = firstDriver->dditable.zes.Frequency.pfnOcSetIccMax;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOcGetTjMax                               = firstDriver->dditable.zes.Frequency.pfnOcGetTjMax;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOcSetTjMax                               = firstDriver->dditable.zes.Frequency.pfnOcSetTjMax;
+            }
         }
     }
 
@@ -7139,7 +7400,18 @@ zesGetLedProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Led;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Led.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetState                                 = firstDriver->dditable.zes.Led.pfnGetState;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetState                                 = firstDriver->dditable.zes.Led.pfnSetState;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetColor                                 = firstDriver->dditable.zes.Led.pfnSetColor;
+            }
         }
     }
 
@@ -7223,7 +7495,15 @@ zesGetMemoryProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Memory;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Memory.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetState                                 = firstDriver->dditable.zes.Memory.pfnGetState;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetBandwidth                             = firstDriver->dditable.zes.Memory.pfnGetBandwidth;
+            }
         }
     }
 
@@ -7349,7 +7629,33 @@ zesGetOverclockProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Overclock;
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGetDomainProperties                      = firstDriver->dditable.zes.Overclock.pfnGetDomainProperties;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGetDomainVFProperties                    = firstDriver->dditable.zes.Overclock.pfnGetDomainVFProperties;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGetDomainControlProperties               = firstDriver->dditable.zes.Overclock.pfnGetDomainControlProperties;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGetControlCurrentValue                   = firstDriver->dditable.zes.Overclock.pfnGetControlCurrentValue;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGetControlPendingValue                   = firstDriver->dditable.zes.Overclock.pfnGetControlPendingValue;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnSetControlUserValue                      = firstDriver->dditable.zes.Overclock.pfnSetControlUserValue;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGetControlState                          = firstDriver->dditable.zes.Overclock.pfnGetControlState;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGetVFPointValues                         = firstDriver->dditable.zes.Overclock.pfnGetVFPointValues;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnSetVFPointValues                         = firstDriver->dditable.zes.Overclock.pfnSetVFPointValues;
+            }
         }
     }
 
@@ -7433,7 +7739,15 @@ zesGetPerformanceFactorProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.PerformanceFactor;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.PerformanceFactor.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetConfig                                = firstDriver->dditable.zes.PerformanceFactor.pfnGetConfig;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetConfig                                = firstDriver->dditable.zes.PerformanceFactor.pfnSetConfig;
+            }
         }
     }
 
@@ -7552,7 +7866,30 @@ zesGetPowerProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Power;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Power.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetEnergyCounter                         = firstDriver->dditable.zes.Power.pfnGetEnergyCounter;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetLimits                                = firstDriver->dditable.zes.Power.pfnGetLimits;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetLimits                                = firstDriver->dditable.zes.Power.pfnSetLimits;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetEnergyThreshold                       = firstDriver->dditable.zes.Power.pfnGetEnergyThreshold;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetEnergyThreshold                       = firstDriver->dditable.zes.Power.pfnSetEnergyThreshold;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetLimitsExt                             = firstDriver->dditable.zes.Power.pfnGetLimitsExt;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetLimitsExt                             = firstDriver->dditable.zes.Power.pfnSetLimitsExt;
+            }
         }
     }
 
@@ -7629,7 +7966,12 @@ zesGetPsuProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Psu;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Psu.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetState                                 = firstDriver->dditable.zes.Psu.pfnGetState;
+            }
         }
     }
 
@@ -7720,7 +8062,18 @@ zesGetRasProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Ras;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Ras.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetConfig                                = firstDriver->dditable.zes.Ras.pfnGetConfig;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetConfig                                = firstDriver->dditable.zes.Ras.pfnSetConfig;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetState                                 = firstDriver->dditable.zes.Ras.pfnGetState;
+            }
         }
     }
 
@@ -7797,7 +8150,12 @@ zesGetRasExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.RasExp;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetStateExp                              = firstDriver->dditable.zes.RasExp.pfnGetStateExp;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnClearStateExp                            = firstDriver->dditable.zes.RasExp.pfnClearStateExp;
+            }
         }
     }
 
@@ -7916,7 +8274,30 @@ zesGetSchedulerProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Scheduler;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Scheduler.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetCurrentMode                           = firstDriver->dditable.zes.Scheduler.pfnGetCurrentMode;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetTimeoutModeProperties                 = firstDriver->dditable.zes.Scheduler.pfnGetTimeoutModeProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetTimesliceModeProperties               = firstDriver->dditable.zes.Scheduler.pfnGetTimesliceModeProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetTimeoutMode                           = firstDriver->dditable.zes.Scheduler.pfnSetTimeoutMode;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetTimesliceMode                         = firstDriver->dditable.zes.Scheduler.pfnSetTimesliceMode;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetExclusiveMode                         = firstDriver->dditable.zes.Scheduler.pfnSetExclusiveMode;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetComputeUnitDebugMode                  = firstDriver->dditable.zes.Scheduler.pfnSetComputeUnitDebugMode;
+            }
         }
     }
 
@@ -8000,7 +8381,15 @@ zesGetStandbyProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Standby;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Standby.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetMode                                  = firstDriver->dditable.zes.Standby.pfnGetMode;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetMode                                  = firstDriver->dditable.zes.Standby.pfnSetMode;
+            }
         }
     }
 
@@ -8091,7 +8480,18 @@ zesGetTemperatureProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.Temperature;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zes.Temperature.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetConfig                                = firstDriver->dditable.zes.Temperature.pfnGetConfig;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetConfig                                = firstDriver->dditable.zes.Temperature.pfnSetConfig;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetState                                 = firstDriver->dditable.zes.Temperature.pfnGetState;
+            }
         }
     }
 
@@ -8217,7 +8617,33 @@ zesGetVFManagementExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->sysmanInstanceDrivers->front().dditable.zes.VFManagementExp;
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnGetVFCapabilitiesExp                     = firstDriver->dditable.zes.VFManagementExp.pfnGetVFCapabilitiesExp;
+            }
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnGetVFMemoryUtilizationExp2               = firstDriver->dditable.zes.VFManagementExp.pfnGetVFMemoryUtilizationExp2;
+            }
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnGetVFEngineUtilizationExp2               = firstDriver->dditable.zes.VFManagementExp.pfnGetVFEngineUtilizationExp2;
+            }
+            if (version >= ZE_API_VERSION_1_12) {
+                pDdiTable->pfnGetVFCapabilitiesExp2                    = firstDriver->dditable.zes.VFManagementExp.pfnGetVFCapabilitiesExp2;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetVFPropertiesExp                       = firstDriver->dditable.zes.VFManagementExp.pfnGetVFPropertiesExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetVFMemoryUtilizationExp                = firstDriver->dditable.zes.VFManagementExp.pfnGetVFMemoryUtilizationExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetVFEngineUtilizationExp                = firstDriver->dditable.zes.VFManagementExp.pfnGetVFEngineUtilizationExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnSetVFTelemetryModeExp                    = firstDriver->dditable.zes.VFManagementExp.pfnSetVFTelemetryModeExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnSetVFTelemetrySamplingIntervalExp        = firstDriver->dditable.zes.VFManagementExp.pfnSetVFTelemetrySamplingIntervalExp;
+            }
         }
     }
 
diff --git a/source/loader/zet_ldrddi.cpp b/source/loader/zet_ldrddi.cpp
index 9c128323..dae7f99e 100644
--- a/source/loader/zet_ldrddi.cpp
+++ b/source/loader/zet_ldrddi.cpp
@@ -3230,7 +3230,15 @@ zetGetMetricDecoderExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.MetricDecoderExp;
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnCreateExp                                = firstDriver->dditable.zet.MetricDecoderExp.pfnCreateExp;
+            }
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnDestroyExp                               = firstDriver->dditable.zet.MetricDecoderExp.pfnDestroyExp;
+            }
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnGetDecodableMetricsExp                   = firstDriver->dditable.zet.MetricDecoderExp.pfnGetDecodableMetricsExp;
+            }
         }
     }
 
@@ -3321,7 +3329,18 @@ zetGetMetricProgrammableExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.MetricProgrammableExp;
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetExp                                   = firstDriver->dditable.zet.MetricProgrammableExp.pfnGetExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetPropertiesExp                         = firstDriver->dditable.zet.MetricProgrammableExp.pfnGetPropertiesExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetParamInfoExp                          = firstDriver->dditable.zet.MetricProgrammableExp.pfnGetParamInfoExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnGetParamValueInfoExp                     = firstDriver->dditable.zet.MetricProgrammableExp.pfnGetParamValueInfoExp;
+            }
         }
     }
 
@@ -3426,7 +3445,24 @@ zetGetMetricTracerExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.MetricTracerExp;
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnCreateExp                                = firstDriver->dditable.zet.MetricTracerExp.pfnCreateExp;
+            }
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnDestroyExp                               = firstDriver->dditable.zet.MetricTracerExp.pfnDestroyExp;
+            }
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnEnableExp                                = firstDriver->dditable.zet.MetricTracerExp.pfnEnableExp;
+            }
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnDisableExp                               = firstDriver->dditable.zet.MetricTracerExp.pfnDisableExp;
+            }
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnReadDataExp                              = firstDriver->dditable.zet.MetricTracerExp.pfnReadDataExp;
+            }
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnDecodeExp                                = firstDriver->dditable.zet.MetricTracerExp.pfnDecodeExp;
+            }
         }
     }
 
@@ -3496,7 +3532,9 @@ zetGetDeviceProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.Device;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetDebugProperties                       = firstDriver->dditable.zet.Device.pfnGetDebugProperties;
+            }
         }
     }
 
@@ -3587,7 +3625,18 @@ zetGetDeviceExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.DeviceExp;
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnGetConcurrentMetricGroupsExp             = firstDriver->dditable.zet.DeviceExp.pfnGetConcurrentMetricGroupsExp;
+            }
+            if (version >= ZE_API_VERSION_1_10) {
+                pDdiTable->pfnCreateMetricGroupsFromMetricsExp         = firstDriver->dditable.zet.DeviceExp.pfnCreateMetricGroupsFromMetricsExp;
+            }
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnEnableMetricsExp                         = firstDriver->dditable.zet.DeviceExp.pfnEnableMetricsExp;
+            }
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnDisableMetricsExp                        = firstDriver->dditable.zet.DeviceExp.pfnDisableMetricsExp;
+            }
         }
     }
 
@@ -3657,7 +3706,9 @@ zetGetContextProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.Context;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnActivateMetricGroups                     = firstDriver->dditable.zet.Context.pfnActivateMetricGroups;
+            }
         }
     }
 
@@ -3748,7 +3799,18 @@ zetGetCommandListProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.CommandList;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendMetricStreamerMarker               = firstDriver->dditable.zet.CommandList.pfnAppendMetricStreamerMarker;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendMetricQueryBegin                   = firstDriver->dditable.zet.CommandList.pfnAppendMetricQueryBegin;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendMetricQueryEnd                     = firstDriver->dditable.zet.CommandList.pfnAppendMetricQueryEnd;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAppendMetricMemoryBarrier                = firstDriver->dditable.zet.CommandList.pfnAppendMetricMemoryBarrier;
+            }
         }
     }
 
@@ -3818,7 +3880,9 @@ zetGetCommandListExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.CommandListExp;
+            if (version >= ZE_API_VERSION_1_13) {
+                pDdiTable->pfnAppendMarkerExp                          = firstDriver->dditable.zet.CommandListExp.pfnAppendMarkerExp;
+            }
         }
     }
 
@@ -3888,7 +3952,9 @@ zetGetKernelProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.Kernel;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProfileInfo                           = firstDriver->dditable.zet.Kernel.pfnGetProfileInfo;
+            }
         }
     }
 
@@ -3958,7 +4024,9 @@ zetGetModuleProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.Module;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetDebugInfo                             = firstDriver->dditable.zet.Module.pfnGetDebugInfo;
+            }
         }
     }
 
@@ -4105,7 +4173,42 @@ zetGetDebugProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.Debug;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAttach                                   = firstDriver->dditable.zet.Debug.pfnAttach;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDetach                                   = firstDriver->dditable.zet.Debug.pfnDetach;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnReadEvent                                = firstDriver->dditable.zet.Debug.pfnReadEvent;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnAcknowledgeEvent                         = firstDriver->dditable.zet.Debug.pfnAcknowledgeEvent;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnInterrupt                                = firstDriver->dditable.zet.Debug.pfnInterrupt;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnResume                                   = firstDriver->dditable.zet.Debug.pfnResume;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnReadMemory                               = firstDriver->dditable.zet.Debug.pfnReadMemory;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnWriteMemory                              = firstDriver->dditable.zet.Debug.pfnWriteMemory;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetRegisterSetProperties                 = firstDriver->dditable.zet.Debug.pfnGetRegisterSetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnReadRegisters                            = firstDriver->dditable.zet.Debug.pfnReadRegisters;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnWriteRegisters                           = firstDriver->dditable.zet.Debug.pfnWriteRegisters;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGetThreadRegisterSetProperties           = firstDriver->dditable.zet.Debug.pfnGetThreadRegisterSetProperties;
+            }
         }
     }
 
@@ -4182,7 +4285,12 @@ zetGetMetricProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.Metric;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGet                                      = firstDriver->dditable.zet.Metric.pfnGet;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zet.Metric.pfnGetProperties;
+            }
         }
     }
 
@@ -4266,7 +4374,15 @@ zetGetMetricExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.MetricExp;
+            if (version >= ZE_API_VERSION_1_11) {
+                pDdiTable->pfnCreateFromProgrammableExp2               = firstDriver->dditable.zet.MetricExp.pfnCreateFromProgrammableExp2;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnCreateFromProgrammableExp                = firstDriver->dditable.zet.MetricExp.pfnCreateFromProgrammableExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnDestroyExp                               = firstDriver->dditable.zet.MetricExp.pfnDestroyExp;
+            }
         }
     }
 
@@ -4350,7 +4466,15 @@ zetGetMetricGroupProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.MetricGroup;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGet                                      = firstDriver->dditable.zet.MetricGroup.pfnGet;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetProperties                            = firstDriver->dditable.zet.MetricGroup.pfnGetProperties;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCalculateMetricValues                    = firstDriver->dditable.zet.MetricGroup.pfnCalculateMetricValues;
+            }
         }
     }
 
@@ -4476,7 +4600,33 @@ zetGetMetricGroupExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.MetricGroupExp;
+            if (version >= ZE_API_VERSION_1_2) {
+                pDdiTable->pfnCalculateMultipleMetricValuesExp         = firstDriver->dditable.zet.MetricGroupExp.pfnCalculateMultipleMetricValuesExp;
+            }
+            if (version >= ZE_API_VERSION_1_5) {
+                pDdiTable->pfnGetGlobalTimestampsExp                   = firstDriver->dditable.zet.MetricGroupExp.pfnGetGlobalTimestampsExp;
+            }
+            if (version >= ZE_API_VERSION_1_6) {
+                pDdiTable->pfnGetExportDataExp                         = firstDriver->dditable.zet.MetricGroupExp.pfnGetExportDataExp;
+            }
+            if (version >= ZE_API_VERSION_1_6) {
+                pDdiTable->pfnCalculateMetricExportDataExp             = firstDriver->dditable.zet.MetricGroupExp.pfnCalculateMetricExportDataExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnCreateExp                                = firstDriver->dditable.zet.MetricGroupExp.pfnCreateExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnAddMetricExp                             = firstDriver->dditable.zet.MetricGroupExp.pfnAddMetricExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnRemoveMetricExp                          = firstDriver->dditable.zet.MetricGroupExp.pfnRemoveMetricExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnCloseExp                                 = firstDriver->dditable.zet.MetricGroupExp.pfnCloseExp;
+            }
+            if (version >= ZE_API_VERSION_1_9) {
+                pDdiTable->pfnDestroyExp                               = firstDriver->dditable.zet.MetricGroupExp.pfnDestroyExp;
+            }
         }
     }
 
@@ -4567,7 +4717,18 @@ zetGetMetricQueryProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.MetricQuery;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.zet.MetricQuery.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.zet.MetricQuery.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnReset                                    = firstDriver->dditable.zet.MetricQuery.pfnReset;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnGetData                                  = firstDriver->dditable.zet.MetricQuery.pfnGetData;
+            }
         }
     }
 
@@ -4644,7 +4805,12 @@ zetGetMetricQueryPoolProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.MetricQueryPool;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.zet.MetricQueryPool.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.zet.MetricQueryPool.pfnDestroy;
+            }
         }
     }
 
@@ -4728,7 +4894,15 @@ zetGetMetricStreamerProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.MetricStreamer;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnOpen                                     = firstDriver->dditable.zet.MetricStreamer.pfnOpen;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnClose                                    = firstDriver->dditable.zet.MetricStreamer.pfnClose;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnReadData                                 = firstDriver->dditable.zet.MetricStreamer.pfnReadData;
+            }
         }
     }
 
@@ -4826,7 +5000,21 @@ zetGetTracerExpProcAddrTable(
         else
         {
             // return pointers directly to driver's DDIs
-            *pDdiTable = loader::context->zeDrivers.front().dditable.zet.TracerExp;
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnCreate                                   = firstDriver->dditable.zet.TracerExp.pfnCreate;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnDestroy                                  = firstDriver->dditable.zet.TracerExp.pfnDestroy;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetPrologues                             = firstDriver->dditable.zet.TracerExp.pfnSetPrologues;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetEpilogues                             = firstDriver->dditable.zet.TracerExp.pfnSetEpilogues;
+            }
+            if (version >= ZE_API_VERSION_1_0) {
+                pDdiTable->pfnSetEnabled                               = firstDriver->dditable.zet.TracerExp.pfnSetEnabled;
+            }
         }
     }