3 files changed, 664 insertions, 1173 deletions

diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
index 52855120c..067cafb85 100644
--- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp
+++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
@@ -60,22 +60,9 @@ std::string GetDriverVersion(const Device& device) {
     return GetReadableVersion(version);
 }
 
-std::string BuildCommaSeparatedExtensions(std::vector<std::string> available_extensions) {
-    std::sort(std::begin(available_extensions), std::end(available_extensions));
-
-    static constexpr std::size_t AverageExtensionSize = 64;
-    std::string separated_extensions;
-    separated_extensions.reserve(available_extensions.size() * AverageExtensionSize);
-
-    const auto end = std::end(available_extensions);
-    for (auto extension = std::begin(available_extensions); extension != end; ++extension) {
-        if (const bool is_last = extension + 1 == end; is_last) {
-            separated_extensions += *extension;
-        } else {
-            separated_extensions += fmt::format("{},", *extension);
-        }
-    }
-    return separated_extensions;
+std::string BuildCommaSeparatedExtensions(
+    const std::set<std::string, std::less<>>& available_extensions) {
+    return fmt::format("{}", fmt::join(available_extensions, ","));
 }
 
 } // Anonymous namespace
diff --git a/src/video_core/vulkan_common/vulkan_device.cpp b/src/video_core/vulkan_common/vulkan_device.cpp
index fd1c5a683..1458ec4c8 100644
--- a/src/video_core/vulkan_common/vulkan_device.cpp
+++ b/src/video_core/vulkan_common/vulkan_device.cpp
@@ -74,30 +74,6 @@ enum class NvidiaArchitecture {
     VoltaOrOlder,
 };
 
-constexpr std::array REQUIRED_EXTENSIONS{
-    VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME,
-    VK_EXT_ROBUSTNESS_2_EXTENSION_NAME,
-#ifdef _WIN32
-    VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME,
-#endif
-#ifdef __unix__
-    VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME,
-#endif
-};
-
-constexpr std::array REQUIRED_EXTENSIONS_BEFORE_1_2{
-    VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME,
-    VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME,
-    VK_KHR_8BIT_STORAGE_EXTENSION_NAME,
-    VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME,
-    VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME,
-    VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME,
-};
-
-constexpr std::array REQUIRED_EXTENSIONS_BEFORE_1_3{
-    VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME,
-};
-
 template <typename T>
 void SetNext(void**& next, T& data) {
     *next = &data;
@@ -286,24 +262,9 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::Physica
     return format_properties;
 }
 
-std::vector<std::string> GetSupportedExtensions(vk::PhysicalDevice physical) {
-    const std::vector extensions = physical.EnumerateDeviceExtensionProperties();
-    std::vector<std::string> supported_extensions;
-    supported_extensions.reserve(extensions.size());
-    for (const auto& extension : extensions) {
-        supported_extensions.emplace_back(extension.extensionName);
-    }
-    return supported_extensions;
-}
-
-bool IsExtensionSupported(std::span<const std::string> supported_extensions,
-                          std::string_view extension) {
-    return std::ranges::find(supported_extensions, extension) != supported_extensions.end();
-}
-
 NvidiaArchitecture GetNvidiaArchitecture(vk::PhysicalDevice physical,
-                                         std::span<const std::string> exts) {
-    if (IsExtensionSupported(exts, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME)) {
+                                         const std::set<std::string, std::less<>>& exts) {
+    if (exts.contains(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME)) {
         VkPhysicalDeviceFragmentShadingRatePropertiesKHR shading_rate_props{};
         shading_rate_props.sType =
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
@@ -316,423 +277,39 @@ NvidiaArchitecture GetNvidiaArchitecture(vk::PhysicalDevice physical,
             return NvidiaArchitecture::AmpereOrNewer;
         }
     }
-    if (IsExtensionSupported(exts, VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME)) {
+    if (exts.contains(VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME)) {
         return NvidiaArchitecture::Turing;
     }
     return NvidiaArchitecture::VoltaOrOlder;
 }
+
+std::vector<const char*> ExtensionListForVulkan(
+    const std::set<std::string, std::less<>>& extensions) {
+    std::vector<const char*> output;
+    for (const auto& extension : extensions) {
+        output.push_back(extension.c_str());
+    }
+    return output;
+}
+
 } // Anonymous namespace
 
 Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR surface,
                const vk::InstanceDispatch& dld_)
-    : instance{instance_}, dld{dld_}, physical{physical_}, properties{physical.GetProperties()},
-      instance_version{properties.apiVersion}, supported_extensions{GetSupportedExtensions(
-                                                   physical)},
+    : instance{instance_}, dld{dld_}, physical{physical_},
       format_properties(GetFormatProperties(physical)) {
-    CheckSuitability(surface != nullptr);
+    if (!GetSuitability(surface != nullptr)) {
+        throw vk::Exception(VK_ERROR_INCOMPATIBLE_DRIVER);
+    }
     SetupFamilies(surface);
-    SetupFeatures();
-    SetupProperties();
-
     const auto queue_cis = GetDeviceQueueCreateInfos();
-    const std::vector extensions = LoadExtensions(surface != nullptr);
-
-    VkPhysicalDeviceFeatures2 features2{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
-        .pNext = nullptr,
-        .features{
-            .robustBufferAccess = true,
-            .fullDrawIndexUint32 = false,
-            .imageCubeArray = true,
-            .independentBlend = true,
-            .geometryShader = true,
-            .tessellationShader = true,
-            .sampleRateShading = true,
-            .dualSrcBlend = true,
-            .logicOp = true,
-            .multiDrawIndirect = true,
-            .drawIndirectFirstInstance = true,
-            .depthClamp = true,
-            .depthBiasClamp = true,
-            .fillModeNonSolid = true,
-            .depthBounds = is_depth_bounds_supported,
-            .wideLines = true,
-            .largePoints = true,
-            .alphaToOne = false,
-            .multiViewport = true,
-            .samplerAnisotropy = true,
-            .textureCompressionETC2 = false,
-            .textureCompressionASTC_LDR = is_optimal_astc_supported,
-            .textureCompressionBC = false,
-            .occlusionQueryPrecise = true,
-            .pipelineStatisticsQuery = false,
-            .vertexPipelineStoresAndAtomics = true,
-            .fragmentStoresAndAtomics = true,
-            .shaderTessellationAndGeometryPointSize = false,
-            .shaderImageGatherExtended = true,
-            .shaderStorageImageExtendedFormats = false,
-            .shaderStorageImageMultisample = is_shader_storage_image_multisample,
-            .shaderStorageImageReadWithoutFormat = is_formatless_image_load_supported,
-            .shaderStorageImageWriteWithoutFormat = true,
-            .shaderUniformBufferArrayDynamicIndexing = false,
-            .shaderSampledImageArrayDynamicIndexing = false,
-            .shaderStorageBufferArrayDynamicIndexing = false,
-            .shaderStorageImageArrayDynamicIndexing = false,
-            .shaderClipDistance = true,
-            .shaderCullDistance = true,
-            .shaderFloat64 = is_shader_float64_supported,
-            .shaderInt64 = is_shader_int64_supported,
-            .shaderInt16 = is_shader_int16_supported,
-            .shaderResourceResidency = false,
-            .shaderResourceMinLod = false,
-            .sparseBinding = false,
-            .sparseResidencyBuffer = false,
-            .sparseResidencyImage2D = false,
-            .sparseResidencyImage3D = false,
-            .sparseResidency2Samples = false,
-            .sparseResidency4Samples = false,
-            .sparseResidency8Samples = false,
-            .sparseResidency16Samples = false,
-            .sparseResidencyAliased = false,
-            .variableMultisampleRate = false,
-            .inheritedQueries = false,
-        },
-    };
-    const void* first_next = &features2;
-    void** next = &features2.pNext;
-
-    VkPhysicalDeviceTimelineSemaphoreFeatures timeline_semaphore{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
-        .pNext = nullptr,
-        .timelineSemaphore = true,
-    };
-    SetNext(next, timeline_semaphore);
-
-    VkPhysicalDevice16BitStorageFeatures bit16_storage{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
-        .pNext = nullptr,
-        .storageBuffer16BitAccess = true,
-        .uniformAndStorageBuffer16BitAccess = true,
-        .storagePushConstant16 = false,
-        .storageInputOutput16 = false,
-    };
-    SetNext(next, bit16_storage);
-
-    VkPhysicalDevice8BitStorageFeatures bit8_storage{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
-        .pNext = nullptr,
-        .storageBuffer8BitAccess = true,
-        .uniformAndStorageBuffer8BitAccess = true,
-        .storagePushConstant8 = false,
-    };
-    SetNext(next, bit8_storage);
-
-    VkPhysicalDeviceRobustness2FeaturesEXT robustness2{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
-        .pNext = nullptr,
-        .robustBufferAccess2 = true,
-        .robustImageAccess2 = true,
-        .nullDescriptor = true,
-    };
-    SetNext(next, robustness2);
-
-    VkPhysicalDeviceHostQueryResetFeatures host_query_reset{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
-        .pNext = nullptr,
-        .hostQueryReset = true,
-    };
-    SetNext(next, host_query_reset);
-
-    VkPhysicalDeviceVariablePointerFeatures variable_pointers{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
-        .pNext = nullptr,
-        .variablePointersStorageBuffer = VK_TRUE,
-        .variablePointers = VK_TRUE,
-    };
-    SetNext(next, variable_pointers);
-
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures demote{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES,
-        .pNext = nullptr,
-        .shaderDemoteToHelperInvocation = true,
-    };
-    SetNext(next, demote);
-
-    VkPhysicalDeviceShaderDrawParametersFeatures draw_parameters{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES,
-        .pNext = nullptr,
-        .shaderDrawParameters = true,
-    };
-    SetNext(next, draw_parameters);
-
-    VkPhysicalDeviceShaderFloat16Int8Features float16_int8;
-    if (is_int8_supported || is_float16_supported) {
-        float16_int8 = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
-            .pNext = nullptr,
-            .shaderFloat16 = is_float16_supported,
-            .shaderInt8 = is_int8_supported,
-        };
-        SetNext(next, float16_int8);
-    }
-    if (!is_float16_supported) {
-        LOG_INFO(Render_Vulkan, "Device doesn't support float16 natively");
-    }
-    if (!is_int8_supported) {
-        LOG_INFO(Render_Vulkan, "Device doesn't support int8 natively");
-    }
-
-    if (!nv_viewport_swizzle) {
-        LOG_INFO(Render_Vulkan, "Device doesn't support viewport swizzles");
-    }
-
-    if (!nv_viewport_array2) {
-        LOG_INFO(Render_Vulkan, "Device doesn't support viewport masks");
-    }
-
-    if (!nv_geometry_shader_passthrough) {
-        LOG_INFO(Render_Vulkan, "Device doesn't support passthrough geometry shaders");
-    }
-
-    VkPhysicalDeviceUniformBufferStandardLayoutFeatures std430_layout;
-    if (khr_uniform_buffer_standard_layout) {
-        std430_layout = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
-            .pNext = nullptr,
-            .uniformBufferStandardLayout = true,
-        };
-        SetNext(next, std430_layout);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support packed UBOs");
-    }
-
-    VkPhysicalDeviceIndexTypeUint8FeaturesEXT index_type_uint8;
-    if (ext_index_type_uint8) {
-        index_type_uint8 = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
-            .pNext = nullptr,
-            .indexTypeUint8 = true,
-        };
-        SetNext(next, index_type_uint8);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support uint8 indexes");
-    }
-
-    VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT primitive_topology_list_restart;
-    if (is_topology_list_restart_supported || is_patch_list_restart_supported) {
-        primitive_topology_list_restart = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT,
-            .pNext = nullptr,
-            .primitiveTopologyListRestart = is_topology_list_restart_supported,
-            .primitiveTopologyPatchListRestart = is_patch_list_restart_supported,
-        };
-        SetNext(next, primitive_topology_list_restart);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support list topology primitive restart");
-    }
-
-    VkPhysicalDeviceTransformFeedbackFeaturesEXT transform_feedback;
-    if (ext_transform_feedback) {
-        transform_feedback = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
-            .pNext = nullptr,
-            .transformFeedback = true,
-            .geometryStreams = true,
-        };
-        SetNext(next, transform_feedback);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support transform feedbacks");
-    }
-
-    VkPhysicalDeviceCustomBorderColorFeaturesEXT custom_border;
-    if (ext_custom_border_color) {
-        custom_border = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT,
-            .pNext = nullptr,
-            .customBorderColors = VK_TRUE,
-            .customBorderColorWithoutFormat = VK_TRUE,
-        };
-        SetNext(next, custom_border);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support custom border colors");
-    }
-
-    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT dynamic_state;
-    if (ext_extended_dynamic_state) {
-        dynamic_state = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
-            .pNext = nullptr,
-            .extendedDynamicState = VK_TRUE,
-        };
-        SetNext(next, dynamic_state);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support extended dynamic state");
-    }
-
-    VkPhysicalDeviceExtendedDynamicState2FeaturesEXT dynamic_state_2;
-    if (ext_extended_dynamic_state_2) {
-        dynamic_state_2 = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT,
-            .pNext = nullptr,
-            .extendedDynamicState2 = VK_TRUE,
-            .extendedDynamicState2LogicOp = ext_extended_dynamic_state_2_extra ? VK_TRUE : VK_FALSE,
-            .extendedDynamicState2PatchControlPoints = VK_FALSE,
-        };
-        SetNext(next, dynamic_state_2);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support extended dynamic state 2");
-    }
 
-    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT dynamic_state_3;
-    if (ext_extended_dynamic_state_3) {
-        dynamic_state_3 = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
-            .pNext = nullptr,
-            .extendedDynamicState3TessellationDomainOrigin = VK_FALSE,
-            .extendedDynamicState3DepthClampEnable =
-                ext_extended_dynamic_state_3_enables ? VK_TRUE : VK_FALSE,
-            .extendedDynamicState3PolygonMode = VK_FALSE,
-            .extendedDynamicState3RasterizationSamples = VK_FALSE,
-            .extendedDynamicState3SampleMask = VK_FALSE,
-            .extendedDynamicState3AlphaToCoverageEnable = VK_FALSE,
-            .extendedDynamicState3AlphaToOneEnable = VK_FALSE,
-            .extendedDynamicState3LogicOpEnable =
-                ext_extended_dynamic_state_3_enables ? VK_TRUE : VK_FALSE,
-            .extendedDynamicState3ColorBlendEnable =
-                ext_extended_dynamic_state_3_blend ? VK_TRUE : VK_FALSE,
-            .extendedDynamicState3ColorBlendEquation =
-                ext_extended_dynamic_state_3_blend ? VK_TRUE : VK_FALSE,
-            .extendedDynamicState3ColorWriteMask =
-                ext_extended_dynamic_state_3_blend ? VK_TRUE : VK_FALSE,
-            .extendedDynamicState3RasterizationStream = VK_FALSE,
-            .extendedDynamicState3ConservativeRasterizationMode = VK_FALSE,
-            .extendedDynamicState3ExtraPrimitiveOverestimationSize = VK_FALSE,
-            .extendedDynamicState3DepthClipEnable = VK_FALSE,
-            .extendedDynamicState3SampleLocationsEnable = VK_FALSE,
-            .extendedDynamicState3ColorBlendAdvanced = VK_FALSE,
-            .extendedDynamicState3ProvokingVertexMode = VK_FALSE,
-            .extendedDynamicState3LineRasterizationMode = VK_FALSE,
-            .extendedDynamicState3LineStippleEnable = VK_FALSE,
-            .extendedDynamicState3DepthClipNegativeOneToOne = VK_FALSE,
-            .extendedDynamicState3ViewportWScalingEnable = VK_FALSE,
-            .extendedDynamicState3ViewportSwizzle = VK_FALSE,
-            .extendedDynamicState3CoverageToColorEnable = VK_FALSE,
-            .extendedDynamicState3CoverageToColorLocation = VK_FALSE,
-            .extendedDynamicState3CoverageModulationMode = VK_FALSE,
-            .extendedDynamicState3CoverageModulationTableEnable = VK_FALSE,
-            .extendedDynamicState3CoverageModulationTable = VK_FALSE,
-            .extendedDynamicState3CoverageReductionMode = VK_FALSE,
-            .extendedDynamicState3RepresentativeFragmentTestEnable = VK_FALSE,
-            .extendedDynamicState3ShadingRateImageEnable = VK_FALSE,
-        };
-        SetNext(next, dynamic_state_3);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support extended dynamic state 3");
-    }
-
-    VkPhysicalDeviceLineRasterizationFeaturesEXT line_raster;
-    if (ext_line_rasterization) {
-        line_raster = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
-            .pNext = nullptr,
-            .rectangularLines = VK_TRUE,
-            .bresenhamLines = VK_FALSE,
-            .smoothLines = VK_TRUE,
-            .stippledRectangularLines = VK_FALSE,
-            .stippledBresenhamLines = VK_FALSE,
-            .stippledSmoothLines = VK_FALSE,
-        };
-        SetNext(next, line_raster);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support smooth lines");
-    }
-
-    if (!ext_conservative_rasterization) {
-        LOG_INFO(Render_Vulkan, "Device doesn't support conservative rasterization");
-    }
-
-    VkPhysicalDeviceProvokingVertexFeaturesEXT provoking_vertex;
-    if (ext_provoking_vertex) {
-        provoking_vertex = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT,
-            .pNext = nullptr,
-            .provokingVertexLast = VK_TRUE,
-            .transformFeedbackPreservesProvokingVertex = VK_TRUE,
-        };
-        SetNext(next, provoking_vertex);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support provoking vertex last");
-    }
-
-    VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT vertex_input_dynamic;
-    if (ext_vertex_input_dynamic_state) {
-        vertex_input_dynamic = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT,
-            .pNext = nullptr,
-            .vertexInputDynamicState = VK_TRUE,
-        };
-        SetNext(next, vertex_input_dynamic);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support vertex input dynamic state");
-    }
-
-    VkPhysicalDeviceShaderAtomicInt64Features atomic_int64;
-    if (ext_shader_atomic_int64) {
-        atomic_int64 = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
-            .pNext = nullptr,
-            .shaderBufferInt64Atomics = VK_TRUE,
-            .shaderSharedInt64Atomics = VK_TRUE,
-        };
-        SetNext(next, atomic_int64);
-    }
-
-    VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR workgroup_layout;
-    if (khr_workgroup_memory_explicit_layout && is_shader_int16_supported) {
-        workgroup_layout = {
-            .sType =
-                VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR,
-            .pNext = nullptr,
-            .workgroupMemoryExplicitLayout = VK_TRUE,
-            .workgroupMemoryExplicitLayoutScalarBlockLayout = VK_TRUE,
-            .workgroupMemoryExplicitLayout8BitAccess = VK_TRUE,
-            .workgroupMemoryExplicitLayout16BitAccess = VK_TRUE,
-        };
-        SetNext(next, workgroup_layout);
-    } else if (khr_workgroup_memory_explicit_layout) {
-        // TODO(lat9nq): Find a proper fix for this
-        LOG_WARNING(Render_Vulkan, "Disabling VK_KHR_workgroup_memory_explicit_layout due to a "
-                                   "yuzu bug when host driver does not support 16-bit integers");
-        khr_workgroup_memory_explicit_layout = false;
-    }
-
-    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR executable_properties;
-    if (khr_pipeline_executable_properties) {
-        LOG_INFO(Render_Vulkan, "Enabling shader feedback, expect slower shader build times");
-        executable_properties = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
-            .pNext = nullptr,
-            .pipelineExecutableInfo = VK_TRUE,
-        };
-        SetNext(next, executable_properties);
-    }
-
-    if (!ext_depth_range_unrestricted) {
-        LOG_INFO(Render_Vulkan, "Device doesn't support depth range unrestricted");
-    }
-
-    VkPhysicalDeviceDepthClipControlFeaturesEXT depth_clip_control_features;
-    if (ext_depth_clip_control) {
-        depth_clip_control_features = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT,
-            .pNext = nullptr,
-            .depthClipControl = VK_TRUE,
-        };
-        SetNext(next, depth_clip_control_features);
-    }
+    // GetSuitability has already configured the linked list of features for us.
+    // Reuse it here.
+    const void* first_next = &features2;
 
-    VkDeviceDiagnosticsConfigCreateInfoNV diagnostics_nv;
-    if (Settings::values.enable_nsight_aftermath && nv_device_diagnostics_config) {
+    VkDeviceDiagnosticsConfigCreateInfoNV diagnostics_nv{};
+    if (Settings::values.enable_nsight_aftermath && extensions.device_diagnostics_config) {
         nsight_aftermath_tracker = std::make_unique<NsightAftermathTracker>();
 
         diagnostics_nv = {
@@ -744,33 +321,48 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         };
         first_next = &diagnostics_nv;
     }
-    logical = vk::Device::Create(physical, queue_cis, extensions, first_next, dld);
 
-    is_integrated = properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
-    is_virtual = properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU;
-    is_non_gpu = properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_OTHER ||
-                 properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU;
+    is_blit_depth_stencil_supported = TestDepthStencilBlits();
+    is_optimal_astc_supported = ComputeIsOptimalAstcSupported();
+    is_warp_potentially_bigger = !extensions.subgroup_size_control ||
+                                 properties.subgroup_size_control.maxSubgroupSize > GuestWarpSize;
+
+    is_integrated = properties.properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
+    is_virtual = properties.properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU;
+    is_non_gpu = properties.properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_OTHER ||
+                 properties.properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU;
+
+    supports_d24_depth =
+        IsFormatSupported(VK_FORMAT_D24_UNORM_S8_UINT,
+                          VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, FormatType::Optimal);
 
     CollectPhysicalMemoryInfo();
-    CollectTelemetryParameters();
     CollectToolingInfo();
 
-    if (driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR) {
-        const u32 nv_major_version = (properties.driverVersion >> 22) & 0x3ff;
+    const VkDriverId driver_id = properties.driver.driverID;
+    const bool is_radv = driver_id == VK_DRIVER_ID_MESA_RADV;
+    const bool is_amd_driver =
+        driver_id == VK_DRIVER_ID_AMD_PROPRIETARY || driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE;
+    const bool is_amd = is_amd_driver || is_radv;
+    const bool is_intel_windows = driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS;
+    const bool is_intel_anv = driver_id == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA;
+    const bool is_nvidia = driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY;
 
+    if (is_nvidia) {
+        const u32 nv_major_version = (properties.properties.driverVersion >> 22) & 0x3ff;
         const auto arch = GetNvidiaArchitecture(physical, supported_extensions);
         switch (arch) {
         case NvidiaArchitecture::AmpereOrNewer:
-            LOG_WARNING(Render_Vulkan, "Blacklisting Ampere devices from float16 math");
-            is_float16_supported = false;
+            LOG_WARNING(Render_Vulkan, "Ampere and newer have broken float16 math");
+            features.shader_float16_int8.shaderFloat16 = false;
             break;
         case NvidiaArchitecture::Turing:
             break;
         case NvidiaArchitecture::VoltaOrOlder:
             if (nv_major_version < 527) {
-                LOG_WARNING(Render_Vulkan,
-                            "Blacklisting Volta and older from VK_KHR_push_descriptor");
-                khr_push_descriptor = false;
+                LOG_WARNING(Render_Vulkan, "Volta and older have broken VK_KHR_push_descriptor");
+                extensions.push_descriptor = false;
+                loaded_extensions.erase(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
             }
             break;
         }
@@ -779,75 +371,75 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             cant_blit_msaa = true;
         }
     }
-    const bool is_radv = driver_id == VK_DRIVER_ID_MESA_RADV;
-    if (ext_extended_dynamic_state && is_radv) {
+    if (extensions.extended_dynamic_state && is_radv) {
         // Mask driver version variant
-        const u32 version = (properties.driverVersion << 3) >> 3;
+        const u32 version = (properties.properties.driverVersion << 3) >> 3;
         if (version < VK_MAKE_API_VERSION(0, 21, 2, 0)) {
             LOG_WARNING(Render_Vulkan,
                         "RADV versions older than 21.2 have broken VK_EXT_extended_dynamic_state");
-            ext_extended_dynamic_state = false;
+            extensions.extended_dynamic_state = false;
+            loaded_extensions.erase(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
         }
     }
-    if (ext_vertex_input_dynamic_state && is_radv) {
+    if (extensions.extended_dynamic_state2 && is_radv) {
+        const u32 version = (properties.properties.driverVersion << 3) >> 3;
+        if (version < VK_MAKE_API_VERSION(0, 22, 3, 1)) {
+            LOG_WARNING(
+                Render_Vulkan,
+                "RADV versions older than 22.3.1 have broken VK_EXT_extended_dynamic_state2");
+            features.extended_dynamic_state2.extendedDynamicState2 = false;
+            features.extended_dynamic_state2.extendedDynamicState2LogicOp = false;
+            features.extended_dynamic_state2.extendedDynamicState2PatchControlPoints = false;
+            extensions.extended_dynamic_state2 = false;
+            loaded_extensions.erase(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
+        }
+    }
+    if (extensions.vertex_input_dynamic_state && is_radv) {
         // TODO(ameerj): Blacklist only offending driver versions
         // TODO(ameerj): Confirm if RDNA1 is affected
         const bool is_rdna2 =
-            IsExtensionSupported(supported_extensions, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
+            supported_extensions.contains(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
         if (is_rdna2) {
             LOG_WARNING(Render_Vulkan,
                         "RADV has broken VK_EXT_vertex_input_dynamic_state on RDNA2 hardware");
-            ext_vertex_input_dynamic_state = false;
+            extensions.vertex_input_dynamic_state = false;
+            loaded_extensions.erase(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
         }
     }
-    if (ext_extended_dynamic_state_2 && is_radv) {
-        const u32 version = (properties.driverVersion << 3) >> 3;
-        if (version < VK_MAKE_API_VERSION(0, 22, 3, 1)) {
-            LOG_WARNING(
-                Render_Vulkan,
-                "RADV versions older than 22.3.1 have broken VK_EXT_extended_dynamic_state2");
-            ext_extended_dynamic_state_2 = false;
-            ext_extended_dynamic_state_2_extra = false;
-        }
-    }
-    sets_per_pool = 64;
 
-    const bool is_amd =
-        driver_id == VK_DRIVER_ID_AMD_PROPRIETARY || driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE;
-    if (is_amd) {
+    sets_per_pool = 64;
+    if (is_amd_driver) {
         // AMD drivers need a higher amount of Sets per Pool in certain circunstances like in XC2.
         sets_per_pool = 96;
         // Disable VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT on AMD GCN4 and lower as it is broken.
-        if (!is_float16_supported) {
-            LOG_WARNING(
-                Render_Vulkan,
-                "AMD GCN4 and earlier do not properly support VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT");
+        if (!features.shader_float16_int8.shaderFloat16) {
+            LOG_WARNING(Render_Vulkan,
+                        "AMD GCN4 and earlier have broken VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT");
             has_broken_cube_compatibility = true;
         }
     }
-    const bool is_amd_or_radv = is_amd || is_radv;
-    if (ext_sampler_filter_minmax && is_amd_or_radv) {
+    if (extensions.sampler_filter_minmax && is_amd) {
         // Disable ext_sampler_filter_minmax on AMD GCN4 and lower as it is broken.
-        if (!is_float16_supported) {
+        if (!features.shader_float16_int8.shaderFloat16) {
             LOG_WARNING(Render_Vulkan,
-                        "Blacklisting AMD GCN4 and earlier for VK_EXT_sampler_filter_minmax");
-            ext_sampler_filter_minmax = false;
+                        "AMD GCN4 and earlier have broken VK_EXT_sampler_filter_minmax");
+            extensions.sampler_filter_minmax = false;
+            loaded_extensions.erase(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME);
         }
     }
 
-    const bool is_intel_windows = driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS;
-    const bool is_intel_anv = driver_id == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA;
-    if (ext_vertex_input_dynamic_state && is_intel_windows) {
-        const u32 version = (properties.driverVersion << 3) >> 3;
+    if (extensions.vertex_input_dynamic_state && is_intel_windows) {
+        const u32 version = (properties.properties.driverVersion << 3) >> 3;
         if (version < VK_MAKE_API_VERSION(27, 20, 100, 0)) {
-            LOG_WARNING(Render_Vulkan, "Blacklisting Intel for VK_EXT_vertex_input_dynamic_state");
-            ext_vertex_input_dynamic_state = false;
+            LOG_WARNING(Render_Vulkan, "Intel has broken VK_EXT_vertex_input_dynamic_state");
+            extensions.vertex_input_dynamic_state = false;
+            loaded_extensions.erase(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
         }
     }
-    if (is_float16_supported && is_intel_windows) {
+    if (features.shader_float16_int8.shaderFloat16 && is_intel_windows) {
         // Intel's compiler crashes when using fp16 on Astral Chain, disable it for the time being.
-        LOG_WARNING(Render_Vulkan, "Blacklisting Intel proprietary from float16 math");
-        is_float16_supported = false;
+        LOG_WARNING(Render_Vulkan, "Intel has broken float16 math");
+        features.shader_float16_int8.shaderFloat16 = false;
     }
     if (is_intel_windows) {
         LOG_WARNING(Render_Vulkan, "Intel proprietary drivers do not support MSAA image blits");
@@ -858,9 +450,8 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         must_emulate_bgr565 = true;
     }
 
-    supports_d24_depth =
-        IsFormatSupported(VK_FORMAT_D24_UNORM_S8_UINT,
-                          VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, FormatType::Optimal);
+    logical = vk::Device::Create(physical, queue_cis, ExtensionListForVulkan(loaded_extensions),
+                                 first_next, dld);
 
     graphics_queue = logical.GetQueue(graphics_family);
     present_queue = logical.GetQueue(present_family);
@@ -915,7 +506,7 @@ void Device::SaveShader(std::span<const u32> spirv) const {
     }
 }
 
-bool Device::IsOptimalAstcSupported(const VkPhysicalDeviceFeatures& features) const {
+bool Device::ComputeIsOptimalAstcSupported() const {
     // Disable for now to avoid converting ASTC twice.
     static constexpr std::array astc_formats = {
         VK_FORMAT_ASTC_4x4_UNORM_BLOCK,   VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
@@ -933,7 +524,7 @@ bool Device::IsOptimalAstcSupported(const VkPhysicalDeviceFeatures& features) co
         VK_FORMAT_ASTC_12x10_UNORM_BLOCK, VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
         VK_FORMAT_ASTC_12x12_UNORM_BLOCK, VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
     };
-    if (!features.textureCompressionASTC_LDR) {
+    if (!features.features.textureCompressionASTC_LDR) {
         return false;
     }
     const auto format_feature_usage{
@@ -971,7 +562,7 @@ bool Device::IsFormatSupported(VkFormat wanted_format, VkFormatFeatureFlags want
 }
 
 std::string Device::GetDriverName() const {
-    switch (driver_id) {
+    switch (properties.driver.driverID) {
     case VK_DRIVER_ID_AMD_PROPRIETARY:
         return "AMD";
     case VK_DRIVER_ID_AMD_OPEN_SOURCE:
@@ -987,522 +578,336 @@ std::string Device::GetDriverName() const {
     case VK_DRIVER_ID_MESA_LLVMPIPE:
         return "LAVAPIPE";
     default:
-        return vendor_name;
+        return properties.driver.driverName;
     }
 }
 
 bool Device::ShouldBoostClocks() const {
+    const auto driver_id = properties.driver.driverID;
+    const auto vendor_id = properties.properties.vendorID;
+    const auto device_id = properties.properties.deviceID;
+
     const bool validated_driver =
         driver_id == VK_DRIVER_ID_AMD_PROPRIETARY || driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE ||
         driver_id == VK_DRIVER_ID_MESA_RADV || driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY ||
         driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS ||
         driver_id == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA;
 
-    const bool is_steam_deck = properties.vendorID == 0x1002 && properties.deviceID == 0x163F;
+    const bool is_steam_deck = vendor_id == 0x1002 && device_id == 0x163F;
 
     return validated_driver && !is_steam_deck;
 }
 
-static std::vector<const char*> ExtensionsRequiredForInstanceVersion(u32 available_version) {
-    std::vector<const char*> extensions{REQUIRED_EXTENSIONS.begin(), REQUIRED_EXTENSIONS.end()};
+bool Device::GetSuitability(bool requires_swapchain) {
+    // Assume we will be suitable.
+    bool suitable = true;
 
-    if (available_version < VK_API_VERSION_1_2) {
-        extensions.insert(extensions.end(), REQUIRED_EXTENSIONS_BEFORE_1_2.begin(),
-                          REQUIRED_EXTENSIONS_BEFORE_1_2.end());
-    }
-
-    if (available_version < VK_API_VERSION_1_3) {
-        extensions.insert(extensions.end(), REQUIRED_EXTENSIONS_BEFORE_1_3.begin(),
-                          REQUIRED_EXTENSIONS_BEFORE_1_3.end());
-    }
-
-    return extensions;
-}
+    // Configure properties.
+    properties.properties = physical.GetProperties();
 
-void Device::CheckSuitability(bool requires_swapchain) const {
-    std::vector<const char*> required_extensions =
-        ExtensionsRequiredForInstanceVersion(instance_version);
-    std::vector<const char*> available_extensions;
+    // Set instance version.
+    instance_version = properties.properties.apiVersion;
 
-    if (requires_swapchain) {
-        required_extensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
-    }
+    // Minimum of API version 1.1 is required. (This is well-supported.)
+    ASSERT(instance_version >= VK_API_VERSION_1_1);
 
+    // Get available extensions.
     auto extension_properties = physical.EnumerateDeviceExtensionProperties();
 
+    // Get the set of supported extensions.
+    supported_extensions.clear();
     for (const VkExtensionProperties& property : extension_properties) {
-        available_extensions.push_back(property.extensionName);
+        supported_extensions.insert(property.extensionName);
     }
 
-    bool has_all_required_extensions = true;
-    for (const char* requirement_name : required_extensions) {
-        const bool found =
-            std::ranges::any_of(available_extensions, [&](const char* extension_name) {
-                return std::strcmp(requirement_name, extension_name) == 0;
-            });
+    // Generate list of extensions to load.
+    loaded_extensions.clear();
 
-        if (!found) {
-            LOG_ERROR(Render_Vulkan, "Missing required extension: {}", requirement_name);
-            has_all_required_extensions = false;
-        }
+#define EXTENSION(prefix, macro_name, var_name)                                                    \
+    if (supported_extensions.contains(VK_##prefix##_##macro_name##_EXTENSION_NAME)) {              \
+        loaded_extensions.insert(VK_##prefix##_##macro_name##_EXTENSION_NAME);                     \
+        extensions.var_name = true;                                                                \
     }
-
-    if (!has_all_required_extensions) {
-        throw vk::Exception(VK_ERROR_EXTENSION_NOT_PRESENT);
+#define FEATURE_EXTENSION(prefix, struct_name, macro_name, var_name)                               \
+    if (supported_extensions.contains(VK_##prefix##_##macro_name##_EXTENSION_NAME)) {              \
+        loaded_extensions.insert(VK_##prefix##_##macro_name##_EXTENSION_NAME);                     \
+        extensions.var_name = true;                                                                \
     }
 
-    struct LimitTuple {
-        u32 minimum;
-        u32 value;
-        const char* name;
-    };
-    const VkPhysicalDeviceLimits& limits{properties.limits};
-    const std::array limits_report{
-        LimitTuple{65536, limits.maxUniformBufferRange, "maxUniformBufferRange"},
-        LimitTuple{16, limits.maxViewports, "maxViewports"},
-        LimitTuple{8, limits.maxColorAttachments, "maxColorAttachments"},
-        LimitTuple{8, limits.maxClipDistances, "maxClipDistances"},
-    };
-    for (const auto& tuple : limits_report) {
-        if (tuple.value < tuple.minimum) {
-            LOG_ERROR(Render_Vulkan, "{} has to be {} or greater but it is {}", tuple.name,
-                      tuple.minimum, tuple.value);
-            throw vk::Exception(VK_ERROR_FEATURE_NOT_PRESENT);
-        }
+    if (instance_version < VK_API_VERSION_1_2) {
+        FOR_EACH_VK_FEATURE_1_2(FEATURE_EXTENSION);
+    }
+    if (instance_version < VK_API_VERSION_1_3) {
+        FOR_EACH_VK_FEATURE_1_3(FEATURE_EXTENSION);
     }
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures demote{};
-    demote.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
-    demote.pNext = nullptr;
 
-    VkPhysicalDeviceVariablePointerFeatures variable_pointers{};
-    variable_pointers.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
-    variable_pointers.pNext = &demote;
+    FOR_EACH_VK_FEATURE_EXT(FEATURE_EXTENSION);
+    FOR_EACH_VK_EXTENSION(EXTENSION);
+#ifdef _WIN32
+    FOR_EACH_VK_EXTENSION_WIN32(EXTENSION);
+#endif
 
-    VkPhysicalDeviceRobustness2FeaturesEXT robustness2{};
-    robustness2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
-    robustness2.pNext = &variable_pointers;
+#undef FEATURE_EXTENSION
+#undef EXTENSION
 
-    VkPhysicalDeviceTimelineSemaphoreFeatures timeline_semaphore{};
-    timeline_semaphore.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
-    timeline_semaphore.pNext = &robustness2;
+    // Some extensions are mandatory. Check those.
+#define CHECK_EXTENSION(extension_name)                                                            \
+    if (!loaded_extensions.contains(extension_name)) {                                             \
+        LOG_ERROR(Render_Vulkan, "Missing required extension {}", extension_name);                 \
+        suitable = false;                                                                          \
+    }
 
-    VkPhysicalDevice16BitStorageFeatures bit16_storage{};
-    bit16_storage.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
-    bit16_storage.pNext = &timeline_semaphore;
+#define LOG_EXTENSION(extension_name)                                                              \
+    if (!loaded_extensions.contains(extension_name)) {                                             \
+        LOG_INFO(Render_Vulkan, "Device doesn't support extension {}", extension_name);            \
+    }
 
-    VkPhysicalDevice8BitStorageFeatures bit8_storage{};
-    bit8_storage.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
-    bit8_storage.pNext = &bit16_storage;
+    FOR_EACH_VK_RECOMMENDED_EXTENSION(LOG_EXTENSION);
+    FOR_EACH_VK_MANDATORY_EXTENSION(CHECK_EXTENSION);
+#ifdef _WIN32
+    FOR_EACH_VK_MANDATORY_EXTENSION_WIN32(CHECK_EXTENSION);
+#else
+    FOR_EACH_VK_MANDATORY_EXTENSION_GENERIC(CHECK_EXTENSION);
+#endif
 
-    VkPhysicalDeviceHostQueryResetFeatures host_query_reset{};
-    host_query_reset.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
-    host_query_reset.pNext = &bit8_storage;
+    if (requires_swapchain) {
+        CHECK_EXTENSION(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+    }
 
-    VkPhysicalDeviceShaderDrawParametersFeatures draw_parameters{};
-    draw_parameters.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES;
-    draw_parameters.pNext = &host_query_reset;
+#undef LOG_EXTENSION
+#undef CHECK_EXTENSION
 
-    VkPhysicalDeviceFeatures2 features2{};
+    // Generate the linked list of features to test.
     features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
-    features2.pNext = &draw_parameters;
 
-    physical.GetFeatures2(features2);
+    // Set next pointer.
+    void** next = &features2.pNext;
 
-    const VkPhysicalDeviceFeatures& features{features2.features};
-    std::array feature_report{
-        std::make_pair(features.robustBufferAccess, "robustBufferAccess"),
-        std::make_pair(features.vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics"),
-        std::make_pair(features.imageCubeArray, "imageCubeArray"),
-        std::make_pair(features.independentBlend, "independentBlend"),
-        std::make_pair(features.multiDrawIndirect, "multiDrawIndirect"),
-        std::make_pair(features.drawIndirectFirstInstance, "drawIndirectFirstInstance"),
-        std::make_pair(features.depthClamp, "depthClamp"),
-        std::make_pair(features.samplerAnisotropy, "samplerAnisotropy"),
-        std::make_pair(features.largePoints, "largePoints"),
-        std::make_pair(features.multiViewport, "multiViewport"),
-        std::make_pair(features.depthBiasClamp, "depthBiasClamp"),
-        std::make_pair(features.fillModeNonSolid, "fillModeNonSolid"),
-        std::make_pair(features.wideLines, "wideLines"),
-        std::make_pair(features.geometryShader, "geometryShader"),
-        std::make_pair(features.tessellationShader, "tessellationShader"),
-        std::make_pair(features.sampleRateShading, "sampleRateShading"),
-        std::make_pair(features.dualSrcBlend, "dualSrcBlend"),
-        std::make_pair(features.logicOp, "logicOp"),
-        std::make_pair(features.occlusionQueryPrecise, "occlusionQueryPrecise"),
-        std::make_pair(features.fragmentStoresAndAtomics, "fragmentStoresAndAtomics"),
-        std::make_pair(features.shaderImageGatherExtended, "shaderImageGatherExtended"),
-        std::make_pair(features.shaderStorageImageWriteWithoutFormat,
-                       "shaderStorageImageWriteWithoutFormat"),
-        std::make_pair(features.shaderClipDistance, "shaderClipDistance"),
-        std::make_pair(features.shaderCullDistance, "shaderCullDistance"),
-        std::make_pair(variable_pointers.variablePointers, "variablePointers"),
-        std::make_pair(variable_pointers.variablePointersStorageBuffer,
-                       "variablePointersStorageBuffer"),
-        std::make_pair(robustness2.robustBufferAccess2, "robustBufferAccess2"),
-        std::make_pair(robustness2.robustImageAccess2, "robustImageAccess2"),
-        std::make_pair(robustness2.nullDescriptor, "nullDescriptor"),
-        std::make_pair(demote.shaderDemoteToHelperInvocation, "shaderDemoteToHelperInvocation"),
-        std::make_pair(timeline_semaphore.timelineSemaphore, "timelineSemaphore"),
-        std::make_pair(bit16_storage.storageBuffer16BitAccess, "storageBuffer16BitAccess"),
-        std::make_pair(bit16_storage.uniformAndStorageBuffer16BitAccess,
-                       "uniformAndStorageBuffer16BitAccess"),
-        std::make_pair(bit8_storage.storageBuffer8BitAccess, "storageBuffer8BitAccess"),
-        std::make_pair(bit8_storage.uniformAndStorageBuffer8BitAccess,
-                       "uniformAndStorageBuffer8BitAccess"),
-        std::make_pair(host_query_reset.hostQueryReset, "hostQueryReset"),
-        std::make_pair(draw_parameters.shaderDrawParameters, "shaderDrawParameters"),
-    };
+    // Test all features we know about. If the feature is not available in core at our
+    // current API version, and was not enabled by an extension, skip testing the feature.
+    // We set the structure sType explicitly here as it is zeroed by the constructor.
+#define FEATURE(prefix, struct_name, macro_name, var_name)                                         \
+    features.var_name.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_##macro_name##_FEATURES;           \
+    SetNext(next, features.var_name);
 
-    bool has_all_required_features = true;
-    for (const auto& [is_supported, name] : feature_report) {
-        if (!is_supported) {
-            LOG_ERROR(Render_Vulkan, "Missing required feature: {}", name);
-            has_all_required_features = false;
-        }
+#define EXT_FEATURE(prefix, struct_name, macro_name, var_name)                                     \
+    if (extensions.var_name) {                                                                     \
+        features.var_name.sType =                                                                  \
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_##macro_name##_FEATURES_##prefix;                    \
+        SetNext(next, features.var_name);                                                          \
     }
 
-    if (!has_all_required_features) {
-        throw vk::Exception(VK_ERROR_FEATURE_NOT_PRESENT);
+    FOR_EACH_VK_FEATURE_1_1(FEATURE);
+    FOR_EACH_VK_FEATURE_EXT(EXT_FEATURE);
+    if (instance_version >= VK_API_VERSION_1_2) {
+        FOR_EACH_VK_FEATURE_1_2(FEATURE);
+    } else {
+        FOR_EACH_VK_FEATURE_1_2(EXT_FEATURE);
     }
-}
-
-std::vector<const char*> Device::LoadExtensions(bool requires_surface) {
-    std::vector<const char*> extensions = ExtensionsRequiredForInstanceVersion(instance_version);
-    if (requires_surface) {
-        extensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+    if (instance_version >= VK_API_VERSION_1_3) {
+        FOR_EACH_VK_FEATURE_1_3(FEATURE);
+    } else {
+        FOR_EACH_VK_FEATURE_1_3(EXT_FEATURE);
     }
 
-    bool has_khr_shader_float16_int8{};
-    bool has_khr_workgroup_memory_explicit_layout{};
-    bool has_khr_pipeline_executable_properties{};
-    bool has_khr_image_format_list{};
-    bool has_khr_swapchain_mutable_format{};
-    bool has_ext_subgroup_size_control{};
-    bool has_ext_transform_feedback{};
-    bool has_ext_custom_border_color{};
-    bool has_ext_extended_dynamic_state{};
-    bool has_ext_extended_dynamic_state_2{};
-    bool has_ext_extended_dynamic_state_3{};
-    bool has_ext_shader_atomic_int64{};
-    bool has_ext_provoking_vertex{};
-    bool has_ext_vertex_input_dynamic_state{};
-    bool has_ext_line_rasterization{};
-    bool has_ext_primitive_topology_list_restart{};
-    bool has_ext_depth_clip_control{};
-    for (const std::string& extension : supported_extensions) {
-        const auto test = [&](std::optional<std::reference_wrapper<bool>> status, const char* name,
-                              bool push) {
-            if (extension != name) {
-                return;
-            }
-            if (push) {
-                extensions.push_back(name);
-            }
-            if (status) {
-                status->get() = true;
-            }
-        };
-        test(nv_viewport_swizzle, VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME, true);
-        test(nv_viewport_array2, VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME, true);
-        test(nv_geometry_shader_passthrough, VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME,
-             true);
-        test(khr_uniform_buffer_standard_layout,
-             VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, true);
-        test(khr_spirv_1_4, VK_KHR_SPIRV_1_4_EXTENSION_NAME, true);
-        test(khr_push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, true);
-        test(has_khr_shader_float16_int8, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, false);
-        test(khr_draw_indirect_count, VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME, true);
-        test(ext_depth_range_unrestricted, VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME, true);
-        test(ext_index_type_uint8, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, true);
-        test(has_ext_primitive_topology_list_restart,
-             VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME, true);
-        test(ext_sampler_filter_minmax, VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME, true);
-        test(ext_shader_viewport_index_layer, VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME,
-             true);
-        test(ext_tooling_info, VK_EXT_TOOLING_INFO_EXTENSION_NAME, true);
-        test(ext_shader_stencil_export, VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME, true);
-        test(ext_conservative_rasterization, VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME,
-             true);
-        test(has_ext_depth_clip_control, VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME, false);
-        test(has_ext_transform_feedback, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, false);
-        test(has_ext_custom_border_color, VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME, false);
-        test(has_ext_extended_dynamic_state, VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME, false);
-        test(has_ext_extended_dynamic_state_2, VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME,
-             false);
-        test(has_ext_extended_dynamic_state_3, VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME,
-             false);
-        test(has_ext_subgroup_size_control, VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, true);
-        test(has_ext_provoking_vertex, VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME, false);
-        test(has_ext_vertex_input_dynamic_state, VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME,
-             false);
-        test(has_ext_shader_atomic_int64, VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME, false);
-        test(has_khr_workgroup_memory_explicit_layout,
-             VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME, false);
-        test(has_khr_image_format_list, VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME, false);
-        test(has_khr_swapchain_mutable_format, VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME,
-             false);
-        test(has_ext_line_rasterization, VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, false);
-        test(ext_memory_budget, VK_EXT_MEMORY_BUDGET_EXTENSION_NAME, true);
-        if (Settings::values.enable_nsight_aftermath) {
-            test(nv_device_diagnostics_config, VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME,
-                 true);
-        }
-        if (Settings::values.renderer_shader_feedback) {
-            test(has_khr_pipeline_executable_properties,
-                 VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, false);
-        }
-    }
-    VkPhysicalDeviceFeatures2 features{};
-    features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
-
-    VkPhysicalDeviceProperties2 physical_properties{};
-    physical_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
-
-    if (has_khr_shader_float16_int8) {
-        VkPhysicalDeviceShaderFloat16Int8Features float16_int8_features;
-        float16_int8_features.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
-        float16_int8_features.pNext = nullptr;
-        features.pNext = &float16_int8_features;
-
-        physical.GetFeatures2(features);
-        is_float16_supported = float16_int8_features.shaderFloat16;
-        is_int8_supported = float16_int8_features.shaderInt8;
-        extensions.push_back(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME);
-    }
-    if (has_ext_subgroup_size_control) {
-        VkPhysicalDeviceSubgroupSizeControlFeatures subgroup_features;
-        subgroup_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
-        subgroup_features.pNext = nullptr;
-        features.pNext = &subgroup_features;
-        physical.GetFeatures2(features);
-
-        VkPhysicalDeviceSubgroupSizeControlProperties subgroup_properties;
-        subgroup_properties.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
-        subgroup_properties.pNext = nullptr;
-        physical_properties.pNext = &subgroup_properties;
-        physical.GetProperties2(physical_properties);
+#undef EXT_FEATURE
+#undef FEATURE
 
-        is_warp_potentially_bigger = subgroup_properties.maxSubgroupSize > GuestWarpSize;
+    // Perform the feature test.
+    physical.GetFeatures2(features2);
+    features.features = features2.features;
 
-        if (subgroup_features.subgroupSizeControl &&
-            subgroup_properties.minSubgroupSize <= GuestWarpSize &&
-            subgroup_properties.maxSubgroupSize >= GuestWarpSize) {
-            extensions.push_back(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME);
-            guest_warp_stages = subgroup_properties.requiredSubgroupSizeStages;
-            ext_subgroup_size_control = true;
-        }
-    } else {
-        is_warp_potentially_bigger = true;
-    }
-    if (has_ext_provoking_vertex) {
-        VkPhysicalDeviceProvokingVertexFeaturesEXT provoking_vertex;
-        provoking_vertex.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
-        provoking_vertex.pNext = nullptr;
-        features.pNext = &provoking_vertex;
-        physical.GetFeatures2(features);
-
-        if (provoking_vertex.provokingVertexLast &&
-            provoking_vertex.transformFeedbackPreservesProvokingVertex) {
-            extensions.push_back(VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME);
-            ext_provoking_vertex = true;
-        }
+    // Some features are mandatory. Check those.
+#define CHECK_FEATURE(feature, name)                                                               \
+    if (!features.feature.name) {                                                                  \
+        LOG_ERROR(Render_Vulkan, "Missing required feature {}", #name);                            \
+        suitable = false;                                                                          \
     }
-    if (has_ext_vertex_input_dynamic_state) {
-        VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT vertex_input;
-        vertex_input.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
-        vertex_input.pNext = nullptr;
-        features.pNext = &vertex_input;
-        physical.GetFeatures2(features);
-
-        if (vertex_input.vertexInputDynamicState) {
-            extensions.push_back(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
-            ext_vertex_input_dynamic_state = true;
-        }
-    }
-    if (has_ext_shader_atomic_int64) {
-        VkPhysicalDeviceShaderAtomicInt64Features atomic_int64;
-        atomic_int64.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
-        atomic_int64.pNext = nullptr;
-        features.pNext = &atomic_int64;
-        physical.GetFeatures2(features);
-
-        if (atomic_int64.shaderBufferInt64Atomics && atomic_int64.shaderSharedInt64Atomics) {
-            extensions.push_back(VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME);
-            ext_shader_atomic_int64 = true;
-        }
-    }
-    if (has_ext_transform_feedback) {
-        VkPhysicalDeviceTransformFeedbackFeaturesEXT tfb_features;
-        tfb_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
-        tfb_features.pNext = nullptr;
-        features.pNext = &tfb_features;
-        physical.GetFeatures2(features);
-
-        VkPhysicalDeviceTransformFeedbackPropertiesEXT tfb_properties;
-        tfb_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
-        tfb_properties.pNext = nullptr;
-        physical_properties.pNext = &tfb_properties;
-        physical.GetProperties2(physical_properties);
 
-        if (tfb_features.transformFeedback && tfb_features.geometryStreams &&
-            tfb_properties.maxTransformFeedbackStreams >= 4 &&
-            tfb_properties.maxTransformFeedbackBuffers && tfb_properties.transformFeedbackQueries &&
-            tfb_properties.transformFeedbackDraw) {
-            extensions.push_back(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
-            ext_transform_feedback = true;
-        }
-    }
-    if (has_ext_custom_border_color) {
-        VkPhysicalDeviceCustomBorderColorFeaturesEXT border_features;
-        border_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
-        border_features.pNext = nullptr;
-        features.pNext = &border_features;
-        physical.GetFeatures2(features);
-
-        if (border_features.customBorderColors && border_features.customBorderColorWithoutFormat) {
-            extensions.push_back(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
-            ext_custom_border_color = true;
-        }
-    }
-    if (has_ext_extended_dynamic_state) {
-        VkPhysicalDeviceExtendedDynamicStateFeaturesEXT extended_dynamic_state;
-        extended_dynamic_state.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
-        extended_dynamic_state.pNext = nullptr;
-        features.pNext = &extended_dynamic_state;
-        physical.GetFeatures2(features);
-
-        if (extended_dynamic_state.extendedDynamicState) {
-            extensions.push_back(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
-            ext_extended_dynamic_state = true;
-        }
-    }
-    if (has_ext_extended_dynamic_state_2) {
-        VkPhysicalDeviceExtendedDynamicState2FeaturesEXT extended_dynamic_state_2;
-        extended_dynamic_state_2.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
-        extended_dynamic_state_2.pNext = nullptr;
-        features.pNext = &extended_dynamic_state_2;
-        physical.GetFeatures2(features);
-
-        if (extended_dynamic_state_2.extendedDynamicState2) {
-            extensions.push_back(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-            ext_extended_dynamic_state_2 = true;
-            ext_extended_dynamic_state_2_extra =
-                extended_dynamic_state_2.extendedDynamicState2LogicOp;
-        }
+#define LOG_FEATURE(feature, name)                                                                 \
+    if (!features.feature.name) {                                                                  \
+        LOG_INFO(Render_Vulkan, "Device doesn't support feature {}", #name);                       \
     }
-    if (has_ext_extended_dynamic_state_3) {
-        VkPhysicalDeviceExtendedDynamicState3FeaturesEXT extended_dynamic_state_3;
-        extended_dynamic_state_3.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
-        extended_dynamic_state_3.pNext = nullptr;
-        features.pNext = &extended_dynamic_state_3;
-        physical.GetFeatures2(features);
-
-        ext_extended_dynamic_state_3_blend =
-            extended_dynamic_state_3.extendedDynamicState3ColorBlendEnable &&
-            extended_dynamic_state_3.extendedDynamicState3ColorBlendEquation &&
-            extended_dynamic_state_3.extendedDynamicState3ColorWriteMask;
-
-        ext_extended_dynamic_state_3_enables =
-            extended_dynamic_state_3.extendedDynamicState3DepthClampEnable &&
-            extended_dynamic_state_3.extendedDynamicState3LogicOpEnable;
-
-        ext_extended_dynamic_state_3 =
-            ext_extended_dynamic_state_3_blend || ext_extended_dynamic_state_3_enables;
-        if (ext_extended_dynamic_state_3) {
-            extensions.push_back(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
-        }
+
+    FOR_EACH_VK_RECOMMENDED_FEATURE(LOG_FEATURE);
+    FOR_EACH_VK_MANDATORY_FEATURE(CHECK_FEATURE);
+
+#undef LOG_FEATURE
+#undef CHECK_FEATURE
+
+    // Generate linked list of properties.
+    properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+
+    // Set next pointer.
+    next = &properties2.pNext;
+
+    // Get driver info.
+    properties.driver.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+    SetNext(next, properties.driver);
+
+    // Retrieve relevant extension properties.
+    if (extensions.shader_float_controls) {
+        properties.float_controls.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
+        SetNext(next, properties.float_controls);
     }
-    if (has_ext_line_rasterization) {
-        VkPhysicalDeviceLineRasterizationFeaturesEXT line_raster;
-        line_raster.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
-        line_raster.pNext = nullptr;
-        features.pNext = &line_raster;
-        physical.GetFeatures2(features);
-        if (line_raster.rectangularLines && line_raster.smoothLines) {
-            extensions.push_back(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME);
-            ext_line_rasterization = true;
-        }
+    if (extensions.push_descriptor) {
+        properties.push_descriptor.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
+        SetNext(next, properties.push_descriptor);
     }
-    if (has_ext_depth_clip_control) {
-        VkPhysicalDeviceDepthClipControlFeaturesEXT depth_clip_control_features;
-        depth_clip_control_features.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
-        depth_clip_control_features.pNext = nullptr;
-        features.pNext = &depth_clip_control_features;
-        physical.GetFeatures2(features);
-
-        if (depth_clip_control_features.depthClipControl) {
-            extensions.push_back(VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME);
-            ext_depth_clip_control = true;
-        }
+    if (extensions.subgroup_size_control) {
+        properties.subgroup_size_control.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
+        SetNext(next, properties.subgroup_size_control);
     }
-    if (has_khr_workgroup_memory_explicit_layout) {
-        VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR layout;
-        layout.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
-        layout.pNext = nullptr;
-        features.pNext = &layout;
-        physical.GetFeatures2(features);
-
-        if (layout.workgroupMemoryExplicitLayout &&
-            layout.workgroupMemoryExplicitLayout8BitAccess &&
-            layout.workgroupMemoryExplicitLayout16BitAccess &&
-            layout.workgroupMemoryExplicitLayoutScalarBlockLayout) {
-            extensions.push_back(VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME);
-            khr_workgroup_memory_explicit_layout = true;
-        }
+    if (extensions.transform_feedback) {
+        properties.transform_feedback.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
+        SetNext(next, properties.transform_feedback);
     }
-    if (has_khr_pipeline_executable_properties) {
-        VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR executable_properties;
-        executable_properties.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
-        executable_properties.pNext = nullptr;
-        features.pNext = &executable_properties;
-        physical.GetFeatures2(features);
-
-        if (executable_properties.pipelineExecutableInfo) {
-            extensions.push_back(VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
-            khr_pipeline_executable_properties = true;
+
+    // Perform the property fetch.
+    physical.GetProperties2(properties2);
+    properties.properties = properties2.properties;
+
+    // Unload extensions if feature support is insufficient.
+    RemoveUnsuitableExtensions();
+
+    // Check limits.
+    struct Limit {
+        u32 minimum;
+        u32 value;
+        const char* name;
+    };
+
+    const VkPhysicalDeviceLimits& limits{properties.properties.limits};
+    const std::array limits_report{
+        Limit{65536, limits.maxUniformBufferRange, "maxUniformBufferRange"},
+        Limit{16, limits.maxViewports, "maxViewports"},
+        Limit{8, limits.maxColorAttachments, "maxColorAttachments"},
+        Limit{8, limits.maxClipDistances, "maxClipDistances"},
+    };
+
+    for (const auto& [min, value, name] : limits_report) {
+        if (value < min) {
+            LOG_ERROR(Render_Vulkan, "{} has to be {} or greater but it is {}", name, min, value);
+            suitable = false;
         }
     }
-    if (has_ext_primitive_topology_list_restart) {
-        VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT primitive_topology_list_restart{};
-        primitive_topology_list_restart.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
-        primitive_topology_list_restart.pNext = nullptr;
-        features.pNext = &primitive_topology_list_restart;
-        physical.GetFeatures2(features);
-
-        is_topology_list_restart_supported =
-            primitive_topology_list_restart.primitiveTopologyListRestart;
-        is_patch_list_restart_supported =
-            primitive_topology_list_restart.primitiveTopologyPatchListRestart;
-    }
-    if (requires_surface && has_khr_image_format_list && has_khr_swapchain_mutable_format) {
-        extensions.push_back(VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME);
-        extensions.push_back(VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME);
-        khr_swapchain_mutable_format = true;
-    }
-    if (khr_push_descriptor) {
-        VkPhysicalDevicePushDescriptorPropertiesKHR push_descriptor;
-        push_descriptor.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
-        push_descriptor.pNext = nullptr;
 
-        physical_properties.pNext = &push_descriptor;
-        physical.GetProperties2(physical_properties);
+    // Return whether we were suitable.
+    return suitable;
+}
 
-        max_push_descriptors = push_descriptor.maxPushDescriptors;
+void Device::RemoveExtensionIfUnsuitable(bool is_suitable, const std::string& extension_name) {
+    if (loaded_extensions.contains(extension_name) && !is_suitable) {
+        LOG_WARNING(Render_Vulkan, "Removing unsuitable extension {}", extension_name);
+        loaded_extensions.erase(extension_name);
     }
+}
 
-    has_null_descriptor = true;
-
-    return extensions;
+void Device::RemoveUnsuitableExtensions() {
+    // VK_EXT_custom_border_color
+    extensions.custom_border_color = features.custom_border_color.customBorderColors &&
+                                     features.custom_border_color.customBorderColorWithoutFormat;
+    RemoveExtensionIfUnsuitable(extensions.custom_border_color,
+                                VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
+
+    // VK_EXT_depth_clip_control
+    extensions.depth_clip_control = features.depth_clip_control.depthClipControl;
+    RemoveExtensionIfUnsuitable(extensions.depth_clip_control,
+                                VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME);
+
+    // VK_EXT_extended_dynamic_state
+    extensions.extended_dynamic_state = features.extended_dynamic_state.extendedDynamicState;
+    RemoveExtensionIfUnsuitable(extensions.extended_dynamic_state,
+                                VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+
+    // VK_EXT_extended_dynamic_state2
+    extensions.extended_dynamic_state2 = features.extended_dynamic_state2.extendedDynamicState2;
+    RemoveExtensionIfUnsuitable(extensions.extended_dynamic_state2,
+                                VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
+
+    // VK_EXT_extended_dynamic_state3
+    dynamic_state3_blending =
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable &&
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation &&
+        features.extended_dynamic_state3.extendedDynamicState3ColorWriteMask;
+    dynamic_state3_enables =
+        features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable &&
+        features.extended_dynamic_state3.extendedDynamicState3LogicOpEnable;
+
+    extensions.extended_dynamic_state3 = dynamic_state3_blending || dynamic_state3_enables;
+    dynamic_state3_blending = dynamic_state3_blending && extensions.extended_dynamic_state3;
+    dynamic_state3_enables = dynamic_state3_enables && extensions.extended_dynamic_state3;
+    RemoveExtensionIfUnsuitable(extensions.extended_dynamic_state3,
+                                VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
+
+    // VK_EXT_provoking_vertex
+    extensions.provoking_vertex =
+        features.provoking_vertex.provokingVertexLast &&
+        features.provoking_vertex.transformFeedbackPreservesProvokingVertex;
+    RemoveExtensionIfUnsuitable(extensions.provoking_vertex,
+                                VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME);
+
+    // VK_KHR_shader_atomic_int64
+    extensions.shader_atomic_int64 = features.shader_atomic_int64.shaderBufferInt64Atomics &&
+                                     features.shader_atomic_int64.shaderSharedInt64Atomics;
+    RemoveExtensionIfUnsuitable(extensions.shader_atomic_int64,
+                                VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME);
+
+    // VK_EXT_shader_demote_to_helper_invocation
+    extensions.shader_demote_to_helper_invocation =
+        features.shader_demote_to_helper_invocation.shaderDemoteToHelperInvocation;
+    RemoveExtensionIfUnsuitable(extensions.shader_demote_to_helper_invocation,
+                                VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME);
+
+    // VK_EXT_subgroup_size_control
+    extensions.subgroup_size_control =
+        features.subgroup_size_control.subgroupSizeControl &&
+        properties.subgroup_size_control.minSubgroupSize <= GuestWarpSize &&
+        properties.subgroup_size_control.maxSubgroupSize >= GuestWarpSize;
+    RemoveExtensionIfUnsuitable(extensions.subgroup_size_control,
+                                VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME);
+
+    // VK_EXT_transform_feedback
+    extensions.transform_feedback =
+        features.transform_feedback.transformFeedback &&
+        features.transform_feedback.geometryStreams &&
+        properties.transform_feedback.maxTransformFeedbackStreams >= 4 &&
+        properties.transform_feedback.maxTransformFeedbackBuffers > 0 &&
+        properties.transform_feedback.transformFeedbackQueries &&
+        properties.transform_feedback.transformFeedbackDraw;
+    RemoveExtensionIfUnsuitable(extensions.transform_feedback,
+                                VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
+
+    // VK_EXT_vertex_input_dynamic_state
+    extensions.vertex_input_dynamic_state =
+        features.vertex_input_dynamic_state.vertexInputDynamicState;
+    RemoveExtensionIfUnsuitable(extensions.vertex_input_dynamic_state,
+                                VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+
+    // VK_KHR_pipeline_executable_properties
+    if (Settings::values.renderer_shader_feedback.GetValue()) {
+        extensions.pipeline_executable_properties =
+            features.pipeline_executable_properties.pipelineExecutableInfo;
+        RemoveExtensionIfUnsuitable(extensions.pipeline_executable_properties,
+                                    VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
+    } else {
+        extensions.pipeline_executable_properties = false;
+        loaded_extensions.erase(VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
+    }
+
+    // VK_KHR_workgroup_memory_explicit_layout
+    extensions.workgroup_memory_explicit_layout =
+        features.features.shaderInt16 &&
+        features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout &&
+        features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout8BitAccess &&
+        features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout16BitAccess &&
+        features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayoutScalarBlockLayout;
+    RemoveExtensionIfUnsuitable(extensions.workgroup_memory_explicit_layout,
+                                VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME);
 }
 
 void Device::SetupFamilies(VkSurfaceKHR surface) {
@@ -1540,53 +945,6 @@ void Device::SetupFamilies(VkSurfaceKHR surface) {
     }
 }
 
-void Device::SetupFeatures() {
-    const VkPhysicalDeviceFeatures features{physical.GetFeatures()};
-    is_depth_bounds_supported = features.depthBounds;
-    is_formatless_image_load_supported = features.shaderStorageImageReadWithoutFormat;
-    is_shader_float64_supported = features.shaderFloat64;
-    is_shader_int64_supported = features.shaderInt64;
-    is_shader_int16_supported = features.shaderInt16;
-    is_shader_storage_image_multisample = features.shaderStorageImageMultisample;
-    is_blit_depth_stencil_supported = TestDepthStencilBlits();
-    is_optimal_astc_supported = IsOptimalAstcSupported(features);
-
-    const VkPhysicalDeviceLimits& limits{properties.limits};
-    max_vertex_input_attributes = limits.maxVertexInputAttributes;
-    max_vertex_input_bindings = limits.maxVertexInputBindings;
-}
-
-void Device::SetupProperties() {
-    float_controls.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
-
-    VkPhysicalDeviceProperties2KHR properties2{};
-    properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
-    properties2.pNext = &float_controls;
-
-    physical.GetProperties2(properties2);
-}
-
-void Device::CollectTelemetryParameters() {
-    VkPhysicalDeviceDriverProperties driver{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
-        .pNext = nullptr,
-        .driverID = {},
-        .driverName = {},
-        .driverInfo = {},
-        .conformanceVersion = {},
-    };
-
-    VkPhysicalDeviceProperties2 device_properties{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
-        .pNext = &driver,
-        .properties = {},
-    };
-    physical.GetProperties2(device_properties);
-
-    driver_id = driver.driverID;
-    vendor_name = driver.driverName;
-}
-
 u64 Device::GetDeviceMemoryUsage() const {
     VkPhysicalDeviceMemoryBudgetPropertiesEXT budget;
     budget.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
@@ -1602,7 +960,8 @@ u64 Device::GetDeviceMemoryUsage() const {
 void Device::CollectPhysicalMemoryInfo() {
     VkPhysicalDeviceMemoryBudgetPropertiesEXT budget{};
     budget.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
-    const auto mem_info = physical.GetMemoryProperties(ext_memory_budget ? &budget : nullptr);
+    const auto mem_info =
+        physical.GetMemoryProperties(extensions.memory_budget ? &budget : nullptr);
     const auto& mem_properties = mem_info.memoryProperties;
     const size_t num_properties = mem_properties.memoryHeapCount;
     device_access_memory = 0;
@@ -1618,7 +977,7 @@ void Device::CollectPhysicalMemoryInfo() {
         if (is_heap_local) {
             local_memory += mem_properties.memoryHeaps[element].size;
         }
-        if (ext_memory_budget) {
+        if (extensions.memory_budget) {
             device_initial_usage += budget.heapUsage[element];
             device_access_memory += budget.heapBudget[element];
             continue;
@@ -1634,7 +993,7 @@ void Device::CollectPhysicalMemoryInfo() {
 }
 
 void Device::CollectToolingInfo() {
-    if (!ext_tooling_info) {
+    if (!extensions.tooling_info) {
         return;
     }
     auto tools{physical.GetPhysicalDeviceToolProperties()};
diff --git a/src/video_core/vulkan_common/vulkan_device.h b/src/video_core/vulkan_common/vulkan_device.h
index 4bc267163..4cfb20bc2 100644
--- a/src/video_core/vulkan_common/vulkan_device.h
+++ b/src/video_core/vulkan_common/vulkan_device.h
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <set>
 #include <span>
 #include <string>
 #include <unordered_map>
@@ -11,6 +12,155 @@
 #include "common/common_types.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
+// Define all features which may be used by the implementation here.
+// Vulkan version in the macro describes the minimum version required for feature availability.
+// If the Vulkan version is lower than the required version, the named extension is required.
+#define FOR_EACH_VK_FEATURE_1_1(FEATURE)                                                           \
+    FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)                \
+    FEATURE(KHR, 16BitStorage, 16BIT_STORAGE, bit16_storage)                                       \
+    FEATURE(KHR, ShaderAtomicInt64, SHADER_ATOMIC_INT64, shader_atomic_int64)                      \
+    FEATURE(KHR, ShaderDrawParameters, SHADER_DRAW_PARAMETERS, shader_draw_parameters)             \
+    FEATURE(KHR, ShaderFloat16Int8, SHADER_FLOAT16_INT8, shader_float16_int8)                      \
+    FEATURE(KHR, UniformBufferStandardLayout, UNIFORM_BUFFER_STANDARD_LAYOUT,                      \
+            uniform_buffer_standard_layout)                                                        \
+    FEATURE(KHR, VariablePointer, VARIABLE_POINTERS, variable_pointer)
+
+#define FOR_EACH_VK_FEATURE_1_2(FEATURE)                                                           \
+    FEATURE(EXT, HostQueryReset, HOST_QUERY_RESET, host_query_reset)                               \
+    FEATURE(KHR, 8BitStorage, 8BIT_STORAGE, bit8_storage)                                          \
+    FEATURE(KHR, TimelineSemaphore, TIMELINE_SEMAPHORE, timeline_semaphore)
+
+#define FOR_EACH_VK_FEATURE_1_3(FEATURE)                                                           \
+    FEATURE(EXT, ShaderDemoteToHelperInvocation, SHADER_DEMOTE_TO_HELPER_INVOCATION,               \
+            shader_demote_to_helper_invocation)
+
+// Define all features which may be used by the implementation and require an extension here.
+#define FOR_EACH_VK_FEATURE_EXT(FEATURE)                                                           \
+    FEATURE(EXT, CustomBorderColor, CUSTOM_BORDER_COLOR, custom_border_color)                      \
+    FEATURE(EXT, DepthClipControl, DEPTH_CLIP_CONTROL, depth_clip_control)                         \
+    FEATURE(EXT, ExtendedDynamicState, EXTENDED_DYNAMIC_STATE, extended_dynamic_state)             \
+    FEATURE(EXT, ExtendedDynamicState2, EXTENDED_DYNAMIC_STATE_2, extended_dynamic_state2)         \
+    FEATURE(EXT, ExtendedDynamicState3, EXTENDED_DYNAMIC_STATE_3, extended_dynamic_state3)         \
+    FEATURE(EXT, IndexTypeUint8, INDEX_TYPE_UINT8, index_type_uint8)                               \
+    FEATURE(EXT, LineRasterization, LINE_RASTERIZATION, line_rasterization)                        \
+    FEATURE(EXT, PrimitiveTopologyListRestart, PRIMITIVE_TOPOLOGY_LIST_RESTART,                    \
+            primitive_topology_list_restart)                                                       \
+    FEATURE(EXT, ProvokingVertex, PROVOKING_VERTEX, provoking_vertex)                              \
+    FEATURE(EXT, Robustness2, ROBUSTNESS_2, robustness2)                                           \
+    FEATURE(EXT, TransformFeedback, TRANSFORM_FEEDBACK, transform_feedback)                        \
+    FEATURE(EXT, VertexInputDynamicState, VERTEX_INPUT_DYNAMIC_STATE, vertex_input_dynamic_state)  \
+    FEATURE(KHR, PipelineExecutableProperties, PIPELINE_EXECUTABLE_PROPERTIES,                     \
+            pipeline_executable_properties)                                                        \
+    FEATURE(KHR, WorkgroupMemoryExplicitLayout, WORKGROUP_MEMORY_EXPLICIT_LAYOUT,                  \
+            workgroup_memory_explicit_layout)
+
+// Define miscellaneous extensions which may be used by the implementation here.
+#define FOR_EACH_VK_EXTENSION(EXTENSION)                                                           \
+    EXTENSION(EXT, CONSERVATIVE_RASTERIZATION, conservative_rasterization)                         \
+    EXTENSION(EXT, DEPTH_RANGE_UNRESTRICTED, depth_range_unrestricted)                             \
+    EXTENSION(EXT, MEMORY_BUDGET, memory_budget)                                                   \
+    EXTENSION(EXT, ROBUSTNESS_2, robustness_2)                                                     \
+    EXTENSION(EXT, SAMPLER_FILTER_MINMAX, sampler_filter_minmax)                                   \
+    EXTENSION(EXT, SHADER_STENCIL_EXPORT, shader_stencil_export)                                   \
+    EXTENSION(EXT, SHADER_VIEWPORT_INDEX_LAYER, shader_viewport_index_layer)                       \
+    EXTENSION(EXT, TOOLING_INFO, tooling_info)                                                     \
+    EXTENSION(EXT, VERTEX_ATTRIBUTE_DIVISOR, vertex_attribute_divisor)                             \
+    EXTENSION(KHR, DRIVER_PROPERTIES, driver_properties)                                           \
+    EXTENSION(KHR, EXTERNAL_MEMORY_FD, external_memory_fd)                                         \
+    EXTENSION(KHR, PUSH_DESCRIPTOR, push_descriptor)                                               \
+    EXTENSION(KHR, SAMPLER_MIRROR_CLAMP_TO_EDGE, sampler_mirror_clamp_to_edge)                     \
+    EXTENSION(KHR, SHADER_FLOAT_CONTROLS, shader_float_controls)                                   \
+    EXTENSION(KHR, SPIRV_1_4, spirv_1_4)                                                           \
+    EXTENSION(KHR, SWAPCHAIN, swapchain)                                                           \
+    EXTENSION(KHR, SWAPCHAIN_MUTABLE_FORMAT, swapchain_mutable_format)                             \
+    EXTENSION(NV, DEVICE_DIAGNOSTICS_CONFIG, device_diagnostics_config)                            \
+    EXTENSION(NV, GEOMETRY_SHADER_PASSTHROUGH, geometry_shader_passthrough)                        \
+    EXTENSION(NV, VIEWPORT_ARRAY2, viewport_array2)                                                \
+    EXTENSION(NV, VIEWPORT_SWIZZLE, viewport_swizzle)
+
+#define FOR_EACH_VK_EXTENSION_WIN32(EXTENSION)                                                     \
+    EXTENSION(KHR, EXTERNAL_MEMORY_WIN32, external_memory_win32)
+
+// Define extensions which must be supported.
+#define FOR_EACH_VK_MANDATORY_EXTENSION(EXTENSION_NAME)                                            \
+    EXTENSION_NAME(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)                                             \
+    EXTENSION_NAME(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)                                 \
+    EXTENSION_NAME(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)                                        \
+    EXTENSION_NAME(VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME)                             \
+    EXTENSION_NAME(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME)
+
+#define FOR_EACH_VK_MANDATORY_EXTENSION_GENERIC(EXTENSION_NAME)                                    \
+    EXTENSION_NAME(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME)
+
+#define FOR_EACH_VK_MANDATORY_EXTENSION_WIN32(EXTENSION_NAME)                                      \
+    EXTENSION_NAME(VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME)
+
+// Define extensions where the absence of the extension may result in a degraded experience.
+#define FOR_EACH_VK_RECOMMENDED_EXTENSION(EXTENSION_NAME)                                          \
+    EXTENSION_NAME(VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME)                               \
+    EXTENSION_NAME(VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME)                                 \
+    EXTENSION_NAME(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME)                                   \
+    EXTENSION_NAME(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME)                                 \
+    EXTENSION_NAME(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME)                                 \
+    EXTENSION_NAME(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)                                       \
+    EXTENSION_NAME(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME)                               \
+    EXTENSION_NAME(VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME)                               \
+    EXTENSION_NAME(VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME)                                           \
+    EXTENSION_NAME(VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME)
+
+// Define features which must be supported.
+#define FOR_EACH_VK_MANDATORY_FEATURE(FEATURE_NAME)                                                \
+    FEATURE_NAME(bit16_storage, storageBuffer16BitAccess)                                          \
+    FEATURE_NAME(bit16_storage, uniformAndStorageBuffer16BitAccess)                                \
+    FEATURE_NAME(bit8_storage, storageBuffer8BitAccess)                                            \
+    FEATURE_NAME(bit8_storage, uniformAndStorageBuffer8BitAccess)                                  \
+    FEATURE_NAME(features, depthBiasClamp)                                                         \
+    FEATURE_NAME(features, depthClamp)                                                             \
+    FEATURE_NAME(features, drawIndirectFirstInstance)                                              \
+    FEATURE_NAME(features, dualSrcBlend)                                                           \
+    FEATURE_NAME(features, fillModeNonSolid)                                                       \
+    FEATURE_NAME(features, fragmentStoresAndAtomics)                                               \
+    FEATURE_NAME(features, geometryShader)                                                         \
+    FEATURE_NAME(features, imageCubeArray)                                                         \
+    FEATURE_NAME(features, independentBlend)                                                       \
+    FEATURE_NAME(features, largePoints)                                                            \
+    FEATURE_NAME(features, logicOp)                                                                \
+    FEATURE_NAME(features, multiDrawIndirect)                                                      \
+    FEATURE_NAME(features, multiViewport)                                                          \
+    FEATURE_NAME(features, occlusionQueryPrecise)                                                  \
+    FEATURE_NAME(features, robustBufferAccess)                                                     \
+    FEATURE_NAME(features, samplerAnisotropy)                                                      \
+    FEATURE_NAME(features, sampleRateShading)                                                      \
+    FEATURE_NAME(features, shaderClipDistance)                                                     \
+    FEATURE_NAME(features, shaderCullDistance)                                                     \
+    FEATURE_NAME(features, shaderImageGatherExtended)                                              \
+    FEATURE_NAME(features, shaderStorageImageWriteWithoutFormat)                                   \
+    FEATURE_NAME(features, tessellationShader)                                                     \
+    FEATURE_NAME(features, vertexPipelineStoresAndAtomics)                                         \
+    FEATURE_NAME(features, wideLines)                                                              \
+    FEATURE_NAME(host_query_reset, hostQueryReset)                                                 \
+    FEATURE_NAME(robustness2, nullDescriptor)                                                      \
+    FEATURE_NAME(robustness2, robustBufferAccess2)                                                 \
+    FEATURE_NAME(robustness2, robustImageAccess2)                                                  \
+    FEATURE_NAME(shader_demote_to_helper_invocation, shaderDemoteToHelperInvocation)               \
+    FEATURE_NAME(shader_draw_parameters, shaderDrawParameters)                                     \
+    FEATURE_NAME(timeline_semaphore, timelineSemaphore)                                            \
+    FEATURE_NAME(variable_pointer, variablePointers)                                               \
+    FEATURE_NAME(variable_pointer, variablePointersStorageBuffer)
+
+// Define features where the absence of the feature may result in a degraded experience.
+#define FOR_EACH_VK_RECOMMENDED_FEATURE(FEATURE_NAME)                                              \
+    FEATURE_NAME(custom_border_color, customBorderColors)                                          \
+    FEATURE_NAME(extended_dynamic_state, extendedDynamicState)                                     \
+    FEATURE_NAME(index_type_uint8, indexTypeUint8)                                                 \
+    FEATURE_NAME(primitive_topology_list_restart, primitiveTopologyListRestart)                    \
+    FEATURE_NAME(provoking_vertex, provokingVertexLast)                                            \
+    FEATURE_NAME(shader_float16_int8, shaderFloat16)                                               \
+    FEATURE_NAME(shader_float16_int8, shaderInt8)                                                  \
+    FEATURE_NAME(transform_feedback, transformFeedback)                                            \
+    FEATURE_NAME(uniform_buffer_standard_layout, uniformBufferStandardLayout)                      \
+    FEATURE_NAME(vertex_input_dynamic_state, vertexInputDynamicState)
+
 namespace Vulkan {
 
 class NsightAftermathTracker;
@@ -88,69 +238,69 @@ public:
 
     /// Returns the current Vulkan API version provided in Vulkan-formatted version numbers.
     u32 ApiVersion() const {
-        return properties.apiVersion;
+        return properties.properties.apiVersion;
     }
 
     /// Returns the current driver version provided in Vulkan-formatted version numbers.
     u32 GetDriverVersion() const {
-        return properties.driverVersion;
+        return properties.properties.driverVersion;
     }
 
     /// Returns the device name.
     std::string_view GetModelName() const {
-        return properties.deviceName;
+        return properties.properties.deviceName;
     }
 
     /// Returns the driver ID.
     VkDriverIdKHR GetDriverID() const {
-        return driver_id;
+        return properties.driver.driverID;
     }
 
     bool ShouldBoostClocks() const;
 
     /// Returns uniform buffer alignment requeriment.
     VkDeviceSize GetUniformBufferAlignment() const {
-        return properties.limits.minUniformBufferOffsetAlignment;
+        return properties.properties.limits.minUniformBufferOffsetAlignment;
     }
 
     /// Returns storage alignment requeriment.
     VkDeviceSize GetStorageBufferAlignment() const {
-        return properties.limits.minStorageBufferOffsetAlignment;
+        return properties.properties.limits.minStorageBufferOffsetAlignment;
     }
 
     /// Returns the maximum range for storage buffers.
     VkDeviceSize GetMaxStorageBufferRange() const {
-        return properties.limits.maxStorageBufferRange;
+        return properties.properties.limits.maxStorageBufferRange;
     }
 
     /// Returns the maximum size for push constants.
     VkDeviceSize GetMaxPushConstantsSize() const {
-        return properties.limits.maxPushConstantsSize;
+        return properties.properties.limits.maxPushConstantsSize;
     }
 
     /// Returns the maximum size for shared memory.
     u32 GetMaxComputeSharedMemorySize() const {
-        return properties.limits.maxComputeSharedMemorySize;
+        return properties.properties.limits.maxComputeSharedMemorySize;
     }
 
     /// Returns float control properties of the device.
     const VkPhysicalDeviceFloatControlsPropertiesKHR& FloatControlProperties() const {
-        return float_controls;
+        return properties.float_controls;
     }
 
     /// Returns true if ASTC is natively supported.
     bool IsOptimalAstcSupported() const {
-        return is_optimal_astc_supported;
+        return features.features.textureCompressionASTC_LDR;
     }
 
     /// Returns true if the device supports float16 natively.
     bool IsFloat16Supported() const {
-        return is_float16_supported;
+        return features.shader_float16_int8.shaderFloat16;
     }
 
     /// Returns true if the device supports int8 natively.
     bool IsInt8Supported() const {
-        return is_int8_supported;
+        return features.shader_float16_int8.shaderInt8;
     }
 
     /// Returns true if the device warp size can potentially be bigger than guest's warp size.
@@ -160,32 +310,32 @@ public:
 
     /// Returns true if the device can be forced to use the guest warp size.
     bool IsGuestWarpSizeSupported(VkShaderStageFlagBits stage) const {
-        return guest_warp_stages & stage;
+        return properties.subgroup_size_control.requiredSubgroupSizeStages & stage;
     }
 
     /// Returns the maximum number of push descriptors.
     u32 MaxPushDescriptors() const {
-        return max_push_descriptors;
+        return properties.push_descriptor.maxPushDescriptors;
     }
 
     /// Returns true if formatless image load is supported.
     bool IsFormatlessImageLoadSupported() const {
-        return is_formatless_image_load_supported;
+        return features.features.shaderStorageImageReadWithoutFormat;
     }
 
     /// Returns true if shader int64 is supported.
     bool IsShaderInt64Supported() const {
-        return is_shader_int64_supported;
+        return features.features.shaderInt64;
     }
 
     /// Returns true if shader int16 is supported.
     bool IsShaderInt16Supported() const {
-        return is_shader_int16_supported;
+        return features.features.shaderInt16;
     }
 
     // Returns true if depth bounds is supported.
     bool IsDepthBoundsSupported() const {
-        return is_depth_bounds_supported;
+        return features.features.depthBounds;
     }
 
     /// Returns true when blitting from and to depth stencil images is supported.
@@ -195,151 +345,151 @@ public:
 
     /// Returns true if the device supports VK_NV_viewport_swizzle.
     bool IsNvViewportSwizzleSupported() const {
-        return nv_viewport_swizzle;
+        return extensions.viewport_swizzle;
     }
 
     /// Returns true if the device supports VK_NV_viewport_array2.
     bool IsNvViewportArray2Supported() const {
-        return nv_viewport_array2;
+        return extensions.viewport_array2;
     }
 
     /// Returns true if the device supports VK_NV_geometry_shader_passthrough.
     bool IsNvGeometryShaderPassthroughSupported() const {
-        return nv_geometry_shader_passthrough;
+        return extensions.geometry_shader_passthrough;
     }
 
     /// Returns true if the device supports VK_KHR_uniform_buffer_standard_layout.
     bool IsKhrUniformBufferStandardLayoutSupported() const {
-        return khr_uniform_buffer_standard_layout;
+        return extensions.uniform_buffer_standard_layout;
     }
 
     /// Returns true if the device supports VK_KHR_push_descriptor.
     bool IsKhrPushDescriptorSupported() const {
-        return khr_push_descriptor;
+        return extensions.push_descriptor;
     }
 
     /// Returns true if VK_KHR_pipeline_executable_properties is enabled.
     bool IsKhrPipelineExecutablePropertiesEnabled() const {
-        return khr_pipeline_executable_properties;
+        return extensions.pipeline_executable_properties;
     }
 
     /// Returns true if VK_KHR_swapchain_mutable_format is enabled.
     bool IsKhrSwapchainMutableFormatEnabled() const {
-        return khr_swapchain_mutable_format;
+        return extensions.swapchain_mutable_format;
     }
 
     /// Returns true if the device supports VK_KHR_workgroup_memory_explicit_layout.
     bool IsKhrWorkgroupMemoryExplicitLayoutSupported() const {
-        return khr_workgroup_memory_explicit_layout;
+        return extensions.workgroup_memory_explicit_layout;
     }
 
     /// Returns true if the device supports VK_EXT_primitive_topology_list_restart.
     bool IsTopologyListPrimitiveRestartSupported() const {
-        return is_topology_list_restart_supported;
+        return features.primitive_topology_list_restart.primitiveTopologyListRestart;
     }
 
     /// Returns true if the device supports VK_EXT_primitive_topology_list_restart.
     bool IsPatchListPrimitiveRestartSupported() const {
-        return is_patch_list_restart_supported;
+        return features.primitive_topology_list_restart.primitiveTopologyPatchListRestart;
     }
 
     /// Returns true if the device supports VK_EXT_index_type_uint8.
     bool IsExtIndexTypeUint8Supported() const {
-        return ext_index_type_uint8;
+        return extensions.index_type_uint8;
     }
 
     /// Returns true if the device supports VK_EXT_sampler_filter_minmax.
     bool IsExtSamplerFilterMinmaxSupported() const {
-        return ext_sampler_filter_minmax;
+        return extensions.sampler_filter_minmax;
     }
 
     /// Returns true if the device supports VK_EXT_depth_range_unrestricted.
     bool IsExtDepthRangeUnrestrictedSupported() const {
-        return ext_depth_range_unrestricted;
+        return extensions.depth_range_unrestricted;
     }
 
     /// Returns true if the device supports VK_EXT_depth_clip_control.
     bool IsExtDepthClipControlSupported() const {
-        return ext_depth_clip_control;
+        return extensions.depth_clip_control;
     }
 
     /// Returns true if the device supports VK_EXT_shader_viewport_index_layer.
     bool IsExtShaderViewportIndexLayerSupported() const {
-        return ext_shader_viewport_index_layer;
+        return extensions.shader_viewport_index_layer;
     }
 
     /// Returns true if the device supports VK_EXT_subgroup_size_control.
     bool IsExtSubgroupSizeControlSupported() const {
-        return ext_subgroup_size_control;
+        return extensions.subgroup_size_control;
     }
 
     /// Returns true if the device supports VK_EXT_transform_feedback.
     bool IsExtTransformFeedbackSupported() const {
-        return ext_transform_feedback;
+        return extensions.transform_feedback;
     }
 
     /// Returns true if the device supports VK_EXT_custom_border_color.
     bool IsExtCustomBorderColorSupported() const {
-        return ext_custom_border_color;
+        return extensions.custom_border_color;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state.
     bool IsExtExtendedDynamicStateSupported() const {
-        return ext_extended_dynamic_state;
+        return extensions.extended_dynamic_state;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state2.
     bool IsExtExtendedDynamicState2Supported() const {
-        return ext_extended_dynamic_state_2;
+        return extensions.extended_dynamic_state2;
     }
 
     bool IsExtExtendedDynamicState2ExtrasSupported() const {
-        return ext_extended_dynamic_state_2_extra;
+        return features.extended_dynamic_state2.extendedDynamicState2LogicOp;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state3.
     bool IsExtExtendedDynamicState3Supported() const {
-        return ext_extended_dynamic_state_3;
+        return extensions.extended_dynamic_state3;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state3.
     bool IsExtExtendedDynamicState3BlendingSupported() const {
-        return ext_extended_dynamic_state_3_blend;
+        return dynamic_state3_blending;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state3.
     bool IsExtExtendedDynamicState3EnablesSupported() const {
-        return ext_extended_dynamic_state_3_enables;
+        return dynamic_state3_enables;
     }
 
     /// Returns true if the device supports VK_EXT_line_rasterization.
     bool IsExtLineRasterizationSupported() const {
-        return ext_line_rasterization;
+        return extensions.line_rasterization;
     }
 
     /// Returns true if the device supports VK_EXT_vertex_input_dynamic_state.
     bool IsExtVertexInputDynamicStateSupported() const {
-        return ext_vertex_input_dynamic_state;
+        return extensions.vertex_input_dynamic_state;
     }
 
     /// Returns true if the device supports VK_EXT_shader_stencil_export.
     bool IsExtShaderStencilExportSupported() const {
-        return ext_shader_stencil_export;
+        return extensions.shader_stencil_export;
     }
 
     /// Returns true if the device supports VK_EXT_conservative_rasterization.
     bool IsExtConservativeRasterizationSupported() const {
-        return ext_conservative_rasterization;
+        return extensions.conservative_rasterization;
     }
 
     /// Returns true if the device supports VK_EXT_provoking_vertex.
     bool IsExtProvokingVertexSupported() const {
-        return ext_provoking_vertex;
+        return extensions.provoking_vertex;
     }
 
     /// Returns true if the device supports VK_KHR_shader_atomic_int64.
     bool IsExtShaderAtomicInt64Supported() const {
-        return ext_shader_atomic_int64;
+        return extensions.shader_atomic_int64;
     }
 
     /// Returns the minimum supported version of SPIR-V.
@@ -347,7 +497,7 @@ public:
         if (instance_version >= VK_API_VERSION_1_3) {
             return 0x00010600U;
         }
-        if (khr_spirv_1_4) {
+        if (extensions.spirv_1_4) {
             return 0x00010400U;
         }
         return 0x00010000U;
@@ -365,11 +515,11 @@ public:
 
     /// Returns the vendor name reported from Vulkan.
     std::string_view GetVendorName() const {
-        return vendor_name;
+        return properties.driver.driverName;
     }
 
     /// Returns the list of available extensions.
-    const std::vector<std::string>& GetAvailableExtensions() const {
+    const std::set<std::string, std::less<>>& GetAvailableExtensions() const {
         return supported_extensions;
     }
 
@@ -378,7 +528,7 @@ public:
     }
 
     bool CanReportMemoryUsage() const {
-        return ext_memory_budget;
+        return extensions.memory_budget;
     }
 
     u64 GetDeviceMemoryUsage() const;
@@ -400,36 +550,29 @@ public:
     }
 
     bool HasNullDescriptor() const {
-        return has_null_descriptor;
+        return features.robustness2.nullDescriptor;
     }
 
     u32 GetMaxVertexInputAttributes() const {
-        return max_vertex_input_attributes;
+        return properties.properties.limits.maxVertexInputAttributes;
     }
 
     u32 GetMaxVertexInputBindings() const {
-        return max_vertex_input_bindings;
+        return properties.properties.limits.maxVertexInputBindings;
     }
 
 private:
-    /// Checks if the physical device is suitable.
-    void CheckSuitability(bool requires_swapchain) const;
+    /// Checks if the physical device is suitable and configures the object state
+    /// with all necessary info about its properties.
+    bool GetSuitability(bool requires_swapchain);
 
-    /// Loads extensions into a vector and stores available ones in this object.
-    std::vector<const char*> LoadExtensions(bool requires_surface);
+    // Remove extensions which have incomplete feature support.
+    void RemoveUnsuitableExtensions();
+    void RemoveExtensionIfUnsuitable(bool is_suitable, const std::string& extension_name);
 
     /// Sets up queue families.
     void SetupFamilies(VkSurfaceKHR surface);
 
-    /// Sets up device features.
-    void SetupFeatures();
-
-    /// Sets up device properties.
-    void SetupProperties();
-
-    /// Collects telemetry information from the device.
-    void CollectTelemetryParameters();
-
     /// Collects information about attached tools.
     void CollectToolingInfo();
 
@@ -440,91 +583,93 @@ private:
     std::vector<VkDeviceQueueCreateInfo> GetDeviceQueueCreateInfos() const;
 
     /// Returns true if ASTC textures are natively supported.
-    bool IsOptimalAstcSupported(const VkPhysicalDeviceFeatures& features) const;
+    bool ComputeIsOptimalAstcSupported() const;
 
     /// Returns true if the device natively supports blitting depth stencil images.
     bool TestDepthStencilBlits() const;
 
-    VkInstance instance;                                         ///< Vulkan instance.
-    vk::DeviceDispatch dld;                                      ///< Device function pointers.
-    vk::PhysicalDevice physical;                                 ///< Physical device.
-    VkPhysicalDeviceProperties properties;                       ///< Device properties.
-    VkPhysicalDeviceFloatControlsPropertiesKHR float_controls{}; ///< Float control properties.
-    vk::Device logical;                                          ///< Logical device.
-    vk::Queue graphics_queue;                                    ///< Main graphics queue.
-    vk::Queue present_queue;                                     ///< Main present queue.
-    u32 instance_version{};                                      ///< Vulkan onstance version.
-    u32 graphics_family{};                      ///< Main graphics queue family index.
-    u32 present_family{};                       ///< Main present queue family index.
-    VkDriverIdKHR driver_id{};                  ///< Driver ID.
-    VkShaderStageFlags guest_warp_stages{};     ///< Stages where the guest warp size can be forced.
-    u64 device_access_memory{};                 ///< Total size of device local memory in bytes.
-    u32 max_push_descriptors{};                 ///< Maximum number of push descriptors
-    u32 sets_per_pool{};                        ///< Sets per Description Pool
-    bool is_optimal_astc_supported{};           ///< Support for native ASTC.
-    bool is_float16_supported{};                ///< Support for float16 arithmetic.
-    bool is_int8_supported{};                   ///< Support for int8 arithmetic.
-    bool is_warp_potentially_bigger{};          ///< Host warp size can be bigger than guest.
-    bool is_formatless_image_load_supported{};  ///< Support for shader image read without format.
-    bool is_depth_bounds_supported{};           ///< Support for depth bounds.
-    bool is_shader_float64_supported{};         ///< Support for float64.
-    bool is_shader_int64_supported{};           ///< Support for int64.
-    bool is_shader_int16_supported{};           ///< Support for int16.
-    bool is_shader_storage_image_multisample{}; ///< Support for image operations on MSAA images.
-    bool is_blit_depth_stencil_supported{};     ///< Support for blitting from and to depth stencil.
-    bool is_topology_list_restart_supported{};  ///< Support for primitive restart with list
-                                                ///< topologies.
-    bool is_patch_list_restart_supported{};     ///< Support for primitive restart with list patch.
-    bool is_integrated{};                       ///< Is GPU an iGPU.
-    bool is_virtual{};                          ///< Is GPU a virtual GPU.
-    bool is_non_gpu{};                          ///< Is SoftwareRasterizer, FPGA, non-GPU device.
-    bool nv_viewport_swizzle{};                 ///< Support for VK_NV_viewport_swizzle.
-    bool nv_viewport_array2{};                  ///< Support for VK_NV_viewport_array2.
-    bool nv_geometry_shader_passthrough{};      ///< Support for VK_NV_geometry_shader_passthrough.
-    bool khr_draw_indirect_count{};             ///< Support for VK_KHR_draw_indirect_count.
-    bool khr_uniform_buffer_standard_layout{};  ///< Support for scalar uniform buffer layouts.
-    bool khr_spirv_1_4{};                       ///< Support for VK_KHR_spirv_1_4.
-    bool khr_workgroup_memory_explicit_layout{}; ///< Support for explicit workgroup layouts.
-    bool khr_push_descriptor{};                  ///< Support for VK_KHR_push_descritor.
-    bool khr_pipeline_executable_properties{};   ///< Support for executable properties.
-    bool khr_swapchain_mutable_format{};         ///< Support for VK_KHR_swapchain_mutable_format.
-    bool ext_index_type_uint8{};                 ///< Support for VK_EXT_index_type_uint8.
-    bool ext_sampler_filter_minmax{};            ///< Support for VK_EXT_sampler_filter_minmax.
-    bool ext_depth_clip_control{};               ///< Support for VK_EXT_depth_clip_control
-    bool ext_depth_range_unrestricted{};         ///< Support for VK_EXT_depth_range_unrestricted.
-    bool ext_shader_viewport_index_layer{};    ///< Support for VK_EXT_shader_viewport_index_layer.
-    bool ext_tooling_info{};                   ///< Support for VK_EXT_tooling_info.
-    bool ext_subgroup_size_control{};          ///< Support for VK_EXT_subgroup_size_control.
-    bool ext_transform_feedback{};             ///< Support for VK_EXT_transform_feedback.
-    bool ext_custom_border_color{};            ///< Support for VK_EXT_custom_border_color.
-    bool ext_extended_dynamic_state{};         ///< Support for VK_EXT_extended_dynamic_state.
-    bool ext_extended_dynamic_state_2{};       ///< Support for VK_EXT_extended_dynamic_state2.
-    bool ext_extended_dynamic_state_2_extra{}; ///< Support for VK_EXT_extended_dynamic_state2.
-    bool ext_extended_dynamic_state_3{};       ///< Support for VK_EXT_extended_dynamic_state3.
-    bool ext_extended_dynamic_state_3_blend{}; ///< Support for VK_EXT_extended_dynamic_state3.
-    bool ext_extended_dynamic_state_3_enables{}; ///< Support for VK_EXT_extended_dynamic_state3.
-    bool ext_line_rasterization{};               ///< Support for VK_EXT_line_rasterization.
-    bool ext_vertex_input_dynamic_state{};       ///< Support for VK_EXT_vertex_input_dynamic_state.
-    bool ext_shader_stencil_export{};            ///< Support for VK_EXT_shader_stencil_export.
-    bool ext_shader_atomic_int64{};              ///< Support for VK_KHR_shader_atomic_int64.
-    bool ext_conservative_rasterization{};       ///< Support for VK_EXT_conservative_rasterization.
-    bool ext_provoking_vertex{};                 ///< Support for VK_EXT_provoking_vertex.
-    bool ext_memory_budget{};                    ///< Support for VK_EXT_memory_budget.
-    bool nv_device_diagnostics_config{};         ///< Support for VK_NV_device_diagnostics_config.
-    bool has_broken_cube_compatibility{};        ///< Has broken cube compatiblity bit
-    bool has_renderdoc{};                        ///< Has RenderDoc attached
-    bool has_nsight_graphics{};                  ///< Has Nsight Graphics attached
-    bool supports_d24_depth{};                   ///< Supports D24 depth buffers.
-    bool cant_blit_msaa{};                       ///< Does not support MSAA<->MSAA blitting.
-    bool must_emulate_bgr565{};                  ///< Emulates BGR565 by swizzling RGB565 format.
-    bool has_null_descriptor{};                  ///< Has support for null descriptors.
-    u32 max_vertex_input_attributes{};           ///< Max vertex input attributes in pipeline
-    u32 max_vertex_input_bindings{};             ///< Max vertex input buffers in pipeline
+private:
+    VkInstance instance;         ///< Vulkan instance.
+    vk::DeviceDispatch dld;      ///< Device function pointers.
+    vk::PhysicalDevice physical; ///< Physical device.
+    vk::Device logical;          ///< Logical device.
+    vk::Queue graphics_queue;    ///< Main graphics queue.
+    vk::Queue present_queue;     ///< Main present queue.
+    u32 instance_version{};      ///< Vulkan instance version.
+    u32 graphics_family{};       ///< Main graphics queue family index.
+    u32 present_family{};        ///< Main present queue family index.
+
+    struct Extensions {
+#define EXTENSION(prefix, macro_name, var_name) bool var_name{};
+#define FEATURE(prefix, struct_name, macro_name, var_name) bool var_name{};
+
+        FOR_EACH_VK_FEATURE_1_1(FEATURE);
+        FOR_EACH_VK_FEATURE_1_2(FEATURE);
+        FOR_EACH_VK_FEATURE_1_3(FEATURE);
+        FOR_EACH_VK_FEATURE_EXT(FEATURE);
+        FOR_EACH_VK_EXTENSION(EXTENSION);
+        FOR_EACH_VK_EXTENSION_WIN32(EXTENSION);
+
+#undef EXTENSION
+#undef FEATURE
+    };
+
+    struct Features {
+#define FEATURE_CORE(prefix, struct_name, macro_name, var_name)                                    \
+    VkPhysicalDevice##struct_name##Features var_name{};
+#define FEATURE_EXT(prefix, struct_name, macro_name, var_name)                                     \
+    VkPhysicalDevice##struct_name##Features##prefix var_name{};
+
+        FOR_EACH_VK_FEATURE_1_1(FEATURE_CORE);
+        FOR_EACH_VK_FEATURE_1_2(FEATURE_CORE);
+        FOR_EACH_VK_FEATURE_1_3(FEATURE_CORE);
+        FOR_EACH_VK_FEATURE_EXT(FEATURE_EXT);
+
+#undef FEATURE_CORE
+#undef FEATURE_EXT
+
+        VkPhysicalDeviceFeatures features{};
+    };
+
+    struct Properties {
+        VkPhysicalDeviceDriverProperties driver{};
+        VkPhysicalDeviceFloatControlsProperties float_controls{};
+        VkPhysicalDevicePushDescriptorPropertiesKHR push_descriptor{};
+        VkPhysicalDeviceSubgroupSizeControlProperties subgroup_size_control{};
+        VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
+
+        VkPhysicalDeviceProperties properties{};
+    };
+
+    Extensions extensions{};
+    Features features{};
+    Properties properties{};
+
+    VkPhysicalDeviceFeatures2 features2{};
+    VkPhysicalDeviceProperties2 properties2{};
+
+    // Misc features
+    bool is_optimal_astc_supported{};       ///< Support for all guest ASTC formats.
+    bool is_blit_depth_stencil_supported{}; ///< Support for blitting from and to depth stencil.
+    bool is_warp_potentially_bigger{};      ///< Host warp size can be bigger than guest.
+    bool is_integrated{};                   ///< Is GPU an iGPU.
+    bool is_virtual{};                      ///< Is GPU a virtual GPU.
+    bool is_non_gpu{};                      ///< Is SoftwareRasterizer, FPGA, non-GPU device.
+    bool has_broken_cube_compatibility{};   ///< Has broken cube compatiblity bit
+    bool has_renderdoc{};                   ///< Has RenderDoc attached
+    bool has_nsight_graphics{};             ///< Has Nsight Graphics attached
+    bool supports_d24_depth{};              ///< Supports D24 depth buffers.
+    bool cant_blit_msaa{};                  ///< Does not support MSAA<->MSAA blitting.
+    bool must_emulate_bgr565{};             ///< Emulates BGR565 by swizzling RGB565 format.
+    bool dynamic_state3_blending{};         ///< Has all blending features of dynamic_state3.
+    bool dynamic_state3_enables{};          ///< Has all enables features of dynamic_state3.
+    u64 device_access_memory{};             ///< Total size of device local memory in bytes.
+    u32 sets_per_pool{};                    ///< Sets per Description Pool
 
     // Telemetry parameters
-    std::string vendor_name;                       ///< Device's driver name.
-    std::vector<std::string> supported_extensions; ///< Reported Vulkan extensions.
-    std::vector<size_t> valid_heap_memory;         ///< Heaps used.
+    std::set<std::string, std::less<>> supported_extensions; ///< Reported Vulkan extensions.
+    std::set<std::string, std::less<>> loaded_extensions;    ///< Loaded Vulkan extensions.
+    std::vector<size_t> valid_heap_memory;                   ///< Heaps used.
 
     /// Format properties dictionary.
     std::unordered_map<VkFormat, VkFormatProperties> format_properties;