diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
index 2b499fd..7844f63 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 177
+define VERSION_MINOR 179
 define VERSION_PATCH 0
 
 // API limits
@@ -621,7 +621,8 @@
     VK_ERROR_MEMORY_MAP_FAILED                              = 0xFFFFFFFB,
     VK_ERROR_LAYER_NOT_PRESENT                              = 0xFFFFFFFA,
     VK_ERROR_EXTENSION_NOT_PRESENT                          = 0xFFFFFFF9,
-    VK_ERROR_INCOMPATIBLE_DRIVER                            = 0xFFFFFFF8,
+    VK_ERROR_FEATURE_NOT_PRESENT                            = 0xFFFFFFF8,
+    VK_ERROR_INCOMPATIBLE_DRIVER                            = 0xFFFFFFF7,
 }
 
 enum VkDynamicState {
@@ -2157,18 +2158,16 @@
     return ?
 }
 
-cmd VkResult vkGetPhysicalDeviceProperties(
+cmd void vkGetPhysicalDeviceProperties(
         VkPhysicalDevice                            physicalDevice,
         VkPhysicalDeviceProperties*                 pProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
 
     properties := ?
     pProperties[0] = properties
-
-    return ?
 }
 
-cmd VkResult vkGetPhysicalDeviceQueueFamilyProperties(
+cmd void vkGetPhysicalDeviceQueueFamilyProperties(
         VkPhysicalDevice                            physicalDevice,
         u32*                                        pCount,
         VkQueueFamilyProperties*                    pQueueFamilyProperties) {
@@ -2187,32 +2186,27 @@
     //     count := ?
     //     pCount[0] = count
     // }
-    return ?
 }
 
-cmd VkResult vkGetPhysicalDeviceMemoryProperties(
+cmd void vkGetPhysicalDeviceMemoryProperties(
         VkPhysicalDevice                            physicalDevice,
         VkPhysicalDeviceMemoryProperties*           pMemoryProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
 
     memoryProperties := ?
     pMemoryProperties[0] = memoryProperties
-
-    return ?
 }
 
-cmd VkResult vkGetPhysicalDeviceFeatures(
+cmd void vkGetPhysicalDeviceFeatures(
         VkPhysicalDevice                            physicalDevice,
         VkPhysicalDeviceFeatures*                   pFeatures) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
 
     features := ?
     pFeatures[0] = features
-
-    return ?
 }
 
-cmd VkResult vkGetPhysicalDeviceFormatProperties(
+cmd void vkGetPhysicalDeviceFormatProperties(
         VkPhysicalDevice                            physicalDevice,
         VkFormat                                    format,
         VkFormatProperties*                         pFormatProperties) {
@@ -2220,11 +2214,9 @@
 
     formatProperties := ?
     pFormatProperties[0] = formatProperties
-
-    return ?
 }
 
-cmd VkResult vkGetPhysicalDeviceImageFormatProperties(
+cmd void vkGetPhysicalDeviceImageFormatProperties(
         VkPhysicalDevice                            physicalDevice,
         VkFormat                                    format,
         VkImageType                                 type,
@@ -2236,8 +2228,6 @@
 
     imageFormatProperties := ?
     pImageFormatProperties[0] = imageFormatProperties
-
-    return ?
 }
 
 
@@ -2340,7 +2330,7 @@
 // Queue functions
 
 @threadSafety("system")
-cmd VkResult vkGetDeviceQueue(
+cmd void vkGetDeviceQueue(
         VkDevice                                    device,
         u32                                         queueFamilyIndex,
         u32                                         queueIndex,
@@ -2353,8 +2343,6 @@
     if !(queue in State.Queues) {
         State.Queues[queue] = new!QueueObject(device: device)
     }
-
-    return ?
 }
 
 @threadSafety("app")
@@ -2499,7 +2487,7 @@
 
 // Memory management API functions
 
-cmd VkResult vkGetDeviceMemoryCommitment(
+cmd void vkGetDeviceMemoryCommitment(
         VkDevice                                    device,
         VkDeviceMemory                              memory,
         VkDeviceSize*                               pCommittedMemoryInBytes) {
@@ -2512,19 +2500,15 @@
 
     committedMemoryInBytes := ?
     pCommittedMemoryInBytes[0] = committedMemoryInBytes
-
-    return ?
 }
 
-cmd VkResult vkGetBufferMemoryRequirements(
+cmd void vkGetBufferMemoryRequirements(
         VkDevice                                    device,
         VkBuffer                                    buffer,
         VkMemoryRequirements*                       pMemoryRequirements) {
     deviceObject := GetDevice(device)
     bufferObject := GetBuffer(buffer)
     assert(bufferObject.device == device)
-
-    return ?
 }
 
 cmd VkResult vkBindBufferMemory(
@@ -2554,15 +2538,13 @@
     return ?
 }
 
-cmd VkResult vkGetImageMemoryRequirements(
+cmd void vkGetImageMemoryRequirements(
         VkDevice                                    device,
         VkImage                                     image,
         VkMemoryRequirements*                       pMemoryRequirements) {
     deviceObject := GetDevice(device)
     imageObject := GetImage(image)
     assert(imageObject.device == device)
-
-    return ?
 }
 
 cmd VkResult vkBindImageMemory(
@@ -2592,7 +2574,7 @@
     return ?
 }
 
-cmd VkResult vkGetImageSparseMemoryRequirements(
+cmd void vkGetImageSparseMemoryRequirements(
         VkDevice                                    device,
         VkImage                                     image,
         u32*                                        pNumRequirements,
@@ -2600,11 +2582,9 @@
     deviceObject := GetDevice(device)
     imageObject := GetImage(image)
     assert(imageObject.device == device)
-
-    return ?
 }
 
-cmd VkResult vkGetPhysicalDeviceSparseImageFormatProperties(
+cmd void vkGetPhysicalDeviceSparseImageFormatProperties(
         VkPhysicalDevice                            physicalDevice,
         VkFormat                                    format,
         VkImageType                                 type,
@@ -2614,8 +2594,6 @@
         u32*                                        pNumProperties,
         VkSparseImageFormatProperties*              pProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
-
-    return ?
 }
 
 cmd VkResult vkQueueBindSparseBufferMemory(
@@ -2985,7 +2963,7 @@
     State.Images[image] = null
 }
 
-cmd VkResult vkGetImageSubresourceLayout(
+cmd void vkGetImageSubresourceLayout(
         VkDevice                                    device,
         VkImage                                     image,
         const VkImageSubresource*                   pSubresource,
@@ -2993,8 +2971,6 @@
     deviceObject := GetDevice(device)
     imageObject := GetImage(image)
     assert(imageObject.device == device)
-
-    return ?
 }
 
 
@@ -3122,6 +3098,7 @@
 cmd VkResult vkGetPipelineCacheData(
         VkDevice                                    device,
         VkPipelineCache                             pipelineCache,
+        platform.size_t                             dataSize,
         void*                                       pData) {
     deviceObject := GetDevice(device)
     pipelineCacheObject := GetPipelineCache(pipelineCache)
@@ -3458,7 +3435,7 @@
     State.RenderPasses[renderPass] = null
 }
 
-cmd VkResult vkGetRenderAreaGranularity(
+cmd void vkGetRenderAreaGranularity(
         VkDevice                                    device,
         VkRenderPass                                renderPass,
         VkExtent2D*                                 pGranularity) {
@@ -3467,8 +3444,6 @@
 
     granularity := ?
     pGranularity[0] = granularity
-
-    return ?
 }
 
 // Command pool functions
diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
index 124d088..eb427f8 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, 177, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(0, 179, 0)
 
 
 #if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
@@ -152,7 +152,8 @@
     VK_ERROR_MEMORY_MAP_FAILED = -5,
     VK_ERROR_LAYER_NOT_PRESENT = -6,
     VK_ERROR_EXTENSION_NOT_PRESENT = -7,
-    VK_ERROR_INCOMPATIBLE_DRIVER = -8,
+    VK_ERROR_FEATURE_NOT_PRESENT = -8,
+    VK_ERROR_INCOMPATIBLE_DRIVER = -9,
     VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_DRIVER,
     VK_RESULT_END_RANGE = VK_INCOMPLETE,
     VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1),
@@ -2099,12 +2100,12 @@
 typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
 typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance);
 typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
 typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
 typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
 typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
@@ -2113,7 +2114,7 @@
 typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
 typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties);
 typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
-typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
 typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
 typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
 typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
@@ -2123,13 +2124,13 @@
 typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
 typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
 typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
-typedef VkResult (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+typedef void (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
 typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
 typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
-typedef VkResult (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
-typedef VkResult (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
-typedef VkResult (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
 typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
 typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
 typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
@@ -2156,7 +2157,7 @@
 typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView);
 typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
 typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image);
-typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
 typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
 typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView);
 typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
@@ -2166,7 +2167,7 @@
 typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
 typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache);
 typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache);
-typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData);
+typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData);
 typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
 typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
 typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
@@ -2187,7 +2188,7 @@
 typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer);
 typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
 typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass);
-typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
 typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
 typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool);
 typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
@@ -2254,16 +2255,16 @@
     uint32_t*                                   pPhysicalDeviceCount,
     VkPhysicalDevice*                           pPhysicalDevices);
 
-VkResult VKAPI vkGetPhysicalDeviceFeatures(
+void VKAPI vkGetPhysicalDeviceFeatures(
     VkPhysicalDevice                            physicalDevice,
     VkPhysicalDeviceFeatures*                   pFeatures);
 
-VkResult VKAPI vkGetPhysicalDeviceFormatProperties(
+void VKAPI vkGetPhysicalDeviceFormatProperties(
     VkPhysicalDevice                            physicalDevice,
     VkFormat                                    format,
     VkFormatProperties*                         pFormatProperties);
 
-VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
+void VKAPI vkGetPhysicalDeviceImageFormatProperties(
     VkPhysicalDevice                            physicalDevice,
     VkFormat                                    format,
     VkImageType                                 type,
@@ -2272,16 +2273,16 @@
     VkImageCreateFlags                          flags,
     VkImageFormatProperties*                    pImageFormatProperties);
 
-VkResult VKAPI vkGetPhysicalDeviceProperties(
+void VKAPI vkGetPhysicalDeviceProperties(
     VkPhysicalDevice                            physicalDevice,
     VkPhysicalDeviceProperties*                 pProperties);
 
-VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
+void VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
     VkPhysicalDevice                            physicalDevice,
     uint32_t*                                   pCount,
     VkQueueFamilyProperties*                    pQueueFamilyProperties);
 
-VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
+void VKAPI vkGetPhysicalDeviceMemoryProperties(
     VkPhysicalDevice                            physicalDevice,
     VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
 
@@ -2321,7 +2322,7 @@
     uint32_t*                                   pCount,
     VkLayerProperties*                          pProperties);
 
-VkResult VKAPI vkGetDeviceQueue(
+void VKAPI vkGetDeviceQueue(
     VkDevice                                    device,
     uint32_t                                    queueFamilyIndex,
     uint32_t                                    queueIndex,
@@ -2370,7 +2371,7 @@
     uint32_t                                    memRangeCount,
     const VkMappedMemoryRange*                  pMemRanges);
 
-VkResult VKAPI vkGetDeviceMemoryCommitment(
+void VKAPI vkGetDeviceMemoryCommitment(
     VkDevice                                    device,
     VkDeviceMemory                              memory,
     VkDeviceSize*                               pCommittedMemoryInBytes);
@@ -2387,23 +2388,23 @@
     VkDeviceMemory                              mem,
     VkDeviceSize                                memOffset);
 
-VkResult VKAPI vkGetBufferMemoryRequirements(
+void VKAPI vkGetBufferMemoryRequirements(
     VkDevice                                    device,
     VkBuffer                                    buffer,
     VkMemoryRequirements*                       pMemoryRequirements);
 
-VkResult VKAPI vkGetImageMemoryRequirements(
+void VKAPI vkGetImageMemoryRequirements(
     VkDevice                                    device,
     VkImage                                     image,
     VkMemoryRequirements*                       pMemoryRequirements);
 
-VkResult VKAPI vkGetImageSparseMemoryRequirements(
+void VKAPI vkGetImageSparseMemoryRequirements(
     VkDevice                                    device,
     VkImage                                     image,
     uint32_t*                                   pNumRequirements,
     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
 
-VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
     VkPhysicalDevice                            physicalDevice,
     VkFormat                                    format,
     VkImageType                                 type,
@@ -2539,7 +2540,7 @@
     VkDevice                                    device,
     VkImage                                     image);
 
-VkResult VKAPI vkGetImageSubresourceLayout(
+void VKAPI vkGetImageSubresourceLayout(
     VkDevice                                    device,
     VkImage                                     image,
     const VkImageSubresource*                   pSubresource,
@@ -2588,6 +2589,7 @@
 VkResult VKAPI vkGetPipelineCacheData(
     VkDevice                                    device,
     VkPipelineCache                             pipelineCache,
+    size_t                                      dataSize,
     void*                                       pData);
 
 VkResult VKAPI vkMergePipelineCaches(
@@ -2693,7 +2695,7 @@
     VkDevice                                    device,
     VkRenderPass                                renderPass);
 
-VkResult VKAPI vkGetRenderAreaGranularity(
+void VKAPI vkGetRenderAreaGranularity(
     VkDevice                                    device,
     VkRenderPass                                renderPass,
     VkExtent2D*                                 pGranularity);
diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
index 4027f9a..b7c4848 100644
--- a/vulkan/libvulkan/entry.cpp
+++ b/vulkan/libvulkan/entry.cpp
@@ -67,33 +67,33 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
-    return GetVtbl(physicalDevice).GetPhysicalDeviceProperties(physicalDevice, pProperties);
+void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
+    GetVtbl(physicalDevice).GetPhysicalDeviceProperties(physicalDevice, pProperties);
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
-    return GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
+void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
+    GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
-    return GetVtbl(physicalDevice).GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
+    GetVtbl(physicalDevice).GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
-    return GetVtbl(physicalDevice).GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
+    GetVtbl(physicalDevice).GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
-    return GetVtbl(physicalDevice).GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
+    GetVtbl(physicalDevice).GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
-    return GetVtbl(physicalDevice).GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+void vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+    GetVtbl(physicalDevice).GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
 }
 
 __attribute__((visibility("default")))
@@ -127,8 +127,8 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
-    return vulkan::GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
+    vulkan::GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
 }
 
 __attribute__((visibility("default")))
@@ -177,13 +177,13 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
-    return GetVtbl(device).GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
+    GetVtbl(device).GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
-    return GetVtbl(device).GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
+    GetVtbl(device).GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
 }
 
 __attribute__((visibility("default")))
@@ -192,8 +192,8 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
-    return GetVtbl(device).GetImageMemoryRequirements(device, image, pMemoryRequirements);
+void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
+    GetVtbl(device).GetImageMemoryRequirements(device, image, pMemoryRequirements);
 }
 
 __attribute__((visibility("default")))
@@ -202,13 +202,13 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
-    return GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
+void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+    GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
-    return GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
+void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
+    GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
 }
 
 __attribute__((visibility("default")))
@@ -342,8 +342,8 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
-    return GetVtbl(device).GetImageSubresourceLayout(device, image, pSubresource, pLayout);
+void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+    GetVtbl(device).GetImageSubresourceLayout(device, image, pSubresource, pLayout);
 }
 
 __attribute__((visibility("default")))
@@ -392,8 +392,8 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData) {
-    return GetVtbl(device).GetPipelineCacheData(device, pipelineCache, pData);
+VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData) {
+    return GetVtbl(device).GetPipelineCacheData(device, pipelineCache, dataSize, pData);
 }
 
 __attribute__((visibility("default")))
@@ -497,8 +497,8 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
-    return GetVtbl(device).GetRenderAreaGranularity(device, renderPass, pGranularity);
+void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+    GetVtbl(device).GetRenderAreaGranularity(device, renderPass, pGranularity);
 }
 
 __attribute__((visibility("default")))
diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
index fe33114..ba2f5cf 100644
--- a/vulkan/libvulkan/loader.cpp
+++ b/vulkan/libvulkan/loader.cpp
@@ -649,21 +649,19 @@
     return VK_SUCCESS;
 }
 
-VkResult GetPhysicalDeviceFeaturesBottom(VkPhysicalDevice pdev,
-                                         VkPhysicalDeviceFeatures* features) {
-    return GetVtbl(pdev)
-        ->instance->drv.vtbl.GetPhysicalDeviceFeatures(pdev, features);
+void GetPhysicalDeviceFeaturesBottom(VkPhysicalDevice pdev,
+                                     VkPhysicalDeviceFeatures* features) {
+    GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceFeatures(pdev, features);
 }
 
-VkResult GetPhysicalDeviceFormatPropertiesBottom(
-    VkPhysicalDevice pdev,
-    VkFormat format,
-    VkFormatProperties* properties) {
-    return GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceFormatProperties(
+void GetPhysicalDeviceFormatPropertiesBottom(VkPhysicalDevice pdev,
+                                             VkFormat format,
+                                             VkFormatProperties* properties) {
+    GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceFormatProperties(
         pdev, format, properties);
 }
 
-VkResult GetPhysicalDeviceImageFormatPropertiesBottom(
+void GetPhysicalDeviceImageFormatPropertiesBottom(
     VkPhysicalDevice pdev,
     VkFormat format,
     VkImageType type,
@@ -671,31 +669,28 @@
     VkImageUsageFlags usage,
     VkImageCreateFlags flags,
     VkImageFormatProperties* properties) {
-    return GetVtbl(pdev)
-        ->instance->drv.vtbl.GetPhysicalDeviceImageFormatProperties(
-            pdev, format, type, tiling, usage, flags, properties);
+    GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceImageFormatProperties(
+        pdev, format, type, tiling, usage, flags, properties);
 }
 
-VkResult GetPhysicalDevicePropertiesBottom(
-    VkPhysicalDevice pdev,
-    VkPhysicalDeviceProperties* properties) {
-    return GetVtbl(pdev)
+void GetPhysicalDevicePropertiesBottom(VkPhysicalDevice pdev,
+                                       VkPhysicalDeviceProperties* properties) {
+    GetVtbl(pdev)
         ->instance->drv.vtbl.GetPhysicalDeviceProperties(pdev, properties);
 }
 
-VkResult GetPhysicalDeviceQueueFamilyPropertiesBottom(
+void GetPhysicalDeviceQueueFamilyPropertiesBottom(
     VkPhysicalDevice pdev,
     uint32_t* pCount,
     VkQueueFamilyProperties* properties) {
-    return GetVtbl(pdev)
-        ->instance->drv.vtbl.GetPhysicalDeviceQueueFamilyProperties(
-            pdev, pCount, properties);
+    GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceQueueFamilyProperties(
+        pdev, pCount, properties);
 }
 
-VkResult GetPhysicalDeviceMemoryPropertiesBottom(
+void GetPhysicalDeviceMemoryPropertiesBottom(
     VkPhysicalDevice pdev,
     VkPhysicalDeviceMemoryProperties* properties) {
-    return GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceMemoryProperties(
+    GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceMemoryProperties(
         pdev, properties);
 }
 
@@ -815,7 +810,7 @@
         pdev, properties_count, properties);
 }
 
-VkResult GetPhysicalDeviceSparseImageFormatPropertiesBottom(
+void GetPhysicalDeviceSparseImageFormatPropertiesBottom(
     VkPhysicalDevice pdev,
     VkFormat format,
     VkImageType type,
@@ -824,7 +819,7 @@
     VkImageTiling tiling,
     uint32_t* properties_count,
     VkSparseImageFormatProperties* properties) {
-    return GetVtbl(pdev)
+    GetVtbl(pdev)
         ->instance->drv.vtbl.GetPhysicalDeviceSparseImageFormatProperties(
             pdev, format, type, samples, usage, tiling, properties_count,
             properties);
@@ -1061,25 +1056,20 @@
     return GetSpecificDeviceProcAddr(GetVtbl(device), name);
 }
 
-VkResult GetDeviceQueue(VkDevice drv_device,
-                        uint32_t family,
-                        uint32_t index,
-                        VkQueue* out_queue) {
+void GetDeviceQueue(VkDevice drv_device,
+                    uint32_t family,
+                    uint32_t index,
+                    VkQueue* out_queue) {
     VkResult result;
     VkQueue queue;
     const DeviceVtbl* vtbl = GetVtbl(drv_device);
-    result = vtbl->GetDeviceQueue(drv_device, family, index, &queue);
-    if (result != VK_SUCCESS)
-        return result;
+    vtbl->GetDeviceQueue(drv_device, family, index, &queue);
     hwvulkan_dispatch_t* dispatch =
         reinterpret_cast<hwvulkan_dispatch_t*>(queue);
-    if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC && dispatch->vtbl != vtbl) {
+    if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC && dispatch->vtbl != vtbl)
         ALOGE("invalid VkQueue dispatch magic: 0x%" PRIxPTR, dispatch->magic);
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
     dispatch->vtbl = vtbl;
     *out_queue = queue;
-    return VK_SUCCESS;
 }
 
 VkResult CreateCommandBuffer(VkDevice drv_device,
diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
index 1ffbdd5..fcaec61 100644
--- a/vulkan/libvulkan/loader.h
+++ b/vulkan/libvulkan/loader.h
@@ -221,10 +221,10 @@
                         VkInstance* instance);
 PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name);
 PFN_vkVoidFunction GetDeviceProcAddr(VkDevice drv_device, const char* name);
-VkResult GetDeviceQueue(VkDevice drv_device,
-                        uint32_t family,
-                        uint32_t index,
-                        VkQueue* out_queue);
+void GetDeviceQueue(VkDevice drv_device,
+                    uint32_t family,
+                    uint32_t index,
+                    VkQueue* out_queue);
 VkResult CreateCommandBuffer(VkDevice device,
                              const VkCmdBufferCreateInfo* create_info,
                              VkCmdBuffer* out_cmdbuf);
diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
index 53c13a9..02d9515 100644
--- a/vulkan/libvulkan/swapchain.cpp
+++ b/vulkan/libvulkan/swapchain.cpp
@@ -311,8 +311,7 @@
     std::shared_ptr<ANativeWindow> window = InitSharedPtr(
         device, static_cast<ANativeWindow*>(
                     reinterpret_cast<const VkSurfaceDescriptionWindowKHR*>(
-                        create_info->pSurfaceDescription)
-                        ->pPlatformWindow));
+                        create_info->pSurfaceDescription)->pPlatformWindow));
 
     // TODO(jessehall): Create and use NATIVE_WINDOW_API_VULKAN.
     err = native_window_api_connect(window.get(), NATIVE_WINDOW_API_EGL);
diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
index 8992db4..0d1b468 100644
--- a/vulkan/nulldrv/null_driver.cpp
+++ b/vulkan/nulldrv/null_driver.cpp
@@ -265,8 +265,8 @@
     return VK_SUCCESS;
 }
 
-VkResult GetPhysicalDeviceProperties(VkPhysicalDevice,
-                                     VkPhysicalDeviceProperties* properties) {
+void GetPhysicalDeviceProperties(VkPhysicalDevice,
+                                 VkPhysicalDeviceProperties* properties) {
     properties->apiVersion = VK_API_VERSION;
     properties->driverVersion = VK_MAKE_VERSION(0, 0, 1);
     properties->vendorId = 0;
@@ -275,26 +275,22 @@
     strcpy(properties->deviceName, "Android Vulkan Null Driver");
     memset(properties->pipelineCacheUUID, 0,
            sizeof(properties->pipelineCacheUUID));
-    return VK_SUCCESS;
 }
 
-VkResult GetPhysicalDeviceQueueFamilyProperties(
+void GetPhysicalDeviceQueueFamilyProperties(
     VkPhysicalDevice,
     uint32_t* count,
     VkQueueFamilyProperties* properties) {
     if (properties) {
-        if (*count < 1)
-            return VK_INCOMPLETE;
         properties->queueFlags =
             VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_DMA_BIT;
         properties->queueCount = 1;
         properties->timestampValidBits = 64;
     }
     *count = 1;
-    return VK_SUCCESS;
 }
 
-VkResult GetPhysicalDeviceMemoryProperties(
+void GetPhysicalDeviceMemoryProperties(
     VkPhysicalDevice,
     VkPhysicalDeviceMemoryProperties* properties) {
     properties->memoryTypeCount = 1;
@@ -304,7 +300,6 @@
     properties->memoryHeapCount = 1;
     properties->memoryHeaps[0].size = kMaxDeviceMemory;
     properties->memoryHeaps[0].flags = VK_MEMORY_HEAP_HOST_LOCAL_BIT;
-    return VK_SUCCESS;
 }
 
 // -----------------------------------------------------------------------------
@@ -337,9 +332,8 @@
     alloc->pfnFree(alloc->pUserData, device);
 }
 
-VkResult GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
+void GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
     *queue = &device->queue;
-    return VK_SUCCESS;
 }
 
 // -----------------------------------------------------------------------------
@@ -443,14 +437,13 @@
     return VK_SUCCESS;
 }
 
-VkResult GetBufferMemoryRequirements(VkDevice,
-                                     VkBuffer buffer_handle,
-                                     VkMemoryRequirements* requirements) {
+void GetBufferMemoryRequirements(VkDevice,
+                                 VkBuffer buffer_handle,
+                                 VkMemoryRequirements* requirements) {
     Buffer* buffer = GetObjectFromHandle(buffer_handle);
     requirements->size = buffer->size;
     requirements->alignment = 16;  // allow fast Neon/SSE memcpy
     requirements->memoryTypeBits = 0x1;
-    return VK_SUCCESS;
 }
 
 void DestroyBuffer(VkDevice device, VkBuffer buffer_handle) {
@@ -502,14 +495,13 @@
     return VK_SUCCESS;
 }
 
-VkResult GetImageMemoryRequirements(VkDevice,
-                                    VkImage image_handle,
-                                    VkMemoryRequirements* requirements) {
+void GetImageMemoryRequirements(VkDevice,
+                                VkImage image_handle,
+                                VkMemoryRequirements* requirements) {
     Image* image = GetObjectFromHandle(image_handle);
     requirements->size = image->size;
     requirements->alignment = 16;  // allow fast Neon/SSE memcpy
     requirements->memoryTypeBits = 0x1;
-    return VK_SUCCESS;
 }
 
 void DestroyImage(VkDevice device, VkImage image_handle) {
@@ -690,19 +682,16 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
 
-VkResult GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
+void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
     ALOGV("TODO: vk%s", __FUNCTION__);
-    return VK_SUCCESS;
 }
 
-VkResult GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
+void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
     ALOGV("TODO: vk%s", __FUNCTION__);
-    return VK_SUCCESS;
 }
 
-VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+void GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
     ALOGV("TODO: vk%s", __FUNCTION__);
-    return VK_SUCCESS;
 }
 
 VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
@@ -747,9 +736,8 @@
     return VK_SUCCESS;
 }
 
-VkResult GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
+void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
     ALOGV("TODO: vk%s", __FUNCTION__);
-    return VK_SUCCESS;
 }
 
 VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) {
@@ -760,14 +748,12 @@
     return VK_SUCCESS;
 }
 
-VkResult GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
     ALOGV("TODO: vk%s", __FUNCTION__);
-    return VK_SUCCESS;
 }
 
-VkResult GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
+void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
     ALOGV("TODO: vk%s", __FUNCTION__);
-    return VK_SUCCESS;
 }
 
 VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
@@ -842,9 +828,8 @@
 void DestroyBufferView(VkDevice device, VkBufferView bufferView) {
 }
 
-VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
     ALOGV("TODO: vk%s", __FUNCTION__);
-    return VK_SUCCESS;
 }
 
 void DestroyImageView(VkDevice device, VkImageView imageView) {
@@ -864,7 +849,7 @@
     return VK_SUCCESS;
 }
 
-VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData) {
+VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData) {
     ALOGV("TODO: vk%s", __FUNCTION__);
     return VK_SUCCESS;
 }
@@ -909,9 +894,8 @@
 void DestroyRenderPass(VkDevice device, VkRenderPass renderPass) {
 }
 
-VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
     ALOGV("TODO: vk%s", __FUNCTION__);
-    return VK_SUCCESS;
 }
 
 void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool) {
diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
index 4940148..2679777 100644
--- a/vulkan/nulldrv/null_driver.h
+++ b/vulkan/nulldrv/null_driver.h
@@ -29,12 +29,12 @@
 // clang-format off
 void DestroyInstance(VkInstance instance);
 VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
-VkResult GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
-VkResult GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
-VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
-VkResult GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
-VkResult GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
-VkResult GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+void GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+void GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+void GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
 PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
 PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
 VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
@@ -43,7 +43,7 @@
 VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
 VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties);
 VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
-VkResult GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
 VkResult QueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
 VkResult QueueWaitIdle(VkQueue queue);
 VkResult DeviceWaitIdle(VkDevice device);
@@ -53,13 +53,13 @@
 void UnmapMemory(VkDevice device, VkDeviceMemory mem);
 VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
 VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
-VkResult GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
 VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
 VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
-VkResult GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
-VkResult GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
-VkResult GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
-VkResult GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+void GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+void GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
 VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
 VkResult QueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
 VkResult QueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
@@ -86,7 +86,7 @@
 void DestroyBufferView(VkDevice device, VkBufferView bufferView);
 VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
 void DestroyImage(VkDevice device, VkImage image);
-VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
 VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
 void DestroyImageView(VkDevice device, VkImageView imageView);
 VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
@@ -96,7 +96,7 @@
 VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
 void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache);
 size_t GetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache);
-VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData);
+VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData);
 VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
 VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
 VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
@@ -117,7 +117,7 @@
 void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer);
 VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
 void DestroyRenderPass(VkDevice device, VkRenderPass renderPass);
-VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
 VkResult CreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
 void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool);
 VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
index 7f6ae8e..e86a795 100644
--- a/vulkan/nulldrv/null_driver_gen.cpp
+++ b/vulkan/nulldrv/null_driver_gen.cpp
@@ -31,7 +31,7 @@
 };
 
 template <size_t N>
-PFN_vkVoidFunction LookupProcAddr(const NameProcEntry (&table)[N],
+PFN_vkVoidFunction LookupProcAddr(const NameProcEntry(&table)[N],
                                   const char* name) {
     auto entry = std::lower_bound(table, table + N, name,
                                   [](const NameProcEntry& e, const char* n) {
diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
index 2af04ad..50c3789 100644
--- a/vulkan/tools/vkinfo.cpp
+++ b/vulkan/tools/vkinfo.cpp
@@ -90,9 +90,7 @@
     std::ostringstream strbuf;
 
     VkPhysicalDeviceProperties props;
-    result = vkGetPhysicalDeviceProperties(pdev, &props);
-    if (result != VK_SUCCESS)
-        die("vkGetPhysicalDeviceProperties", result);
+    vkGetPhysicalDeviceProperties(pdev, &props);
     printf("  %u: \"%s\" (%s) %u.%u.%u/%#x [%04x:%04x]\n", idx,
            props.deviceName, VkPhysicalDeviceTypeStr(props.deviceType),
            (props.apiVersion >> 22) & 0x3FF, (props.apiVersion >> 12) & 0x3FF,
@@ -100,9 +98,7 @@
            props.deviceId);
 
     VkPhysicalDeviceMemoryProperties mem_props;
-    result = vkGetPhysicalDeviceMemoryProperties(pdev, &mem_props);
-    if (result != VK_SUCCESS)
-        die("vkGetPhysicalDeviceMemoryProperties", result);
+    vkGetPhysicalDeviceMemoryProperties(pdev, &mem_props);
     for (uint32_t heap = 0; heap < mem_props.memoryHeapCount; heap++) {
         if ((mem_props.memoryHeaps[heap].flags &
              VK_MEMORY_HEAP_HOST_LOCAL_BIT) != 0)
@@ -132,16 +128,12 @@
     }
 
     uint32_t num_queue_families;
-    result = vkGetPhysicalDeviceQueueFamilyProperties(pdev, &num_queue_families,
-                                                      nullptr);
-    if (result != VK_SUCCESS)
-        die("vkGetPhysicalDeviceQueueFamilyProperties (count)", result);
+    vkGetPhysicalDeviceQueueFamilyProperties(pdev, &num_queue_families,
+                                             nullptr);
     std::vector<VkQueueFamilyProperties> queue_family_properties(
         num_queue_families);
-    result = vkGetPhysicalDeviceQueueFamilyProperties(
-        pdev, &num_queue_families, queue_family_properties.data());
-    if (result != VK_SUCCESS)
-        die("vkGetPhysicalDeviceQueueFamilyProperties (values)", result);
+    vkGetPhysicalDeviceQueueFamilyProperties(pdev, &num_queue_families,
+                                             queue_family_properties.data());
     for (uint32_t family = 0; family < num_queue_families; family++) {
         const VkQueueFamilyProperties& qprops = queue_family_properties[family];
         const char* sep = "";