diff --git a/include/vk_platform.h b/include/vk_platform.h
index 90db1b2..8832097 100644
--- a/include/vk_platform.h
+++ b/include/vk_platform.h
@@ -77,7 +77,7 @@
 #endif // !defined(VK_NO_STDINT_H)
 
 typedef uint64_t   VkDeviceSize;
-typedef uint32_t   bool32_t;
+typedef uint32_t   VkBool32;
 
 typedef uint32_t   VkSampleMask;
 typedef uint32_t   VkFlags;
diff --git a/include/vk_wsi_lunarg.h b/include/vk_wsi_lunarg.h
index 9f95cc3..bbd887d 100644
--- a/include/vk_wsi_lunarg.h
+++ b/include/vk_wsi_lunarg.h
@@ -132,7 +132,7 @@
 
 typedef struct VkPhysicalDeviceQueuePresentPropertiesWSI_
 {
-    bool32_t                                supportsPresent;    // Tells whether the queue supports presenting
+    VkBool32                                supportsPresent;    // Tells whether the queue supports presenting
 } VkPhysicalDeviceQueuePresentPropertiesWSI;
 
 typedef struct VkPresentInfoWSI_
diff --git a/include/vulkan.h b/include/vulkan.h
index 8ef46cc..10265c5 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -1249,64 +1249,64 @@
 
 typedef struct VkPhysicalDeviceFeatures_
 {
-    bool32_t                                    robustBufferAccess;
-    bool32_t                                    fullDrawIndexUint32;
-    bool32_t                                    imageCubeArray;
-    bool32_t                                    independentBlend;
-    bool32_t                                    geometryShader;
-    bool32_t                                    tessellationShader;
-    bool32_t                                    sampleRateShading;
-    bool32_t                                    dualSourceBlend;
-    bool32_t                                    logicOp;
-    bool32_t                                    instancedDrawIndirect;
-    bool32_t                                    depthClip;
-    bool32_t                                    depthBiasClamp;
-    bool32_t                                    fillModeNonSolid;
-    bool32_t                                    depthBounds;
-    bool32_t                                    wideLines;
-    bool32_t                                    largePoints;
-    bool32_t                                    textureCompressionETC2;
-    bool32_t                                    textureCompressionASTC_LDR;
-    bool32_t                                    textureCompressionBC;
-    bool32_t                                    pipelineStatisticsQuery;
-    bool32_t                                    vertexSideEffects;
-    bool32_t                                    tessellationSideEffects;
-    bool32_t                                    geometrySideEffects;
-    bool32_t                                    fragmentSideEffects;
-    bool32_t                                    shaderTessellationPointSize;
-    bool32_t                                    shaderGeometryPointSize;
-    bool32_t                                    shaderTextureGatherExtended;
-    bool32_t                                    shaderStorageImageExtendedFormats;
-    bool32_t                                    shaderStorageImageMultisample;
-    bool32_t                                    shaderStorageBufferArrayConstantIndexing;
-    bool32_t                                    shaderStorageImageArrayConstantIndexing;
-    bool32_t                                    shaderUniformBufferArrayDynamicIndexing;
-    bool32_t                                    shaderSampledImageArrayDynamicIndexing;
-    bool32_t                                    shaderStorageBufferArrayDynamicIndexing;
-    bool32_t                                    shaderStorageImageArrayDynamicIndexing;
-    bool32_t                                    shaderClipDistance;
-    bool32_t                                    shaderCullDistance;
-    bool32_t                                    shaderFloat64;
-    bool32_t                                    shaderInt64;
-    bool32_t                                    shaderFloat16;
-    bool32_t                                    shaderInt16;
-    bool32_t                                    shaderResourceResidency;
-    bool32_t                                    shaderResourceMinLOD;
-    bool32_t                                    sparse;
-    bool32_t                                    sparseResidencyBuffer;
-    bool32_t                                    sparseResidencyImage2D;
-    bool32_t                                    sparseResidencyImage3D;
-    bool32_t                                    sparseResidency2Samples;
-    bool32_t                                    sparseResidency4Samples;
-    bool32_t                                    sparseResidency8Samples;
-    bool32_t                                    sparseResidency16Samples;
-    bool32_t                                    sparseResidencyStandard2DBlockShape;
-    bool32_t                                    sparseResidencyStandard2DMSBlockShape;
-    bool32_t                                    sparseResidencyStandard3DBlockShape;
-    bool32_t                                    sparseResidencyAlignedMipSize;
-    bool32_t                                    sparseResidencyNonResident;
-    bool32_t                                    sparseResidencyNonResidentStrict;
-    bool32_t                                    sparseResidencyAliased;
+    VkBool32                                    robustBufferAccess;
+    VkBool32                                    fullDrawIndexUint32;
+    VkBool32                                    imageCubeArray;
+    VkBool32                                    independentBlend;
+    VkBool32                                    geometryShader;
+    VkBool32                                    tessellationShader;
+    VkBool32                                    sampleRateShading;
+    VkBool32                                    dualSourceBlend;
+    VkBool32                                    logicOp;
+    VkBool32                                    instancedDrawIndirect;
+    VkBool32                                    depthClip;
+    VkBool32                                    depthBiasClamp;
+    VkBool32                                    fillModeNonSolid;
+    VkBool32                                    depthBounds;
+    VkBool32                                    wideLines;
+    VkBool32                                    largePoints;
+    VkBool32                                    textureCompressionETC2;
+    VkBool32                                    textureCompressionASTC_LDR;
+    VkBool32                                    textureCompressionBC;
+    VkBool32                                    pipelineStatisticsQuery;
+    VkBool32                                    vertexSideEffects;
+    VkBool32                                    tessellationSideEffects;
+    VkBool32                                    geometrySideEffects;
+    VkBool32                                    fragmentSideEffects;
+    VkBool32                                    shaderTessellationPointSize;
+    VkBool32                                    shaderGeometryPointSize;
+    VkBool32                                    shaderTextureGatherExtended;
+    VkBool32                                    shaderStorageImageExtendedFormats;
+    VkBool32                                    shaderStorageImageMultisample;
+    VkBool32                                    shaderStorageBufferArrayConstantIndexing;
+    VkBool32                                    shaderStorageImageArrayConstantIndexing;
+    VkBool32                                    shaderUniformBufferArrayDynamicIndexing;
+    VkBool32                                    shaderSampledImageArrayDynamicIndexing;
+    VkBool32                                    shaderStorageBufferArrayDynamicIndexing;
+    VkBool32                                    shaderStorageImageArrayDynamicIndexing;
+    VkBool32                                    shaderClipDistance;
+    VkBool32                                    shaderCullDistance;
+    VkBool32                                    shaderFloat64;
+    VkBool32                                    shaderInt64;
+    VkBool32                                    shaderFloat16;
+    VkBool32                                    shaderInt16;
+    VkBool32                                    shaderResourceResidency;
+    VkBool32                                    shaderResourceMinLOD;
+    VkBool32                                    sparse;
+    VkBool32                                    sparseResidencyBuffer;
+    VkBool32                                    sparseResidencyImage2D;
+    VkBool32                                    sparseResidencyImage3D;
+    VkBool32                                    sparseResidency2Samples;
+    VkBool32                                    sparseResidency4Samples;
+    VkBool32                                    sparseResidency8Samples;
+    VkBool32                                    sparseResidency16Samples;
+    VkBool32                                    sparseResidencyStandard2DBlockShape;
+    VkBool32                                    sparseResidencyStandard2DMSBlockShape;
+    VkBool32                                    sparseResidencyStandard3DBlockShape;
+    VkBool32                                    sparseResidencyAlignedMipSize;
+    VkBool32                                    sparseResidencyNonResident;
+    VkBool32                                    sparseResidencyNonResidentStrict;
+    VkBool32                                    sparseResidencyAliased;
 } VkPhysicalDeviceFeatures;
 
 typedef struct VkPhysicalDeviceLimits_
@@ -1364,7 +1364,7 @@
     uint32_t                                    mipmapPrecisionBits;
     uint32_t                                    maxDrawIndexedIndexValue;
     uint32_t                                    maxDrawIndirectInstanceCount;
-    bool32_t                                    primitiveRestartForPatches;
+    VkBool32                                    primitiveRestartForPatches;
     float                                       maxSamplerLodBias;
     uint32_t                                    maxSamplerAnisotropy;
     uint32_t                                    maxViewports;
@@ -1494,7 +1494,7 @@
 {
     VkQueueFlags                                queueFlags;                 // Queue flags
     uint32_t                                    queueCount;
-    bool32_t                                    supportsTimestamps;
+    VkBool32                                    supportsTimestamps;
 } VkPhysicalDeviceQueueProperties;
 
 typedef struct VkMemoryType_
@@ -1943,8 +1943,8 @@
     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
     const void*                                 pNext;      // Pointer to next structure
     VkPrimitiveTopology                         topology;
-    bool32_t                                    disableVertexReuse;         // optional
-    bool32_t                                    primitiveRestartEnable;
+    VkBool32                                    disableVertexReuse;         // optional
+    VkBool32                                    primitiveRestartEnable;
     uint32_t                                    primitiveRestartIndex;      // optional (GL45)
 } VkPipelineIaStateCreateInfo;
 
@@ -1968,8 +1968,8 @@
 {
     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
     const void*                                 pNext;      // Pointer to next structure
-    bool32_t                                    depthClipEnable;
-    bool32_t                                    rasterizerDiscardEnable;
+    VkBool32                                    depthClipEnable;
+    VkBool32                                    rasterizerDiscardEnable;
     VkCoordinateOrigin                          pointOrigin;                // optional (GL45)
     VkProvokingVertex                           provokingVertex;            // optional (GL45)
     VkFillMode                                  fillMode;                   // optional (GL45)
@@ -1982,15 +1982,15 @@
     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO
     const void*                                 pNext;      // Pointer to next structure
     uint32_t                                    rasterSamples;
-    bool32_t                                    multisampleEnable;          // optional (GL45)
-    bool32_t                                    sampleShadingEnable;        // optional (GL45)
+    VkBool32                                    multisampleEnable;          // optional (GL45)
+    VkBool32                                    sampleShadingEnable;        // optional (GL45)
     float                                       minSampleShading;           // optional (GL45)
     VkSampleMask                                sampleMask;
 } VkPipelineMsStateCreateInfo;
 
 typedef struct VkPipelineCbAttachmentState_
 {
-    bool32_t                                    blendEnable;
+    VkBool32                                    blendEnable;
     VkFormat                                    format;
     VkBlend                                     srcBlendColor;
     VkBlend                                     destBlendColor;
@@ -2005,8 +2005,8 @@
 {
     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
     const void*                                 pNext;      // Pointer to next structure
-    bool32_t                                    alphaToCoverageEnable;
-    bool32_t                                    logicOpEnable;
+    VkBool32                                    alphaToCoverageEnable;
+    VkBool32                                    logicOpEnable;
     VkLogicOp                                   logicOp;
     uint32_t                                    attachmentCount;    // # of pAttachments
     const VkPipelineCbAttachmentState*          pAttachments;
@@ -2025,11 +2025,11 @@
     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO
     const void*                                 pNext;      // Pointer to next structure
     VkFormat                                    format;
-    bool32_t                                    depthTestEnable;
-    bool32_t                                    depthWriteEnable;
+    VkBool32                                    depthTestEnable;
+    VkBool32                                    depthWriteEnable;
     VkCompareOp                                 depthCompareOp;
-    bool32_t                                    depthBoundsEnable;          // optional (depth_bounds_test)
-    bool32_t                                    stencilTestEnable;
+    VkBool32                                    depthBoundsEnable;          // optional (depth_bounds_test)
+    VkBool32                                    stencilTestEnable;
     VkStencilOpState                            front;
     VkStencilOpState                            back;
 } VkPipelineDsStateCreateInfo;
@@ -2290,7 +2290,7 @@
 typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
 typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
 typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
-typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout);
+typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
 typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
 typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore);
 typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore);
@@ -2357,7 +2357,7 @@
 typedef void     (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
 typedef void     (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
 typedef void     (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void** ppMemBarriers);
-typedef void     (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, bool32_t byRegion, uint32_t memBarrierCount, const void** ppMemBarriers);
+typedef void     (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void** ppMemBarriers);
 typedef void     (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
 typedef void     (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
 typedef void     (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
@@ -2587,7 +2587,7 @@
     VkDevice                                    device,
     uint32_t                                    fenceCount,
     const VkFence*                              pFences,
-    bool32_t                                    waitAll,
+    VkBool32                                    waitAll,
     uint64_t                                    timeout); // timeout in nanoseconds
 
 // Queue semaphore functions
@@ -3019,7 +3019,7 @@
     VkCmdBuffer                                 cmdBuffer,
     VkPipelineStageFlags                        sourceStageMask,
     VkPipelineStageFlags                        destStageMask,
-    bool32_t                                    byRegion,
+    VkBool32                                    byRegion,
     uint32_t                                    memBarrierCount,
     const void**                                ppMemBarriers);
 
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index ff99036..0be0af7 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -361,7 +361,7 @@
     g_lastTouchedCBIndex = g_lastTouchedCBIndex % NUM_COMMAND_BUFFERS_TO_DISPLAY;
     loader_platform_thread_unlock_mutex(&globalLock);
 }
-static bool32_t hasDrawCmd(GLOBAL_CB_NODE* pCB)
+static VkBool32 hasDrawCmd(GLOBAL_CB_NODE* pCB)
 {
     for (uint32_t i=0; i<NUM_DRAW_TYPES; i++) {
         if (pCB->drawCount[i])
@@ -370,7 +370,7 @@
     return VK_FALSE;
 }
 // Check object status for selected flag state
-static bool32_t validate_status(GLOBAL_CB_NODE* pNode, CBStatusFlags enable_mask, CBStatusFlags status_mask, CBStatusFlags status_flag, VkFlags msg_flags, DRAW_STATE_ERROR error_code, const char* fail_msg)
+static VkBool32 validate_status(GLOBAL_CB_NODE* pNode, CBStatusFlags enable_mask, CBStatusFlags status_mask, CBStatusFlags status_flag, VkFlags msg_flags, DRAW_STATE_ERROR error_code, const char* fail_msg)
 {
     // If non-zero enable mask is present, check it against status but if enable_mask
     //  is 0 then no enable required so we should always just check status
@@ -416,8 +416,8 @@
     return pipelineMap[pipeline];
 }
 // Validate state stored as flags at time of draw call
-static bool32_t validate_draw_state_flags(GLOBAL_CB_NODE* pCB, bool32_t indexedDraw) {
-    bool32_t result;
+static VkBool32 validate_draw_state_flags(GLOBAL_CB_NODE* pCB, VkBool32 indexedDraw) {
+    VkBool32 result;
     result = validate_status(pCB, CBSTATUS_NONE, CBSTATUS_VIEWPORT_BOUND, CBSTATUS_VIEWPORT_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_VIEWPORT_NOT_BOUND, "Viewport object not bound to this command buffer");
     result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_RASTER_BOUND,   CBSTATUS_RASTER_BOUND,   VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_RASTER_NOT_BOUND,   "Raster object not bound to this command buffer");
     result &= validate_status(pCB, CBSTATUS_COLOR_BLEND_WRITE_ENABLE, CBSTATUS_COLOR_BLEND_BOUND,   CBSTATUS_COLOR_BLEND_BOUND,   VK_DBG_REPORT_ERROR_BIT,  DRAWSTATE_COLOR_BLEND_NOT_BOUND,   "Color-blend object not bound to this command buffer");
@@ -427,9 +427,9 @@
     return result;
 }
 // Validate overall state at the time of a draw call
-static bool32_t validate_draw_state(GLOBAL_CB_NODE* pCB, bool32_t indexedDraw) {
+static VkBool32 validate_draw_state(GLOBAL_CB_NODE* pCB, VkBool32 indexedDraw) {
     // First check flag states
-    bool32_t result = validate_draw_state_flags(pCB, indexedDraw);
+    VkBool32 result = validate_draw_state_flags(pCB, indexedDraw);
     PIPELINE_NODE* pPipe = getPipeline(pCB->lastBoundPipeline);
     // Now complete other state checks
     if (pPipe && (pCB->lastBoundPipelineLayout != pPipe->graphicsPipelineCI.layout)) {
@@ -455,7 +455,7 @@
     return &sampleMap[sampler]->createInfo;
 }
 // Verify that create state for a pipeline is valid
-static bool32_t verifyPipelineCreateState(const VkDevice device, const PIPELINE_NODE* pPipeline)
+static VkBool32 verifyPipelineCreateState(const VkDevice device, const PIPELINE_NODE* pPipeline)
 {
     // VS is required
     if (!(pPipeline->active_shaders & VK_SHADER_STAGE_VERTEX_BIT)) {
@@ -702,7 +702,7 @@
     return layoutMap[layout];
 }
 // Return 1 if update struct is of valid type, 0 otherwise
-static bool32_t validUpdateStruct(const VkDevice device, const GENERIC_HEADER* pUpdateStruct)
+static VkBool32 validUpdateStruct(const VkDevice device, const GENERIC_HEADER* pUpdateStruct)
 {
     char str[1024];
     switch (pUpdateStruct->sType)
@@ -795,7 +795,7 @@
     return (getBindingStartIndex(pLayout, getUpdateBinding(device, pUpdateStruct))+getUpdateArrayIndex(device, pUpdateStruct)+getUpdateCount(device, pUpdateStruct)-1);
 }
 // Verify that the descriptor type in the update struct matches what's expected by the layout
-static bool32_t validateUpdateType(const VkDevice device, const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct)
+static VkBool32 validateUpdateType(const VkDevice device, const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct)
 {
     // First get actual type of update
     VkDescriptorType actualType;
@@ -859,11 +859,11 @@
     return pNewNode;
 }
 // update DS mappings based on ppUpdateArray
-static bool32_t dsUpdate(VkDevice device, VkStructureType type, uint32_t updateCount, const void* pUpdateArray)
+static VkBool32 dsUpdate(VkDevice device, VkStructureType type, uint32_t updateCount, const void* pUpdateArray)
 {
     const VkWriteDescriptorSet *pWDS = NULL;
     const VkCopyDescriptorSet *pCDS = NULL;
-    bool32_t result = 1;
+    VkBool32 result = 1;
 
     if (type == VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET)
         pWDS = (const VkWriteDescriptorSet *) pUpdateArray;
@@ -1587,7 +1587,7 @@
     //  3. If everything looks good, we'll then create the pipeline and add NODE to pipelineMap
     loader_platform_thread_lock_mutex(&globalLock);
     PIPELINE_NODE* pPipeNode = initPipeline(pCreateInfos, NULL);
-    bool32_t valid = verifyPipelineCreateState(device, pPipeNode);
+    VkBool32 valid = verifyPipelineCreateState(device, pPipeNode);
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_TRUE == valid) {
         result = get_dispatch_table(draw_state_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
@@ -2040,7 +2040,7 @@
 VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
-    bool32_t valid = VK_FALSE;
+    VkBool32 valid = VK_FALSE;
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(cmdBuffer);
@@ -2062,7 +2062,7 @@
 VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
-    bool32_t valid = VK_FALSE;
+    VkBool32 valid = VK_FALSE;
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(cmdBuffer);
@@ -2084,7 +2084,7 @@
 VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
-    bool32_t valid = VK_FALSE;
+    VkBool32 valid = VK_FALSE;
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(cmdBuffer);
@@ -2106,7 +2106,7 @@
 VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
-    bool32_t valid = VK_FALSE;
+    VkBool32 valid = VK_FALSE;
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(cmdBuffer);
@@ -2447,7 +2447,7 @@
     }
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, bool32_t byRegion, uint32_t memBarrierCount, const void** ppMemBarriers)
+VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void** ppMemBarriers)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 5bf41cc..22d6ef3 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -255,10 +255,10 @@
 //   if strict is true, verify that (actual & desired) flags == desired
 //  In case of error, report it via dbg callbacks
 static void validate_usage_flags(void* disp_obj, VkFlags actual, VkFlags desired,
-                                     bool32_t strict, VkObject obj, VkObjectType obj_type,
+                                     VkBool32 strict, VkObject obj, VkObjectType obj_type,
                                      char const* ty_str, char const* func_name, char const* usage_str)
 {
-    bool32_t correct_usage = VK_FALSE;
+    VkBool32 correct_usage = VK_FALSE;
     if (strict)
         correct_usage = ((actual & desired) == desired);
     else
@@ -272,7 +272,7 @@
 // Helper function to validate usage flags for images
 // Pulls image info and then sends actual vs. desired usage off to helper above where
 //  an error will be flagged if usage is not correct
-static void validate_image_usage_flags(void* disp_obj, VkImage image, VkFlags desired, bool32_t strict,
+static void validate_image_usage_flags(void* disp_obj, VkImage image, VkFlags desired, VkBool32 strict,
                                            char const* func_name, char const* usage_string)
 {
     MT_OBJ_INFO* pInfo = get_object_info(image);
@@ -284,7 +284,7 @@
 // Helper function to validate usage flags for buffers
 // Pulls buffer info and then sends actual vs. desired usage off to helper above where
 //  an error will be flagged if usage is not correct
-static void validate_buffer_usage_flags(void* disp_obj, VkBuffer buffer, VkFlags desired, bool32_t strict,
+static void validate_buffer_usage_flags(void* disp_obj, VkBuffer buffer, VkFlags desired, VkBool32 strict,
                                             char const* func_name, char const* usage_string)
 {
     MT_OBJ_INFO* pInfo = get_object_info(buffer);
@@ -328,11 +328,11 @@
 
 // Find CB Info and add mem reference to list container
 // Find Mem Obj Info and add CB reference to list container
-static bool32_t update_cmd_buf_and_mem_references(
+static VkBool32 update_cmd_buf_and_mem_references(
     const VkCmdBuffer    cb,
     const VkDeviceMemory mem)
 {
-    bool32_t result = VK_TRUE;
+    VkBool32 result = VK_TRUE;
     // First update CB binding in MemObj mini CB list
     MT_MEM_OBJ_INFO* pMemInfo = get_mem_obj_info(mem);
     if (!pMemInfo) {
@@ -342,7 +342,7 @@
         result = VK_FALSE;
     } else {
         // Search for cmd buffer object in memory object's binding list
-        bool32_t found  = VK_FALSE;
+        VkBool32 found  = VK_FALSE;
         if (pMemInfo->pCmdBufferBindings.size() > 0) {
             for (list<VkCmdBuffer>::iterator it = pMemInfo->pCmdBufferBindings.begin(); it != pMemInfo->pCmdBufferBindings.end(); ++it) {
                 if ((*it) == cb) {
@@ -366,7 +366,7 @@
             result = VK_FALSE;
         } else {
             // Search for memory object in cmd buffer's reference list
-            bool32_t found  = VK_FALSE;
+            VkBool32 found  = VK_FALSE;
             if (pCBInfo->pMemObjList.size() > 0) {
                 for (list<VkDeviceMemory>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
                     if ((*it) == mem) {
@@ -401,10 +401,10 @@
 }
 
 // Free bindings related to CB
-static bool32_t clear_cmd_buf_and_mem_references(
+static VkBool32 clear_cmd_buf_and_mem_references(
     const VkCmdBuffer cb)
 {
-    bool32_t result = VK_TRUE;
+    VkBool32 result = VK_TRUE;
     MT_CB_INFO* pCBInfo = get_cmd_buf_info(cb);
     if (!pCBInfo) {
         log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_CB, "MEM",
@@ -424,10 +424,10 @@
 
 // Delete CBInfo from list along with all of it's mini MemObjInfo
 //   and also clear mem references to CB
-static bool32_t delete_cmd_buf_info(
+static VkBool32 delete_cmd_buf_info(
     const VkCmdBuffer cb)
 {
-    bool32_t result = VK_TRUE;
+    VkBool32 result = VK_TRUE;
     result = clear_cmd_buf_and_mem_references(cb);
     // Delete the CBInfo info
     if (result == VK_TRUE) {
@@ -437,7 +437,7 @@
 }
 
 // Delete the entire CB list
-static bool32_t delete_cmd_buf_info_list(
+static VkBool32 delete_cmd_buf_info_list(
     void)
 {
     for (unordered_map<VkCmdBuffer, MT_CB_INFO>::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) {
@@ -500,10 +500,10 @@
 }
 
 // Check if fence for given CB is completed
-static bool32_t checkCBCompleted(
+static VkBool32 checkCBCompleted(
     const VkCmdBuffer cb)
 {
-    bool32_t result = VK_TRUE;
+    VkBool32 result = VK_TRUE;
     MT_CB_INFO* pCBInfo = get_cmd_buf_info(cb);
     if (!pCBInfo) {
         log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_CB, "MEM",
@@ -522,12 +522,12 @@
     return result;
 }
 
-static bool32_t freeMemObjInfo(
+static VkBool32 freeMemObjInfo(
     VkObject       object,
     VkDeviceMemory mem,
     bool           internal)
 {
-    bool32_t result = VK_TRUE;
+    VkBool32 result = VK_TRUE;
     // Parse global list to find info w/ mem
     MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem);
     if (!pInfo) {
@@ -575,10 +575,10 @@
 // 1. Remove ObjectInfo from MemObjInfo list container of obj bindings & free it
 // 2. Decrement refCount for MemObjInfo
 // 3. Clear MemObjInfo ptr from ObjectInfo
-static bool32_t clear_object_binding(
+static VkBool32 clear_object_binding(
     VkObject object)
 {
-    bool32_t result = VK_FALSE;
+    VkBool32 result = VK_FALSE;
     MT_OBJ_INFO* pObjInfo = get_object_info(object);
     if (pObjInfo) {
         if (!pObjInfo->pMemObjInfo || pObjInfo->pMemObjInfo->pObjBindings.size() <= 0) {
@@ -614,12 +614,12 @@
 //  device is required for error logging, need a dispatchable
 //  object for that.
 // Return VK_TRUE if addition is successful, VK_FALSE otherwise
-static bool32_t set_object_binding(
+static VkBool32 set_object_binding(
     VkObject       dispatch_object,
     VkObject       object,
     VkDeviceMemory mem)
 {
-    bool32_t result = VK_FALSE;
+    VkBool32 result = VK_FALSE;
     // Handle NULL case separately, just clear previous binding & decrement reference
     if (mem == VK_NULL_HANDLE) {
         log_msg(mdd(dispatch_object), VK_DBG_REPORT_WARN_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM",
@@ -670,11 +670,11 @@
 //  Add reference from objectInfo to memoryInfo
 //  Add reference off of objInfo
 // Return VK_TRUE if addition is successful, VK_FALSE otherwise
-static bool32_t set_sparse_buffer_binding(
+static VkBool32 set_sparse_buffer_binding(
     VkObject       object,
     VkDeviceMemory mem)
 {
-    bool32_t result = VK_FALSE;
+    VkBool32 result = VK_FALSE;
     // Handle NULL case separately, just clear previous binding & decrement reference
     if (mem == VK_NULL_HANDLE) {
         clear_object_binding(object);
@@ -694,7 +694,7 @@
             return VK_FALSE;
         } else {
             // Search for object in memory object's binding list
-            bool32_t found  = VK_FALSE;
+            VkBool32 found  = VK_FALSE;
             if (pInfo->pObjBindings.size() > 0) {
                 for (list<VkObject>::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) {
                     if ((*it) == object) {
@@ -1115,7 +1115,7 @@
      * all API objects referencing it and that it is not referenced by any queued command buffers
      */
     loader_platform_thread_lock_mutex(&globalLock);
-    bool32_t noerror = freeMemObjInfo(device, mem, false);
+    VkBool32 noerror = freeMemObjInfo(device, mem, false);
     print_mem_list(device);
     print_object_list(device);
     printCBList(device);
@@ -1316,7 +1316,7 @@
     VkDevice       device,
     uint32_t       fenceCount,
     const VkFence *pFences,
-    bool32_t       waitAll,
+    VkBool32       waitAll,
     uint64_t       timeout)
 {
     // Verify fence status of submitted fences
diff --git a/layers/object_track.h b/layers/object_track.h
index cc75187..cab7717 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -369,7 +369,7 @@
 }
 
 // Check object status for selected flag state
-static bool32_t
+static VkBool32
 validate_status(
     VkObject            dispatchable_object,
     VkObject            vkObj,
@@ -754,7 +754,7 @@
     VkDevice       device,
     uint32_t       fenceCount,
     const VkFence *pFences,
-    bool32_t       waitAll,
+    VkBool32       waitAll,
     uint64_t       timeout)
 {
     loader_platform_thread_lock_mutex(&objLock);
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 0ee1b7e..3c3361d 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -3213,7 +3213,7 @@
 void PostWaitForFences(
     VkDevice device,
     uint32_t fenceCount,
-    bool32_t waitAll,
+    VkBool32 waitAll,
     uint64_t timeout,
     VkResult result)
 {
@@ -3239,7 +3239,7 @@
     VkDevice device,
     uint32_t fenceCount,
     const VkFence* pFences,
-    bool32_t waitAll,
+    VkBool32 waitAll,
     uint64_t timeout)
 {
     PreWaitForFences(device, pFences);
@@ -8064,7 +8064,7 @@
     VkCmdBuffer cmdBuffer,
     VkPipelineStageFlags sourceStageMask,
     VkPipelineStageFlags destStageMask,
-    bool32_t byRegion,
+    VkBool32 byRegion,
     uint32_t memBarrierCount)
 {
     if(cmdBuffer == nullptr)
@@ -8083,7 +8083,7 @@
     VkCmdBuffer cmdBuffer,
     VkPipelineStageFlags sourceStageMask,
     VkPipelineStageFlags destStageMask,
-    bool32_t byRegion,
+    VkBool32 byRegion,
     uint32_t memBarrierCount,
     const void** ppMemBarriers)
 {
diff --git a/loader/trampoline.c b/loader/trampoline.c
index a7b6037..ebf4f5d 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -519,7 +519,7 @@
     return disp->GetFenceStatus(device, fence);
 }
 
-LOADER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout)
+LOADER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
 {
     const VkLayerDispatchTable *disp;
 
@@ -1128,7 +1128,7 @@
     disp->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers);
 }
 
-LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, bool32_t byRegion, uint32_t memBarrierCount, const void** ppMemBarriers)
+LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void** ppMemBarriers)
 {
     const VkLayerDispatchTable *disp;
 
diff --git a/tests/test_environment.cpp b/tests/test_environment.cpp
index ff0d33c..78bb249 100644
--- a/tests/test_environment.cpp
+++ b/tests/test_environment.cpp
@@ -69,7 +69,7 @@
 
     instance_extension_names.push_back(VK_WSI_LUNARG_EXTENSION_NAME);
 
-    bool32_t extFound;
+    VkBool32 extFound;
 
     instance_extensions = vk_testing::GetGlobalExtensions();
 
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index f6d0a84..a8359c7 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -1239,7 +1239,7 @@
     return VK_SUCCESS;
 }
 
-void VkCommandBufferObj::PipelineBarrier(VkPipelineStageFlags src_stages,  VkPipelineStageFlags dest_stages, bool32_t byRegion, uint32_t memBarrierCount, const void** ppMemBarriers)
+void VkCommandBufferObj::PipelineBarrier(VkPipelineStageFlags src_stages,  VkPipelineStageFlags dest_stages, VkBool32 byRegion, uint32_t memBarrierCount, const void** ppMemBarriers)
 {
     vkCmdPipelineBarrier(obj(), src_stages, dest_stages, byRegion, memBarrierCount, ppMemBarriers);
 }
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
index c0e724d..ffc1891 100644
--- a/tests/vkrenderframework.h
+++ b/tests/vkrenderframework.h
@@ -174,7 +174,7 @@
     VkResult BeginCommandBuffer();
     VkResult BeginCommandBuffer(VkCmdBufferBeginInfo *pInfo);
     VkResult EndCommandBuffer();
-    void PipelineBarrier(VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages, bool32_t byRegion, uint32_t memBarrierCount, const void** ppMemBarriers);
+    void PipelineBarrier(VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages, VkBool32 byRegion, uint32_t memBarrierCount, const void** ppMemBarriers);
     void AddRenderTarget(VkImageObj *renderTarget);
     void AddDepthStencil();
     void ClearAllBuffers(VkClearColorValue clear_color, float depth_clear_color, uint32_t stencil_clear_color, VkDepthStencilObj *depthStencilObj);
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index af55e66..6acbbac 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -134,7 +134,7 @@
                     return ("[%i, %i, %i, %i]", '"[" << %s[0] << "," << %s[1] << "," << %s[2] << "," << %s[3] << "]"' % (name, name, name, name))
                 return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name))
             return ("%f", name)
-        if "bool" in vk_type or 'xcb_randr_crtc_t' in vk_type:
+        if "bool" in vk_type.lower() or 'xcb_randr_crtc_t' in vk_type:
             return ("%u", name)
         if True in [t in vk_type.lower() for t in ["int", "flags", "mask", "xcb_window_t"]]:
             if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
diff --git a/vk_helper.py b/vk_helper.py
index 64b02b9..82ee68c 100755
--- a/vk_helper.py
+++ b/vk_helper.py
@@ -591,7 +591,7 @@
             cast_type = "(void*)"
             if not struct_member['ptr']:
                 cast_type = "(void*)&"
-        elif 'bool' in struct_member['type']:
+        elif 'bool' in struct_member['type'].lower():
             print_type = "s"
             member_post = ' ? "TRUE" : "FALSE"'
         elif 'float' in struct_member['type']:
@@ -1475,7 +1475,7 @@
             cast_type = "(void*)"
             if not struct_member['ptr']:
                 cast_type = "(void*)&"
-        elif 'bool' in struct_member['type']:
+        elif 'bool' in struct_member['type'].lower():
             print_type = "s"
             member_post = ' ? "TRUE" : "FALSE"'
         elif 'float' in struct_member['type']:
diff --git a/vulkan.py b/vulkan.py
index f73942f..2415f3b 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -420,7 +420,7 @@
             [Param("VkDevice", "device"),
              Param("uint32_t", "fenceCount"),
              Param("const VkFence*", "pFences"),
-             Param("bool32_t", "waitAll"),
+             Param("VkBool32", "waitAll"),
              Param("uint64_t", "timeout")]),
 
         Proto("VkResult", "CreateSemaphore",
@@ -824,7 +824,7 @@
             [Param("VkCmdBuffer", "cmdBuffer"),
              Param("VkPipelineStageFlags", "sourceStageMask"),
              Param("VkPipelineStageFlags", "destStageMask"),
-             Param("bool32_t", "byRegion"),
+             Param("VkBool32", "byRegion"),
              Param("uint32_t", "memBarrierCount"),
              Param("const void**", "ppMemBarriers")]),