29 files changed, 1127 insertions, 1376 deletions

diff --git a/src/common/settings.h b/src/common/settings.h
index 9eb3711ca..a457e3f23 100644
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -415,7 +415,7 @@ struct Values {
     // Renderer
     SwitchableSetting<RendererBackend, true> renderer_backend{
         RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null, "backend"};
-    SwitchableSetting<bool> renderer_force_max_clock{true, "force_max_clock"};
+    SwitchableSetting<bool> renderer_force_max_clock{false, "force_max_clock"};
     Setting<bool> renderer_debug{false, "debug"};
     Setting<bool> renderer_shader_feedback{false, "shader_feedback"};
     Setting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 0252c8c31..5afdeb5ff 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -226,6 +226,7 @@ add_library(core STATIC
     hle/kernel/k_page_buffer.h
     hle/kernel/k_page_heap.cpp
     hle/kernel/k_page_heap.h
+    hle/kernel/k_page_group.cpp
     hle/kernel/k_page_group.h
     hle/kernel/k_page_table.cpp
     hle/kernel/k_page_table.h
diff --git a/src/core/hle/kernel/k_code_memory.cpp b/src/core/hle/kernel/k_code_memory.cpp
index 4b1c134d4..d9da1e600 100644
--- a/src/core/hle/kernel/k_code_memory.cpp
+++ b/src/core/hle/kernel/k_code_memory.cpp
@@ -27,13 +27,13 @@ Result KCodeMemory::Initialize(Core::DeviceMemory& device_memory, VAddr addr, si
     auto& page_table = m_owner->PageTable();
 
     // Construct the page group.
-    m_page_group = {};
+    m_page_group.emplace(kernel, page_table.GetBlockInfoManager());
 
     // Lock the memory.
-    R_TRY(page_table.LockForCodeMemory(&m_page_group, addr, size))
+    R_TRY(page_table.LockForCodeMemory(std::addressof(*m_page_group), addr, size))
 
     // Clear the memory.
-    for (const auto& block : m_page_group.Nodes()) {
+    for (const auto& block : *m_page_group) {
         std::memset(device_memory.GetPointer<void>(block.GetAddress()), 0xFF, block.GetSize());
     }
 
@@ -51,12 +51,13 @@ Result KCodeMemory::Initialize(Core::DeviceMemory& device_memory, VAddr addr, si
 void KCodeMemory::Finalize() {
     // Unlock.
     if (!m_is_mapped && !m_is_owner_mapped) {
-        const size_t size = m_page_group.GetNumPages() * PageSize;
-        m_owner->PageTable().UnlockForCodeMemory(m_address, size, m_page_group);
+        const size_t size = m_page_group->GetNumPages() * PageSize;
+        m_owner->PageTable().UnlockForCodeMemory(m_address, size, *m_page_group);
     }
 
     // Close the page group.
-    m_page_group = {};
+    m_page_group->Close();
+    m_page_group->Finalize();
 
     // Close our reference to our owner.
     m_owner->Close();
@@ -64,7 +65,7 @@ void KCodeMemory::Finalize() {
 
 Result KCodeMemory::Map(VAddr address, size_t size) {
     // Validate the size.
-    R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
+    R_UNLESS(m_page_group->GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
 
     // Lock ourselves.
     KScopedLightLock lk(m_lock);
@@ -74,7 +75,7 @@ Result KCodeMemory::Map(VAddr address, size_t size) {
 
     // Map the memory.
     R_TRY(kernel.CurrentProcess()->PageTable().MapPages(
-        address, m_page_group, KMemoryState::CodeOut, KMemoryPermission::UserReadWrite));
+        address, *m_page_group, KMemoryState::CodeOut, KMemoryPermission::UserReadWrite));
 
     // Mark ourselves as mapped.
     m_is_mapped = true;
@@ -84,13 +85,13 @@ Result KCodeMemory::Map(VAddr address, size_t size) {
 
 Result KCodeMemory::Unmap(VAddr address, size_t size) {
     // Validate the size.
-    R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
+    R_UNLESS(m_page_group->GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
 
     // Lock ourselves.
     KScopedLightLock lk(m_lock);
 
     // Unmap the memory.
-    R_TRY(kernel.CurrentProcess()->PageTable().UnmapPages(address, m_page_group,
+    R_TRY(kernel.CurrentProcess()->PageTable().UnmapPages(address, *m_page_group,
                                                           KMemoryState::CodeOut));
 
     // Mark ourselves as unmapped.
@@ -101,7 +102,7 @@ Result KCodeMemory::Unmap(VAddr address, size_t size) {
 
 Result KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermission perm) {
     // Validate the size.
-    R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
+    R_UNLESS(m_page_group->GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
 
     // Lock ourselves.
     KScopedLightLock lk(m_lock);
@@ -125,7 +126,7 @@ Result KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermission
 
     // Map the memory.
     R_TRY(
-        m_owner->PageTable().MapPages(address, m_page_group, KMemoryState::GeneratedCode, k_perm));
+        m_owner->PageTable().MapPages(address, *m_page_group, KMemoryState::GeneratedCode, k_perm));
 
     // Mark ourselves as mapped.
     m_is_owner_mapped = true;
@@ -135,13 +136,13 @@ Result KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermission
 
 Result KCodeMemory::UnmapFromOwner(VAddr address, size_t size) {
     // Validate the size.
-    R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
+    R_UNLESS(m_page_group->GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
 
     // Lock ourselves.
     KScopedLightLock lk(m_lock);
 
     // Unmap the memory.
-    R_TRY(m_owner->PageTable().UnmapPages(address, m_page_group, KMemoryState::GeneratedCode));
+    R_TRY(m_owner->PageTable().UnmapPages(address, *m_page_group, KMemoryState::GeneratedCode));
 
     // Mark ourselves as unmapped.
     m_is_owner_mapped = false;
diff --git a/src/core/hle/kernel/k_code_memory.h b/src/core/hle/kernel/k_code_memory.h
index 2e7e1436a..5b260b385 100644
--- a/src/core/hle/kernel/k_code_memory.h
+++ b/src/core/hle/kernel/k_code_memory.h
@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <optional>
+
 #include "common/common_types.h"
 #include "core/device_memory.h"
 #include "core/hle/kernel/k_auto_object.h"
@@ -49,11 +51,11 @@ public:
         return m_address;
     }
     size_t GetSize() const {
-        return m_is_initialized ? m_page_group.GetNumPages() * PageSize : 0;
+        return m_is_initialized ? m_page_group->GetNumPages() * PageSize : 0;
     }
 
 private:
-    KPageGroup m_page_group{};
+    std::optional<KPageGroup> m_page_group{};
     KProcess* m_owner{};
     VAddr m_address{};
     KLightLock m_lock;
diff --git a/src/core/hle/kernel/k_memory_manager.cpp b/src/core/hle/kernel/k_memory_manager.cpp
index bd33571da..cd6ea388e 100644
--- a/src/core/hle/kernel/k_memory_manager.cpp
+++ b/src/core/hle/kernel/k_memory_manager.cpp
@@ -223,7 +223,7 @@ Result KMemoryManager::AllocatePageGroupImpl(KPageGroup* out, size_t num_pages,
 
     // Ensure that we don't leave anything un-freed.
     ON_RESULT_FAILURE {
-        for (const auto& it : out->Nodes()) {
+        for (const auto& it : *out) {
             auto& manager = this->GetManager(it.GetAddress());
             const size_t node_num_pages = std::min<u64>(
                 it.GetNumPages(), (manager.GetEndAddress() - it.GetAddress()) / PageSize);
@@ -285,7 +285,7 @@ Result KMemoryManager::AllocateAndOpen(KPageGroup* out, size_t num_pages, u32 op
                                       m_has_optimized_process[static_cast<size_t>(pool)], true));
 
     // Open the first reference to the pages.
-    for (const auto& block : out->Nodes()) {
+    for (const auto& block : *out) {
         PAddr cur_address = block.GetAddress();
         size_t remaining_pages = block.GetNumPages();
         while (remaining_pages > 0) {
@@ -335,7 +335,7 @@ Result KMemoryManager::AllocateForProcess(KPageGroup* out, size_t num_pages, u32
     // Perform optimized memory tracking, if we should.
     if (optimized) {
         // Iterate over the allocated blocks.
-        for (const auto& block : out->Nodes()) {
+        for (const auto& block : *out) {
             // Get the block extents.
             const PAddr block_address = block.GetAddress();
             const size_t block_pages = block.GetNumPages();
@@ -391,7 +391,7 @@ Result KMemoryManager::AllocateForProcess(KPageGroup* out, size_t num_pages, u32
         }
     } else {
         // Set all the allocated memory.
-        for (const auto& block : out->Nodes()) {
+        for (const auto& block : *out) {
             std::memset(m_system.DeviceMemory().GetPointer<void>(block.GetAddress()), fill_pattern,
                         block.GetSize());
         }
diff --git a/src/core/hle/kernel/k_page_group.cpp b/src/core/hle/kernel/k_page_group.cpp
new file mode 100644
index 000000000..d8c644a33
--- /dev/null
+++ b/src/core/hle/kernel/k_page_group.cpp
@@ -0,0 +1,121 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/kernel/k_dynamic_resource_manager.h"
+#include "core/hle/kernel/k_memory_manager.h"
+#include "core/hle/kernel/k_page_group.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/svc_results.h"
+
+namespace Kernel {
+
+void KPageGroup::Finalize() {
+    KBlockInfo* cur = m_first_block;
+    while (cur != nullptr) {
+        KBlockInfo* next = cur->GetNext();
+        m_manager->Free(cur);
+        cur = next;
+    }
+
+    m_first_block = nullptr;
+    m_last_block = nullptr;
+}
+
+void KPageGroup::CloseAndReset() {
+    auto& mm = m_kernel.MemoryManager();
+
+    KBlockInfo* cur = m_first_block;
+    while (cur != nullptr) {
+        KBlockInfo* next = cur->GetNext();
+        mm.Close(cur->GetAddress(), cur->GetNumPages());
+        m_manager->Free(cur);
+        cur = next;
+    }
+
+    m_first_block = nullptr;
+    m_last_block = nullptr;
+}
+
+size_t KPageGroup::GetNumPages() const {
+    size_t num_pages = 0;
+
+    for (const auto& it : *this) {
+        num_pages += it.GetNumPages();
+    }
+
+    return num_pages;
+}
+
+Result KPageGroup::AddBlock(KPhysicalAddress addr, size_t num_pages) {
+    // Succeed immediately if we're adding no pages.
+    R_SUCCEED_IF(num_pages == 0);
+
+    // Check for overflow.
+    ASSERT(addr < addr + num_pages * PageSize);
+
+    // Try to just append to the last block.
+    if (m_last_block != nullptr) {
+        R_SUCCEED_IF(m_last_block->TryConcatenate(addr, num_pages));
+    }
+
+    // Allocate a new block.
+    KBlockInfo* new_block = m_manager->Allocate();
+    R_UNLESS(new_block != nullptr, ResultOutOfResource);
+
+    // Initialize the block.
+    new_block->Initialize(addr, num_pages);
+
+    // Add the block to our list.
+    if (m_last_block != nullptr) {
+        m_last_block->SetNext(new_block);
+    } else {
+        m_first_block = new_block;
+    }
+    m_last_block = new_block;
+
+    R_SUCCEED();
+}
+
+void KPageGroup::Open() const {
+    auto& mm = m_kernel.MemoryManager();
+
+    for (const auto& it : *this) {
+        mm.Open(it.GetAddress(), it.GetNumPages());
+    }
+}
+
+void KPageGroup::OpenFirst() const {
+    auto& mm = m_kernel.MemoryManager();
+
+    for (const auto& it : *this) {
+        mm.OpenFirst(it.GetAddress(), it.GetNumPages());
+    }
+}
+
+void KPageGroup::Close() const {
+    auto& mm = m_kernel.MemoryManager();
+
+    for (const auto& it : *this) {
+        mm.Close(it.GetAddress(), it.GetNumPages());
+    }
+}
+
+bool KPageGroup::IsEquivalentTo(const KPageGroup& rhs) const {
+    auto lit = this->begin();
+    auto rit = rhs.begin();
+    auto lend = this->end();
+    auto rend = rhs.end();
+
+    while (lit != lend && rit != rend) {
+        if (*lit != *rit) {
+            return false;
+        }
+
+        ++lit;
+        ++rit;
+    }
+
+    return lit == lend && rit == rend;
+}
+
+} // namespace Kernel
diff --git a/src/core/hle/kernel/k_page_group.h b/src/core/hle/kernel/k_page_group.h
index 316f172f2..c07f17663 100644
--- a/src/core/hle/kernel/k_page_group.h
+++ b/src/core/hle/kernel/k_page_group.h
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
@@ -13,24 +13,23 @@
 
 namespace Kernel {
 
+class KBlockInfoManager;
+class KernelCore;
 class KPageGroup;
 
 class KBlockInfo {
-private:
-    friend class KPageGroup;
-
 public:
-    constexpr KBlockInfo() = default;
+    constexpr explicit KBlockInfo() : m_next(nullptr) {}
 
-    constexpr void Initialize(PAddr addr, size_t np) {
+    constexpr void Initialize(KPhysicalAddress addr, size_t np) {
         ASSERT(Common::IsAligned(addr, PageSize));
         ASSERT(static_cast<u32>(np) == np);
 
-        m_page_index = static_cast<u32>(addr) / PageSize;
+        m_page_index = static_cast<u32>(addr / PageSize);
         m_num_pages = static_cast<u32>(np);
     }
 
-    constexpr PAddr GetAddress() const {
+    constexpr KPhysicalAddress GetAddress() const {
         return m_page_index * PageSize;
     }
     constexpr size_t GetNumPages() const {
@@ -39,10 +38,10 @@ public:
     constexpr size_t GetSize() const {
         return this->GetNumPages() * PageSize;
     }
-    constexpr PAddr GetEndAddress() const {
+    constexpr KPhysicalAddress GetEndAddress() const {
         return (m_page_index + m_num_pages) * PageSize;
     }
-    constexpr PAddr GetLastAddress() const {
+    constexpr KPhysicalAddress GetLastAddress() const {
         return this->GetEndAddress() - 1;
     }
 
@@ -62,8 +61,8 @@ public:
         return !(*this == rhs);
     }
 
-    constexpr bool IsStrictlyBefore(PAddr addr) const {
-        const PAddr end = this->GetEndAddress();
+    constexpr bool IsStrictlyBefore(KPhysicalAddress addr) const {
+        const KPhysicalAddress end = this->GetEndAddress();
 
         if (m_page_index != 0 && end == 0) {
             return false;
@@ -72,11 +71,11 @@ public:
         return end < addr;
     }
 
-    constexpr bool operator<(PAddr addr) const {
+    constexpr bool operator<(KPhysicalAddress addr) const {
         return this->IsStrictlyBefore(addr);
     }
 
-    constexpr bool TryConcatenate(PAddr addr, size_t np) {
+    constexpr bool TryConcatenate(KPhysicalAddress addr, size_t np) {
         if (addr != 0 && addr == this->GetEndAddress()) {
             m_num_pages += static_cast<u32>(np);
             return true;
@@ -90,96 +89,118 @@ private:
     }
 
 private:
+    friend class KPageGroup;
+
     KBlockInfo* m_next{};
     u32 m_page_index{};
     u32 m_num_pages{};
 };
 static_assert(sizeof(KBlockInfo) <= 0x10);
 
-class KPageGroup final {
+class KPageGroup {
 public:
-    class Node final {
+    class Iterator {
     public:
-        constexpr Node(u64 addr_, std::size_t num_pages_) : addr{addr_}, num_pages{num_pages_} {}
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = const KBlockInfo;
+        using difference_type = std::ptrdiff_t;
+        using pointer = value_type*;
+        using reference = value_type&;
+
+        constexpr explicit Iterator(pointer n) : m_node(n) {}
+
+        constexpr bool operator==(const Iterator& rhs) const {
+            return m_node == rhs.m_node;
+        }
+        constexpr bool operator!=(const Iterator& rhs) const {
+            return !(*this == rhs);
+        }
 
-        constexpr u64 GetAddress() const {
-            return addr;
+        constexpr pointer operator->() const {
+            return m_node;
+        }
+        constexpr reference operator*() const {
+            return *m_node;
         }
 
-        constexpr std::size_t GetNumPages() const {
-            return num_pages;
+        constexpr Iterator& operator++() {
+            m_node = m_node->GetNext();
+            return *this;
         }
 
-        constexpr std::size_t GetSize() const {
-            return GetNumPages() * PageSize;
+        constexpr Iterator operator++(int) {
+            const Iterator it{*this};
+            ++(*this);
+            return it;
         }
 
     private:
-        u64 addr{};
-        std::size_t num_pages{};
+        pointer m_node{};
     };
 
-public:
-    KPageGroup() = default;
-    KPageGroup(u64 address, u64 num_pages) {
-        ASSERT(AddBlock(address, num_pages).IsSuccess());
+    explicit KPageGroup(KernelCore& kernel, KBlockInfoManager* m)
+        : m_kernel{kernel}, m_manager{m} {}
+    ~KPageGroup() {
+        this->Finalize();
     }
 
-    constexpr std::list<Node>& Nodes() {
-        return nodes;
-    }
+    void CloseAndReset();
+    void Finalize();
 
-    constexpr const std::list<Node>& Nodes() const {
-        return nodes;
+    Iterator begin() const {
+        return Iterator{m_first_block};
+    }
+    Iterator end() const {
+        return Iterator{nullptr};
+    }
+    bool empty() const {
+        return m_first_block == nullptr;
     }
 
-    std::size_t GetNumPages() const {
-        std::size_t num_pages = 0;
-        for (const Node& node : nodes) {
-            num_pages += node.GetNumPages();
-        }
-        return num_pages;
-    }
-
-    bool IsEqual(KPageGroup& other) const {
-        auto this_node = nodes.begin();
-        auto other_node = other.nodes.begin();
-        while (this_node != nodes.end() && other_node != other.nodes.end()) {
-            if (this_node->GetAddress() != other_node->GetAddress() ||
-                this_node->GetNumPages() != other_node->GetNumPages()) {
-                return false;
-            }
-            this_node = std::next(this_node);
-            other_node = std::next(other_node);
-        }
+    Result AddBlock(KPhysicalAddress addr, size_t num_pages);
+    void Open() const;
+    void OpenFirst() const;
+    void Close() const;
+
+    size_t GetNumPages() const;
+
+    bool IsEquivalentTo(const KPageGroup& rhs) const;
+
+    bool operator==(const KPageGroup& rhs) const {
+        return this->IsEquivalentTo(rhs);
+    }
 
-        return this_node == nodes.end() && other_node == other.nodes.end();
+    bool operator!=(const KPageGroup& rhs) const {
+        return !(*this == rhs);
     }
 
-    Result AddBlock(u64 address, u64 num_pages) {
-        if (!num_pages) {
-            return ResultSuccess;
+private:
+    KernelCore& m_kernel;
+    KBlockInfo* m_first_block{};
+    KBlockInfo* m_last_block{};
+    KBlockInfoManager* m_manager{};
+};
+
+class KScopedPageGroup {
+public:
+    explicit KScopedPageGroup(const KPageGroup* gp) : m_pg(gp) {
+        if (m_pg) {
+            m_pg->Open();
         }
-        if (!nodes.empty()) {
-            const auto node = nodes.back();
-            if (node.GetAddress() + node.GetNumPages() * PageSize == address) {
-                address = node.GetAddress();
-                num_pages += node.GetNumPages();
-                nodes.pop_back();
-            }
+    }
+    explicit KScopedPageGroup(const KPageGroup& gp) : KScopedPageGroup(std::addressof(gp)) {}
+    ~KScopedPageGroup() {
+        if (m_pg) {
+            m_pg->Close();
         }
-        nodes.push_back({address, num_pages});
-        return ResultSuccess;
     }
 
-    bool Empty() const {
-        return nodes.empty();
+    void CancelClose() {
+        m_pg = nullptr;
     }
 
-    void Finalize() {}
-
 private:
-    std::list<Node> nodes;
+    const KPageGroup* m_pg{};
 };
 
 } // namespace Kernel
diff --git a/src/core/hle/kernel/k_page_table.cpp b/src/core/hle/kernel/k_page_table.cpp
index 612fc76fa..9c7ac22dc 100644
--- a/src/core/hle/kernel/k_page_table.cpp
+++ b/src/core/hle/kernel/k_page_table.cpp
@@ -100,7 +100,7 @@ constexpr size_t GetAddressSpaceWidthFromType(FileSys::ProgramAddressSpaceType a
 
 KPageTable::KPageTable(Core::System& system_)
     : m_general_lock{system_.Kernel()},
-      m_map_physical_memory_lock{system_.Kernel()}, m_system{system_} {}
+      m_map_physical_memory_lock{system_.Kernel()}, m_system{system_}, m_kernel{system_.Kernel()} {}
 
 KPageTable::~KPageTable() = default;
 
@@ -373,7 +373,7 @@ Result KPageTable::MapProcessCode(VAddr addr, size_t num_pages, KMemoryState sta
                                                  m_memory_block_slab_manager);
 
     // Allocate and open.
-    KPageGroup pg;
+    KPageGroup pg{m_kernel, m_block_info_manager};
     R_TRY(m_system.Kernel().MemoryManager().AllocateAndOpen(
         &pg, num_pages,
         KMemoryManager::EncodeOption(KMemoryManager::Pool::Application, m_allocation_option)));
@@ -432,7 +432,7 @@ Result KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, size_t si
         const size_t num_pages = size / PageSize;
 
         // Create page groups for the memory being mapped.
-        KPageGroup pg;
+        KPageGroup pg{m_kernel, m_block_info_manager};
         AddRegionToPages(src_address, num_pages, pg);
 
         // Reprotect the source as kernel-read/not mapped.
@@ -593,7 +593,7 @@ Result KPageTable::MakePageGroup(KPageGroup& pg, VAddr addr, size_t num_pages) {
     const size_t size = num_pages * PageSize;
 
     // We're making a new group, not adding to an existing one.
-    R_UNLESS(pg.Empty(), ResultInvalidCurrentMemory);
+    R_UNLESS(pg.empty(), ResultInvalidCurrentMemory);
 
     // Begin traversal.
     Common::PageTable::TraversalContext context;
@@ -640,11 +640,10 @@ Result KPageTable::MakePageGroup(KPageGroup& pg, VAddr addr, size_t num_pages) {
     R_SUCCEED();
 }
 
-bool KPageTable::IsValidPageGroup(const KPageGroup& pg_ll, VAddr addr, size_t num_pages) {
+bool KPageTable::IsValidPageGroup(const KPageGroup& pg, VAddr addr, size_t num_pages) {
     ASSERT(this->IsLockedByCurrentThread());
 
     const size_t size = num_pages * PageSize;
-    const auto& pg = pg_ll.Nodes();
     const auto& memory_layout = m_system.Kernel().MemoryLayout();
 
     // Empty groups are necessarily invalid.
@@ -942,9 +941,6 @@ Result KPageTable::SetupForIpcServer(VAddr* out_addr, size_t size, VAddr src_add
 
     ON_RESULT_FAILURE {
         if (cur_mapped_addr != dst_addr) {
-            // HACK: Manually close the pages.
-            HACK_ClosePages(dst_addr, (cur_mapped_addr - dst_addr) / PageSize);
-
             ASSERT(Operate(dst_addr, (cur_mapped_addr - dst_addr) / PageSize,
                            KMemoryPermission::None, OperationType::Unmap)
                        .IsSuccess());
@@ -1020,9 +1016,6 @@ Result KPageTable::SetupForIpcServer(VAddr* out_addr, size_t size, VAddr src_add
         // Map the page.
         R_TRY(Operate(cur_mapped_addr, 1, test_perm, OperationType::Map, start_partial_page));
 
-        // HACK: Manually open the pages.
-        HACK_OpenPages(start_partial_page, 1);
-
         // Update tracking extents.
         cur_mapped_addr += PageSize;
         cur_block_addr += PageSize;
@@ -1051,9 +1044,6 @@ Result KPageTable::SetupForIpcServer(VAddr* out_addr, size_t size, VAddr src_add
             R_TRY(Operate(cur_mapped_addr, cur_block_size / PageSize, test_perm, OperationType::Map,
                           cur_block_addr));
 
-            // HACK: Manually open the pages.
-            HACK_OpenPages(cur_block_addr, cur_block_size / PageSize);
-
             // Update tracking extents.
             cur_mapped_addr += cur_block_size;
             cur_block_addr = next_entry.phys_addr;
@@ -1073,9 +1063,6 @@ Result KPageTable::SetupForIpcServer(VAddr* out_addr, size_t size, VAddr src_add
         R_TRY(Operate(cur_mapped_addr, last_block_size / PageSize, test_perm, OperationType::Map,
                       cur_block_addr));
 
-        // HACK: Manually open the pages.
-        HACK_OpenPages(cur_block_addr, last_block_size / PageSize);
-
         // Update tracking extents.
         cur_mapped_addr += last_block_size;
         cur_block_addr += last_block_size;
@@ -1107,9 +1094,6 @@ Result KPageTable::SetupForIpcServer(VAddr* out_addr, size_t size, VAddr src_add
 
         // Map the page.
         R_TRY(Operate(cur_mapped_addr, 1, test_perm, OperationType::Map, end_partial_page));
-
-        // HACK: Manually open the pages.
-        HACK_OpenPages(end_partial_page, 1);
     }
 
     // Update memory blocks to reflect our changes
@@ -1211,9 +1195,6 @@ Result KPageTable::CleanupForIpcServer(VAddr address, size_t size, KMemoryState
     const size_t aligned_size = aligned_end - aligned_start;
     const size_t aligned_num_pages = aligned_size / PageSize;
 
-    // HACK: Manually close the pages.
-    HACK_ClosePages(aligned_start, aligned_num_pages);
-
     // Unmap the pages.
     R_TRY(Operate(aligned_start, aligned_num_pages, KMemoryPermission::None, OperationType::Unmap));
 
@@ -1501,17 +1482,6 @@ void KPageTable::CleanupForIpcClientOnServerSetupFailure([[maybe_unused]] PageLi
     }
 }
 
-void KPageTable::HACK_OpenPages(PAddr phys_addr, size_t num_pages) {
-    m_system.Kernel().MemoryManager().OpenFirst(phys_addr, num_pages);
-}
-
-void KPageTable::HACK_ClosePages(VAddr virt_addr, size_t num_pages) {
-    for (size_t index = 0; index < num_pages; ++index) {
-        const auto paddr = GetPhysicalAddr(virt_addr + (index * PageSize));
-        m_system.Kernel().MemoryManager().Close(paddr, 1);
-    }
-}
-
 Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
     // Lock the physical memory lock.
     KScopedLightLock phys_lk(m_map_physical_memory_lock);
@@ -1572,7 +1542,7 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
             R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);
 
             // Allocate pages for the new memory.
-            KPageGroup pg;
+            KPageGroup pg{m_kernel, m_block_info_manager};
             R_TRY(m_system.Kernel().MemoryManager().AllocateForProcess(
                 &pg, (size - mapped_size) / PageSize, m_allocate_option, 0, 0));
 
@@ -1650,7 +1620,7 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
                 KScopedPageTableUpdater updater(this);
 
                 // Prepare to iterate over the memory.
-                auto pg_it = pg.Nodes().begin();
+                auto pg_it = pg.begin();
                 PAddr pg_phys_addr = pg_it->GetAddress();
                 size_t pg_pages = pg_it->GetNumPages();
 
@@ -1680,9 +1650,6 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
                                              last_unmap_address + 1 - cur_address) /
                                     PageSize;
 
-                                // HACK: Manually close the pages.
-                                HACK_ClosePages(cur_address, cur_pages);
-
                                 // Unmap.
                                 ASSERT(Operate(cur_address, cur_pages, KMemoryPermission::None,
                                                OperationType::Unmap)
@@ -1703,7 +1670,7 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
                     // Release any remaining unmapped memory.
                     m_system.Kernel().MemoryManager().OpenFirst(pg_phys_addr, pg_pages);
                     m_system.Kernel().MemoryManager().Close(pg_phys_addr, pg_pages);
-                    for (++pg_it; pg_it != pg.Nodes().end(); ++pg_it) {
+                    for (++pg_it; pg_it != pg.end(); ++pg_it) {
                         m_system.Kernel().MemoryManager().OpenFirst(pg_it->GetAddress(),
                                                                     pg_it->GetNumPages());
                         m_system.Kernel().MemoryManager().Close(pg_it->GetAddress(),
@@ -1731,7 +1698,7 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
                             // Check if we're at the end of the physical block.
                             if (pg_pages == 0) {
                                 // Ensure there are more pages to map.
-                                ASSERT(pg_it != pg.Nodes().end());
+                                ASSERT(pg_it != pg.end());
 
                                 // Advance our physical block.
                                 ++pg_it;
@@ -1742,10 +1709,7 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
                             // Map whatever we can.
                             const size_t cur_pages = std::min(pg_pages, map_pages);
                             R_TRY(Operate(cur_address, cur_pages, KMemoryPermission::UserReadWrite,
-                                          OperationType::Map, pg_phys_addr));
-
-                            // HACK: Manually open the pages.
-                            HACK_OpenPages(pg_phys_addr, cur_pages);
+                                          OperationType::MapFirst, pg_phys_addr));
 
                             // Advance.
                             cur_address += cur_pages * PageSize;
@@ -1888,9 +1852,6 @@ Result KPageTable::UnmapPhysicalMemory(VAddr address, size_t size) {
                                               last_address + 1 - cur_address) /
                                      PageSize;
 
-            // HACK: Manually close the pages.
-            HACK_ClosePages(cur_address, cur_pages);
-
             // Unmap.
             ASSERT(Operate(cur_address, cur_pages, KMemoryPermission::None, OperationType::Unmap)
                        .IsSuccess());
@@ -1955,7 +1916,7 @@ Result KPageTable::MapMemory(VAddr dst_address, VAddr src_address, size_t size)
     R_TRY(dst_allocator_result);
 
     // Map the memory.
-    KPageGroup page_linked_list;
+    KPageGroup page_linked_list{m_kernel, m_block_info_manager};
     const size_t num_pages{size / PageSize};
     const KMemoryPermission new_src_perm = static_cast<KMemoryPermission>(
         KMemoryPermission::KernelRead | KMemoryPermission::NotMapped);
@@ -2022,14 +1983,14 @@ Result KPageTable::UnmapMemory(VAddr dst_address, VAddr src_address, size_t size
                                                      num_dst_allocator_blocks);
     R_TRY(dst_allocator_result);
 
-    KPageGroup src_pages;
-    KPageGroup dst_pages;
+    KPageGroup src_pages{m_kernel, m_block_info_manager};
+    KPageGroup dst_pages{m_kernel, m_block_info_manager};
     const size_t num_pages{size / PageSize};
 
     AddRegionToPages(src_address, num_pages, src_pages);
     AddRegionToPages(dst_address, num_pages, dst_pages);
 
-    R_UNLESS(dst_pages.IsEqual(src_pages), ResultInvalidMemoryRegion);
+    R_UNLESS(dst_pages.IsEquivalentTo(src_pages), ResultInvalidMemoryRegion);
 
     {
         auto block_guard = detail::ScopeExit([&] { MapPages(dst_address, dst_pages, dst_perm); });
@@ -2060,7 +2021,7 @@ Result KPageTable::MapPages(VAddr addr, const KPageGroup& page_linked_list,
 
     VAddr cur_addr{addr};
 
-    for (const auto& node : page_linked_list.Nodes()) {
+    for (const auto& node : page_linked_list) {
         if (const auto result{
                 Operate(cur_addr, node.GetNumPages(), perm, OperationType::Map, node.GetAddress())};
             result.IsError()) {
@@ -2160,7 +2121,7 @@ Result KPageTable::UnmapPages(VAddr addr, const KPageGroup& page_linked_list) {
 
     VAddr cur_addr{addr};
 
-    for (const auto& node : page_linked_list.Nodes()) {
+    for (const auto& node : page_linked_list) {
         if (const auto result{Operate(cur_addr, node.GetNumPages(), KMemoryPermission::None,
                                       OperationType::Unmap)};
             result.IsError()) {
@@ -2527,13 +2488,13 @@ Result KPageTable::SetHeapSize(VAddr* out, size_t size) {
     R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);
 
     // Allocate pages for the heap extension.
-    KPageGroup pg;
+    KPageGroup pg{m_kernel, m_block_info_manager};
     R_TRY(m_system.Kernel().MemoryManager().AllocateAndOpen(
         &pg, allocation_size / PageSize,
         KMemoryManager::EncodeOption(m_memory_pool, m_allocation_option)));
 
     // Clear all the newly allocated pages.
-    for (const auto& it : pg.Nodes()) {
+    for (const auto& it : pg) {
         std::memset(m_system.DeviceMemory().GetPointer<void>(it.GetAddress()), m_heap_fill_value,
                     it.GetSize());
     }
@@ -2610,11 +2571,23 @@ ResultVal<VAddr> KPageTable::AllocateAndMapMemory(size_t needed_num_pages, size_
     if (is_map_only) {
         R_TRY(Operate(addr, needed_num_pages, perm, OperationType::Map, map_addr));
     } else {
-        KPageGroup page_group;
-        R_TRY(m_system.Kernel().MemoryManager().AllocateForProcess(
-            &page_group, needed_num_pages,
-            KMemoryManager::EncodeOption(m_memory_pool, m_allocation_option), 0, 0));
-        R_TRY(Operate(addr, needed_num_pages, page_group, OperationType::MapGroup));
+        // Create a page group tohold the pages we allocate.
+        KPageGroup pg{m_kernel, m_block_info_manager};
+
+        R_TRY(m_system.Kernel().MemoryManager().AllocateAndOpen(
+            &pg, needed_num_pages,
+            KMemoryManager::EncodeOption(m_memory_pool, m_allocation_option)));
+
+        // Ensure that the page group is closed when we're done working with it.
+        SCOPE_EXIT({ pg.Close(); });
+
+        // Clear all pages.
+        for (const auto& it : pg) {
+            std::memset(m_system.DeviceMemory().GetPointer<void>(it.GetAddress()),
+                        m_heap_fill_value, it.GetSize());
+        }
+
+        R_TRY(Operate(addr, needed_num_pages, pg, OperationType::MapGroup));
     }
 
     // Update the blocks.
@@ -2795,19 +2768,28 @@ Result KPageTable::Operate(VAddr addr, size_t num_pages, const KPageGroup& page_
     ASSERT(num_pages > 0);
     ASSERT(num_pages == page_group.GetNumPages());
 
-    for (const auto& node : page_group.Nodes()) {
-        const size_t size{node.GetNumPages() * PageSize};
+    switch (operation) {
+    case OperationType::MapGroup: {
+        // We want to maintain a new reference to every page in the group.
+        KScopedPageGroup spg(page_group);
+
+        for (const auto& node : page_group) {
+            const size_t size{node.GetNumPages() * PageSize};
 
-        switch (operation) {
-        case OperationType::MapGroup:
+            // Map the pages.
             m_system.Memory().MapMemoryRegion(*m_page_table_impl, addr, size, node.GetAddress());
-            break;
-        default:
-            ASSERT(false);
-            break;
+
+            addr += size;
         }
 
-        addr += size;
+        // We succeeded! We want to persist the reference to the pages.
+        spg.CancelClose();
+
+        break;
+    }
+    default:
+        ASSERT(false);
+        break;
     }
 
     R_SUCCEED();
@@ -2822,13 +2804,29 @@ Result KPageTable::Operate(VAddr addr, size_t num_pages, KMemoryPermission perm,
     ASSERT(ContainsPages(addr, num_pages));
 
     switch (operation) {
-    case OperationType::Unmap:
+    case OperationType::Unmap: {
+        // Ensure that any pages we track close on exit.
+        KPageGroup pages_to_close{m_kernel, this->GetBlockInfoManager()};
+        SCOPE_EXIT({ pages_to_close.CloseAndReset(); });
+
+        this->AddRegionToPages(addr, num_pages, pages_to_close);
         m_system.Memory().UnmapRegion(*m_page_table_impl, addr, num_pages * PageSize);
         break;
+    }
+    case OperationType::MapFirst:
     case OperationType::Map: {
         ASSERT(map_addr);
         ASSERT(Common::IsAligned(map_addr, PageSize));
         m_system.Memory().MapMemoryRegion(*m_page_table_impl, addr, num_pages * PageSize, map_addr);
+
+        // Open references to pages, if we should.
+        if (IsHeapPhysicalAddress(m_kernel.MemoryLayout(), map_addr)) {
+            if (operation == OperationType::MapFirst) {
+                m_kernel.MemoryManager().OpenFirst(map_addr, num_pages);
+            } else {
+                m_kernel.MemoryManager().Open(map_addr, num_pages);
+            }
+        }
         break;
     }
     case OperationType::Separate: {
diff --git a/src/core/hle/kernel/k_page_table.h b/src/core/hle/kernel/k_page_table.h
index f1ca785d7..0a454b05b 100644
--- a/src/core/hle/kernel/k_page_table.h
+++ b/src/core/hle/kernel/k_page_table.h
@@ -107,6 +107,10 @@ public:
         return *m_page_table_impl;
     }
 
+    KBlockInfoManager* GetBlockInfoManager() {
+        return m_block_info_manager;
+    }
+
     bool CanContain(VAddr addr, size_t size, KMemoryState state) const;
 
 protected:
@@ -261,10 +265,6 @@ private:
     void CleanupForIpcClientOnServerSetupFailure(PageLinkedList* page_list, VAddr address,
                                                  size_t size, KMemoryPermission prot_perm);
 
-    // HACK: These will be removed once we automatically manage page reference counts.
-    void HACK_OpenPages(PAddr phys_addr, size_t num_pages);
-    void HACK_ClosePages(VAddr virt_addr, size_t num_pages);
-
     mutable KLightLock m_general_lock;
     mutable KLightLock m_map_physical_memory_lock;
 
@@ -488,6 +488,7 @@ private:
     std::unique_ptr<Common::PageTable> m_page_table_impl;
 
     Core::System& m_system;
+    KernelCore& m_kernel;
 };
 
 } // namespace Kernel
diff --git a/src/core/hle/kernel/k_shared_memory.cpp b/src/core/hle/kernel/k_shared_memory.cpp
index 0aa68103c..3cf2b5d91 100644
--- a/src/core/hle/kernel/k_shared_memory.cpp
+++ b/src/core/hle/kernel/k_shared_memory.cpp
@@ -13,10 +13,7 @@
 namespace Kernel {
 
 KSharedMemory::KSharedMemory(KernelCore& kernel_) : KAutoObjectWithSlabHeapAndContainer{kernel_} {}
-
-KSharedMemory::~KSharedMemory() {
-    kernel.GetSystemResourceLimit()->Release(LimitableResource::PhysicalMemoryMax, size);
-}
+KSharedMemory::~KSharedMemory() = default;
 
 Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
                                  Svc::MemoryPermission owner_permission_,
@@ -49,7 +46,8 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
     R_UNLESS(physical_address != 0, ResultOutOfMemory);
 
     //! Insert the result into our page group.
-    page_group.emplace(physical_address, num_pages);
+    page_group.emplace(kernel, &kernel.GetSystemSystemResource().GetBlockInfoManager());
+    page_group->AddBlock(physical_address, num_pages);
 
     // Commit our reservation.
     memory_reservation.Commit();
@@ -62,7 +60,7 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
     is_initialized = true;
 
     // Clear all pages in the memory.
-    for (const auto& block : page_group->Nodes()) {
+    for (const auto& block : *page_group) {
         std::memset(device_memory_.GetPointer<void>(block.GetAddress()), 0, block.GetSize());
     }
 
@@ -71,13 +69,8 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
 
 void KSharedMemory::Finalize() {
     // Close and finalize the page group.
-    // page_group->Close();
-    // page_group->Finalize();
-
-    //! HACK: Manually close.
-    for (const auto& block : page_group->Nodes()) {
-        kernel.MemoryManager().Close(block.GetAddress(), block.GetNumPages());
-    }
+    page_group->Close();
+    page_group->Finalize();
 
     // Release the memory reservation.
     resource_limit->Release(LimitableResource::PhysicalMemoryMax, size);
diff --git a/src/core/hle/kernel/memory_types.h b/src/core/hle/kernel/memory_types.h
index 3975507bd..92b8b37ac 100644
--- a/src/core/hle/kernel/memory_types.h
+++ b/src/core/hle/kernel/memory_types.h
@@ -14,4 +14,7 @@ constexpr std::size_t PageSize{1 << PageBits};
 
 using Page = std::array<u8, PageSize>;
 
+using KPhysicalAddress = PAddr;
+using KProcessAddress = VAddr;
+
 } // namespace Kernel
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index 788ee2160..aca442196 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -1485,7 +1485,7 @@ static Result MapProcessMemory(Core::System& system, VAddr dst_address, Handle p
              ResultInvalidMemoryRegion);
 
     // Create a new page group.
-    KPageGroup pg;
+    KPageGroup pg{system.Kernel(), dst_pt.GetBlockInfoManager()};
     R_TRY(src_pt.MakeAndOpenPageGroup(
         std::addressof(pg), src_address, size / PageSize, KMemoryState::FlagCanMapProcess,
         KMemoryState::FlagCanMapProcess, KMemoryPermission::None, KMemoryPermission::None,
diff --git a/src/input_common/drivers/tas_input.cpp b/src/input_common/drivers/tas_input.cpp
index f3ade90da..f3cb14c56 100644
--- a/src/input_common/drivers/tas_input.cpp
+++ b/src/input_common/drivers/tas_input.cpp
@@ -156,10 +156,12 @@ void Tas::RecordInput(u64 buttons, TasAnalog left_axis, TasAnalog right_axis) {
     };
 }
 
-std::tuple<TasState, size_t, size_t> Tas::GetStatus() const {
+std::tuple<TasState, size_t, std::array<size_t, PLAYER_NUMBER>> Tas::GetStatus() const {
     TasState state;
+    std::array<size_t, PLAYER_NUMBER> lengths{0};
     if (is_recording) {
-        return {TasState::Recording, 0, record_commands.size()};
+        lengths[0] = record_commands.size();
+        return {TasState::Recording, record_commands.size(), lengths};
     }
 
     if (is_running) {
@@ -168,7 +170,11 @@ std::tuple<TasState, size_t, size_t> Tas::GetStatus() const {
         state = TasState::Stopped;
     }
 
-    return {state, current_command, script_length};
+    for (size_t i = 0; i < PLAYER_NUMBER; i++) {
+        lengths[i] = commands[i].size();
+    }
+
+    return {state, current_command, lengths};
 }
 
 void Tas::UpdateThread() {
diff --git a/src/input_common/drivers/tas_input.h b/src/input_common/drivers/tas_input.h
index 38a27a230..5be66d142 100644
--- a/src/input_common/drivers/tas_input.h
+++ b/src/input_common/drivers/tas_input.h
@@ -124,7 +124,7 @@ public:
      * Current playback progress ;
      * Total length of script file currently loaded or being recorded
      */
-    std::tuple<TasState, size_t, size_t> GetStatus() const;
+    std::tuple<TasState, size_t, std::array<size_t, PLAYER_NUMBER>> GetStatus() const;
 
 private:
     enum class TasAxis : u8;
diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
index 52855120c..2a8d9e377 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
@@ -112,6 +99,7 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
                  state_tracker, scheduler) {
     if (Settings::values.renderer_force_max_clock.GetValue() && device.ShouldBoostClocks()) {
         turbo_mode.emplace(instance, dld);
+        scheduler.RegisterOnSubmit([this] { turbo_mode->QueueSubmitted(); });
     }
     Report();
 } catch (const vk::Exception& exception) {
@@ -120,6 +108,7 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
 }
 
 RendererVulkan::~RendererVulkan() {
+    scheduler.RegisterOnSubmit([] {});
     void(device.GetLogical().WaitIdle());
 }
 
diff --git a/src/video_core/renderer_vulkan/vk_scheduler.cpp b/src/video_core/renderer_vulkan/vk_scheduler.cpp
index c2e53a5d5..e03685af1 100644
--- a/src/video_core/renderer_vulkan/vk_scheduler.cpp
+++ b/src/video_core/renderer_vulkan/vk_scheduler.cpp
@@ -213,6 +213,11 @@ void Scheduler::SubmitExecution(VkSemaphore signal_semaphore, VkSemaphore wait_s
             .signalSemaphoreCount = num_signal_semaphores,
             .pSignalSemaphores = signal_semaphores.data(),
         };
+
+        if (on_submit) {
+            on_submit();
+        }
+
         switch (const VkResult result = device.GetGraphicsQueue().Submit(submit_info)) {
         case VK_SUCCESS:
             break;
diff --git a/src/video_core/renderer_vulkan/vk_scheduler.h b/src/video_core/renderer_vulkan/vk_scheduler.h
index 3858c506c..bd4cb0f7e 100644
--- a/src/video_core/renderer_vulkan/vk_scheduler.h
+++ b/src/video_core/renderer_vulkan/vk_scheduler.h
@@ -5,6 +5,7 @@
 
 #include <condition_variable>
 #include <cstddef>
+#include <functional>
 #include <memory>
 #include <thread>
 #include <utility>
@@ -66,6 +67,11 @@ public:
         query_cache = &query_cache_;
     }
 
+    // Registers a callback to perform on queue submission.
+    void RegisterOnSubmit(std::function<void()>&& func) {
+        on_submit = std::move(func);
+    }
+
     /// Send work to a separate thread.
     template <typename T>
     void Record(T&& command) {
@@ -216,6 +222,7 @@ private:
     vk::CommandBuffer current_cmdbuf;
 
     std::unique_ptr<CommandChunk> chunk;
+    std::function<void()> on_submit;
 
     State state;
 
diff --git a/src/video_core/renderer_vulkan/vk_turbo_mode.cpp b/src/video_core/renderer_vulkan/vk_turbo_mode.cpp
index 852b86f84..c42594149 100644
--- a/src/video_core/renderer_vulkan/vk_turbo_mode.cpp
+++ b/src/video_core/renderer_vulkan/vk_turbo_mode.cpp
@@ -14,11 +14,21 @@ using namespace Common::Literals;
 
 TurboMode::TurboMode(const vk::Instance& instance, const vk::InstanceDispatch& dld)
     : m_device{CreateDevice(instance, dld, VK_NULL_HANDLE)}, m_allocator{m_device, false} {
+    {
+        std::scoped_lock lk{m_submission_lock};
+        m_submission_time = std::chrono::steady_clock::now();
+    }
     m_thread = std::jthread([&](auto stop_token) { Run(stop_token); });
 }
 
 TurboMode::~TurboMode() = default;
 
+void TurboMode::QueueSubmitted() {
+    std::scoped_lock lk{m_submission_lock};
+    m_submission_time = std::chrono::steady_clock::now();
+    m_submission_cv.notify_one();
+}
+
 void TurboMode::Run(std::stop_token stop_token) {
     auto& dld = m_device.GetLogical();
 
@@ -199,6 +209,13 @@ void TurboMode::Run(std::stop_token stop_token) {
 
         // Wait for completion.
         fence.Wait();
+
+        // Wait for the next graphics queue submission if necessary.
+        std::unique_lock lk{m_submission_lock};
+        Common::CondvarWait(m_submission_cv, lk, stop_token, [this] {
+            return (std::chrono::steady_clock::now() - m_submission_time) <=
+                   std::chrono::milliseconds{100};
+        });
     }
 }
 
diff --git a/src/video_core/renderer_vulkan/vk_turbo_mode.h b/src/video_core/renderer_vulkan/vk_turbo_mode.h
index 2060e2395..99b5ac50b 100644
--- a/src/video_core/renderer_vulkan/vk_turbo_mode.h
+++ b/src/video_core/renderer_vulkan/vk_turbo_mode.h
@@ -3,6 +3,9 @@
 
 #pragma once
 
+#include <chrono>
+#include <mutex>
+
 #include "common/polyfill_thread.h"
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_memory_allocator.h"
@@ -15,11 +18,17 @@ public:
     explicit TurboMode(const vk::Instance& instance, const vk::InstanceDispatch& dld);
     ~TurboMode();
 
+    void QueueSubmitted();
+
 private:
     void Run(std::stop_token stop_token);
 
     Device m_device;
     MemoryAllocator m_allocator;
+    std::mutex m_submission_lock;
+    std::condition_variable_any m_submission_cv;
+    std::chrono::time_point<std::chrono::steady_clock> m_submission_time{};
+
     std::jthread m_thread;
 };
 
diff --git a/src/video_core/vulkan_common/vulkan_device.cpp b/src/video_core/vulkan_common/vulkan_device.cpp
index fd1c5a683..23d922e5d 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,55 @@ 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);
-    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");
-    }
+    // Get suitability and device properties.
+    const bool is_suitable = GetSuitability(surface != nullptr);
 
-    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);
-    }
+    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;
+    const bool is_mvk = driver_id == VK_DRIVER_ID_MOLTENVK;
 
-    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;
+    if (is_mvk && !is_suitable) {
+        LOG_WARNING(Render_Vulkan, "Unsuitable driver is MoltenVK, continuing anyway");
+    } else if (!is_suitable) {
+        throw vk::Exception(VK_ERROR_INCOMPATIBLE_DRIVER);
     }
 
-    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");
-    }
+    SetupFamilies(surface);
+    const auto queue_cis = GetDeviceQueueCreateInfos();
 
-    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 +337,39 @@ 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;
-
+    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 +378,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");
@@ -857,10 +456,17 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         LOG_WARNING(Render_Vulkan, "ANV driver does not support native BGR format");
         must_emulate_bgr565 = true;
     }
+    if (is_mvk) {
+        LOG_WARNING(Render_Vulkan,
+                    "MVK driver breaks when using more than 16 vertex attributes/bindings");
+        properties.properties.limits.maxVertexInputAttributes =
+            std::min(properties.properties.limits.maxVertexInputAttributes, 16U);
+        properties.properties.limits.maxVertexInputBindings =
+            std::min(properties.properties.limits.maxVertexInputBindings, 16U);
+    }
 
-    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 +521,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 +539,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 +577,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 +593,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 +960,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 +975,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 +992,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 +1008,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..0662a2d9f 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,156 @@
 #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, DRAW_INDIRECT_COUNT, draw_indirect_count)                                       \
+    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 +239,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 +311,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 +346,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 +498,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 +516,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 +529,7 @@ public:
     }
 
     bool CanReportMemoryUsage() const {
-        return ext_memory_budget;
+        return extensions.memory_budget;
     }
 
     u64 GetDeviceMemoryUsage() const;
@@ -400,36 +551,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 +584,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;
diff --git a/src/video_core/vulkan_common/vulkan_wrapper.cpp b/src/video_core/vulkan_common/vulkan_wrapper.cpp
index 61be1fce1..486d4dfaf 100644
--- a/src/video_core/vulkan_common/vulkan_wrapper.cpp
+++ b/src/video_core/vulkan_common/vulkan_wrapper.cpp
@@ -96,8 +96,8 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkCmdDrawIndexed);
     X(vkCmdDrawIndirect);
     X(vkCmdDrawIndexedIndirect);
-    X(vkCmdDrawIndirectCountKHR);
-    X(vkCmdDrawIndexedIndirectCountKHR);
+    X(vkCmdDrawIndirectCount);
+    X(vkCmdDrawIndexedIndirectCount);
     X(vkCmdEndQuery);
     X(vkCmdEndRenderPass);
     X(vkCmdEndTransformFeedbackEXT);
@@ -221,6 +221,12 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     if (!dld.vkResetQueryPool) {
         Proc(dld.vkResetQueryPool, dld, "vkResetQueryPoolEXT", device);
     }
+
+    // Support for draw indirect with count is optional in Vulkan 1.2
+    if (!dld.vkCmdDrawIndirectCount) {
+        Proc(dld.vkCmdDrawIndirectCount, dld, "vkCmdDrawIndirectCountKHR", device);
+        Proc(dld.vkCmdDrawIndexedIndirectCount, dld, "vkCmdDrawIndexedIndirectCountKHR", device);
+    }
 #undef X
 }
 
diff --git a/src/video_core/vulkan_common/vulkan_wrapper.h b/src/video_core/vulkan_common/vulkan_wrapper.h
index 412779b51..e86f661cb 100644
--- a/src/video_core/vulkan_common/vulkan_wrapper.h
+++ b/src/video_core/vulkan_common/vulkan_wrapper.h
@@ -215,8 +215,8 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkCmdDrawIndexed vkCmdDrawIndexed{};
     PFN_vkCmdDrawIndirect vkCmdDrawIndirect{};
     PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect{};
-    PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR{};
-    PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR{};
+    PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount{};
+    PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount{};
     PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT{};
     PFN_vkCmdEndQuery vkCmdEndQuery{};
     PFN_vkCmdEndRenderPass vkCmdEndRenderPass{};
@@ -1065,15 +1065,15 @@ public:
 
     void DrawIndirectCount(VkBuffer src_buffer, VkDeviceSize src_offset, VkBuffer count_buffer,
                            VkDeviceSize count_offset, u32 draw_count, u32 stride) const noexcept {
-        dld->vkCmdDrawIndirectCountKHR(handle, src_buffer, src_offset, count_buffer, count_offset,
-                                       draw_count, stride);
+        dld->vkCmdDrawIndirectCount(handle, src_buffer, src_offset, count_buffer, count_offset,
+                                    draw_count, stride);
     }
 
     void DrawIndexedIndirectCount(VkBuffer src_buffer, VkDeviceSize src_offset,
                                   VkBuffer count_buffer, VkDeviceSize count_offset, u32 draw_count,
                                   u32 stride) const noexcept {
-        dld->vkCmdDrawIndexedIndirectCountKHR(handle, src_buffer, src_offset, count_buffer,
-                                              count_offset, draw_count, stride);
+        dld->vkCmdDrawIndexedIndirectCount(handle, src_buffer, src_offset, count_buffer,
+                                           count_offset, draw_count, stride);
     }
 
     void ClearAttachments(Span<VkClearAttachment> attachments,
diff --git a/src/yuzu/Info.plist b/src/yuzu/Info.plist
index 0eb377926..f05f3186c 100644
--- a/src/yuzu/Info.plist
+++ b/src/yuzu/Info.plist
@@ -34,6 +34,8 @@ SPDX-License-Identifier: GPL-2.0-or-later
     <string></string>
     <key>CSResourcesFileMapped</key>
     <true/>
+    <key>LSApplicationCategoryType</key>
+    <string>public.app-category.games</string>
     <key>LSRequiresCarbon</key>
     <true/>
     <key>NSHumanReadableCopyright</key>
diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp
index 3d560f303..d65991734 100644
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -96,9 +96,9 @@ void EmuThread::run() {
             m_is_running.store(false);
             m_is_running.notify_all();
 
-            emit DebugModeEntered();
+            EmulationPaused(lk);
             Common::CondvarWait(m_should_run_cv, lk, stop_token, [&] { return m_should_run; });
-            emit DebugModeLeft();
+            EmulationResumed(lk);
         }
     }
 
@@ -111,6 +111,21 @@ void EmuThread::run() {
 #endif
 }
 
+// Unlock while emitting signals so that the main thread can
+// continue pumping events.
+
+void EmuThread::EmulationPaused(std::unique_lock<std::mutex>& lk) {
+    lk.unlock();
+    emit DebugModeEntered();
+    lk.lock();
+}
+
+void EmuThread::EmulationResumed(std::unique_lock<std::mutex>& lk) {
+    lk.unlock();
+    emit DebugModeLeft();
+    lk.lock();
+}
+
 #ifdef HAS_OPENGL
 class OpenGLSharedContext : public Core::Frontend::GraphicsContext {
 public:
diff --git a/src/yuzu/bootmanager.h b/src/yuzu/bootmanager.h
index eca16b313..092c6206f 100644
--- a/src/yuzu/bootmanager.h
+++ b/src/yuzu/bootmanager.h
@@ -92,6 +92,10 @@ public:
     }
 
 private:
+    void EmulationPaused(std::unique_lock<std::mutex>& lk);
+    void EmulationResumed(std::unique_lock<std::mutex>& lk);
+
+private:
     Core::System& m_system;
 
     std::stop_source m_stop_source;
diff --git a/src/yuzu/configuration/configure_graphics_advanced.cpp b/src/yuzu/configuration/configure_graphics_advanced.cpp
index fdf8485ce..cc0155a2c 100644
--- a/src/yuzu/configuration/configure_graphics_advanced.cpp
+++ b/src/yuzu/configuration/configure_graphics_advanced.cpp
@@ -22,6 +22,7 @@ ConfigureGraphicsAdvanced::~ConfigureGraphicsAdvanced() = default;
 void ConfigureGraphicsAdvanced::SetConfiguration() {
     const bool runtime_lock = !system.IsPoweredOn();
     ui->use_vsync->setEnabled(runtime_lock);
+    ui->renderer_force_max_clock->setEnabled(runtime_lock);
     ui->use_asynchronous_shaders->setEnabled(runtime_lock);
     ui->anisotropic_filtering_combobox->setEnabled(runtime_lock);
 
@@ -40,12 +41,12 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
             Settings::values.max_anisotropy.GetValue());
     } else {
         ConfigurationShared::SetPerGameSetting(ui->gpu_accuracy, &Settings::values.gpu_accuracy);
-        ConfigurationShared::SetPerGameSetting(ui->renderer_force_max_clock,
-                                               &Settings::values.renderer_force_max_clock);
         ConfigurationShared::SetPerGameSetting(ui->anisotropic_filtering_combobox,
                                                &Settings::values.max_anisotropy);
         ConfigurationShared::SetHighlight(ui->label_gpu_accuracy,
                                           !Settings::values.gpu_accuracy.UsingGlobal());
+        ConfigurationShared::SetHighlight(ui->renderer_force_max_clock,
+                                          !Settings::values.renderer_force_max_clock.UsingGlobal());
         ConfigurationShared::SetHighlight(ui->af_label,
                                           !Settings::values.max_anisotropy.UsingGlobal());
     }
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index c55f81c2f..571eacf9f 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -1839,9 +1839,11 @@ void GMainWindow::OnEmulationStopTimeExpired() {
 
 void GMainWindow::OnEmulationStopped() {
     shutdown_timer.stop();
-    emu_thread->disconnect();
-    emu_thread->wait();
-    emu_thread = nullptr;
+    if (emu_thread) {
+        emu_thread->disconnect();
+        emu_thread->wait();
+        emu_thread.reset();
+    }
 
     if (shutdown_dialog) {
         shutdown_dialog->deleteLater();
@@ -3029,6 +3031,8 @@ void GMainWindow::OnStopGame() {
 
     if (OnShutdownBegin()) {
         OnShutdownBeginDialog();
+    } else {
+        OnEmulationStopped();
     }
 }
 
@@ -3726,15 +3730,36 @@ void GMainWindow::UpdateWindowTitle(std::string_view title_name, std::string_vie
     }
 }
 
+std::string GMainWindow::CreateTASFramesString(
+    std::array<size_t, InputCommon::TasInput::PLAYER_NUMBER> frames) const {
+    std::string string = "";
+    size_t maxPlayerIndex = 0;
+    for (size_t i = 0; i < frames.size(); i++) {
+        if (frames[i] != 0) {
+            if (maxPlayerIndex != 0)
+                string += ", ";
+            while (maxPlayerIndex++ != i)
+                string += "0, ";
+            string += std::to_string(frames[i]);
+        }
+    }
+    return string;
+}
+
 QString GMainWindow::GetTasStateDescription() const {
     auto [tas_status, current_tas_frame, total_tas_frames] = input_subsystem->GetTas()->GetStatus();
+    std::string tas_frames_string = CreateTASFramesString(total_tas_frames);
     switch (tas_status) {
     case InputCommon::TasInput::TasState::Running:
-        return tr("TAS state: Running %1/%2").arg(current_tas_frame).arg(total_tas_frames);
+        return tr("TAS state: Running %1/%2")
+            .arg(current_tas_frame)
+            .arg(QString::fromStdString(tas_frames_string));
     case InputCommon::TasInput::TasState::Recording:
-        return tr("TAS state: Recording %1").arg(total_tas_frames);
+        return tr("TAS state: Recording %1").arg(total_tas_frames[0]);
     case InputCommon::TasInput::TasState::Stopped:
-        return tr("TAS state: Idle %1/%2").arg(current_tas_frame).arg(total_tas_frames);
+        return tr("TAS state: Idle %1/%2")
+            .arg(current_tas_frame)
+            .arg(QString::fromStdString(tas_frames_string));
     default:
         return tr("TAS State: Invalid");
     }
diff --git a/src/yuzu/main.h b/src/yuzu/main.h
index f25ce65a8..0f61abc7a 100644
--- a/src/yuzu/main.h
+++ b/src/yuzu/main.h
@@ -12,6 +12,7 @@
 
 #include "common/announce_multiplayer_room.h"
 #include "common/common_types.h"
+#include "input_common/drivers/tas_input.h"
 #include "yuzu/compatibility_list.h"
 #include "yuzu/hotkeys.h"
 
@@ -266,6 +267,9 @@ private:
     void changeEvent(QEvent* event) override;
     void closeEvent(QCloseEvent* event) override;
 
+    std::string CreateTASFramesString(
+        std::array<size_t, InputCommon::TasInput::PLAYER_NUMBER> frames) const;
+
 #ifdef __unix__
     void SetupSigInterrupts();
     static void HandleSigInterrupt(int);