diff --git a/include/vkDbg.h b/include/vkDbg.h
index 43a5599..cc3c425 100644
--- a/include/vkDbg.h
+++ b/include/vkDbg.h
@@ -109,8 +109,11 @@
     VK_DBG_OBJECT_PIPELINE_LAYOUT,
     VK_DBG_OBJECT_DESCRIPTOR_POOL,
 
+    VK_DBG_OBJECT_DISPLAY_WSI,
+    VK_DBG_OBJECT_SWAP_CHAIN_WSI,
+
     VK_DBG_OBJECT_TYPE_BEGIN_RANGE = VK_DBG_OBJECT_UNKNOWN,
-    VK_DBG_OBJECT_TYPE_END_RANGE   = VK_DBG_OBJECT_DESCRIPTOR_POOL,
+    VK_DBG_OBJECT_TYPE_END_RANGE   = VK_DBG_OBJECT_SWAP_CHAIN_WSI,
     VK_NUM_DBG_OBJECT_TYPE         = (VK_DBG_OBJECT_TYPE_END_RANGE - VK_DBG_OBJECT_TYPE_BEGIN_RANGE + 1),
 } VK_DBG_OBJECT_TYPE;
 
diff --git a/include/vkLayer.h b/include/vkLayer.h
index 70c36a9..55fb384 100644
--- a/include/vkLayer.h
+++ b/include/vkLayer.h
@@ -6,9 +6,7 @@
 
 #include "vulkan.h"
 #include "vkDbg.h"
-#if defined(__linux__) || defined(XCB_NVIDIA)
-#include "vkWsiX11Ext.h"
-#endif
+#include "vk_wsi_lunarg.h"
 #if defined(__GNUC__) && __GNUC__ >= 4
 #  define VK_LAYER_EXPORT __attribute__((visibility("default")))
 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
@@ -153,12 +151,11 @@
     PFN_vkDbgSetDeviceOption DbgSetDeviceOption;
     PFN_vkCmdDbgMarkerBegin CmdDbgMarkerBegin;
     PFN_vkCmdDbgMarkerEnd CmdDbgMarkerEnd;
-#if defined(__linux__) || defined(XCB_NVIDIA)
-    PFN_vkWsiX11AssociateConnection WsiX11AssociateConnection;
-    PFN_vkWsiX11GetMSC WsiX11GetMSC;
-    PFN_vkWsiX11CreatePresentableImage WsiX11CreatePresentableImage;
-    PFN_vkWsiX11QueuePresent WsiX11QueuePresent;
-#endif // WIN32
+    PFN_vkGetDisplayInfoWSI GetDisplayInfoWSI;
+    PFN_vkCreateSwapChainWSI CreateSwapChainWSI;
+    PFN_vkDestroySwapChainWSI DestroySwapChainWSI;
+    PFN_vkGetSwapChainInfoWSI GetSwapChainInfoWSI;
+    PFN_vkQueuePresentWSI QueuePresentWSI;
 } VkLayerDispatchTable;
 
 // LL node for tree of dbg callback functions
diff --git a/include/vkWsiWinExt.h b/include/vkWsiWinExt.h
deleted file mode 100644
index f3ee0f3..0000000
--- a/include/vkWsiWinExt.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* IN DEVELOPMENT.  DO NOT SHIP. */
-
-#ifndef __VKWSIWINEXT_H__
-#define __VKWSIWINEXT_H__
-
-// This is just to get windows to build.
-// Need to replace with the declarations for Windows wsi.
-typedef void VK_WSI_X11_CONNECTION_INFO;
-typedef unsigned int xcb_window_t;
-typedef unsigned int xcb_randr_crtc_t;
-typedef void VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO;
-typedef void VK_WSI_X11_PRESENT_INFO;
-
-#endif // __VKWSIWINEXT_H__
diff --git a/include/vkWsiX11Ext.h b/include/vkWsiX11Ext.h
deleted file mode 100644
index 3b39c64..0000000
--- a/include/vkWsiX11Ext.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/* IN DEVELOPMENT.  DO NOT SHIP. */
-
-#ifndef __VKWSIX11EXT_H__
-#define __VKWSIX11EXT_H__
-
-#include <xcb/xcb.h>
-#include <xcb/randr.h>
-#include "vulkan.h"
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif // __cplusplus
-
-typedef struct _VK_WSI_X11_CONNECTION_INFO {
-    xcb_connection_t*                           pConnection;
-    xcb_window_t                                root;
-    xcb_randr_provider_t                        provider;
-} VK_WSI_X11_CONNECTION_INFO;
-
-typedef struct _VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO
-{
-    VkFormat          format;
-    VkFlags           usage;           // VkImageUsageFlags
-    VkExtent2D        extent;
-    VkFlags           flags;
-} VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO;
-
-typedef struct _VK_WSI_X11_PRESENT_INFO
-{
-    /* which window to present to */
-    xcb_window_t destWindow;
-    VkImage srcImage;
-
-    /**
-     * After the command buffers in the queue have been completed, if the MSC
-     * of \p crtc is less than or equal to \p target_msc, wait until it
-     * reaches \p target_msc.
-     *
-     * If the current MSC of \p crtc is greater than \p target_msc, adjust
-     * \p target_msc as following:
-     *
-     *   if (divisor) {
-     *       target_msc = crtc_msc - (crtc_msc % divisor) + remainder;
-     *       if (target_msc < crtc_msc)
-     *           target_msc += divisor;
-     *   } else {
-     *       target_msc = crtc_msc;
-     *   }
-     *
-     * In other words, either set \p target_msc to an absolute value (require
-     * vkWsiX11GetMSC(), potentially a round-trip to the server, to get the
-     * current MSC first), or set \p target_msc to zero and set a "swap
-     * interval".
-     *
-     * \p crtc can be XCB_NONE.  In that case, a suitable CRTC is picked based
-     * on \p destWindow.
-     */
-    xcb_randr_crtc_t crtc;
-    uint64_t target_msc;
-    uint64_t divisor;
-    uint64_t remainder;
-
-    /**
-     * After waiting for the current and target MSCs to match, the
-     * presentation is scheduled.  When \p async is false, it will occur the
-     * next time current MSC is incremented.  When \p async is true, it will
-     * occur as soon as possible.
-     */
-    bool32_t async;
-
-    /**
-     * When \p flip is false, the contents of \p srcImage are copied to
-     * \p destWindow when the presentation occurs.  When \p flip is true,
-     * \p srcImage is made the front buffer of \p destWindow.
-     *
-     * An error may be returned if \p flip is true but \p destWindow can not
-     * be flipped to.
-     */
-    bool32_t flip;
-} VK_WSI_X11_PRESENT_INFO;
-
-typedef VkResult (VKAPI *PFN_vkWsiX11AssociateConnection)(VkPhysicalDevice gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo);
-typedef VkResult (VKAPI *PFN_vkWsiX11GetMSC)(VkDevice device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc);
-typedef VkResult (VKAPI *PFN_vkWsiX11CreatePresentableImage)(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VkImage* pImage, VkDeviceMemory* pMem);
-typedef VkResult (VKAPI *PFN_vkWsiX11QueuePresent)(VkQueue queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VkFence fence);
-
-/**
- * Associate an X11 connection with a GPU.  This should be done before device
- * creation.  If the device is already created,
- * VK_ERROR_DEVICE_ALREADY_CREATED is returned.
- *
- * Truth is, given a connection, we could find the associated GPU.  But
- * without having a GPU as the first parameter, the loader could not find the
- * dispatch table.
- *
- * This function is available when vkGetGlobalExtensionInfo says "VK_WSI_X11"
- * is supported.
- */
-VkResult VKAPI vkWsiX11AssociateConnection(
-    VkPhysicalDevice                            gpu,
-    const VK_WSI_X11_CONNECTION_INFO*          pConnectionInfo);
-
-/**
- * Return the current MSC (Media Stream Counter, incremented for each vblank)
- * of \p crtc.  If crtc is \p XCB_NONE, a suitable CRTC is picked based on \p
- * win.
- */
-VkResult VKAPI vkWsiX11GetMSC(
-    VkDevice                                  device,
-    xcb_window_t                                window,
-    xcb_randr_crtc_t                            crtc,
-    uint64_t*                                   pMsc);
-
-/**
- * Create an VkImage that can be presented.  An VkDeviceMemory is created
- * and bound automatically.  The memory returned can only be used in
- * vkQueue[Add|Remove]MemReference.  Destroying the memory or binding another memory to the
- * image is not allowed.
- */
-VkResult VKAPI vkWsiX11CreatePresentableImage(
-    VkDevice                                  device,
-    const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo,
-    VkImage*                                  pImage,
-    VkDeviceMemory*                             pMem);
-
-/**
- * Present an image to an X11 window.  The presentation always occurs after
- * the command buffers in the queue have been completed, subject to other
- * parameters specified in VK_WSI_X11_PRESENT_INFO.
- *
- * Fence is reached when the presentation occurs.
- */
-VkResult VKAPI vkWsiX11QueuePresent(
-    VkQueue                                   queue,
-    const VK_WSI_X11_PRESENT_INFO*             pPresentInfo,
-    VkFence                                   fence);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif // __cplusplus
-
-#endif // __VKWSIX11EXT_H__
diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c
index 1a399b9..b4a2507 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -525,7 +525,8 @@
     GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pGlobalObjs;
     while (pTrav != NULL)
     {
-        if (pTrav->obj.objType == VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY)
+        if (pTrav->obj.objType == VK_OBJECT_TYPE_SWAP_CHAIN_IMAGE_WSI ||
+            pTrav->obj.objType == VK_OBJECT_TYPE_SWAP_CHAIN_MEMORY_WSI)
         {
             GLV_VK_SNAPSHOT_LL_NODE *pDel = pTrav;
             pTrav = pTrav->pNextGlobal;
@@ -1691,58 +1692,67 @@
     nextTable.CmdDbgMarkerEnd(cmdBuffer);
 }
 
-#if defined(__linux__) || defined(XCB_NVIDIA)
-
-VK_LAYER_EXPORT VkResult VKAPI vkWsiX11AssociateConnection(VkPhysicalGpu gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo)
+VK_LAYER_EXPORT VkResult VKAPI xglGetDisplayInfoWSI(VkDisplayWSI display, VkDisplayInfoTypeWSI infoType, size_t* pDataSize, void* pData)
 {
-    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)gpu, VK_OBJECT_TYPE_PHYSICAL_GPU);
+    ll_increment_use_count((void*)display, VK_OBJECT_TYPE_DISPLAY_WSI);
     loader_platform_thread_unlock_mutex(&objLock);
-    pCurObj = gpuw;
-    loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
-    VkResult result = nextTable.WsiX11AssociateConnection((VkPhysicalGpu)gpuw->nextObject, pConnectionInfo);
+    VkResult result = nextTable.GetDisplayInfoWSI(display, infoType, pDataSize, pData);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkWsiX11GetMSC(VkDevice device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc)
+VK_LAYER_EXPORT VkResult VKAPI xglCreateSwapChainWSI(VkDevice device, const VkSwapChainCreateInfoWSI* pCreateInfo, VkSwapChainWSI* pSwapChain)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    VkResult result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc);
-    return result;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkWsiX11CreatePresentableImage(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VkImage* pImage, VkGpuMemory* pMem)
-{
-    loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
-    loader_platform_thread_unlock_mutex(&objLock);
-    VkResult result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
-
+    VkResult result = nextTable.CreateSwapChainWSI(device, pCreateInfo, pSwapChain);
     if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
 
+#if 0
         GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, VK_OBJECT_TYPE_IMAGE);
         pNode->obj.pStruct = NULL;
 
         GLV_VK_SNAPSHOT_LL_NODE* pMemNode = snapshot_insert_object(&s_delta, *pMem, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);
         pMemNode->obj.pStruct = NULL;
+#else
+        snapshot_insert_object(&s_delta, (void*)*pSwapChain, VK_OBJECT_TYPE_SWAP_CHAIN_WSI);
+#endif
 
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
+
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkWsiX11QueuePresent(VkQueue queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VkFence fence)
+VK_LAYER_EXPORT VkResult VKAPI xglDestroySwapChainWSI(VkSwapChainWSI swapChain)
 {
-    VkResult result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
+    VkResult result = nextTable.DestroySwapChainWSI(swapChain);
+    loader_platform_thread_lock_mutex(&objLock);
+    snapshot_remove_object(&s_delta, (void*)swapChain);
+    loader_platform_thread_unlock_mutex(&objLock);
     return result;
 }
 
-#endif
+VK_LAYER_EXPORT VkResult VKAPI xglGetSwapChainInfoWSI(VkSwapChainWSI swapChain, VkSwapChainInfoTypeWSI infoType, size_t* pDataSize, void* pData)
+{
+    loader_platform_thread_lock_mutex(&objLock);
+    ll_increment_use_count((void*)swapChain, VK_OBJECT_TYPE_SWAP_CHAIN_WSI);
+    loader_platform_thread_unlock_mutex(&objLock);
+    VkResult result = nextTable.GetSwapChainInfoWSI(swapChain, infoType, pDataSize, pData);
+    return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI xglQueuePresentWSI(VkQueue queue, const VkPresentInfoWSI* pPresentInfo)
+{
+    loader_platform_thread_lock_mutex(&objLock);
+    ll_increment_use_count((void*)queue, VK_OBJECT_TYPE_QUEUE);
+    loader_platform_thread_unlock_mutex(&objLock);
+    VkResult result = nextTable.QueuePresentWSI(queue, pPresentInfo);
+    return result;
+}
 
 //=================================================================================================
 // Exported methods
diff --git a/layers/glave_snapshot.h b/layers/glave_snapshot.h
index f0de0e9..9ca095b 100644
--- a/layers/glave_snapshot.h
+++ b/layers/glave_snapshot.h
@@ -90,7 +90,11 @@
     VK_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT,
     VK_OBJECT_TYPE_FENCE,
     VK_OBJECT_TYPE_CMD_BUFFER,
-    VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY,
+
+    VK_OBJECT_TYPE_DISPLAY_WSI,
+    VK_OBJECT_TYPE_SWAP_CHAIN_WSI,
+    VK_OBJECT_TYPE_SWAP_CHAIN_IMAGE_WSI,
+    VK_OBJECT_TYPE_SWAP_CHAIN_MEMORY_WSI,
 
     VK_NUM_OBJECT_TYPE,
     VK_OBJECT_TYPE_ANY, // Allow global object list to be queried/retrieved
@@ -157,8 +161,14 @@
             return "QUERY_POOL";
         case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
             return "DESCRIPTOR_POOL";
-        case VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY:
-            return "PRESENTABLE_IMAGE_MEMORY";
+        case VK_OBJECT_TYPE_DISPLAY_WSI:
+            return "DISPLAY_WSI";
+        case VK_OBJECT_TYPE_SWAP_CHAIN_WSI:
+            return "SWAP_CHAIN_WSI";
+        case VK_OBJECT_TYPE_SWAP_CHAIN_IMAGE_WSI:
+            return "SWAP_CHAIN_IMAGE_WSI";
+        case VK_OBJECT_TYPE_SWAP_CHAIN_MEMORY_WSI:
+            return "SWAP_CHAIN_MEMORY_WSI";
         default:
             return "UNKNOWN";
     }
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 10215e6..bf0a325 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -29,6 +29,7 @@
 #include <assert.h>
 #include <list>
 #include <map>
+#include <vector>
 using namespace std;
 
 #include "loader_platform.h"
@@ -55,6 +56,7 @@
 map<VkObject,     MT_OBJ_INFO*>     objectMap;
 map<uint64_t,       MT_FENCE_INFO*>   fenceMap;    // Map fenceId to fence info
 map<VkQueue,      MT_QUEUE_INFO*>   queueMap;
+map<VkSwapChainWSI, MT_SWAP_CHAIN_INFO*>   swapChainMap;
 
 // TODO : Add per-device fence completion
 static uint64_t     g_currentFenceId  = 1;
@@ -78,6 +80,12 @@
     queueMap.clear();
 }
 
+static void addSwapChainInfo(const VkSwapChainWSI swapChain)
+{
+    MT_SWAP_CHAIN_INFO* pInfo = new MT_SWAP_CHAIN_INFO;
+    swapChainMap[swapChain] = pInfo;
+}
+
 // Add new CBInfo for this cb to map container
 static void addCBInfo(const VkCmdBuffer cb)
 {
@@ -362,7 +370,7 @@
     pInfo->refCount           = 0;
     memset(&pInfo->allocInfo, 0, sizeof(VkMemoryAllocInfo));
 
-    if (pAllocInfo) {  // MEM alloc created by vkWsiX11CreatePresentableImage() doesn't have alloc info struct
+    if (pAllocInfo) {  // MEM alloc created by vkCreateSwapChainWSI() doesn't have alloc info struct
         memcpy(&pInfo->allocInfo, pAllocInfo, sizeof(VkMemoryAllocInfo));
         // TODO:  Update for real hardware, actually process allocation info structures
         pInfo->allocInfo.pNext = NULL;
@@ -570,7 +578,7 @@
     } else {
         if (pInfo->allocInfo.allocationSize == 0 && !internal) {
             char str[1024];
-            sprintf(str, "Attempting to free memory associated with a Presentable Image, %p, this should not be explicitly freed\n", (void*)mem);
+            sprintf(str, "Attempting to free memory associated with a Persistent Image, %p, this should not be explicitly freed\n", (void*)mem);
             layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
             result = VK_FALSE;
         } else {
@@ -767,7 +775,7 @@
             sprintf(str, "    Mem Alloc info:\n%s", pAllocInfoMsg.c_str());
             layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
         } else {
-            sprintf(str, "    Mem Alloc info is NULL (alloc done by vkWsiX11CreatePresentableImage())");
+            sprintf(str, "    Mem Alloc info is NULL (alloc done by vkCreateSwapChainWSI())");
             layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
         }
 
@@ -1938,40 +1946,82 @@
     return result;
 }
 
-#if !defined(WIN32)
-VK_LAYER_EXPORT VkResult VKAPI vkWsiX11CreatePresentableImage(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo,
-    VkImage* pImage, VkDeviceMemory* pMem)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapChainWSI(VkDevice device, const VkSwapChainCreateInfoWSI* pCreateInfo, VkSwapChainWSI* pSwapChain)
 {
-    VkResult result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
-    loader_platform_thread_lock_mutex(&globalLock);
+    VkResult result = nextTable.CreateSwapChainWSI(device, pCreateInfo, pSwapChain);
+
     if (VK_SUCCESS == result) {
-        // Add image object, then insert the new Mem Object and then bind it to created image
-        addObjectInfo(*pImage, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, sizeof(VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO), "wsi_x11_image");
-        addMemObjInfo(*pMem, NULL);
-        if (VK_FALSE == updateObjectBinding(*pImage, *pMem)) {
-            char str[1024];
-            sprintf(str, "In vkWsiX11CreatePresentableImage(), unable to set image %p binding to mem obj %p", (void*)*pImage, (void*)*pMem);
-            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, *pImage, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
-        }
+        loader_platform_thread_lock_mutex(&globalLock);
+        addSwapChainInfo(*pSwapChain);
+        loader_platform_thread_unlock_mutex(&globalLock);
     }
-    printObjList();
-    printMemList();
-    loader_platform_thread_unlock_mutex(&globalLock);
+
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkWsiX11QueuePresent(VkQueue queue, const VK_WSI_X11_PRESENT_INFO*  pPresentInfo, VkFence fence)
+VK_LAYER_EXPORT VkResult VKAPI vkDestroySwapChainWSI(VkSwapChainWSI swapChain)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    addFenceInfo(fence, queue);
-    char            str[1024];
-    sprintf(str, "In vkWsiX11QueuePresent(), checking queue %p for fence %p", queue, fence);
-    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str);
+
+    if (swapChainMap.find(swapChain) != swapChainMap.end()) {
+        MT_SWAP_CHAIN_INFO* pInfo = swapChainMap[swapChain];
+
+        for (std::vector<VkSwapChainImageInfoWSI>::const_iterator it = pInfo->images.begin();
+             it != pInfo->images.end(); it++) {
+            clearObjectBinding(it->image);
+            freeMemObjInfo(it->memory, true);
+
+            MT_OBJ_INFO* pDelInfo = objectMap[it->image];
+            delete pDelInfo;
+            objectMap.erase(it->image);
+        }
+
+        delete pInfo;
+        swapChainMap.erase(swapChain);
+    }
+
     loader_platform_thread_unlock_mutex(&globalLock);
-    VkResult result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
+
+    return nextTable.DestroySwapChainWSI(swapChain);
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkGetSwapChainInfoWSI(VkSwapChainWSI swapChain, VkSwapChainInfoTypeWSI infoType, size_t* pDataSize, void* pData)
+{
+    VkResult result = nextTable.GetSwapChainInfoWSI(swapChain, infoType, pDataSize, pData);
+
+    if (infoType == VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI && result == VK_SUCCESS) {
+        const size_t count = *pDataSize / sizeof(VkSwapChainImageInfoWSI);
+        MT_SWAP_CHAIN_INFO *pInfo = swapChainMap[swapChain];
+
+        if (pInfo->images.empty()) {
+            pInfo->images.resize(count);
+            memcpy(&pInfo->images[0], pData, sizeof(pInfo->images[0]) * count);
+
+            for (std::vector<VkSwapChainImageInfoWSI>::const_iterator it = pInfo->images.begin();
+                 it != pInfo->images.end(); it++) {
+                // Add image object, then insert the new Mem Object and then bind it to created image
+                addObjectInfo(it->image, VK_STRUCTURE_TYPE_MAX_ENUM, &pInfo->createInfo, sizeof(pInfo->createInfo), "persistent_image");
+                addMemObjInfo(it->memory, NULL);
+                if (VK_FALSE == updateObjectBinding(it->image, it->memory)) {
+                    char str[1024];
+                    sprintf(str, "In vkGetSwapChainInfoWSI(), unable to set image %p binding to mem obj %p", (void*)it->image, (void*)it->memory);
+                    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, it->image, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+                }
+            }
+        } else {
+            const bool mismatch = (pInfo->images.size() != count ||
+                    memcmp(&pInfo->images[0], pData, sizeof(pInfo->images[0]) * count));
+
+            if (mismatch) {
+                char str[1024];
+                sprintf(str, "vkGetSwapChainInfoWSI(%p, VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI) returned mismatching data", swapChain);
+                layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, (VkBaseObject) swapChain, 0, MEMTRACK_NONE, "SWAP_CHAIN", str);
+            }
+        }
+    }
+
     return result;
 }
-#endif // WIN32
 
 VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char* funcName)
 {
@@ -2122,12 +2172,12 @@
         return (void*) vkQueueAddMemReferences;
     if (!strcmp(funcName, "vkQueueRemoveMemReferences"))
         return (void*) vkQueueRemoveMemReferences;
-#if !defined(WIN32)
-    if (!strcmp(funcName, "vkWsiX11CreatePresentableImage"))
-        return (void*) vkWsiX11CreatePresentableImage;
-    if (!strcmp(funcName, "vkWsiX11QueuePresent"))
-        return (void*) vkWsiX11QueuePresent;
-#endif
+    if (!strcmp(funcName, "vkCreateSwapChainWSI"))
+        return (void*) vkCreateSwapChainWSI;
+    if (!strcmp(funcName, "vkDestroySwapChainWSI"))
+        return (void*) vkDestroySwapChainWSI;
+    if (!strcmp(funcName, "vkGetSwapChainInfoWSI"))
+        return (void*) vkGetSwapChainInfoWSI;
     else {
         if (gpuw->pGPA == NULL)
             return NULL;
diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h
index d1d2b82..417da1d 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -22,6 +22,7 @@
  * DEALINGS IN THE SOFTWARE.
  */
 #pragma once
+#include <vector>
 #include "vkLayer.h"
 
 #ifdef __cplusplus
@@ -108,9 +109,7 @@
         VkComputePipelineCreateInfo          compute_pipeline_create_info;
         VkSamplerCreateInfo                   sampler_create_info;
         VkFenceCreateInfo                     fence_create_info;
-#ifndef _WIN32
-        VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO wsi_x11_presentable_image_create_info;
-#endif // _WIN32
+        VkSwapChainCreateInfoWSI            swap_chain_create_info;
     } create_info;
     char object_name[64];
 };
@@ -143,6 +142,11 @@
     list<VkDeviceMemory>          pMemRefList;
 };
 
+struct MT_SWAP_CHAIN_INFO {
+    VkSwapChainCreateInfoWSI createInfo;
+    std::vector<VkSwapChainImageInfoWSI> images;
+};
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/layers/object_track.h b/layers/object_track.h
index 64e95b0..7b86c37 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -87,7 +87,11 @@
     VkObjectTypeDynamicRsState,
     VkObjectTypeFence,
     VkObjectTypeCmdBuffer,
-    VkObjectTypePresentableImageMemory,
+
+    VkObjectTypeDisplayWSI,
+    VkObjectTypeSwapChainWSI,
+    VkObjectTypeSwapChainImageWSI,
+    VkObjectTypeSwapChainMemoryWSI,
 
     VkObjectTypeUnknown,
     VkNumObjectType,
@@ -155,8 +159,15 @@
             return "QUERY_POOL";
         case VkObjectTypeDescriptorPool:
             return "DESCRIPTOR_POOL";
-        case VkObjectTypePresentableImageMemory:
-            return "PRESENTABLE_IMAGE_MEMORY";
+
+        case VkObjectTypeDisplayWSI:
+            return "DISPLAY_WSI";
+        case VkObjectTypeSwapChainWSI:
+            return "SWAP_CHAIN_WSI";
+        case VkObjectTypeSwapChainImageWSI:
+            return "SWAP_CHAIN_IMAGE_WSI";
+        case VkObjectTypeSwapChainMemoryWSI:
+            return "SWAP_CHAIN_MEMORY_WSI";
         default:
             return "UNKNOWN";
     }
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index e3058a5..b3eb1dc 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -1952,39 +1952,35 @@
     nextTable.CmdDbgMarkerEnd(cmdBuffer);
 }
 
-#if defined(__linux__) || defined(XCB_NVIDIA)
-
-VK_LAYER_EXPORT VkResult VKAPI vkWsiX11AssociateConnection(VkPhysicalDevice gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo)
+VK_LAYER_EXPORT VkResult VKAPI vkGetDisplayInfoWSI(VkDisplayWSI display, VkDisplayInfoTypeWSI infoType, size_t* pDataSize, void* pData)
 {
-    pCurObj = (VkBaseLayerObject *) gpu;
-    loader_platform_thread_once(&tabOnce, initParamChecker);
-
-    VkResult result = nextTable.WsiX11AssociateConnection(gpu, pConnectionInfo);
+    VkResult result = nextTable.GetDisplayInfoWSI(display, infoType, pDataSize, pData);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkWsiX11GetMSC(VkDevice device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapChainWSI(VkDevice device, const VkSwapChainCreateInfoWSI* pCreateInfo, VkSwapChainWSI* pSwapChain)
 {
-
-    VkResult result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc);
+    VkResult result = nextTable.CreateSwapChainWSI(device, pCreateInfo, pSwapChain);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkWsiX11CreatePresentableImage(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VkImage* pImage, VkDeviceMemory* pMem)
+VK_LAYER_EXPORT VkResult VKAPI vkDestroySwapChainWSI(VkSwapChainWSI swapChain)
 {
-
-    VkResult result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
+    VkResult result = nextTable.DestroySwapChainWSI(swapChain);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkWsiX11QueuePresent(VkQueue queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VkFence fence)
+VK_LAYER_EXPORT VkResult VKAPI vkGetSwapChainInfoWSI(VkSwapChainWSI swapChain, VkSwapChainInfoTypeWSI infoType, size_t* pDataSize, void* pData)
 {
-
-    VkResult result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
+    VkResult result = nextTable.GetSwapChainInfoWSI(swapChain, infoType, pDataSize, pData);
     return result;
 }
 
-#endif
+VK_LAYER_EXPORT VkResult VKAPI vkQueuePresentWSI(VkQueue queue, const VkPresentInfoWSI* pPresentInfo)
+{
+    VkResult result = nextTable.QueuePresentWSI(queue, pPresentInfo);
+    return result;
+}
 
 #include "vk_generic_intercept_proc_helper.h"
 VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char* funcName)
diff --git a/loader/loader.h b/loader/loader.h
index 79d77c8..ce157bf 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -30,11 +30,7 @@
 
 #include <vulkan.h>
 #include <vkDbg.h>
-#if defined(WIN32)
-// FIXME: NEED WINDOWS EQUIVALENT
-#else // WIN32
-#include <vkWsiX11Ext.h>
-#endif // WIN32
+#include <vk_wsi_lunarg.h>
 #include <vkLayer.h>
 #include <vkIcd.h>
 #include <assert.h>
diff --git a/tests/test_environment.cpp b/tests/test_environment.cpp
index 03beb12..90483ec 100644
--- a/tests/test_environment.cpp
+++ b/tests/test_environment.cpp
@@ -7,7 +7,7 @@
 namespace vk_testing {
 
 Environment::Environment() :
-    m_connection(NULL), default_dev_(0)
+    default_dev_(0)
 {
     app_.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
     app_.pAppName = "vk_testing";
@@ -77,64 +77,8 @@
     }
 }
 
-void Environment::X11SetUp()
-{
-
-    uint32_t count;
-    VkResult err;
-    const xcb_setup_t *setup;
-    xcb_screen_iterator_t iter;
-    int scr;
-    VkInstanceCreateInfo instInfo = {};
-    instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
-    instInfo.pNext = NULL;
-    instInfo.pAppInfo = &app_;
-    instInfo.pAllocCb = NULL;
-    instInfo.extensionCount = 0;
-    instInfo.ppEnabledExtensionNames = NULL;
-
-    err = vkCreateInstance(&instInfo, &inst);
-    ASSERT_EQ(VK_SUCCESS, err);
-    err = vkEnumeratePhysicalDevices(inst, &count, NULL);
-    ASSERT_EQ(VK_SUCCESS, err);
-    ASSERT_LE(count, ARRAY_SIZE(gpus));
-    err = vkEnumeratePhysicalDevices(inst, &count, gpus);
-    ASSERT_EQ(VK_SUCCESS, err);
-    ASSERT_GT(count, default_dev_);
-
-    m_connection = xcb_connect(NULL, &scr);
-
-    setup = xcb_get_setup(m_connection);
-    iter = xcb_setup_roots_iterator(setup);
-    while (scr-- > 0)
-        xcb_screen_next(&iter);
-
-    m_screen = iter.data;
-
-    VK_WSI_X11_CONNECTION_INFO connection_info = {};
-    connection_info.pConnection = m_connection;
-    connection_info.root = m_screen->root;
-    connection_info.provider = 0;
-
-    err = vkWsiX11AssociateConnection(gpus[0], &connection_info);
-    assert(!err);
-
-
-    devs_.reserve(count);
-    for (uint32_t i = 0; i < count; i++) {
-        devs_.push_back(new Device(gpus[i]));
-        if (i == default_dev_) {
-            devs_[i]->init();
-            ASSERT_NE(true, devs_[i]->graphics_queues().empty());
-        }
-    }
-}
-
 void Environment::TearDown()
 {
-    if (m_connection)
-        xcb_disconnect(m_connection);
-
     // destroy devices first
     for (std::vector<Device *>::iterator it = devs_.begin(); it != devs_.end(); it++)
         delete *it;
diff --git a/tests/test_environment.h b/tests/test_environment.h
index 43530a7..fba8885 100644
--- a/tests/test_environment.h
+++ b/tests/test_environment.h
@@ -1,7 +1,7 @@
 #ifndef TEST_ENVIRONMENT_H
 #define TEST_ENVIRONMENT_H
+
 #include "vktestbinding.h"
-#include <vkWsiX11Ext.h>
 
 namespace vk_testing {
 class Environment : public ::testing::Environment {
@@ -11,10 +11,7 @@
     bool parse_args(int argc, char **argv);
 
     virtual void SetUp();
-    virtual void X11SetUp();
     virtual void TearDown();
-    xcb_connection_t         *m_connection;
-    xcb_screen_t             *m_screen;
 
     const std::vector<Device *> &devices() { return devs_; }
     Device &default_device() { return *(devs_[default_dev_]); }
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index abfaca4..10afce8 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -150,7 +150,7 @@
 {
     // Extensions to enable
     static const char *known_exts[] = {
-        "VK_WSI_X11",
+        "VK_WSI_LunarG",
     };
     std::vector<const char *> exts;
     size_t extSize = sizeof(uint32_t);
diff --git a/tests/vktestframework.cpp b/tests/vktestframework.cpp
index 8f9f360..20904a3 100644
--- a/tests/vktestframework.cpp
+++ b/tests/vktestframework.cpp
@@ -28,6 +28,8 @@
 #include <limits.h>
 #include <math.h>
 #include <wand/MagickWand.h>
+#include <xcb/xcb.h>
+#include <vk_wsi_lunarg.h>
 
 // Command-line options
 enum TOptions {
@@ -47,6 +49,43 @@
     EOptionDefaultDesktop     = 0x1000,
 };
 
+class TestFrameworkVkPresent
+{
+public:
+    TestFrameworkVkPresent(vk_testing::Device &device);
+
+    void Run();
+    void InitPresentFramework(std::list<VkTestImageRecord> &imagesIn);
+    void CreateMyWindow();
+    void CreateSwapChain();
+    void TearDown();
+
+protected:
+    vk_testing::Device                    &m_device;
+    vk_testing::Queue                     &m_queue;
+    vk_testing::CmdBuffer                  m_cmdbuf;
+
+private:
+    xcb_connection_t                       *m_connection;
+    xcb_screen_t                           *m_screen;
+    xcb_window_t                            m_window;
+    xcb_intern_atom_reply_t                *m_atom_wm_delete_window;
+    std::list<VkTestImageRecord>           m_images;
+
+    VkSwapChainWSI                          m_swap_chain;
+
+    bool                                    m_quit;
+    bool                                    m_pause;
+
+    uint32_t                                m_width;
+    uint32_t                                m_height;
+
+    std::list<VkTestImageRecord>::iterator m_display_image;
+
+    void Display();
+    void HandleEvent(xcb_generic_event_t *event);
+};
+
 #ifndef _WIN32
 
 #include <errno.h>
@@ -380,10 +419,8 @@
     }
 }
 
-static vk_testing::Environment *environment;
-
-TestFrameworkVkPresent::TestFrameworkVkPresent() :
-   m_device(environment->default_device()),
+TestFrameworkVkPresent::TestFrameworkVkPresent(vk_testing::Device &device) :
+   m_device(device),
    m_queue(*m_device.graphics_queues()[0]),
    m_cmdbuf(m_device, vk_testing::CmdBuffer::create_info(m_device.graphics_queue_node_index_))
 {
@@ -397,11 +434,12 @@
 {
     VkResult err;
 
-    VK_WSI_X11_PRESENT_INFO present = {};
-    present.destWindow = m_window;
-    present.srcImage = m_display_image->m_presentableImage;
+    VkPresentInfoWSI present = {};
+    present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_WSI;
+    present.image = m_display_image->m_presentableImage;
+    present.flipInterval = 1;
 
-    xcb_change_property (environment->m_connection,
+    xcb_change_property (m_connection,
                          XCB_PROP_MODE_REPLACE,
                          m_window,
                          XCB_ATOM_WM_NAME,
@@ -410,7 +448,7 @@
                          m_display_image->m_title.size(),
                          m_display_image->m_title.c_str());
 
-    err = vkWsiX11QueuePresent(m_queue.obj(), &present, NULL);
+    err = vkQueuePresentWSI(m_queue.obj(), &present);
     assert(!err);
 
     m_queue.wait();
@@ -466,15 +504,15 @@
 
 void  TestFrameworkVkPresent::Run()
 {
-    xcb_flush(environment->m_connection);
+    xcb_flush(m_connection);
 
     while (! m_quit) {
         xcb_generic_event_t *event;
 
         if (m_pause) {
-            event = xcb_wait_for_event(environment->m_connection);
+            event = xcb_wait_for_event(m_connection);
         } else {
-            event = xcb_poll_for_event(environment->m_connection);
+            event = xcb_poll_for_event(m_connection);
         }
         if (event) {
             HandleEvent(event);
@@ -483,26 +521,42 @@
     }
 }
 
-void TestFrameworkVkPresent::CreatePresentableImages()
+void TestFrameworkVkPresent::CreateSwapChain()
 {
     VkResult err;
 
+    VkSwapChainCreateInfoWSI swap_chain = {};
+    swap_chain.sType = VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI;
+    swap_chain.pNativeWindowSystemHandle = (void *) m_connection;
+    swap_chain.pNativeWindowHandle = (void *) (intptr_t) m_window;
+    swap_chain.imageCount = m_images.size();
+    swap_chain.imageFormat = VK_FORMAT_B8G8R8A8_UNORM;
+    swap_chain.imageExtent.width = m_width;
+    swap_chain.imageExtent.height = m_height;
+    swap_chain.imageArraySize = 1;
+    swap_chain.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT;
+    swap_chain.swapModeFlags = VK_SWAP_MODE_FLIP_BIT_WSI |
+                               VK_SWAP_MODE_BLIT_BIT_WSI;
+
+    err = vkCreateSwapChainWSI(m_device.obj(), &swap_chain, &m_swap_chain);
+    assert(!err);
+
+    size_t size = sizeof(VkSwapChainImageInfoWSI) * m_images.size();
+    std::vector<VkSwapChainImageInfoWSI> persistent_images;
+    persistent_images.resize(m_images.size());
+    err = vkGetSwapChainInfoWSI(m_swap_chain,
+            VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI,
+            &size, &persistent_images[0]);
+    assert(!err && size == sizeof(VkSwapChainImageInfoWSI) * m_images.size());
+
     m_display_image = m_images.begin();
 
     for (int x=0; x < m_images.size(); x++)
     {
-        VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO presentable_image_info = {};
-        presentable_image_info.format = VK_FORMAT_B8G8R8A8_UNORM;
-        presentable_image_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-        presentable_image_info.extent.width = m_display_image->m_width;
-        presentable_image_info.extent.height = m_display_image->m_height;
-        presentable_image_info.flags = 0;
-
         void *dest_ptr;
 
-        err = vkWsiX11CreatePresentableImage(m_device.obj(), &presentable_image_info,
-                        &m_display_image->m_presentableImage, &m_display_image->m_presentableMemory);
-        assert(!err);
+        m_display_image->m_presentableImage = persistent_images[x].image;
+        m_display_image->m_presentableMemory = persistent_images[x].memory;
 
         vk_testing::Buffer buf;
         buf.init(m_device, (VkDeviceSize) m_display_image->m_data_size);
@@ -535,15 +589,7 @@
         vkQueueRemoveMemReferences(m_queue.obj(), 1, &m_display_image->m_presentableMemory);
         vkQueueRemoveMemReferences(m_queue.obj(), buf.memories().size(), &buf.memories()[0]);
 
-        if (m_display_image->m_width > m_width)
-            m_width = m_display_image->m_width;
-
-        if (m_display_image->m_height > m_height)
-            m_height = m_display_image->m_height;
-
-
         ++m_display_image;
-
     }
 
     m_display_image = m_images.begin();
@@ -556,67 +602,83 @@
 
 void  TestFrameworkVkPresent::CreateMyWindow()
 {
+    const xcb_setup_t *setup;
+    xcb_screen_iterator_t iter;
+    int scr;
     uint32_t value_mask, value_list[32];
 
-    m_window = xcb_generate_id(environment->m_connection);
+    m_connection = xcb_connect(NULL, &scr);
+
+    setup = xcb_get_setup(m_connection);
+    iter = xcb_setup_roots_iterator(setup);
+    while (scr-- > 0)
+        xcb_screen_next(&iter);
+
+    m_screen = iter.data;
+
+    for (std::list<VkTestImageRecord>::const_iterator it = m_images.begin();
+         it != m_images.end(); it++) {
+        if (m_width < it->m_width)
+            m_width = it->m_width;
+        if (m_height < it->m_height)
+            m_height = it->m_height;
+    }
+
+    m_window = xcb_generate_id(m_connection);
 
     value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
-    value_list[0] = environment->m_screen->black_pixel;
+    value_list[0] = m_screen->black_pixel;
     value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |
                     XCB_EVENT_MASK_EXPOSURE |
                     XCB_EVENT_MASK_STRUCTURE_NOTIFY;
 
-    xcb_create_window(environment->m_connection,
+    xcb_create_window(m_connection,
             XCB_COPY_FROM_PARENT,
-            m_window, environment->m_screen->root,
+            m_window, m_screen->root,
             0, 0, m_width, m_height, 0,
             XCB_WINDOW_CLASS_INPUT_OUTPUT,
-            environment->m_screen->root_visual,
+            m_screen->root_visual,
             value_mask, value_list);
 
     /* Magic code that will send notification when window is destroyed */
-    xcb_intern_atom_cookie_t cookie = xcb_intern_atom(environment->m_connection, 1, 12,
+    xcb_intern_atom_cookie_t cookie = xcb_intern_atom(m_connection, 1, 12,
                                                       "WM_PROTOCOLS");
-    xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(environment->m_connection, cookie, 0);
+    xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(m_connection, cookie, 0);
 
-    xcb_intern_atom_cookie_t cookie2 = xcb_intern_atom(environment->m_connection, 0, 16, "WM_DELETE_WINDOW");
-    m_atom_wm_delete_window = xcb_intern_atom_reply(environment->m_connection, cookie2, 0);
+    xcb_intern_atom_cookie_t cookie2 = xcb_intern_atom(m_connection, 0, 16, "WM_DELETE_WINDOW");
+    m_atom_wm_delete_window = xcb_intern_atom_reply(m_connection, cookie2, 0);
 
-    xcb_change_property(environment->m_connection, XCB_PROP_MODE_REPLACE,
+    xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE,
                         m_window, (*reply).atom, 4, 32, 1,
                         &(*m_atom_wm_delete_window).atom);
     free(reply);
 
-    xcb_map_window(environment->m_connection, m_window);
+    xcb_map_window(m_connection, m_window);
 }
 
 void TestFrameworkVkPresent::TearDown()
 {
-    std::list<VkTestImageRecord>::const_iterator iterator;
-    for (iterator = m_images.begin(); iterator != m_images.end(); ++iterator) {
-        vkDestroyObject(iterator->m_presentableImage);
-    }
-    xcb_destroy_window(environment->m_connection, m_window);
+    vkDestroySwapChainWSI(m_swap_chain);
+    xcb_destroy_window(m_connection, m_window);
+    xcb_disconnect(m_connection);
 }
 
 void VkTestFramework::Finish()
 {
     if (m_images.size() == 0) return;
 
-    environment = new vk_testing::Environment();
-    ::testing::AddGlobalTestEnvironment(environment);
-    environment->X11SetUp();
-
+    vk_testing::Environment env;
+    env.SetUp();
     {
-        TestFrameworkVkPresent vkPresent;
+        TestFrameworkVkPresent vkPresent(env.default_device());
 
         vkPresent.InitPresentFramework(m_images);
-        vkPresent.CreatePresentableImages();
         vkPresent.CreateMyWindow();
+        vkPresent.CreateSwapChain();
         vkPresent.Run();
         vkPresent.TearDown();
     }
-    environment->TearDown();
+    env.TearDown();
 }
 
 //
diff --git a/tests/vktestframework.h b/tests/vktestframework.h
index ba53923..02fd107 100644
--- a/tests/vktestframework.h
+++ b/tests/vktestframework.h
@@ -38,7 +38,6 @@
 #include <iostream>
 #include <fstream>
 #include <list>
-#include <vkWsiX11Ext.h>
 
 // Can be used by tests to record additional details / description of test
 #define TEST_DESCRIPTION(desc) RecordProperty("description", desc)
@@ -116,40 +115,6 @@
 
 };
 
-
-class TestFrameworkVkPresent
-{
-public:
-    TestFrameworkVkPresent();
-
-    void Run();
-    void InitPresentFramework(std::list<VkTestImageRecord> &imagesIn);
-    void CreateMyWindow();
-    void CreatePresentableImages();
-    void TearDown();
-
-protected:
-    vk_testing::Device                    &m_device;
-    vk_testing::Queue                     &m_queue;
-    vk_testing::CmdBuffer                  m_cmdbuf;
-
-private:
-    xcb_window_t                            m_window;
-    xcb_intern_atom_reply_t                *m_atom_wm_delete_window;
-    std::list<VkTestImageRecord>           m_images;
-
-    bool                                    m_quit;
-    bool                                    m_pause;
-
-    uint32_t                                m_width;
-    uint32_t                                m_height;
-
-    std::list<VkTestImageRecord>::iterator m_display_image;
-
-    void Display();
-    void HandleEvent(xcb_generic_event_t *event);
-};
-
 class TestEnvironment : public ::testing::Environment
 {
  public:
diff --git a/vk-generate.py b/vk-generate.py
index 39af406..550ebc1 100755
--- a/vk-generate.py
+++ b/vk-generate.py
@@ -133,6 +133,29 @@
             setup.append("uint32_t i;")
             setup.append("for (i = 0; i < *%s; i++)" % pcount)
             setup.append("    %s(%s[i], disp);" % (method, psets))
+        elif proto.name == "GetPhysicalDeviceInfo":
+            ptype = proto.params[-3].name
+            psize = proto.params[-2].name
+            pdata = proto.params[-1].name
+            cond = ("%s == VK_PHYSICAL_DEVICE_INFO_TYPE_DISPLAY_PROPERTIES_WSI && "
+                    "%s && %s" % (ptype, pdata, cond))
+            setup.append("VkDisplayPropertiesWSI *info = %s;" % pdata)
+            setup.append("uint32_t count = *%s / sizeof(*info), i;" % psize)
+            setup.append("for (i = 0; i < count; i++) {")
+            setup.append("    %s(info[i].display, disp);" % method)
+            setup.append("}")
+        elif proto.name == "GetSwapChainInfoWSI":
+            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 && "
+                    "%s && %s" % (ptype, pdata, cond))
+            setup.append("VkSwapChainImageInfoWSI *info = %s;" % pdata)
+            setup.append("uint32_t count = *%s / sizeof(*info), i;" % psize)
+            setup.append("for (i = 0; i < count; i++) {")
+            setup.append("    %s(info[i].image, disp);" % method)
+            setup.append("    %s(info[i].memory, disp);" % method)
+            setup.append("}")
         else:
             obj_params = proto.object_out_params()
             for param in obj_params:
@@ -187,12 +210,8 @@
 
             func.append("}")
 
-            if 'WsiX11AssociateConnection' == proto.name:
-                funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
-
             funcs.append("\n".join(func))
 
-        funcs.append("#endif")
         return "\n\n".join(funcs)
 
     def generate_body(self):
@@ -218,15 +237,12 @@
     def _generate_init(self):
         stmts = []
         for proto in self.protos:
-            if 'WsiX11AssociateConnection' == proto.name:
-                stmts.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
             if self.is_dispatchable_object_first_param(proto) or proto.name == "CreateInstance":
                 stmts.append("table->%s = (PFN_vk%s) gpa(gpu, \"vk%s\");" %
                         (proto.name, proto.name, proto.name))
             else:
                 stmts.append("table->%s = vk%s; /* non-dispatchable */" %
                              (proto.name, proto.name))
-        stmts.append("#endif")
 
         func = []
         func.append("static inline void %s_initialize_dispatch_table(VkLayerDispatchTable *table,"
@@ -244,13 +260,10 @@
     def _generate_lookup(self):
         lookups = []
         for proto in self.protos:
-            if 'WsiX11AssociateConnection' == proto.name:
-                lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
             if self.is_dispatchable_object_first_param(proto):
                 lookups.append("if (!strcmp(name, \"%s\"))" % (proto.name))
                 lookups.append("    return (void *) table->%s;"
                     % (proto.name))
-        lookups.append("#endif")
 
         func = []
         func.append("static inline void *%s_lookup_dispatch_table(const VkLayerDispatchTable *table,"
@@ -321,13 +334,10 @@
 
         lookups = []
         for proto in self.protos:
-            if 'WsiX11AssociateConnection' == proto.name:
-                lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
             lookups.append("if (!strcmp(%s, \"%s\"))" %
                     (gpa_pname, proto.name))
             lookups.append("    return (%s) %s%s;" %
                     (gpa_proto.ret, self.prefix, proto.name))
-        lookups.append("#endif")
 
         body = []
         body.append("%s %s" % (self.qual, gpa_decl))
@@ -366,12 +376,9 @@
                 lookups.append("/* no %s%s */" % (self.prefix, proto.name))
                 continue
 
-            if 'WsiX11AssociateConnection' == proto.name:
-                lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
             lookups.append("if (!strcmp(name, \"%s\"))" % proto.name)
             lookups.append("    return (%s) %s%s;" %
                     (self.gpa.ret, self.prefix, proto.name))
-        lookups.append("#endif")
 
         body = []
         body.append("static inline %s layer_intercept_proc(const char *name)" %
@@ -479,12 +486,9 @@
                 lookups.append("/* no %s%s */" % (self.prefix, proto.name))
                 continue
 
-            if 'WsiX11AssociateConnection' == proto.name:
-                lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
             lookups.append("if (!strcmp(name, \"%s\"))" % proto.name)
             lookups.append("    return (%s) %s%s;" %
                     (self.gpa.ret, self.prefix, proto.name))
-        lookups.append("#endif")
 
         special_lookups = []
         # these functions require special trampoline code beyond just the normal create object trampoline code
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 9fcc68f..8bcc132 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -308,24 +308,16 @@
         prefix="vk"
         lookups = []
         for proto in intercepted:
-            if 'WsiX11' in proto.name:
-                lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
             lookups.append("if (!strcmp(name, \"%s\"))" % proto.name)
             lookups.append("    return (void*) %s%s;" %
                     (prefix, proto.name))
-            if 'WsiX11' in proto.name:
-                lookups.append("#endif")
 
         prefix="vk"
         lookups = []
         for proto in intercepted:
-            if 'WsiX11' in proto.name:
-                lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
             lookups.append("if (!strcmp(name, \"%s\"))" % proto.name)
             lookups.append("    return (void*) %s%s;" %
                     (prefix, proto.name))
-            if 'WsiX11' in proto.name:
-                lookups.append("#endif")
 
         # add customized layer_intercept_proc
         body = []
@@ -485,8 +477,6 @@
         if proto.ret != "void":
             ret_val = "VkResult result = "
             stmt = "    return result;\n"
-        if 'WsiX11AssociateConnection' == proto.name:
-            funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
         if proto.name == "EnumerateLayers":
             funcs.append('%s%s\n'
                      '{\n'
@@ -516,8 +506,6 @@
                      '    %snextTable.%s;\n'
                      '%s'
                      '}' % (qual, decl, ret_val, proto.c_call(), stmt))
-        if 'WsiX11QueuePresent' == proto.name:
-            funcs.append("#endif")
         return "\n\n".join(funcs)
 
     def generate_body(self):
@@ -669,7 +657,7 @@
         funcs = []
         sp_param_dict = {} # Store 'index' for struct param to print, or an name of binding "Count" param for array to print
         create_params = 0 # Num of params at end of function that are created and returned as output values
-        if 'WsiX11CreatePresentableImage' in proto.name or 'AllocDescriptorSets' in proto.name:
+        if 'AllocDescriptorSets' in proto.name:
             create_params = -2
         elif 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name:
             create_params = -1
@@ -701,7 +689,7 @@
                 prev_count_name = ''
             elif 'pDescriptorSets' == p.name and proto.params[-1].name == 'pCount':
                 sp_param_dict[pindex] = '*pCount'
-            elif 'Wsi' not in proto.name and vk_helper.is_type(p.ty.strip('*').replace('const ', ''), 'struct'):
+            elif vk_helper.is_type(p.ty.strip('*').replace('const ', ''), 'struct'):
                 sp_param_dict[pindex] = 'index'
             if p.name.endswith('Count'):
                 if '*' in p.ty:
@@ -753,8 +741,6 @@
                     log_func += '\n        %s' % (cis_print_func)
                     log_func += '\n        (*outputStream) << "   %s[" << i << "] (" << %s%s[i] << ")" << endl << tmp_str << endl;' % (proto.params[sp_index].name, '&', proto.params[sp_index].name)
                     log_func += '\n    }'
-        if 'WsiX11AssociateConnection' == proto.name:
-            funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
         if proto.name == "EnumerateLayers":
             c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalDevice)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
@@ -813,8 +799,6 @@
                      '    %s%s%s\n'
                      '%s'
                      '}' % (qual, decl, ret_val, proto.c_call(), f_open, log_func, f_close, stmt))
-        if 'WsiX11QueuePresent' == proto.name:
-            funcs.append("#endif")
         return "\n\n".join(funcs)
 
     def generate_body(self):
@@ -1121,7 +1105,8 @@
         header_txt.append('        }')
         header_txt.append('        pTrav = pTrav->pNextObj;')
         header_txt.append('    }')
-        header_txt.append('    if (objType != VkObjectTypePresentableImageMemory) {')
+        header_txt.append('    if (objType != VkObjectTypeSwapChainImageWSI &&')
+        header_txt.append('        objType != VkObjectTypeSwapChainMemoryWSI) {')
         header_txt.append('        // If we do not find it print an error')
         header_txt.append('        char str[1024];')
         header_txt.append('        sprintf(str, "Unable to obtain status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));')
@@ -1158,7 +1143,7 @@
         destroy_line = ''
         funcs = []
         # Special cases for API funcs that don't use an object as first arg
-        if True in [no_use_proto in proto.name for no_use_proto in ['GlobalOption', 'CreateInstance', 'QueueSubmit', 'QueueAddMemReferences', 'QueueRemoveMemReferences', 'QueueWaitIdle', 'GetGlobalExtensionInfo', 'CreateDevice', 'GetGpuInfo', 'QueueSignalSemaphore', 'QueueWaitSemaphore', 'WsiX11QueuePresent']]:
+        if True in [no_use_proto in proto.name for no_use_proto in ['GlobalOption', 'CreateInstance', 'QueueSubmit', 'QueueAddMemReferences', 'QueueRemoveMemReferences', 'QueueWaitIdle', 'GetGlobalExtensionInfo', 'CreateDevice', 'GetGpuInfo', 'QueueSignalSemaphore', 'QueueWaitSemaphore']]:
             using_line = ''
         else:
             using_line = '    loader_platform_thread_lock_mutex(&objLock);\n'
@@ -1191,12 +1176,6 @@
             create_line += '        ll_insert_obj((void*)pDescriptorSets[i], VkObjectTypeDescriptorSet);\n'
             create_line += '        loader_platform_thread_unlock_mutex(&objLock);\n'
             create_line += '    }\n'
-        elif 'CreatePresentableImage' in proto.name:
-            create_line = '    loader_platform_thread_lock_mutex(&objLock);\n'
-            create_line += '    ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-2].name, obj_type_mapping[proto.params[-2].ty.strip('*').replace('const ', '')])
-            create_line += '    ll_insert_obj((void*)*pMem, VkObjectTypePresentableImageMemory);\n'
-
-            create_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
         elif 'Create' in proto.name or 'Alloc' in proto.name:
             create_line = '    loader_platform_thread_lock_mutex(&objLock);\n'
             create_line += '    ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-1].name, obj_type_mapping[proto.params[-1].ty.strip('*').replace('const ', '')])
@@ -1214,7 +1193,8 @@
                 using_line = ''
             if 'DestroyDevice' in proto.name:
                 destroy_line += '    // Report any remaining objects in LL\n    objNode *pTrav = pGlobalHead;\n    while (pTrav) {\n'
-                destroy_line += '        if (pTrav->obj.objType == VkObjectTypePresentableImageMemory) {\n'
+                destroy_line += '        if (pTrav->obj.objType == VkObjectTypeSwapChainImageWSI ||\n'
+                destroy_line += '            pTrav->obj.objType == VkObjectTypeSwapChainMemoryWSI) {\n'
                 destroy_line += '            objNode *pDel = pTrav;\n'
                 destroy_line += '            pTrav = pTrav->pNextGlobal;\n'
                 destroy_line += '            ll_destroy_obj((void*)(pDel->obj.pObj));\n'
@@ -1237,8 +1217,6 @@
         if proto.ret != "void":
             ret_val = "VkResult result = "
             stmt = "    return result;\n"
-        if 'WsiX11AssociateConnection' == proto.name:
-            funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
         if proto.name == "EnumerateLayers":
             funcs.append('%s%s\n'
                      '{\n'
@@ -1302,8 +1280,6 @@
                      '%s%s'
                      '%s'
                      '}' % (qual, decl, using_line, ret_val, proto.c_call(), create_line, destroy_line, stmt))
-        if 'WsiX11QueuePresent' == proto.name:
-            funcs.append("#endif")
         return "\n\n".join(funcs)
 
     def generate_body(self):
diff --git a/vulkan.py b/vulkan.py
index 72cb9cd..044a98c 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -923,40 +923,48 @@
     ],
 )
 
-wsi_x11 = Extension(
-    name="VK_WSI_X11",
-    headers=["vkWsiX11Ext.h"],
-    objects=[],
+wsi_lunarg = Extension(
+    name="VK_WSI_LunarG",
+    headers=["vk_wsi_lunarg.h"],
+    objects=[
+        "VkDisplayWSI",
+        "VkSwapChainWSI",
+    ],
     protos=[
-        Proto("VkResult", "WsiX11AssociateConnection",
-            [Param("VkPhysicalDevice", "gpu"),
-             Param("const VK_WSI_X11_CONNECTION_INFO*", "pConnectionInfo")]),
+        Proto("VkResult", "GetDisplayInfoWSI",
+            [Param("VkDisplayWSI", "display"),
+             Param("VkDisplayInfoTypeWSI", "infoType"),
+             Param("size_t*", "pDataSize"),
+             Param("void*", "pData")]),
 
-        Proto("VkResult", "WsiX11GetMSC",
+        Proto("VkResult", "CreateSwapChainWSI",
             [Param("VkDevice", "device"),
-             Param("xcb_window_t", "window"),
-             Param("xcb_randr_crtc_t", "crtc"),
-             Param("uint64_t*", "pMsc")]),
+             Param("const VkSwapChainCreateInfoWSI*", "pCreateInfo"),
+             Param("VkSwapChainWSI*", "pSwapChain")]),
 
-        Proto("VkResult", "WsiX11CreatePresentableImage",
-            [Param("VkDevice", "device"),
-             Param("const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO*", "pCreateInfo"),
-             Param("VkImage*", "pImage"),
-             Param("VkDeviceMemory*", "pMem")]),
+        Proto("VkResult", "DestroySwapChainWSI",
+            [Param("VkSwapChainWSI", "swapChain")]),
 
-        Proto("VkResult", "WsiX11QueuePresent",
+        Proto("VkResult", "GetSwapChainInfoWSI",
+            [Param("VkSwapChainWSI", "swapChain"),
+             Param("VkSwapChainInfoTypeWSI", "infoType"),
+             Param("size_t*", "pDataSize"),
+             Param("void*", "pData")]),
+
+        Proto("VkResult", "QueuePresentWSI",
             [Param("VkQueue", "queue"),
-             Param("const VK_WSI_X11_PRESENT_INFO*", "pPresentInfo"),
-             Param("VkFence", "fence")]),
+             Param("const VkPresentInfoWSI*", "pPresentInfo")]),
     ],
 )
 
-extensions = [core, wsi_x11]
+extensions = [core, wsi_lunarg]
 
 object_root_list = [
     "VkInstance",
     "VkPhysicalDevice",
-    "VkBaseObject"
+    "VkBaseObject",
+    "VkDisplayWSI",
+    "VkSwapChainWSI",
 ]
 
 object_base_list = [