WSI: Convert WSI swapchain extension usage to new KHR style

23 files changed, 465 insertions, 462 deletions

diff --git a/demos/cube.c b/demos/cube.c
index bbbb9dae..10cd1239 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -37,8 +37,8 @@
 #endif // _WIN32
 
 #include <vulkan.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>
 #include "vk_debug_report_lunarg.h"
 
 #include "icd-spv.h"
@@ -288,11 +288,11 @@ void dbgFunc(
     free(message);
 }
 
-typedef struct _SwapChainBuffers {
+typedef struct _SwapchainBuffers {
     VkImage image;
     VkCmdBuffer cmd;
     VkImageView view;
-} SwapChainBuffers;
+} SwapchainBuffers;
 
 struct demo {
 #ifdef _WIN32
@@ -305,7 +305,7 @@ struct demo {
     xcb_screen_t *screen;
     xcb_window_t window;
     xcb_intern_atom_reply_t *atom_wm_delete_window;
-    VkPlatformHandleXcbWSI platform_handle_xcb;
+    VkPlatformHandleXcbKHR platform_handle_xcb;
 #endif // _WIN32
     bool prepared;
     bool use_staging_buffer;
@@ -323,21 +323,21 @@ struct demo {
     VkFramebuffer framebuffer;
     int width, height;
     VkFormat format;
-    VkColorSpaceWSI color_space;
-
-    PFN_vkGetPhysicalDeviceSurfaceSupportWSI fpGetPhysicalDeviceSurfaceSupportWSI;
-    PFN_vkGetSurfacePropertiesWSI fpGetSurfacePropertiesWSI;
-    PFN_vkGetSurfaceFormatsWSI fpGetSurfaceFormatsWSI;
-    PFN_vkGetSurfacePresentModesWSI fpGetSurfacePresentModesWSI;
-    PFN_vkCreateSwapChainWSI fpCreateSwapChainWSI;
-    PFN_vkDestroySwapChainWSI fpDestroySwapChainWSI;
-    PFN_vkGetSwapChainImagesWSI fpGetSwapChainImagesWSI;
-    PFN_vkAcquireNextImageWSI fpAcquireNextImageWSI;
-    PFN_vkQueuePresentWSI fpQueuePresentWSI;
-    VkSurfaceDescriptionWindowWSI surface_description;
-    uint32_t swapChainImageCount;
-    VkSwapChainWSI swap_chain;
-    SwapChainBuffers *buffers;
+    VkColorSpaceKHR color_space;
+
+    PFN_vkGetPhysicalDeviceSurfaceSupportKHR fpGetPhysicalDeviceSurfaceSupportKHR;
+    PFN_vkGetSurfacePropertiesKHR fpGetSurfacePropertiesKHR;
+    PFN_vkGetSurfaceFormatsKHR fpGetSurfaceFormatsKHR;
+    PFN_vkGetSurfacePresentModesKHR fpGetSurfacePresentModesKHR;
+    PFN_vkCreateSwapchainKHR fpCreateSwapchainKHR;
+    PFN_vkDestroySwapchainKHR fpDestroySwapchainKHR;
+    PFN_vkGetSwapchainImagesKHR fpGetSwapchainImagesKHR;
+    PFN_vkAcquireNextImageKHR fpAcquireNextImageKHR;
+    PFN_vkQueuePresentKHR fpQueuePresentKHR;
+    VkSurfaceDescriptionWindowKHR surface_description;
+    uint32_t swapchainImageCount;
+    VkSwapchainKHR swap_chain;
+    SwapchainBuffers *buffers;
 
     VkCmdPool cmd_pool;
 
@@ -597,11 +597,11 @@ static void demo_draw(struct demo *demo)
     assert(!err);
 
     // Get the index of the next available swapchain image:
-    err = demo->fpAcquireNextImageWSI(demo->device, demo->swap_chain,
+    err = demo->fpAcquireNextImageKHR(demo->device, demo->swap_chain,
                                       UINT64_MAX,
                                       presentCompleteSemaphore,
                                       &demo->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);
 
@@ -611,22 +611,22 @@ static void demo_draw(struct demo *demo)
     // okay to render to the image.
     vkQueueWaitSemaphore(demo->queue, presentCompleteSemaphore);
 
-// FIXME/TODO: DEAL WITH VK_IMAGE_LAYOUT_PRESENT_SOURCE_WSI
+// FIXME/TODO: DEAL WITH VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR
     err = vkQueueSubmit(demo->queue, 1, &demo->buffers[demo->current_buffer].cmd,
             nullFence);
     assert(!err);
 
-    VkPresentInfoWSI present = {
-        .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_WSI,
+    VkPresentInfoKHR present = {
+        .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
         .pNext = NULL,
-        .swapChainCount = 1,
-        .swapChains = &demo->swap_chain,
+        .swapchainCount = 1,
+        .swapchains = &demo->swap_chain,
         .imageIndices = &demo->current_buffer,
     };
 
 // TBD/TODO: SHOULD THE "present" PARAMETER BE "const" IN THE HEADER?
-    err = demo->fpQueuePresentWSI(demo->queue, &present);
-    // TODO: Deal with the VK_SUBOPTIMAL_WSI and VK_ERROR_OUT_OF_DATE_WSI
+    err = demo->fpQueuePresentKHR(demo->queue, &present);
+    // TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
     // return codes
     assert(!err);
 
@@ -642,53 +642,53 @@ static void demo_prepare_buffers(struct demo *demo)
     VkResult U_ASSERT_ONLY err;
 
     // Check the surface properties and formats
-    VkSurfacePropertiesWSI surfProperties;
-    err = demo->fpGetSurfacePropertiesWSI(demo->device,
-        (const VkSurfaceDescriptionWSI *)&demo->surface_description,
+    VkSurfacePropertiesKHR surfProperties;
+    err = demo->fpGetSurfacePropertiesKHR(demo->device,
+        (const VkSurfaceDescriptionKHR *)&demo->surface_description,
         &surfProperties);
     assert(!err);
 
     uint32_t presentModeCount;
-    err = demo->fpGetSurfacePresentModesWSI(demo->device,
-        (const VkSurfaceDescriptionWSI *)&demo->surface_description,
+    err = demo->fpGetSurfacePresentModesKHR(demo->device,
+        (const VkSurfaceDescriptionKHR *)&demo->surface_description,
         &presentModeCount, NULL);
     assert(!err);
-    VkPresentModeWSI *presentModes =
-        (VkPresentModeWSI *)malloc(presentModeCount * sizeof(VkPresentModeWSI));
+    VkPresentModeKHR *presentModes =
+        (VkPresentModeKHR *)malloc(presentModeCount * sizeof(VkPresentModeKHR));
     assert(presentModes);
-    err = demo->fpGetSurfacePresentModesWSI(demo->device,
-        (const VkSurfaceDescriptionWSI *)&demo->surface_description,
+    err = demo->fpGetSurfacePresentModesKHR(demo->device,
+        (const VkSurfaceDescriptionKHR *)&demo->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 = demo->width;
-        swapChainExtent.height = demo->height;
+        swapchainExtent.width = demo->width;
+        swapchainExtent.height = demo->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;
         }
     }
 
@@ -698,38 +698,38 @@ static void demo_prepare_buffers(struct demo *demo)
     // modified to only support DEMO_BUFFER_COUNT number of command buffers,
     // images, etc.  Live with that for now.
     // TODO: Rework this demo code to live with the number of buffers returned
-    // by vkCreateSwapChainWSI().
-    uint32_t desiredNumberOfSwapChainImages = DEMO_BUFFER_COUNT;
+    // by vkCreateSwapchainKHR().
+    uint32_t desiredNumberOfSwapchainImages = DEMO_BUFFER_COUNT;
 #else  // WORK_AROUND_CODE
     // 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;
     }
 #endif // WORK_AROUND_CODE
 
-    VkSurfaceTransformFlagBitsWSI preTransform;
-    if (surfProperties.supportedTransforms & VK_SURFACE_TRANSFORM_NONE_BIT_WSI) {
-        preTransform = VK_SURFACE_TRANSFORM_NONE_WSI;
+    VkSurfaceTransformFlagBitsKHR preTransform;
+    if (surfProperties.supportedTransforms & VK_SURFACE_TRANSFORM_NONE_BIT_KHR) {
+        preTransform = VK_SURFACE_TRANSFORM_NONE_KHR;
     } else {
         preTransform = surfProperties.currentTransform;
     }
 
-    const VkSwapChainCreateInfoWSI swap_chain = {
-        .sType = VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI,
+    const VkSwapchainCreateInfoKHR swap_chain = {
+        .sType = VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_KHR,
         .pNext = NULL,
-        .pSurfaceDescription = (const VkSurfaceDescriptionWSI *)&demo->surface_description,
-        .minImageCount = desiredNumberOfSwapChainImages,
+        .pSurfaceDescription = (const VkSurfaceDescriptionKHR *)&demo->surface_description,
+        .minImageCount = desiredNumberOfSwapchainImages,
         .imageFormat = demo->format,
         .imageColorSpace = demo->color_space,
         .imageExtent = {
-            .width = swapChainExtent.width,
-            .height = swapChainExtent.height,
+            .width = swapchainExtent.width,
+            .height = swapchainExtent.height,
         },
         .imageUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
         .preTransform = preTransform,
@@ -737,39 +737,39 @@ static void demo_prepare_buffers(struct demo *demo)
         .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
         .queueFamilyCount = 0,
         .pQueueFamilyIndices = NULL,
-        .presentMode = swapChainPresentMode,
-        .oldSwapChain.handle = 0,
+        .presentMode = swapchainPresentMode,
+        .oldSwapchain.handle = 0,
         .clipped = true,
     };
     uint32_t i;
 
-    err = demo->fpCreateSwapChainWSI(demo->device, &swap_chain, &demo->swap_chain);
+    err = demo->fpCreateSwapchainKHR(demo->device, &swap_chain, &demo->swap_chain);
     assert(!err);
 
-    err = demo->fpGetSwapChainImagesWSI(demo->device, demo->swap_chain,
-                                        &demo->swapChainImageCount, NULL);
+    err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swap_chain,
+                                        &demo->swapchainImageCount, NULL);
     assert(!err);
 
-    VkImage* swapChainImages =
-        (VkImage*)malloc(demo->swapChainImageCount * sizeof(VkImage));
-    assert(swapChainImages);
-    err = demo->fpGetSwapChainImagesWSI(demo->device, demo->swap_chain,
-                                        &demo->swapChainImageCount,
-                                        swapChainImages);
+    VkImage* swapchainImages =
+        (VkImage*)malloc(demo->swapchainImageCount * sizeof(VkImage));
+    assert(swapchainImages);
+    err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swap_chain,
+                                        &demo->swapchainImageCount,
+                                        swapchainImages);
     assert(!err);
 #ifdef WORK_AROUND_CODE
     // After the proper code was created, other parts of this demo were
     // modified to only support DEMO_BUFFER_COUNT number of command buffers,
     // images, etc.  Live with that for now.
     // TODO: Rework this demo code to live with the number of buffers returned
-    // by vkCreateSwapChainWSI().
-    demo->swapChainImageCount = DEMO_BUFFER_COUNT;
+    // by vkCreateSwapchainKHR().
+    demo->swapchainImageCount = DEMO_BUFFER_COUNT;
 #endif // WORK_AROUND_CODE
 
-    demo->buffers = (SwapChainBuffers*)malloc(sizeof(SwapChainBuffers)*demo->swapChainImageCount);
+    demo->buffers = (SwapchainBuffers*)malloc(sizeof(SwapchainBuffers)*demo->swapchainImageCount);
     assert(demo->buffers);
 
-    for (i = 0; i < demo->swapChainImageCount; i++) {
+    for (i = 0; i < demo->swapchainImageCount; i++) {
         VkImageViewCreateInfo color_image_view = {
             .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
             .pNext = NULL,
@@ -791,7 +791,7 @@ static void demo_prepare_buffers(struct demo *demo)
             .flags = 0,
         };
 
-        demo->buffers[i].image = swapChainImages[i];
+        demo->buffers[i].image = swapchainImages[i];
 
         demo_set_image_layout(demo, demo->buffers[i].image,
                                VK_IMAGE_ASPECT_COLOR,
@@ -1886,7 +1886,7 @@ static void demo_prepare(struct demo *demo)
     demo_prepare_pipeline(demo);
     demo_prepare_dynamic_states(demo);
 
-    for (uint32_t i = 0; i < demo->swapChainImageCount; i++) {
+    for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
         err = vkCreateCommandBuffer(demo->device, &cmd, &demo->buffers[i].cmd);
         assert(!err);
     }
@@ -1896,7 +1896,7 @@ static void demo_prepare(struct demo *demo)
 
     demo_prepare_framebuffers(demo);
 
-    for (uint32_t i = 0; i < demo->swapChainImageCount; i++) {
+    for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
         demo->current_buffer = i;
         demo_draw_build_cmd(demo, demo->buffers[i].cmd);
     }
@@ -1942,7 +1942,7 @@ static void demo_cleanup(struct demo *demo)
         vkFreeMemory(demo->device, demo->textures[i].mem);
         vkDestroySampler(demo->device, demo->textures[i].sampler);
     }
-    demo->fpDestroySwapChainWSI(demo->device, demo->swap_chain);
+    demo->fpDestroySwapchainKHR(demo->device, demo->swap_chain);
 
     vkDestroyImageView(demo->device, demo->depth.view);
     vkDestroyImage(demo->device, demo->depth.image);
@@ -1952,7 +1952,7 @@ static void demo_cleanup(struct demo *demo)
     vkDestroyBuffer(demo->device, demo->uniform_data.buf);
     vkFreeMemory(demo->device, demo->uniform_data.mem);
 
-    for (i = 0; i < demo->swapChainImageCount; i++) {
+    for (i = 0; i < demo->swapchainImageCount; i++) {
         vkDestroyImageView(demo->device, demo->buffers[i].view);
         vkDestroyCommandBuffer(demo->device, demo->buffers[i].cmd);
     }
@@ -2263,9 +2263,9 @@ static void demo_init_vk(struct demo *demo)
     err = vkGetGlobalExtensionProperties(NULL, &instance_extension_count, instance_extensions);
     assert(!err);
     for (uint32_t i = 0; i < instance_extension_count; i++) {
-        if (!strcmp("VK_WSI_swapchain", instance_extensions[i].extName)) {
+        if (!strcmp("VK_EXT_KHR_swapchain", instance_extensions[i].extName)) {
             WSIextFound = 1;
-            extension_names[enabled_extension_count++] = "VK_WSI_swapchain";
+            extension_names[enabled_extension_count++] = "VK_EXT_KHR_swapchain";
         }
         if (!strcmp(VK_DEBUG_REPORT_EXTENSION_NAME, instance_extensions[i].extName)) {
             if (demo->validate) {
@@ -2276,7 +2276,7 @@ static void demo_init_vk(struct demo *demo)
     }
     if (!WSIextFound) {
         ERR_EXIT("vkGetGlobalExtensionProperties failed to find the "
-                 "\"VK_WSI_swapchain\" extension.\n\nDo you have a compatible "
+                 "\"VK_EXT_KHR_swapchain\" extension.\n\nDo you have a compatible "
                  "Vulkan installable client driver (ICD) installed?\nPlease "
                  "look at the Getting Started guide for additional "
                  "information.\n",
@@ -2371,15 +2371,15 @@ static void demo_init_vk(struct demo *demo)
     assert(!err);
 
     for (uint32_t i = 0; i < device_extension_count; i++) {
-        if (!strcmp("VK_WSI_device_swapchain", device_extensions[i].extName)) {
+        if (!strcmp("VK_EXT_KHR_device_swapchain", device_extensions[i].extName)) {
             WSIextFound = 1;
-            extension_names[enabled_extension_count++] = "VK_WSI_device_swapchain";
+            extension_names[enabled_extension_count++] = "VK_EXT_KHR_device_swapchain";
         }
         assert(enabled_extension_count < 64);
     }
     if (!WSIextFound) {
         ERR_EXIT("vkGetPhysicalDeviceExtensionProperties failed to find the "
-                 "\"VK_WSI_device_swapchain\" extension.\n\nDo you have a compatible "
+                 "\"VK_EXT_KHR_device_swapchain\" extension.\n\nDo you have a compatible "
                  "Vulkan installable client driver (ICD) installed?\nPlease "
                  "look at the Getting Started guide for additional "
                  "information.\n",
@@ -2449,16 +2449,16 @@ static void demo_init_vk(struct demo *demo)
 
     free(device_layers);
 
-    GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, GetSurfacePropertiesWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, GetSurfaceFormatsWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, GetSurfacePresentModesWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, CreateSwapChainWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, CreateSwapChainWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, DestroySwapChainWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, GetSwapChainImagesWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, AcquireNextImageWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, QueuePresentWSI);
+    GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, GetSurfacePropertiesKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, GetSurfaceFormatsKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, GetSurfacePresentModesKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, CreateSwapchainKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, CreateSwapchainKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, DestroySwapchainKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, GetSwapchainImagesKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, AcquireNextImageKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, QueuePresentKHR);
 
     err = vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
     assert(!err);
@@ -2480,16 +2480,16 @@ static void demo_init_vk_wsi(struct demo *demo)
     uint32_t i;
 
     // Construct the WSI surface description:
-    demo->surface_description.sType = VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI;
+    demo->surface_description.sType = VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR;
     demo->surface_description.pNext = NULL;
 #ifdef _WIN32
-    demo->surface_description.platform = VK_PLATFORM_WIN32_WSI;
+    demo->surface_description.platform = VK_PLATFORM_WIN32_KHR;
     demo->surface_description.pPlatformHandle = demo->connection;
     demo->surface_description.pPlatformWindow = demo->window;
 #else  // _WIN32
     demo->platform_handle_xcb.connection = demo->connection;
     demo->platform_handle_xcb.root = demo->screen->root;
-    demo->surface_description.platform = VK_PLATFORM_XCB_WSI;
+    demo->surface_description.platform = VK_PLATFORM_XCB_KHR;
     demo->surface_description.pPlatformHandle = &demo->platform_handle_xcb;
     demo->surface_description.pPlatformWindow = &demo->window;
 #endif // _WIN32
@@ -2497,8 +2497,8 @@ static void demo_init_vk_wsi(struct demo *demo)
     // Iterate over each queue to learn whether it supports presenting to WSI:
     VkBool32* supportsPresent = (VkBool32 *)malloc(demo->queue_count * sizeof(VkBool32));
     for (i = 0; i < demo->queue_count; i++) {
-        demo->fpGetPhysicalDeviceSurfaceSupportWSI(demo->gpu, i,
-                                                   (VkSurfaceDescriptionWSI *) &demo->surface_description,
+        demo->fpGetPhysicalDeviceSurfaceSupportKHR(demo->gpu, i,
+                                                   (VkSurfaceDescriptionKHR *) &demo->surface_description,
                                                    &supportsPresent[i]);
     }
 
@@ -2554,14 +2554,14 @@ static void demo_init_vk_wsi(struct demo *demo)
 
     // Get the list of VkFormat's that are supported:
     uint32_t formatCount;
-    err = demo->fpGetSurfaceFormatsWSI(demo->device,
-                                    (VkSurfaceDescriptionWSI *) &demo->surface_description,
+    err = demo->fpGetSurfaceFormatsKHR(demo->device,
+                                    (VkSurfaceDescriptionKHR *) &demo->surface_description,
                                     &formatCount, NULL);
     assert(!err);
-    VkSurfaceFormatWSI *surfFormats =
-        (VkSurfaceFormatWSI *)malloc(formatCount * sizeof(VkSurfaceFormatWSI));
-    err = demo->fpGetSurfaceFormatsWSI(demo->device,
-                                    (VkSurfaceDescriptionWSI *) &demo->surface_description,
+    VkSurfaceFormatKHR *surfFormats =
+        (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
+    err = demo->fpGetSurfaceFormatsKHR(demo->device,
+                                    (VkSurfaceDescriptionKHR *) &demo->surface_description,
                                     &formatCount, surfFormats);
     assert(!err);
     // If the format list includes just one entry of VK_FORMAT_UNDEFINED,
diff --git a/demos/tri.c b/demos/tri.c
index 03a3ccbe..1a53d0ea 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -43,8 +43,8 @@
 
 #include <vulkan.h>
 #include "vk_debug_report_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>
 
 #include "icd-spv.h"
 
@@ -138,11 +138,11 @@ void dbgFunc(
     free(message);
 }
 
-typedef struct _SwapChainBuffers {
+typedef struct _SwapchainBuffers {
     VkImage image;
     VkCmdBuffer cmd;
     VkImageView view;
-} SwapChainBuffers;
+} SwapchainBuffers;
 
 struct demo {
 #ifdef _WIN32
@@ -155,7 +155,7 @@ struct demo {
     xcb_screen_t *screen;
     xcb_window_t window;
     xcb_intern_atom_reply_t *atom_wm_delete_window;
-    VkPlatformHandleXcbWSI platform_handle_xcb;
+    VkPlatformHandleXcbKHR platform_handle_xcb;
 #endif // _WIN32
 	bool prepared;
     bool use_staging_buffer;
@@ -171,21 +171,21 @@ struct demo {
 
     int width, height;
     VkFormat format;
-    VkColorSpaceWSI color_space;
-
-    PFN_vkGetPhysicalDeviceSurfaceSupportWSI fpGetPhysicalDeviceSurfaceSupportWSI;
-    PFN_vkGetSurfacePropertiesWSI fpGetSurfacePropertiesWSI;
-    PFN_vkGetSurfaceFormatsWSI fpGetSurfaceFormatsWSI;
-    PFN_vkGetSurfacePresentModesWSI fpGetSurfacePresentModesWSI;
-    PFN_vkCreateSwapChainWSI fpCreateSwapChainWSI;
-    PFN_vkDestroySwapChainWSI fpDestroySwapChainWSI;
-    PFN_vkGetSwapChainImagesWSI fpGetSwapChainImagesWSI;
-    PFN_vkAcquireNextImageWSI fpAcquireNextImageWSI;
-    PFN_vkQueuePresentWSI fpQueuePresentWSI;
-    VkSurfaceDescriptionWindowWSI surface_description;
-    uint32_t swapChainImageCount;
-    VkSwapChainWSI swap_chain;
-    SwapChainBuffers *buffers;
+    VkColorSpaceKHR color_space;
+
+    PFN_vkGetPhysicalDeviceSurfaceSupportKHR fpGetPhysicalDeviceSurfaceSupportKHR;
+    PFN_vkGetSurfacePropertiesKHR fpGetSurfacePropertiesKHR;
+    PFN_vkGetSurfaceFormatsKHR fpGetSurfaceFormatsKHR;
+    PFN_vkGetSurfacePresentModesKHR fpGetSurfacePresentModesKHR;
+    PFN_vkCreateSwapchainKHR fpCreateSwapchainKHR;
+    PFN_vkDestroySwapchainKHR fpDestroySwapchainKHR;
+    PFN_vkGetSwapchainImagesKHR fpGetSwapchainImagesKHR;
+    PFN_vkAcquireNextImageKHR fpAcquireNextImageKHR;
+    PFN_vkQueuePresentKHR fpQueuePresentKHR;
+    VkSurfaceDescriptionWindowKHR surface_description;
+    uint32_t swapchainImageCount;
+    VkSwapchainKHR swap_chain;
+    SwapchainBuffers *buffers;
 
     VkCmdPool cmd_pool;
 
@@ -416,11 +416,11 @@ static void demo_draw(struct demo *demo)
     assert(!err);
 
     // Get the index of the next available swapchain image:
-    err = demo->fpAcquireNextImageWSI(demo->device, demo->swap_chain,
+    err = demo->fpAcquireNextImageKHR(demo->device, demo->swap_chain,
                                       UINT64_MAX,
                                       presentCompleteSemaphore,
                                       &demo->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);
 
@@ -430,24 +430,24 @@ static void demo_draw(struct demo *demo)
     // okay to render to the image.
     vkQueueWaitSemaphore(demo->queue, presentCompleteSemaphore);
 
-// FIXME/TODO: DEAL WITH VK_IMAGE_LAYOUT_PRESENT_SOURCE_WSI
+// FIXME/TODO: DEAL WITH VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR
     demo_draw_build_cmd(demo);
     VkFence nullFence = { VK_NULL_HANDLE };
 
     err = vkQueueSubmit(demo->queue, 1, &demo->draw_cmd, nullFence);
     assert(!err);
 
-    VkPresentInfoWSI present = {
-        .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_WSI,
+    VkPresentInfoKHR present = {
+        .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
         .pNext = NULL,
-        .swapChainCount = 1,
-        .swapChains = &demo->swap_chain,
+        .swapchainCount = 1,
+        .swapchains = &demo->swap_chain,
         .imageIndices = &demo->current_buffer,
     };
 
 // TBD/TODO: SHOULD THE "present" PARAMETER BE "const" IN THE HEADER?
-    err = demo->fpQueuePresentWSI(demo->queue, &present);
-    // TODO: Deal with the VK_SUBOPTIMAL_WSI and VK_ERROR_OUT_OF_DATE_WSI
+    err = demo->fpQueuePresentKHR(demo->queue, &present);
+    // TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
     // return codes
     assert(!err);
 
@@ -463,84 +463,84 @@ static void demo_prepare_buffers(struct demo *demo)
     VkResult U_ASSERT_ONLY err;
 
     // Check the surface proprties and formats
-    VkSurfacePropertiesWSI surfProperties;
-    err = demo->fpGetSurfacePropertiesWSI(demo->device,
-        (const VkSurfaceDescriptionWSI *)&demo->surface_description,
+    VkSurfacePropertiesKHR surfProperties;
+    err = demo->fpGetSurfacePropertiesKHR(demo->device,
+        (const VkSurfaceDescriptionKHR *)&demo->surface_description,
         &surfProperties);
     assert(!err);
 
     uint32_t presentModeCount;
-    err = demo->fpGetSurfacePresentModesWSI(demo->device,
-        (const VkSurfaceDescriptionWSI *)&demo->surface_description,
+    err = demo->fpGetSurfacePresentModesKHR(demo->device,
+        (const VkSurfaceDescriptionKHR *)&demo->surface_description,
         &presentModeCount, NULL);
     assert(!err);
-    VkPresentModeWSI *presentModes =
-        (VkPresentModeWSI *)malloc(presentModeCount * sizeof(VkPresentModeWSI));
+    VkPresentModeKHR *presentModes =
+        (VkPresentModeKHR *)malloc(presentModeCount * sizeof(VkPresentModeKHR));
     assert(presentModes);
-    err = demo->fpGetSurfacePresentModesWSI(demo->device,
-        (const VkSurfaceDescriptionWSI *)&demo->surface_description,
+    err = demo->fpGetSurfacePresentModesKHR(demo->device,
+        (const VkSurfaceDescriptionKHR *)&demo->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 = demo->width;
-        swapChainExtent.height = demo->height;
+        swapchainExtent.width = demo->width;
+        swapchainExtent.height = demo->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;
     }
 
-    const VkSwapChainCreateInfoWSI swap_chain = {
-        .sType = VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI,
+    const VkSwapchainCreateInfoKHR swap_chain = {
+        .sType = VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_KHR,
         .pNext = NULL,
-        .pSurfaceDescription = (const VkSurfaceDescriptionWSI *)&demo->surface_description,
-        .minImageCount = desiredNumberOfSwapChainImages,
+        .pSurfaceDescription = (const VkSurfaceDescriptionKHR *)&demo->surface_description,
+        .minImageCount = desiredNumberOfSwapchainImages,
         .imageFormat = demo->format,
         .imageColorSpace = demo->color_space,
         .imageExtent = {
-            .width = swapChainExtent.width,
-            .height = swapChainExtent.height,
+            .width = swapchainExtent.width,
+            .height = swapchainExtent.height,
         },
         .imageUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
         .preTransform = preTransform,
@@ -548,31 +548,31 @@ static void demo_prepare_buffers(struct demo *demo)
         .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
         .queueFamilyCount = 0,
         .pQueueFamilyIndices = NULL,
-        .presentMode = swapChainPresentMode,
-        .oldSwapChain.handle = 0,
+        .presentMode = swapchainPresentMode,
+        .oldSwapchain.handle = 0,
         .clipped = true,
     };
     uint32_t i;
 
-    err = demo->fpCreateSwapChainWSI(demo->device, &swap_chain, &demo->swap_chain);
+    err = demo->fpCreateSwapchainKHR(demo->device, &swap_chain, &demo->swap_chain);
     assert(!err);
 
-    err = demo->fpGetSwapChainImagesWSI(demo->device, demo->swap_chain,
-                                        &demo->swapChainImageCount, NULL);
+    err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swap_chain,
+                                        &demo->swapchainImageCount, NULL);
     assert(!err);
 
-    VkImage* swapChainImages =
-        (VkImage*)malloc(demo->swapChainImageCount * sizeof(VkImage));
-    assert(swapChainImages);
-    err = demo->fpGetSwapChainImagesWSI(demo->device, demo->swap_chain,
-                                        &demo->swapChainImageCount,
-                                        swapChainImages);
+    VkImage* swapchainImages =
+        (VkImage*)malloc(demo->swapchainImageCount * sizeof(VkImage));
+    assert(swapchainImages);
+    err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swap_chain,
+                                        &demo->swapchainImageCount,
+                                        swapchainImages);
     assert(!err);
 
-    demo->buffers = (SwapChainBuffers*)malloc(sizeof(SwapChainBuffers)*demo->swapChainImageCount);
+    demo->buffers = (SwapchainBuffers*)malloc(sizeof(SwapchainBuffers)*demo->swapchainImageCount);
     assert(demo->buffers);
 
-    for (i = 0; i < demo->swapChainImageCount; i++) {
+    for (i = 0; i < demo->swapchainImageCount; i++) {
         VkImageViewCreateInfo color_attachment_view = {
             .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
             .pNext = NULL,
@@ -594,7 +594,7 @@ static void demo_prepare_buffers(struct demo *demo)
             .flags = 0,
         };
 
-        demo->buffers[i].image = swapChainImages[i];
+        demo->buffers[i].image = swapchainImages[i];
 
         demo_set_image_layout(demo, demo->buffers[i].image,
                                VK_IMAGE_ASPECT_COLOR,
@@ -1757,9 +1757,9 @@ static void demo_init_vk(struct demo *demo)
     err = vkGetGlobalExtensionProperties(NULL, &instance_extension_count, instance_extensions);
     assert(!err);
     for (uint32_t i = 0; i < instance_extension_count; i++) {
-        if (!strcmp("VK_WSI_swapchain", instance_extensions[i].extName)) {
+        if (!strcmp("VK_EXT_KHR_swapchain", instance_extensions[i].extName)) {
             WSIextFound = 1;
-            extension_names[enabled_extension_count++] = "VK_WSI_swapchain";
+            extension_names[enabled_extension_count++] = "VK_EXT_KHR_swapchain";
         }
         if (!strcmp(VK_DEBUG_REPORT_EXTENSION_NAME, instance_extensions[i].extName)) {
             if (demo->validate) {
@@ -1770,7 +1770,7 @@ static void demo_init_vk(struct demo *demo)
     }
     if (!WSIextFound) {
         ERR_EXIT("vkGetGlobalExtensionProperties failed to find the "
-                 "\"VK_WSI_swapchain\" extension.\n\nDo you have a compatible "
+                 "\"VK_EXT_KHR_swapchain\" extension.\n\nDo you have a compatible "
                  "Vulkan installable client driver (ICD) installed?\nPlease "
                  "look at the Getting Started guide for additional "
                  "information.\n",
@@ -1864,15 +1864,15 @@ static void demo_init_vk(struct demo *demo)
     assert(!err);
 
     for (uint32_t i = 0; i < device_extension_count; i++) {
-        if (!strcmp("VK_WSI_device_swapchain", device_extensions[i].extName)) {
+        if (!strcmp("VK_EXT_KHR_device_swapchain", device_extensions[i].extName)) {
             WSIextFound = 1;
-            extension_names[enabled_extension_count++] = "VK_WSI_device_swapchain";
+            extension_names[enabled_extension_count++] = "VK_EXT_KHR_device_swapchain";
         }
         assert(enabled_extension_count < 64);
     }
     if (!WSIextFound) {
         ERR_EXIT("vkGetPhysicalDeviceExtensionProperties failed to find the "
-                 "\"VK_WSI_device_swapchain\" extension.\n\nDo you have a compatible "
+                 "\"VK_EXT_KHR_device_swapchain\" extension.\n\nDo you have a compatible "
                  "Vulkan installable client driver (ICD) installed?\nPlease "
                  "look at the Getting Started guide for additional "
                  "information.\n",
@@ -1923,16 +1923,16 @@ static void demo_init_vk(struct demo *demo)
     err = vkCreateDevice(demo->gpu, &device, &demo->device);
     assert(!err);
 
-    GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, GetSurfacePropertiesWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, GetSurfaceFormatsWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, GetSurfacePresentModesWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, CreateSwapChainWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, CreateSwapChainWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, DestroySwapChainWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, GetSwapChainImagesWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, AcquireNextImageWSI);
-    GET_DEVICE_PROC_ADDR(demo->device, QueuePresentWSI);
+    GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, GetSurfacePropertiesKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, GetSurfaceFormatsKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, GetSurfacePresentModesKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, CreateSwapchainKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, CreateSwapchainKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, DestroySwapchainKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, GetSwapchainImagesKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, AcquireNextImageKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, QueuePresentKHR);
 
     err = vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
 
@@ -1956,16 +1956,16 @@ static void demo_init_vk_wsi(struct demo *demo)
     uint32_t i;
 
     // Construct the WSI surface description:
-    demo->surface_description.sType = VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI;
+    demo->surface_description.sType = VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR;
     demo->surface_description.pNext = NULL;
 #ifdef _WIN32
-    demo->surface_description.platform = VK_PLATFORM_WIN32_WSI;
+    demo->surface_description.platform = VK_PLATFORM_WIN32_KHR;
     demo->surface_description.pPlatformHandle = demo->connection;
     demo->surface_description.pPlatformWindow = demo->window;
 #else  // _WIN32
     demo->platform_handle_xcb.connection = demo->connection;
     demo->platform_handle_xcb.root = demo->screen->root;
-    demo->surface_description.platform = VK_PLATFORM_XCB_WSI;
+    demo->surface_description.platform = VK_PLATFORM_XCB_KHR;
     demo->surface_description.pPlatformHandle = &demo->platform_handle_xcb;
     demo->surface_description.pPlatformWindow = &demo->window;
 #endif // _WIN32
@@ -1973,8 +1973,8 @@ static void demo_init_vk_wsi(struct demo *demo)
     // Iterate over each queue to learn whether it supports presenting to WSI:
     VkBool32* supportsPresent = (VkBool32 *)malloc(demo->queue_count * sizeof(VkBool32));
     for (i = 0; i < demo->queue_count; i++) {
-        demo->fpGetPhysicalDeviceSurfaceSupportWSI(demo->gpu, i,
-                                                   (VkSurfaceDescriptionWSI *) &demo->surface_description,
+        demo->fpGetPhysicalDeviceSurfaceSupportKHR(demo->gpu, i,
+                                                   (VkSurfaceDescriptionKHR *) &demo->surface_description,
                                                    &supportsPresent[i]);
     }
 
@@ -2030,14 +2030,14 @@ static void demo_init_vk_wsi(struct demo *demo)
 
     // Get the list of VkFormat's that are supported:
     uint32_t formatCount;
-    err = demo->fpGetSurfaceFormatsWSI(demo->device,
-                                    (VkSurfaceDescriptionWSI *) &demo->surface_description,
+    err = demo->fpGetSurfaceFormatsKHR(demo->device,
+                                    (VkSurfaceDescriptionKHR *) &demo->surface_description,
                                     &formatCount, NULL);
     assert(!err);
-    VkSurfaceFormatWSI *surfFormats =
-        (VkSurfaceFormatWSI *)malloc(formatCount * sizeof(VkSurfaceFormatWSI));
-    err = demo->fpGetSurfaceFormatsWSI(demo->device,
-                                    (VkSurfaceDescriptionWSI *) &demo->surface_description,
+    VkSurfaceFormatKHR *surfFormats =
+        (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
+    err = demo->fpGetSurfaceFormatsKHR(demo->device,
+                                    (VkSurfaceDescriptionKHR *) &demo->surface_description,
                                     &formatCount, surfFormats);
     assert(!err);
     // If the format list includes just one entry of VK_FORMAT_UNDEFINED,
@@ -2164,7 +2164,7 @@ static void demo_cleanup(struct demo *demo)
         vkDestroySampler(demo->device, demo->textures[i].sampler);
     }
 
-    for (i = 0; i < demo->swapChainImageCount; i++) {
+    for (i = 0; i < demo->swapchainImageCount; i++) {
         vkDestroyImageView(demo->device, demo->buffers[i].view);
     }
 
@@ -2172,7 +2172,7 @@ static void demo_cleanup(struct demo *demo)
     vkDestroyImage(demo->device, demo->depth.image);
     vkFreeMemory(demo->device, demo->depth.mem);
 
-    demo->fpDestroySwapChainWSI(demo->device, demo->swap_chain);
+    demo->fpDestroySwapchainKHR(demo->device, demo->swap_chain);
     free(demo->buffers);
 
     vkDestroyDevice(demo->device);
diff --git a/demos/vulkaninfo.c b/demos/vulkaninfo.c
index 66517e80..0d6aaf27 100644
--- a/demos/vulkaninfo.c
+++ b/demos/vulkaninfo.c
@@ -34,8 +34,8 @@
 #include <io.h>
 #endif
 
-#include "vk_wsi_swapchain.h"
-#include "vk_wsi_device_swapchain.h"
+#include "vk_ext_khr_swapchain.h"
+#include "vk_ext_khr_device_swapchain.h"
 
 #include <vulkan.h>
 
@@ -427,7 +427,7 @@ static void app_dev_init(struct app_dev *dev, struct app_gpu *gpu)
     VkResult U_ASSERT_ONLY err;
     // Extensions to enable
     static const char *known_extensions[] = {
-        VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NAME,
+        VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME,
     };
 
     uint32_t count = 0;
@@ -570,7 +570,7 @@ static void app_create_instance(struct app_instance *inst)
     VkResult U_ASSERT_ONLY err;
     // Global Extensions to enable
     static char *known_extensions[] = {
-        "VK_WSI_swapchain",
+        "VK_EXT_KHR_swapchain",
     };
 
     uint32_t global_extension_count = 0;
diff --git a/icd/common/icd.h b/icd/common/icd.h
index bb598ecd..e7679330 100644
--- a/icd/common/icd.h
+++ b/icd/common/icd.h
@@ -31,8 +31,8 @@
 #include <vulkan.h>
 #include <vk_platform.h>
 #include <vk_debug_report_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"
 #include "vk_sdk_platform.h"
 
 #if defined(__GNUC__) && __GNUC__ >= 4
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index e8402894..f8c75a72 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -40,12 +40,12 @@
 
 // The null driver supports all WSI extenstions ... for now ...
 static const char * const nulldrv_gpu_exts[NULLDRV_EXT_COUNT] = {
-	[NULLDRV_EXT_WSI_SWAPCHAIN] = VK_WSI_SWAPCHAIN_EXTENSION_NAME,
+	[NULLDRV_EXT_KHR_SWAPCHAIN] = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME,
 };
 static const VkExtensionProperties intel_gpu_exts[NULLDRV_EXT_COUNT] = {
     {
-        .extName = VK_WSI_SWAPCHAIN_EXTENSION_NAME,
-        .specVersion = VK_WSI_SWAPCHAIN_REVISION,
+        .extName = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME,
+        .specVersion = VK_EXT_KHR_SWAPCHAIN_VERSION,
     }
 };
 
@@ -816,9 +816,9 @@ static const VkFormat nulldrv_presentable_formats[] = {
 };
 
 #if 0
-ICD_EXPORT VkResult VKAPI vkGetDisplayInfoWSI(
-    VkDisplayWSI                            display,
-    VkDisplayInfoTypeWSI                    infoType,
+ICD_EXPORT VkResult VKAPI vkGetDisplayInfoKHR(
+    VkDisplayKHR                            display,
+    VkDisplayInfoTypeKHR                    infoType,
     size_t*                                 pDataSize,
     void*                                   pData)
 {
@@ -830,9 +830,9 @@ ICD_EXPORT VkResult VKAPI vkGetDisplayInfoWSI(
         return VK_ERROR_INVALID_POINTER;
 
     switch (infoType) {
-    case VK_DISPLAY_INFO_TYPE_FORMAT_PROPERTIES_WSI:
+    case VK_DISPLAY_INFO_TYPE_FORMAT_PROPERTIES_KHR:
        {
-            VkDisplayFormatPropertiesWSI *dst = pData;
+            VkDisplayFormatPropertiesKHR *dst = pData;
             size_t size_ret;
             uint32_t i;
 
@@ -846,7 +846,7 @@ ICD_EXPORT VkResult VKAPI vkGetDisplayInfoWSI(
                 return VK_SUCCESS;
 
             for (i = 0; i < ARRAY_SIZE(nulldrv_presentable_formats); i++)
-                dst[i].swapChainFormat = nulldrv_presentable_formats[i];
+                dst[i].swapchainFormat = nulldrv_presentable_formats[i];
         }
         break;
     default:
@@ -858,52 +858,52 @@ ICD_EXPORT VkResult VKAPI vkGetDisplayInfoWSI(
 }
 #endif
 
-ICD_EXPORT VkResult VKAPI vkCreateSwapChainWSI(
+ICD_EXPORT VkResult VKAPI vkCreateSwapchainKHR(
     VkDevice                                device,
-    const VkSwapChainCreateInfoWSI*         pCreateInfo,
-    VkSwapChainWSI*                         pSwapChain)
+    const VkSwapchainCreateInfoKHR*         pCreateInfo,
+    VkSwapchainKHR*                         pSwapchain)
 {
     NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
     struct nulldrv_swap_chain *sc;
 
     sc = (struct nulldrv_swap_chain *) nulldrv_base_create(dev, sizeof(*sc),
-            VK_OBJECT_TYPE_SWAP_CHAIN_WSI);
+            VK_OBJECT_TYPE_SWAPCHAIN_KHR);
     if (!sc) {
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
     sc->dev = dev;
 
-    *(VkSwapChainWSI **)pSwapChain = *(VkSwapChainWSI **)&sc;
+    *(VkSwapchainKHR **)pSwapchain = *(VkSwapchainKHR **)&sc;
 
     return VK_SUCCESS;
 }
 
-ICD_EXPORT VkResult VKAPI vkDestroySwapChainWSI(
+ICD_EXPORT VkResult VKAPI vkDestroySwapchainKHR(
     VkDevice                                device,
-    VkSwapChainWSI                          swapChain)
+    VkSwapchainKHR                          swapchain)
 {
     NULLDRV_LOG_FUNC;
-    struct nulldrv_swap_chain *sc = *(struct nulldrv_swap_chain **) &swapChain;
+    struct nulldrv_swap_chain *sc = *(struct nulldrv_swap_chain **) &swapchain;
 
     free(sc);
 
     return VK_SUCCESS;
 }
 
-ICD_EXPORT VkResult VKAPI vkGetSwapChainImagesWSI(
+ICD_EXPORT VkResult VKAPI vkGetSwapchainImagesKHR(
     VkDevice                                 device,
-    VkSwapChainWSI                           swapChain,
+    VkSwapchainKHR                           swapchain,
     uint32_t*                                pCount,
-    VkImage*                                 pSwapChainImages)
+    VkImage*                                 pSwapchainImages)
 {
     NULLDRV_LOG_FUNC;
-    struct nulldrv_swap_chain *sc = *(struct nulldrv_swap_chain **) &swapChain;
+    struct nulldrv_swap_chain *sc = *(struct nulldrv_swap_chain **) &swapchain;
     struct nulldrv_dev *dev = sc->dev;
     VkResult ret = VK_SUCCESS;
 
     *pCount = 2;
-    if (pSwapChainImages) {
+    if (pSwapchainImages) {
         uint32_t i;
         for (i = 0; i < 2; i++) {
                 struct nulldrv_img *img;
@@ -913,16 +913,16 @@ ICD_EXPORT VkResult VKAPI vkGetSwapChainImagesWSI(
                         VK_OBJECT_TYPE_IMAGE);
                 if (!img)
                     return VK_ERROR_OUT_OF_HOST_MEMORY;
-            pSwapChainImages[i].handle = (uint64_t) &img;
+            pSwapchainImages[i].handle = (uint64_t) &img;
         }
     }
 
     return ret;
 }
 
-ICD_EXPORT VkResult VKAPI vkAcquireNextImageWSI(
+ICD_EXPORT VkResult VKAPI vkAcquireNextImageKHR(
     VkDevice                                 device,
-    VkSwapChainWSI                           swapChain,
+    VkSwapchainKHR                           swapchain,
     uint64_t                                 timeout,
     VkSemaphore                              semaphore,
     uint32_t*                                pImageIndex)
@@ -932,42 +932,42 @@ ICD_EXPORT VkResult VKAPI vkAcquireNextImageWSI(
     return VK_SUCCESS;
 }
 
-VkResult VKAPI vkGetSurfacePropertiesWSI(
+VkResult VKAPI vkGetSurfacePropertiesKHR(
     VkDevice                                 device,
-    const VkSurfaceDescriptionWSI*           pSurfaceDescription,
-    VkSurfacePropertiesWSI*                  pSurfaceProperties)
+    const VkSurfaceDescriptionKHR*           pSurfaceDescription,
+    VkSurfacePropertiesKHR*                  pSurfaceProperties)
 {
     NULLDRV_LOG_FUNC;
 
     return VK_SUCCESS;
 }
 
-VkResult VKAPI vkGetSurfaceFormatsWSI(
+VkResult VKAPI vkGetSurfaceFormatsKHR(
     VkDevice                                 device,
-    const VkSurfaceDescriptionWSI*           pSurfaceDescription,
+    const VkSurfaceDescriptionKHR*           pSurfaceDescription,
     uint32_t*                                pCount,
-    VkSurfaceFormatWSI*                      pSurfaceFormats)
+    VkSurfaceFormatKHR*                      pSurfaceFormats)
 {
     NULLDRV_LOG_FUNC;
 
     return VK_SUCCESS;
 }
 
-VkResult VKAPI vkGetSurfacePresentModesWSI(
+VkResult VKAPI vkGetSurfacePresentModesKHR(
     VkDevice                                 device,
-    const VkSurfaceDescriptionWSI*           pSurfaceDescription,
+    const VkSurfaceDescriptionKHR*           pSurfaceDescription,
     uint32_t*                                pCount,
-    VkPresentModeWSI*                        pPresentModes)
+    VkPresentModeKHR*                        pPresentModes)
 {
     NULLDRV_LOG_FUNC;
 
     return VK_SUCCESS;
 }
 
-ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportWSI(
+ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
     VkPhysicalDevice                        physicalDevice,
     uint32_t                                queueFamilyIndex,
-    const VkSurfaceDescriptionWSI*          pSurfaceDescription,
+    const VkSurfaceDescriptionKHR*          pSurfaceDescription,
     VkBool32*                               pSupported)
 {
     NULLDRV_LOG_FUNC;
@@ -975,9 +975,9 @@ ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportWSI(
     return VK_SUCCESS;
 }
 
-ICD_EXPORT VkResult VKAPI vkQueuePresentWSI(
+ICD_EXPORT VkResult VKAPI vkQueuePresentKHR(
     VkQueue                                  queue_,
-    VkPresentInfoWSI*                        pPresentInfo)
+    VkPresentInfoKHR*                        pPresentInfo)
 {
     NULLDRV_LOG_FUNC;
 
diff --git a/icd/nulldrv/nulldrv.h b/icd/nulldrv/nulldrv.h
index 81088237..eb8632d7 100644
--- a/icd/nulldrv/nulldrv.h
+++ b/icd/nulldrv/nulldrv.h
@@ -33,8 +33,8 @@
 #include <vulkan.h>
 #include <vk_debug_report_lunarg.h>
 #include <vk_icd.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"
 
 #include "icd.h"
 
@@ -52,7 +52,7 @@ struct nulldrv_obj {
 };
 
 enum nulldrv_ext_type {
-   NULLDRV_EXT_WSI_SWAPCHAIN,
+   NULLDRV_EXT_KHR_SWAPCHAIN,
    NULLDRV_EXT_COUNT,
    NULLDRV_EXT_INVALID = NULLDRV_EXT_COUNT,
 };
diff --git a/include/vk_debug_report_lunarg.h b/include/vk_debug_report_lunarg.h
index a8705a12..eeb84251 100644
--- a/include/vk_debug_report_lunarg.h
+++ b/include/vk_debug_report_lunarg.h
@@ -79,7 +79,7 @@ typedef enum {
     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 886ca2d3..721dfb2b 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 @@ typedef struct VkLayerDispatchTable_
     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 @@ typedef struct VkLayerInstanceDispatchTable_
     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 2b82c667..d7e83168 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -70,7 +70,7 @@ unordered_map<VkCmdBuffer,    MT_CB_INFO>           cbMap;
 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 delete_queue_info_list(
 }
 
 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 @@ static void add_object_create_info(const uint64_t handle, const VkDbgObjectType
         // 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 @@ static void print_mem_list(
                     "    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 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkDbgDestroyMsgCallback(
     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 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
     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 cc3a2478..6ae878b6 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -136,7 +136,7 @@ struct MT_QUEUE_INFO {
 };
 
 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 80e1ccde..ca957fbb 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -165,8 +165,8 @@ static inline const char* string_VkDbgObjectType(VkDbgObjectType input_value)
             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 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     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 @@ objTypeToIndex(
 {
     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*> VkBufferMap;
 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 @@ static void create_obj(VkDevice dispatchable_object, VkCmdBuffer vkObj, VkDbgObj
     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 @@ static void create_obj(VkDevice dispatchable_object, VkSwapChainWSI vkObj, VkDbg
     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 @@ static void destroy_obj(VkDevice dispatchable_object, VkSwapChainWSI object)
             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 @@ explicit_AllocDescriptorSets(
 }
 
 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 1190cb7d..975ffb32 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -317,7 +317,7 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapChainWSI(
         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 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetSwapChainImagesWSI(
     }
 
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetSwapChainImagesWSI(
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkQueuePresentWSI(VkQueue queue, VkPresentInfoWSI
             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 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
     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 812c107a..3a6b186c 100644
--- a/layers/vk_validation_layer_details.md
+++ b/layers/vk_validation_layer_details.md
@@ -198,12 +198,12 @@ The ObjectTracker layer maintains a record of all Vulkan objects. It flags error
 
 | 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 87e854d3..0ab7ca30 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -100,7 +100,7 @@ const VkLayerInstanceDispatchTable instance_disp = {
     .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 @@ static bool loader_icd_init_entrys(struct loader_icd *icd,
     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 1e4a3aba..98c57568 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 @@ struct loader_icd {
     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 4064178f..75c7b7a4 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -178,14 +178,14 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
 //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 @@ static inline void *loader_lookup_instance_dispatch_table(
         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 eed42dfa..b51c6e4a 100755
--- a/loader/vk-loader-generate.py
+++ b/loader/vk-loader-generate.py
@@ -48,7 +48,7 @@ class Subcommand(object):
     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 @@ class LoaderEntrypointsSubcommand(Subcommand):
         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 @@ class WinDefFileSubcommand(Subcommand):
         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 4860d846..683945e5 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 @@ void wsi_swapchain_create_instance(
     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 @@ void wsi_swapchain_create_instance(
 
 /*
  * 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 @@ VkResult wsi_swapchain_GetPhysicalDeviceSurfaceSupportWSI(
 
 /*
  * 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 VKAPI loader_GetPhysicalDeviceSurfaceSupportWSI(
     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 @@ void *wsi_swapchain_GetInstanceProcAddr(
         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 68dbc961..c0904e93 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 @@ void *wsi_swapchain_GetInstanceProcAddr(
         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/vk-layer-generate.py b/vk-layer-generate.py
index 619d04a2..6410d326 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -288,7 +288,7 @@ class Subcommand(object):
 
                 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 @@ class GenericLayerSubcommand(Subcommand):
         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 @@ class GenericLayerSubcommand(Subcommand):
     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 @@ class APIDumpSubcommand(Subcommand):
         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 @@ class APIDumpSubcommand(Subcommand):
                     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 @@ class APIDumpSubcommand(Subcommand):
     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 @@ class ObjectTrackerSubcommand(Subcommand):
         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 @@ class ObjectTrackerSubcommand(Subcommand):
             "MapMemory",
             "UnmapMemory",
             "FreeMemory",
-            "DestroySwapChainWSI"
+            "DestroySwapchainKHR"
         ]
         decl = proto.c_func(prefix="vk", attr="VKAPI")
         param0_name = proto.params[0].name
@@ -1584,8 +1584,8 @@ class ObjectTrackerSubcommand(Subcommand):
     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 @@ class ThreadingSubcommand(Subcommand):
         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 4becc7d4..0112087b 100755
--- a/vk_helper.py
+++ b/vk_helper.py
@@ -122,7 +122,7 @@ class HeaderFileParser:
         # 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 @@ class HeaderFileParser:
                         (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 @@ class StructWrapperGen:
         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 @@ class StructWrapperGen:
             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 @@ class StructWrapperGen:
     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 da18b69b..48eba171 100755
--- a/vk_layer_documentation_generate.py
+++ b/vk_layer_documentation_generate.py
@@ -264,8 +264,8 @@ class LayerDoc:
         # 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 05e09200..1847bd58 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -1045,66 +1045,66 @@ core = Extension(
     ],
 )
 
-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 @@ debug_marker_lunarg = Extension(
              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 @@ object_non_dispatch_list = [
     "VkDynamicStencilState",
     "VkRenderPass",
     "VkFramebuffer",
-    "VkSwapChainWSI",
+    "VkSwapchainKHR",
     "VkDbgMsgCallback",
 ]