diff --git a/include/vulkan.h b/include/vulkan.h
index b3527c0..ef5ce64 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -1396,25 +1396,25 @@
     VK_FREE_FUNCTION                            pfnFree;
 } VK_ALLOC_CALLBACKS;
 
-typedef struct _VK_DEVICE_QUEUE_CREATE_INFO
+typedef struct _VkDeviceQueueCreateInfo
 {
     uint32_t                                    queueNodeIndex;
     uint32_t                                    queueCount;
-} VK_DEVICE_QUEUE_CREATE_INFO;
+} VkDeviceQueueCreateInfo;
 
-typedef struct _VK_DEVICE_CREATE_INFO
+typedef struct _VkDeviceCreateInfo
 {
     VK_STRUCTURE_TYPE                           sType;                      // Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
     const void*                                 pNext;                      // Pointer to next structure
     uint32_t                                    queueRecordCount;
-    const VK_DEVICE_QUEUE_CREATE_INFO*          pRequestedQueues;
+    const VkDeviceQueueCreateInfo*              pRequestedQueues;
     uint32_t                                    extensionCount;
     const char*const*                           ppEnabledExtensionNames;
     VK_VALIDATION_LEVEL                         maxValidationLevel;
     VK_FLAGS                                    flags;                      // VK_DEVICE_CREATE_FLAGS
-} VK_DEVICE_CREATE_INFO;
+} VkDeviceCreateInfo;
 
-typedef struct _VK_INSTANCE_CREATE_INFO
+typedef struct _VkInstanceCreateInfo
 {
     VK_STRUCTURE_TYPE                           sType;                      // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
     const void*                                 pNext;                      // Pointer to next structure
@@ -1422,16 +1422,16 @@
     const VK_ALLOC_CALLBACKS*                   pAllocCb;
     uint32_t                                    extensionCount;
     const char*const*                           ppEnabledExtensionNames;    // layer or extension name to be enabled
-} VK_INSTANCE_CREATE_INFO;
+} VkInstanceCreateInfo;
 
-// can be added to VK_DEVICE_CREATE_INFO or VK_INSTANCE_CREATE_INFO via pNext
-typedef struct _VK_LAYER_CREATE_INFO
+// can be added to VkDeviceCreateInfo or VkInstanceCreateInfo via pNext
+typedef struct _VkLayerCreateInfo
 {
     VK_STRUCTURE_TYPE                           sType;                      // Should be VK_STRUCTURE_TYPE_LAYER_CREATE_INFO
     const void*                                 pNext;                      // Pointer to next structure
     uint32_t                                    layerCount;
     const char *const*                          ppActiveLayerNames;         // layer name from the layer's vkEnumerateLayers())
-} VK_LAYER_CREATE_INFO;
+} VkLayerCreateInfo;
 
 typedef struct _VK_PHYSICAL_GPU_QUEUE_PROPERTIES
 {
@@ -1448,7 +1448,7 @@
     bool32_t                                    supportsPinning;
 } VK_PHYSICAL_GPU_MEMORY_PROPERTIES;
 
-typedef struct _VK_MEMORY_ALLOC_INFO
+typedef struct _VkMemoryAllocInfo
 {
     VK_STRUCTURE_TYPE                           sType;                      // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
     const void*                                 pNext;                      // Pointer to next structure
@@ -1456,27 +1456,27 @@
     VK_FLAGS                                    memProps;                   // VK_MEMORY_PROPERTY_FLAGS
     VK_MEMORY_TYPE                              memType;
     VK_MEMORY_PRIORITY                          memPriority;
-} VK_MEMORY_ALLOC_INFO;
+} VkMemoryAllocInfo;
 
-// This structure is included in the VK_MEMORY_ALLOC_INFO chain
+// This structure is included in the VkMemoryAllocInfo chain
 // for memory regions allocated for buffer usage.
-typedef struct _VK_MEMORY_ALLOC_BUFFER_INFO
+typedef struct _VkMemoryAllocBufferInfo
 {
     VK_STRUCTURE_TYPE                           sType;                      // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO
     const void*                                 pNext;                      // Pointer to next structure
     VK_FLAGS                                    usage;                      // VK_BUFFER_USAGE_FLAGS
-} VK_MEMORY_ALLOC_BUFFER_INFO;
+} VkMemoryAllocBufferInfo;
 
-// This structure is included in the VK_MEMORY_ALLOC_INFO chain
+// This structure is included in the VkMemoryAllocInfo chain
 // for memory regions allocated for image usage.
-typedef struct _VK_MEMORY_ALLOC_IMAGE_INFO
+typedef struct _VkMemoryAllocImageInfo
 {
     VK_STRUCTURE_TYPE                           sType;                      // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO
     const void*                                 pNext;                      // Pointer to next structure
     VK_FLAGS                                    usage;                      // VK_IMAGE_USAGE_FLAGS
     VK_IMAGE_FORMAT_CLASS                       formatClass;
     uint32_t                                    samples;
-} VK_MEMORY_ALLOC_IMAGE_INFO;
+} VkMemoryAllocImageInfo;
 
 typedef struct _VK_MEMORY_OPEN_INFO
 {
@@ -1593,16 +1593,16 @@
     uint32_t                                    count;
 } VK_UPDATE_AS_COPY;
 
-typedef struct _VK_BUFFER_CREATE_INFO
+typedef struct _VkBufferCreateInfo
 {
     VK_STRUCTURE_TYPE                           sType;                      // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
     const void*                                 pNext;                      // Pointer to next structure.
     VK_GPU_SIZE                                 size;                       // Specified in bytes
     VK_FLAGS                                    usage;                      // VK_BUFFER_USAGE_FLAGS
     VK_FLAGS                                    flags;                      // VK_BUFFER_CREATE_FLAGS
-} VK_BUFFER_CREATE_INFO;
+} VkBufferCreateInfo;
 
-typedef struct _VK_BUFFER_VIEW_CREATE_INFO
+typedef struct _VkBufferViewCreateInfo
 {
     VK_STRUCTURE_TYPE                           sType;                      // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
     const void*                                 pNext;                      // Pointer to next structure.
@@ -1611,7 +1611,7 @@
     VK_FORMAT                                   format;                     // Optionally specifies format of elements
     VK_GPU_SIZE                                 offset;                     // Specified in bytes
     VK_GPU_SIZE                                 range;                      // View size specified in bytes
-} VK_BUFFER_VIEW_CREATE_INFO;
+} VkBufferViewCreateInfo;
 
 typedef struct _VK_IMAGE_SUBRESOURCE
 {
@@ -2266,12 +2266,12 @@
 
 // ------------------------------------------------------------------------------------------------
 // API functions
-typedef VK_RESULT (VKAPI *vkCreateInstanceType)(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance);
+typedef VK_RESULT (VKAPI *vkCreateInstanceType)(const VkInstanceCreateInfo* pCreateInfo, VK_INSTANCE* pInstance);
 typedef VK_RESULT (VKAPI *vkDestroyInstanceType)(VK_INSTANCE instance);
 typedef VK_RESULT (VKAPI *vkEnumerateGpusType)(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus);
 typedef VK_RESULT (VKAPI *vkGetGpuInfoType)(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData);
 typedef void *    (VKAPI *vkGetProcAddrType)(VK_PHYSICAL_GPU gpu, const char * pName);
-typedef VK_RESULT (VKAPI *vkCreateDeviceType)(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice);
+typedef VK_RESULT (VKAPI *vkCreateDeviceType)(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice);
 typedef VK_RESULT (VKAPI *vkDestroyDeviceType)(VK_DEVICE device);
 typedef VK_RESULT (VKAPI *vkGetExtensionSupportType)(VK_PHYSICAL_GPU gpu, const char* pExtName);
 typedef VK_RESULT (VKAPI *vkEnumerateLayersType)(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved);
@@ -2281,7 +2281,7 @@
 typedef VK_RESULT (VKAPI *vkQueueRemoveMemReferenceType)(VK_QUEUE queue, VK_GPU_MEMORY mem);
 typedef VK_RESULT (VKAPI *vkQueueWaitIdleType)(VK_QUEUE queue);
 typedef VK_RESULT (VKAPI *vkDeviceWaitIdleType)(VK_DEVICE device);
-typedef VK_RESULT (VKAPI *vkAllocMemoryType)(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem);
+typedef VK_RESULT (VKAPI *vkAllocMemoryType)(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem);
 typedef VK_RESULT (VKAPI *vkFreeMemoryType)(VK_GPU_MEMORY mem);
 typedef VK_RESULT (VKAPI *vkSetMemoryPriorityType)(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority);
 typedef VK_RESULT (VKAPI *vkMapMemoryType)(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData);
@@ -2311,8 +2311,8 @@
 typedef VK_RESULT (VKAPI *vkCreateQueryPoolType)(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool);
 typedef VK_RESULT (VKAPI *vkGetQueryPoolResultsType)(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData);
 typedef VK_RESULT (VKAPI *vkGetFormatInfoType)(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData);
-typedef VK_RESULT (VKAPI *vkCreateBufferType)(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer);
-typedef VK_RESULT (VKAPI *vkCreateBufferViewType)(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView);
+typedef VK_RESULT (VKAPI *vkCreateBufferType)(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer);
+typedef VK_RESULT (VKAPI *vkCreateBufferViewType)(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView);
 typedef VK_RESULT (VKAPI *vkCreateImageType)(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage);
 typedef VK_RESULT (VKAPI *vkGetImageSubresourceInfoType)(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData);
 typedef VK_RESULT (VKAPI *vkCreateImageViewType)(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView);
@@ -2386,7 +2386,7 @@
 // GPU initialization
 
 VK_RESULT VKAPI vkCreateInstance(
-    const VK_INSTANCE_CREATE_INFO*             pCreateInfo,
+    const VkInstanceCreateInfo*             pCreateInfo,
     VK_INSTANCE*                               pInstance);
 
 VK_RESULT VKAPI vkDestroyInstance(
@@ -2412,7 +2412,7 @@
 
 VK_RESULT VKAPI vkCreateDevice(
     VK_PHYSICAL_GPU                             gpu,
-    const VK_DEVICE_CREATE_INFO*                pCreateInfo,
+    const VkDeviceCreateInfo*                pCreateInfo,
     VK_DEVICE*                                  pDevice);
 
 VK_RESULT VKAPI vkDestroyDevice(
@@ -2466,7 +2466,7 @@
 
 VK_RESULT VKAPI vkAllocMemory(
     VK_DEVICE                                   device,
-    const VK_MEMORY_ALLOC_INFO*                 pAllocInfo,
+    const VkMemoryAllocInfo*                 pAllocInfo,
     VK_GPU_MEMORY*                              pMem);
 
 VK_RESULT VKAPI vkFreeMemory(
@@ -2630,14 +2630,14 @@
 
 VK_RESULT VKAPI vkCreateBuffer(
     VK_DEVICE                                   device,
-    const VK_BUFFER_CREATE_INFO*                pCreateInfo,
+    const VkBufferCreateInfo*                pCreateInfo,
     VK_BUFFER*                                  pBuffer);
 
 // Buffer view functions
 
 VK_RESULT VKAPI vkCreateBufferView(
     VK_DEVICE                                   device,
-    const VK_BUFFER_VIEW_CREATE_INFO*           pCreateInfo,
+    const VkBufferViewCreateInfo*           pCreateInfo,
     VK_BUFFER_VIEW*                             pView);
 
 // Image functions
diff --git a/layers/basic.cpp b/layers/basic.cpp
index dbbb491..402adb6 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -86,7 +86,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
 {
     VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     VK_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw];
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 6806882..5e4a95f 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -262,7 +262,7 @@
         delete (*ii).second;
     }
 }
-static VK_BUFFER_VIEW_CREATE_INFO* getBufferViewCreateInfo(VK_BUFFER_VIEW view)
+static VkBufferViewCreateInfo* getBufferViewCreateInfo(VK_BUFFER_VIEW view)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     if (bufferMap.find(view) == bufferMap.end()) {
@@ -1111,7 +1111,7 @@
             VK_UPDATE_AS_COPY* pUAC = NULL;
             VK_SAMPLER_CREATE_INFO* pSCI = NULL;
             VK_IMAGE_VIEW_CREATE_INFO* pIVCI = NULL;
-            VK_BUFFER_VIEW_CREATE_INFO* pBVCI = NULL;
+            VkBufferViewCreateInfo* pBVCI = NULL;
             void** ppNextPtr = NULL;
             void* pSaveNext = NULL;
             for (i=0; i < pSet->descriptorCount; i++) {
@@ -1156,7 +1156,7 @@
                             pBVCI = getBufferViewCreateInfo(pUB->pBufferViews[i-pUB->arrayIndex].view);
                             if (pBVCI) {
                                 sprintf(tmp_str, "BUFFER_VIEW%u", i);
-                                fprintf(pOutFile, "%s", vk_gv_print_vk_buffer_view_create_info(pBVCI, tmp_str));
+                                fprintf(pOutFile, "%s", vk_gv_print_vkbufferviewcreateinfo(pBVCI, tmp_str));
                                 fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
                             }
                             break;
@@ -1441,7 +1441,7 @@
     }
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
 {
     VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     pCurObj = gpuw;
@@ -1522,7 +1522,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView)
 {
     VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
     if (VK_SUCCESS == result) {
diff --git a/layers/draw_state.h b/layers/draw_state.h
index 0bf33c4..426bf38 100644
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -116,7 +116,7 @@
 
 typedef struct _BUFFER_NODE {
     VK_BUFFER_VIEW             buffer;
-    VK_BUFFER_VIEW_CREATE_INFO createInfo;
+    VkBufferViewCreateInfo createInfo;
     VK_BUFFER_VIEW_ATTACH_INFO attachInfo;
 } BUFFER_NODE;
 
diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c
index 12caf3c..7b1c4ad 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -62,15 +62,15 @@
     memcpy(*ppDest, pSrc, size);
 }
 
-VK_DEVICE_CREATE_INFO* glv_deepcopy_VK_DEVICE_CREATE_INFO(const VK_DEVICE_CREATE_INFO* pSrcCreateInfo)
+VkDeviceCreateInfo* glv_deepcopy_VkDeviceCreateInfo(const VkDeviceCreateInfo* pSrcCreateInfo)
 {
-    VK_DEVICE_CREATE_INFO* pDestCreateInfo;
+    VkDeviceCreateInfo* pDestCreateInfo;
 
-    // NOTE: partially duplicated code from add_VK_DEVICE_CREATE_INFO_to_packet(...)
+    // NOTE: partially duplicated code from add_VkDeviceCreateInfo_to_packet(...)
     {
         uint32_t i;
-        glv_vk_malloc_and_copy((void**)&pDestCreateInfo, sizeof(VK_DEVICE_CREATE_INFO), pSrcCreateInfo);
-        glv_vk_malloc_and_copy((void**)&pDestCreateInfo->pRequestedQueues, pSrcCreateInfo->queueRecordCount*sizeof(VK_DEVICE_QUEUE_CREATE_INFO), pSrcCreateInfo->pRequestedQueues);
+        glv_vk_malloc_and_copy((void**)&pDestCreateInfo, sizeof(VkDeviceCreateInfo), pSrcCreateInfo);
+        glv_vk_malloc_and_copy((void**)&pDestCreateInfo->pRequestedQueues, pSrcCreateInfo->queueRecordCount*sizeof(VkDeviceQueueCreateInfo), pSrcCreateInfo->pRequestedQueues);
 
         if (pSrcCreateInfo->extensionCount > 0)
         {
@@ -80,29 +80,29 @@
                 glv_vk_malloc_and_copy((void**)&pDestCreateInfo->ppEnabledExtensionNames[i], strlen(pSrcCreateInfo->ppEnabledExtensionNames[i]) + 1, pSrcCreateInfo->ppEnabledExtensionNames[i]);
             }
         }
-        VK_LAYER_CREATE_INFO *pSrcNext = ( VK_LAYER_CREATE_INFO *) pSrcCreateInfo->pNext;
-        VK_LAYER_CREATE_INFO **ppDstNext = ( VK_LAYER_CREATE_INFO **) &pDestCreateInfo->pNext;
+        VkLayerCreateInfo *pSrcNext = ( VkLayerCreateInfo *) pSrcCreateInfo->pNext;
+        VkLayerCreateInfo **ppDstNext = ( VkLayerCreateInfo **) &pDestCreateInfo->pNext;
         while (pSrcNext != NULL)
         {
             if ((pSrcNext->sType == VK_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
             {
-                glv_vk_malloc_and_copy((void**)ppDstNext, sizeof(VK_LAYER_CREATE_INFO), pSrcNext);
+                glv_vk_malloc_and_copy((void**)ppDstNext, sizeof(VkLayerCreateInfo), pSrcNext);
                 glv_vk_malloc_and_copy((void**)&(*ppDstNext)->ppActiveLayerNames, pSrcNext->layerCount * sizeof(char*), pSrcNext->ppActiveLayerNames);
                 for (i = 0; i < pSrcNext->layerCount; i++)
                 {
                     glv_vk_malloc_and_copy((void**)&(*ppDstNext)->ppActiveLayerNames[i], strlen(pSrcNext->ppActiveLayerNames[i]) + 1, pSrcNext->ppActiveLayerNames[i]);
                 }
 
-                ppDstNext = (VK_LAYER_CREATE_INFO**) &(*ppDstNext)->pNext;
+                ppDstNext = (VkLayerCreateInfo**) &(*ppDstNext)->pNext;
             }
-            pSrcNext = (VK_LAYER_CREATE_INFO*) pSrcNext->pNext;
+            pSrcNext = (VkLayerCreateInfo*) pSrcNext->pNext;
         }
     }
 
     return pDestCreateInfo;
 }
 
-void glv_deepfree_VK_DEVICE_CREATE_INFO(VK_DEVICE_CREATE_INFO* pCreateInfo)
+void glv_deepfree_VkDeviceCreateInfo(VkDeviceCreateInfo* pCreateInfo)
 {
     uint32_t i;
     if (pCreateInfo->pRequestedQueues != NULL)
@@ -119,10 +119,10 @@
         free((void*)pCreateInfo->ppEnabledExtensionNames);
     }
 
-    VK_LAYER_CREATE_INFO *pSrcNext = (VK_LAYER_CREATE_INFO*)pCreateInfo->pNext;
+    VkLayerCreateInfo *pSrcNext = (VkLayerCreateInfo*)pCreateInfo->pNext;
     while (pSrcNext != NULL)
     {
-        VK_LAYER_CREATE_INFO* pTmp = (VK_LAYER_CREATE_INFO*)pSrcNext->pNext;
+        VkLayerCreateInfo* pTmp = (VkLayerCreateInfo*)pSrcNext->pNext;
         if ((pSrcNext->sType == VK_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
         {
             for (i = 0; i < pSrcNext->layerCount; i++)
@@ -139,11 +139,11 @@
     free(pCreateInfo);
 }
 
-void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
 {
     pDest->gpu = gpu;
 
-    pDest->pCreateInfo = glv_deepcopy_VK_DEVICE_CREATE_INFO(pCreateInfo);
+    pDest->pCreateInfo = glv_deepcopy_VkDeviceCreateInfo(pCreateInfo);
 
     pDest->pDevice = (VK_DEVICE*)malloc(sizeof(VK_DEVICE));
     *pDest->pDevice = *pDevice;
@@ -153,7 +153,7 @@
 {
     memset(&pSrc->gpu, 0, sizeof(VK_PHYSICAL_GPU));
 
-    glv_deepfree_VK_DEVICE_CREATE_INFO(pSrc->pCreateInfo);
+    glv_deepfree_VkDeviceCreateInfo(pSrc->pCreateInfo);
     pSrc->pCreateInfo = NULL;
 
     free(pSrc->pDevice);
@@ -267,7 +267,7 @@
 }
 
 // Note: the parameters after pSnapshot match the order of vkCreateDevice(..)
-static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
 {
     GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(pSnapshot, *pDevice, VK_OBJECT_TYPE_DEVICE);
     pNode->obj.pStruct = malloc(sizeof(GLV_VK_SNAPSHOT_DEVICE_NODE));
@@ -463,7 +463,7 @@
 //=============================================================================
 // vulkan entrypoints
 //=============================================================================
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VK_INSTANCE* pInstance)
 {
     VK_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance);
     loader_platform_thread_lock_mutex(&objLock);
@@ -499,7 +499,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
 {
     VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     pCurObj = gpuw;
@@ -605,7 +605,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAllocInfo * pAllocInfo, VK_GPU_MEMORY* pMem)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
@@ -901,7 +901,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
@@ -917,7 +917,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
@@ -1809,7 +1809,7 @@
         while (pDeviceNode != NULL)
         {
             GLV_VK_SNAPSHOT_DEVICE_NODE* pDev = (GLV_VK_SNAPSHOT_DEVICE_NODE*)pDeviceNode->obj.pStruct;
-            char * createInfoStr = vk_print_vk_device_create_info(pDev->params.pCreateInfo, "\t\t");
+            char * createInfoStr = vk_print_vkdevicecreateinfo(pDev->params.pCreateInfo, "\t\t");
             sprintf(str, "\t%s obj %p:\n%s", string_VK_OBJECT_TYPE(VK_OBJECT_TYPE_DEVICE), pDeviceNode->obj.pVkObject, createInfoStr);
             layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDeviceNode->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
             pDeviceNode = pDeviceNode->pNextObj;
diff --git a/layers/glave_snapshot.h b/layers/glave_snapshot.h
index 999736d..f22915c 100644
--- a/layers/glave_snapshot.h
+++ b/layers/glave_snapshot.h
@@ -174,12 +174,12 @@
 typedef struct _GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS
 {
     VK_PHYSICAL_GPU gpu;
-    VK_DEVICE_CREATE_INFO* pCreateInfo;
+    VkDeviceCreateInfo* pCreateInfo;
     VK_DEVICE* pDevice;
 } GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS;
 
-VK_DEVICE_CREATE_INFO* glv_deepcopy_xgl_device_create_info(const VK_DEVICE_CREATE_INFO* pSrcCreateInfo);void glv_deepfree_xgl_device_create_info(VK_DEVICE_CREATE_INFO* pCreateInfo);
-void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice);
+VkDeviceCreateInfo* glv_deepcopy_xgl_device_create_info(const VkDeviceCreateInfo* pSrcCreateInfo);void glv_deepfree_xgl_device_create_info(VkDeviceCreateInfo* pCreateInfo);
+void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice);
 void glv_vk_snapshot_destroy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc);
 
 //=============================================================================
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 71b8a5a..c05e07e 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -345,14 +345,14 @@
     return pMemObjInfo;
 }
 
-static void addMemObjInfo(const VK_GPU_MEMORY mem, const VK_MEMORY_ALLOC_INFO* pAllocInfo)
+static void addMemObjInfo(const VK_GPU_MEMORY mem, const VkMemoryAllocInfo* pAllocInfo)
 {
     MT_MEM_OBJ_INFO* pInfo = new MT_MEM_OBJ_INFO;
     pInfo->refCount           = 0;
-    memset(&pInfo->allocInfo, 0, sizeof(VK_MEMORY_ALLOC_INFO));
+    memset(&pInfo->allocInfo, 0, sizeof(VkMemoryAllocInfo));
 
     if (pAllocInfo) {  // MEM alloc created by vkWsiX11CreatePresentableImage() doesn't have alloc info struct
-        memcpy(&pInfo->allocInfo, pAllocInfo, sizeof(VK_MEMORY_ALLOC_INFO));
+        memcpy(&pInfo->allocInfo, pAllocInfo, sizeof(VkMemoryAllocInfo));
         // TODO:  Update for real hardware, actually process allocation info structures
         pInfo->allocInfo.pNext = NULL;
     }
@@ -734,7 +734,7 @@
         sprintf(str, "    Ref Count: %u", pInfo->refCount);
         layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
         if (0 != pInfo->allocInfo.allocationSize) {
-            string pAllocInfoMsg = vk_print_vk_memory_alloc_info(&pInfo->allocInfo, "{MEM}INFO :       ");
+            string pAllocInfoMsg = vk_print_vkmemoryallocinfo(&pInfo->allocInfo, "{MEM}INFO :       ");
             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 {
@@ -821,7 +821,7 @@
     }
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
 {
     VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     pCurObj = gpuw;
@@ -999,7 +999,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem)
 {
     VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
     // TODO : Track allocations and overall size here
@@ -1262,23 +1262,23 @@
     return result;
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer)
 {
     VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(VK_BUFFER_CREATE_INFO), "buffer");
+        addObjectInfo(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferCreateInfo), "buffer");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView)
 {
     VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_BUFFER_VIEW_CREATE_INFO), "buffer_view");
+        addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferViewCreateInfo), "buffer_view");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h
index bb12132..d3a8608 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -86,7 +86,7 @@
 struct MT_MEM_OBJ_INFO {
     uint32_t                     refCount;           // Count of references (obj bindings or CB use)
     VK_GPU_MEMORY               mem;
-    VK_MEMORY_ALLOC_INFO        allocInfo;
+    VkMemoryAllocInfo        allocInfo;
     list<VK_OBJECT>             pObjBindings;       // list container of objects bound to this memory
     list<VK_CMD_BUFFER>         pCmdBufferBindings; // list container of cmd buffers that reference this mem object
 };
diff --git a/layers/multi.cpp b/layers/multi.cpp
index a4856eb..3f967d6 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -62,7 +62,7 @@
 #endif
 
 
-VK_LAYER_EXPORT VK_RESULT VKAPI multi1CreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo,
+VK_LAYER_EXPORT VK_RESULT VKAPI multi1CreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo,
                                                       VK_DEVICE* pDevice)
 {
     VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
@@ -163,7 +163,7 @@
     }
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI multi2CreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo,
+VK_LAYER_EXPORT VK_RESULT VKAPI multi2CreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo,
                                                       VK_DEVICE* pDevice)
 {
     VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index fb1189e..9be48ad 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -124,7 +124,7 @@
     }
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VK_INSTANCE* pInstance)
 {
     PreCreateInstance(pCreateInfo->pAppInfo, pCreateInfo->pAllocCb);
     VK_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance);
@@ -160,7 +160,7 @@
     return result;
 }
 
-void PreCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo)
+void PreCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo)
 {
     if(gpu == nullptr)
     {
@@ -172,7 +172,7 @@
 
     if(pCreateInfo == nullptr)
     {
-        char const str[] = "vkCreateDevice parameter, VK_DEVICE_CREATE_INFO* pCreateInfo, is "\
+        char const str[] = "vkCreateDevice parameter, VkDeviceCreateInfo* pCreateInfo, is "\
             "nullptr (precondition).";
         layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
@@ -196,7 +196,7 @@
 
     if(pCreateInfo->pRequestedQueues == nullptr)
     {
-        char const str[] = "vkCreateDevice parameter, VK_DEVICE_QUEUE_CREATE_INFO* pCreateInfo->pRequestedQueues, is "\
+        char const str[] = "vkCreateDevice parameter, VkDeviceQueueCreateInfo* pCreateInfo->pRequestedQueues, is "\
             "nullptr (precondition).";
         layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
@@ -204,10 +204,10 @@
 
     for(uint32_t i = 0; i < pCreateInfo->queueRecordCount; ++i)
     {
-        if(!vk_validate_vk_device_queue_create_info(&(pCreateInfo->pRequestedQueues[i])))
+        if(!vk_validate_vkdevicequeuecreateinfo(&(pCreateInfo->pRequestedQueues[i])))
         {
             std::stringstream ss;
-            ss << "vkCreateDevice parameter, VK_DEVICE_QUEUE_CREATE_INFO pCreateInfo->pRequestedQueues[" << i <<
+            ss << "vkCreateDevice parameter, VkDeviceQueueCreateInfo pCreateInfo->pRequestedQueues[" << i <<
                 "], is invalid (precondition).";
             layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
             continue;
@@ -241,7 +241,7 @@
     }
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
 {
     VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     pCurObj = gpuw;
@@ -331,14 +331,13 @@
     return result;
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem)
 {
     char str[1024];
     if (!pAllocInfo) {
         sprintf(str, "Struct ptr parameter pAllocInfo to function AllocMemory is NULL.");
         layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
-    }
-    else if (!vk_validate_vk_memory_alloc_info(pAllocInfo)) {
+    } else if (!vk_validate_vkmemoryallocinfo(pAllocInfo)) {
         sprintf(str, "Parameter pAllocInfo to function AllocMemory contains an invalid value.");
         layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
@@ -640,14 +639,14 @@
     return result;
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateBuffer is NULL.");
         layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!vk_validate_vk_buffer_create_info(pCreateInfo)) {
+    else if (!vk_validate_vkbuffercreateinfo(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateBuffer contains an invalid value.");
         layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
@@ -655,14 +654,14 @@
     return result;
 }
 
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateBufferView is NULL.");
         layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!vk_validate_vk_buffer_view_create_info(pCreateInfo)) {
+    else if (!vk_validate_vkbufferviewcreateinfo(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateBufferView contains an invalid value.");
         layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
diff --git a/loader/loader.c b/loader/loader.c
index 60c5f21..377de81 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -714,7 +714,7 @@
     return count;
 }
 
-static uint32_t loader_get_layer_libs(struct loader_icd *icd, uint32_t gpu_index, const VK_DEVICE_CREATE_INFO* pCreateInfo, struct layer_name_pair **ppLayerNames)
+static uint32_t loader_get_layer_libs(struct loader_icd *icd, uint32_t gpu_index, const VkDeviceCreateInfo* pCreateInfo, struct layer_name_pair **ppLayerNames)
 {
     static struct layer_name_pair layerNames[MAX_LAYER_LIBRARIES];
     const char *lib_name = NULL;
@@ -788,7 +788,7 @@
     }
 }
 
-extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo)
+extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo)
 {
     uint32_t gpu_index;
     uint32_t count;
@@ -858,7 +858,7 @@
 }
 
 LOADER_EXPORT VK_RESULT VKAPI vkCreateInstance(
-        const VK_INSTANCE_CREATE_INFO*         pCreateInfo,
+        const VkInstanceCreateInfo*         pCreateInfo,
         VK_INSTANCE*                           pInstance)
 {
     static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_icd);
diff --git a/loader/loader.h b/loader/loader.h
index 1817386..f40a36a 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -74,7 +74,7 @@
     return loader_get_data(wrap->baseObject);
 }
 
-extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo);
+extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo);
 #define MAX_LAYER_LIBRARIES 64
 
 #endif /* LOADER_H */
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index 848fc83..b6dbc6d 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -778,9 +778,9 @@
 
     //        VK_RESULT VKAPI vkAllocMemory(
     //            VK_DEVICE                                  device,
-    //            const VK_MEMORY_ALLOC_INFO*                pAllocInfo,
+    //            const VkMemoryAllocInfo*                pAllocInfo,
     //            VK_GPU_MEMORY*                             pMem);
-    VK_MEMORY_ALLOC_INFO mem_info;
+    VkMemoryAllocInfo mem_info;
     VK_GPU_MEMORY event_mem;
 
     ASSERT_NE(0, mem_req.size) << "vkGetObjectInfo (Event): Failed - expect events to require memory";
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index 8898ae7..cf81836 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -93,7 +93,7 @@
         this->app_info.pEngineName = "unittest";
         this->app_info.engineVersion = 1;
         this->app_info.apiVersion = VK_API_VERSION;
-        VK_INSTANCE_CREATE_INFO inst_info = {};
+        VkInstanceCreateInfo inst_info = {};
         inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
         inst_info.pNext = NULL;
         inst_info.pAppInfo = &app_info;
@@ -211,11 +211,11 @@
     size_t img_reqs_size = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS);
     uint32_t num_allocations = 0;
     size_t num_alloc_size = sizeof(num_allocations);
-    VK_MEMORY_ALLOC_IMAGE_INFO img_alloc = {};
+    VkMemoryAllocImageInfo img_alloc = {};
     img_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO;
     img_alloc.pNext = NULL;
 
-    VK_MEMORY_ALLOC_INFO mem_info = {};
+    VkMemoryAllocInfo mem_info = {};
     mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
     mem_info.pNext = &img_alloc;
 
diff --git a/tests/init.cpp b/tests/init.cpp
index 9de9dfc..f40f435 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -98,7 +98,7 @@
         this->app_info.pEngineName = "unittest";
         this->app_info.engineVersion = 1;
         this->app_info.apiVersion = VK_API_VERSION;
-        VK_INSTANCE_CREATE_INFO inst_info = {};
+        VkInstanceCreateInfo inst_info = {};
         inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
         inst_info.pNext = NULL;
         inst_info.pAppInfo = &app_info;
@@ -143,7 +143,7 @@
     char *layers[16];
     size_t layer_count;
     char layer_buf[16][256];
-    VK_INSTANCE_CREATE_INFO inst_info = {};
+    VkInstanceCreateInfo inst_info = {};
     inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     inst_info.pNext = NULL;
     inst_info.pAppInfo = &app_info;
@@ -184,7 +184,7 @@
 
 TEST_F(XglTest, AllocMemory) {
     VK_RESULT err;
-    VK_MEMORY_ALLOC_INFO alloc_info = {};
+    VkMemoryAllocInfo alloc_info = {};
     VK_GPU_MEMORY gpu_mem;
     uint8_t *pData;
 
@@ -239,9 +239,9 @@
 
     //        VK_RESULT VKAPI vkAllocMemory(
     //            VK_DEVICE                                  device,
-    //            const VK_MEMORY_ALLOC_INFO*                pAllocInfo,
+    //            const VkMemoryAllocInfo*                pAllocInfo,
     //            VK_GPU_MEMORY*                             pMem);
-    VK_MEMORY_ALLOC_INFO mem_info;
+    VkMemoryAllocInfo mem_info;
     VK_GPU_MEMORY event_mem;
 
     ASSERT_NE(0, mem_req.size) << "vkGetObjectInfo (Event): Failed - expect events to require memory";
@@ -371,9 +371,9 @@
 
     //        VK_RESULT VKAPI vkAllocMemory(
     //            VK_DEVICE                                  device,
-    //            const VK_MEMORY_ALLOC_INFO*                pAllocInfo,
+    //            const VkMemoryAllocInfo*                pAllocInfo,
     //            VK_GPU_MEMORY*                             pMem);
-    VK_MEMORY_ALLOC_INFO mem_info;
+    VkMemoryAllocInfo mem_info;
     VK_GPU_MEMORY query_mem;
 
     memset(&mem_info, 0, sizeof(mem_info));
@@ -638,7 +638,7 @@
         subresource.mipLevel++;
     }
 
-    VK_MEMORY_ALLOC_IMAGE_INFO img_alloc = {
+    VkMemoryAllocImageInfo img_alloc = {
         .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO,
         .pNext = NULL,
 
@@ -661,9 +661,9 @@
     img_alloc.samples = img_reqs.samples;
     //        VK_RESULT VKAPI vkAllocMemory(
     //            VK_DEVICE                                  device,
-    //            const VK_MEMORY_ALLOC_INFO*                pAllocInfo,
+    //            const VkMemoryAllocInfo*                pAllocInfo,
     //            VK_GPU_MEMORY*                             pMem);
-    VK_MEMORY_ALLOC_INFO mem_info = {};
+    VkMemoryAllocInfo mem_info = {};
     VK_GPU_MEMORY image_mem;
 
     mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
diff --git a/tests/test_environment.cpp b/tests/test_environment.cpp
index 5d3a580..d2a22ef 100644
--- a/tests/test_environment.cpp
+++ b/tests/test_environment.cpp
@@ -51,7 +51,7 @@
 
     uint32_t count;
     VK_RESULT err;
-    VK_INSTANCE_CREATE_INFO inst_info = {};
+    VkInstanceCreateInfo inst_info = {};
     inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     inst_info.pNext = NULL;
     inst_info.pAppInfo = &app_;
@@ -82,7 +82,7 @@
     const xcb_setup_t *setup;
     xcb_screen_iterator_t iter;
     int scr;
-    VK_INSTANCE_CREATE_INFO instInfo = {};
+    VkInstanceCreateInfo instInfo = {};
     instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     instInfo.pNext = NULL;
     instInfo.pAppInfo = &app_;
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index 9d38aa2..a130f13 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -59,7 +59,7 @@
 void VkRenderFramework::InitFramework()
 {
     VK_RESULT err;
-    VK_INSTANCE_CREATE_INFO instInfo = {};
+    VkInstanceCreateInfo instInfo = {};
     instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     instInfo.pNext = NULL;
     instInfo.pAppInfo = &app_info;
@@ -765,7 +765,7 @@
     unmap();
 
     // set up the buffer view for the constant buffer
-    VK_BUFFER_VIEW_CREATE_INFO view_info = {};
+    VkBufferViewCreateInfo view_info = {};
     view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
     view_info.buffer = obj();
     view_info.viewType = VK_BUFFER_VIEW_RAW;
@@ -896,7 +896,7 @@
     unmap();
 
     // set up the buffer view for the constant buffer
-    VK_BUFFER_VIEW_CREATE_INFO view_info = {};
+    VkBufferViewCreateInfo view_info = {};
     view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
     view_info.buffer = obj();
     view_info.viewType = VK_BUFFER_VIEW_TYPED;
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index fcadfd9..2f525dc 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -267,15 +267,15 @@
     const std::vector<VK_MEMORY_REQUIREMENTS> mem_reqs = memory_requirements();
     std::vector<VK_IMAGE_MEMORY_REQUIREMENTS> img_reqs;
     std::vector<VK_BUFFER_MEMORY_REQUIREMENTS> buf_reqs;
-    VK_MEMORY_ALLOC_IMAGE_INFO img_info;
-    VK_MEMORY_ALLOC_BUFFER_INFO buf_info;
-    VK_MEMORY_ALLOC_INFO info, *next_info = NULL;
+    VkMemoryAllocImageInfo img_info;
+    VkMemoryAllocBufferInfo buf_info;
+    VkMemoryAllocInfo info, *next_info = NULL;
 
     if (for_img) {
         img_reqs = get_info<VK_IMAGE_MEMORY_REQUIREMENTS>(obj(),
                         VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS, 0);
         EXPECT(img_reqs.size() == 1);
-        next_info = (VK_MEMORY_ALLOC_INFO *) &img_info;
+        next_info = (VkMemoryAllocInfo *) &img_info;
         img_info.pNext = NULL;
         img_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO;
         img_info.usage = img_reqs[0].usage;
@@ -290,7 +290,7 @@
         if (for_img)
             img_info.pNext = &buf_info;
         else
-            next_info = (VK_MEMORY_ALLOC_INFO *) &buf_info;
+            next_info = (VkMemoryAllocInfo *) &buf_info;
         buf_info.pNext = NULL;
         buf_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO;
         buf_info.usage = buf_reqs[0].usage;
@@ -368,10 +368,10 @@
 {
     // request all queues
     const std::vector<VK_PHYSICAL_GPU_QUEUE_PROPERTIES> queue_props = gpu_.queue_properties();
-    std::vector<VK_DEVICE_QUEUE_CREATE_INFO> queue_info;
+    std::vector<VkDeviceQueueCreateInfo> queue_info;
     queue_info.reserve(queue_props.size());
     for (int i = 0; i < queue_props.size(); i++) {
-        VK_DEVICE_QUEUE_CREATE_INFO qi = {};
+        VkDeviceQueueCreateInfo qi = {};
         qi.queueNodeIndex = i;
         qi.queueCount = queue_props[i].queueCount;
         if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
@@ -380,7 +380,7 @@
         queue_info.push_back(qi);
     }
 
-    VK_LAYER_CREATE_INFO layer_info = {};
+    VkLayerCreateInfo layer_info = {};
     layer_info.sType = VK_STRUCTURE_TYPE_LAYER_CREATE_INFO;
 
     std::vector<const char *> layers;
@@ -394,7 +394,7 @@
 
     const std::vector<const char *> exts = gpu_.extensions();
 
-    VK_DEVICE_CREATE_INFO dev_info = {};
+    VkDeviceCreateInfo dev_info = {};
     dev_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
     dev_info.pNext = (enable_layers) ? static_cast<void *>(&layer_info) : NULL;
     dev_info.queueRecordCount = queue_info.size();
@@ -407,7 +407,7 @@
     init(dev_info);
 }
 
-void Device::init(const VK_DEVICE_CREATE_INFO &info)
+void Device::init(const VkDeviceCreateInfo &info)
 {
     DERIVED_OBJECT_INIT(vkCreateDevice, gpu_.obj(), &info);
 
@@ -565,7 +565,7 @@
         EXPECT(vkFreeMemory(obj()) == VK_SUCCESS);
 }
 
-void GpuMemory::init(const Device &dev, const VK_MEMORY_ALLOC_INFO &info)
+void GpuMemory::init(const Device &dev, const VkMemoryAllocInfo &info)
 {
     DERIVED_OBJECT_INIT(vkAllocMemory, dev.obj(), &info);
 }
@@ -666,19 +666,19 @@
     return err;
 }
 
-void Buffer::init(const Device &dev, const VK_BUFFER_CREATE_INFO &info)
+void Buffer::init(const Device &dev, const VkBufferCreateInfo &info)
 {
     init_no_mem(dev, info);
     alloc_memory(dev, true, false);
 }
 
-void Buffer::init_no_mem(const Device &dev, const VK_BUFFER_CREATE_INFO &info)
+void Buffer::init_no_mem(const Device &dev, const VkBufferCreateInfo &info)
 {
     DERIVED_OBJECT_INIT(vkCreateBuffer, dev.obj(), &info);
     create_info_ = info;
 }
 
-void BufferView::init(const Device &dev, const VK_BUFFER_VIEW_CREATE_INFO &info)
+void BufferView::init(const Device &dev, const VkBufferViewCreateInfo &info)
 {
     DERIVED_OBJECT_INIT(vkCreateBufferView, dev.obj(), &info);
     alloc_memory(dev);
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index 4068e75..39159eb 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -200,7 +200,7 @@
     ~Device();
 
     // vkCreateDevice()
-    void init(const VK_DEVICE_CREATE_INFO &info);
+    void init(const VkDeviceCreateInfo &info);
     void init(bool enable_layers); // all queues, all extensions, etc
     void init() { init(false); };
 
@@ -278,7 +278,7 @@
     ~GpuMemory();
 
     // vkAllocMemory()
-    void init(const Device &dev, const VK_MEMORY_ALLOC_INFO &info);
+    void init(const Device &dev, const VkMemoryAllocInfo &info);
     // vkPinSystemMemory()
     void init(const Device &dev, size_t size, const void *data);
     // vkOpenSharedMemory()
@@ -300,8 +300,8 @@
     // vkUnmapMemory()
     void unmap() const;
 
-    static VK_MEMORY_ALLOC_INFO alloc_info(const VK_MEMORY_REQUIREMENTS &reqs,
-                  const VK_MEMORY_ALLOC_INFO *next_info);
+    static VkMemoryAllocInfo alloc_info(const VK_MEMORY_REQUIREMENTS &reqs,
+                  const VkMemoryAllocInfo *next_info);
 };
 
 class Fence : public DerivedObject<VK_FENCE, Object> {
@@ -355,15 +355,15 @@
 class Buffer : public DerivedObject<VK_BUFFER, Object> {
 public:
     explicit Buffer() {}
-    explicit Buffer(const Device &dev, const VK_BUFFER_CREATE_INFO &info) { init(dev, info); }
+    explicit Buffer(const Device &dev, const VkBufferCreateInfo &info) { init(dev, info); }
     explicit Buffer(const Device &dev, VK_GPU_SIZE size) { init(dev, size); }
 
     // vkCreateBuffer()
-    void init(const Device &dev, const VK_BUFFER_CREATE_INFO &info);
+    void init(const Device &dev, const VkBufferCreateInfo &info);
     void init(const Device &dev, VK_GPU_SIZE size) { init(dev, create_info(size, 0)); }
-    void init_no_mem(const Device &dev, const VK_BUFFER_CREATE_INFO &info);
+    void init_no_mem(const Device &dev, const VkBufferCreateInfo &info);
 
-    static VK_BUFFER_CREATE_INFO create_info(VK_GPU_SIZE size, VK_FLAGS usage);
+    static VkBufferCreateInfo create_info(VK_GPU_SIZE size, VK_FLAGS usage);
 
     VK_BUFFER_MEMORY_BARRIER buffer_memory_barrier(VK_FLAGS output_mask, VK_FLAGS input_mask,
                                                  VK_GPU_SIZE offset, VK_GPU_SIZE size) const
@@ -378,13 +378,13 @@
         return barrier;
     }
 private:
-    VK_BUFFER_CREATE_INFO create_info_;
+    VkBufferCreateInfo create_info_;
 };
 
 class BufferView : public DerivedObject<VK_BUFFER_VIEW, Object> {
 public:
     // vkCreateBufferView()
-    void init(const Device &dev, const VK_BUFFER_VIEW_CREATE_INFO &info);
+    void init(const Device &dev, const VkBufferViewCreateInfo &info);
 };
 
 class Image : public DerivedObject<VK_IMAGE, Object> {
@@ -618,10 +618,10 @@
         primary_mem_->unmap();
 }
 
-inline VK_MEMORY_ALLOC_INFO GpuMemory::alloc_info(const VK_MEMORY_REQUIREMENTS &reqs,
-                                const VK_MEMORY_ALLOC_INFO *next_info)
+inline VkMemoryAllocInfo GpuMemory::alloc_info(const VK_MEMORY_REQUIREMENTS &reqs,
+                                const VkMemoryAllocInfo *next_info)
 {
-    VK_MEMORY_ALLOC_INFO info = {};
+    VkMemoryAllocInfo info = {};
     info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
     if (next_info != NULL)
         info.pNext = (void *) next_info;
@@ -633,9 +633,9 @@
     return info;
 }
 
-inline VK_BUFFER_CREATE_INFO Buffer::create_info(VK_GPU_SIZE size, VK_FLAGS usage)
+inline VkBufferCreateInfo Buffer::create_info(VK_GPU_SIZE size, VK_FLAGS usage)
 {
-    VK_BUFFER_CREATE_INFO info = {};
+    VkBufferCreateInfo info = {};
     info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
     info.size = size;
     info.usage = usage;
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 2cfa002..ec8a97c 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -104,7 +104,7 @@
     def _get_printf_params(self, vk_type, name, output_param, cpp=False):
         # TODO : Need ENUM and STRUCT checks here
         if vk_helper.is_type(vk_type, 'enum'):#"_TYPE" in vk_type: # TODO : This should be generic ENUM check
-            return ("%s", "string_%s(%s)" % (vk_type.strip('const ').strip('*'), name))
+            return ("%s", "string_%s(%s)" % (vk_type.replace('const ', '').strip('*'), name))
         if "char*" == vk_type:
             return ("%s", name)
         if "uint64" in vk_type:
@@ -636,11 +636,11 @@
                 log_func_no_addr += '%s = address, ' % (p.name)
             else:
                 log_func_no_addr += '%s = " << %s << ", ' % (p.name, pfi)
-            if prev_count_name != '' and (prev_count_name.strip('Count')[1:] in p.name or 'slotCount' == prev_count_name):
+            if prev_count_name != '' and (prev_count_name.replace('Count', '')[1:] in p.name or 'slotCount' == prev_count_name):
                 sp_param_dict[pindex] = 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('*').strip('const '), 'struct'):
+            elif 'Wsi' not in proto.name and vk_helper.is_type(p.ty.strip('*').replace('const ', ''), 'struct'):
                 sp_param_dict[pindex] = 'index'
             pindex += 1
             if p.name.endswith('Count'):
@@ -666,7 +666,7 @@
             log_func += '\n    string tmp_str;'
             for sp_index in sp_param_dict:
                 if 'index' == sp_param_dict[sp_index]:
-                    cis_print_func = 'vk_print_%s' % (proto.params[sp_index].ty.strip('const ').strip('*').lower())
+                    cis_print_func = 'vk_print_%s' % (proto.params[sp_index].ty.replace('const ', '').strip('*').lower())
                     local_name = proto.params[sp_index].name
                     if '*' not in proto.params[sp_index].ty:
                         local_name = '&%s' % proto.params[sp_index].name
@@ -677,11 +677,9 @@
                 else: # We have a count value stored to iterate over an array
                     print_cast = ''
                     print_func = ''
-                    if vk_helper.is_type(proto.params[sp_index].ty.strip('*').strip('const '), 'struct'):
+                    if vk_helper.is_type(proto.params[sp_index].ty.strip('*').replace('const ', ''), 'struct'):
                         print_cast = '&'
-                        print_func = 'vk_print_%s' % proto.params[sp_index].ty.strip('const ').strip('*').lower()
-                        #cis_print_func = 'tmp_str = vk_print_%s(&%s[i], "    ");' % (proto.params[sp_index].ty.strip('const ').strip('*').lower(), proto.params[sp_index].name)
-# TODO : Need to display this address as a string
+                        print_func = 'vk_print_%s' % proto.params[sp_index].ty.replace('const ', '').strip('*').lower()
                     else:
                         print_cast = ''
                         print_func = 'string_convert_helper'
@@ -1084,7 +1082,7 @@
 
         decl = proto.c_func(prefix="vk", attr="VKAPI")
         param0_name = proto.params[0].name
-        p0_type = proto.params[0].ty.strip('*').strip('const ')
+        p0_type = proto.params[0].ty.strip('*').replace('const ', '')
         create_line = ''
         destroy_line = ''
         funcs = []
@@ -1124,13 +1122,13 @@
             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('*').strip('const ')])
+            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, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n'
-            # create_line += '    ll_insert_obj((void*)*%s, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n' % (obj_type_mapping[proto.params[-1].ty.strip('*').strip('const ')])
+            # create_line += '    ll_insert_obj((void*)*%s, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n' % (obj_type_mapping[proto.params[-1].ty.strip('*').replace('const ', '')])
             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('*').strip('const ')])
+            create_line += '    ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-1].name, obj_type_mapping[proto.params[-1].ty.strip('*').replace('const ', '')])
             create_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
         if 'DestroyObject' in proto.name:
             destroy_line = '    loader_platform_thread_lock_mutex(&objLock);\n'
diff --git a/vk_helper.py b/vk_helper.py
index 74ae5d9..f8cf2a8 100755
--- a/vk_helper.py
+++ b/vk_helper.py
@@ -160,6 +160,7 @@
                         (cur_char, targ_type) = line.strip().split(None, 1)
                         self.typedef_fwd_dict[base_type] = targ_type.strip(';')
                         self.typedef_rev_dict[targ_type.strip(';')] = base_type
+                        #print("fwd_dict: %s = %s" % (base_type, targ_type))
                 elif parse_enum:
                     #if 'VK_MAX_ENUM' not in line and '{' not in line:
                     if True not in [ens in line for ens in ['{', 'VK_MAX_ENUM', '_RANGE']]:
@@ -238,7 +239,7 @@
             self.struct_dict[struct_type][num]['ptr'] = False
         if 'const' in member_type:
             self.struct_dict[struct_type][num]['const'] = True
-            member_type = member_type.strip('const').strip()
+            member_type = member_type.replace('const', '').strip()
         else:
             self.struct_dict[struct_type][num]['const'] = False
         # TODO : There is a bug here where it seems that at the time we do this check,
@@ -296,6 +297,29 @@
         sys.stdout.write(typedef_fwd_dict[struct_name])
         sys.stdout.write(";\n\n")
 
+#
+def get_struct_name_from_struct_type(struct_type):
+    caps_struct_name = struct_type.replace("_STRUCTURE_TYPE", "")
+    # NOTE: These must stay in caps as they are looking at the VK_STRUCTURE_TYPE_*_CREATE_INFO
+    # and that has not changed to camel case
+    exceptions_list = ['VK_DEVICE_CREATE_INFO', 'VK_INSTANCE_CREATE_INFO', 'VK_LAYER_CREATE_INFO',
+                       'VK_MEMORY_ALLOC_INFO', 'VK_MEMORY_ALLOC_BUFFER_INFO', 'VK_MEMORY_ALLOC_IMAGE_INFO',
+                       'VK_BUFFER_CREATE_INFO', 'VK_BUFFER_VIEW_CREATE_INFO']
+    if caps_struct_name in exceptions_list:
+        char_idx = 0
+        struct_name = ''
+        for char in caps_struct_name:
+            if (0 == char_idx) or (caps_struct_name[char_idx-1] == '_'):
+                struct_name += caps_struct_name[char_idx]
+            elif (caps_struct_name[char_idx] == '_'):
+                pass
+            else:
+                struct_name += caps_struct_name[char_idx].lower()
+            char_idx += 1
+    else:
+        struct_name = caps_struct_name
+    return struct_name
+
 # class for writing common file elements
 # Here's how this class lays out a file:
 #  COPYRIGHT
@@ -508,7 +532,7 @@
             class_num = 0
             if "_STRUCTURE_TYPE" in e:
                 for v in sorted(enum_type_dict[e]):
-                    struct_name = v.replace("_STRUCTURE_TYPE", "")
+                    struct_name = get_struct_name_from_struct_type(v)
                     class_name = self.get_class_name(struct_name)
                     instance_name = "swc%i" % class_num
                     dp_funcs.append("        case %s:\n        {" % (v))
@@ -705,7 +729,7 @@
         for e in enum_type_dict:
             if "_STRUCTURE_TYPE" in e:
                 for v in sorted(enum_type_dict[e]):
-                    struct_name = v.replace("_STRUCTURE_TYPE", "")
+                    struct_name = get_struct_name_from_struct_type(v)
                     print_func_name = self._get_sh_func_name(struct_name)
                     sh_funcs.append('        case %s:\n        {' % (v))
                     sh_funcs.append('            return %s((%s*)pStruct, indent);' % (print_func_name, struct_name))
@@ -754,12 +778,16 @@
                     if 1 < stp_list[index]['full_type'].count('*'):
                         addr_char = ''
                     if (stp_list[index]['array']):
+                        sh_funcs.append('/* A */');
                         if stp_list[index]['dyn_array']:
+                            sh_funcs.append('/* AA */');
                             array_count = 'pStruct->%s' % (stp_list[index]['array_size'])
                         else:
+                            sh_funcs.append('/* AB */');
                             array_count = '%s' % (stp_list[index]['array_size'])
                         sh_funcs.append('%sstp_strs[%u] = "";' % (indent, index))
                         if not idx_ss_decl:
+                            sh_funcs.append('/* AC */');
                             sh_funcs.append('%sstringstream index_ss;' % (indent))
                             idx_ss_decl = True
                         sh_funcs.append('%sif (pStruct->%s) {' % (indent, stp_list[index]['name']))
@@ -769,15 +797,19 @@
                         sh_funcs.append('%sindex_ss.str("");' % (indent))
                         sh_funcs.append('%sindex_ss << i;' % (indent))
                         if not is_type(stp_list[index]['type'], 'struct'):
+                            sh_funcs.append('/* AD */');
                             addr_char = ''
                             sh_funcs.append('%sss[%u] << %spStruct->%s[i];' % (indent, index, addr_char, stp_list[index]['name']))
                             sh_funcs.append('%sstp_strs[%u] += " " + prefix + "%s[" + index_ss.str() + "] = " + ss[%u].str() + "\\n";' % (indent, index, stp_list[index]['name'], index))
                         else:
+                            sh_funcs.append('/* AD */');
                             sh_funcs.append('%sss[%u] << %spStruct->%s[i];' % (indent, index, addr_char, stp_list[index]['name']))
                             sh_funcs.append('%stmp_str = %s(%spStruct->%s[i], extra_indent);' % (indent, self._get_sh_func_name(stp_list[index]['type']), addr_char, stp_list[index]['name']))
                             if self.no_addr:
+                                sh_funcs.append('/* ADA */');
                                 sh_funcs.append('%sstp_strs[%u] += " " + prefix + "%s[" + index_ss.str() + "] (addr)\\n" + tmp_str;' % (indent, index, stp_list[index]['name']))
                             else:
+                                sh_funcs.append('/* ADB */');
                                 sh_funcs.append('%sstp_strs[%u] += " " + prefix + "%s[" + index_ss.str() + "] (" + ss[%u].str() + ")\\n" + tmp_str;' % (indent, index, stp_list[index]['name'], index))
                         indent = indent[4:]
                         sh_funcs.append('%s}' % (indent))
@@ -785,6 +817,7 @@
                         indent = indent[4:]
                         sh_funcs.append('%s}' % (indent))
                     elif (stp_list[index]['ptr']):
+                        sh_funcs.append('/* B */');
                         sh_funcs.append('    if (pStruct->%s) {' % stp_list[index]['name'])
                         if 'pNext' == stp_list[index]['name']:
                             sh_funcs.append('        tmp_str = dynamic_display((void*)pStruct->pNext, prefix);')
@@ -804,6 +837,7 @@
                         sh_funcs.append('    else')
                         sh_funcs.append('        stp_strs[%u] = "";' % index)
                     else:
+                        sh_funcs.append('/* C */');
                         sh_funcs.append('    tmp_str = %s(&pStruct->%s, extra_indent);' % (self._get_sh_func_name(stp_list[index]['type']), stp_list[index]['name']))
                         sh_funcs.append('    ss[%u] << %spStruct->%s;' % (index, addr_char, stp_list[index]['name']))
                         if self.no_addr:
@@ -865,7 +899,7 @@
         for e in enum_type_dict:
             if "_STRUCTURE_TYPE" in e:
                 for v in sorted(enum_type_dict[e]):
-                    struct_name = v.replace("_STRUCTURE_TYPE", "")
+                    struct_name = get_struct_name_from_struct_type(v)
                     print_func_name = self._get_sh_func_name(struct_name)
                     sh_funcs.append('        case %s:\n        {' % (v))
                     sh_funcs.append('            return %s((%s*)pStruct, indent);' % (print_func_name, struct_name))
@@ -1131,7 +1165,7 @@
             for e in enum_type_dict:
                 if '_STRUCTURE_TYPE' in e:
                     for v in sorted(enum_type_dict[e]):
-                        struct_name = v.replace("_STRUCTURE_TYPE", "")
+                        struct_name = get_struct_name_from_struct_type(v)
                         sh_funcs.append('%scase %s:' % (indent, v))
                         sh_funcs.append('%s{' % (indent))
                         indent += '    '
@@ -1533,7 +1567,7 @@
         for e in enum_type_dict:
             if "_STRUCTURE_TYPE" in e:
                 for v in sorted(enum_type_dict[e]):
-                    struct_name = v.replace("_STRUCTURE_TYPE", "")
+                    struct_name = get_struct_name_from_struct_type(v)
                     print_func_name = self._get_gv_func_name(struct_name)
                     # TODO : Hand-coded fixes for some exceptions
                     #if 'VK_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
diff --git a/vulkan.py b/vulkan.py
index 6e30e45..28fcd7c 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -218,7 +218,7 @@
     ],
     protos=[
         Proto("VK_RESULT", "CreateInstance",
-            [Param("const VK_INSTANCE_CREATE_INFO*", "pCreateInfo"),
+            [Param("const VkInstanceCreateInfo*", "pCreateInfo"),
              Param("VK_INSTANCE*", "pInstance")]),
 
         Proto("VK_RESULT", "DestroyInstance",
@@ -242,7 +242,7 @@
 
         Proto("VK_RESULT", "CreateDevice",
             [Param("VK_PHYSICAL_GPU", "gpu"),
-             Param("const VK_DEVICE_CREATE_INFO*", "pCreateInfo"),
+             Param("const VkDeviceCreateInfo*", "pCreateInfo"),
              Param("VK_DEVICE*", "pDevice")]),
 
         Proto("VK_RESULT", "DestroyDevice",
@@ -288,7 +288,7 @@
 
         Proto("VK_RESULT", "AllocMemory",
             [Param("VK_DEVICE", "device"),
-             Param("const VK_MEMORY_ALLOC_INFO*", "pAllocInfo"),
+             Param("const VkMemoryAllocInfo*", "pAllocInfo"),
              Param("VK_GPU_MEMORY*", "pMem")]),
 
         Proto("VK_RESULT", "FreeMemory",
@@ -436,12 +436,12 @@
 
         Proto("VK_RESULT", "CreateBuffer",
             [Param("VK_DEVICE", "device"),
-             Param("const VK_BUFFER_CREATE_INFO*", "pCreateInfo"),
+             Param("const VkBufferCreateInfo*", "pCreateInfo"),
              Param("VK_BUFFER*", "pBuffer")]),
 
         Proto("VK_RESULT", "CreateBufferView",
             [Param("VK_DEVICE", "device"),
-             Param("const VK_BUFFER_VIEW_CREATE_INFO*", "pCreateInfo"),
+             Param("const VkBufferViewCreateInfo*", "pCreateInfo"),
              Param("VK_BUFFER_VIEW*", "pView")]),
 
         Proto("VK_RESULT", "CreateImage",