diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
index d2a15b5..bd3049c 100644
--- a/vulkan/api/vulkan.api
+++ b/vulkan/api/vulkan.api
@@ -27,7 +27,7 @@
 
 // API version (major.minor.patch)
 define VERSION_MAJOR 0
-define VERSION_MINOR 192
+define VERSION_MINOR 193
 define VERSION_PATCH 0
 
 // API limits
@@ -726,7 +726,7 @@
     VK_QUEUE_GRAPHICS_BIT                                   = 0x00000001,    /// Queue supports graphics operations
     VK_QUEUE_COMPUTE_BIT                                    = 0x00000002,    /// Queue supports compute operations
     VK_QUEUE_DMA_BIT                                        = 0x00000004,    /// Queue supports DMA operations
-    VK_QUEUE_SPARSE_MEMMGR_BIT                              = 0x00000008,    /// Queue supports sparse resource memory management operations
+    VK_QUEUE_SPARSE_BINDING_BIT                             = 0x00000008,    /// Queue supports sparse resource memory management operations
 }
 
 /// Memory properties passed into vkAllocMemory().
@@ -840,12 +840,10 @@
     VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT                     = 0x00000010,    /// Allows creating image views with cube type from the created image
 }
 
-/// Framebuffer attachment view creation flags
+/// Image view creation flags
 type VkFlags VkImageViewCreateFlags
-bitfield VkImageViewCreateFlagBits {
-    VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT                = 0x00000001,
-    VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT              = 0x00000002,
-}
+//bitfield VkImageViewCreateFlagBits {
+//}
 
 /// Pipeline creation flags
 type VkFlags VkPipelineCreateFlags
@@ -970,9 +968,9 @@
 /// Sparse image memory requirements flags
 type VkFlags VkSparseImageFormatFlags
 bitfield VkSparseImageFormatFlagBits {
-    VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT                  = 0x00000001,  /// Image uses a single miptail region for all array slices
-    VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT                = 0x00000002,  /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels.
-    VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT               = 0x00000004,  /// Image uses a non-standard sparse block size
+    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT                  = 0x00000001,  /// Image uses a single miptail region for all array slices
+    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT                = 0x00000002,  /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels.
+    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT          = 0x00000004,  /// Image uses a non-standard sparse block size
 }
 
 /// Pipeline stages
@@ -1363,7 +1361,7 @@
 }
 
 class VkSparseImageMemoryRequirements {
-    VkSparseImageFormatProperties               formatProps
+    VkSparseImageFormatProperties               formatProperties
     u32                                         imageMipTailStartLOD
     VkDeviceSize                                imageMipTailSize           /// Specified in bytes, must be a multiple of image block size / alignment
     VkDeviceSize                                imageMipTailOffset         /// Specified in bytes, must be a multiple of image block size / alignment
@@ -1545,14 +1543,14 @@
 class VkBufferCopy {
     VkDeviceSize                                srcOffset              /// Specified in bytes
     VkDeviceSize                                destOffset             /// Specified in bytes
-    VkDeviceSize                                copySize               /// Specified in bytes
+    VkDeviceSize                                size                   /// Specified in bytes
 }
 
 class VkSparseMemoryBind {
-    VkDeviceSize                                rangeOffset           /// Specified in bytes
-    VkDeviceSize                                rangeSize             /// Specified in bytes
-    VkDeviceSize                                memOffset             /// Specified in bytes
+    VkDeviceSize                                resourceOffset        /// Specified in bytes
+    VkDeviceSize                                size                  /// Specified in bytes
     VkDeviceMemory                              mem
+    VkDeviceSize                                memOffset             /// Specified in bytes
     VkSparseMemoryBindFlags                     flags
 }
 
@@ -1560,8 +1558,8 @@
     VkImageSubresource                          subresource
     VkOffset3D                                  offset
     VkExtent3D                                  extent
-    VkDeviceSize                                memOffset             /// Specified in bytes
     VkDeviceMemory                              mem
+    VkDeviceSize                                memOffset             /// Specified in bytes
     VkSparseMemoryBindFlags                     flags
 }
 
@@ -1695,13 +1693,13 @@
 
 class VkSpecializationMapEntry {
     u32                                         constantId         /// The SpecConstant ID specified in the BIL
-    platform.size_t                             size               /// Size in bytes of the SpecConstant
     u32                                         offset             /// Offset of the value in the data block
+    platform.size_t                             size               /// Size in bytes of the SpecConstant
 }
 
 class VkSpecializationInfo {
     u32                                         mapEntryCount      /// Number of entries in the map
-    const VkSpecializationMapEntry*             pMap               /// Array of map entries
+    const VkSpecializationMapEntry*             pMapEntries        /// Array of map entries
     platform.size_t                             dataSize           /// Size in bytes of pData
     const void*                                 pData              /// Pointer to SpecConstant data
 }
@@ -1725,16 +1723,16 @@
 }
 
 class VkVertexInputBindingDescription {
-    u32                                         binding        /// Vertex buffer binding id
-    u32                                         strideInBytes  /// Distance between vertices in bytes (0 = no advancement)
-    VkVertexInputStepRate                       stepRate       /// Rate at which binding is incremented
+    u32                                         binding               /// Vertex buffer binding id
+    u32                                         stride                /// Distance between vertices in bytes (0 = no advancement)
+    VkVertexInputStepRate                       stepRate              /// Rate at which binding is incremented
 }
 
 class VkVertexInputAttributeDescription {
-    u32                                         location       /// location of the shader vertex attrib
-    u32                                         binding        /// Vertex buffer binding id
-    VkFormat                                    format         /// format of source data
-    u32                                         offsetInBytes  /// Offset of first element in bytes from base of vertex
+    u32                                         location              /// location of the shader vertex attrib
+    u32                                         binding               /// Vertex buffer binding id
+    VkFormat                                    format                /// format of source data
+    u32                                         offset                /// Offset of first element in bytes from base of vertex
 }
 
 class VkPipelineVertexInputStateCreateInfo {
@@ -1819,7 +1817,7 @@
     VkLogicOp                                   logicOp
     u32                                         attachmentCount    /// # of pAttachments
     const VkPipelineColorBlendAttachmentState*  pAttachments
-    f32[4]                                      blendConst
+    f32[4]                                      blendConstants
 }
 
 class VkStencilOpState {
@@ -1878,12 +1876,12 @@
 }
 
 class VkPipelineCacheCreateInfo {
-    VkStructureType                             sType        /// Must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
-    const void*                                 pNext        /// Pointer to next structure
+    VkStructureType                             sType                 /// Must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
+    const void*                                 pNext                 /// Pointer to next structure
     VkPipelineCacheCreateFlags                  flags
-    platform.size_t                             initialSize  /// Size of initial data to populate cache, in bytes
-    const void*                                 initialData  /// Initial data to populate cache
-    platform.size_t                             maxSize      /// Maximum size cache can grow to, in bytes. If zero, then the cache may grow without bound.
+    platform.size_t                             initialDataSize       /// Size of initial data to populate cache, in bytes
+    const void*                                 pInitialData          /// Initial data to populate cache
+    platform.size_t                             maxSize               /// Maximum size cache can grow to, in bytes. If zero, then the cache may grow without bound.
 }
 
 class VkPushConstantRange {
@@ -2113,7 +2111,7 @@
     u32                                         maxImageDimensionCube                     /// max cubemap image dimension
     u32                                         maxImageArrayLayers                       /// max layers for image arrays
     VkSampleCountFlags                          sampleCounts                              /// sample counts supported for all images supporting rendering and sampling
-    u32                                         maxTexelBufferSize                        /// max texel buffer size (bytes)
+    u32                                         maxTexelBufferElements
     u32                                         maxUniformBufferRange                     /// max uniform buffer size (bytes)
     u32                                         maxStorageBufferRange                     /// max storage buffer size (bytes)
     u32                                         maxPushConstantsSize                      /// max size of the push constants pool (bytes)
@@ -2229,7 +2227,7 @@
 
 class VkPhysicalDeviceSparseProperties {
     VkBool32                                    residencyStandard2DBlockShape             /// Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard block shapes (based on pixel format)
-    VkBool32                                    residencyStandard2DMSBlockShape           /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard block shapes (based on pixel format)
+    VkBool32                                    residencyStandard2DMultisampleBlockShape  /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard block shapes (based on pixel format)
     VkBool32                                    residencyStandard3DBlockShape             /// Sparse resources support: GPU will access all 3D sparse resources using the standard block shapes (based on pixel format)
     VkBool32                                    residencyAlignedMipSize                   /// Sparse resources support: Images with mip-level dimensions that are NOT a multiple of the block size will be placed in the mip tail
     VkBool32                                    residencyNonResident                      /// Sparse resources support: GPU can safely access non-resident regions of a resource, read values from read-write resources are undefined
@@ -2284,8 +2282,8 @@
     u32                                         z
 }
 
-@extension("VK_EXT_KHR_swapchain")
-class VkSurfacePropertiesKHR {
+@extension("VK_EXT_KHR_surface")
+class VkSurfaceCapabilitiesKHR {
     u32                                         minImageCount
     u32                                         maxImageCount
     VkExtent2D                                  currentExtent
@@ -2298,7 +2296,7 @@
     VkImageUsageFlags                           supportedUsageFlags
 }
 
-@extension("VK_EXT_KHR_swapchain")
+@extension("VK_EXT_KHR_surface")
 class VkSurfaceFormatKHR {
     VkFormat                                    format
     VkColorSpaceKHR                             colorSpace
@@ -2329,6 +2327,8 @@
 class VkPresentInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
+    u32                                         waitSemaphoreCount
+    const VkSemaphore*                          pWaitSemaphores
     u32                                         swapchainCount
     const VkSwapchainKHR*                       pSwapchains
     const u32*                                  imageIndices
@@ -2727,7 +2727,7 @@
 cmd VkResult vkQueueSubmit(
         VkQueue                                     queue,
         u32                                         submitCount,
-        const VkSubmitInfo*                         pSubmitInfo,
+        const VkSubmitInfo*                         pSubmits,
         VkFence                                     fence) {
     queueObject := GetQueue(queue)
 
@@ -3709,21 +3709,21 @@
 
 cmd void vkUpdateDescriptorSets(
         VkDevice                                    device,
-        u32                                         writeCount,
+        u32                                         descriptorWriteCount,
         const VkWriteDescriptorSet*                 pDescriptorWrites,
-        u32                                         copyCount,
+        u32                                         descriptorCopyCount,
         const VkCopyDescriptorSet*                  pDescriptorCopies) {
     deviceObject := GetDevice(device)
 
-    descriptorWrites := pDescriptorWrites[0:writeCount]
-    for i in (0 .. writeCount) {
+    descriptorWrites := pDescriptorWrites[0:descriptorWriteCount]
+    for i in (0 .. descriptorWriteCount) {
         descriptorWrite := descriptorWrites[i]
         descriptorWriteObject := GetDescriptorSet(descriptorWrite.destSet)
         assert(descriptorWriteObject.device == device)
     }
 
-    descriptorCopies := pDescriptorCopies[0:copyCount]
-    for i in (0 .. copyCount) {
+    descriptorCopies := pDescriptorCopies[0:descriptorCopyCount]
+    for i in (0 .. descriptorCopyCount) {
         descriptorCopy := descriptorCopies[i]
         descriptorCopyObject := GetDescriptorSet(descriptorCopy.destSet)
         assert(descriptorCopyObject.device == device)
@@ -3987,7 +3987,7 @@
         // TODO(jessehall): apic only supports 'const' on pointer types. Using
         // an annotation as a quick hack to pass this to the template without
         // having to modify the AST and semantic model.
-        @readonly f32[4]                            blendConst) {
+        @readonly f32[4]                            blendConstants) {
     cmdBufferObject := GetCmdBuffer(cmdBuffer)
     cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }
@@ -4330,7 +4330,7 @@
         VkCmdBuffer                                 cmdBuffer,
         VkBuffer                                    destBuffer,
         VkDeviceSize                                destOffset,
-        VkDeviceSize                                fillSize,
+        VkDeviceSize                                size,
         u32                                         data) {
     cmdBufferObject := GetCmdBuffer(cmdBuffer)
     destBufferObject := GetBuffer(destBuffer)
@@ -4643,34 +4643,33 @@
 cmd VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
         VkPhysicalDevice                            physicalDevice,
         u32                                         queueFamilyIndex,
-        VkSurfaceKHR                                surface) {
-    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
-
-    //supported := ?
-
-    return ?//supported
-}
-
-@extension("VK_EXT_KHR_swapchain")
-cmd VkResult vkGetSurfacePropertiesKHR(
-        VkDevice                                    device,
         VkSurfaceKHR                                surface,
-        VkSurfacePropertiesKHR*                     pSurfaceProperties) {
-    deviceObject := GetDevice(device)
-
-    surfaceProperties := ?
-    pSurfaceProperties[0] = surfaceProperties
+        VkBool32*                                   pSupported) {
+    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
 
     return ?
 }
 
-@extension("VK_EXT_KHR_swapchain")
-cmd VkResult vkGetSurfaceFormatsKHR(
-        VkDevice                                    device,
+@extension("VK_EXT_KHR_surface")
+cmd VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+        VkPhysicalDevice                            physicalDevice,
+        VkSurfaceKHR                                surface,
+        VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities) {
+    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+
+    surfaceCapabilities := ?
+    pSurfaceCapabilities[0] = surfaceCapabilities
+
+    return ?
+}
+
+@extension("VK_EXT_KHR_surface")
+cmd VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
+        VkPhysicalDevice                            physicalDevice,
         VkSurfaceKHR                                surface,
         u32*                                        pSurfaceFormatCount,
         VkSurfaceFormatKHR*                         pSurfaceFormats) {
-    deviceObject := GetDevice(device)
+    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
 
     count := as!u32(?)
     pSurfaceFormatCount[0] = count
@@ -4684,13 +4683,13 @@
     return ?
 }
 
-@extension("VK_EXT_KHR_swapchain")
-cmd VkResult vkGetSurfacePresentModesKHR(
-        VkDevice                                    device,
+@extension("VK_EXT_KHR_surface")
+cmd VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
+        VkPhysicalDevice                            physicalDevice,
         VkSurfaceKHR                                surface,
         u32*                                        pPresentModeCount,
         VkPresentModeKHR*                           pPresentModes) {
-    deviceObject := GetDevice(device)
+    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
 
     count := as!u32(?)
     pPresentModeCount[0] = count
diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
index fd09209..8442325 100644
--- a/vulkan/include/vulkan/vulkan.h
+++ b/vulkan/include/vulkan/vulkan.h
@@ -41,7 +41,7 @@
     ((major << 22) | (minor << 12) | patch)
 
 // Vulkan API version supported by this file
-#define VK_API_VERSION VK_MAKE_VERSION(0, 192, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(0, 193, 0)
 
 
 #define VK_NULL_HANDLE 0
@@ -818,7 +818,7 @@
     VK_QUEUE_GRAPHICS_BIT = 0x00000001,
     VK_QUEUE_COMPUTE_BIT = 0x00000002,
     VK_QUEUE_DMA_BIT = 0x00000004,
-    VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008,
+    VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
 } VkQueueFlagBits;
 typedef VkFlags VkQueueFlags;
 
@@ -847,9 +847,9 @@
 } VkImageAspectFlagBits;
 
 typedef enum {
-    VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001,
-    VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
-    VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004,
+    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
+    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
+    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
 } VkSparseImageFormatFlagBits;
 typedef VkFlags VkSparseImageFormatFlags;
 
@@ -910,11 +910,6 @@
 } VkBufferUsageFlagBits;
 typedef VkFlags VkBufferUsageFlags;
 typedef VkFlags VkBufferViewCreateFlags;
-
-typedef enum {
-    VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
-    VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
-} VkImageViewCreateFlagBits;
 typedef VkFlags VkImageViewCreateFlags;
 typedef VkFlags VkImageAspectFlags;
 typedef VkFlags VkShaderModuleCreateFlags;
@@ -1198,7 +1193,7 @@
     uint32_t                                    maxImageDimensionCube;
     uint32_t                                    maxImageArrayLayers;
     VkSampleCountFlags                          sampleCounts;
-    uint32_t                                    maxTexelBufferSize;
+    uint32_t                                    maxTexelBufferElements;
     uint32_t                                    maxUniformBufferRange;
     uint32_t                                    maxStorageBufferRange;
     uint32_t                                    maxPushConstantsSize;
@@ -1294,7 +1289,7 @@
 
 typedef struct {
     VkBool32                                    residencyStandard2DBlockShape;
-    VkBool32                                    residencyStandard2DMSBlockShape;
+    VkBool32                                    residencyStandard2DMultisampleBlockShape;
     VkBool32                                    residencyStandard3DBlockShape;
     VkBool32                                    residencyAlignedMipSize;
     VkBool32                                    residencyNonResident;
@@ -1409,7 +1404,7 @@
 } VkSparseImageFormatProperties;
 
 typedef struct {
-    VkSparseImageFormatProperties               formatProps;
+    VkSparseImageFormatProperties               formatProperties;
     uint32_t                                    imageMipTailStartLOD;
     VkDeviceSize                                imageMipTailSize;
     VkDeviceSize                                imageMipTailOffset;
@@ -1417,10 +1412,10 @@
 } VkSparseImageMemoryRequirements;
 
 typedef struct {
-    VkDeviceSize                                rangeOffset;
-    VkDeviceSize                                rangeSize;
-    VkDeviceSize                                memOffset;
+    VkDeviceSize                                resourceOffset;
+    VkDeviceSize                                size;
     VkDeviceMemory                              mem;
+    VkDeviceSize                                memOffset;
     VkSparseMemoryBindFlags                     flags;
 } VkSparseMemoryBind;
 
@@ -1452,8 +1447,8 @@
     VkImageSubresource                          subresource;
     VkOffset3D                                  offset;
     VkExtent3D                                  extent;
-    VkDeviceSize                                memOffset;
     VkDeviceMemory                              mem;
+    VkDeviceSize                                memOffset;
     VkSparseMemoryBindFlags                     flags;
 } VkSparseImageMemoryBind;
 
@@ -1598,20 +1593,20 @@
     VkStructureType                             sType;
     const void*                                 pNext;
     VkPipelineCacheCreateFlags                  flags;
-    size_t                                      initialSize;
-    const void*                                 initialData;
+    size_t                                      initialDataSize;
+    const void*                                 pInitialData;
     size_t                                      maxSize;
 } VkPipelineCacheCreateInfo;
 
 typedef struct {
     uint32_t                                    constantId;
-    size_t                                      size;
     uint32_t                                    offset;
+    size_t                                      size;
 } VkSpecializationMapEntry;
 
 typedef struct {
     uint32_t                                    mapEntryCount;
-    const VkSpecializationMapEntry*             pMap;
+    const VkSpecializationMapEntry*             pMapEntries;
     size_t                                      dataSize;
     const void*                                 pData;
 } VkSpecializationInfo;
@@ -1626,7 +1621,7 @@
 
 typedef struct {
     uint32_t                                    binding;
-    uint32_t                                    strideInBytes;
+    uint32_t                                    stride;
     VkVertexInputStepRate                       stepRate;
 } VkVertexInputBindingDescription;
 
@@ -1634,7 +1629,7 @@
     uint32_t                                    location;
     uint32_t                                    binding;
     VkFormat                                    format;
-    uint32_t                                    offsetInBytes;
+    uint32_t                                    offset;
 } VkVertexInputAttributeDescription;
 
 typedef struct {
@@ -1768,7 +1763,7 @@
     VkLogicOp                                   logicOp;
     uint32_t                                    attachmentCount;
     const VkPipelineColorBlendAttachmentState*  pAttachments;
-    float                                       blendConst[4];
+    float                                       blendConstants[4];
 } VkPipelineColorBlendStateCreateInfo;
 
 typedef struct {
@@ -2018,7 +2013,7 @@
 typedef struct {
     VkDeviceSize                                srcOffset;
     VkDeviceSize                                destOffset;
-    VkDeviceSize                                copySize;
+    VkDeviceSize                                size;
 } VkBufferCopy;
 
 typedef struct {
@@ -2172,7 +2167,7 @@
 typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
 typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
 typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
-typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
+typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
 typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
 typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
 typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem);
@@ -2235,7 +2230,7 @@
 typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
 typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
 typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
-typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
 typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
 typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass);
@@ -2254,7 +2249,7 @@
 typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
 typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCmdBuffer cmdBuffer, float lineWidth);
 typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
-typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConst[4]);
+typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConstants[4]);
 typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
 typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
 typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
@@ -2274,7 +2269,7 @@
 typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
 typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
 typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
-typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
+typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data);
 typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
 typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
 typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
@@ -2387,7 +2382,7 @@
 VkResult VKAPI vkQueueSubmit(
     VkQueue                                     queue,
     uint32_t                                    submitCount,
-    const VkSubmitInfo*                         pSubmitInfo,
+    const VkSubmitInfo*                         pSubmits,
     VkFence                                     fence);
 
 VkResult VKAPI vkQueueWaitIdle(
@@ -2738,9 +2733,9 @@
 
 void VKAPI vkUpdateDescriptorSets(
     VkDevice                                    device,
-    uint32_t                                    writeCount,
+    uint32_t                                    descriptorWriteCount,
     const VkWriteDescriptorSet*                 pDescriptorWrites,
-    uint32_t                                    copyCount,
+    uint32_t                                    descriptorCopyCount,
     const VkCopyDescriptorSet*                  pDescriptorCopies);
 
 VkResult VKAPI vkCreateFramebuffer(
@@ -2835,7 +2830,7 @@
 
 void VKAPI vkCmdSetBlendConstants(
     VkCmdBuffer                                 cmdBuffer,
-    const float                                 blendConst[4]);
+    const float                                 blendConstants[4]);
 
 void VKAPI vkCmdSetDepthBounds(
     VkCmdBuffer                                 cmdBuffer,
@@ -2973,7 +2968,7 @@
     VkCmdBuffer                                 cmdBuffer,
     VkBuffer                                    destBuffer,
     VkDeviceSize                                destOffset,
-    VkDeviceSize                                fillSize,
+    VkDeviceSize                                size,
     uint32_t                                    data);
 
 void VKAPI vkCmdClearColorImage(
@@ -3102,32 +3097,6 @@
 #define VK_EXT_KHR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_surface"
 #define VK_ERROR_SURFACE_LOST_KHR         ((VkResult)(int)0xc0000400)
 
-typedef void (VKAPI *PFN_vkDestroySurfaceKHR)(VkInstance  instance, VkSurfaceKHR  surface);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface);
-
-#ifdef VK_PROTOTYPES
-void VKAPI vkDestroySurfaceKHR(
-    VkInstance                                   instance,
-    VkSurfaceKHR                                 surface);
-
-VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t                                    queueFamilyIndex,
-    VkSurfaceKHR                                surface);
-#endif
-
-#define vk_ext_khr_swapchain 1
-VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR)
-
-#define VK_EXT_KHR_SWAPCHAIN_REVISION     62
-#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
-#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
-#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
-#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801)
-#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR ((VkImageLayout)(int)0xc0000802)
-#define VK_SUBOPTIMAL_KHR                 ((VkResult)(int)0x40000403)
-#define VK_ERROR_OUT_OF_DATE_KHR          ((VkResult)(int)0xc0000804)
-
 
 typedef enum {
     VK_SURFACE_TRANSFORM_NONE_KHR = 0,
@@ -3197,13 +3166,61 @@
     VkCompositeAlphaFlagsKHR                    supportedCompositeAlpha;
     uint32_t                                    maxImageArraySize;
     VkImageUsageFlags                           supportedUsageFlags;
-} VkSurfacePropertiesKHR;
+} VkSurfaceCapabilitiesKHR;
 
 typedef struct {
     VkFormat                                    format;
     VkColorSpaceKHR                             colorSpace;
 } VkSurfaceFormatKHR;
 
+
+typedef void (VKAPI *PFN_vkDestroySurfaceKHR)(VkInstance  instance, VkSurfaceKHR  surface);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
+
+#ifdef VK_PROTOTYPES
+void VKAPI vkDestroySurfaceKHR(
+    VkInstance                                   instance,
+    VkSurfaceKHR                                 surface);
+
+VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    VkSurfaceKHR                                surface,
+    VkBool32*                                   pSupported);
+
+VkResult VKAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
+
+VkResult VKAPI vkGetPhysicalDeviceSurfaceFormatsKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    uint32_t*                                   pSurfaceFormatCount,
+    VkSurfaceFormatKHR*                         pSurfaceFormats);
+
+VkResult VKAPI vkGetPhysicalDeviceSurfacePresentModesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    uint32_t*                                   pPresentModeCount,
+    VkPresentModeKHR*                           pPresentModes);
+#endif
+
+#define vk_ext_khr_swapchain 1
+VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR)
+
+#define VK_EXT_KHR_SWAPCHAIN_REVISION     62
+#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
+#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
+#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801)
+#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR ((VkImageLayout)(int)0xc0000802)
+#define VK_SUBOPTIMAL_KHR                 ((VkResult)(int)0x40000403)
+#define VK_ERROR_OUT_OF_DATE_KHR          ((VkResult)(int)0xc0000804)
+
 typedef struct {
     VkStructureType                             sType;
     const void*                                   pNext;
@@ -3227,15 +3244,14 @@
 typedef struct {
     VkStructureType                             sType;
     const void*                                   pNext;
+    uint32_t                                    waitSemaphoreCount;
+    const VkSemaphore*                          pWaitSemaphores;
     uint32_t                                    swapchainCount;
     const VkSwapchainKHR*                       pSwapchains;
     const uint32_t*                             imageIndices;
 } VkPresentInfoKHR;
 
 
-typedef VkResult (VKAPI *PFN_vkGetSurfacePropertiesKHR)(VkDevice  device, VkSurfaceKHR  surface, VkSurfacePropertiesKHR*  pSurfaceProperties);
-typedef VkResult (VKAPI *PFN_vkGetSurfaceFormatsKHR)(VkDevice  device, VkSurfaceKHR  surface, uint32_t*  pSurfaceFormatCount, VkSurfaceFormatKHR*  pSurfaceFormats);
-typedef VkResult (VKAPI *PFN_vkGetSurfacePresentModesKHR)(VkDevice  device, VkSurfaceKHR  surface, uint32_t*  pPresentModeCount, VkPresentModeKHR*  pPresentModes);
 typedef VkResult (VKAPI *PFN_vkCreateSwapchainKHR)(VkDevice  device, const VkSwapchainCreateInfoKHR*  pCreateInfo, VkSwapchainKHR*  pSwapchain);
 typedef void (VKAPI *PFN_vkDestroySwapchainKHR)(VkDevice  device, VkSwapchainKHR  swapchain);
 typedef VkResult (VKAPI *PFN_vkGetSwapchainImagesKHR)(VkDevice  device, VkSwapchainKHR  swapchain, uint32_t*  pSwapchainImageCount, VkImage*  pSwapchainImages);
@@ -3243,23 +3259,6 @@
 typedef VkResult (VKAPI *PFN_vkQueuePresentKHR)(VkQueue  queue, VkPresentInfoKHR*  pPresentInfo);
 
 #ifdef VK_PROTOTYPES
-VkResult VKAPI vkGetSurfacePropertiesKHR(
-    VkDevice                                     device,
-    VkSurfaceKHR                                 surface,
-    VkSurfacePropertiesKHR*                      pSurfaceProperties);
-
-VkResult VKAPI vkGetSurfaceFormatsKHR(
-    VkDevice                                     device,
-    VkSurfaceKHR                                 surface,
-    uint32_t*                                    pSurfaceFormatCount,
-    VkSurfaceFormatKHR*                          pSurfaceFormats);
-
-VkResult VKAPI vkGetSurfacePresentModesKHR(
-    VkDevice                                     device,
-    VkSurfaceKHR                                 surface,
-    uint32_t*                                    pPresentModeCount,
-    VkPresentModeKHR*                            pPresentModes);
-
 VkResult VKAPI vkCreateSwapchainKHR(
     VkDevice                                     device,
     const VkSwapchainCreateInfoKHR*              pCreateInfo,
@@ -3333,11 +3332,6 @@
 } VkDisplayModeCreateInfoKHR;
 
 typedef struct {
-    VkDisplayKHR                                currentDisplay;
-    uint32_t                                    currentStackIndex;
-} VkDisplayPlanePropertiesKHR;
-
-typedef struct {
     VkDisplayPlaneAlphaFlagsKHR                 supportedAlpha;
     VkOffset2D                                  minSrcPosition;
     VkOffset2D                                  maxSrcPosition;
@@ -3350,6 +3344,11 @@
 } VkDisplayPlaneCapabilitiesKHR;
 
 typedef struct {
+    VkDisplayKHR                                currentDisplay;
+    uint32_t                                    currentStackIndex;
+} VkDisplayPlanePropertiesKHR;
+
+typedef struct {
     VkStructureType                             sType;
     const void*                                   pNext;
     VkDisplayModeKHR                            displayMode;
diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
index 9198f64..31f0231 100644
--- a/vulkan/libvulkan/entry.cpp
+++ b/vulkan/libvulkan/entry.cpp
@@ -132,8 +132,8 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence) {
-    return GetVtbl(queue).QueueSubmit(queue, submitCount, pSubmitInfo, fence);
+VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
+    return GetVtbl(queue).QueueSubmit(queue, submitCount, pSubmits, fence);
 }
 
 __attribute__((visibility("default")))
@@ -447,8 +447,8 @@
 }
 
 __attribute__((visibility("default")))
-void vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
-    GetVtbl(device).UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
+void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
+    GetVtbl(device).UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
 }
 
 __attribute__((visibility("default")))
@@ -542,8 +542,8 @@
 }
 
 __attribute__((visibility("default")))
-void vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConst[4]) {
-    GetVtbl(cmdBuffer).CmdSetBlendConstants(cmdBuffer, blendConst);
+void vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConstants[4]) {
+    GetVtbl(cmdBuffer).CmdSetBlendConstants(cmdBuffer, blendConstants);
 }
 
 __attribute__((visibility("default")))
@@ -642,8 +642,8 @@
 }
 
 __attribute__((visibility("default")))
-void vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {
-    GetVtbl(cmdBuffer).CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
+void vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data) {
+    GetVtbl(cmdBuffer).CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
 }
 
 __attribute__((visibility("default")))
@@ -742,23 +742,23 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface) {
-    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface);
+VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
+    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetSurfacePropertiesKHR(VkDevice device, VkSurfaceKHR surface, VkSurfacePropertiesKHR* pSurfaceProperties) {
-    return GetVtbl(device).GetSurfacePropertiesKHR(device, surface, pSurfaceProperties);
+VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
+    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetSurfaceFormatsKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
-    return GetVtbl(device).GetSurfaceFormatsKHR(device, surface, pSurfaceFormatCount, pSurfaceFormats);
+VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
+    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
-    return GetVtbl(device).GetSurfacePresentModesKHR(device, surface, pPresentModeCount, pPresentModes);
+VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
+    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
 }
 
 __attribute__((visibility("default")))
diff --git a/vulkan/libvulkan/get_proc_addr.cpp b/vulkan/libvulkan/get_proc_addr.cpp
index a0987e2..4e08015 100644
--- a/vulkan/libvulkan/get_proc_addr.cpp
+++ b/vulkan/libvulkan/get_proc_addr.cpp
@@ -64,6 +64,9 @@
     {"vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties)},
     {"vkGetPhysicalDeviceQueueFamilyProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyProperties)},
     {"vkGetPhysicalDeviceSparseImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSparseImageFormatProperties)},
+    {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)},
+    {"vkGetPhysicalDeviceSurfaceFormatsKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceFormatsKHR)},
+    {"vkGetPhysicalDeviceSurfacePresentModesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfacePresentModesKHR)},
     {"vkGetPhysicalDeviceSurfaceSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceSupportKHR)},
     // clang-format on
 };
@@ -181,9 +184,6 @@
     {"vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData)},
     {"vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults)},
     {"vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity)},
-    {"vkGetSurfaceFormatsKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfaceFormatsKHR)},
-    {"vkGetSurfacePresentModesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfacePresentModesKHR)},
-    {"vkGetSurfacePropertiesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfacePropertiesKHR)},
     {"vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR)},
     {"vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges)},
     {"vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory)},
@@ -221,6 +221,9 @@
     {"vkGetPhysicalDeviceProperties", offsetof(InstanceVtbl, GetPhysicalDeviceProperties)},
     {"vkGetPhysicalDeviceQueueFamilyProperties", offsetof(InstanceVtbl, GetPhysicalDeviceQueueFamilyProperties)},
     {"vkGetPhysicalDeviceSparseImageFormatProperties", offsetof(InstanceVtbl, GetPhysicalDeviceSparseImageFormatProperties)},
+    {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", offsetof(InstanceVtbl, GetPhysicalDeviceSurfaceCapabilitiesKHR)},
+    {"vkGetPhysicalDeviceSurfaceFormatsKHR", offsetof(InstanceVtbl, GetPhysicalDeviceSurfaceFormatsKHR)},
+    {"vkGetPhysicalDeviceSurfacePresentModesKHR", offsetof(InstanceVtbl, GetPhysicalDeviceSurfacePresentModesKHR)},
     {"vkGetPhysicalDeviceSurfaceSupportKHR", offsetof(InstanceVtbl, GetPhysicalDeviceSurfaceSupportKHR)},
     // clang-format on
 };
@@ -338,9 +341,6 @@
     {"vkGetPipelineCacheData", offsetof(DeviceVtbl, GetPipelineCacheData)},
     {"vkGetQueryPoolResults", offsetof(DeviceVtbl, GetQueryPoolResults)},
     {"vkGetRenderAreaGranularity", offsetof(DeviceVtbl, GetRenderAreaGranularity)},
-    {"vkGetSurfaceFormatsKHR", offsetof(DeviceVtbl, GetSurfaceFormatsKHR)},
-    {"vkGetSurfacePresentModesKHR", offsetof(DeviceVtbl, GetSurfacePresentModesKHR)},
-    {"vkGetSurfacePropertiesKHR", offsetof(DeviceVtbl, GetSurfacePropertiesKHR)},
     {"vkGetSwapchainImagesKHR", offsetof(DeviceVtbl, GetSwapchainImagesKHR)},
     {"vkInvalidateMappedMemoryRanges", offsetof(DeviceVtbl, InvalidateMappedMemoryRanges)},
     {"vkMapMemory", offsetof(DeviceVtbl, MapMemory)},
@@ -486,6 +486,9 @@
     }
     vtbl.DestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(get_proc_addr(instance, "vkDestroySurfaceKHR"));
     vtbl.GetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR"));
+    vtbl.GetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
+    vtbl.GetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
+    vtbl.GetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
     vtbl.CreateAndroidSurfaceKHR = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(get_proc_addr(instance, "vkCreateAndroidSurfaceKHR"));
     // clang-format on
     return success;
@@ -1112,21 +1115,6 @@
         ALOGE("missing device proc: %s", "vkCmdExecuteCommands");
         success = false;
     }
-    vtbl.GetSurfacePropertiesKHR = reinterpret_cast<PFN_vkGetSurfacePropertiesKHR>(get_proc_addr(device, "vkGetSurfacePropertiesKHR"));
-    if (UNLIKELY(!vtbl.GetSurfacePropertiesKHR)) {
-        ALOGE("missing device proc: %s", "vkGetSurfacePropertiesKHR");
-        success = false;
-    }
-    vtbl.GetSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetSurfaceFormatsKHR>(get_proc_addr(device, "vkGetSurfaceFormatsKHR"));
-    if (UNLIKELY(!vtbl.GetSurfaceFormatsKHR)) {
-        ALOGE("missing device proc: %s", "vkGetSurfaceFormatsKHR");
-        success = false;
-    }
-    vtbl.GetSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetSurfacePresentModesKHR>(get_proc_addr(device, "vkGetSurfacePresentModesKHR"));
-    if (UNLIKELY(!vtbl.GetSurfacePresentModesKHR)) {
-        ALOGE("missing device proc: %s", "vkGetSurfacePresentModesKHR");
-        success = false;
-    }
     vtbl.CreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(get_proc_addr(device, "vkCreateSwapchainKHR"));
     if (UNLIKELY(!vtbl.CreateSwapchainKHR)) {
         ALOGE("missing device proc: %s", "vkCreateSwapchainKHR");
diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
index 10877c5..03265ef 100644
--- a/vulkan/libvulkan/loader.cpp
+++ b/vulkan/libvulkan/loader.cpp
@@ -546,15 +546,6 @@
         return reinterpret_cast<PFN_vkVoidFunction>(Noop);
     }
     // WSI extensions are not in the driver so return the loader functions
-    if (strcmp(name, "vkGetSurfacePropertiesKHR") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(GetSurfacePropertiesKHR);
-    }
-    if (strcmp(name, "vkGetSurfaceFormatsKHR") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(GetSurfaceFormatsKHR);
-    }
-    if (strcmp(name, "vkGetSurfacePresentModesKHR") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(GetSurfacePresentModesKHR);
-    }
     if (strcmp(name, "vkCreateSwapchainKHR") == 0) {
         return reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR);
     }
@@ -900,6 +891,9 @@
     .EnumerateDeviceLayerProperties = EnumerateDeviceLayerPropertiesBottom,
     .GetPhysicalDeviceSparseImageFormatProperties = GetPhysicalDeviceSparseImageFormatPropertiesBottom,
     .GetPhysicalDeviceSurfaceSupportKHR = GetPhysicalDeviceSurfaceSupportKHR,
+    .GetPhysicalDeviceSurfaceCapabilitiesKHR = GetPhysicalDeviceSurfaceCapabilitiesKHR,
+    .GetPhysicalDeviceSurfaceFormatsKHR = GetPhysicalDeviceSurfaceFormatsKHR,
+    .GetPhysicalDeviceSurfacePresentModesKHR = GetPhysicalDeviceSurfacePresentModesKHR,
     // clang-format on
 };
 
diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
index 5c176db..b6c8552 100644
--- a/vulkan/libvulkan/loader.h
+++ b/vulkan/libvulkan/loader.h
@@ -51,6 +51,9 @@
     PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
 
     // Layers and loader only, not implemented by drivers
+    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
+    PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
+    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
     PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
     PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
     PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
@@ -187,9 +190,6 @@
     PFN_vkCmdExecuteCommands CmdExecuteCommands;
 
     // Layers and loader only, not implemented by drivers
-    PFN_vkGetSurfacePropertiesKHR GetSurfacePropertiesKHR;
-    PFN_vkGetSurfaceFormatsKHR GetSurfaceFormatsKHR;
-    PFN_vkGetSurfacePresentModesKHR GetSurfacePresentModesKHR;
     PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
     PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
     PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
@@ -268,18 +268,20 @@
 void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface);
 VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev,
                                             uint32_t queue_family,
-                                            VkSurfaceKHR surface);
-VkResult GetSurfacePropertiesKHR(VkDevice device,
-                                 VkSurfaceKHR surface,
-                                 VkSurfacePropertiesKHR* properties);
-VkResult GetSurfaceFormatsKHR(VkDevice device,
-                              VkSurfaceKHR surface,
-                              uint32_t* count,
-                              VkSurfaceFormatKHR* formats);
-VkResult GetSurfacePresentModesKHR(VkDevice device,
-                                   VkSurfaceKHR surface,
-                                   uint32_t* count,
-                                   VkPresentModeKHR* modes);
+                                            VkSurfaceKHR surface,
+                                            VkBool32* pSupported);
+VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
+    VkPhysicalDevice pdev,
+    VkSurfaceKHR surface,
+    VkSurfaceCapabilitiesKHR* capabilities);
+VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
+                                            VkSurfaceKHR surface,
+                                            uint32_t* count,
+                                            VkSurfaceFormatKHR* formats);
+VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
+                                                 VkSurfaceKHR surface,
+                                                 uint32_t* count,
+                                                 VkPresentModeKHR* modes);
 VkResult CreateSwapchainKHR(VkDevice device,
                             const VkSwapchainCreateInfoKHR* create_info,
                             VkSwapchainKHR* swapchain_handle);
diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
index 88619186..f1fe236 100644
--- a/vulkan/libvulkan/swapchain.cpp
+++ b/vulkan/libvulkan/swapchain.cpp
@@ -177,13 +177,16 @@
 
 VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
                                             uint32_t /*queue_family*/,
-                                            VkSurfaceKHR /*surface*/) {
+                                            VkSurfaceKHR /*surface*/,
+                                            VkBool32* pSupported) {
+    *pSupported = VK_TRUE;
     return VK_SUCCESS;
 }
 
-VkResult GetSurfacePropertiesKHR(VkDevice /*device*/,
-                                 VkSurfaceKHR surface,
-                                 VkSurfacePropertiesKHR* properties) {
+VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
+    VkPhysicalDevice /*pdev*/,
+    VkSurfaceKHR surface,
+    VkSurfaceCapabilitiesKHR* capabilities) {
     int err;
     ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
 
@@ -201,25 +204,25 @@
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
-    properties->currentExtent = VkExtent2D{width, height};
+    capabilities->currentExtent = VkExtent2D{width, height};
 
     // TODO(jessehall): Figure out what the min/max values should be.
-    properties->minImageCount = 2;
-    properties->maxImageCount = 3;
+    capabilities->minImageCount = 2;
+    capabilities->maxImageCount = 3;
 
     // TODO(jessehall): Figure out what the max extent should be. Maximum
     // texture dimension maybe?
-    properties->minImageExtent = VkExtent2D{1, 1};
-    properties->maxImageExtent = VkExtent2D{4096, 4096};
+    capabilities->minImageExtent = VkExtent2D{1, 1};
+    capabilities->maxImageExtent = VkExtent2D{4096, 4096};
 
     // TODO(jessehall): We can support all transforms, fix this once
     // implemented.
-    properties->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_KHR;
+    capabilities->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_KHR;
 
     // TODO(jessehall): Implement based on NATIVE_WINDOW_TRANSFORM_HINT.
-    properties->currentTransform = VK_SURFACE_TRANSFORM_NONE_KHR;
+    capabilities->currentTransform = VK_SURFACE_TRANSFORM_NONE_KHR;
 
-    properties->maxImageArraySize = 1;
+    capabilities->maxImageArraySize = 1;
 
     // TODO(jessehall): I think these are right, but haven't thought hard about
     // it. Do we need to query the driver for support of any of these?
@@ -227,7 +230,7 @@
     // - VK_IMAGE_USAGE_GENERAL: maybe? does this imply cpu mappable?
     // - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT: definitely not
     // - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: definitely not
-    properties->supportedUsageFlags =
+    capabilities->supportedUsageFlags =
         VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT |
         VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
         VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
@@ -236,10 +239,10 @@
     return VK_SUCCESS;
 }
 
-VkResult GetSurfaceFormatsKHR(VkDevice /*device*/,
-                              VkSurfaceKHR /*surface*/,
-                              uint32_t* count,
-                              VkSurfaceFormatKHR* formats) {
+VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice /*pdev*/,
+                                            VkSurfaceKHR /*surface*/,
+                                            uint32_t* count,
+                                            VkSurfaceFormatKHR* formats) {
     // TODO(jessehall): Fill out the set of supported formats. Longer term, add
     // a new gralloc method to query whether a (format, usage) pair is
     // supported, and check that for each gralloc format that corresponds to a
@@ -262,10 +265,10 @@
     return result;
 }
 
-VkResult GetSurfacePresentModesKHR(VkDevice /*device*/,
-                                   VkSurfaceKHR /*surface*/,
-                                   uint32_t* count,
-                                   VkPresentModeKHR* modes) {
+VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice /*pdev*/,
+                                                 VkSurfaceKHR /*surface*/,
+                                                 uint32_t* count,
+                                                 VkPresentModeKHR* modes) {
     const VkPresentModeKHR kModes[] = {
         VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR,
     };
diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
index 63e0d5f..eaec272 100644
--- a/vulkan/tools/vkinfo.cpp
+++ b/vulkan/tools/vkinfo.cpp
@@ -77,7 +77,7 @@
             return "COMPUTE";
         case VK_QUEUE_DMA_BIT:
             return "DMA";
-        case VK_QUEUE_SPARSE_MEMMGR_BIT:
+        case VK_QUEUE_SPARSE_BINDING_BIT:
             return "SPARSE";
     }
 }