diff --git a/include/vk_debug_report_lunarg.h b/include/vk_debug_report_lunarg.h
index a8705a1..eeb8425 100644
--- a/include/vk_debug_report_lunarg.h
+++ b/include/vk_debug_report_lunarg.h
@@ -79,7 +79,7 @@
     VK_OBJECT_TYPE_FRAMEBUFFER = 30,
     VK_OBJECT_TYPE_RENDER_PASS = 31,
     VK_OBJECT_TYPE_PIPELINE_CACHE = 32,
-    VK_OBJECT_TYPE_SWAP_CHAIN_WSI = 33,
+    VK_OBJECT_TYPE_SWAPCHAIN_KHR = 33,
     VK_OBJECT_TYPE_CMD_POOL = 34,
     VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE,
     VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_CMD_POOL,
diff --git a/include/vk_layer.h b/include/vk_layer.h
index 886ca2d..721dfb2 100644
--- a/include/vk_layer.h
+++ b/include/vk_layer.h
@@ -7,8 +7,8 @@
 #include "vulkan.h"
 #include "vk_debug_report_lunarg.h"
 #include "vk_debug_marker_lunarg.h"
-#include "vk_wsi_swapchain.h"
-#include "vk_wsi_device_swapchain.h"
+#include "vk_ext_khr_swapchain.h"
+#include "vk_ext_khr_device_swapchain.h"
 #if defined(__GNUC__) && __GNUC__ >= 4
 #  define VK_LAYER_EXPORT __attribute__((visibility("default")))
 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
@@ -167,14 +167,14 @@
     PFN_vkCmdNextSubpass CmdNextSubpass;
     PFN_vkCmdEndRenderPass CmdEndRenderPass;
     PFN_vkCmdExecuteCommands CmdExecuteCommands;
-    PFN_vkGetSurfacePropertiesWSI GetSurfacePropertiesWSI;
-    PFN_vkGetSurfaceFormatsWSI GetSurfaceFormatsWSI;
-    PFN_vkGetSurfacePresentModesWSI GetSurfacePresentModesWSI;
-    PFN_vkCreateSwapChainWSI CreateSwapChainWSI;
-    PFN_vkDestroySwapChainWSI DestroySwapChainWSI;
-    PFN_vkGetSwapChainImagesWSI GetSwapChainImagesWSI;
-    PFN_vkAcquireNextImageWSI AcquireNextImageWSI;
-    PFN_vkQueuePresentWSI QueuePresentWSI;
+    PFN_vkGetSurfacePropertiesKHR GetSurfacePropertiesKHR;
+    PFN_vkGetSurfaceFormatsKHR GetSurfaceFormatsKHR;
+    PFN_vkGetSurfacePresentModesKHR GetSurfacePresentModesKHR;
+    PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
+    PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
+    PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
+    PFN_vkAcquireNextImageKHR AcquireNextImageKHR;
+    PFN_vkQueuePresentKHR QueuePresentKHR;
     PFN_vkDbgCreateMsgCallback DbgCreateMsgCallback;
     PFN_vkDbgDestroyMsgCallback DbgDestroyMsgCallback;
 } VkLayerDispatchTable;
@@ -195,7 +195,7 @@
     PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
     PFN_vkGetPhysicalDeviceExtensionProperties GetPhysicalDeviceExtensionProperties;
     PFN_vkGetPhysicalDeviceLayerProperties GetPhysicalDeviceLayerProperties;
-    PFN_vkGetPhysicalDeviceSurfaceSupportWSI GetPhysicalDeviceSurfaceSupportWSI;
+    PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
     PFN_vkDbgCreateMsgCallback DbgCreateMsgCallback;
     PFN_vkDbgDestroyMsgCallback DbgDestroyMsgCallback;
 } VkLayerInstanceDispatchTable;
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 2b82c66..d7e8316 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -70,7 +70,7 @@
 unordered_map<uint64_t,       MT_MEM_OBJ_INFO>      memObjMap;
 unordered_map<uint64_t,       MT_FENCE_INFO>        fenceMap;    // Map fence to fence info
 unordered_map<VkQueue,        MT_QUEUE_INFO>        queueMap;
-unordered_map<uint64_t,       MT_SWAP_CHAIN_INFO*>  swapChainMap;
+unordered_map<uint64_t,       MT_SWAP_CHAIN_INFO*>  swapchainMap;
 
 // Images and Buffers are 2 objects that can have memory bound to them so they get special treatment
 unordered_map<uint64_t, MT_OBJ_BINDING_INFO> imageMap;
@@ -349,11 +349,11 @@
 }
 
 static void add_swap_chain_info(
-    const VkSwapChainWSI swapChain, const VkSwapChainCreateInfoWSI* pCI)
+    const VkSwapchainKHR swapchain, const VkSwapchainCreateInfoKHR* pCI)
 {
     MT_SWAP_CHAIN_INFO* pInfo = new MT_SWAP_CHAIN_INFO;
-    memcpy(&pInfo->createInfo, pCI, sizeof(VkSwapChainCreateInfoWSI));
-    swapChainMap[swapChain.handle] = pInfo;
+    memcpy(&pInfo->createInfo, pCI, sizeof(VkSwapchainCreateInfoKHR));
+    swapchainMap[swapchain.handle] = pInfo;
 }
 
 // Add new CBInfo for this cb to map container
@@ -418,12 +418,12 @@
         // Swap Chain is very unique, use imageMap, but copy in
         // SwapChainCreatInfo's usage flags. This is used by vkCreateImageView
         // to distinguish swap chain images
-        case VK_OBJECT_TYPE_SWAP_CHAIN_WSI:
+        case VK_OBJECT_TYPE_SWAPCHAIN_KHR:
         {
             auto pCI = &imageMap[handle];
             memset(pCI, 0, sizeof(MT_OBJ_BINDING_INFO));
             pCI->create_info.image.usage =
-                const_cast<VkSwapChainCreateInfoWSI*>(static_cast<const VkSwapChainCreateInfoWSI *>(pCreateInfo))->imageUsageFlags;
+                const_cast<VkSwapchainCreateInfoKHR*>(static_cast<const VkSwapchainCreateInfoKHR *>(pCreateInfo))->imageUsageFlags;
             break;
         }
         // All other non-disp objects store their Create info struct as map value
@@ -1231,7 +1231,7 @@
                     "    Mem Alloc info:\n%s", pAllocInfoMsg.c_str());
         } else {
             log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
-                    "    Mem Alloc info is NULL (alloc done by vkCreateSwapChainWSI())");
+                    "    Mem Alloc info is NULL (alloc done by vkCreateSwapchainKHR())");
         }
 
         log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
@@ -1378,7 +1378,7 @@
     layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     my_device_data->wsi_enabled = false;
     for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0)
             my_device_data->wsi_enabled = true;
     }
 }
@@ -3020,78 +3020,78 @@
     return res;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapChainWSI(
+VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapchainKHR(
     VkDevice                        device,
-    const VkSwapChainCreateInfoWSI *pCreateInfo,
-    VkSwapChainWSI                 *pSwapChain)
+    const VkSwapchainCreateInfoKHR *pCreateInfo,
+    VkSwapchainKHR                 *pSwapchain)
 {
-    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateSwapChainWSI(device, pCreateInfo, pSwapChain);
+    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateSwapchainKHR(device, pCreateInfo, pSwapchain);
 
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        add_swap_chain_info(*pSwapChain, pCreateInfo);
+        add_swap_chain_info(*pSwapchain, pCreateInfo);
         loader_platform_thread_unlock_mutex(&globalLock);
     }
 
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDestroySwapChainWSI(
+VK_LAYER_EXPORT VkResult VKAPI vkDestroySwapchainKHR(
     VkDevice                        device,
-    VkSwapChainWSI swapChain)
+    VkSwapchainKHR swapchain)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    if (swapChainMap.find(swapChain.handle) != swapChainMap.end()) {
-        MT_SWAP_CHAIN_INFO* pInfo = swapChainMap[swapChain.handle];
+    if (swapchainMap.find(swapchain.handle) != swapchainMap.end()) {
+        MT_SWAP_CHAIN_INFO* pInfo = swapchainMap[swapchain.handle];
 
         if (pInfo->images.size() > 0) {
             for (auto it = pInfo->images.begin(); it != pInfo->images.end(); it++) {
-                clear_object_binding(device, it->handle, VK_OBJECT_TYPE_SWAP_CHAIN_WSI);
+                clear_object_binding(device, it->handle, VK_OBJECT_TYPE_SWAPCHAIN_KHR);
                 auto image_item = imageMap.find(it->handle);
                 if (image_item != imageMap.end())
                     imageMap.erase(image_item);
             }
         }
         delete pInfo;
-        swapChainMap.erase(swapChain.handle);
+        swapchainMap.erase(swapchain.handle);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    return get_dispatch_table(mem_tracker_device_table_map, device)->DestroySwapChainWSI(device, swapChain);
+    return get_dispatch_table(mem_tracker_device_table_map, device)->DestroySwapchainKHR(device, swapchain);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkGetSwapChainImagesWSI(
+VK_LAYER_EXPORT VkResult VKAPI vkGetSwapchainImagesKHR(
     VkDevice                device,
-    VkSwapChainWSI          swapChain,
+    VkSwapchainKHR          swapchain,
     uint32_t*               pCount,
-    VkImage*                pSwapChainImages)
+    VkImage*                pSwapchainImages)
 {
-    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->GetSwapChainImagesWSI(device, swapChain, pCount, pSwapChainImages);
+    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages);
 
-    if (result == VK_SUCCESS && pSwapChainImages != NULL) {
+    if (result == VK_SUCCESS && pSwapchainImages != NULL) {
         const size_t count = *pCount;
-        MT_SWAP_CHAIN_INFO *pInfo = swapChainMap[swapChain.handle];
+        MT_SWAP_CHAIN_INFO *pInfo = swapchainMap[swapchain.handle];
 
         if (pInfo->images.empty()) {
             pInfo->images.resize(count);
-            memcpy(&pInfo->images[0], pSwapChainImages, sizeof(pInfo->images[0]) * count);
+            memcpy(&pInfo->images[0], pSwapchainImages, sizeof(pInfo->images[0]) * count);
 
             if (pInfo->images.size() > 0) {
                 for (std::vector<VkImage>::const_iterator it = pInfo->images.begin();
                      it != pInfo->images.end(); it++) {
                     // Add image object binding, then insert the new Mem Object and then bind it to created image
-                    add_object_create_info(it->handle, VK_OBJECT_TYPE_SWAP_CHAIN_WSI, &pInfo->createInfo);
+                    add_object_create_info(it->handle, VK_OBJECT_TYPE_SWAPCHAIN_KHR, &pInfo->createInfo);
                 }
             }
         } else {
             const size_t count = *pCount;
-            MT_SWAP_CHAIN_INFO *pInfo = swapChainMap[swapChain.handle];
+            MT_SWAP_CHAIN_INFO *pInfo = swapchainMap[swapchain.handle];
             const bool mismatch = (pInfo->images.size() != count ||
-                    memcmp(&pInfo->images[0], pSwapChainImages, sizeof(pInfo->images[0]) * count));
+                    memcmp(&pInfo->images[0], pSwapchainImages, sizeof(pInfo->images[0]) * count));
 
             if (mismatch) {
-                // TODO : Want swapChain to be srcObj here
-                log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_SWAP_CHAIN_WSI, 0, 0, MEMTRACK_NONE, "SWAP_CHAIN",
-                        "vkGetSwapChainInfoWSI(%p, VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI) returned mismatching data", swapChain);
+                // TODO : Want swapchain to be srcObj here
+                log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_SWAPCHAIN_KHR, 0, 0, MEMTRACK_NONE, "SWAP_CHAIN",
+                        "vkGetSwapchainInfoKHR(%p, VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_KHR) returned mismatching data", swapchain);
             }
         }
     }
@@ -3293,16 +3293,16 @@
     layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map);
     if (my_device_data->wsi_enabled)
     {
-        if (!strcmp(funcName, "vkCreateSwapChainWSI"))
-            return (PFN_vkVoidFunction) vkCreateSwapChainWSI;
-        if (!strcmp(funcName, "vkDestroySwapChainWSI"))
-            return (PFN_vkVoidFunction) vkDestroySwapChainWSI;
-        if (!strcmp(funcName, "vkGetSwapChainImagesWSI"))
-            return (PFN_vkVoidFunction) vkGetSwapChainImagesWSI;
-//        if (!strcmp(funcName, "vkAcquireNextImageWSI"))
-//            return (PFN_vkVoidFunction) vkAcquireNextImageWSI;
-//        if (!strcmp(funcName, "vkQueuePresentWSI"))
-//            return (PFN_vkVoidFunction) vkQueuePresentWSI;
+        if (!strcmp(funcName, "vkCreateSwapchainKHR"))
+            return (PFN_vkVoidFunction) vkCreateSwapchainKHR;
+        if (!strcmp(funcName, "vkDestroySwapchainKHR"))
+            return (PFN_vkVoidFunction) vkDestroySwapchainKHR;
+        if (!strcmp(funcName, "vkGetSwapchainImagesKHR"))
+            return (PFN_vkVoidFunction) vkGetSwapchainImagesKHR;
+//        if (!strcmp(funcName, "vkAcquireNextImageKHR"))
+//            return (PFN_vkVoidFunction) vkAcquireNextImageKHR;
+//        if (!strcmp(funcName, "vkQueuePresentKHR"))
+//            return (PFN_vkVoidFunction) vkQueuePresentKHR;
     }
 
     VkLayerDispatchTable *pDisp  = get_dispatch_table(mem_tracker_device_table_map, dev);
diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h
index cc3a247..6ae878b 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -136,7 +136,7 @@
 };
 
 struct MT_SWAP_CHAIN_INFO {
-    VkSwapChainCreateInfoWSI             createInfo;
+    VkSwapchainCreateInfoKHR             createInfo;
     std::vector<VkImage> images;
 };
 
diff --git a/layers/object_track.h b/layers/object_track.h
index 80e1ccd..ca957fb 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -165,8 +165,8 @@
             return "VK_OBJECT_TYPE_SHADER";
         case VK_OBJECT_TYPE_SHADER_MODULE:
             return "VK_OBJECT_TYPE_SHADER_MODULE";
-        case VK_OBJECT_TYPE_SWAP_CHAIN_WSI:
-            return "VK_OBJECT_TYPE_SWAP_CHAIN_WSI";
+        case VK_OBJECT_TYPE_SWAPCHAIN_KHR:
+            return "VK_OBJECT_TYPE_SWAPCHAIN_KHR";
         default:
             return "Unhandled VkObjectType";
     }
@@ -181,7 +181,7 @@
     layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     my_device_data->wsi_enabled = false;
     for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_WSI_SWAPCHAIN_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
             my_device_data->wsi_enabled = true;
 
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], "OBJTRACK_EXTENSIONS") == 0)
@@ -237,8 +237,8 @@
 {
     uint32_t index = objType;
     if (objType > VK_OBJECT_TYPE_END_RANGE) {
-        // These come from vk_wsi_swapchain.h, rebase
-        index = (index -(VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NUMBER * -1000)) + VK_OBJECT_TYPE_END_RANGE;
+        // These come from vk_ext_khr_swapchain.h, rebase
+        index = (index -(VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NUMBER * -1000)) + VK_OBJECT_TYPE_END_RANGE;
     }
     return index;
 }
@@ -414,7 +414,7 @@
 extern unordered_map<const void*, OBJTRACK_NODE*> VkFenceMap;
 extern unordered_map<const void*, OBJTRACK_NODE*> VkSemaphoreMap;
 extern unordered_map<const void*, OBJTRACK_NODE*> VkCmdBufferMap;
-extern unordered_map<const void*, OBJTRACK_NODE*> VkSwapChainWSIMap;
+extern unordered_map<const void*, OBJTRACK_NODE*> VkSwapchainKHRMap;
 
 static void validate_object(VkQueue dispatchable_object, VkBuffer object)
 {
@@ -472,7 +472,7 @@
     numObjs[objIndex]++;
     numTotalObjs++;
 }
-static void create_obj(VkDevice dispatchable_object, VkSwapChainWSI vkObj, VkDbgObjectType objType)
+static void create_obj(VkDevice dispatchable_object, VkSwapchainKHR vkObj, VkDbgObjectType objType)
 {
     log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, vkObj.handle, 0, OBJTRACK_NONE, "OBJTRACK",
         "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),
@@ -482,15 +482,15 @@
     pNewObjNode->objType = objType;
     pNewObjNode->status  = OBJSTATUS_NONE;
     pNewObjNode->vkObj  = vkObj.handle;
-    VkSwapChainWSIMap[(void*) vkObj.handle] = pNewObjNode;
+    VkSwapchainKHRMap[(void*) vkObj.handle] = pNewObjNode;
     uint32_t objIndex = objTypeToIndex(objType);
     numObjs[objIndex]++;
     numTotalObjs++;
 }
-static void destroy_obj(VkDevice dispatchable_object, VkSwapChainWSI object)
+static void destroy_obj(VkDevice dispatchable_object, VkSwapchainKHR object)
 {
-    if (VkSwapChainWSIMap.find((void*) object.handle) != VkSwapChainWSIMap.end()) {
-        OBJTRACK_NODE* pNode = VkSwapChainWSIMap[(void*) object.handle];
+    if (VkSwapchainKHRMap.find((void*) object.handle) != VkSwapchainKHRMap.end()) {
+        OBJTRACK_NODE* pNode = VkSwapchainKHRMap[(void*) object.handle];
         uint32_t objIndex = objTypeToIndex(pNode->objType);
         assert(numTotalObjs > 0);
         numTotalObjs--;
@@ -501,7 +501,7 @@
             string_VkDbgObjectType(pNode->objType), object.handle, numTotalObjs, numObjs[objIndex],
             string_VkDbgObjectType(pNode->objType));
         delete pNode;
-        VkSwapChainWSIMap.erase((void*) object.handle);
+        VkSwapchainKHRMap.erase((void*) object.handle);
     } else {
         log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",
             "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",
@@ -760,16 +760,16 @@
 }
 
 VkResult
-explicit_DestroySwapChainWSI(
+explicit_DestroySwapchainKHR(
     VkDevice                        device,
-    VkSwapChainWSI swapChain)
+    VkSwapchainKHR swapchain)
 {
 
     loader_platform_thread_lock_mutex(&objLock);
-    destroy_obj(device, swapChain);
+    destroy_obj(device, swapchain);
     loader_platform_thread_unlock_mutex(&objLock);
 
-    VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->DestroySwapChainWSI(device, swapChain);
+    VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->DestroySwapchainKHR(device, swapchain);
 
     return result;
 }
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index 1190cb7..975ffb3 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -317,7 +317,7 @@
     VkLayerDispatchTable *pDisp  = get_dispatch_table(screenshot_device_table_map, device);
     deviceExtMap[pDisp].wsi_enabled = false;
     for (i = 0; i < pCreateInfo->extensionCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0)
             deviceExtMap[pDisp].wsi_enabled = true;
     }
 }
@@ -476,13 +476,13 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapChainWSI(
+VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapchainKHR(
     VkDevice                        device,
-    const VkSwapChainCreateInfoWSI *pCreateInfo,
-    VkSwapChainWSI                 *pSwapChain)
+    const VkSwapchainCreateInfoKHR *pCreateInfo,
+    VkSwapchainKHR                 *pSwapchain)
 {
     VkLayerDispatchTable* pTable = screenshot_device_table_map[device];
-    VkResult result = get_dispatch_table(screenshot_device_table_map, device)->CreateSwapChainWSI(device, pCreateInfo, pSwapChain);
+    VkResult result = get_dispatch_table(screenshot_device_table_map, device)->CreateSwapchainKHR(device, pCreateInfo, pSwapchain);
 
     loader_platform_thread_lock_mutex(&globalLock);
     if (screenshotEnvQueried && screenshotFrames.empty()) {
@@ -498,23 +498,23 @@
         swapchainMapElem->device = device;
         swapchainMapElem->imageExtent = pCreateInfo->imageExtent;
         swapchainMapElem->format = pCreateInfo->imageFormat;
-        swapchainMap.insert(make_pair(pSwapChain->handle, swapchainMapElem));
+        swapchainMap.insert(make_pair(pSwapchain->handle, swapchainMapElem));
 
         // Create a mapping for the swapchain object into the dispatch table
-        screenshot_device_table_map.emplace((void *)pSwapChain->handle, pTable);
+        screenshot_device_table_map.emplace((void *)pSwapchain->handle, pTable);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
 
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkGetSwapChainImagesWSI(
+VK_LAYER_EXPORT VkResult VKAPI vkGetSwapchainImagesKHR(
     VkDevice                device,
-    VkSwapChainWSI          swapChain,
+    VkSwapchainKHR          swapchain,
     uint32_t*               pCount,
-    VkImage*                pSwapChainImages)
+    VkImage*                pSwapchainImages)
 {
-    VkResult result = get_dispatch_table(screenshot_device_table_map, device)->GetSwapChainImagesWSI(device, swapChain, pCount, pSwapChainImages);
+    VkResult result = get_dispatch_table(screenshot_device_table_map, device)->GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages);
 
     loader_platform_thread_lock_mutex(&globalLock);
     if (screenshotEnvQueried && screenshotFrames.empty()) {
@@ -524,33 +524,33 @@
     }
 
     if (result == VK_SUCCESS &&
-        pSwapChainImages &&
-        !swapchainMap.empty() && swapchainMap.find(swapChain.handle) != swapchainMap.end())
+        pSwapchainImages &&
+        !swapchainMap.empty() && swapchainMap.find(swapchain.handle) != swapchainMap.end())
     {
         unsigned i;
 
         for (i=0; i<*pCount; i++)
         {
             // Create a mapping for an image to a device, image extent, and format
-            if (imageMap[pSwapChainImages[i].handle] == NULL)
+            if (imageMap[pSwapchainImages[i].handle] == NULL)
             {
                 ImageMapStruct *imageMapElem = new ImageMapStruct;
-                imageMap[pSwapChainImages[i].handle] = imageMapElem;
+                imageMap[pSwapchainImages[i].handle] = imageMapElem;
             }
-            imageMap[pSwapChainImages[i].handle]->device = swapchainMap[swapChain.handle]->device;
-            imageMap[pSwapChainImages[i].handle]->imageExtent = swapchainMap[swapChain.handle]->imageExtent;
-            imageMap[pSwapChainImages[i].handle]->format = swapchainMap[swapChain.handle]->format;
+            imageMap[pSwapchainImages[i].handle]->device = swapchainMap[swapchain.handle]->device;
+            imageMap[pSwapchainImages[i].handle]->imageExtent = swapchainMap[swapchain.handle]->imageExtent;
+            imageMap[pSwapchainImages[i].handle]->format = swapchainMap[swapchain.handle]->format;
         }
 
         // Add list of images to swapchain to image map
-        SwapchainMapStruct *swapchainMapElem = swapchainMap[swapChain.handle];
+        SwapchainMapStruct *swapchainMapElem = swapchainMap[swapchain.handle];
         if (i >= 1 && swapchainMapElem)
         {
             VkImage *imageList = new VkImage[i];
             swapchainMapElem->imageList = imageList;
             for (unsigned j=0; j<i; j++)
             {
-                swapchainMapElem->imageList[j] = pSwapChainImages[j].handle;
+                swapchainMapElem->imageList[j] = pSwapchainImages[j].handle;
             }
         }
 
@@ -559,11 +559,11 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueuePresentWSI(VkQueue queue, VkPresentInfoWSI* pPresentInfo)
+VK_LAYER_EXPORT VkResult VKAPI vkQueuePresentKHR(VkQueue queue, VkPresentInfoKHR* pPresentInfo)
 {
     static int frameNumber = 0;
     if (frameNumber == 10) {fflush(stdout); /* *((int*)0)=0; */ }
-    VkResult result = get_dispatch_table(screenshot_device_table_map, queue)->QueuePresentWSI(queue, pPresentInfo);
+    VkResult result = get_dispatch_table(screenshot_device_table_map, queue)->QueuePresentKHR(queue, pPresentInfo);
 
     loader_platform_thread_lock_mutex(&globalLock);
 
@@ -609,10 +609,10 @@
             fileName = to_string(frameNumber) + ".ppm";
 
             VkImage image;
-            uint64_t swapChain;
+            uint64_t swapchain;
             // We'll dump only one image: the first
-            swapChain = pPresentInfo->swapChains[0].handle;
-            image = swapchainMap[swapChain]->imageList[pPresentInfo->imageIndices[0]];
+            swapchain = pPresentInfo->swapchains[0].handle;
+            image = swapchainMap[swapchain]->imageList[pPresentInfo->imageIndices[0]];
             writePPM(fileName.c_str(), image);
             screenshotFrames.erase(it);
 
@@ -676,12 +676,12 @@
     VkLayerDispatchTable *pDisp =  get_dispatch_table(screenshot_device_table_map, dev);
     if (deviceExtMap.size() == 0 || deviceExtMap[pDisp].wsi_enabled)
     {
-        if (!strcmp(funcName, "vkCreateSwapChainWSI"))
-            return (PFN_vkVoidFunction) vkCreateSwapChainWSI;
-        if (!strcmp(funcName, "vkGetSwapChainImagesWSI"))
-            return (PFN_vkVoidFunction) vkGetSwapChainImagesWSI;
-        if (!strcmp(funcName, "vkQueuePresentWSI"))
-            return (PFN_vkVoidFunction) vkQueuePresentWSI;
+        if (!strcmp(funcName, "vkCreateSwapchainKHR"))
+            return (PFN_vkVoidFunction) vkCreateSwapchainKHR;
+        if (!strcmp(funcName, "vkGetSwapchainImagesKHR"))
+            return (PFN_vkVoidFunction) vkGetSwapchainImagesKHR;
+        if (!strcmp(funcName, "vkQueuePresentKHR"))
+            return (PFN_vkVoidFunction) vkQueuePresentKHR;
     }
 
     if (pDisp->GetDeviceProcAddr == NULL)
diff --git a/layers/vk_validation_layer_details.md b/layers/vk_validation_layer_details.md
index 812c107..3a6b186 100644
--- a/layers/vk_validation_layer_details.md
+++ b/layers/vk_validation_layer_details.md
@@ -198,12 +198,12 @@
 
 | Check | Overview | ENUM OBJTRACK_* | Relevant API | Testname | Notes/TODO |
 | ----- | -------- | ---------------- | ------------ | -------- | ---------- |
-| Valid Object | Validates that referenced object was properly created and is currently valid. | INVALID_OBJECT | vkAcquireNextImageWSI vkAllocDescriptorSets vkAllocMemory vkBeginCommandBuffer vkBindBufferMemory vkBindImageMemory vkCmdBeginQuery vkCmdBeginRenderPass vkCmdBindDescriptorSets vkCmdBindDynamicViewportState vkCmdBindDynamicLineWidthState vkCmdBindDynamicDepthBiasState vkCmdBindDynamicBlendState vkCmdBindDynamicDepthBoundsState vkCmdBindDynamicStencilState vkCmdBindIndexBuffer vkCmdBindPipeline vkCmdBindVertexBuffers vkCmdBlitImage vkCmdClearColorAttachment vkCmdClearColorImage vkCmdClearDepthStencilAttachment vkCmdClearDepthStencilImage vkCmdCopyBuffer vkCmdCopyBufferToImage vkCmdCopyImage vkCmdCopyImageToBuffer vkCmdCopyQueryPoolResults vkCmdDispatch vkCmdDispatchIndirect vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndexedIndirect vkCmdDrawIndirect vkCmdEndQuery vkCmdEndRenderPass vkCmdExecuteCommands vkCmdFillBuffer vkCmdNextSubpass vkCmdPipelineBarrier vkCmdPushConstants vkCmdResetEvent vkCmdResetQueryPool vkCmdResolveImage vkCmdSetEvent vkCmdUpdateBuffer vkCmdWaitEvents vkCmdWriteTimestamp vkCreateBuffer vkCreateBufferView vkCreateCommandBuffer vkCreateCommandPool vkCreateComputePipelines vkCreateDescriptorPool vkCreateDescriptorSetLayout vkCreateDynamicViewportState vkCreateDynamicLineWidthState vkCreateDynamicDepthBiasState vkCreateDynamicBlendState vkCreateDynamicDepthBoundsState vkCreateDynamicStencilState vkCreateEvent vkCreateFence vkCreateFramebuffer vkCreateGraphicsPipelines vkCreateImage vkCreateImageView vkCreatePipelineCache vkCreatePipelineLayout vkCreateQueryPool vkCreateRenderPass vkCreateSampler vkCreateSemaphore vkCreateShader vkCreateShaderModule vkCreateSwapChainWSI vkDestroyBuffer vkDestroyBufferView vkDestroyCommandBuffer vkDestroyCommandPool vkDestroyDescriptorPool vkDestroyDescriptorSetLayout vkDestroyDynamicBlendState vkDestroyDynamicLineWidthState vkDestroyDynamicDepthBiasState vkDestroyDynamicDepthBoundsState vkDestroyDynamicStencilState vkDestroyDynamicViewportState vkDestroyEvent vkDestroyFence vkDestroyFramebuffer vkDestroyImage vkDestroyImageView vkDestroyPipeline vkDestroyPipelineCache vkDestroyPipelineLayout vkDestroyQueryPool vkDestroyRenderPass vkDestroySampler vkDestroySemaphore vkDestroyShader vkDestroyShaderModule vkDestroySwapChainWSI vkDeviceWaitIdle vkEndCommandBuffer vkEnumeratePhysicalDevices vkFreeDescriptorSets vkFreeMemory vkFreeMemory vkGetBufferMemoryRequirements vkGetDeviceMemoryCommitment vkGetDeviceQueue vkGetEventStatus vkGetFenceStatus vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetImageSubresourceLayout vkGetPhysicalDeviceSurfaceSupportWSI vkGetPipelineCacheData vkGetPipelineCacheSize vkGetQueryPoolResults vkGetRenderAreaGranularity vkInvalidateMappedMemoryRanges vkMapMemory vkMergePipelineCaches vkQueueBindSparseBufferMemory vkQueueSignalSemaphore vkQueueWaitSemaphore vkResetCommandBuffer vkResetCommandPool vkResetDescriptorPool vkResetEvent vkResetFences vkSetEvent vkUnmapMemory vkUpdateDescriptorSets vkWaitForFences | ? | Every VkObject class of parameter will be run through this check. This check may ultimately supersede UNKNOWN_OBJECT |
+| Valid Object | Validates that referenced object was properly created and is currently valid. | INVALID_OBJECT | vkAcquireNextImageKHR vkAllocDescriptorSets vkAllocMemory vkBeginCommandBuffer vkBindBufferMemory vkBindImageMemory vkCmdBeginQuery vkCmdBeginRenderPass vkCmdBindDescriptorSets vkCmdBindDynamicViewportState vkCmdBindDynamicLineWidthState vkCmdBindDynamicDepthBiasState vkCmdBindDynamicBlendState vkCmdBindDynamicDepthBoundsState vkCmdBindDynamicStencilState vkCmdBindIndexBuffer vkCmdBindPipeline vkCmdBindVertexBuffers vkCmdBlitImage vkCmdClearColorAttachment vkCmdClearColorImage vkCmdClearDepthStencilAttachment vkCmdClearDepthStencilImage vkCmdCopyBuffer vkCmdCopyBufferToImage vkCmdCopyImage vkCmdCopyImageToBuffer vkCmdCopyQueryPoolResults vkCmdDispatch vkCmdDispatchIndirect vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndexedIndirect vkCmdDrawIndirect vkCmdEndQuery vkCmdEndRenderPass vkCmdExecuteCommands vkCmdFillBuffer vkCmdNextSubpass vkCmdPipelineBarrier vkCmdPushConstants vkCmdResetEvent vkCmdResetQueryPool vkCmdResolveImage vkCmdSetEvent vkCmdUpdateBuffer vkCmdWaitEvents vkCmdWriteTimestamp vkCreateBuffer vkCreateBufferView vkCreateCommandBuffer vkCreateCommandPool vkCreateComputePipelines vkCreateDescriptorPool vkCreateDescriptorSetLayout vkCreateDynamicViewportState vkCreateDynamicLineWidthState vkCreateDynamicDepthBiasState vkCreateDynamicBlendState vkCreateDynamicDepthBoundsState vkCreateDynamicStencilState vkCreateEvent vkCreateFence vkCreateFramebuffer vkCreateGraphicsPipelines vkCreateImage vkCreateImageView vkCreatePipelineCache vkCreatePipelineLayout vkCreateQueryPool vkCreateRenderPass vkCreateSampler vkCreateSemaphore vkCreateShader vkCreateShaderModule vkCreateSwapchainKHR vkDestroyBuffer vkDestroyBufferView vkDestroyCommandBuffer vkDestroyCommandPool vkDestroyDescriptorPool vkDestroyDescriptorSetLayout vkDestroyDynamicBlendState vkDestroyDynamicLineWidthState vkDestroyDynamicDepthBiasState vkDestroyDynamicDepthBoundsState vkDestroyDynamicStencilState vkDestroyDynamicViewportState vkDestroyEvent vkDestroyFence vkDestroyFramebuffer vkDestroyImage vkDestroyImageView vkDestroyPipeline vkDestroyPipelineCache vkDestroyPipelineLayout vkDestroyQueryPool vkDestroyRenderPass vkDestroySampler vkDestroySemaphore vkDestroyShader vkDestroyShaderModule vkDestroySwapchainKHR vkDeviceWaitIdle vkEndCommandBuffer vkEnumeratePhysicalDevices vkFreeDescriptorSets vkFreeMemory vkFreeMemory vkGetBufferMemoryRequirements vkGetDeviceMemoryCommitment vkGetDeviceQueue vkGetEventStatus vkGetFenceStatus vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetImageSubresourceLayout vkGetPhysicalDeviceSurfaceSupportKHR vkGetPipelineCacheData vkGetPipelineCacheSize vkGetQueryPoolResults vkGetRenderAreaGranularity vkInvalidateMappedMemoryRanges vkMapMemory vkMergePipelineCaches vkQueueBindSparseBufferMemory vkQueueSignalSemaphore vkQueueWaitSemaphore vkResetCommandBuffer vkResetCommandPool vkResetDescriptorPool vkResetEvent vkResetFences vkSetEvent vkUnmapMemory vkUpdateDescriptorSets vkWaitForFences | ? | Every VkObject class of parameter will be run through this check. This check may ultimately supersede UNKNOWN_OBJECT |
 | Object Cleanup | Verify that object properly destroyed | DESTROY_OBJECT_FAILED | vkDestroyInstance, vkDestroyDevice, vkFreeMemory | ? | NA |
 | Objects Leak | When an Instance or Device object is destroyed, validates that all objects belonging to that device/instance have previously been destroyed | OBJECT_LEAK | vkDestroyDevice vkDestroyInstance | ? | NA |
 | Object Count | Flag error if number of objects requested from extenstion functions exceeds max number of actual objects | OBJCOUNT_MAX_EXCEEDED | objTrackGetObjects objTrackGetObjectsOfType | ? | NA |
 | Valid Fence for Wait | Flag error if waiting on unsubmitted fence object | INVALID_FENCE | vkGetFenceStatus | WaitForUnsubmittedFence | NA |
-| Valid Destroy Object | Validates that an object pass into a destroy function was properly created and is currently valid | NONE | vkDestroyInstance vkDestroyDevice vkDestroyFence vkDestroySemaphore vkDestroyEvent vkDestroyQueryPool vkDestroyBuffer vkDestroyBufferView vkDestroyImage vkDestroyImageView vkDestroyShaderModule vkDestroyShader vkDestroyPipelineCache vkDestroyPipeline vkDestroyPipelineLayout vkDestroySampler vkDestroyDescriptorSetLayout vkDestroyDescriptorPool vkDestroyDynamicViewportState vkDestroyDynamicBlendState vkDestroyDynamicLineWidthState vkDestroyDynamicDepthBiasState vkDestroyDynamicDepthBoundsState vkDestroyDynamicStencilState vkDestroyCommandPool vkDestroyCommandBuffer vkDestroyFramebuffer vkDestroyRenderPass vkDestroySwapChainWSI | TBD | These cases need to be moved to a more appropriate error enum |
+| Valid Destroy Object | Validates that an object pass into a destroy function was properly created and is currently valid | NONE | vkDestroyInstance vkDestroyDevice vkDestroyFence vkDestroySemaphore vkDestroyEvent vkDestroyQueryPool vkDestroyBuffer vkDestroyBufferView vkDestroyImage vkDestroyImageView vkDestroyShaderModule vkDestroyShader vkDestroyPipelineCache vkDestroyPipeline vkDestroyPipelineLayout vkDestroySampler vkDestroyDescriptorSetLayout vkDestroyDescriptorPool vkDestroyDynamicViewportState vkDestroyDynamicBlendState vkDestroyDynamicLineWidthState vkDestroyDynamicDepthBiasState vkDestroyDynamicDepthBoundsState vkDestroyDynamicStencilState vkDestroyCommandPool vkDestroyCommandBuffer vkDestroyFramebuffer vkDestroyRenderPass vkDestroySwapchainKHR | TBD | These cases need to be moved to a more appropriate error enum |
 | Unknown object  | Internal layer errors when it attempts to update use count for an object that's not in its internal tracking datastructures. | UNKNOWN_OBJECT | | NA | This may be irrelevant due to INVALID_OBJECT error, need to look closely and merge this with that error as appropriate. |
 | NA | Enum used for informational messages | NONE | | NA | None |
 | NA | Enum used for errors in the layer itself. This does not indicate an app issue, but instead a bug in the layer. | INTERNAL_ERROR | | NA | None |
diff --git a/loader/loader.c b/loader/loader.c
index 87e854d..0ab7ca3 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -100,7 +100,7 @@
     .GetPhysicalDeviceExtensionProperties = loader_GetPhysicalDeviceExtensionProperties,
     .GetPhysicalDeviceLayerProperties = loader_GetPhysicalDeviceLayerProperties,
     .GetPhysicalDeviceSparseImageFormatProperties = loader_GetPhysicalDeviceSparseImageFormatProperties,
-    .GetPhysicalDeviceSurfaceSupportWSI = loader_GetPhysicalDeviceSurfaceSupportWSI,
+    .GetPhysicalDeviceSurfaceSupportKHR = loader_GetPhysicalDeviceSurfaceSupportKHR,
     .DbgCreateMsgCallback = loader_DbgCreateMsgCallback,
     .DbgDestroyMsgCallback = loader_DbgDestroyMsgCallback,
 };
@@ -1036,7 +1036,7 @@
     LOOKUP_GIPA(GetPhysicalDeviceSparseImageFormatProperties, true);
     LOOKUP_GIPA(DbgCreateMsgCallback, false);
     LOOKUP_GIPA(DbgDestroyMsgCallback, false);
-    LOOKUP_GIPA(GetPhysicalDeviceSurfaceSupportWSI, false);
+    LOOKUP_GIPA(GetPhysicalDeviceSurfaceSupportKHR, false);
 
 #undef LOOKUP_GIPA
 
diff --git a/loader/loader.h b/loader/loader.h
index 1e4a3ab..98c5756 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -30,7 +30,7 @@
 
 #include <vulkan.h>
 #include <vk_debug_report_lunarg.h>
-#include <vk_wsi_swapchain.h>
+#include <vk_ext_khr_swapchain.h>
 #include <vk_layer.h>
 #include <vk_icd.h>
 #include <assert.h>
@@ -144,7 +144,7 @@
     PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
     PFN_vkDbgCreateMsgCallback DbgCreateMsgCallback;
     PFN_vkDbgDestroyMsgCallback DbgDestroyMsgCallback;
-    PFN_vkGetPhysicalDeviceSurfaceSupportWSI GetPhysicalDeviceSurfaceSupportWSI;
+    PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
 
     /*
      * Fill in the cache of available device extensions from
diff --git a/loader/table_ops.h b/loader/table_ops.h
index 4064178..75c7b7a 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -178,14 +178,14 @@
 //TODO move into it's own table
 //TODO also consider dropping trampoline code for these device level extensions entirely
 // then don't need loader to know about these at all but then not queryable via GIPA
-    table->AcquireNextImageWSI = (PFN_vkAcquireNextImageWSI) gpa(dev, "vkAcquireNextImageWSI");
-    table->CreateSwapChainWSI = (PFN_vkCreateSwapChainWSI) gpa(dev, "vkCreateSwapChainWSI");
-    table->DestroySwapChainWSI = (PFN_vkDestroySwapChainWSI) gpa(dev, "vkDestroySwapChainWSI");
-    table->GetSurfacePropertiesWSI = (PFN_vkGetSurfacePropertiesWSI) gpa(dev, "vkGetSurfacePropertiesWSI");
-    table->GetSurfaceFormatsWSI = (PFN_vkGetSurfaceFormatsWSI) gpa(dev, "vkGetSurfaceFormatsWSI");
-    table->GetSurfacePresentModesWSI = (PFN_vkGetSurfacePresentModesWSI) gpa(dev, "vkGetSurfacePresentModesWSI");
-    table->GetSwapChainImagesWSI = (PFN_vkGetSwapChainImagesWSI) gpa(dev, "vkGetSwapChainImagesWSI");
-    table->QueuePresentWSI = (PFN_vkQueuePresentWSI) gpa(dev, "vkQueuePresentWSI");
+    table->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) gpa(dev, "vkAcquireNextImageKHR");
+    table->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) gpa(dev, "vkCreateSwapchainKHR");
+    table->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) gpa(dev, "vkDestroySwapchainKHR");
+    table->GetSurfacePropertiesKHR = (PFN_vkGetSurfacePropertiesKHR) gpa(dev, "vkGetSurfacePropertiesKHR");
+    table->GetSurfaceFormatsKHR = (PFN_vkGetSurfaceFormatsKHR) gpa(dev, "vkGetSurfaceFormatsKHR");
+    table->GetSurfacePresentModesKHR = (PFN_vkGetSurfacePresentModesKHR) gpa(dev, "vkGetSurfacePresentModesKHR");
+    table->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) gpa(dev, "vkGetSwapchainImagesKHR");
+    table->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(dev, "vkQueuePresentKHR");
 }
 
 static inline void *loader_lookup_device_dispatch_table(
@@ -547,8 +547,8 @@
         return (void *) table->GetPhysicalDeviceExtensionProperties;
     if (!strcmp(name, "GetPhysicalDeviceLayerProperties"))
         return (void *) table->GetPhysicalDeviceLayerProperties;
-    if (!strcmp(name, "GetPhysicalDeviceSurfaceSupportWSI"))
-        return (void *) table->GetPhysicalDeviceSurfaceSupportWSI;
+    if (!strcmp(name, "GetPhysicalDeviceSurfaceSupportKHR"))
+        return (void *) table->GetPhysicalDeviceSurfaceSupportKHR;
     if (!strcmp(name, "DbgCreateMsgCallback"))
         return (void *) table->DbgCreateMsgCallback;
     if (!strcmp(name, "DbgDestroyMsgCallback"))
diff --git a/loader/vk-loader-generate.py b/loader/vk-loader-generate.py
index eed42df..b51c6e4 100755
--- a/loader/vk-loader-generate.py
+++ b/loader/vk-loader-generate.py
@@ -48,7 +48,7 @@
     def _requires_special_trampoline_code(self, name):
         # Dont be cute trying to use a general rule to programmatically populate this list
         # it just obsfucates what is going on!
-        wsi_creates_dispatchable_object = ["CreateSwapChainWSI"]
+        wsi_creates_dispatchable_object = ["CreateSwapchainKHR"]
         creates_dispatchable_object = ["CreateDevice", "GetDeviceQueue", "CreateCommandBuffer"] + wsi_creates_dispatchable_object
         if name in creates_dispatchable_object:
             return True
@@ -136,13 +136,13 @@
         if "Get" in proto.name:
             method = "loader_set_dispatch"
 
-        if proto.name == "GetSwapChainInfoWSI":
+        if proto.name == "GetSwapchainInfoKHR":
             ptype = proto.params[-3].name
             psize = proto.params[-2].name
             pdata = proto.params[-1].name
-            cond = ("%s == VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI && "
+            cond = ("%s == VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_KHR && "
                     "%s && %s" % (ptype, pdata, cond))
-            setup.append("VkSwapChainImageInfoWSI *info = %s;" % pdata)
+            setup.append("VkSwapchainImageInfoKHR *info = %s;" % pdata)
             setup.append("size_t count = *%s / sizeof(*info), i;" % psize)
             setup.append("for (i = 0; i < count; i++) {")
             setup.append("    %s(info[i].image, disp);" % method)
@@ -342,7 +342,7 @@
         for proto in self.protos:
             if self.exports and proto.name not in self.exports:
                 continue
-            if proto.name.endswith("WSI"):
+            if proto.name.endswith("KHR"):
                 continue
             body.append("   vk" + proto.name)
 
diff --git a/loader/wsi_swapchain.c b/loader/wsi_swapchain.c
index 4860d84..683945e 100644
--- a/loader/wsi_swapchain.c
+++ b/loader/wsi_swapchain.c
@@ -35,8 +35,8 @@
 #include "wsi_swapchain.h"
 
 static const VkExtensionProperties wsi_swapchain_extension_info = {
-        .extName = VK_WSI_SWAPCHAIN_EXTENSION_NAME,
-        .specVersion = VK_WSI_SWAPCHAIN_REVISION,
+        .extName = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME,
+        .specVersion = VK_EXT_KHR_SWAPCHAIN_VERSION,
 };
 
 void wsi_swapchain_add_instance_extensions(
@@ -52,7 +52,7 @@
     ptr_instance->wsi_swapchain_enabled = false;
 
     for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_WSI_SWAPCHAIN_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
             ptr_instance->wsi_swapchain_enabled = true;
             return;
         }
@@ -61,19 +61,19 @@
 
 /*
  * This is the trampoline entrypoint
- * for GetPhysicalDeviceSurfaceSupportWSI
+ * for GetPhysicalDeviceSurfaceSupportKHR
  */
-VkResult wsi_swapchain_GetPhysicalDeviceSurfaceSupportWSI(
+VkResult wsi_swapchain_GetPhysicalDeviceSurfaceSupportKHR(
         VkPhysicalDevice                        physicalDevice,
         uint32_t                                queueNodeIndex,
-        const VkSurfaceDescriptionWSI*          pSurfaceDescription,
+        const VkSurfaceDescriptionKHR*          pSurfaceDescription,
         VkBool32*                               pSupported)
 {
     const VkLayerInstanceDispatchTable *disp;
 // TBD/TODO: DO WE NEED TO DO LOCKING FOR THIS FUNCTION?
     disp = loader_get_instance_dispatch(physicalDevice);
     loader_platform_thread_lock_mutex(&loader_lock);
-    VkResult res = disp->GetPhysicalDeviceSurfaceSupportWSI(
+    VkResult res = disp->GetPhysicalDeviceSurfaceSupportKHR(
                                                       physicalDevice,
                                                       queueNodeIndex,
                                                       pSurfaceDescription,
@@ -84,12 +84,12 @@
 
 /*
  * This is the instance chain terminator function
- * for GetPhysicalDeviceSurfaceSupportWSI
+ * for GetPhysicalDeviceSurfaceSupportKHR
  */
-VkResult VKAPI loader_GetPhysicalDeviceSurfaceSupportWSI(
+VkResult VKAPI loader_GetPhysicalDeviceSurfaceSupportKHR(
         VkPhysicalDevice                        physicalDevice,
         uint32_t                                queueNodeIndex,
-        const VkSurfaceDescriptionWSI*          pSurfaceDescription,
+        const VkSurfaceDescriptionKHR*          pSurfaceDescription,
         VkBool32*                               pSupported)
 {
     uint32_t gpu_index;
@@ -97,8 +97,8 @@
     VkResult res = VK_ERROR_UNAVAILABLE;
     *pSupported = false;
 
-    if (icd->GetPhysicalDeviceSurfaceSupportWSI) {
-        res = icd->GetPhysicalDeviceSurfaceSupportWSI(physicalDevice,
+    if (icd->GetPhysicalDeviceSurfaceSupportKHR) {
+        res = icd->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice,
                                                       queueNodeIndex,
                                                       pSurfaceDescription,
                                                       pSupported);
@@ -116,8 +116,8 @@
         return NULL;
     }
 
-    if (!strcmp(pName, "vkGetPhysicalDeviceSurfaceSupportWSI")) {
-        return (void*) wsi_swapchain_GetPhysicalDeviceSurfaceSupportWSI;
+    if (!strcmp(pName, "vkGetPhysicalDeviceSurfaceSupportKHR")) {
+        return (void*) wsi_swapchain_GetPhysicalDeviceSurfaceSupportKHR;
     }
 
     return NULL;
diff --git a/loader/wsi_swapchain.h b/loader/wsi_swapchain.h
index 68dbc96..c0904e9 100644
--- a/loader/wsi_swapchain.h
+++ b/loader/wsi_swapchain.h
@@ -29,7 +29,7 @@
 
 #include "vk_loader_platform.h"
 #include "loader.h"
-#include "vk_wsi_swapchain.h"
+#include "vk_ext_khr_swapchain.h"
 
 void wsi_swapchain_add_instance_extensions(
         struct loader_extension_list *ext_list);
@@ -42,8 +42,8 @@
         struct loader_instance                  *ptr_instance,
         const char*                             pName);
 
-VkResult VKAPI loader_GetPhysicalDeviceSurfaceSupportWSI(
+VkResult VKAPI loader_GetPhysicalDeviceSurfaceSupportKHR(
         VkPhysicalDevice                        physicalDevice,
         uint32_t                                queueNodeIndex,
-        const VkSurfaceDescriptionWSI*          pSurfaceDescription,
+        const VkSurfaceDescriptionKHR*          pSurfaceDescription,
         VkBool32*                               pSupported);
diff --git a/tests/test_environment.cpp b/tests/test_environment.cpp
index 402b147..da62397 100644
--- a/tests/test_environment.cpp
+++ b/tests/test_environment.cpp
@@ -1,8 +1,8 @@
 #include "test_common.h"
 #include "vktestbinding.h"
 #include "test_environment.h"
-#include "vk_wsi_swapchain.h"
-#include "vk_wsi_device_swapchain.h"
+#include "vk_ext_khr_swapchain.h"
+#include "vk_ext_khr_device_swapchain.h"
 
 #if defined(NDEBUG) && defined(__GNUC__)
 #define U_ASSERT_ONLY __attribute__((unused))
@@ -68,8 +68,8 @@
     std::vector<const char *> device_extension_names;
     std::vector<const char *> device_layer_names;
 
-    instance_extension_names.push_back(VK_WSI_SWAPCHAIN_EXTENSION_NAME);
-    device_extension_names.push_back(VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NAME);
+    instance_extension_names.push_back(VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME);
+    device_extension_names.push_back(VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME);
 
     VkBool32 extFound;
 
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index ff70f33..54708e2 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -26,8 +26,8 @@
  */
 
 #include "vkrenderframework.h"
-#include <vk_wsi_swapchain.h>
-#include <vk_wsi_device_swapchain.h>
+#include <vk_ext_khr_swapchain.h>
+#include <vk_ext_khr_device_swapchain.h>
 
 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
 #define GET_DEVICE_PROC_ADDR(dev, entrypoint)                           \
@@ -196,20 +196,20 @@
     VkResult err;
 
     // Get the list of VkFormat's that are supported:
-    PFN_vkGetSurfaceFormatsWSI fpGetSurfaceFormatsWSI;
+    PFN_vkGetSurfaceFormatsKHR fpGetSurfaceFormatsKHR;
     uint32_t formatCount;
-    VkSurfaceDescriptionWSI surface_description;
-    surface_description.sType = VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI;
+    VkSurfaceDescriptionKHR surface_description;
+    surface_description.sType = VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR;
     surface_description.pNext = NULL;
-    GET_DEVICE_PROC_ADDR(device(), GetSurfaceFormatsWSI);
-    err = fpGetSurfaceFormatsWSI(device(),
-                                    (VkSurfaceDescriptionWSI *) &surface_description,
+    GET_DEVICE_PROC_ADDR(device(), GetSurfaceFormatsKHR);
+    err = fpGetSurfaceFormatsKHR(device(),
+                                    (VkSurfaceDescriptionKHR *) &surface_description,
                                     &formatCount, NULL);
     ASSERT_VK_SUCCESS(err);
-    VkSurfaceFormatWSI *surfFormats =
-        (VkSurfaceFormatWSI *)malloc(formatCount * sizeof(VkSurfaceFormatWSI));
-    err = fpGetSurfaceFormatsWSI(device(),
-                                    (VkSurfaceDescriptionWSI *) &surface_description,
+    VkSurfaceFormatKHR *surfFormats =
+        (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
+    err = fpGetSurfaceFormatsKHR(device(),
+                                    (VkSurfaceDescriptionKHR *) &surface_description,
                                     &formatCount, surfFormats);
     ASSERT_VK_SUCCESS(err);
     m_render_target_fmt = surfFormats[0].format;
diff --git a/tests/vktestframework.cpp b/tests/vktestframework.cpp
index ff6a33d..2e24bff 100644
--- a/tests/vktestframework.cpp
+++ b/tests/vktestframework.cpp
@@ -28,8 +28,8 @@
 #include <math.h>
 #include <wand/MagickWand.h>
 #include <xcb/xcb.h>
-#include "vk_wsi_swapchain.h"
-#include "vk_wsi_device_swapchain.h"
+#include "vk_ext_khr_swapchain.h"
+#include "vk_ext_khr_device_swapchain.h"
 
 #if defined(PATH_MAX) && !defined(MAX_PATH)
 #define MAX_PATH PATH_MAX
@@ -87,11 +87,11 @@
     EOptionDefaultDesktop     = 0x1000,
 };
 
-typedef struct _SwapChainBuffers {
+typedef struct _SwapchainBuffers {
     VkImage image;
     VkCmdBuffer cmd;
     VkImageView view;
-} SwapChainBuffers;
+} SwapchainBuffers;
 
 class TestFrameworkVkPresent
 {
@@ -101,7 +101,7 @@
     void Run();
     void InitPresentFramework(std::list<VkTestImageRecord> &imagesIn, VkInstance inst);
     void CreateMyWindow();
-    void CreateSwapChain();
+    void CreateSwapchain();
     void TearDown();
 #ifdef _WIN32
     static LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
@@ -124,26 +124,26 @@
     xcb_screen_t                           *m_screen;
     xcb_window_t                            m_window;
     xcb_intern_atom_reply_t                *m_atom_wm_delete_window;
-    VkPlatformHandleXcbWSI                  m_platform_handle_xcb;
+    VkPlatformHandleXcbKHR                  m_platform_handle_xcb;
 #endif
     std::list<VkTestImageRecord>            m_images;
     uint32_t                                m_present_queue_node_index;
 
-    PFN_vkGetPhysicalDeviceSurfaceSupportWSI m_fpGetPhysicalDeviceSurfaceSupportWSI;
-    PFN_vkGetSurfacePropertiesWSI           m_fpGetSurfacePropertiesWSI;
-    PFN_vkGetSurfaceFormatsWSI              m_fpGetSurfaceFormatsWSI;
-    PFN_vkGetSurfacePresentModesWSI         m_fpGetSurfacePresentModesWSI;
-    PFN_vkCreateSwapChainWSI                m_fpCreateSwapChainWSI;
-    PFN_vkDestroySwapChainWSI               m_fpDestroySwapChainWSI;
-    PFN_vkGetSwapChainImagesWSI             m_fpGetSwapChainImagesWSI;
-    PFN_vkAcquireNextImageWSI               m_fpAcquireNextImageWSI;
-    PFN_vkQueuePresentWSI                   m_fpQueuePresentWSI;
-    VkSurfaceDescriptionWindowWSI           m_surface_description;
-    uint32_t                                m_swapChainImageCount;
-    VkSwapChainWSI                          m_swap_chain;
-    SwapChainBuffers                       *m_buffers;
+    PFN_vkGetPhysicalDeviceSurfaceSupportKHR m_fpGetPhysicalDeviceSurfaceSupportKHR;
+    PFN_vkGetSurfacePropertiesKHR           m_fpGetSurfacePropertiesKHR;
+    PFN_vkGetSurfaceFormatsKHR              m_fpGetSurfaceFormatsKHR;
+    PFN_vkGetSurfacePresentModesKHR         m_fpGetSurfacePresentModesKHR;
+    PFN_vkCreateSwapchainKHR                m_fpCreateSwapchainKHR;
+    PFN_vkDestroySwapchainKHR               m_fpDestroySwapchainKHR;
+    PFN_vkGetSwapchainImagesKHR             m_fpGetSwapchainImagesKHR;
+    PFN_vkAcquireNextImageKHR               m_fpAcquireNextImageKHR;
+    PFN_vkQueuePresentKHR                   m_fpQueuePresentKHR;
+    VkSurfaceDescriptionWindowKHR           m_surface_description;
+    uint32_t                                m_swapchainImageCount;
+    VkSwapchainKHR                          m_swap_chain;
+    SwapchainBuffers                       *m_buffers;
     VkFormat                                m_format;
-    VkColorSpaceWSI                         m_color_space;
+    VkColorSpaceKHR                         m_color_space;
 
     uint32_t                                m_current_buffer;
 
@@ -523,11 +523,11 @@
     assert(!err);
 
     // Get the index of the next available swapchain image:
-    err = m_fpAcquireNextImageWSI(m_device.handle(), m_swap_chain,
+    err = m_fpAcquireNextImageKHR(m_device.handle(), m_swap_chain,
                                       UINT64_MAX,
                                       presentCompleteSemaphore,
                                       &m_current_buffer);
-    // TODO: Deal with the VK_SUBOPTIMAL_WSI and VK_ERROR_OUT_OF_DATE_WSI
+    // TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
     // return codes
     assert(!err);
 
@@ -563,11 +563,11 @@
     vkQueueSubmit(m_queue.handle(), 1, cmdBufs, nullFence);
     m_queue.wait();
 
-    VkPresentInfoWSI present = {};
-    present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_WSI;
+    VkPresentInfoKHR present = {};
+    present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
     present.pNext = NULL;
-    present.swapChainCount = 1;
-    present.swapChains = & m_swap_chain;
+    present.swapchainCount = 1;
+    present.swapchains = & m_swap_chain;
     present.imageIndices = &m_current_buffer;
 
 #ifndef _WIN32
@@ -581,7 +581,7 @@
                          m_display_image->m_title.c_str());
 #endif
 
-    err = m_fpQueuePresentWSI(m_queue.handle(), &present);
+    err = m_fpQueuePresentKHR(m_queue.handle(), &present);
     assert(!err);
 
     m_queue.wait();
@@ -737,7 +737,7 @@
 }
 #endif // _WIN32
 
-void TestFrameworkVkPresent::CreateSwapChain()
+void TestFrameworkVkPresent::CreateSwapchain()
 {
     VkResult U_ASSERT_ONLY err;
 
@@ -745,16 +745,16 @@
     m_current_buffer = 0;
 
     // Construct the WSI surface description:
-    m_surface_description.sType = VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI;
+    m_surface_description.sType = VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR;
     m_surface_description.pNext = NULL;
 #ifdef _WIN32
-    m_surface_description.platform = VK_PLATFORM_WIN32_WSI;
+    m_surface_description.platform = VK_PLATFORM_WIN32_KHR;
     m_surface_description.pPlatformHandle = m_connection;
     m_surface_description.pPlatformWindow = m_window;
 #else  // _WIN32
     m_platform_handle_xcb.connection = m_connection;
     m_platform_handle_xcb.root = m_screen->root;
-    m_surface_description.platform = VK_PLATFORM_XCB_WSI;
+    m_surface_description.platform = VK_PLATFORM_XCB_KHR;
     m_surface_description.pPlatformHandle = &m_platform_handle_xcb;
     m_surface_description.pPlatformWindow = &m_window;
 #endif // _WIN32
@@ -766,9 +766,9 @@
     for (int i=0; i < queues.size(); i++)
     {
         int family_index = queues[i]->get_family_index();
-        m_fpGetPhysicalDeviceSurfaceSupportWSI(m_device.phy().handle(),
+        m_fpGetPhysicalDeviceSurfaceSupportKHR(m_device.phy().handle(),
                                                family_index,
-                                               (VkSurfaceDescriptionWSI *) &m_surface_description,
+                                               (VkSurfaceDescriptionKHR *) &m_surface_description,
                                                &supportsPresent);
         if (supportsPresent) {
             m_present_queue_node_index = family_index;
@@ -780,14 +780,14 @@
 
     // Get the list of VkFormat's that are supported:
     uint32_t formatCount;
-    err = m_fpGetSurfaceFormatsWSI(m_device.handle(),
-                                   (VkSurfaceDescriptionWSI *) &m_surface_description,
+    err = m_fpGetSurfaceFormatsKHR(m_device.handle(),
+                                   (VkSurfaceDescriptionKHR *) &m_surface_description,
                                    &formatCount, NULL);
     assert(!err);
-    VkSurfaceFormatWSI *surfFormats =
-        (VkSurfaceFormatWSI *)malloc(formatCount * sizeof(VkSurfaceFormatWSI));
-    err = m_fpGetSurfaceFormatsWSI(m_device.handle(),
-                                   (VkSurfaceDescriptionWSI *) &m_surface_description,
+    VkSurfaceFormatKHR *surfFormats =
+        (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
+    err = m_fpGetSurfaceFormatsKHR(m_device.handle(),
+                                   (VkSurfaceDescriptionKHR *) &m_surface_description,
                                    &formatCount, surfFormats);
     assert(!err);
     // If the format list includes just one entry of VK_FORMAT_UNDEFINED,
@@ -805,70 +805,70 @@
     m_color_space = surfFormats[0].colorSpace;
 
     // Check the surface proprties and formats
-    VkSurfacePropertiesWSI surfProperties;
-    err = m_fpGetSurfacePropertiesWSI(m_device.handle(),
-        (const VkSurfaceDescriptionWSI *)&m_surface_description,
+    VkSurfacePropertiesKHR surfProperties;
+    err = m_fpGetSurfacePropertiesKHR(m_device.handle(),
+        (const VkSurfaceDescriptionKHR *)&m_surface_description,
         &surfProperties);
     assert(!err);
 
     uint32_t presentModeCount;
-    err = m_fpGetSurfacePresentModesWSI(m_device.handle(),
-        (const VkSurfaceDescriptionWSI *)&m_surface_description,
+    err = m_fpGetSurfacePresentModesKHR(m_device.handle(),
+        (const VkSurfaceDescriptionKHR *)&m_surface_description,
         &presentModeCount, NULL);
     assert(!err);
-    VkPresentModeWSI *presentModes =
-        (VkPresentModeWSI *)malloc(presentModeCount * sizeof(VkPresentModeWSI));
+    VkPresentModeKHR *presentModes =
+        (VkPresentModeKHR *)malloc(presentModeCount * sizeof(VkPresentModeKHR));
     assert(presentModes);
-    err = m_fpGetSurfacePresentModesWSI(m_device.handle(),
-        (const VkSurfaceDescriptionWSI *)&m_surface_description,
+    err = m_fpGetSurfacePresentModesKHR(m_device.handle(),
+        (const VkSurfaceDescriptionKHR *)&m_surface_description,
         &presentModeCount, presentModes);
     assert(!err);
 
-    VkExtent2D swapChainExtent;
+    VkExtent2D swapchainExtent;
     // width and height are either both -1, or both not -1.
     if (surfProperties.currentExtent.width == -1)
     {
         // If the surface size is undefined, the size is set to
         // the size of the images requested.
-        swapChainExtent.width = m_width;
-        swapChainExtent.height = m_height;
+        swapchainExtent.width = m_width;
+        swapchainExtent.height = m_height;
     }
     else
     {
         // If the surface size is defined, the swap chain size must match
-        swapChainExtent = surfProperties.currentExtent;
+        swapchainExtent = surfProperties.currentExtent;
     }
 
     // If mailbox mode is available, use it, as is the lowest-latency non-
     // tearing mode.  If not, try IMMEDIATE which will usually be available,
     // and is fastest (though it tears).  If not, fall back to FIFO which is
     // always available.
-    VkPresentModeWSI swapChainPresentMode = VK_PRESENT_MODE_FIFO_WSI;
+    VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
     for (size_t i = 0; i < presentModeCount; i++) {
-        if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_WSI) {
-            swapChainPresentMode = VK_PRESENT_MODE_MAILBOX_WSI;
+        if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
+            swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
             break;
         }
-        if ((swapChainPresentMode != VK_PRESENT_MODE_MAILBOX_WSI) &&
-            (presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_WSI)) {
-            swapChainPresentMode = VK_PRESENT_MODE_IMMEDIATE_WSI;
+        if ((swapchainPresentMode != VK_PRESENT_MODE_MAILBOX_KHR) &&
+            (presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR)) {
+            swapchainPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
         }
     }
 
     // Determine the number of VkImage's to use in the swap chain (we desire to
     // own only 1 image at a time, besides the images being displayed and
     // queued for display):
-    uint32_t desiredNumberOfSwapChainImages = surfProperties.minImageCount + 1;
+    uint32_t desiredNumberOfSwapchainImages = surfProperties.minImageCount + 1;
     if ((surfProperties.maxImageCount > 0) &&
-        (desiredNumberOfSwapChainImages > surfProperties.maxImageCount))
+        (desiredNumberOfSwapchainImages > surfProperties.maxImageCount))
     {
         // Application must settle for fewer images than desired:
-        desiredNumberOfSwapChainImages = surfProperties.maxImageCount;
+        desiredNumberOfSwapchainImages = surfProperties.maxImageCount;
     }
 
-    VkSurfaceTransformWSI preTransform;
-    if (surfProperties.supportedTransforms & VK_SURFACE_TRANSFORM_NONE_BIT_WSI) {
-        preTransform = VK_SURFACE_TRANSFORM_NONE_WSI;
+    VkSurfaceTransformKHR preTransform;
+    if (surfProperties.supportedTransforms & VK_SURFACE_TRANSFORM_NONE_BIT_KHR) {
+        preTransform = VK_SURFACE_TRANSFORM_NONE_KHR;
     } else {
         preTransform = surfProperties.currentTransform;
     }
@@ -876,15 +876,15 @@
     // We want to blit to the swap chain, ensure the driver supports it.  Color is always supported, per WSI spec.
     assert((surfProperties.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT) != 0);
 
-    VkSwapChainCreateInfoWSI swap_chain = {};
-    swap_chain.sType = VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI;
+    VkSwapchainCreateInfoKHR swap_chain = {};
+    swap_chain.sType = VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_KHR;
     swap_chain.pNext = NULL;
-    swap_chain.pSurfaceDescription = (const VkSurfaceDescriptionWSI *)&m_surface_description;
-    swap_chain.minImageCount = desiredNumberOfSwapChainImages;
+    swap_chain.pSurfaceDescription = (const VkSurfaceDescriptionKHR *)&m_surface_description;
+    swap_chain.minImageCount = desiredNumberOfSwapchainImages;
     swap_chain.imageFormat = m_format;
     swap_chain.imageColorSpace = m_color_space;
-    swap_chain.imageExtent.width = swapChainExtent.width;
-    swap_chain.imageExtent.height = swapChainExtent.height;
+    swap_chain.imageExtent.width = swapchainExtent.width;
+    swap_chain.imageExtent.height = swapchainExtent.height;
     swap_chain.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT |
                                  VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
     swap_chain.preTransform = preTransform;
@@ -892,29 +892,29 @@
     swap_chain.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
     swap_chain.queueFamilyCount = 0;
     swap_chain.pQueueFamilyIndices = NULL;
-    swap_chain.presentMode = swapChainPresentMode;
-    swap_chain.oldSwapChain.handle = 0;
+    swap_chain.presentMode = swapchainPresentMode;
+    swap_chain.oldSwapchain.handle = 0;
     swap_chain.clipped = true;
 
     uint32_t i;
 
-    err = m_fpCreateSwapChainWSI(m_device.handle(), &swap_chain, &m_swap_chain);
+    err = m_fpCreateSwapchainKHR(m_device.handle(), &swap_chain, &m_swap_chain);
     assert(!err);
 
-    err = m_fpGetSwapChainImagesWSI(m_device.handle(), m_swap_chain,
-                                    &m_swapChainImageCount, NULL);
+    err = m_fpGetSwapchainImagesKHR(m_device.handle(), m_swap_chain,
+                                    &m_swapchainImageCount, NULL);
     assert(!err);
 
-    VkImage* swapChainImages = (VkImage*)malloc(m_swapChainImageCount * sizeof(VkImage));
-    assert(swapChainImages);
-    err = m_fpGetSwapChainImagesWSI(m_device.handle(), m_swap_chain,
-                                    &m_swapChainImageCount, swapChainImages);
+    VkImage* swapchainImages = (VkImage*)malloc(m_swapchainImageCount * sizeof(VkImage));
+    assert(swapchainImages);
+    err = m_fpGetSwapchainImagesKHR(m_device.handle(), m_swap_chain,
+                                    &m_swapchainImageCount, swapchainImages);
     assert(!err);
 
-    m_buffers = (SwapChainBuffers*)malloc(sizeof(SwapChainBuffers)*m_swapChainImageCount);
+    m_buffers = (SwapchainBuffers*)malloc(sizeof(SwapchainBuffers)*m_swapchainImageCount);
     assert(m_buffers);
 
-    for (i = 0; i < m_swapChainImageCount; i++) {
+    for (i = 0; i < m_swapchainImageCount; i++) {
         VkImageViewCreateInfo color_image_view = {};
         color_image_view.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
         color_image_view.pNext = NULL;
@@ -925,7 +925,7 @@
         color_image_view.subresourceRange.baseArraySlice = 0;
         color_image_view.subresourceRange.arraySize = 1;
 
-        m_buffers[i].image = swapChainImages[i];
+        m_buffers[i].image = swapchainImages[i];
 
         color_image_view.image = m_buffers[i].image;
         err = vkCreateImageView(m_device.handle(),
@@ -936,16 +936,16 @@
 
 void  TestFrameworkVkPresent::InitPresentFramework(std::list<VkTestImageRecord>  &imagesIn, VkInstance inst)
 {
-    GET_INSTANCE_PROC_ADDR(inst, GetPhysicalDeviceSurfaceSupportWSI);
-    GET_DEVICE_PROC_ADDR(m_device.handle(), GetSurfacePropertiesWSI);
-    GET_DEVICE_PROC_ADDR(m_device.handle(), GetSurfaceFormatsWSI);
-    GET_DEVICE_PROC_ADDR(m_device.handle(), GetSurfacePresentModesWSI);
-    GET_DEVICE_PROC_ADDR(m_device.handle(), CreateSwapChainWSI);
-    GET_DEVICE_PROC_ADDR(m_device.handle(), CreateSwapChainWSI);
-    GET_DEVICE_PROC_ADDR(m_device.handle(), DestroySwapChainWSI);
-    GET_DEVICE_PROC_ADDR(m_device.handle(), GetSwapChainImagesWSI);
-    GET_DEVICE_PROC_ADDR(m_device.handle(), AcquireNextImageWSI);
-    GET_DEVICE_PROC_ADDR(m_device.handle(), QueuePresentWSI);
+    GET_INSTANCE_PROC_ADDR(inst, GetPhysicalDeviceSurfaceSupportKHR);
+    GET_DEVICE_PROC_ADDR(m_device.handle(), GetSurfacePropertiesKHR);
+    GET_DEVICE_PROC_ADDR(m_device.handle(), GetSurfaceFormatsKHR);
+    GET_DEVICE_PROC_ADDR(m_device.handle(), GetSurfacePresentModesKHR);
+    GET_DEVICE_PROC_ADDR(m_device.handle(), CreateSwapchainKHR);
+    GET_DEVICE_PROC_ADDR(m_device.handle(), CreateSwapchainKHR);
+    GET_DEVICE_PROC_ADDR(m_device.handle(), DestroySwapchainKHR);
+    GET_DEVICE_PROC_ADDR(m_device.handle(), GetSwapchainImagesKHR);
+    GET_DEVICE_PROC_ADDR(m_device.handle(), AcquireNextImageKHR);
+    GET_DEVICE_PROC_ADDR(m_device.handle(), QueuePresentKHR);
 
     m_images = imagesIn;
 }
@@ -1073,7 +1073,7 @@
 
 void TestFrameworkVkPresent::TearDown()
 {
-    m_fpDestroySwapChainWSI(m_device.handle(), m_swap_chain);
+    m_fpDestroySwapchainKHR(m_device.handle(), m_swap_chain);
 #ifndef _WIN32
     xcb_destroy_window(m_connection, m_window);
     xcb_disconnect(m_connection);
@@ -1091,7 +1091,7 @@
 
         vkPresent.InitPresentFramework(m_images, env.get_instance());
         vkPresent.CreateMyWindow();
-        vkPresent.CreateSwapChain();
+        vkPresent.CreateSwapchain();
         vkPresent.Run();
         vkPresent.TearDown();
     }
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 619d04a..6410d32 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -288,7 +288,7 @@
 
                 if intercept is not None:
                     funcs.append(intercept)
-                    if not "WSI" in proto.name:
+                    if not "KHR" in proto.name:
                         intercepted.append(proto)
 
         prefix="vk"
@@ -600,7 +600,7 @@
         gen_header.append('    VkLayerDispatchTable *pDisp  = device_dispatch_table(device);')
         gen_header.append('    deviceExtMap[pDisp].wsi_enabled = false;')
         gen_header.append('    for (i = 0; i < pCreateInfo->extensionCount; i++) {')
-        gen_header.append('        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_WSI_SWAPCHAIN_EXTENSION_NAME) == 0)')
+        gen_header.append('        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)')
         gen_header.append('            deviceExtMap[pDisp].wsi_enabled = true;')
         gen_header.append('')
         gen_header.append('    }')
@@ -682,8 +682,8 @@
     def generate_body(self):
         self.layer_name = "Generic"
         extensions=[('wsi_enabled', 
-                     ['vkCreateSwapChainWSI', 'vkDestroySwapChainWSI',
-                      'vkGetSwapChainImagesWSI', 'vkQueuePresentWSI'])]
+                     ['vkCreateSwapchainKHR', 'vkDestroySwapchainKHR',
+                      'vkGetSwapchainImagesKHR', 'vkQueuePresentKHR'])]
         body = [self._generate_layer_initialization(True),
                 self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"),
                 self._gen_create_msg_callback(),
@@ -782,7 +782,7 @@
         header_txt.append('    VkLayerDispatchTable *pDisp  = device_dispatch_table(device);')
         header_txt.append('    deviceExtMap[pDisp].wsi_enabled = false;')
         header_txt.append('    for (i = 0; i < pCreateInfo->extensionCount; i++) {')
-        header_txt.append('        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_WSI_SWAPCHAIN_EXTENSION_NAME) == 0)')
+        header_txt.append('        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)')
         header_txt.append('            deviceExtMap[pDisp].wsi_enabled = true;')
         header_txt.append('')
         header_txt.append('    }')
@@ -935,9 +935,9 @@
                     if p.name == proto.params[y].name:
                         cp = True
             (pft, pfi) = self._get_printf_params(p.ty, p.name, cp, cpp=True)
-            if p.name == "pSwapChain":
+            if p.name == "pSwapchain":
                 log_func += '%s = " << %s->handle << ", ' % (p.name, p.name)
-            elif p.name == "swapChain":
+            elif p.name == "swapchain":
                 log_func += '%s = " << %s.handle << ", ' % (p.name, p.name)
             else:
                 log_func += '%s = " << %s << ", ' % (p.name, pfi)
@@ -1092,8 +1092,8 @@
     def generate_body(self):
         self.layer_name = "APIDump"
         extensions=[('wsi_enabled',
-                    ['vkCreateSwapChainWSI', 'vkDestroySwapChainWSI',
-                    'vkGetSwapChainImagesWSI', 'vkQueuePresentWSI'])]
+                    ['vkCreateSwapchainKHR', 'vkDestroySwapchainKHR',
+                    'vkGetSwapchainImagesKHR', 'vkQueuePresentKHR'])]
         body = [self.generate_init(),
                 self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"),
                 self._generate_layer_gpa_function(extensions)]
@@ -1133,7 +1133,7 @@
         maps_txt = []
         for o in vulkan.core.objects:
             maps_txt.append('unordered_map<const void*, OBJTRACK_NODE*> %sMap;' % (o))
-        maps_txt.append('unordered_map<const void*, OBJTRACK_NODE*> VkSwapChainWSIMap;')
+        maps_txt.append('unordered_map<const void*, OBJTRACK_NODE*> VkSwapchainKHRMap;')
         return "\n".join(maps_txt)
 
     def generate_procs(self):
@@ -1457,7 +1457,7 @@
             "MapMemory",
             "UnmapMemory",
             "FreeMemory",
-            "DestroySwapChainWSI"
+            "DestroySwapchainKHR"
         ]
         decl = proto.c_func(prefix="vk", attr="VKAPI")
         param0_name = proto.params[0].name
@@ -1584,8 +1584,8 @@
     def generate_body(self):
         self.layer_name = "ObjectTracker"
         extensions=[('wsi_enabled',
-                    ['vkCreateSwapChainWSI', 'vkDestroySwapChainWSI',
-                     'vkGetSwapChainImagesWSI', 'vkQueuePresentWSI'])]
+                    ['vkCreateSwapchainKHR', 'vkDestroySwapchainKHR',
+                     'vkGetSwapchainImagesKHR', 'vkQueuePresentKHR'])]
         body = [self.generate_maps(),
                 self.generate_procs(),
                 self.generate_destroy_instance(),
@@ -1770,7 +1770,7 @@
         if 'Get' in proto.name:
             return None
         # All WSI functions are thread safe
-        if 'WSI' in proto.name:
+        if 'KHR' in proto.name:
             return None
         # Initialize in early calls
         if proto.name == "CreateDevice":
diff --git a/vk_helper.py b/vk_helper.py
index 4becc7d..0112087 100755
--- a/vk_helper.py
+++ b/vk_helper.py
@@ -122,7 +122,7 @@
         # TODO : Comment parsing is very fragile but handles 2 known files
         block_comment = False
         prev_count_name = ''
-        exclude_struct_list = ['VkPlatformHandleXcbWSI', 'VkPlatformHandleX11WSI']
+        exclude_struct_list = ['VkPlatformHandleXcbKHR', 'VkPlatformHandleX11KHR']
         with open(self.header_file) as f:
             for line in f:
                 if block_comment:
@@ -172,6 +172,9 @@
                         (cur_char, targ_type) = line.strip().split(None, 1)
                         if 'tmp_struct' == base_type:
                             base_type = targ_type.strip(';')
+                            if True in [ex_type in base_type for ex_type in exclude_struct_list]:
+                                del self.struct_dict['tmp_struct']
+                                continue
                             #print("Found Actual Struct type %s" % base_type)
                             self.struct_dict[base_type] = self.struct_dict['tmp_struct']
                             self.struct_dict.pop('tmp_struct', 0)
@@ -996,20 +999,20 @@
         sh_funcs.append("}")
         sh_funcs.append('%s' % lineinfo.get())
         #### TODO: Get the following function moved to be in "vk_enum_string_helper.h"
-        # Add function to return a string value for input VkSurfaceFormatWSI*
-        sh_funcs.append("static inline const char* string_VkColorSpaceWSI(VkColorSpaceWSI input_value)\n{")
-        sh_funcs.append("    switch ((VkColorSpaceWSI)input_value)")
+        # Add function to return a string value for input VkSurfaceFormatKHR*
+        sh_funcs.append("static inline const char* string_VkColorSpaceKHR(VkColorSpaceKHR input_value)\n{")
+        sh_funcs.append("    switch ((VkColorSpaceKHR)input_value)")
         sh_funcs.append("    {")
-        sh_funcs.append("        case VK_COLORSPACE_SRGB_NONLINEAR_WSI:")
-        sh_funcs.append("            return \"VK_COLORSPACE_SRGB_NONLINEAR_WSI\";")
+        sh_funcs.append("        case VK_COLORSPACE_SRGB_NONLINEAR_KHR:")
+        sh_funcs.append("            return \"VK_COLORSPACE_SRGB_NONLINEAR_KHR\";")
         sh_funcs.append("        default:")
-        sh_funcs.append("            return \"Unhandled VkColorSpaceWSI\";")
+        sh_funcs.append("            return \"Unhandled VkColorSpaceKHR\";")
         sh_funcs.append("    }")
         sh_funcs.append("}")
         sh_funcs.append('%s' % lineinfo.get())
-        # Add function to return a string value for input VkSurfaceFormatWSI*
-        sh_funcs.append("string string_convert_helper(VkSurfaceFormatWSI toString, const string prefix)\n{")
-        sh_funcs.append('    string final_str = prefix + "format = " + string_VkFormat(toString.format) + "format = " + string_VkColorSpaceWSI(toString.colorSpace);')
+        # Add function to return a string value for input VkSurfaceFormatKHR*
+        sh_funcs.append("string string_convert_helper(VkSurfaceFormatKHR toString, const string prefix)\n{")
+        sh_funcs.append('    string final_str = prefix + "format = " + string_VkFormat(toString.format) + "format = " + string_VkColorSpaceKHR(toString.colorSpace);')
         sh_funcs.append("    return final_str;")
         sh_funcs.append("}")
         sh_funcs.append('%s' % lineinfo.get())
@@ -1277,7 +1280,7 @@
             sh_funcs.append('%s}' % (indent))
             sh_funcs.append("%sreturn structSize;\n}" % (indent))
         # Now generate generic functions to loop over entire struct chain (or just handle single generic structs)
-        if 'wsi' not in self.header_filename and '_debug_' not in self.header_filename:
+        if 'khr' not in self.header_filename and '_debug_' not in self.header_filename:
             for follow_chain in [True, False]:
                 sh_funcs.append('%s' % self.lineinfo.get())
                 if follow_chain:
@@ -1331,8 +1334,8 @@
     def _generateSizeHelperHeaderC(self):
         header = []
         header.append('#include "vk_struct_size_helper.h"')
-        header.append('#include "vk_wsi_swapchain.h"')
-        header.append('#include "vk_wsi_device_swapchain.h"')
+        header.append('#include "vk_ext_khr_swapchain.h"')
+        header.append('#include "vk_ext_khr_device_swapchain.h"')
         header.append('#include <string.h>')
         header.append('#include <assert.h>')
         header.append('\n// Function definitions\n')
diff --git a/vk_layer_documentation_generate.py b/vk_layer_documentation_generate.py
index da18b69..48eba17 100755
--- a/vk_layer_documentation_generate.py
+++ b/vk_layer_documentation_generate.py
@@ -264,8 +264,8 @@
         # Now go through API names in doc and verify they're real
         # First we're going to transform proto names from vulkan.py into single list
         core_api_names = [p.name for p in vulkan.core.protos]
-        wsi_s_names = [p.name for p in vulkan.wsi_swapchain.protos]
-        wsi_ds_names = [p.name for p in vulkan.wsi_device_swapchain.protos]
+        wsi_s_names = [p.name for p in vulkan.ext_khr_swapchain.protos]
+        wsi_ds_names = [p.name for p in vulkan.ext_khr_device_swapchain.protos]
         dbg_rpt_names = [p.name for p in vulkan.debug_report_lunarg.protos]
         dbg_mrk_names = [p.name for p in vulkan.debug_marker_lunarg.protos]
         api_names = core_api_names + wsi_s_names + wsi_ds_names + dbg_rpt_names + dbg_mrk_names
diff --git a/vulkan.py b/vulkan.py
index 05e0920..1847bd5 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -1045,66 +1045,66 @@
     ],
 )
 
-wsi_swapchain = Extension(
-    name="VK_WSI_swapchain",
-    headers=["vk_wsi_swapchain.h"],
+ext_khr_swapchain = Extension(
+    name="VK_EXT_KHR_swapchain",
+    headers=["vk_ext_khr_swapchain.h"],
     objects=[],
     protos=[
-        Proto("VkResult", "GetPhysicalDeviceSurfaceSupportWSI",
+        Proto("VkResult", "GetPhysicalDeviceSurfaceSupportKHR",
             [Param("VkPhysicalDevice", "physicalDevice"),
              Param("uint32_t", "queueFamilyIndex"),
-             Param("const VkSurfaceDescriptionWSI*", "pSurfaceDescription"),
+             Param("const VkSurfaceDescriptionKHR*", "pSurfaceDescription"),
              Param("VkBool32*", "pSupported")]),
     ],
 )
 
-wsi_device_swapchain = Extension(
-    name="VK_WSI_device_swapchain",
-    headers=["vk_wsi_device_swapchain.h"],
-    objects=["VkSwapChainWSI"],
+ext_khr_device_swapchain = Extension(
+    name="VK_EXT_KHR_device_swapchain",
+    headers=["vk_ext_khr_device_swapchain.h"],
+    objects=["VkSwapchainKHR"],
     protos=[
-        Proto("VkResult", "GetSurfacePropertiesWSI",
+        Proto("VkResult", "GetSurfacePropertiesKHR",
             [Param("VkDevice", "device"),
-	     Param("const VkSurfaceDescriptionWSI*", "pSurfaceDescription"),
-             Param("VkSurfacePropertiesWSI*", "pSurfaceProperties")]),
+	     Param("const VkSurfaceDescriptionKHR*", "pSurfaceDescription"),
+             Param("VkSurfacePropertiesKHR*", "pSurfaceProperties")]),
 
-        Proto("VkResult", "GetSurfaceFormatsWSI",
+        Proto("VkResult", "GetSurfaceFormatsKHR",
             [Param("VkDevice", "device"),
-	     Param("const VkSurfaceDescriptionWSI*", "pSurfaceDescription"),
+	     Param("const VkSurfaceDescriptionKHR*", "pSurfaceDescription"),
 	     Param("uint32_t*", "pCount"),
-             Param("VkSurfaceFormatWSI*", "pSurfaceFormats")]),
+             Param("VkSurfaceFormatKHR*", "pSurfaceFormats")]),
 
-        Proto("VkResult", "GetSurfacePresentModesWSI",
+        Proto("VkResult", "GetSurfacePresentModesKHR",
             [Param("VkDevice", "device"),
-	     Param("const VkSurfaceDescriptionWSI*", "pSurfaceDescription"),
+	     Param("const VkSurfaceDescriptionKHR*", "pSurfaceDescription"),
 	     Param("uint32_t*", "pCount"),
-             Param("VkPresentModeWSI*", "pPresentModes")]),
+             Param("VkPresentModeKHR*", "pPresentModes")]),
 
-        Proto("VkResult", "CreateSwapChainWSI",
+        Proto("VkResult", "CreateSwapchainKHR",
             [Param("VkDevice", "device"),
-             Param("const VkSwapChainCreateInfoWSI*", "pCreateInfo"),
-             Param("VkSwapChainWSI*", "pSwapChain")]),
+             Param("const VkSwapchainCreateInfoKHR*", "pCreateInfo"),
+             Param("VkSwapchainKHR*", "pSwapchain")]),
 
-        Proto("VkResult", "DestroySwapChainWSI",
+        Proto("VkResult", "DestroySwapchainKHR",
             [Param("VkDevice", "device"),
-             Param("VkSwapChainWSI", "swapChain")]),
+             Param("VkSwapchainKHR", "swapchain")]),
 
-        Proto("VkResult", "GetSwapChainImagesWSI",
+        Proto("VkResult", "GetSwapchainImagesKHR",
             [Param("VkDevice", "device"),
-	     Param("VkSwapChainWSI", "swapChain"),
+	     Param("VkSwapchainKHR", "swapchain"),
 	     Param("uint32_t*", "pCount"),
-             Param("VkImage*", "pSwapChainImages")]),
+             Param("VkImage*", "pSwapchainImages")]),
 
-        Proto("VkResult", "AcquireNextImageWSI",
+        Proto("VkResult", "AcquireNextImageKHR",
             [Param("VkDevice", "device"),
-             Param("VkSwapChainWSI", "swapChain"),
+             Param("VkSwapchainKHR", "swapchain"),
              Param("uint64_t", "timeout"),
              Param("VkSemaphore", "semaphore"),
              Param("uint32_t*", "pImageIndex")]),
 
-        Proto("VkResult", "QueuePresentWSI",
+        Proto("VkResult", "QueuePresentKHR",
             [Param("VkQueue", "queue"),
-             Param("VkPresentInfoWSI*", "pPresentInfo")]),
+             Param("VkPresentInfoKHR*", "pPresentInfo")]),
     ],
 )
 debug_report_lunarg = Extension(
@@ -1153,8 +1153,8 @@
              Param("const char*", "pName")]),
     ],
 )
-extensions = [core, wsi_swapchain, wsi_device_swapchain]
-extensions_all = [core, wsi_swapchain, wsi_device_swapchain, debug_report_lunarg, debug_marker_lunarg]
+extensions = [core, ext_khr_swapchain, ext_khr_device_swapchain]
+extensions_all = [core, ext_khr_swapchain, ext_khr_device_swapchain, debug_report_lunarg, debug_marker_lunarg]
 object_dispatch_list = [
     "VkInstance",
     "VkPhysicalDevice",
@@ -1191,7 +1191,7 @@
     "VkDynamicStencilState",
     "VkRenderPass",
     "VkFramebuffer",
-    "VkSwapChainWSI",
+    "VkSwapchainKHR",
     "VkDbgMsgCallback",
 ]