105 files changed, 3718 insertions, 2543 deletions
diff --git a/src/audio_core/stream.cpp b/src/audio_core/stream.cpp
index f80ab92e4..7be5d5087 100644
--- a/src/audio_core/stream.cpp
+++ b/src/audio_core/stream.cpp
@@ -36,9 +36,10 @@ Stream::Stream(Core::Timing::CoreTiming& core_timing, u32 sample_rate, Format fo
               ReleaseCallback&& release_callback, SinkStream& sink_stream, std::string&& name_)
    : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)},
      sink_stream{sink_stream}, core_timing{core_timing}, name{std::move(name_)} {
+    release_event =
-    release_event = Core::Timing::CreateEvent(
+        Core::Timing::CreateEvent(name, [this](std::uintptr_t, std::chrono::nanoseconds ns_late) {
-        name, [this](u64, std::chrono::nanoseconds ns_late) { ReleaseActiveBuffer(ns_late); });
+            ReleaseActiveBuffer(ns_late);
+        });
 }
 void Stream::Play() {
diff --git a/src/common/string_util.h b/src/common/string_util.h
index 583fd05e6..023dff5dc 100644
--- a/src/common/string_util.h
+++ b/src/common/string_util.h
@@ -74,16 +74,4 @@ std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, std::size_t
 std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer,
                                                        std::size_t max_len);
-/**
- * Attempts to trim an arbitrary prefix from `path`, leaving only the part starting at `root`. It's
- * intended to be used to strip a system-specific build directory from the `__FILE__` macro,
- * leaving only the path relative to the sources root.
- *
- * @param path The input file path as a null-terminated string
- * @param root The name of the root source directory as a null-terminated string. Path up to and
- *             including the last occurrence of this name will be stripped
- * @return A pointer to the same string passed as `path`, but starting at the trimmed portion
- */
-const char* TrimSourcePath(const char* path, const char* root = "src");
 } // namespace Common
diff --git a/src/common/virtual_buffer.cpp b/src/common/virtual_buffer.cpp
index b426f4747..be5b67752 100644
--- a/src/common/virtual_buffer.cpp
+++ b/src/common/virtual_buffer.cpp
@@ -38,7 +38,7 @@ void* AllocateMemoryPages(std::size_t size) {
    return base;
 }
-void FreeMemoryPages(void* base, std::size_t size) {
+void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) {
    if (!base) {
        return;
    }
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index c42f95705..c85c9485f 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -586,6 +586,9 @@ add_library(core STATIC
    memory/dmnt_cheat_vm.h
    memory.cpp
    memory.h
+    network/network.cpp
+    network/network.h
+    network/sockets.h
    perf_stats.cpp
    perf_stats.h
    reporter.cpp
diff --git a/src/core/core.cpp b/src/core/core.cpp
index 69a1aa0a5..42277e2cd 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -43,6 +43,7 @@
 #include "core/loader/loader.h"
 #include "core/memory.h"
 #include "core/memory/cheat_engine.h"
+#include "core/network/network.h"
 #include "core/perf_stats.h"
 #include "core/reporter.h"
 #include "core/settings.h"
@@ -145,7 +146,7 @@ struct System::Impl {
    ResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
        LOG_DEBUG(HW_Memory, "initialized OK");
-        device_memory = std::make_unique<Core::DeviceMemory>(system);
+        device_memory = std::make_unique<Core::DeviceMemory>();
        is_multicore = Settings::values.use_multi_core.GetValue();
        is_async_gpu = is_multicore || Settings::values.use_asynchronous_gpu_emulation.GetValue();
@@ -394,6 +395,9 @@ struct System::Impl {
    /// Telemetry session for this emulation session
    std::unique_ptr<Core::TelemetrySession> telemetry_session;
+    /// Network instance
+    Network::NetworkInstance network_instance;
    ResultStatus status = ResultStatus::Success;
    std::string status_details = "";
diff --git a/src/core/core_timing.cpp b/src/core/core_timing.cpp
index b5feb3f24..71af26ec5 100644
--- a/src/core/core_timing.cpp
+++ b/src/core/core_timing.cpp
@@ -23,7 +23,7 @@ std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callbac
 struct CoreTiming::Event {
    u64 time;
    u64 fifo_order;
-    u64 userdata;
+    std::uintptr_t user_data;
    std::weak_ptr<EventType> type;
    // Sort by time, unless the times are the same, in which case sort by
@@ -58,7 +58,7 @@ void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {
    event_fifo_id = 0;
    shutting_down = false;
    ticks = 0;
-    const auto empty_timed_callback = [](u64, std::chrono::nanoseconds) {};
+    const auto empty_timed_callback = [](std::uintptr_t, std::chrono::nanoseconds) {};
    ev_lost = CreateEvent("_lost_event", empty_timed_callback);
    if (is_multicore) {
        timer_thread = std::make_unique<std::thread>(ThreadEntry, std::ref(*this));
@@ -107,22 +107,24 @@ bool CoreTiming::HasPendingEvents() const {
 }
 void CoreTiming::ScheduleEvent(std::chrono::nanoseconds ns_into_future,
-                               const std::shared_ptr<EventType>& event_type, u64 userdata) {
+                               const std::shared_ptr<EventType>& event_type,
+                               std::uintptr_t user_data) {
    {
        std::scoped_lock scope{basic_lock};
        const u64 timeout = static_cast<u64>((GetGlobalTimeNs() + ns_into_future).count());
-        event_queue.emplace_back(Event{timeout, event_fifo_id++, userdata, event_type});
+        event_queue.emplace_back(Event{timeout, event_fifo_id++, user_data, event_type});
        std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
    }
    event.Set();
 }
-void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type, u64 userdata) {
+void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type,
+                                 std::uintptr_t user_data) {
    std::scoped_lock scope{basic_lock};
    const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
-        return e.type.lock().get() == event_type.get() && e.userdata == userdata;
+        return e.type.lock().get() == event_type.get() && e.user_data == user_data;
    });
    // Removing random items breaks the invariant so we have to re-establish it.
@@ -197,7 +199,7 @@ std::optional<s64> CoreTiming::Advance() {
        if (const auto event_type{evt.type.lock()}) {
            event_type->callback(
-                evt.userdata, std::chrono::nanoseconds{static_cast<s64>(global_timer - evt.time)});
+                evt.user_data, std::chrono::nanoseconds{static_cast<s64>(global_timer - evt.time)});
        }
        basic_lock.lock();
diff --git a/src/core/core_timing.h b/src/core/core_timing.h
index 120c74e46..b0b6036e4 100644
--- a/src/core/core_timing.h
+++ b/src/core/core_timing.h
@@ -22,7 +22,8 @@
 namespace Core::Timing {
 /// A callback that may be scheduled for a particular core timing event.
-using TimedCallback = std::function<void(u64 userdata, std::chrono::nanoseconds ns_late)>;
+using TimedCallback =
+    std::function<void(std::uintptr_t user_data, std::chrono::nanoseconds ns_late)>;
 /// Contains the characteristics of a particular event.
 struct EventType {
@@ -94,9 +95,9 @@ public:
    /// Schedules an event in core timing
    void ScheduleEvent(std::chrono::nanoseconds ns_into_future,
-                       const std::shared_ptr<EventType>& event_type, u64 userdata = 0);
+                       const std::shared_ptr<EventType>& event_type, std::uintptr_t user_data = 0);
-    void UnscheduleEvent(const std::shared_ptr<EventType>& event_type, u64 userdata);
+    void UnscheduleEvent(const std::shared_ptr<EventType>& event_type, std::uintptr_t user_data);
    /// We only permit one event of each type in the queue at a time.
    void RemoveEvent(const std::shared_ptr<EventType>& event_type);
diff --git a/src/core/cpu_manager.cpp b/src/core/cpu_manager.cpp
index 32afcf3ae..358943429 100644
--- a/src/core/cpu_manager.cpp
+++ b/src/core/cpu_manager.cpp
@@ -52,15 +52,15 @@ void CpuManager::Shutdown() {
 }
 std::function<void(void*)> CpuManager::GetGuestThreadStartFunc() {
-    return std::function<void(void*)>(GuestThreadFunction);
+    return GuestThreadFunction;
 }
 std::function<void(void*)> CpuManager::GetIdleThreadStartFunc() {
-    return std::function<void(void*)>(IdleThreadFunction);
+    return IdleThreadFunction;
 }
 std::function<void(void*)> CpuManager::GetSuspendThreadStartFunc() {
-    return std::function<void(void*)>(SuspendThreadFunction);
+    return SuspendThreadFunction;
 }
 void CpuManager::GuestThreadFunction(void* cpu_manager_) {
diff --git a/src/core/device_memory.cpp b/src/core/device_memory.cpp
index 51097ced3..0c4b440ed 100644
--- a/src/core/device_memory.cpp
+++ b/src/core/device_memory.cpp
@@ -2,14 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-#include "core/core.h"
 #include "core/device_memory.h"
-#include "core/memory.h"
 namespace Core {
-DeviceMemory::DeviceMemory(System& system) : buffer{DramMemoryMap::Size}, system{system} {}
+DeviceMemory::DeviceMemory() : buffer{DramMemoryMap::Size} {}
 DeviceMemory::~DeviceMemory() = default;
 } // namespace Core
diff --git a/src/core/device_memory.h b/src/core/device_memory.h
index 9efa088d0..5b1ae28f3 100644
--- a/src/core/device_memory.h
+++ b/src/core/device_memory.h
@@ -4,14 +4,11 @@
 #pragma once
-#include "common/assert.h"
+#include "common/common_types.h"
-#include "common/common_funcs.h"
 #include "common/virtual_buffer.h"
 namespace Core {
-class System;
 namespace DramMemoryMap {
 enum : u64 {
    Base = 0x80000000ULL,
@@ -26,7 +23,7 @@ enum : u64 {
 class DeviceMemory : NonCopyable {
 public:
-    explicit DeviceMemory(Core::System& system);
+    explicit DeviceMemory();
    ~DeviceMemory();
    template <typename T>
@@ -45,7 +42,6 @@ public:
 private:
    Common::VirtualBuffer<u8> buffer;
-    Core::System& system;
 };
 } // namespace Core
diff --git a/src/core/file_sys/registered_cache.cpp b/src/core/file_sys/registered_cache.cpp
index 37351c561..e94eed3b6 100644
--- a/src/core/file_sys/registered_cache.cpp
+++ b/src/core/file_sys/registered_cache.cpp
@@ -547,56 +547,6 @@ InstallResult RegisteredCache::InstallEntry(const XCI& xci, bool overwrite_if_ex
    return InstallEntry(*xci.GetSecurePartitionNSP(), overwrite_if_exists, copy);
 }
-bool RegisteredCache::RemoveExistingEntry(u64 title_id) {
-    const auto delete_nca = [this](const NcaID& id) {
-        const auto path = GetRelativePathFromNcaID(id, false, true, false);
-        if (dir->GetFileRelative(path) == nullptr) {
-            return false;
-        }
-        Core::Crypto::SHA256Hash hash{};
-        mbedtls_sha256_ret(id.data(), id.size(), hash.data(), 0);
-        const auto dirname = fmt::format("000000{:02X}", hash[0]);
-        const auto dir2 = GetOrCreateDirectoryRelative(dir, dirname);
-        const auto res = dir2->DeleteFile(fmt::format("{}.nca", Common::HexToString(id, false)));
-        return res;
-    };
-    // If an entry exists in the registered cache, remove it
-    if (HasEntry(title_id, ContentRecordType::Meta)) {
-        LOG_INFO(Loader,
-                 "Previously installed entry (v{}) for title_id={:016X} detected! "
-                 "Attempting to remove...",
-                 GetEntryVersion(title_id).value_or(0), title_id);
-        // Get all the ncas associated with the current CNMT and delete them
-        const auto meta_old_id =
-            GetNcaIDFromMetadata(title_id, ContentRecordType::Meta).value_or(NcaID{});
-        const auto program_id =
-            GetNcaIDFromMetadata(title_id, ContentRecordType::Program).value_or(NcaID{});
-        const auto data_id =
-            GetNcaIDFromMetadata(title_id, ContentRecordType::Data).value_or(NcaID{});
-        const auto control_id =
-            GetNcaIDFromMetadata(title_id, ContentRecordType::Control).value_or(NcaID{});
-        const auto html_id =
-            GetNcaIDFromMetadata(title_id, ContentRecordType::HtmlDocument).value_or(NcaID{});
-        const auto legal_id =
-            GetNcaIDFromMetadata(title_id, ContentRecordType::LegalInformation).value_or(NcaID{});
-        delete_nca(meta_old_id);
-        delete_nca(program_id);
-        delete_nca(data_id);
-        delete_nca(control_id);
-        delete_nca(html_id);
-        delete_nca(legal_id);
-        return true;
-    }
-    return false;
-}
 InstallResult RegisteredCache::InstallEntry(const NSP& nsp, bool overwrite_if_exists,
                                            const VfsCopyFunction& copy) {
    const auto ncas = nsp.GetNCAsCollapsed();
@@ -692,6 +642,57 @@ InstallResult RegisteredCache::InstallEntry(const NCA& nca, TitleType type,
    return RawInstallNCA(nca, copy, overwrite_if_exists, c_rec.nca_id);
 }
+bool RegisteredCache::RemoveExistingEntry(u64 title_id) const {
+    const auto delete_nca = [this](const NcaID& id) {
+        const auto path = GetRelativePathFromNcaID(id, false, true, false);
+        const bool isFile = dir->GetFileRelative(path) != nullptr;
+        const bool isDir = dir->GetDirectoryRelative(path) != nullptr;
+        if (isFile) {
+            return dir->DeleteFile(path);
+        } else if (isDir) {
+            return dir->DeleteSubdirectoryRecursive(path);
+        }
+        return false;
+    };
+    // If an entry exists in the registered cache, remove it
+    if (HasEntry(title_id, ContentRecordType::Meta)) {
+        LOG_INFO(Loader,
+                 "Previously installed entry (v{}) for title_id={:016X} detected! "
+                 "Attempting to remove...",
+                 GetEntryVersion(title_id).value_or(0), title_id);
+        // Get all the ncas associated with the current CNMT and delete them
+        const auto meta_old_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::Meta).value_or(NcaID{});
+        const auto program_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::Program).value_or(NcaID{});
+        const auto data_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::Data).value_or(NcaID{});
+        const auto control_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::Control).value_or(NcaID{});
+        const auto html_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::HtmlDocument).value_or(NcaID{});
+        const auto legal_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::LegalInformation).value_or(NcaID{});
+        const auto deleted_meta = delete_nca(meta_old_id);
+        const auto deleted_program = delete_nca(program_id);
+        const auto deleted_data = delete_nca(data_id);
+        const auto deleted_control = delete_nca(control_id);
+        const auto deleted_html = delete_nca(html_id);
+        const auto deleted_legal = delete_nca(legal_id);
+        return deleted_meta && (deleted_meta || deleted_program || deleted_data ||
+                                deleted_control || deleted_html || deleted_legal);
+    }
+    return false;
+}
 InstallResult RegisteredCache::RawInstallNCA(const NCA& nca, const VfsCopyFunction& copy,
                                             bool overwrite_if_exists,
                                             std::optional<NcaID> override_id) {
diff --git a/src/core/file_sys/registered_cache.h b/src/core/file_sys/registered_cache.h
index 29cf0d40c..ec1d54f27 100644
--- a/src/core/file_sys/registered_cache.h
+++ b/src/core/file_sys/registered_cache.h
@@ -155,9 +155,6 @@ public:
        std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
        std::optional<u64> title_id = {}) const override;
-    // Removes an existing entry based on title id
-    bool RemoveExistingEntry(u64 title_id);
    // Raw copies all the ncas from the xci/nsp to the csache. Does some quick checks to make sure
    // there is a meta NCA and all of them are accessible.
    InstallResult InstallEntry(const XCI& xci, bool overwrite_if_exists = false,
@@ -172,6 +169,9 @@ public:
    InstallResult InstallEntry(const NCA& nca, TitleType type, bool overwrite_if_exists = false,
                               const VfsCopyFunction& copy = &VfsRawCopy);
+    // Removes an existing entry based on title id
+    bool RemoveExistingEntry(u64 title_id) const;
 private:
    template <typename T>
    void IterateAllMetadata(std::vector<T>& out,
diff --git a/src/core/file_sys/xts_archive.cpp b/src/core/file_sys/xts_archive.cpp
index 86e06ccb9..81413c684 100644
--- a/src/core/file_sys/xts_archive.cpp
+++ b/src/core/file_sys/xts_archive.cpp
@@ -70,14 +70,18 @@ NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
 NAX::~NAX() = default;
 Loader::ResultStatus NAX::Parse(std::string_view path) {
-    if (file->ReadObject(header.get()) != sizeof(NAXHeader))
+    if (file == nullptr) {
+        return Loader::ResultStatus::ErrorNullFile;
+    }
+    if (file->ReadObject(header.get()) != sizeof(NAXHeader)) {
        return Loader::ResultStatus::ErrorBadNAXHeader;
+    }
-    if (header->magic != Common::MakeMagic('N', 'A', 'X', '0'))
+    if (header->magic != Common::MakeMagic('N', 'A', 'X', '0')) {
        return Loader::ResultStatus::ErrorBadNAXHeader;
+    }
-    if (file->GetSize() < NAX_HEADER_PADDING_SIZE + header->file_size)
+    if (file->GetSize() < NAX_HEADER_PADDING_SIZE + header->file_size) {
        return Loader::ResultStatus::ErrorIncorrectNAXFileSize;
+    }
    keys.DeriveSDSeedLazy();
    std::array<Core::Crypto::Key256, 2> sd_keys{};
diff --git a/src/core/hardware_interrupt_manager.cpp b/src/core/hardware_interrupt_manager.cpp
index efc1030c1..645f26e91 100644
--- a/src/core/hardware_interrupt_manager.cpp
+++ b/src/core/hardware_interrupt_manager.cpp
@@ -11,8 +11,8 @@
 namespace Core::Hardware {
 InterruptManager::InterruptManager(Core::System& system_in) : system(system_in) {
-    gpu_interrupt_event =
+    gpu_interrupt_event = Core::Timing::CreateEvent(
-        Core::Timing::CreateEvent("GPUInterrupt", [this](u64 message, std::chrono::nanoseconds) {
+        "GPUInterrupt", [this](std::uintptr_t message, std::chrono::nanoseconds) {
            auto nvdrv = system.ServiceManager().GetService<Service::Nvidia::NVDRV>("nvdrv");
            const u32 syncpt = static_cast<u32>(message >> 32);
            const u32 value = static_cast<u32>(message);
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 8dd4a2637..cabe8d418 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -145,7 +145,7 @@ struct KernelCore::Impl {
    void InitializePreemption(KernelCore& kernel) {
        preemption_event = Core::Timing::CreateEvent(
-            "PreemptionCallback", [this, &kernel](u64, std::chrono::nanoseconds) {
+            "PreemptionCallback", [this, &kernel](std::uintptr_t, std::chrono::nanoseconds) {
                {
                    SchedulerLock lock(kernel);
                    global_scheduler.PreemptThreads();
diff --git a/src/core/hle/kernel/server_session.cpp b/src/core/hle/kernel/server_session.cpp
index af22f4c33..7e6391c6c 100644
--- a/src/core/hle/kernel/server_session.cpp
+++ b/src/core/hle/kernel/server_session.cpp
@@ -33,8 +33,10 @@ ResultVal<std::shared_ptr<ServerSession>> ServerSession::Create(KernelCore& kern
                                                                std::string name) {
    std::shared_ptr<ServerSession> session{std::make_shared<ServerSession>(kernel)};
-    session->request_event = Core::Timing::CreateEvent(
+    session->request_event =
-        name, [session](u64, std::chrono::nanoseconds) { session->CompleteSyncRequest(); });
+        Core::Timing::CreateEvent(name, [session](std::uintptr_t, std::chrono::nanoseconds) {
+            session->CompleteSyncRequest();
+        });
    session->name = std::move(name);
    session->parent = std::move(parent);
diff --git a/src/core/hle/kernel/time_manager.cpp b/src/core/hle/kernel/time_manager.cpp
index 88b01b751..95f2446c9 100644
--- a/src/core/hle/kernel/time_manager.cpp
+++ b/src/core/hle/kernel/time_manager.cpp
@@ -16,14 +16,14 @@ namespace Kernel {
 TimeManager::TimeManager(Core::System& system_) : system{system_} {
    time_manager_event_type = Core::Timing::CreateEvent(
-        "Kernel::TimeManagerCallback", [this](u64 thread_handle, std::chrono::nanoseconds) {
+        "Kernel::TimeManagerCallback",
-            SchedulerLock lock(system.Kernel());
+        [this](std::uintptr_t thread_handle, std::chrono::nanoseconds) {
-            Handle proper_handle = static_cast<Handle>(thread_handle);
+            const SchedulerLock lock(system.Kernel());
+            const auto proper_handle = static_cast<Handle>(thread_handle);
            if (cancelled_events[proper_handle]) {
                return;
            }
-            std::shared_ptr<Thread> thread =
+            auto thread = this->system.Kernel().RetrieveThreadFromGlobalHandleTable(proper_handle);
-                this->system.Kernel().RetrieveThreadFromGlobalHandleTable(proper_handle);
            thread->OnWakeUp();
        });
 }
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index 4e7a0bec9..ceed20609 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -1405,7 +1405,6 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
    // Get supported languages from NACP, if possible
    // Default to 0 (all languages supported)
    u32 supported_languages = 0;
-    FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID()};
    const auto res = [this] {
        const auto title_id = system.CurrentProcess()->GetTitleID();
diff --git a/src/core/hle/service/am/applets/software_keyboard.cpp b/src/core/hle/service/am/applets/software_keyboard.cpp
index fbe3686ae..289da2619 100644
--- a/src/core/hle/service/am/applets/software_keyboard.cpp
+++ b/src/core/hle/service/am/applets/software_keyboard.cpp
@@ -13,11 +13,23 @@
 namespace Service::AM::Applets {
+namespace {
+enum class Request : u32 {
+    Finalize = 0x4,
+    SetUserWordInfo = 0x6,
+    SetCustomizeDic = 0x7,
+    Calc = 0xa,
+    SetCustomizedDictionaries = 0xb,
+    UnsetCustomizedDictionaries = 0xc,
+    UnknownD = 0xd,
+    UnknownE = 0xe,
+};
+constexpr std::size_t SWKBD_INLINE_INIT_SIZE = 0x8;
 constexpr std::size_t SWKBD_OUTPUT_BUFFER_SIZE = 0x7D8;
 constexpr std::size_t SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE = 0x7D4;
 constexpr std::size_t DEFAULT_MAX_LENGTH = 500;
 constexpr bool INTERACTIVE_STATUS_OK = false;
+} // Anonymous namespace
 static Core::Frontend::SoftwareKeyboardParameters ConvertToFrontendParameters(
    KeyboardConfig config, std::u16string initial_text) {
    Core::Frontend::SoftwareKeyboardParameters params{};
@@ -47,6 +59,7 @@ SoftwareKeyboard::~SoftwareKeyboard() = default;
 void SoftwareKeyboard::Initialize() {
    complete = false;
+    is_inline = false;
    initial_text.clear();
    final_data.clear();
@@ -56,6 +69,11 @@ void SoftwareKeyboard::Initialize() {
    ASSERT(keyboard_config_storage != nullptr);
    const auto& keyboard_config = keyboard_config_storage->GetData();
+    if (keyboard_config.size() == SWKBD_INLINE_INIT_SIZE) {
+        is_inline = true;
+        return;
+    }
    ASSERT(keyboard_config.size() >= sizeof(KeyboardConfig));
    std::memcpy(&config, keyboard_config.data(), sizeof(KeyboardConfig));
@@ -87,16 +105,32 @@ void SoftwareKeyboard::ExecuteInteractive() {
    const auto storage = broker.PopInteractiveDataToApplet();
    ASSERT(storage != nullptr);
    const auto data = storage->GetData();
-    const auto status = static_cast<bool>(data[0]);
+    if (!is_inline) {
+        const auto status = static_cast<bool>(data[0]);
-    if (status == INTERACTIVE_STATUS_OK) {
+        if (status == INTERACTIVE_STATUS_OK) {
-        complete = true;
+            complete = true;
+        } else {
+            std::array<char16_t, SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE / 2 - 2> string;
+            std::memcpy(string.data(), data.data() + 4, string.size() * 2);
+            frontend.SendTextCheckDialog(
+                Common::UTF16StringFromFixedZeroTerminatedBuffer(string.data(), string.size()),
+                [this] { broker.SignalStateChanged(); });
+        }
    } else {
-        std::array<char16_t, SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE / 2 - 2> string;
+        Request request{};
-        std::memcpy(string.data(), data.data() + 4, string.size() * 2);
+        std::memcpy(&request, data.data(), sizeof(Request));
-        frontend.SendTextCheckDialog(
-            Common::UTF16StringFromFixedZeroTerminatedBuffer(string.data(), string.size()),
+        switch (request) {
-            [this] { broker.SignalStateChanged(); });
+        case Request::Calc: {
+            broker.PushNormalDataFromApplet(
+                std::make_shared<IStorage>(std::move(std::vector<u8>{1})));
+            broker.SignalStateChanged();
+            break;
+        }
+        default:
+            UNIMPLEMENTED_MSG("Request {:X} is not implemented", request);
+            break;
+        }
    }
 }
@@ -108,9 +142,10 @@ void SoftwareKeyboard::Execute() {
    }
    const auto parameters = ConvertToFrontendParameters(config, initial_text);
+    if (!is_inline) {
-    frontend.RequestText([this](std::optional<std::u16string> text) { WriteText(std::move(text)); },
+        frontend.RequestText(
-                         parameters);
+            [this](std::optional<std::u16string> text) { WriteText(std::move(text)); }, parameters);
+    }
 }
 void SoftwareKeyboard::WriteText(std::optional<std::u16string> text) {
diff --git a/src/core/hle/service/am/applets/software_keyboard.h b/src/core/hle/service/am/applets/software_keyboard.h
index ef4801fc6..5a3824b5a 100644
--- a/src/core/hle/service/am/applets/software_keyboard.h
+++ b/src/core/hle/service/am/applets/software_keyboard.h
@@ -78,6 +78,7 @@ private:
    KeyboardConfig config;
    std::u16string initial_text;
    bool complete = false;
+    bool is_inline = false;
    std::vector<u8> final_data;
 };
diff --git a/src/core/hle/service/hid/controllers/debug_pad.cpp b/src/core/hle/service/hid/controllers/debug_pad.cpp
index cb35919e9..ad251ed4a 100644
--- a/src/core/hle/service/hid/controllers/debug_pad.cpp
+++ b/src/core/hle/service/hid/controllers/debug_pad.cpp
@@ -39,33 +39,36 @@ void Controller_DebugPad::OnUpdate(const Core::Timing::CoreTiming& core_timing,
    cur_entry.sampling_number = last_entry.sampling_number + 1;
    cur_entry.sampling_number2 = cur_entry.sampling_number;
-    cur_entry.attribute.connected.Assign(1);
-    auto& pad = cur_entry.pad_state;
-    using namespace Settings::NativeButton;
+    if (Settings::values.debug_pad_enabled) {
-    pad.a.Assign(buttons[A - BUTTON_HID_BEGIN]->GetStatus());
+        cur_entry.attribute.connected.Assign(1);
-    pad.b.Assign(buttons[B - BUTTON_HID_BEGIN]->GetStatus());
+        auto& pad = cur_entry.pad_state;
-    pad.x.Assign(buttons[X - BUTTON_HID_BEGIN]->GetStatus());
-    pad.y.Assign(buttons[Y - BUTTON_HID_BEGIN]->GetStatus());
-    pad.l.Assign(buttons[L - BUTTON_HID_BEGIN]->GetStatus());
-    pad.r.Assign(buttons[R - BUTTON_HID_BEGIN]->GetStatus());
-    pad.zl.Assign(buttons[ZL - BUTTON_HID_BEGIN]->GetStatus());
-    pad.zr.Assign(buttons[ZR - BUTTON_HID_BEGIN]->GetStatus());
-    pad.plus.Assign(buttons[Plus - BUTTON_HID_BEGIN]->GetStatus());
-    pad.minus.Assign(buttons[Minus - BUTTON_HID_BEGIN]->GetStatus());
-    pad.d_left.Assign(buttons[DLeft - BUTTON_HID_BEGIN]->GetStatus());
-    pad.d_up.Assign(buttons[DUp - BUTTON_HID_BEGIN]->GetStatus());
-    pad.d_right.Assign(buttons[DRight - BUTTON_HID_BEGIN]->GetStatus());
-    pad.d_down.Assign(buttons[DDown - BUTTON_HID_BEGIN]->GetStatus());
-    const auto [stick_l_x_f, stick_l_y_f] =
+        using namespace Settings::NativeButton;
-        analogs[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetStatus();
+        pad.a.Assign(buttons[A - BUTTON_HID_BEGIN]->GetStatus());
-    const auto [stick_r_x_f, stick_r_y_f] =
+        pad.b.Assign(buttons[B - BUTTON_HID_BEGIN]->GetStatus());
-        analogs[static_cast<std::size_t>(JoystickId::Joystick_Right)]->GetStatus();
+        pad.x.Assign(buttons[X - BUTTON_HID_BEGIN]->GetStatus());
-    cur_entry.l_stick.x = static_cast<s32>(stick_l_x_f * HID_JOYSTICK_MAX);
+        pad.y.Assign(buttons[Y - BUTTON_HID_BEGIN]->GetStatus());
-    cur_entry.l_stick.y = static_cast<s32>(stick_l_y_f * HID_JOYSTICK_MAX);
+        pad.l.Assign(buttons[L - BUTTON_HID_BEGIN]->GetStatus());
-    cur_entry.r_stick.x = static_cast<s32>(stick_r_x_f * HID_JOYSTICK_MAX);
+        pad.r.Assign(buttons[R - BUTTON_HID_BEGIN]->GetStatus());
-    cur_entry.r_stick.y = static_cast<s32>(stick_r_y_f * HID_JOYSTICK_MAX);
+        pad.zl.Assign(buttons[ZL - BUTTON_HID_BEGIN]->GetStatus());
+        pad.zr.Assign(buttons[ZR - BUTTON_HID_BEGIN]->GetStatus());
+        pad.plus.Assign(buttons[Plus - BUTTON_HID_BEGIN]->GetStatus());
+        pad.minus.Assign(buttons[Minus - BUTTON_HID_BEGIN]->GetStatus());
+        pad.d_left.Assign(buttons[DLeft - BUTTON_HID_BEGIN]->GetStatus());
+        pad.d_up.Assign(buttons[DUp - BUTTON_HID_BEGIN]->GetStatus());
+        pad.d_right.Assign(buttons[DRight - BUTTON_HID_BEGIN]->GetStatus());
+        pad.d_down.Assign(buttons[DDown - BUTTON_HID_BEGIN]->GetStatus());
+        const auto [stick_l_x_f, stick_l_y_f] =
+            analogs[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetStatus();
+        const auto [stick_r_x_f, stick_r_y_f] =
+            analogs[static_cast<std::size_t>(JoystickId::Joystick_Right)]->GetStatus();
+        cur_entry.l_stick.x = static_cast<s32>(stick_l_x_f * HID_JOYSTICK_MAX);
+        cur_entry.l_stick.y = static_cast<s32>(stick_l_y_f * HID_JOYSTICK_MAX);
+        cur_entry.r_stick.x = static_cast<s32>(stick_r_x_f * HID_JOYSTICK_MAX);
+        cur_entry.r_stick.y = static_cast<s32>(stick_r_y_f * HID_JOYSTICK_MAX);
+    }
    std::memcpy(data, &shared_memory, sizeof(SharedMemory));
 }
diff --git a/src/core/hle/service/hid/controllers/keyboard.cpp b/src/core/hle/service/hid/controllers/keyboard.cpp
index feae89525..0b896d5ad 100644
--- a/src/core/hle/service/hid/controllers/keyboard.cpp
+++ b/src/core/hle/service/hid/controllers/keyboard.cpp
@@ -40,15 +40,16 @@ void Controller_Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing,
    cur_entry.key.fill(0);
    cur_entry.modifier = 0;
+    if (Settings::values.keyboard_enabled) {
-    for (std::size_t i = 0; i < keyboard_keys.size(); ++i) {
+        for (std::size_t i = 0; i < keyboard_keys.size(); ++i) {
-        cur_entry.key[i / KEYS_PER_BYTE] |= (keyboard_keys[i]->GetStatus() << (i % KEYS_PER_BYTE));
+            cur_entry.key[i / KEYS_PER_BYTE] |=
-    }
+                (keyboard_keys[i]->GetStatus() << (i % KEYS_PER_BYTE));
+        }
-    for (std::size_t i = 0; i < keyboard_mods.size(); ++i) {
-        cur_entry.modifier |= (keyboard_mods[i]->GetStatus() << i);
+        for (std::size_t i = 0; i < keyboard_mods.size(); ++i) {
+            cur_entry.modifier |= (keyboard_mods[i]->GetStatus() << i);
+        }
    }
    std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(SharedMemory));
 }
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 680290cbd..1e95b7580 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -77,8 +77,9 @@ IAppletResource::IAppletResource(Core::System& system)
    // Register update callbacks
    pad_update_event = Core::Timing::CreateEvent(
-        "HID::UpdatePadCallback", [this](u64 userdata, std::chrono::nanoseconds ns_late) {
+        "HID::UpdatePadCallback",
-            UpdateControllers(userdata, ns_late);
+        [this](std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
+            UpdateControllers(user_data, ns_late);
        });
    // TODO(shinyquagsire23): Other update callbacks? (accel, gyro?)
@@ -108,7 +109,8 @@ void IAppletResource::GetSharedMemoryHandle(Kernel::HLERequestContext& ctx) {
    rb.PushCopyObjects(shared_mem);
 }
-void IAppletResource::UpdateControllers(u64 userdata, std::chrono::nanoseconds ns_late) {
+void IAppletResource::UpdateControllers(std::uintptr_t user_data,
+                                        std::chrono::nanoseconds ns_late) {
    auto& core_timing = system.CoreTiming();
    const bool should_reload = Settings::values.is_device_reload_pending.exchange(false);
diff --git a/src/core/hle/service/hid/hid.h b/src/core/hle/service/hid/hid.h
index c6f0a2584..efb07547f 100644
--- a/src/core/hle/service/hid/hid.h
+++ b/src/core/hle/service/hid/hid.h
@@ -64,7 +64,7 @@ private:
    }
    void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx);
-    void UpdateControllers(u64 userdata, std::chrono::nanoseconds ns_late);
+    void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
    std::shared_ptr<Kernel::SharedMemory> shared_mem;
diff --git a/src/core/hle/service/nvflinger/nvflinger.cpp b/src/core/hle/service/nvflinger/nvflinger.cpp
index 789856118..f644a460d 100644
--- a/src/core/hle/service/nvflinger/nvflinger.cpp
+++ b/src/core/hle/service/nvflinger/nvflinger.cpp
@@ -67,8 +67,8 @@ NVFlinger::NVFlinger(Core::System& system) : system(system) {
    // Schedule the screen composition events
    composition_event = Core::Timing::CreateEvent(
-        "ScreenComposition", [this](u64, std::chrono::nanoseconds ns_late) {
+        "ScreenComposition", [this](std::uintptr_t, std::chrono::nanoseconds ns_late) {
-            Lock();
+            const auto guard = Lock();
            Compose();
            const auto ticks = std::chrono::nanoseconds{GetNextTicks()};
diff --git a/src/core/hle/service/nvflinger/nvflinger.h b/src/core/hle/service/nvflinger/nvflinger.h
index e4959a9af..ff85cbba6 100644
--- a/src/core/hle/service/nvflinger/nvflinger.h
+++ b/src/core/hle/service/nvflinger/nvflinger.h
@@ -54,12 +54,12 @@ public:
    /// Opens the specified display and returns the ID.
    ///
    /// If an invalid display name is provided, then an empty optional is returned.
-    std::optional<u64> OpenDisplay(std::string_view name);
+    [[nodiscard]] std::optional<u64> OpenDisplay(std::string_view name);
    /// Creates a layer on the specified display and returns the layer ID.
    ///
    /// If an invalid display ID is specified, then an empty optional is returned.
-    std::optional<u64> CreateLayer(u64 display_id);
+    [[nodiscard]] std::optional<u64> CreateLayer(u64 display_id);
    /// Closes a layer on all displays for the given layer ID.
    void CloseLayer(u64 layer_id);
@@ -67,41 +67,39 @@ public:
    /// Finds the buffer queue ID of the specified layer in the specified display.
    ///
    /// If an invalid display ID or layer ID is provided, then an empty optional is returned.
-    std::optional<u32> FindBufferQueueId(u64 display_id, u64 layer_id) const;
+    [[nodiscard]] std::optional<u32> FindBufferQueueId(u64 display_id, u64 layer_id) const;
    /// Gets the vsync event for the specified display.
    ///
    /// If an invalid display ID is provided, then nullptr is returned.
-    std::shared_ptr<Kernel::ReadableEvent> FindVsyncEvent(u64 display_id) const;
+    [[nodiscard]] std::shared_ptr<Kernel::ReadableEvent> FindVsyncEvent(u64 display_id) const;
    /// Obtains a buffer queue identified by the ID.
-    BufferQueue& FindBufferQueue(u32 id);
+    [[nodiscard]] BufferQueue& FindBufferQueue(u32 id);
    /// Obtains a buffer queue identified by the ID.
-    const BufferQueue& FindBufferQueue(u32 id) const;
+    [[nodiscard]] const BufferQueue& FindBufferQueue(u32 id) const;
    /// Performs a composition request to the emulated nvidia GPU and triggers the vsync events when
    /// finished.
    void Compose();
-    s64 GetNextTicks() const;
+    [[nodiscard]] s64 GetNextTicks() const;
-    std::unique_lock<std::mutex> Lock() {
+    [[nodiscard]] std::unique_lock<std::mutex> Lock() const { return std::unique_lock{*guard}; }
-        return std::unique_lock{*guard};
-    }
-private:
+    private :
-    /// Finds the display identified by the specified ID.
+        /// Finds the display identified by the specified ID.
-    VI::Display* FindDisplay(u64 display_id);
+        [[nodiscard]] VI::Display* FindDisplay(u64 display_id);
    /// Finds the display identified by the specified ID.
-    const VI::Display* FindDisplay(u64 display_id) const;
+    [[nodiscard]] const VI::Display* FindDisplay(u64 display_id) const;
    /// Finds the layer identified by the specified ID in the desired display.
-    VI::Layer* FindLayer(u64 display_id, u64 layer_id);
+    [[nodiscard]] VI::Layer* FindLayer(u64 display_id, u64 layer_id);
    /// Finds the layer identified by the specified ID in the desired display.
-    const VI::Layer* FindLayer(u64 display_id, u64 layer_id) const;
+    [[nodiscard]] const VI::Layer* FindLayer(u64 display_id, u64 layer_id) const;
    static void VSyncThread(NVFlinger& nv_flinger);
diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp
index ea7b4ae13..825d11a3f 100644
--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -511,7 +511,7 @@ private:
        LOG_DEBUG(Service_VI, "called. id=0x{:08X} transaction={:X}, flags=0x{:08X}", id,
                  static_cast<u32>(transaction), flags);
-        nv_flinger->Lock();
+        const auto guard = nv_flinger->Lock();
        auto& buffer_queue = nv_flinger->FindBufferQueue(id);
        switch (transaction) {
@@ -551,7 +551,7 @@ private:
                    [=](std::shared_ptr<Kernel::Thread> thread, Kernel::HLERequestContext& ctx,
                        Kernel::ThreadWakeupReason reason) {
                        // Repeat TransactParcel DequeueBuffer when a buffer is available
-                        nv_flinger->Lock();
+                        const auto guard = nv_flinger->Lock();
                        auto& buffer_queue = nv_flinger->FindBufferQueue(id);
                        auto result = buffer_queue.DequeueBuffer(width, height);
                        ASSERT_MSG(result != std::nullopt, "Could not dequeue buffer.");
diff --git a/src/core/memory/cheat_engine.cpp b/src/core/memory/cheat_engine.cpp
index ced41b1fe..eeebdf02e 100644
--- a/src/core/memory/cheat_engine.cpp
+++ b/src/core/memory/cheat_engine.cpp
@@ -188,11 +188,11 @@ CheatEngine::~CheatEngine() {
 }
 void CheatEngine::Initialize() {
-    event = Core::Timing::CreateEvent("CheatEngine::FrameCallback::" +
+    event = Core::Timing::CreateEvent(
-                                          Common::HexToString(metadata.main_nso_build_id),
+        "CheatEngine::FrameCallback::" + Common::HexToString(metadata.main_nso_build_id),
-                                      [this](u64 userdata, std::chrono::nanoseconds ns_late) {
+        [this](std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
-                                          FrameCallback(userdata, ns_late);
+            FrameCallback(user_data, ns_late);
-                                      });
+        });
    core_timing.ScheduleEvent(CHEAT_ENGINE_NS, event);
    metadata.process_id = system.CurrentProcess()->GetProcessID();
@@ -219,7 +219,7 @@ void CheatEngine::Reload(std::vector<CheatEntry> cheats) {
 MICROPROFILE_DEFINE(Cheat_Engine, "Add-Ons", "Cheat Engine", MP_RGB(70, 200, 70));
-void CheatEngine::FrameCallback(u64, std::chrono::nanoseconds ns_late) {
+void CheatEngine::FrameCallback(std::uintptr_t, std::chrono::nanoseconds ns_late) {
    if (is_pending_reload.exchange(false)) {
        vm.LoadProgram(cheats);
    }
diff --git a/src/core/memory/cheat_engine.h b/src/core/memory/cheat_engine.h
index d4068cf84..fa039a831 100644
--- a/src/core/memory/cheat_engine.h
+++ b/src/core/memory/cheat_engine.h
@@ -72,7 +72,7 @@ public:
    void Reload(std::vector<CheatEntry> cheats);
 private:
-    void FrameCallback(u64 userdata, std::chrono::nanoseconds ns_late);
+    void FrameCallback(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
    DmntCheatVm vm;
    CheatProcessMetadata metadata;
diff --git a/src/core/network/network.cpp b/src/core/network/network.cpp
new file mode 100644
index 000000000..56d173b5e
--- /dev/null
+++ b/src/core/network/network.cpp
@@ -0,0 +1,654 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#include <algorithm>
+#include <cstring>
+#include <limits>
+#include <utility>
+#include <vector>
+#ifdef _WIN32
+#define _WINSOCK_DEPRECATED_NO_WARNINGS // gethostname
+#include <winsock2.h>
+#elif __unix__
+#include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <poll.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#else
+#error "Unimplemented platform"
+#endif
+#include "common/assert.h"
+#include "common/common_types.h"
+#include "common/logging/log.h"
+#include "core/network/network.h"
+#include "core/network/sockets.h"
+namespace Network {
+namespace {
+#ifdef _WIN32
+using socklen_t = int;
+void Initialize() {
+    WSADATA wsa_data;
+    (void)WSAStartup(MAKEWORD(2, 2), &wsa_data);
+}
+void Finalize() {
+    WSACleanup();
+}
+constexpr IPv4Address TranslateIPv4(in_addr addr) {
+    auto& bytes = addr.S_un.S_un_b;
+    return IPv4Address{bytes.s_b1, bytes.s_b2, bytes.s_b3, bytes.s_b4};
+}
+sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
+    sockaddr_in result;
+#ifdef __unix__
+    result.sin_len = sizeof(result);
+#endif
+    switch (static_cast<Domain>(input.family)) {
+    case Domain::INET:
+        result.sin_family = AF_INET;
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unhandled sockaddr family={}", static_cast<int>(input.family));
+        result.sin_family = AF_INET;
+        break;
+    }
+    result.sin_port = htons(input.portno);
+    auto& ip = result.sin_addr.S_un.S_un_b;
+    ip.s_b1 = input.ip[0];
+    ip.s_b2 = input.ip[1];
+    ip.s_b3 = input.ip[2];
+    ip.s_b4 = input.ip[3];
+    sockaddr addr;
+    std::memcpy(&addr, &result, sizeof(addr));
+    return addr;
+}
+LINGER MakeLinger(bool enable, u32 linger_value) {
+    ASSERT(linger_value <= std::numeric_limits<u_short>::max());
+    LINGER value;
+    value.l_onoff = enable ? 1 : 0;
+    value.l_linger = static_cast<u_short>(linger_value);
+    return value;
+}
+int LastError() {
+    return WSAGetLastError();
+}
+bool EnableNonBlock(SOCKET fd, bool enable) {
+    u_long value = enable ? 1 : 0;
+    return ioctlsocket(fd, FIONBIO, &value) != SOCKET_ERROR;
+}
+#elif __unix__ // ^ _WIN32 v __unix__
+using SOCKET = int;
+using WSAPOLLFD = pollfd;
+using ULONG = u64;
+constexpr SOCKET INVALID_SOCKET = -1;
+constexpr SOCKET SOCKET_ERROR = -1;
+constexpr int WSAEWOULDBLOCK = EAGAIN;
+constexpr int WSAENOTCONN = ENOTCONN;
+constexpr int SD_RECEIVE = SHUT_RD;
+constexpr int SD_SEND = SHUT_WR;
+constexpr int SD_BOTH = SHUT_RDWR;
+void Initialize() {}
+void Finalize() {}
+constexpr IPv4Address TranslateIPv4(in_addr addr) {
+    const u32 bytes = addr.s_addr;
+    return IPv4Address{static_cast<u8>(bytes), static_cast<u8>(bytes >> 8),
+                       static_cast<u8>(bytes >> 16), static_cast<u8>(bytes >> 24)};
+}
+sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
+    sockaddr_in result;
+    switch (static_cast<Domain>(input.family)) {
+    case Domain::INET:
+        result.sin_family = AF_INET;
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unhandled sockaddr family={}", static_cast<int>(input.family));
+        result.sin_family = AF_INET;
+        break;
+    }
+    result.sin_port = htons(input.portno);
+    result.sin_addr.s_addr = input.ip[0] | input.ip[1] << 8 | input.ip[2] << 16 | input.ip[3] << 24;
+    sockaddr addr;
+    std::memcpy(&addr, &result, sizeof(addr));
+    return addr;
+}
+int WSAPoll(WSAPOLLFD* fds, ULONG nfds, int timeout) {
+    return poll(fds, nfds, timeout);
+}
+int closesocket(SOCKET fd) {
+    return close(fd);
+}
+linger MakeLinger(bool enable, u32 linger_value) {
+    linger value;
+    value.l_onoff = enable ? 1 : 0;
+    value.l_linger = linger_value;
+    return value;
+}
+int LastError() {
+    return errno;
+}
+bool EnableNonBlock(int fd, bool enable) {
+    int flags = fcntl(fd, F_GETFD);
+    if (flags == -1) {
+        return false;
+    }
+    if (enable) {
+        flags |= O_NONBLOCK;
+    } else {
+        flags &= ~O_NONBLOCK;
+    }
+    return fcntl(fd, F_SETFD, flags) == 0;
+}
+#endif
+int TranslateDomain(Domain domain) {
+    switch (domain) {
+    case Domain::INET:
+        return AF_INET;
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented domain={}", static_cast<int>(domain));
+        return 0;
+    }
+}
+int TranslateType(Type type) {
+    switch (type) {
+    case Type::STREAM:
+        return SOCK_STREAM;
+    case Type::DGRAM:
+        return SOCK_DGRAM;
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented type={}", static_cast<int>(type));
+        return 0;
+    }
+}
+int TranslateProtocol(Protocol protocol) {
+    switch (protocol) {
+    case Protocol::TCP:
+        return IPPROTO_TCP;
+    case Protocol::UDP:
+        return IPPROTO_UDP;
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented protocol={}", static_cast<int>(protocol));
+        return 0;
+    }
+}
+SockAddrIn TranslateToSockAddrIn(sockaddr input_) {
+    sockaddr_in input;
+    std::memcpy(&input, &input_, sizeof(input));
+    SockAddrIn result;
+    switch (input.sin_family) {
+    case AF_INET:
+        result.family = Domain::INET;
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unhandled sockaddr family={}", input.sin_family);
+        result.family = Domain::INET;
+        break;
+    }
+    result.portno = ntohs(input.sin_port);
+    result.ip = TranslateIPv4(input.sin_addr);
+    return result;
+}
+u16 TranslatePollEvents(u16 events) {
+    u16 result = 0;
+    if (events & POLL_IN) {
+        events &= ~POLL_IN;
+        result |= POLLIN;
+    }
+    if (events & POLL_PRI) {
+        events &= ~POLL_PRI;
+#ifdef _WIN32
+        LOG_WARNING(Service, "Winsock doesn't support POLLPRI");
+#else
+        result |= POLL_PRI;
+#endif
+    }
+    if (events & POLL_OUT) {
+        events &= ~POLL_OUT;
+        result |= POLLOUT;
+    }
+    UNIMPLEMENTED_IF_MSG(events != 0, "Unhandled guest events=0x{:x}", events);
+    return result;
+}
+u16 TranslatePollRevents(u16 revents) {
+    u16 result = 0;
+    const auto translate = [&result, &revents](int host, unsigned guest) {
+        if (revents & host) {
+            revents &= ~host;
+            result |= guest;
+        }
+    };
+    translate(POLLIN, POLL_IN);
+    translate(POLLPRI, POLL_PRI);
+    translate(POLLOUT, POLL_OUT);
+    translate(POLLERR, POLL_ERR);
+    translate(POLLHUP, POLL_HUP);
+    UNIMPLEMENTED_IF_MSG(revents != 0, "Unhandled host revents=0x{:x}", revents);
+    return result;
+}
+template <typename T>
+Errno SetSockOpt(SOCKET fd, int option, T value) {
+    const int result =
+        setsockopt(fd, SOL_SOCKET, option, reinterpret_cast<const char*>(&value), sizeof(value));
+    if (result != SOCKET_ERROR) {
+        return Errno::SUCCESS;
+    }
+    const int ec = LastError();
+    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+    return Errno::SUCCESS;
+}
+} // Anonymous namespace
+NetworkInstance::NetworkInstance() {
+    Initialize();
+}
+NetworkInstance::~NetworkInstance() {
+    Finalize();
+}
+std::pair<IPv4Address, Errno> GetHostIPv4Address() {
+    std::array<char, 256> name{};
+    if (gethostname(name.data(), static_cast<int>(name.size()) - 1) == SOCKET_ERROR) {
+        UNIMPLEMENTED_MSG("Unhandled gethostname error");
+        return {IPv4Address{}, Errno::SUCCESS};
+    }
+    hostent* const ent = gethostbyname(name.data());
+    if (!ent) {
+        UNIMPLEMENTED_MSG("Unhandled gethostbyname error");
+        return {IPv4Address{}, Errno::SUCCESS};
+    }
+    if (ent->h_addr_list == nullptr) {
+        UNIMPLEMENTED_MSG("No addr provided in hostent->h_addr_list");
+        return {IPv4Address{}, Errno::SUCCESS};
+    }
+    if (ent->h_length != sizeof(in_addr)) {
+        UNIMPLEMENTED_MSG("Unexpected size={} in hostent->h_length", ent->h_length);
+    }
+    in_addr addr;
+    std::memcpy(&addr, ent->h_addr_list[0], sizeof(addr));
+    return {TranslateIPv4(addr), Errno::SUCCESS};
+}
+std::pair<s32, Errno> Poll(std::vector<PollFD>& pollfds, s32 timeout) {
+    const size_t num = pollfds.size();
+    std::vector<WSAPOLLFD> host_pollfds(pollfds.size());
+    std::transform(pollfds.begin(), pollfds.end(), host_pollfds.begin(), [](PollFD fd) {
+        WSAPOLLFD result;
+        result.fd = fd.socket->fd;
+        result.events = TranslatePollEvents(fd.events);
+        result.revents = 0;
+        return result;
+    });
+    const int result = WSAPoll(host_pollfds.data(), static_cast<ULONG>(num), timeout);
+    if (result == 0) {
+        ASSERT(std::all_of(host_pollfds.begin(), host_pollfds.end(),
+                           [](WSAPOLLFD fd) { return fd.revents == 0; }));
+        return {0, Errno::SUCCESS};
+    }
+    for (size_t i = 0; i < num; ++i) {
+        pollfds[i].revents = TranslatePollRevents(host_pollfds[i].revents);
+    }
+    if (result > 0) {
+        return {result, Errno::SUCCESS};
+    }
+    ASSERT(result == SOCKET_ERROR);
+    const int ec = LastError();
+    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+    return {-1, Errno::SUCCESS};
+}
+Socket::~Socket() {
+    if (fd == INVALID_SOCKET) {
+        return;
+    }
+    (void)closesocket(fd);
+    fd = INVALID_SOCKET;
+}
+Socket::Socket(Socket&& rhs) noexcept : fd{std::exchange(rhs.fd, INVALID_SOCKET)} {}
+Errno Socket::Initialize(Domain domain, Type type, Protocol protocol) {
+    fd = socket(TranslateDomain(domain), TranslateType(type), TranslateProtocol(protocol));
+    if (fd != INVALID_SOCKET) {
+        return Errno::SUCCESS;
+    }
+    const int ec = LastError();
+    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+    return Errno::SUCCESS;
+}
+std::pair<Socket::AcceptResult, Errno> Socket::Accept() {
+    sockaddr addr;
+    socklen_t addrlen = sizeof(addr);
+    const SOCKET new_socket = accept(fd, &addr, &addrlen);
+    if (new_socket == INVALID_SOCKET) {
+        const int ec = LastError();
+        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+        return {AcceptResult{}, Errno::SUCCESS};
+    }
+    AcceptResult result;
+    result.socket = std::make_unique<Socket>();
+    result.socket->fd = new_socket;
+    ASSERT(addrlen == sizeof(sockaddr_in));
+    result.sockaddr_in = TranslateToSockAddrIn(addr);
+    return {std::move(result), Errno::SUCCESS};
+}
+Errno Socket::Connect(SockAddrIn addr_in) {
+    const sockaddr host_addr_in = TranslateFromSockAddrIn(addr_in);
+    if (connect(fd, &host_addr_in, sizeof(host_addr_in)) != INVALID_SOCKET) {
+        return Errno::SUCCESS;
+    }
+    switch (const int ec = LastError()) {
+    case WSAEWOULDBLOCK:
+        LOG_DEBUG(Service, "EAGAIN generated");
+        return Errno::AGAIN;
+    default:
+        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+        return Errno::SUCCESS;
+    }
+}
+std::pair<SockAddrIn, Errno> Socket::GetPeerName() {
+    sockaddr addr;
+    socklen_t addrlen = sizeof(addr);
+    if (getpeername(fd, &addr, &addrlen) == SOCKET_ERROR) {
+        const int ec = LastError();
+        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+        return {SockAddrIn{}, Errno::SUCCESS};
+    }
+    ASSERT(addrlen == sizeof(sockaddr_in));
+    return {TranslateToSockAddrIn(addr), Errno::SUCCESS};
+}
+std::pair<SockAddrIn, Errno> Socket::GetSockName() {
+    sockaddr addr;
+    socklen_t addrlen = sizeof(addr);
+    if (getsockname(fd, &addr, &addrlen) == SOCKET_ERROR) {
+        const int ec = LastError();
+        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+        return {SockAddrIn{}, Errno::SUCCESS};
+    }
+    ASSERT(addrlen == sizeof(sockaddr_in));
+    return {TranslateToSockAddrIn(addr), Errno::SUCCESS};
+}
+Errno Socket::Bind(SockAddrIn addr) {
+    const sockaddr addr_in = TranslateFromSockAddrIn(addr);
+    if (bind(fd, &addr_in, sizeof(addr_in)) != SOCKET_ERROR) {
+        return Errno::SUCCESS;
+    }
+    const int ec = LastError();
+    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+    return Errno::SUCCESS;
+}
+Errno Socket::Listen(s32 backlog) {
+    if (listen(fd, backlog) != SOCKET_ERROR) {
+        return Errno::SUCCESS;
+    }
+    const int ec = LastError();
+    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+    return Errno::SUCCESS;
+}
+Errno Socket::Shutdown(ShutdownHow how) {
+    int host_how = 0;
+    switch (how) {
+    case ShutdownHow::RD:
+        host_how = SD_RECEIVE;
+        break;
+    case ShutdownHow::WR:
+        host_how = SD_SEND;
+        break;
+    case ShutdownHow::RDWR:
+        host_how = SD_BOTH;
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented flag how={}", static_cast<int>(how));
+        return Errno::SUCCESS;
+    }
+    if (shutdown(fd, host_how) != SOCKET_ERROR) {
+        return Errno::SUCCESS;
+    }
+    switch (const int ec = LastError()) {
+    case WSAENOTCONN:
+        LOG_ERROR(Service, "ENOTCONN generated");
+        return Errno::NOTCONN;
+    default:
+        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+        return Errno::SUCCESS;
+    }
+}
+std::pair<s32, Errno> Socket::Recv(int flags, std::vector<u8>& message) {
+    ASSERT(flags == 0);
+    ASSERT(message.size() < static_cast<size_t>(std::numeric_limits<int>::max()));
+    const int result =
+        recv(fd, reinterpret_cast<char*>(message.data()), static_cast<int>(message.size()), 0);
+    if (result != SOCKET_ERROR) {
+        return {result, Errno::SUCCESS};
+    }
+    switch (const int ec = LastError()) {
+    case WSAEWOULDBLOCK:
+        LOG_DEBUG(Service, "EAGAIN generated");
+        return {-1, Errno::AGAIN};
+    case WSAENOTCONN:
+        LOG_ERROR(Service, "ENOTCONN generated");
+        return {-1, Errno::NOTCONN};
+    default:
+        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+        return {0, Errno::SUCCESS};
+    }
+}
+std::pair<s32, Errno> Socket::RecvFrom(int flags, std::vector<u8>& message, SockAddrIn* addr) {
+    ASSERT(flags == 0);
+    ASSERT(message.size() < static_cast<size_t>(std::numeric_limits<int>::max()));
+    sockaddr addr_in{};
+    socklen_t addrlen = sizeof(addr_in);
+    socklen_t* const p_addrlen = addr ? &addrlen : nullptr;
+    sockaddr* const p_addr_in = addr ? &addr_in : nullptr;
+    const int result = recvfrom(fd, reinterpret_cast<char*>(message.data()),
+                                static_cast<int>(message.size()), 0, p_addr_in, p_addrlen);
+    if (result != SOCKET_ERROR) {
+        if (addr) {
+            ASSERT(addrlen == sizeof(addr_in));
+            *addr = TranslateToSockAddrIn(addr_in);
+        }
+        return {result, Errno::SUCCESS};
+    }
+    switch (const int ec = LastError()) {
+    case WSAEWOULDBLOCK:
+        LOG_DEBUG(Service, "EAGAIN generated");
+        return {-1, Errno::AGAIN};
+    case WSAENOTCONN:
+        LOG_ERROR(Service, "ENOTCONN generated");
+        return {-1, Errno::NOTCONN};
+    default:
+        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+        return {-1, Errno::SUCCESS};
+    }
+}
+std::pair<s32, Errno> Socket::Send(const std::vector<u8>& message, int flags) {
+    ASSERT(message.size() < static_cast<size_t>(std::numeric_limits<int>::max()));
+    ASSERT(flags == 0);
+    const int result = send(fd, reinterpret_cast<const char*>(message.data()),
+                            static_cast<int>(message.size()), 0);
+    if (result != SOCKET_ERROR) {
+        return {result, Errno::SUCCESS};
+    }
+    const int ec = LastError();
+    switch (ec) {
+    case WSAEWOULDBLOCK:
+        LOG_DEBUG(Service, "EAGAIN generated");
+        return {-1, Errno::AGAIN};
+    case WSAENOTCONN:
+        LOG_ERROR(Service, "ENOTCONN generated");
+        return {-1, Errno::NOTCONN};
+    default:
+        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+        return {-1, Errno::SUCCESS};
+    }
+}
+std::pair<s32, Errno> Socket::SendTo(u32 flags, const std::vector<u8>& message,
+                                     const SockAddrIn* addr) {
+    ASSERT(flags == 0);
+    const sockaddr* to = nullptr;
+    const int tolen = addr ? 0 : sizeof(sockaddr);
+    sockaddr host_addr_in;
+    if (addr) {
+        host_addr_in = TranslateFromSockAddrIn(*addr);
+        to = &host_addr_in;
+    }
+    const int result = sendto(fd, reinterpret_cast<const char*>(message.data()),
+                              static_cast<int>(message.size()), 0, to, tolen);
+    if (result != SOCKET_ERROR) {
+        return {result, Errno::SUCCESS};
+    }
+    const int ec = LastError();
+    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+    return {-1, Errno::SUCCESS};
+}
+Errno Socket::Close() {
+    [[maybe_unused]] const int result = closesocket(fd);
+    ASSERT(result == 0);
+    fd = INVALID_SOCKET;
+    return Errno::SUCCESS;
+}
+Errno Socket::SetLinger(bool enable, u32 linger) {
+    return SetSockOpt(fd, SO_LINGER, MakeLinger(enable, linger));
+}
+Errno Socket::SetReuseAddr(bool enable) {
+    return SetSockOpt<u32>(fd, SO_REUSEADDR, enable ? 1 : 0);
+}
+Errno Socket::SetBroadcast(bool enable) {
+    return SetSockOpt<u32>(fd, SO_BROADCAST, enable ? 1 : 0);
+}
+Errno Socket::SetSndBuf(u32 value) {
+    return SetSockOpt(fd, SO_SNDBUF, value);
+}
+Errno Socket::SetRcvBuf(u32 value) {
+    return SetSockOpt(fd, SO_RCVBUF, value);
+}
+Errno Socket::SetSndTimeo(u32 value) {
+    return SetSockOpt(fd, SO_SNDTIMEO, value);
+}
+Errno Socket::SetRcvTimeo(u32 value) {
+    return SetSockOpt(fd, SO_RCVTIMEO, value);
+}
+Errno Socket::SetNonBlock(bool enable) {
+    if (EnableNonBlock(fd, enable)) {
+        return Errno::SUCCESS;
+    }
+    const int ec = LastError();
+    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
+    return Errno::SUCCESS;
+}
+bool Socket::IsOpened() const {
+    return fd != INVALID_SOCKET;
+}
+} // namespace Network
diff --git a/src/core/network/network.h b/src/core/network/network.h
new file mode 100644
index 000000000..0622e4593
--- /dev/null
+++ b/src/core/network/network.h
@@ -0,0 +1,87 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#pragma once
+#include <array>
+#include <utility>
+#include "common/common_types.h"
+namespace Network {
+class Socket;
+/// Error code for network functions
+enum class Errno {
+    SUCCESS,
+    BADF,
+    INVAL,
+    MFILE,
+    NOTCONN,
+    AGAIN,
+};
+/// Address families
+enum class Domain {
+    INET, ///< Address family for IPv4
+};
+/// Socket types
+enum class Type {
+    STREAM,
+    DGRAM,
+    RAW,
+    SEQPACKET,
+};
+/// Protocol values for sockets
+enum class Protocol {
+    ICMP,
+    TCP,
+    UDP,
+};
+/// Shutdown mode
+enum class ShutdownHow {
+    RD,
+    WR,
+    RDWR,
+};
+/// Array of IPv4 address
+using IPv4Address = std::array<u8, 4>;
+/// Cross-platform sockaddr structure
+struct SockAddrIn {
+    Domain family;
+    IPv4Address ip;
+    u16 portno;
+};
+/// Cross-platform poll fd structure
+struct PollFD {
+    Socket* socket;
+    u16 events;
+    u16 revents;
+};
+constexpr u16 POLL_IN = 1 << 0;
+constexpr u16 POLL_PRI = 1 << 1;
+constexpr u16 POLL_OUT = 1 << 2;
+constexpr u16 POLL_ERR = 1 << 3;
+constexpr u16 POLL_HUP = 1 << 4;
+constexpr u16 POLL_NVAL = 1 << 5;
+class NetworkInstance {
+public:
+    explicit NetworkInstance();
+    ~NetworkInstance();
+};
+/// @brief Returns host's IPv4 address
+/// @return Pair of an array of human ordered IPv4 address (e.g. 192.168.0.1) and an error code
+std::pair<IPv4Address, Errno> GetHostIPv4Address();
+} // namespace Network
diff --git a/src/core/network/sockets.h b/src/core/network/sockets.h
new file mode 100644
index 000000000..7bdff0fe4
--- /dev/null
+++ b/src/core/network/sockets.h
@@ -0,0 +1,94 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#pragma once
+#include <memory>
+#include <utility>
+#if defined(_WIN32)
+#include <winsock.h>
+#elif !defined(__unix__)
+#error "Platform not implemented"
+#endif
+#include "common/common_types.h"
+#include "core/network/network.h"
+// TODO: C++20 Replace std::vector usages with std::span
+namespace Network {
+class Socket {
+public:
+    struct AcceptResult {
+        std::unique_ptr<Socket> socket;
+        SockAddrIn sockaddr_in;
+    };
+    explicit Socket() = default;
+    ~Socket();
+    Socket(const Socket&) = delete;
+    Socket& operator=(const Socket&) = delete;
+    Socket(Socket&& rhs) noexcept;
+    // Avoid closing sockets implicitly
+    Socket& operator=(Socket&&) noexcept = delete;
+    Errno Initialize(Domain domain, Type type, Protocol protocol);
+    Errno Close();
+    std::pair<AcceptResult, Errno> Accept();
+    Errno Connect(SockAddrIn addr_in);
+    std::pair<SockAddrIn, Errno> GetPeerName();
+    std::pair<SockAddrIn, Errno> GetSockName();
+    Errno Bind(SockAddrIn addr);
+    Errno Listen(s32 backlog);
+    Errno Shutdown(ShutdownHow how);
+    std::pair<s32, Errno> Recv(int flags, std::vector<u8>& message);
+    std::pair<s32, Errno> RecvFrom(int flags, std::vector<u8>& message, SockAddrIn* addr);
+    std::pair<s32, Errno> Send(const std::vector<u8>& message, int flags);
+    std::pair<s32, Errno> SendTo(u32 flags, const std::vector<u8>& message, const SockAddrIn* addr);
+    Errno SetLinger(bool enable, u32 linger);
+    Errno SetReuseAddr(bool enable);
+    Errno SetBroadcast(bool enable);
+    Errno SetSndBuf(u32 value);
+    Errno SetRcvBuf(u32 value);
+    Errno SetSndTimeo(u32 value);
+    Errno SetRcvTimeo(u32 value);
+    Errno SetNonBlock(bool enable);
+    bool IsOpened() const;
+#if defined(_WIN32)
+    SOCKET fd = INVALID_SOCKET;
+#elif defined(__unix__)
+    int fd = -1;
+#endif
+};
+std::pair<s32, Errno> Poll(std::vector<PollFD>& poll_fds, s32 timeout);
+} // namespace Network
diff --git a/src/core/settings.cpp b/src/core/settings.cpp
index 44252dd81..416b2d866 100644
--- a/src/core/settings.cpp
+++ b/src/core/settings.cpp
@@ -173,7 +173,6 @@ void RestoreGlobalState() {
    values.use_assembly_shaders.SetGlobal(true);
    values.use_asynchronous_shaders.SetGlobal(true);
    values.use_fast_gpu_time.SetGlobal(true);
-    values.force_30fps_mode.SetGlobal(true);
    values.bg_red.SetGlobal(true);
    values.bg_green.SetGlobal(true);
    values.bg_blue.SetGlobal(true);
diff --git a/src/core/settings.h b/src/core/settings.h
index 386233fdf..bb145f193 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -435,7 +435,6 @@ struct Values {
    Setting<bool> use_vsync;
    Setting<bool> use_assembly_shaders;
    Setting<bool> use_asynchronous_shaders;
-    Setting<bool> force_30fps_mode;
    Setting<bool> use_fast_gpu_time;
    Setting<float> bg_red;
diff --git a/src/core/tools/freezer.cpp b/src/core/tools/freezer.cpp
index 27b894b51..2003e096f 100644
--- a/src/core/tools/freezer.cpp
+++ b/src/core/tools/freezer.cpp
@@ -55,10 +55,11 @@ void MemoryWriteWidth(Core::Memory::Memory& memory, u32 width, VAddr addr, u64 v
 Freezer::Freezer(Core::Timing::CoreTiming& core_timing_, Core::Memory::Memory& memory_)
    : core_timing{core_timing_}, memory{memory_} {
-    event = Core::Timing::CreateEvent("MemoryFreezer::FrameCallback",
+    event = Core::Timing::CreateEvent(
-                                      [this](u64 userdata, std::chrono::nanoseconds ns_late) {
+        "MemoryFreezer::FrameCallback",
-                                          FrameCallback(userdata, ns_late);
+        [this](std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
-                                      });
+            FrameCallback(user_data, ns_late);
+        });
    core_timing.ScheduleEvent(memory_freezer_ns, event);
 }
@@ -159,7 +160,7 @@ std::vector<Freezer::Entry> Freezer::GetEntries() const {
    return entries;
 }
-void Freezer::FrameCallback(u64, std::chrono::nanoseconds ns_late) {
+void Freezer::FrameCallback(std::uintptr_t, std::chrono::nanoseconds ns_late) {
    if (!IsActive()) {
        LOG_DEBUG(Common_Memory, "Memory freezer has been deactivated, ending callback events.");
        return;
diff --git a/src/core/tools/freezer.h b/src/core/tools/freezer.h
index 8438783d5..2b2326bc4 100644
--- a/src/core/tools/freezer.h
+++ b/src/core/tools/freezer.h
@@ -73,7 +73,7 @@ public:
    std::vector<Entry> GetEntries() const;
 private:
-    void FrameCallback(u64 userdata, std::chrono::nanoseconds ns_late);
+    void FrameCallback(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
    void FillEntryReads();
    std::atomic_bool active{false};
diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp
index 898a278a9..74759ea7d 100644
--- a/src/input_common/gcadapter/gc_adapter.cpp
+++ b/src/input_common/gcadapter/gc_adapter.cpp
@@ -24,12 +24,9 @@ Adapter::Adapter() {
    }
    LOG_INFO(Input, "GC Adapter Initialization started");
-    current_status = NO_ADAPTER_DETECTED;
-    get_origin.fill(true);
    const int init_res = libusb_init(&libusb_ctx);
    if (init_res == LIBUSB_SUCCESS) {
-        StartScanThread();
+        Setup();
    } else {
        LOG_ERROR(Input, "libusb could not be initialized. failed with error = {}", init_res);
    }
@@ -37,9 +34,9 @@ Adapter::Adapter() {
 GCPadStatus Adapter::GetPadStatus(std::size_t port, const std::array<u8, 37>& adapter_payload) {
    GCPadStatus pad = {};
+    const std::size_t offset = 1 + (9 * port);
-    ControllerTypes type = ControllerTypes(adapter_payload[1 + (9 * port)] >> 4);
+    adapter_controllers_status[port] = static_cast<ControllerTypes>(adapter_payload[offset] >> 4);
-    adapter_controllers_status[port] = type;
    static constexpr std::array<PadButton, 8> b1_buttons{
        PadButton::PAD_BUTTON_A,    PadButton::PAD_BUTTON_B,    PadButton::PAD_BUTTON_X,
@@ -54,14 +51,19 @@ GCPadStatus Adapter::GetPadStatus(std::size_t port, const std::array<u8, 37>& ad
        PadButton::PAD_TRIGGER_L,
    };
+    static constexpr std::array<PadAxes, 6> axes{
+        PadAxes::StickX,    PadAxes::StickY,      PadAxes::SubstickX,
+        PadAxes::SubstickY, PadAxes::TriggerLeft, PadAxes::TriggerRight,
+    };
    if (adapter_controllers_status[port] == ControllerTypes::None && !get_origin[port]) {
        // Controller may have been disconnected, recalibrate if reconnected.
        get_origin[port] = true;
    }
    if (adapter_controllers_status[port] != ControllerTypes::None) {
-        const u8 b1 = adapter_payload[1 + (9 * port) + 1];
+        const u8 b1 = adapter_payload[offset + 1];
-        const u8 b2 = adapter_payload[1 + (9 * port) + 2];
+        const u8 b2 = adapter_payload[offset + 2];
        for (std::size_t i = 0; i < b1_buttons.size(); ++i) {
            if ((b1 & (1U << i)) != 0) {
@@ -74,21 +76,13 @@ GCPadStatus Adapter::GetPadStatus(std::size_t port, const std::array<u8, 37>& ad
                pad.button |= static_cast<u16>(b2_buttons[j]);
            }
        }
+        for (PadAxes axis : axes) {
-        pad.stick_x = adapter_payload[1 + (9 * port) + 3];
+            const std::size_t index = static_cast<std::size_t>(axis);
-        pad.stick_y = adapter_payload[1 + (9 * port) + 4];
+            pad.axis_values[index] = adapter_payload[offset + 3 + index];
-        pad.substick_x = adapter_payload[1 + (9 * port) + 5];
+        }
-        pad.substick_y = adapter_payload[1 + (9 * port) + 6];
-        pad.trigger_left = adapter_payload[1 + (9 * port) + 7];
-        pad.trigger_right = adapter_payload[1 + (9 * port) + 8];
        if (get_origin[port]) {
-            origin_status[port].stick_x = pad.stick_x;
+            origin_status[port].axis_values = pad.axis_values;
-            origin_status[port].stick_y = pad.stick_y;
-            origin_status[port].substick_x = pad.substick_x;
-            origin_status[port].substick_y = pad.substick_y;
-            origin_status[port].trigger_left = pad.trigger_left;
-            origin_status[port].trigger_right = pad.trigger_right;
            get_origin[port] = false;
        }
    }
@@ -101,82 +95,47 @@ void Adapter::PadToState(const GCPadStatus& pad, GCState& state) {
        state.buttons.insert_or_assign(button_value, pad.button & button_value);
    }
-    state.axes.insert_or_assign(static_cast<u8>(PadAxes::StickX), pad.stick_x);
+    for (size_t i = 0; i < pad.axis_values.size(); ++i) {
-    state.axes.insert_or_assign(static_cast<u8>(PadAxes::StickY), pad.stick_y);
+        state.axes.insert_or_assign(static_cast<u8>(i), pad.axis_values[i]);
-    state.axes.insert_or_assign(static_cast<u8>(PadAxes::SubstickX), pad.substick_x);
+    }
-    state.axes.insert_or_assign(static_cast<u8>(PadAxes::SubstickY), pad.substick_y);
-    state.axes.insert_or_assign(static_cast<u8>(PadAxes::TriggerLeft), pad.trigger_left);
-    state.axes.insert_or_assign(static_cast<u8>(PadAxes::TriggerRight), pad.trigger_right);
 }
 void Adapter::Read() {
    LOG_DEBUG(Input, "GC Adapter Read() thread started");
-    int payload_size_in, payload_size_copy;
+    int payload_size;
    std::array<u8, 37> adapter_payload;
-    std::array<u8, 37> adapter_payload_copy;
    std::array<GCPadStatus, 4> pads;
    while (adapter_thread_running) {
        libusb_interrupt_transfer(usb_adapter_handle, input_endpoint, adapter_payload.data(),
-                                  sizeof(adapter_payload), &payload_size_in, 16);
+                                  sizeof(adapter_payload), &payload_size, 16);
-        payload_size_copy = 0;
-        // this mutex might be redundant?
-        {
-            std::lock_guard<std::mutex> lk(s_mutex);
-            std::copy(std::begin(adapter_payload), std::end(adapter_payload),
-                      std::begin(adapter_payload_copy));
-            payload_size_copy = payload_size_in;
-        }
-        if (payload_size_copy != sizeof(adapter_payload_copy) ||
+        if (payload_size != sizeof(adapter_payload) || adapter_payload[0] != LIBUSB_DT_HID) {
-            adapter_payload_copy[0] != LIBUSB_DT_HID) {
+            LOG_ERROR(Input,
-            LOG_ERROR(Input, "error reading payload (size: {}, type: {:02x})", payload_size_copy,
+                      "Error reading payload (size: {}, type: {:02x}) Is the adapter connected?",
-                      adapter_payload_copy[0]);
+                      payload_size, adapter_payload[0]);
            adapter_thread_running = false; // error reading from adapter, stop reading.
            break;
        }
        for (std::size_t port = 0; port < pads.size(); ++port) {
-            pads[port] = GetPadStatus(port, adapter_payload_copy);
+            pads[port] = GetPadStatus(port, adapter_payload);
            if (DeviceConnected(port) && configuring) {
                if (pads[port].button != 0) {
                    pad_queue[port].Push(pads[port]);
                }
-                // Accounting for a threshold here because of some controller variance
+                // Accounting for a threshold here to ensure an intentional press
-                if (pads[port].stick_x > origin_status[port].stick_x + pads[port].THRESHOLD ||
+                for (size_t i = 0; i < pads[port].axis_values.size(); ++i) {
-                    pads[port].stick_x < origin_status[port].stick_x - pads[port].THRESHOLD) {
+                    const u8 value = pads[port].axis_values[i];
-                    pads[port].axis = GCAdapter::PadAxes::StickX;
+                    const u8 origin = origin_status[port].axis_values[i];
-                    pads[port].axis_value = pads[port].stick_x;
-                    pad_queue[port].Push(pads[port]);
+                    if (value > origin + pads[port].THRESHOLD ||
-                }
+                        value < origin - pads[port].THRESHOLD) {
-                if (pads[port].stick_y > origin_status[port].stick_y + pads[port].THRESHOLD ||
+                        pads[port].axis = static_cast<PadAxes>(i);
-                    pads[port].stick_y < origin_status[port].stick_y - pads[port].THRESHOLD) {
+                        pads[port].axis_value = pads[port].axis_values[i];
-                    pads[port].axis = GCAdapter::PadAxes::StickY;
+                        pad_queue[port].Push(pads[port]);
-                    pads[port].axis_value = pads[port].stick_y;
+                    }
-                    pad_queue[port].Push(pads[port]);
-                }
-                if (pads[port].substick_x > origin_status[port].substick_x + pads[port].THRESHOLD ||
-                    pads[port].substick_x < origin_status[port].substick_x - pads[port].THRESHOLD) {
-                    pads[port].axis = GCAdapter::PadAxes::SubstickX;
-                    pads[port].axis_value = pads[port].substick_x;
-                    pad_queue[port].Push(pads[port]);
-                }
-                if (pads[port].substick_y > origin_status[port].substick_y + pads[port].THRESHOLD ||
-                    pads[port].substick_y < origin_status[port].substick_y - pads[port].THRESHOLD) {
-                    pads[port].axis = GCAdapter::PadAxes::SubstickY;
-                    pads[port].axis_value = pads[port].substick_y;
-                    pad_queue[port].Push(pads[port]);
-                }
-                if (pads[port].trigger_left > pads[port].TRIGGER_THRESHOLD) {
-                    pads[port].axis = GCAdapter::PadAxes::TriggerLeft;
-                    pads[port].axis_value = pads[port].trigger_left;
-                    pad_queue[port].Push(pads[port]);
-                }
-                if (pads[port].trigger_right > pads[port].TRIGGER_THRESHOLD) {
-                    pads[port].axis = GCAdapter::PadAxes::TriggerRight;
-                    pads[port].axis_value = pads[port].trigger_right;
-                    pad_queue[port].Push(pads[port]);
                }
            }
            PadToState(pads[port], state[port]);
@@ -185,42 +144,11 @@ void Adapter::Read() {
    }
 }
-void Adapter::ScanThreadFunc() {
-    LOG_INFO(Input, "GC Adapter scanning thread started");
-    while (detect_thread_running) {
-        if (usb_adapter_handle == nullptr) {
-            std::lock_guard<std::mutex> lk(initialization_mutex);
-            Setup();
-        }
-        std::this_thread::sleep_for(std::chrono::milliseconds(500));
-    }
-}
-void Adapter::StartScanThread() {
-    if (detect_thread_running) {
-        return;
-    }
-    if (!libusb_ctx) {
-        return;
-    }
-    detect_thread_running = true;
-    detect_thread = std::thread(&Adapter::ScanThreadFunc, this);
-}
-void Adapter::StopScanThread() {
-    detect_thread_running = false;
-    detect_thread.join();
-}
 void Adapter::Setup() {
-    // Reset the error status in case the adapter gets unplugged
+    // Initialize all controllers as unplugged
-    if (current_status < 0) {
-        current_status = NO_ADAPTER_DETECTED;
-    }
    adapter_controllers_status.fill(ControllerTypes::None);
+    // Initialize all ports to store axis origin values
+    get_origin.fill(true);
    // pointer to list of connected usb devices
    libusb_device** devices{};
@@ -229,8 +157,6 @@ void Adapter::Setup() {
    const ssize_t device_count = libusb_get_device_list(libusb_ctx, &devices);
    if (device_count < 0) {
        LOG_ERROR(Input, "libusb_get_device_list failed with error: {}", device_count);
-        detect_thread_running = false; // Stop the loop constantly checking for gc adapter
-        // TODO: For hotplug+gc adapter checkbox implementation, revert this.
        return;
    }
@@ -244,9 +170,6 @@ void Adapter::Setup() {
        }
        libusb_free_device_list(devices, 1);
    }
-    // Break out of the ScanThreadFunc() loop that is constantly looking for the device
-    // Assumes user has GC adapter plugged in before launch to use the adapter
-    detect_thread_running = false;
 }
 bool Adapter::CheckDeviceAccess(libusb_device* device) {
@@ -331,32 +254,23 @@ void Adapter::GetGCEndpoint(libusb_device* device) {
                              sizeof(clear_payload), nullptr, 16);
    adapter_thread_running = true;
-    current_status = ADAPTER_DETECTED;
+    adapter_input_thread = std::thread(&Adapter::Read, this);
-    adapter_input_thread = std::thread([=] { Read(); }); // Read input
 }
 Adapter::~Adapter() {
-    StopScanThread();
    Reset();
 }
 void Adapter::Reset() {
-    std::unique_lock<std::mutex> lock(initialization_mutex, std::defer_lock);
-    if (!lock.try_lock()) {
-        return;
-    }
-    if (current_status != ADAPTER_DETECTED) {
-        return;
-    }
    if (adapter_thread_running) {
        adapter_thread_running = false;
    }
-    adapter_input_thread.join();
+    if (adapter_input_thread.joinable()) {
+        adapter_input_thread.join();
+    }
    adapter_controllers_status.fill(ControllerTypes::None);
    get_origin.fill(true);
-    current_status = NO_ADAPTER_DETECTED;
    if (usb_adapter_handle) {
        libusb_release_interface(usb_adapter_handle, 1);
@@ -409,24 +323,7 @@ const std::array<GCState, 4>& Adapter::GetPadState() const {
 }
 int Adapter::GetOriginValue(int port, int axis) const {
-    const auto& status = origin_status[port];
+    return origin_status[port].axis_values[axis];
-    switch (static_cast<PadAxes>(axis)) {
-    case PadAxes::StickX:
-        return status.stick_x;
-    case PadAxes::StickY:
-        return status.stick_y;
-    case PadAxes::SubstickX:
-        return status.substick_x;
-    case PadAxes::SubstickY:
-        return status.substick_y;
-    case PadAxes::TriggerLeft:
-        return status.trigger_left;
-    case PadAxes::TriggerRight:
-        return status.trigger_right;
-    default:
-        return 0;
-    }
 }
 } // namespace GCAdapter
diff --git a/src/input_common/gcadapter/gc_adapter.h b/src/input_common/gcadapter/gc_adapter.h
index 3586c8bda..bed81915c 100644
--- a/src/input_common/gcadapter/gc_adapter.h
+++ b/src/input_common/gcadapter/gc_adapter.h
@@ -47,24 +47,10 @@ enum class PadAxes : u8 {
 };
 struct GCPadStatus {
-    u16 button{};       // Or-ed PAD_BUTTON_* and PAD_TRIGGER_* bits
+    u16 button{}; // Or-ed PAD_BUTTON_* and PAD_TRIGGER_* bits
-    u8 stick_x{};       // 0 <= stick_x       <= 255
-    u8 stick_y{};       // 0 <= stick_y       <= 255
+    std::array<u8, 6> axis_values{};    // Triggers and sticks, following indices defined in PadAxes
-    u8 substick_x{};    // 0 <= substick_x    <= 255
+    static constexpr u8 THRESHOLD = 50; // Threshold for axis press for polling
-    u8 substick_y{};    // 0 <= substick_y    <= 255
-    u8 trigger_left{};  // 0 <= trigger_left  <= 255
-    u8 trigger_right{}; // 0 <= trigger_right <= 255
-    static constexpr u8 MAIN_STICK_CENTER_X = 0x80;
-    static constexpr u8 MAIN_STICK_CENTER_Y = 0x80;
-    static constexpr u8 MAIN_STICK_RADIUS = 0x7f;
-    static constexpr u8 C_STICK_CENTER_X = 0x80;
-    static constexpr u8 C_STICK_CENTER_Y = 0x80;
-    static constexpr u8 C_STICK_RADIUS = 0x7f;
-    static constexpr u8 THRESHOLD = 10;
-    // 256/4, at least a quarter press to count as a press. For polling mostly
-    static constexpr u8 TRIGGER_THRESHOLD = 64;
    u8 port{};
    PadAxes axis{PadAxes::Undefined};
@@ -78,11 +64,6 @@ struct GCState {
 enum class ControllerTypes { None, Wired, Wireless };
-enum {
-    NO_ADAPTER_DETECTED = 0,
-    ADAPTER_DETECTED = 1,
-};
 class Adapter {
 public:
    /// Initialize the GC Adapter capture and read sequence
@@ -111,12 +92,6 @@ private:
    void PadToState(const GCPadStatus& pad, GCState& state);
    void Read();
-    void ScanThreadFunc();
-    /// Begin scanning for the GC Adapter.
-    void StartScanThread();
-    /// Stop scanning for the adapter
-    void StopScanThread();
    /// Resets status of device connected to port
    void ResetDeviceType(std::size_t port);
@@ -133,19 +108,11 @@ private:
    /// For use in initialization, querying devices to find the adapter
    void Setup();
-    int current_status = NO_ADAPTER_DETECTED;
    libusb_device_handle* usb_adapter_handle = nullptr;
-    std::array<ControllerTypes, 4> adapter_controllers_status{};
-    std::mutex s_mutex;
    std::thread adapter_input_thread;
    bool adapter_thread_running;
-    std::mutex initialization_mutex;
-    std::thread detect_thread;
-    bool detect_thread_running = false;
    libusb_context* libusb_ctx;
    u8 input_endpoint = 0;
@@ -153,10 +120,11 @@ private:
    bool configuring = false;
-    std::array<Common::SPSCQueue<GCPadStatus>, 4> pad_queue;
    std::array<GCState, 4> state;
    std::array<bool, 4> get_origin;
    std::array<GCPadStatus, 4> origin_status;
+    std::array<Common::SPSCQueue<GCPadStatus>, 4> pad_queue;
+    std::array<ControllerTypes, 4> adapter_controllers_status{};
 };
 } // namespace GCAdapter
diff --git a/src/input_common/gcadapter/gc_poller.cpp b/src/input_common/gcadapter/gc_poller.cpp
index 96e22d3ad..f45983f3f 100644
--- a/src/input_common/gcadapter/gc_poller.cpp
+++ b/src/input_common/gcadapter/gc_poller.cpp
@@ -76,8 +76,7 @@ std::unique_ptr<Input::ButtonDevice> GCButtonFactory::Create(const Common::Param
    // button is not an axis/stick button
    if (button_id != PAD_STICK_ID) {
-        auto button = std::make_unique<GCButton>(port, button_id, adapter.get());
+        return std::make_unique<GCButton>(port, button_id, adapter.get());
-        return std::move(button);
    }
    // For Axis buttons, used by the binary sticks.
@@ -264,7 +263,8 @@ Common::ParamPackage GCAnalogFactory::GetNextInput() {
            if (analog_x_axis == -1) {
                analog_x_axis = axis;
                controller_number = static_cast<int>(port);
-            } else if (analog_y_axis == -1 && analog_x_axis != axis && controller_number == port) {
+            } else if (analog_y_axis == -1 && analog_x_axis != axis &&
+                       controller_number == static_cast<int>(port)) {
                analog_y_axis = axis;
            }
        }
diff --git a/src/input_common/udp/client.cpp b/src/input_common/udp/client.cpp
index e63c73c4f..6c95a8b42 100644
--- a/src/input_common/udp/client.cpp
+++ b/src/input_common/udp/client.cpp
@@ -9,7 +9,6 @@
 #include <functional>
 #include <thread>
 #include <boost/asio.hpp>
-#include <boost/bind.hpp>
 #include "common/logging/log.h"
 #include "input_common/udp/client.h"
 #include "input_common/udp/protocol.h"
diff --git a/src/tests/core/core_timing.cpp b/src/tests/core/core_timing.cpp
index 244463a47..022b26e6d 100644
--- a/src/tests/core/core_timing.cpp
+++ b/src/tests/core/core_timing.cpp
@@ -25,10 +25,10 @@ std::bitset<CB_IDS.size()> callbacks_ran_flags;
 u64 expected_callback = 0;
 template <unsigned int IDX>
-void HostCallbackTemplate(u64 userdata, std::chrono::nanoseconds ns_late) {
+void HostCallbackTemplate(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
    static_assert(IDX < CB_IDS.size(), "IDX out of range");
    callbacks_ran_flags.set(IDX);
-    REQUIRE(CB_IDS[IDX] == userdata);
+    REQUIRE(CB_IDS[IDX] == user_data);
    REQUIRE(CB_IDS[IDX] == CB_IDS[calls_order[expected_callback]]);
    delays[IDX] = ns_late.count();
    ++expected_callback;
diff --git a/src/video_core/buffer_cache/buffer_cache.h b/src/video_core/buffer_cache/buffer_cache.h
index dd7ce8c99..b5dc68902 100644
--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@@ -524,11 +524,8 @@ private:
    void MarkRegionAsWritten(VAddr start, VAddr end) {
        const u64 page_end = end >> WRITE_PAGE_BIT;
        for (u64 page_start = start >> WRITE_PAGE_BIT; page_start <= page_end; ++page_start) {
-            auto it = written_pages.find(page_start);
+            if (const auto [it, inserted] = written_pages.emplace(page_start, 1); !inserted) {
-            if (it != written_pages.end()) {
+                ++it->second;
-                it->second = it->second + 1;
-            } else {
-                written_pages.insert_or_assign(page_start, 1);
            }
        }
    }
@@ -539,7 +536,7 @@ private:
            auto it = written_pages.find(page_start);
            if (it != written_pages.end()) {
                if (it->second > 1) {
-                    it->second = it->second - 1;
+                    --it->second;
                } else {
                    written_pages.erase(it);
                }
diff --git a/src/video_core/compatible_formats.cpp b/src/video_core/compatible_formats.cpp
index 6c426b035..b06c32c84 100644
--- a/src/video_core/compatible_formats.cpp
+++ b/src/video_core/compatible_formats.cpp
@@ -17,101 +17,94 @@ namespace {
 // https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_texture_view.txt
 constexpr std::array VIEW_CLASS_128_BITS = {
-    PixelFormat::RGBA32F,
+    PixelFormat::R32G32B32A32_FLOAT,
-    PixelFormat::RGBA32UI,
+    PixelFormat::R32G32B32A32_UINT,
+    PixelFormat::R32G32B32A32_SINT,
 };
-// Missing formats:
-// PixelFormat::RGBA32I
 constexpr std::array VIEW_CLASS_96_BITS = {
-    PixelFormat::RGB32F,
+    PixelFormat::R32G32B32_FLOAT,
 };
 // Missing formats:
 // PixelFormat::RGB32UI,
 // PixelFormat::RGB32I,
 constexpr std::array VIEW_CLASS_64_BITS = {
-    PixelFormat::RGBA16F, PixelFormat::RG32F,   PixelFormat::RGBA16UI, PixelFormat::RG32UI,
+    PixelFormat::R32G32_FLOAT,       PixelFormat::R32G32_UINT,
-    PixelFormat::RGBA16U, PixelFormat::RGBA16F, PixelFormat::RGBA16S,
+    PixelFormat::R32G32_SINT,        PixelFormat::R16G16B16A16_FLOAT,
+    PixelFormat::R16G16B16A16_UNORM, PixelFormat::R16G16B16A16_SNORM,
+    PixelFormat::R16G16B16A16_UINT,  PixelFormat::R16G16B16A16_SINT,
 };
-// Missing formats:
-// PixelFormat::RGBA16I
-// PixelFormat::RG32I
 // TODO: How should we handle 48 bits?
 constexpr std::array VIEW_CLASS_32_BITS = {
-    PixelFormat::RG16F,        PixelFormat::R11FG11FB10F, PixelFormat::R32F,
+    PixelFormat::R16G16_FLOAT,      PixelFormat::B10G11R11_FLOAT, PixelFormat::R32_FLOAT,
-    PixelFormat::A2B10G10R10U, PixelFormat::RG16UI,       PixelFormat::R32UI,
+    PixelFormat::A2B10G10R10_UNORM, PixelFormat::R16G16_UINT,     PixelFormat::R32_UINT,
-    PixelFormat::RG16I,        PixelFormat::R32I,         PixelFormat::ABGR8U,
+    PixelFormat::R16G16_SINT,       PixelFormat::R32_SINT,        PixelFormat::A8B8G8R8_UNORM,
-    PixelFormat::RG16,         PixelFormat::ABGR8S,       PixelFormat::RG16S,
+    PixelFormat::R16G16_UNORM,      PixelFormat::A8B8G8R8_SNORM,  PixelFormat::R16G16_SNORM,
-    PixelFormat::RGBA8_SRGB,   PixelFormat::E5B9G9R9F,    PixelFormat::BGRA8,
+    PixelFormat::A8B8G8R8_SRGB,     PixelFormat::E5B9G9R9_FLOAT,  PixelFormat::B8G8R8A8_UNORM,
-    PixelFormat::BGRA8_SRGB,
+    PixelFormat::B8G8R8A8_SRGB,     PixelFormat::A8B8G8R8_UINT,   PixelFormat::A8B8G8R8_SINT,
+    PixelFormat::A2B10G10R10_UINT,
 };
-// Missing formats:
-// PixelFormat::RGBA8UI
-// PixelFormat::RGBA8I
-// PixelFormat::RGB10_A2_UI
 // TODO: How should we handle 24 bits?
 constexpr std::array VIEW_CLASS_16_BITS = {
-    PixelFormat::R16F, PixelFormat::RG8UI, PixelFormat::R16UI, PixelFormat::R16I,
+    PixelFormat::R16_FLOAT,  PixelFormat::R8G8_UINT,  PixelFormat::R16_UINT,
-    PixelFormat::RG8U, PixelFormat::R16U,  PixelFormat::RG8S,  PixelFormat::R16S,
+    PixelFormat::R16_SINT,   PixelFormat::R8G8_UNORM, PixelFormat::R16_UNORM,
+    PixelFormat::R8G8_SNORM, PixelFormat::R16_SNORM,  PixelFormat::R8G8_SINT,
 };
-// Missing formats:
-// PixelFormat::RG8I
 constexpr std::array VIEW_CLASS_8_BITS = {
-    PixelFormat::R8UI,
+    PixelFormat::R8_UINT,
-    PixelFormat::R8U,
+    PixelFormat::R8_UNORM,
+    PixelFormat::R8_SINT,
+    PixelFormat::R8_SNORM,
 };
-// Missing formats:
-// PixelFormat::R8I
-// PixelFormat::R8S
 constexpr std::array VIEW_CLASS_RGTC1_RED = {
-    PixelFormat::DXN1,
+    PixelFormat::BC4_UNORM,
+    PixelFormat::BC4_SNORM,
 };
-// Missing formats:
-// COMPRESSED_SIGNED_RED_RGTC1
 constexpr std::array VIEW_CLASS_RGTC2_RG = {
-    PixelFormat::DXN2UNORM,
+    PixelFormat::BC5_UNORM,
-    PixelFormat::DXN2SNORM,
+    PixelFormat::BC5_SNORM,
 };
 constexpr std::array VIEW_CLASS_BPTC_UNORM = {
-    PixelFormat::BC7U,
+    PixelFormat::BC7_UNORM,
-    PixelFormat::BC7U_SRGB,
+    PixelFormat::BC7_SRGB,
 };
 constexpr std::array VIEW_CLASS_BPTC_FLOAT = {
-    PixelFormat::BC6H_SF16,
+    PixelFormat::BC6H_SFLOAT,
-    PixelFormat::BC6H_UF16,
+    PixelFormat::BC6H_UFLOAT,
 };
 // Compatibility table taken from Table 4.X.1 in:
 // https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_copy_image.txt
 constexpr std::array COPY_CLASS_128_BITS = {
-    PixelFormat::RGBA32UI,   PixelFormat::RGBA32F,   PixelFormat::DXT23,
+    PixelFormat::R32G32B32A32_UINT, PixelFormat::R32G32B32A32_FLOAT, PixelFormat::R32G32B32A32_SINT,
-    PixelFormat::DXT23_SRGB, PixelFormat::DXT45,     PixelFormat::DXT45_SRGB,
+    PixelFormat::BC2_UNORM,         PixelFormat::BC2_SRGB,           PixelFormat::BC3_UNORM,
-    PixelFormat::DXN2SNORM,  PixelFormat::BC7U,      PixelFormat::BC7U_SRGB,
+    PixelFormat::BC3_SRGB,          PixelFormat::BC5_UNORM,          PixelFormat::BC5_SNORM,
-    PixelFormat::BC6H_SF16,  PixelFormat::BC6H_UF16,
+    PixelFormat::BC7_UNORM,         PixelFormat::BC7_SRGB,           PixelFormat::BC6H_SFLOAT,
+    PixelFormat::BC6H_UFLOAT,
 };
 // Missing formats:
 // PixelFormat::RGBA32I
 // COMPRESSED_RG_RGTC2
 constexpr std::array COPY_CLASS_64_BITS = {
-    PixelFormat::RGBA16F, PixelFormat::RG32F,   PixelFormat::RGBA16UI,  PixelFormat::RG32UI,
+    PixelFormat::R16G16B16A16_FLOAT, PixelFormat::R16G16B16A16_UINT,
-    PixelFormat::RGBA16U, PixelFormat::RGBA16S, PixelFormat::DXT1_SRGB, PixelFormat::DXT1,
+    PixelFormat::R16G16B16A16_UNORM, PixelFormat::R16G16B16A16_SNORM,
+    PixelFormat::R16G16B16A16_SINT,  PixelFormat::R32G32_UINT,
+    PixelFormat::R32G32_FLOAT,       PixelFormat::R32G32_SINT,
+    PixelFormat::BC1_RGBA_UNORM,     PixelFormat::BC1_RGBA_SRGB,
 };
 // Missing formats:
-// PixelFormat::RGBA16I
-// PixelFormat::RG32I,
 // COMPRESSED_RGB_S3TC_DXT1_EXT
 // COMPRESSED_SRGB_S3TC_DXT1_EXT
 // COMPRESSED_RGBA_S3TC_DXT1_EXT
diff --git a/src/video_core/compatible_formats.h b/src/video_core/compatible_formats.h
index d1082566d..51766349b 100644
--- a/src/video_core/compatible_formats.h
+++ b/src/video_core/compatible_formats.h
@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#pragma once
 #include <array>
 #include <bitset>
 #include <cstddef>
diff --git a/src/video_core/gpu.h b/src/video_core/gpu.h
index 8d04d9fd9..ebfc7b0c7 100644
--- a/src/video_core/gpu.h
+++ b/src/video_core/gpu.h
@@ -40,53 +40,61 @@ namespace Tegra {
 enum class RenderTargetFormat : u32 {
    NONE = 0x0,
-    RGBA32_FLOAT = 0xC0,
+    R32B32G32A32_FLOAT = 0xC0,
-    RGBA32_UINT = 0xC2,
+    R32G32B32A32_SINT = 0xC1,
-    RGBA16_UNORM = 0xC6,
+    R32G32B32A32_UINT = 0xC2,
-    RGBA16_SNORM = 0xC7,
+    R16G16B16A16_UNORM = 0xC6,
-    RGBA16_UINT = 0xC9,
+    R16G16B16A16_SNORM = 0xC7,
-    RGBA16_FLOAT = 0xCA,
+    R16G16B16A16_SINT = 0xC8,
-    RG32_FLOAT = 0xCB,
+    R16G16B16A16_UINT = 0xC9,
-    RG32_UINT = 0xCD,
+    R16G16B16A16_FLOAT = 0xCA,
-    RGBX16_FLOAT = 0xCE,
+    R32G32_FLOAT = 0xCB,
-    BGRA8_UNORM = 0xCF,
+    R32G32_SINT = 0xCC,
-    BGRA8_SRGB = 0xD0,
+    R32G32_UINT = 0xCD,
-    RGB10_A2_UNORM = 0xD1,
+    R16G16B16X16_FLOAT = 0xCE,
-    RGBA8_UNORM = 0xD5,
+    B8G8R8A8_UNORM = 0xCF,
-    RGBA8_SRGB = 0xD6,
+    B8G8R8A8_SRGB = 0xD0,
-    RGBA8_SNORM = 0xD7,
+    A2B10G10R10_UNORM = 0xD1,
-    RGBA8_UINT = 0xD9,
+    A2B10G10R10_UINT = 0xD2,
-    RG16_UNORM = 0xDA,
+    A8B8G8R8_UNORM = 0xD5,
-    RG16_SNORM = 0xDB,
+    A8B8G8R8_SRGB = 0xD6,
-    RG16_SINT = 0xDC,
+    A8B8G8R8_SNORM = 0xD7,
-    RG16_UINT = 0xDD,
+    A8B8G8R8_SINT = 0xD8,
-    RG16_FLOAT = 0xDE,
+    A8B8G8R8_UINT = 0xD9,
-    R11G11B10_FLOAT = 0xE0,
+    R16G16_UNORM = 0xDA,
+    R16G16_SNORM = 0xDB,
+    R16G16_SINT = 0xDC,
+    R16G16_UINT = 0xDD,
+    R16G16_FLOAT = 0xDE,
+    B10G11R11_FLOAT = 0xE0,
    R32_SINT = 0xE3,
    R32_UINT = 0xE4,
    R32_FLOAT = 0xE5,
-    B5G6R5_UNORM = 0xE8,
+    R5G6B5_UNORM = 0xE8,
-    BGR5A1_UNORM = 0xE9,
+    A1R5G5B5_UNORM = 0xE9,
-    RG8_UNORM = 0xEA,
+    R8G8_UNORM = 0xEA,
-    RG8_SNORM = 0xEB,
+    R8G8_SNORM = 0xEB,
-    RG8_UINT = 0xED,
+    R8G8_SINT = 0xEC,
+    R8G8_UINT = 0xED,
    R16_UNORM = 0xEE,
    R16_SNORM = 0xEF,
    R16_SINT = 0xF0,
    R16_UINT = 0xF1,
    R16_FLOAT = 0xF2,
    R8_UNORM = 0xF3,
+    R8_SNORM = 0xF4,
+    R8_SINT = 0xF5,
    R8_UINT = 0xF6,
 };
 enum class DepthFormat : u32 {
-    Z32_FLOAT = 0xA,
+    D32_FLOAT = 0xA,
-    Z16_UNORM = 0x13,
+    D16_UNORM = 0x13,
-    S8_Z24_UNORM = 0x14,
+    S8_UINT_Z24_UNORM = 0x14,
-    Z24_X8_UNORM = 0x15,
+    D24X8_UNORM = 0x15,
-    Z24_S8_UNORM = 0x16,
+    D24S8_UNORM = 0x16,
-    Z24_C8_UNORM = 0x18,
+    D24C8_UNORM = 0x18,
-    Z32_S8_X24_FLOAT = 0x19,
+    D32_FLOAT_S8X24_UINT = 0x19,
 };
 struct CommandListHeader;
@@ -97,9 +105,9 @@ class DebugContext;
 */
 struct FramebufferConfig {
    enum class PixelFormat : u32 {
-        ABGR8 = 1,
+        A8B8G8R8_UNORM = 1,
-        RGB565 = 4,
+        RGB565_UNORM = 4,
-        BGRA8 = 5,
+        B8G8R8A8_UNORM = 5,
    };
    VAddr address;
@@ -244,7 +252,7 @@ public:
    const Tegra::DmaPusher& DmaPusher() const;
    struct Regs {
-        static constexpr size_t NUM_REGS = 0x100;
+        static constexpr size_t NUM_REGS = 0x40;
        union {
            struct {
@@ -263,7 +271,7 @@ public:
                u32 semaphore_trigger;
                INSERT_UNION_PADDING_WORDS(0xC);
-                // The puser and the puller share the reference counter, the pusher only has read
+                // The pusher and the puller share the reference counter, the pusher only has read
                // access
                u32 reference_count;
                INSERT_UNION_PADDING_WORDS(0x5);
diff --git a/src/video_core/gpu_thread.cpp b/src/video_core/gpu_thread.cpp
index 738c6f0c1..bf761abf2 100644
--- a/src/video_core/gpu_thread.cpp
+++ b/src/video_core/gpu_thread.cpp
@@ -44,9 +44,9 @@ static void RunThread(Core::System& system, VideoCore::RendererBase& renderer,
            dma_pusher.DispatchCalls();
        } else if (const auto data = std::get_if<SwapBuffersCommand>(&next.data)) {
            renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
-        } else if (const auto data = std::get_if<OnCommandListEndCommand>(&next.data)) {
+        } else if (std::holds_alternative<OnCommandListEndCommand>(next.data)) {
            renderer.Rasterizer().ReleaseFences();
-        } else if (const auto data = std::get_if<GPUTickCommand>(&next.data)) {
+        } else if (std::holds_alternative<GPUTickCommand>(next.data)) {
            system.GPU().TickWork();
        } else if (const auto data = std::get_if<FlushRegionCommand>(&next.data)) {
            renderer.Rasterizer().FlushRegion(data->addr, data->size);
diff --git a/src/video_core/macro/macro_jit_x64.cpp b/src/video_core/macro/macro_jit_x64.cpp
index 07292702f..c1b9e4ad9 100644
--- a/src/video_core/macro/macro_jit_x64.cpp
+++ b/src/video_core/macro/macro_jit_x64.cpp
@@ -419,7 +419,6 @@ void Tegra::MacroJITx64Impl::Optimizer_ScanFlags() {
 void MacroJITx64Impl::Compile() {
    MICROPROFILE_SCOPE(MacroJitCompile);
-    bool keep_executing = true;
    labels.fill(Xbyak::Label());
    Common::X64::ABI_PushRegistersAndAdjustStack(*this, Common::X64::ABI_ALL_CALLEE_SAVED, 8);
diff --git a/src/video_core/morton.cpp b/src/video_core/morton.cpp
index 836b25c1d..9da9fb4ff 100644
--- a/src/video_core/morton.cpp
+++ b/src/video_core/morton.cpp
@@ -41,146 +41,168 @@ static void MortonCopy(u32 stride, u32 block_height, u32 height, u32 block_depth
 }
 static constexpr ConversionArray morton_to_linear_fns = {
-    MortonCopy<true, PixelFormat::ABGR8U>,
+    MortonCopy<true, PixelFormat::A8B8G8R8_UNORM>,
-    MortonCopy<true, PixelFormat::ABGR8S>,
+    MortonCopy<true, PixelFormat::A8B8G8R8_SNORM>,
-    MortonCopy<true, PixelFormat::ABGR8UI>,
+    MortonCopy<true, PixelFormat::A8B8G8R8_SINT>,
-    MortonCopy<true, PixelFormat::B5G6R5U>,
+    MortonCopy<true, PixelFormat::A8B8G8R8_UINT>,
-    MortonCopy<true, PixelFormat::A2B10G10R10U>,
+    MortonCopy<true, PixelFormat::R5G6B5_UNORM>,
-    MortonCopy<true, PixelFormat::A1B5G5R5U>,
+    MortonCopy<true, PixelFormat::B5G6R5_UNORM>,
-    MortonCopy<true, PixelFormat::R8U>,
+    MortonCopy<true, PixelFormat::A1R5G5B5_UNORM>,
-    MortonCopy<true, PixelFormat::R8UI>,
+    MortonCopy<true, PixelFormat::A2B10G10R10_UNORM>,
-    MortonCopy<true, PixelFormat::RGBA16F>,
+    MortonCopy<true, PixelFormat::A2B10G10R10_UINT>,
-    MortonCopy<true, PixelFormat::RGBA16U>,
+    MortonCopy<true, PixelFormat::A1B5G5R5_UNORM>,
-    MortonCopy<true, PixelFormat::RGBA16S>,
+    MortonCopy<true, PixelFormat::R8_UNORM>,
-    MortonCopy<true, PixelFormat::RGBA16UI>,
+    MortonCopy<true, PixelFormat::R8_SNORM>,
-    MortonCopy<true, PixelFormat::R11FG11FB10F>,
+    MortonCopy<true, PixelFormat::R8_SINT>,
-    MortonCopy<true, PixelFormat::RGBA32UI>,
+    MortonCopy<true, PixelFormat::R8_UINT>,
-    MortonCopy<true, PixelFormat::DXT1>,
+    MortonCopy<true, PixelFormat::R16G16B16A16_FLOAT>,
-    MortonCopy<true, PixelFormat::DXT23>,
+    MortonCopy<true, PixelFormat::R16G16B16A16_UNORM>,
-    MortonCopy<true, PixelFormat::DXT45>,
+    MortonCopy<true, PixelFormat::R16G16B16A16_SNORM>,
-    MortonCopy<true, PixelFormat::DXN1>,
+    MortonCopy<true, PixelFormat::R16G16B16A16_SINT>,
-    MortonCopy<true, PixelFormat::DXN2UNORM>,
+    MortonCopy<true, PixelFormat::R16G16B16A16_UINT>,
-    MortonCopy<true, PixelFormat::DXN2SNORM>,
+    MortonCopy<true, PixelFormat::B10G11R11_FLOAT>,
-    MortonCopy<true, PixelFormat::BC7U>,
+    MortonCopy<true, PixelFormat::R32G32B32A32_UINT>,
-    MortonCopy<true, PixelFormat::BC6H_UF16>,
+    MortonCopy<true, PixelFormat::BC1_RGBA_UNORM>,
-    MortonCopy<true, PixelFormat::BC6H_SF16>,
+    MortonCopy<true, PixelFormat::BC2_UNORM>,
-    MortonCopy<true, PixelFormat::ASTC_2D_4X4>,
+    MortonCopy<true, PixelFormat::BC3_UNORM>,
-    MortonCopy<true, PixelFormat::BGRA8>,
+    MortonCopy<true, PixelFormat::BC4_UNORM>,
-    MortonCopy<true, PixelFormat::RGBA32F>,
+    MortonCopy<true, PixelFormat::BC4_SNORM>,
-    MortonCopy<true, PixelFormat::RG32F>,
+    MortonCopy<true, PixelFormat::BC5_UNORM>,
-    MortonCopy<true, PixelFormat::R32F>,
+    MortonCopy<true, PixelFormat::BC5_SNORM>,
-    MortonCopy<true, PixelFormat::R16F>,
+    MortonCopy<true, PixelFormat::BC7_UNORM>,
-    MortonCopy<true, PixelFormat::R16U>,
+    MortonCopy<true, PixelFormat::BC6H_UFLOAT>,
-    MortonCopy<true, PixelFormat::R16S>,
+    MortonCopy<true, PixelFormat::BC6H_SFLOAT>,
-    MortonCopy<true, PixelFormat::R16UI>,
+    MortonCopy<true, PixelFormat::ASTC_2D_4X4_UNORM>,
-    MortonCopy<true, PixelFormat::R16I>,
+    MortonCopy<true, PixelFormat::B8G8R8A8_UNORM>,
-    MortonCopy<true, PixelFormat::RG16>,
+    MortonCopy<true, PixelFormat::R32G32B32A32_FLOAT>,
-    MortonCopy<true, PixelFormat::RG16F>,
+    MortonCopy<true, PixelFormat::R32G32B32A32_SINT>,
-    MortonCopy<true, PixelFormat::RG16UI>,
+    MortonCopy<true, PixelFormat::R32G32_FLOAT>,
-    MortonCopy<true, PixelFormat::RG16I>,
+    MortonCopy<true, PixelFormat::R32G32_SINT>,
-    MortonCopy<true, PixelFormat::RG16S>,
+    MortonCopy<true, PixelFormat::R32_FLOAT>,
-    MortonCopy<true, PixelFormat::RGB32F>,
+    MortonCopy<true, PixelFormat::R16_FLOAT>,
-    MortonCopy<true, PixelFormat::RGBA8_SRGB>,
+    MortonCopy<true, PixelFormat::R16_UNORM>,
-    MortonCopy<true, PixelFormat::RG8U>,
+    MortonCopy<true, PixelFormat::R16_SNORM>,
-    MortonCopy<true, PixelFormat::RG8S>,
+    MortonCopy<true, PixelFormat::R16_UINT>,
-    MortonCopy<true, PixelFormat::RG8UI>,
+    MortonCopy<true, PixelFormat::R16_SINT>,
-    MortonCopy<true, PixelFormat::RG32UI>,
+    MortonCopy<true, PixelFormat::R16G16_UNORM>,
-    MortonCopy<true, PixelFormat::RGBX16F>,
+    MortonCopy<true, PixelFormat::R16G16_FLOAT>,
-    MortonCopy<true, PixelFormat::R32UI>,
+    MortonCopy<true, PixelFormat::R16G16_UINT>,
-    MortonCopy<true, PixelFormat::R32I>,
+    MortonCopy<true, PixelFormat::R16G16_SINT>,
-    MortonCopy<true, PixelFormat::ASTC_2D_8X8>,
+    MortonCopy<true, PixelFormat::R16G16_SNORM>,
-    MortonCopy<true, PixelFormat::ASTC_2D_8X5>,
+    MortonCopy<true, PixelFormat::R32G32B32_FLOAT>,
-    MortonCopy<true, PixelFormat::ASTC_2D_5X4>,
+    MortonCopy<true, PixelFormat::A8B8G8R8_SRGB>,
-    MortonCopy<true, PixelFormat::BGRA8_SRGB>,
+    MortonCopy<true, PixelFormat::R8G8_UNORM>,
-    MortonCopy<true, PixelFormat::DXT1_SRGB>,
+    MortonCopy<true, PixelFormat::R8G8_SNORM>,
-    MortonCopy<true, PixelFormat::DXT23_SRGB>,
+    MortonCopy<true, PixelFormat::R8G8_SINT>,
-    MortonCopy<true, PixelFormat::DXT45_SRGB>,
+    MortonCopy<true, PixelFormat::R8G8_UINT>,
-    MortonCopy<true, PixelFormat::BC7U_SRGB>,
+    MortonCopy<true, PixelFormat::R32G32_UINT>,
-    MortonCopy<true, PixelFormat::R4G4B4A4U>,
+    MortonCopy<true, PixelFormat::R16G16B16X16_FLOAT>,
+    MortonCopy<true, PixelFormat::R32_UINT>,
+    MortonCopy<true, PixelFormat::R32_SINT>,
+    MortonCopy<true, PixelFormat::ASTC_2D_8X8_UNORM>,
+    MortonCopy<true, PixelFormat::ASTC_2D_8X5_UNORM>,
+    MortonCopy<true, PixelFormat::ASTC_2D_5X4_UNORM>,
+    MortonCopy<true, PixelFormat::B8G8R8A8_SRGB>,
+    MortonCopy<true, PixelFormat::BC1_RGBA_SRGB>,
+    MortonCopy<true, PixelFormat::BC2_SRGB>,
+    MortonCopy<true, PixelFormat::BC3_SRGB>,
+    MortonCopy<true, PixelFormat::BC7_SRGB>,
+    MortonCopy<true, PixelFormat::A4B4G4R4_UNORM>,
    MortonCopy<true, PixelFormat::ASTC_2D_4X4_SRGB>,
    MortonCopy<true, PixelFormat::ASTC_2D_8X8_SRGB>,
    MortonCopy<true, PixelFormat::ASTC_2D_8X5_SRGB>,
    MortonCopy<true, PixelFormat::ASTC_2D_5X4_SRGB>,
-    MortonCopy<true, PixelFormat::ASTC_2D_5X5>,
+    MortonCopy<true, PixelFormat::ASTC_2D_5X5_UNORM>,
    MortonCopy<true, PixelFormat::ASTC_2D_5X5_SRGB>,
-    MortonCopy<true, PixelFormat::ASTC_2D_10X8>,
+    MortonCopy<true, PixelFormat::ASTC_2D_10X8_UNORM>,
    MortonCopy<true, PixelFormat::ASTC_2D_10X8_SRGB>,
-    MortonCopy<true, PixelFormat::ASTC_2D_6X6>,
+    MortonCopy<true, PixelFormat::ASTC_2D_6X6_UNORM>,
    MortonCopy<true, PixelFormat::ASTC_2D_6X6_SRGB>,
-    MortonCopy<true, PixelFormat::ASTC_2D_10X10>,
+    MortonCopy<true, PixelFormat::ASTC_2D_10X10_UNORM>,
    MortonCopy<true, PixelFormat::ASTC_2D_10X10_SRGB>,
-    MortonCopy<true, PixelFormat::ASTC_2D_12X12>,
+    MortonCopy<true, PixelFormat::ASTC_2D_12X12_UNORM>,
    MortonCopy<true, PixelFormat::ASTC_2D_12X12_SRGB>,
-    MortonCopy<true, PixelFormat::ASTC_2D_8X6>,
+    MortonCopy<true, PixelFormat::ASTC_2D_8X6_UNORM>,
    MortonCopy<true, PixelFormat::ASTC_2D_8X6_SRGB>,
-    MortonCopy<true, PixelFormat::ASTC_2D_6X5>,
+    MortonCopy<true, PixelFormat::ASTC_2D_6X5_UNORM>,
    MortonCopy<true, PixelFormat::ASTC_2D_6X5_SRGB>,
-    MortonCopy<true, PixelFormat::E5B9G9R9F>,
+    MortonCopy<true, PixelFormat::E5B9G9R9_FLOAT>,
-    MortonCopy<true, PixelFormat::Z32F>,
+    MortonCopy<true, PixelFormat::D32_FLOAT>,
-    MortonCopy<true, PixelFormat::Z16>,
+    MortonCopy<true, PixelFormat::D16_UNORM>,
-    MortonCopy<true, PixelFormat::Z24S8>,
+    MortonCopy<true, PixelFormat::D24_UNORM_S8_UINT>,
-    MortonCopy<true, PixelFormat::S8Z24>,
+    MortonCopy<true, PixelFormat::S8_UINT_D24_UNORM>,
-    MortonCopy<true, PixelFormat::Z32FS8>,
+    MortonCopy<true, PixelFormat::D32_FLOAT_S8_UINT>,
 };
 static constexpr ConversionArray linear_to_morton_fns = {
-    MortonCopy<false, PixelFormat::ABGR8U>,
+    MortonCopy<false, PixelFormat::A8B8G8R8_UNORM>,
-    MortonCopy<false, PixelFormat::ABGR8S>,
+    MortonCopy<false, PixelFormat::A8B8G8R8_SNORM>,
-    MortonCopy<false, PixelFormat::ABGR8UI>,
+    MortonCopy<false, PixelFormat::A8B8G8R8_SINT>,
-    MortonCopy<false, PixelFormat::B5G6R5U>,
+    MortonCopy<false, PixelFormat::A8B8G8R8_UINT>,
-    MortonCopy<false, PixelFormat::A2B10G10R10U>,
+    MortonCopy<false, PixelFormat::R5G6B5_UNORM>,
-    MortonCopy<false, PixelFormat::A1B5G5R5U>,
+    MortonCopy<false, PixelFormat::B5G6R5_UNORM>,
-    MortonCopy<false, PixelFormat::R8U>,
+    MortonCopy<false, PixelFormat::A1R5G5B5_UNORM>,
-    MortonCopy<false, PixelFormat::R8UI>,
+    MortonCopy<false, PixelFormat::A2B10G10R10_UNORM>,
-    MortonCopy<false, PixelFormat::RGBA16F>,
+    MortonCopy<false, PixelFormat::A2B10G10R10_UINT>,
-    MortonCopy<false, PixelFormat::RGBA16S>,
+    MortonCopy<false, PixelFormat::A1B5G5R5_UNORM>,
-    MortonCopy<false, PixelFormat::RGBA16U>,
+    MortonCopy<false, PixelFormat::R8_UNORM>,
-    MortonCopy<false, PixelFormat::RGBA16UI>,
+    MortonCopy<false, PixelFormat::R8_SNORM>,
-    MortonCopy<false, PixelFormat::R11FG11FB10F>,
+    MortonCopy<false, PixelFormat::R8_SINT>,
-    MortonCopy<false, PixelFormat::RGBA32UI>,
+    MortonCopy<false, PixelFormat::R8_UINT>,
-    MortonCopy<false, PixelFormat::DXT1>,
+    MortonCopy<false, PixelFormat::R16G16B16A16_FLOAT>,
-    MortonCopy<false, PixelFormat::DXT23>,
+    MortonCopy<false, PixelFormat::R16G16B16A16_SNORM>,
-    MortonCopy<false, PixelFormat::DXT45>,
+    MortonCopy<false, PixelFormat::R16G16B16A16_SINT>,
-    MortonCopy<false, PixelFormat::DXN1>,
+    MortonCopy<false, PixelFormat::R16G16B16A16_UNORM>,
-    MortonCopy<false, PixelFormat::DXN2UNORM>,
+    MortonCopy<false, PixelFormat::R16G16B16A16_UINT>,
-    MortonCopy<false, PixelFormat::DXN2SNORM>,
+    MortonCopy<false, PixelFormat::B10G11R11_FLOAT>,
-    MortonCopy<false, PixelFormat::BC7U>,
+    MortonCopy<false, PixelFormat::R32G32B32A32_UINT>,
-    MortonCopy<false, PixelFormat::BC6H_UF16>,
+    MortonCopy<false, PixelFormat::BC1_RGBA_UNORM>,
-    MortonCopy<false, PixelFormat::BC6H_SF16>,
+    MortonCopy<false, PixelFormat::BC2_UNORM>,
+    MortonCopy<false, PixelFormat::BC3_UNORM>,
+    MortonCopy<false, PixelFormat::BC4_UNORM>,
+    MortonCopy<false, PixelFormat::BC4_SNORM>,
+    MortonCopy<false, PixelFormat::BC5_UNORM>,
+    MortonCopy<false, PixelFormat::BC5_SNORM>,
+    MortonCopy<false, PixelFormat::BC7_UNORM>,
+    MortonCopy<false, PixelFormat::BC6H_UFLOAT>,
+    MortonCopy<false, PixelFormat::BC6H_SFLOAT>,
    // TODO(Subv): Swizzling ASTC formats are not supported
    nullptr,
-    MortonCopy<false, PixelFormat::BGRA8>,
+    MortonCopy<false, PixelFormat::B8G8R8A8_UNORM>,
-    MortonCopy<false, PixelFormat::RGBA32F>,
+    MortonCopy<false, PixelFormat::R32G32B32A32_FLOAT>,
-    MortonCopy<false, PixelFormat::RG32F>,
+    MortonCopy<false, PixelFormat::R32G32B32A32_SINT>,
-    MortonCopy<false, PixelFormat::R32F>,
+    MortonCopy<false, PixelFormat::R32G32_FLOAT>,
-    MortonCopy<false, PixelFormat::R16F>,
+    MortonCopy<false, PixelFormat::R32G32_SINT>,
-    MortonCopy<false, PixelFormat::R16U>,
+    MortonCopy<false, PixelFormat::R32_FLOAT>,
-    MortonCopy<false, PixelFormat::R16S>,
+    MortonCopy<false, PixelFormat::R16_FLOAT>,
-    MortonCopy<false, PixelFormat::R16UI>,
+    MortonCopy<false, PixelFormat::R16_UNORM>,
-    MortonCopy<false, PixelFormat::R16I>,
+    MortonCopy<false, PixelFormat::R16_SNORM>,
-    MortonCopy<false, PixelFormat::RG16>,
+    MortonCopy<false, PixelFormat::R16_UINT>,
-    MortonCopy<false, PixelFormat::RG16F>,
+    MortonCopy<false, PixelFormat::R16_SINT>,
-    MortonCopy<false, PixelFormat::RG16UI>,
+    MortonCopy<false, PixelFormat::R16G16_UNORM>,
-    MortonCopy<false, PixelFormat::RG16I>,
+    MortonCopy<false, PixelFormat::R16G16_FLOAT>,
-    MortonCopy<false, PixelFormat::RG16S>,
+    MortonCopy<false, PixelFormat::R16G16_UINT>,
-    MortonCopy<false, PixelFormat::RGB32F>,
+    MortonCopy<false, PixelFormat::R16G16_SINT>,
-    MortonCopy<false, PixelFormat::RGBA8_SRGB>,
+    MortonCopy<false, PixelFormat::R16G16_SNORM>,
-    MortonCopy<false, PixelFormat::RG8U>,
+    MortonCopy<false, PixelFormat::R32G32B32_FLOAT>,
-    MortonCopy<false, PixelFormat::RG8S>,
+    MortonCopy<false, PixelFormat::A8B8G8R8_SRGB>,
-    MortonCopy<false, PixelFormat::RG8UI>,
+    MortonCopy<false, PixelFormat::R8G8_UNORM>,
-    MortonCopy<false, PixelFormat::RG32UI>,
+    MortonCopy<false, PixelFormat::R8G8_SNORM>,
-    MortonCopy<false, PixelFormat::RGBX16F>,
+    MortonCopy<false, PixelFormat::R8G8_SINT>,
-    MortonCopy<false, PixelFormat::R32UI>,
+    MortonCopy<false, PixelFormat::R8G8_UINT>,
-    MortonCopy<false, PixelFormat::R32I>,
+    MortonCopy<false, PixelFormat::R32G32_UINT>,
+    MortonCopy<false, PixelFormat::R16G16B16X16_FLOAT>,
+    MortonCopy<false, PixelFormat::R32_UINT>,
+    MortonCopy<false, PixelFormat::R32_SINT>,
    nullptr,
    nullptr,
    nullptr,
-    MortonCopy<false, PixelFormat::BGRA8_SRGB>,
+    MortonCopy<false, PixelFormat::B8G8R8A8_SRGB>,
-    MortonCopy<false, PixelFormat::DXT1_SRGB>,
+    MortonCopy<false, PixelFormat::BC1_RGBA_SRGB>,
-    MortonCopy<false, PixelFormat::DXT23_SRGB>,
+    MortonCopy<false, PixelFormat::BC2_SRGB>,
-    MortonCopy<false, PixelFormat::DXT45_SRGB>,
+    MortonCopy<false, PixelFormat::BC3_SRGB>,
-    MortonCopy<false, PixelFormat::BC7U_SRGB>,
+    MortonCopy<false, PixelFormat::BC7_SRGB>,
-    MortonCopy<false, PixelFormat::R4G4B4A4U>,
+    MortonCopy<false, PixelFormat::A4B4G4R4_UNORM>,
    nullptr,
    nullptr,
    nullptr,
@@ -199,12 +221,12 @@ static constexpr ConversionArray linear_to_morton_fns = {
    nullptr,
    nullptr,
    nullptr,
-    MortonCopy<false, PixelFormat::E5B9G9R9F>,
+    MortonCopy<false, PixelFormat::E5B9G9R9_FLOAT>,
-    MortonCopy<false, PixelFormat::Z32F>,
+    MortonCopy<false, PixelFormat::D32_FLOAT>,
-    MortonCopy<false, PixelFormat::Z16>,
+    MortonCopy<false, PixelFormat::D16_UNORM>,
-    MortonCopy<false, PixelFormat::Z24S8>,
+    MortonCopy<false, PixelFormat::D24_UNORM_S8_UINT>,
-    MortonCopy<false, PixelFormat::S8Z24>,
+    MortonCopy<false, PixelFormat::S8_UINT_D24_UNORM>,
-    MortonCopy<false, PixelFormat::Z32FS8>,
+    MortonCopy<false, PixelFormat::D32_FLOAT_S8_UINT>,
 };
 static MortonCopyFn GetSwizzleFunction(MortonSwizzleMode mode, Surface::PixelFormat format) {
diff --git a/src/video_core/renderer_opengl/gl_arb_decompiler.cpp b/src/video_core/renderer_opengl/gl_arb_decompiler.cpp
index 4489abf61..b7e9ed2e9 100644
--- a/src/video_core/renderer_opengl/gl_arb_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_arb_decompiler.cpp
@@ -913,11 +913,19 @@ void ARBDecompiler::DeclareCompute() {
    const ComputeInfo& info = registry.GetComputeInfo();
    AddLine("GROUP_SIZE {} {} {};", info.workgroup_size[0], info.workgroup_size[1],
            info.workgroup_size[2]);
-    if (info.shared_memory_size_in_words > 0) {
+    if (info.shared_memory_size_in_words == 0) {
-        const u32 size_in_bytes = info.shared_memory_size_in_words * 4;
+        return;
-        AddLine("SHARED_MEMORY {};", size_in_bytes);
+    }
-        AddLine("SHARED shared_mem[] = {{program.sharedmem}};");
+    const u32 limit = device.GetMaxComputeSharedMemorySize();
+    u32 size_in_bytes = info.shared_memory_size_in_words * 4;
+    if (size_in_bytes > limit) {
+        LOG_ERROR(Render_OpenGL, "Shared memory size {} is clamped to host's limit {}",
+                  size_in_bytes, limit);
+        size_in_bytes = limit;
    }
+    AddLine("SHARED_MEMORY {};", size_in_bytes);
+    AddLine("SHARED shared_mem[] = {{program.sharedmem}};");
 }
 void ARBDecompiler::DeclareInputAttributes() {
@@ -1283,13 +1291,6 @@ std::string ARBDecompiler::Visit(const Node& node) {
            return "{0, 0, 0, 0}.x";
        }
-        const auto buffer_index = [this, &abuf]() -> std::string {
-            if (stage != ShaderType::Geometry) {
-                return "";
-            }
-            return fmt::format("[{}]", Visit(abuf->GetBuffer()));
-        };
        const Attribute::Index index = abuf->GetIndex();
        const u32 element = abuf->GetElement();
        const char swizzle = Swizzle(element);
@@ -1395,7 +1396,7 @@ std::string ARBDecompiler::Visit(const Node& node) {
        return {};
    }
-    if (const auto cmt = std::get_if<CommentNode>(&*node)) {
+    if ([[maybe_unused]] const auto cmt = std::get_if<CommentNode>(&*node)) {
        // Uncommenting this will generate invalid code. GLASM lacks comments.
        // AddLine("// {}", cmt->GetText());
        return {};
@@ -1703,7 +1704,7 @@ std::string ARBDecompiler::HCastFloat(Operation operation) {
 }
 std::string ARBDecompiler::HUnpack(Operation operation) {
-    const std::string operand = Visit(operation[0]);
+    std::string operand = Visit(operation[0]);
    switch (std::get<Tegra::Shader::HalfType>(operation.GetMeta())) {
    case Tegra::Shader::HalfType::H0_H1:
        return operand;
@@ -2053,7 +2054,7 @@ std::string ARBDecompiler::InvocationId(Operation) {
 std::string ARBDecompiler::YNegate(Operation) {
    LOG_WARNING(Render_OpenGL, "(STUBBED)");
-    const std::string temporary = AllocTemporary();
+    std::string temporary = AllocTemporary();
    AddLine("MOV.F {}, 1;", temporary);
    return temporary;
 }
@@ -2076,10 +2077,6 @@ std::string ARBDecompiler::ShuffleIndexed(Operation operation) {
 }
 std::string ARBDecompiler::Barrier(Operation) {
-    if (!ir.IsDecompiled()) {
-        LOG_ERROR(Render_OpenGL, "BAR used but shader is not decompiled");
-        return {};
-    }
    AddLine("BAR;");
    return {};
 }
diff --git a/src/video_core/renderer_opengl/gl_device.cpp b/src/video_core/renderer_opengl/gl_device.cpp
index 630acb73b..e7d95149f 100644
--- a/src/video_core/renderer_opengl/gl_device.cpp
+++ b/src/video_core/renderer_opengl/gl_device.cpp
@@ -212,6 +212,7 @@ Device::Device()
    shader_storage_alignment = GetInteger<std::size_t>(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT);
    max_vertex_attributes = GetInteger<u32>(GL_MAX_VERTEX_ATTRIBS);
    max_varyings = GetInteger<u32>(GL_MAX_VARYING_VECTORS);
+    max_compute_shared_memory_size = GetInteger<u32>(GL_MAX_COMPUTE_SHARED_MEMORY_SIZE);
    has_warp_intrinsics = GLAD_GL_NV_gpu_shader5 && GLAD_GL_NV_shader_thread_group &&
                          GLAD_GL_NV_shader_thread_shuffle;
    has_shader_ballot = GLAD_GL_ARB_shader_ballot;
@@ -250,6 +251,7 @@ Device::Device(std::nullptr_t) {
    shader_storage_alignment = 4;
    max_vertex_attributes = 16;
    max_varyings = 15;
+    max_compute_shared_memory_size = 0x10000;
    has_warp_intrinsics = true;
    has_shader_ballot = true;
    has_vertex_viewport_layer = true;
diff --git a/src/video_core/renderer_opengl/gl_device.h b/src/video_core/renderer_opengl/gl_device.h
index 94d38d7d1..8a4b6b9fc 100644
--- a/src/video_core/renderer_opengl/gl_device.h
+++ b/src/video_core/renderer_opengl/gl_device.h
@@ -52,6 +52,10 @@ public:
        return max_varyings;
    }
+    u32 GetMaxComputeSharedMemorySize() const {
+        return max_compute_shared_memory_size;
+    }
    bool HasWarpIntrinsics() const {
        return has_warp_intrinsics;
    }
@@ -118,6 +122,7 @@ private:
    std::size_t shader_storage_alignment{};
    u32 max_vertex_attributes{};
    u32 max_varyings{};
+    u32 max_compute_shared_memory_size{};
    bool has_warp_intrinsics{};
    bool has_shader_ballot{};
    bool has_vertex_viewport_layer{};
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.cpp b/src/video_core/renderer_opengl/gl_shader_cache.cpp
index f469ed656..be71e1733 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -126,7 +126,7 @@ std::shared_ptr<Registry> MakeRegistry(const ShaderDiskCacheEntry& entry) {
    const VideoCore::GuestDriverProfile guest_profile{entry.texture_handler_size};
    const VideoCommon::Shader::SerializedRegistryInfo info{guest_profile, entry.bound_buffer,
                                                           entry.graphics_info, entry.compute_info};
-    const auto registry = std::make_shared<Registry>(entry.type, info);
+    auto registry = std::make_shared<Registry>(entry.type, info);
    for (const auto& [address, value] : entry.keys) {
        const auto [buffer, offset] = address;
        registry->InsertKey(buffer, offset, value);
@@ -237,7 +237,6 @@ std::unique_ptr<Shader> Shader::CreateStageFromMemory(
    const ShaderParameters& params, Maxwell::ShaderProgram program_type, ProgramCode code,
    ProgramCode code_b, VideoCommon::Shader::AsyncShaders& async_shaders, VAddr cpu_addr) {
    const auto shader_type = GetShaderType(program_type);
-    const std::size_t size_in_bytes = code.size() * sizeof(u64);
    auto& gpu = params.system.GPU();
    gpu.ShaderNotify().MarkSharderBuilding();
@@ -287,8 +286,6 @@ std::unique_ptr<Shader> Shader::CreateStageFromMemory(
 std::unique_ptr<Shader> Shader::CreateKernelFromMemory(const ShaderParameters& params,
                                                       ProgramCode code) {
-    const std::size_t size_in_bytes = code.size() * sizeof(u64);
    auto& gpu = params.system.GPU();
    gpu.ShaderNotify().MarkSharderBuilding();
diff --git a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
index 2c49aeaac..3f75fcd2b 100644
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
@@ -602,8 +602,15 @@ private:
            return;
        }
        const auto& info = registry.GetComputeInfo();
-        if (const u32 size = info.shared_memory_size_in_words; size > 0) {
+        if (u32 size = info.shared_memory_size_in_words * 4; size > 0) {
-            code.AddLine("shared uint smem[{}];", size);
+            const u32 limit = device.GetMaxComputeSharedMemorySize();
+            if (size > limit) {
+                LOG_ERROR(Render_OpenGL, "Shared memory size {} is clamped to host's limit {}",
+                          size, limit);
+                size = limit;
+            }
+            code.AddLine("shared uint smem[{}];", size / 4);
            code.AddNewLine();
        }
        code.AddLine("layout (local_size_x = {}, local_size_y = {}, local_size_z = {}) in;",
@@ -1912,7 +1919,7 @@ private:
    Expression Comparison(Operation operation) {
        static_assert(!unordered || type == Type::Float);
-        const Expression expr = GenerateBinaryInfix(operation, op, Type::Bool, type, type);
+        Expression expr = GenerateBinaryInfix(operation, op, Type::Bool, type, type);
        if constexpr (op.compare("!=") == 0 && type == Type::Float && !unordered) {
            // GLSL's operator!=(float, float) doesn't seem be ordered. This happens on both AMD's
@@ -1952,10 +1959,6 @@ private:
        return {fmt::format("({} != 0)", carry), Type::Bool};
    }
-    Expression LogicalFIsNan(Operation operation) {
-        return GenerateUnary(operation, "isnan", Type::Bool, Type::Float);
-    }
    Expression LogicalAssign(Operation operation) {
        const Node& dest = operation[0];
        const Node& src = operation[1];
@@ -2771,15 +2774,6 @@ private:
        return std::min<u32>(device.GetMaxVaryings(), Maxwell::NumVaryings);
    }
-    bool IsRenderTargetEnabled(u32 render_target) const {
-        for (u32 component = 0; component < 4; ++component) {
-            if (header.ps.IsColorComponentOutputEnabled(render_target, component)) {
-                return true;
-            }
-        }
-        return false;
-    }
    const Device& device;
    const ShaderIR& ir;
    const Registry& registry;
diff --git a/src/video_core/renderer_opengl/gl_texture_cache.cpp b/src/video_core/renderer_opengl/gl_texture_cache.cpp
index 61505879b..0a7bc9e2b 100644
--- a/src/video_core/renderer_opengl/gl_texture_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_texture_cache.cpp
@@ -41,91 +41,103 @@ struct FormatTuple {
 };
 constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex_format_tuples = {{
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},             // ABGR8U
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},                 // A8B8G8R8_UNORM
-    {GL_RGBA8_SNORM, GL_RGBA, GL_BYTE},                           // ABGR8S
+    {GL_RGBA8_SNORM, GL_RGBA, GL_BYTE},                               // A8B8G8R8_SNORM
-    {GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE},              // ABGR8UI
+    {GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE},                            // A8B8G8R8_SINT
-    {GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV},             // B5G6R5U
+    {GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE},                  // A8B8G8R8_UINT
-    {GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV},       // A2B10G10R10U
+    {GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5},                     // R5G6B5_UNORM
-    {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV},         // A1B5G5R5U
+    {GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV},                 // B5G6R5_UNORM
-    {GL_R8, GL_RED, GL_UNSIGNED_BYTE},                            // R8U
+    {GL_RGB5_A1, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV},             // A1R5G5B5_UNORM
-    {GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE},                  // R8UI
+    {GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV},           // A2B10G10R10_UNORM
-    {GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT},                         // RGBA16F
+    {GL_RGB10_A2UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT_2_10_10_10_REV}, // A2B10G10R10_UINT
-    {GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT},                      // RGBA16U
+    {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV},             // A1B5G5R5_UNORM
-    {GL_RGBA16_SNORM, GL_RGBA, GL_SHORT},                         // RGBA16S
+    {GL_R8, GL_RED, GL_UNSIGNED_BYTE},                                // R8_UNORM
-    {GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT},            // RGBA16UI
+    {GL_R8_SNORM, GL_RED, GL_BYTE},                                   // R8_SNORM
-    {GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV}, // R11FG11FB10F
+    {GL_R8I, GL_RED_INTEGER, GL_BYTE},                                // R8_SINT
-    {GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT},              // RGBA32UI
+    {GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE},                      // R8_UINT
-    {GL_COMPRESSED_RGBA_S3TC_DXT1_EXT},                           // DXT1
+    {GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT},                             // R16G16B16A16_FLOAT
-    {GL_COMPRESSED_RGBA_S3TC_DXT3_EXT},                           // DXT23
+    {GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT},                          // R16G16B16A16_UNORM
-    {GL_COMPRESSED_RGBA_S3TC_DXT5_EXT},                           // DXT45
+    {GL_RGBA16_SNORM, GL_RGBA, GL_SHORT},                             // R16G16B16A16_SNORM
-    {GL_COMPRESSED_RED_RGTC1},                                    // DXN1
+    {GL_RGBA16I, GL_RGBA_INTEGER, GL_SHORT},                          // R16G16B16A16_SINT
-    {GL_COMPRESSED_RG_RGTC2},                                     // DXN2UNORM
+    {GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT},                // R16G16B16A16_UINT
-    {GL_COMPRESSED_SIGNED_RG_RGTC2},                              // DXN2SNORM
+    {GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV},     // B10G11R11_FLOAT
-    {GL_COMPRESSED_RGBA_BPTC_UNORM},                              // BC7U
+    {GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT},                  // R32G32B32A32_UINT
-    {GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT},                      // BC6H_UF16
+    {GL_COMPRESSED_RGBA_S3TC_DXT1_EXT},                               // BC1_RGBA_UNORM
-    {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT},                        // BC6H_SF16
+    {GL_COMPRESSED_RGBA_S3TC_DXT3_EXT},                               // BC2_UNORM
-    {GL_COMPRESSED_RGBA_ASTC_4x4_KHR},                            // ASTC_2D_4X4
+    {GL_COMPRESSED_RGBA_S3TC_DXT5_EXT},                               // BC3_UNORM
-    {GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE},                        // BGRA8
+    {GL_COMPRESSED_RED_RGTC1},                                        // BC4_UNORM
-    {GL_RGBA32F, GL_RGBA, GL_FLOAT},                              // RGBA32F
+    {GL_COMPRESSED_SIGNED_RED_RGTC1},                                 // BC4_SNORM
-    {GL_RG32F, GL_RG, GL_FLOAT},                                  // RG32F
+    {GL_COMPRESSED_RG_RGTC2},                                         // BC5_UNORM
-    {GL_R32F, GL_RED, GL_FLOAT},                                  // R32F
+    {GL_COMPRESSED_SIGNED_RG_RGTC2},                                  // BC5_SNORM
-    {GL_R16F, GL_RED, GL_HALF_FLOAT},                             // R16F
+    {GL_COMPRESSED_RGBA_BPTC_UNORM},                                  // BC7_UNORM
-    {GL_R16, GL_RED, GL_UNSIGNED_SHORT},                          // R16U
+    {GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT},                          // BC6H_UFLOAT
-    {GL_R16_SNORM, GL_RED, GL_SHORT},                             // R16S
+    {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT},                            // BC6H_SFLOAT
-    {GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT},                // R16UI
+    {GL_COMPRESSED_RGBA_ASTC_4x4_KHR},                                // ASTC_2D_4X4_UNORM
-    {GL_R16I, GL_RED_INTEGER, GL_SHORT},                          // R16I
+    {GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE},                            // B8G8R8A8_UNORM
-    {GL_RG16, GL_RG, GL_UNSIGNED_SHORT},                          // RG16
+    {GL_RGBA32F, GL_RGBA, GL_FLOAT},                                  // R32G32B32A32_FLOAT
-    {GL_RG16F, GL_RG, GL_HALF_FLOAT},                             // RG16F
+    {GL_RGBA32I, GL_RGBA_INTEGER, GL_INT},                            // R32G32B32A32_SINT
-    {GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT},                // RG16UI
+    {GL_RG32F, GL_RG, GL_FLOAT},                                      // R32G32_FLOAT
-    {GL_RG16I, GL_RG_INTEGER, GL_SHORT},                          // RG16I
+    {GL_RG32I, GL_RG_INTEGER, GL_INT},                                // R32G32_SINT
-    {GL_RG16_SNORM, GL_RG, GL_SHORT},                             // RG16S
+    {GL_R32F, GL_RED, GL_FLOAT},                                      // R32_FLOAT
-    {GL_RGB32F, GL_RGB, GL_FLOAT},                                // RGB32F
+    {GL_R16F, GL_RED, GL_HALF_FLOAT},                                 // R16_FLOAT
-    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},      // RGBA8_SRGB
+    {GL_R16, GL_RED, GL_UNSIGNED_SHORT},                              // R16_UNORM
-    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE},                            // RG8U
+    {GL_R16_SNORM, GL_RED, GL_SHORT},                                 // R16_SNORM
-    {GL_RG8_SNORM, GL_RG, GL_BYTE},                               // RG8S
+    {GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT},                    // R16_UINT
-    {GL_RG8UI, GL_RG_INTEGER, GL_UNSIGNED_INT},                   // RG8UI
+    {GL_R16I, GL_RED_INTEGER, GL_SHORT},                              // R16_SINT
-    {GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT},                  // RG32UI
+    {GL_RG16, GL_RG, GL_UNSIGNED_SHORT},                              // R16G16_UNORM
-    {GL_RGB16F, GL_RGBA, GL_HALF_FLOAT},                          // RGBX16F
+    {GL_RG16F, GL_RG, GL_HALF_FLOAT},                                 // R16G16_FLOAT
-    {GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT},                  // R32UI
+    {GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT},                    // R16G16_UINT
-    {GL_R32I, GL_RED_INTEGER, GL_INT},                            // R32I
+    {GL_RG16I, GL_RG_INTEGER, GL_SHORT},                              // R16G16_SINT
-    {GL_COMPRESSED_RGBA_ASTC_8x8_KHR},                            // ASTC_2D_8X8
+    {GL_RG16_SNORM, GL_RG, GL_SHORT},                                 // R16G16_SNORM
-    {GL_COMPRESSED_RGBA_ASTC_8x5_KHR},                            // ASTC_2D_8X5
+    {GL_RGB32F, GL_RGB, GL_FLOAT},                                    // R32G32B32_FLOAT
-    {GL_COMPRESSED_RGBA_ASTC_5x4_KHR},                            // ASTC_2D_5X4
+    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},          // A8B8G8R8_SRGB
-    {GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_BYTE},                 // BGRA8
+    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE},                                // R8G8_UNORM
+    {GL_RG8_SNORM, GL_RG, GL_BYTE},                                   // R8G8_SNORM
+    {GL_RG8I, GL_RG_INTEGER, GL_BYTE},                                // R8G8_SINT
+    {GL_RG8UI, GL_RG_INTEGER, GL_UNSIGNED_BYTE},                      // R8G8_UINT
+    {GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT},                      // R32G32_UINT
+    {GL_RGB16F, GL_RGBA, GL_HALF_FLOAT},                              // R16G16B16X16_FLOAT
+    {GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT},                      // R32_UINT
+    {GL_R32I, GL_RED_INTEGER, GL_INT},                                // R32_SINT
+    {GL_COMPRESSED_RGBA_ASTC_8x8_KHR},                                // ASTC_2D_8X8_UNORM
+    {GL_COMPRESSED_RGBA_ASTC_8x5_KHR},                                // ASTC_2D_8X5_UNORM
+    {GL_COMPRESSED_RGBA_ASTC_5x4_KHR},                                // ASTC_2D_5X4_UNORM
+    {GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_BYTE},                     // B8G8R8A8_UNORM
    // Compressed sRGB formats
-    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT},           // DXT1_SRGB
+    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT},           // BC1_RGBA_SRGB
-    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT},           // DXT23_SRGB
+    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT},           // BC2_SRGB
-    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT},           // DXT45_SRGB
+    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT},           // BC3_SRGB
-    {GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM},              // BC7U_SRGB
+    {GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM},              // BC7_SRGB
-    {GL_RGBA4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4_REV}, // R4G4B4A4U
+    {GL_RGBA4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4_REV}, // A4B4G4R4_UNORM
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR},          // ASTC_2D_4X4_SRGB
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR},          // ASTC_2D_8X8_SRGB
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR},          // ASTC_2D_8X5_SRGB
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR},          // ASTC_2D_5X4_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_5x5_KHR},                  // ASTC_2D_5X5
+    {GL_COMPRESSED_RGBA_ASTC_5x5_KHR},                  // ASTC_2D_5X5_UNORM
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR},          // ASTC_2D_5X5_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_10x8_KHR},                 // ASTC_2D_10X8
+    {GL_COMPRESSED_RGBA_ASTC_10x8_KHR},                 // ASTC_2D_10X8_UNORM
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR},         // ASTC_2D_10X8_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_6x6_KHR},                  // ASTC_2D_6X6
+    {GL_COMPRESSED_RGBA_ASTC_6x6_KHR},                  // ASTC_2D_6X6_UNORM
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR},          // ASTC_2D_6X6_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_10x10_KHR},                // ASTC_2D_10X10
+    {GL_COMPRESSED_RGBA_ASTC_10x10_KHR},                // ASTC_2D_10X10_UNORM
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR},        // ASTC_2D_10X10_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_12x12_KHR},                // ASTC_2D_12X12
+    {GL_COMPRESSED_RGBA_ASTC_12x12_KHR},                // ASTC_2D_12X12_UNORM
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR},        // ASTC_2D_12X12_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_8x6_KHR},                  // ASTC_2D_8X6
+    {GL_COMPRESSED_RGBA_ASTC_8x6_KHR},                  // ASTC_2D_8X6_UNORM
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR},          // ASTC_2D_8X6_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_6x5_KHR},                  // ASTC_2D_6X5
+    {GL_COMPRESSED_RGBA_ASTC_6x5_KHR},                  // ASTC_2D_6X5_UNORM
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR},          // ASTC_2D_6X5_SRGB
-    {GL_RGB9_E5, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV},  // E5B9G9R9F
+    {GL_RGB9_E5, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV},  // E5B9G9R9_FLOAT
    // Depth formats
-    {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT},         // Z32F
+    {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT},         // D32_FLOAT
-    {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT}, // Z16
+    {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT}, // D16_UNORM
    // DepthStencil formats
-    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8},               // Z24S8
+    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8}, // D24_UNORM_S8_UINT
-    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8},               // S8Z24
+    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8}, // S8_UINT_D24_UNORM
-    {GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV}, // Z32FS8
+    {GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL,
+     GL_FLOAT_32_UNSIGNED_INT_24_8_REV}, // D32_FLOAT_S8_UINT
 }};
 const FormatTuple& GetFormatTuple(PixelFormat pixel_format) {
@@ -178,10 +190,10 @@ GLint GetSwizzleSource(SwizzleSource source) {
 GLenum GetComponent(PixelFormat format, bool is_first) {
    switch (format) {
-    case PixelFormat::Z24S8:
+    case PixelFormat::D24_UNORM_S8_UINT:
-    case PixelFormat::Z32FS8:
+    case PixelFormat::D32_FLOAT_S8_UINT:
        return is_first ? GL_DEPTH_COMPONENT : GL_STENCIL_INDEX;
-    case PixelFormat::S8Z24:
+    case PixelFormat::S8_UINT_D24_UNORM:
        return is_first ? GL_STENCIL_INDEX : GL_DEPTH_COMPONENT;
    default:
        UNREACHABLE();
@@ -482,9 +494,9 @@ GLuint CachedSurfaceView::GetTexture(SwizzleSource x_source, SwizzleSource y_sou
    std::array swizzle{x_source, y_source, z_source, w_source};
    switch (const PixelFormat format = GetSurfaceParams().pixel_format) {
-    case PixelFormat::Z24S8:
+    case PixelFormat::D24_UNORM_S8_UINT:
-    case PixelFormat::Z32FS8:
+    case PixelFormat::D32_FLOAT_S8_UINT:
-    case PixelFormat::S8Z24:
+    case PixelFormat::S8_UINT_D24_UNORM:
        UNIMPLEMENTED_IF(x_source != SwizzleSource::R && x_source != SwizzleSource::G);
        glTextureParameteri(view.handle, GL_DEPTH_STENCIL_TEXTURE_MODE,
                            GetComponent(format, x_source == SwizzleSource::R));
diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp
index e66cdc083..52e9e8250 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.cpp
+++ b/src/video_core/renderer_opengl/renderer_opengl.cpp
@@ -535,12 +535,12 @@ void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture,
    GLint internal_format;
    switch (framebuffer.pixel_format) {
-    case Tegra::FramebufferConfig::PixelFormat::ABGR8:
+    case Tegra::FramebufferConfig::PixelFormat::A8B8G8R8_UNORM:
        internal_format = GL_RGBA8;
        texture.gl_format = GL_RGBA;
        texture.gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
        break;
-    case Tegra::FramebufferConfig::PixelFormat::RGB565:
+    case Tegra::FramebufferConfig::PixelFormat::RGB565_UNORM:
        internal_format = GL_RGB565;
        texture.gl_format = GL_RGB;
        texture.gl_type = GL_UNSIGNED_SHORT_5_6_5;
diff --git a/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp b/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
index d1f0ea932..81a39a3b8 100644
--- a/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
+++ b/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
@@ -40,7 +40,6 @@ constexpr std::array POLYGON_OFFSET_ENABLE_LUT = {
 } // Anonymous namespace
 void FixedPipelineState::Fill(const Maxwell& regs, bool has_extended_dynamic_state) {
-    const auto& clip = regs.view_volume_clip_control;
    const std::array enabled_lut = {regs.polygon_offset_point_enable,
                                    regs.polygon_offset_line_enable,
                                    regs.polygon_offset_fill_enable};
diff --git a/src/video_core/renderer_vulkan/maxwell_to_vk.cpp b/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
index d7f1ae89f..f8c77f4fa 100644
--- a/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
+++ b/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
@@ -117,90 +117,101 @@ struct FormatTuple {
    VkFormat format; ///< Vulkan format
    int usage = 0;   ///< Describes image format usage
 } constexpr tex_format_tuples[] = {
-    {VK_FORMAT_A8B8G8R8_UNORM_PACK32, Attachable | Storage},    // ABGR8U
+    {VK_FORMAT_A8B8G8R8_UNORM_PACK32, Attachable | Storage},    // A8B8G8R8_UNORM
-    {VK_FORMAT_A8B8G8R8_SNORM_PACK32, Attachable | Storage},    // ABGR8S
+    {VK_FORMAT_A8B8G8R8_SNORM_PACK32, Attachable | Storage},    // A8B8G8R8_SNORM
-    {VK_FORMAT_A8B8G8R8_UINT_PACK32, Attachable | Storage},     // ABGR8UI
+    {VK_FORMAT_A8B8G8R8_SINT_PACK32, Attachable | Storage},     // A8B8G8R8_SINT
-    {VK_FORMAT_B5G6R5_UNORM_PACK16},                            // B5G6R5U
+    {VK_FORMAT_A8B8G8R8_UINT_PACK32, Attachable | Storage},     // A8B8G8R8_UINT
-    {VK_FORMAT_A2B10G10R10_UNORM_PACK32, Attachable | Storage}, // A2B10G10R10U
+    {VK_FORMAT_R5G6B5_UNORM_PACK16, Attachable},                // R5G6B5_UNORM
-    {VK_FORMAT_A1R5G5B5_UNORM_PACK16, Attachable},              // A1B5G5R5U (flipped with swizzle)
+    {VK_FORMAT_B5G6R5_UNORM_PACK16, Attachable},                // B5G6R5_UNORM
-    {VK_FORMAT_R8_UNORM, Attachable | Storage},                 // R8U
+    {VK_FORMAT_A1R5G5B5_UNORM_PACK16, Attachable},              // A1R5G5B5_UNORM
-    {VK_FORMAT_R8_UINT, Attachable | Storage},                  // R8UI
+    {VK_FORMAT_A2B10G10R10_UNORM_PACK32, Attachable | Storage}, // A2B10G10R10_UNORM
-    {VK_FORMAT_R16G16B16A16_SFLOAT, Attachable | Storage},      // RGBA16F
+    {VK_FORMAT_A2B10G10R10_UINT_PACK32, Attachable | Storage},  // A2B10G10R10_UINT
-    {VK_FORMAT_R16G16B16A16_UNORM, Attachable | Storage},       // RGBA16U
+    {VK_FORMAT_A1R5G5B5_UNORM_PACK16, Attachable},         // A1B5G5R5_UNORM (flipped with swizzle)
-    {VK_FORMAT_R16G16B16A16_SNORM, Attachable | Storage},       // RGBA16S
+    {VK_FORMAT_R8_UNORM, Attachable | Storage},            // R8_UNORM
-    {VK_FORMAT_R16G16B16A16_UINT, Attachable | Storage},        // RGBA16UI
+    {VK_FORMAT_R8_SNORM, Attachable | Storage},            // R8_SNORM
-    {VK_FORMAT_B10G11R11_UFLOAT_PACK32, Attachable | Storage},  // R11FG11FB10F
+    {VK_FORMAT_R8_SINT, Attachable | Storage},             // R8_SINT
-    {VK_FORMAT_R32G32B32A32_UINT, Attachable | Storage},        // RGBA32UI
+    {VK_FORMAT_R8_UINT, Attachable | Storage},             // R8_UINT
-    {VK_FORMAT_BC1_RGBA_UNORM_BLOCK},                           // DXT1
+    {VK_FORMAT_R16G16B16A16_SFLOAT, Attachable | Storage}, // R16G16B16A16_FLOAT
-    {VK_FORMAT_BC2_UNORM_BLOCK},                                // DXT23
+    {VK_FORMAT_R16G16B16A16_UNORM, Attachable | Storage},  // R16G16B16A16_UNORM
-    {VK_FORMAT_BC3_UNORM_BLOCK},                                // DXT45
+    {VK_FORMAT_R16G16B16A16_SNORM, Attachable | Storage},  // R16G16B16A16_SNORM
-    {VK_FORMAT_BC4_UNORM_BLOCK},                                // DXN1
+    {VK_FORMAT_R16G16B16A16_SINT, Attachable | Storage},   // R16G16B16A16_SINT
-    {VK_FORMAT_BC5_UNORM_BLOCK},                                // DXN2UNORM
+    {VK_FORMAT_R16G16B16A16_UINT, Attachable | Storage},   // R16G16B16A16_UINT
-    {VK_FORMAT_BC5_SNORM_BLOCK},                                // DXN2SNORM
+    {VK_FORMAT_B10G11R11_UFLOAT_PACK32, Attachable | Storage}, // B10G11R11_FLOAT
-    {VK_FORMAT_BC7_UNORM_BLOCK},                                // BC7U
+    {VK_FORMAT_R32G32B32A32_UINT, Attachable | Storage},       // R32G32B32A32_UINT
-    {VK_FORMAT_BC6H_UFLOAT_BLOCK},                              // BC6H_UF16
+    {VK_FORMAT_BC1_RGBA_UNORM_BLOCK},                          // BC1_RGBA_UNORM
-    {VK_FORMAT_BC6H_SFLOAT_BLOCK},                              // BC6H_SF16
+    {VK_FORMAT_BC2_UNORM_BLOCK},                               // BC2_UNORM
-    {VK_FORMAT_ASTC_4x4_UNORM_BLOCK},                           // ASTC_2D_4X4
+    {VK_FORMAT_BC3_UNORM_BLOCK},                               // BC3_UNORM
-    {VK_FORMAT_B8G8R8A8_UNORM, Attachable},                     // BGRA8
+    {VK_FORMAT_BC4_UNORM_BLOCK},                               // BC4_UNORM
-    {VK_FORMAT_R32G32B32A32_SFLOAT, Attachable | Storage},      // RGBA32F
+    {VK_FORMAT_BC4_SNORM_BLOCK},                               // BC4_SNORM
-    {VK_FORMAT_R32G32_SFLOAT, Attachable | Storage},            // RG32F
+    {VK_FORMAT_BC5_UNORM_BLOCK},                               // BC5_UNORM
-    {VK_FORMAT_R32_SFLOAT, Attachable | Storage},               // R32F
+    {VK_FORMAT_BC5_SNORM_BLOCK},                               // BC5_SNORM
-    {VK_FORMAT_R16_SFLOAT, Attachable | Storage},               // R16F
+    {VK_FORMAT_BC7_UNORM_BLOCK},                               // BC7_UNORM
-    {VK_FORMAT_R16_UNORM, Attachable | Storage},                // R16U
+    {VK_FORMAT_BC6H_UFLOAT_BLOCK},                             // BC6H_UFLOAT
-    {VK_FORMAT_UNDEFINED},                                      // R16S
+    {VK_FORMAT_BC6H_SFLOAT_BLOCK},                             // BC6H_SFLOAT
-    {VK_FORMAT_R16_UINT, Attachable | Storage},                 // R16UI
+    {VK_FORMAT_ASTC_4x4_UNORM_BLOCK},                          // ASTC_2D_4X4_UNORM
-    {VK_FORMAT_UNDEFINED},                                      // R16I
+    {VK_FORMAT_B8G8R8A8_UNORM, Attachable},                    // B8G8R8A8_UNORM
-    {VK_FORMAT_R16G16_UNORM, Attachable | Storage},             // RG16
+    {VK_FORMAT_R32G32B32A32_SFLOAT, Attachable | Storage},     // R32G32B32A32_FLOAT
-    {VK_FORMAT_R16G16_SFLOAT, Attachable | Storage},            // RG16F
+    {VK_FORMAT_R32G32B32A32_SINT, Attachable | Storage},       // R32G32B32A32_SINT
-    {VK_FORMAT_UNDEFINED},                                      // RG16UI
+    {VK_FORMAT_R32G32_SFLOAT, Attachable | Storage},           // R32G32_FLOAT
-    {VK_FORMAT_UNDEFINED},                                      // RG16I
+    {VK_FORMAT_R32G32_SINT, Attachable | Storage},             // R32G32_SINT
-    {VK_FORMAT_R16G16_SNORM, Attachable | Storage},             // RG16S
+    {VK_FORMAT_R32_SFLOAT, Attachable | Storage},              // R32_FLOAT
-    {VK_FORMAT_UNDEFINED},                                      // RGB32F
+    {VK_FORMAT_R16_SFLOAT, Attachable | Storage},              // R16_FLOAT
-    {VK_FORMAT_R8G8B8A8_SRGB, Attachable},                      // RGBA8_SRGB
+    {VK_FORMAT_R16_UNORM, Attachable | Storage},               // R16_UNORM
-    {VK_FORMAT_R8G8_UNORM, Attachable | Storage},               // RG8U
+    {VK_FORMAT_UNDEFINED},                                     // R16_SNORM
-    {VK_FORMAT_R8G8_SNORM, Attachable | Storage},               // RG8S
+    {VK_FORMAT_R16_UINT, Attachable | Storage},                // R16_UINT
-    {VK_FORMAT_R8G8_UINT, Attachable | Storage},                // RG8UI
+    {VK_FORMAT_UNDEFINED},                                     // R16_SINT
-    {VK_FORMAT_R32G32_UINT, Attachable | Storage},              // RG32UI
+    {VK_FORMAT_R16G16_UNORM, Attachable | Storage},            // R16G16_UNORM
-    {VK_FORMAT_UNDEFINED},                                      // RGBX16F
+    {VK_FORMAT_R16G16_SFLOAT, Attachable | Storage},           // R16G16_FLOAT
-    {VK_FORMAT_R32_UINT, Attachable | Storage},                 // R32UI
+    {VK_FORMAT_UNDEFINED},                                     // R16G16_UINT
-    {VK_FORMAT_R32_SINT, Attachable | Storage},                 // R32I
+    {VK_FORMAT_UNDEFINED},                                     // R16G16_SINT
-    {VK_FORMAT_ASTC_8x8_UNORM_BLOCK},                           // ASTC_2D_8X8
+    {VK_FORMAT_R16G16_SNORM, Attachable | Storage},            // R16G16_SNORM
-    {VK_FORMAT_UNDEFINED},                                      // ASTC_2D_8X5
+    {VK_FORMAT_UNDEFINED},                                     // R32G32B32_FLOAT
-    {VK_FORMAT_UNDEFINED},                                      // ASTC_2D_5X4
+    {VK_FORMAT_R8G8B8A8_SRGB, Attachable},                     // A8B8G8R8_SRGB
-    {VK_FORMAT_B8G8R8A8_SRGB, Attachable},                      // BGRA8_SRGB
+    {VK_FORMAT_R8G8_UNORM, Attachable | Storage},              // R8G8_UNORM
-    {VK_FORMAT_BC1_RGBA_SRGB_BLOCK},                            // DXT1_SRGB
+    {VK_FORMAT_R8G8_SNORM, Attachable | Storage},              // R8G8_SNORM
-    {VK_FORMAT_BC2_SRGB_BLOCK},                                 // DXT23_SRGB
+    {VK_FORMAT_R8G8_SINT, Attachable | Storage},               // R8G8_SINT
-    {VK_FORMAT_BC3_SRGB_BLOCK},                                 // DXT45_SRGB
+    {VK_FORMAT_R8G8_UINT, Attachable | Storage},               // R8G8_UINT
-    {VK_FORMAT_BC7_SRGB_BLOCK},                                 // BC7U_SRGB
+    {VK_FORMAT_R32G32_UINT, Attachable | Storage},             // R32G32_UINT
-    {VK_FORMAT_R4G4B4A4_UNORM_PACK16, Attachable},              // R4G4B4A4U
+    {VK_FORMAT_UNDEFINED},                                     // R16G16B16X16_FLOAT
-    {VK_FORMAT_ASTC_4x4_SRGB_BLOCK},                            // ASTC_2D_4X4_SRGB
+    {VK_FORMAT_R32_UINT, Attachable | Storage},                // R32_UINT
-    {VK_FORMAT_ASTC_8x8_SRGB_BLOCK},                            // ASTC_2D_8X8_SRGB
+    {VK_FORMAT_R32_SINT, Attachable | Storage},                // R32_SINT
-    {VK_FORMAT_ASTC_8x5_SRGB_BLOCK},                            // ASTC_2D_8X5_SRGB
+    {VK_FORMAT_ASTC_8x8_UNORM_BLOCK},                          // ASTC_2D_8X8_UNORM
-    {VK_FORMAT_ASTC_5x4_SRGB_BLOCK},                            // ASTC_2D_5X4_SRGB
+    {VK_FORMAT_UNDEFINED},                                     // ASTC_2D_8X5_UNORM
-    {VK_FORMAT_ASTC_5x5_UNORM_BLOCK},                           // ASTC_2D_5X5
+    {VK_FORMAT_UNDEFINED},                                     // ASTC_2D_5X4_UNORM
-    {VK_FORMAT_ASTC_5x5_SRGB_BLOCK},                            // ASTC_2D_5X5_SRGB
+    {VK_FORMAT_B8G8R8A8_SRGB, Attachable},                     // B8G8R8A8_SRGB
-    {VK_FORMAT_ASTC_10x8_UNORM_BLOCK},                          // ASTC_2D_10X8
+    {VK_FORMAT_BC1_RGBA_SRGB_BLOCK},                           // BC1_RGBA_SRGB
-    {VK_FORMAT_ASTC_10x8_SRGB_BLOCK},                           // ASTC_2D_10X8_SRGB
+    {VK_FORMAT_BC2_SRGB_BLOCK},                                // BC2_SRGB
-    {VK_FORMAT_ASTC_6x6_UNORM_BLOCK},                           // ASTC_2D_6X6
+    {VK_FORMAT_BC3_SRGB_BLOCK},                                // BC3_SRGB
-    {VK_FORMAT_ASTC_6x6_SRGB_BLOCK},                            // ASTC_2D_6X6_SRGB
+    {VK_FORMAT_BC7_SRGB_BLOCK},                                // BC7_SRGB
-    {VK_FORMAT_ASTC_10x10_UNORM_BLOCK},                         // ASTC_2D_10X10
+    {VK_FORMAT_R4G4B4A4_UNORM_PACK16, Attachable},             // A4B4G4R4_UNORM
-    {VK_FORMAT_ASTC_10x10_SRGB_BLOCK},                          // ASTC_2D_10X10_SRGB
+    {VK_FORMAT_ASTC_4x4_SRGB_BLOCK},                           // ASTC_2D_4X4_SRGB
-    {VK_FORMAT_ASTC_12x12_UNORM_BLOCK},                         // ASTC_2D_12X12
+    {VK_FORMAT_ASTC_8x8_SRGB_BLOCK},                           // ASTC_2D_8X8_SRGB
-    {VK_FORMAT_ASTC_12x12_SRGB_BLOCK},                          // ASTC_2D_12X12_SRGB
+    {VK_FORMAT_ASTC_8x5_SRGB_BLOCK},                           // ASTC_2D_8X5_SRGB
-    {VK_FORMAT_ASTC_8x6_UNORM_BLOCK},                           // ASTC_2D_8X6
+    {VK_FORMAT_ASTC_5x4_SRGB_BLOCK},                           // ASTC_2D_5X4_SRGB
-    {VK_FORMAT_ASTC_8x6_SRGB_BLOCK},                            // ASTC_2D_8X6_SRGB
+    {VK_FORMAT_ASTC_5x5_UNORM_BLOCK},                          // ASTC_2D_5X5_UNORM
-    {VK_FORMAT_ASTC_6x5_UNORM_BLOCK},                           // ASTC_2D_6X5
+    {VK_FORMAT_ASTC_5x5_SRGB_BLOCK},                           // ASTC_2D_5X5_SRGB
-    {VK_FORMAT_ASTC_6x5_SRGB_BLOCK},                            // ASTC_2D_6X5_SRGB
+    {VK_FORMAT_ASTC_10x8_UNORM_BLOCK},                         // ASTC_2D_10X8_UNORM
-    {VK_FORMAT_E5B9G9R9_UFLOAT_PACK32},                         // E5B9G9R9F
+    {VK_FORMAT_ASTC_10x8_SRGB_BLOCK},                          // ASTC_2D_10X8_SRGB
+    {VK_FORMAT_ASTC_6x6_UNORM_BLOCK},                          // ASTC_2D_6X6_UNORM
+    {VK_FORMAT_ASTC_6x6_SRGB_BLOCK},                           // ASTC_2D_6X6_SRGB
+    {VK_FORMAT_ASTC_10x10_UNORM_BLOCK},                        // ASTC_2D_10X10_UNORM
+    {VK_FORMAT_ASTC_10x10_SRGB_BLOCK},                         // ASTC_2D_10X10_SRGB
+    {VK_FORMAT_ASTC_12x12_UNORM_BLOCK},                        // ASTC_2D_12X12_UNORM
+    {VK_FORMAT_ASTC_12x12_SRGB_BLOCK},                         // ASTC_2D_12X12_SRGB
+    {VK_FORMAT_ASTC_8x6_UNORM_BLOCK},                          // ASTC_2D_8X6_UNORM
+    {VK_FORMAT_ASTC_8x6_SRGB_BLOCK},                           // ASTC_2D_8X6_SRGB
+    {VK_FORMAT_ASTC_6x5_UNORM_BLOCK},                          // ASTC_2D_6X5_UNORM
+    {VK_FORMAT_ASTC_6x5_SRGB_BLOCK},                           // ASTC_2D_6X5_SRGB
+    {VK_FORMAT_E5B9G9R9_UFLOAT_PACK32},                        // E5B9G9R9_FLOAT
    // Depth formats
-    {VK_FORMAT_D32_SFLOAT, Attachable}, // Z32F
+    {VK_FORMAT_D32_SFLOAT, Attachable}, // D32_FLOAT
-    {VK_FORMAT_D16_UNORM, Attachable},  // Z16
+    {VK_FORMAT_D16_UNORM, Attachable},  // D16_UNORM
    // DepthStencil formats
-    {VK_FORMAT_D24_UNORM_S8_UINT, Attachable},  // Z24S8
+    {VK_FORMAT_D24_UNORM_S8_UINT, Attachable},  // D24_UNORM_S8_UINT
-    {VK_FORMAT_D24_UNORM_S8_UINT, Attachable},  // S8Z24 (emulated)
+    {VK_FORMAT_D24_UNORM_S8_UINT, Attachable},  // S8_UINT_D24_UNORM (emulated)
-    {VK_FORMAT_D32_SFLOAT_S8_UINT, Attachable}, // Z32FS8
+    {VK_FORMAT_D32_SFLOAT_S8_UINT, Attachable}, // D32_FLOAT_S8_UINT
 };
 static_assert(std::size(tex_format_tuples) == VideoCore::Surface::MaxPixelFormat);
@@ -221,7 +232,7 @@ FormatInfo SurfaceFormat(const VKDevice& device, FormatType format_type, PixelFo
        return {VK_FORMAT_A8B8G8R8_UNORM_PACK32, true, true};
    }
-    // Use ABGR8 on hardware that doesn't support ASTC natively
+    // Use A8B8G8R8_UNORM on hardware that doesn't support ASTC natively
    if (!device.IsOptimalAstcSupported() && VideoCore::Surface::IsPixelFormatASTC(pixel_format)) {
        tuple.format = VideoCore::Surface::IsPixelFormatSRGB(pixel_format)
                           ? VK_FORMAT_A8B8G8R8_SRGB_PACK32
diff --git a/src/video_core/renderer_vulkan/vk_blit_screen.cpp b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
index 866813465..ce53e5a6b 100644
--- a/src/video_core/renderer_vulkan/vk_blit_screen.cpp
+++ b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
@@ -187,9 +187,9 @@ std::size_t GetSizeInBytes(const Tegra::FramebufferConfig& framebuffer) {
 VkFormat GetFormat(const Tegra::FramebufferConfig& framebuffer) {
    switch (framebuffer.pixel_format) {
-    case Tegra::FramebufferConfig::PixelFormat::ABGR8:
+    case Tegra::FramebufferConfig::PixelFormat::A8B8G8R8_UNORM:
        return VK_FORMAT_A8B8G8R8_UNORM_PACK32;
-    case Tegra::FramebufferConfig::PixelFormat::RGB565:
+    case Tegra::FramebufferConfig::PixelFormat::RGB565_UNORM:
        return VK_FORMAT_R5G6B5_UNORM_PACK16;
    default:
        UNIMPLEMENTED_MSG("Unknown framebuffer pixel format: {}",
diff --git a/src/video_core/renderer_vulkan/vk_device.cpp b/src/video_core/renderer_vulkan/vk_device.cpp
index 26379ee01..6245e0d78 100644
--- a/src/video_core/renderer_vulkan/vk_device.cpp
+++ b/src/video_core/renderer_vulkan/vk_device.cpp
@@ -84,14 +84,19 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(
        VK_FORMAT_A8B8G8R8_UNORM_PACK32,
        VK_FORMAT_A8B8G8R8_UINT_PACK32,
        VK_FORMAT_A8B8G8R8_SNORM_PACK32,
+        VK_FORMAT_A8B8G8R8_SINT_PACK32,
        VK_FORMAT_A8B8G8R8_SRGB_PACK32,
        VK_FORMAT_B5G6R5_UNORM_PACK16,
        VK_FORMAT_A2B10G10R10_UNORM_PACK32,
+        VK_FORMAT_A2B10G10R10_UINT_PACK32,
        VK_FORMAT_A1R5G5B5_UNORM_PACK16,
        VK_FORMAT_R32G32B32A32_SFLOAT,
+        VK_FORMAT_R32G32B32A32_SINT,
        VK_FORMAT_R32G32B32A32_UINT,
        VK_FORMAT_R32G32_SFLOAT,
+        VK_FORMAT_R32G32_SINT,
        VK_FORMAT_R32G32_UINT,
+        VK_FORMAT_R16G16B16A16_SINT,
        VK_FORMAT_R16G16B16A16_UINT,
        VK_FORMAT_R16G16B16A16_SNORM,
        VK_FORMAT_R16G16B16A16_UNORM,
@@ -103,8 +108,11 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(
        VK_FORMAT_R8G8B8A8_SRGB,
        VK_FORMAT_R8G8_UNORM,
        VK_FORMAT_R8G8_SNORM,
+        VK_FORMAT_R8G8_SINT,
        VK_FORMAT_R8G8_UINT,
        VK_FORMAT_R8_UNORM,
+        VK_FORMAT_R8_SNORM,
+        VK_FORMAT_R8_SINT,
        VK_FORMAT_R8_UINT,
        VK_FORMAT_B10G11R11_UFLOAT_PACK32,
        VK_FORMAT_R32_SFLOAT,
@@ -124,6 +132,7 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(
        VK_FORMAT_BC2_UNORM_BLOCK,
        VK_FORMAT_BC3_UNORM_BLOCK,
        VK_FORMAT_BC4_UNORM_BLOCK,
+        VK_FORMAT_BC4_SNORM_BLOCK,
        VK_FORMAT_BC5_UNORM_BLOCK,
        VK_FORMAT_BC5_SNORM_BLOCK,
        VK_FORMAT_BC7_UNORM_BLOCK,
diff --git a/src/video_core/renderer_vulkan/vk_device.h b/src/video_core/renderer_vulkan/vk_device.h
index ae5c21baa..529744f2d 100644
--- a/src/video_core/renderer_vulkan/vk_device.h
+++ b/src/video_core/renderer_vulkan/vk_device.h
@@ -122,6 +122,11 @@ public:
        return properties.limits.maxPushConstantsSize;
    }
+    /// Returns the maximum size for shared memory.
+    u32 GetMaxComputeSharedMemorySize() const {
+        return properties.limits.maxComputeSharedMemorySize;
+    }
    /// Returns true if ASTC is natively supported.
    bool IsOptimalAstcSupported() const {
        return is_optimal_astc_supported;
diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.cpp b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
index 31e44aa2b..2ed2004f0 100644
--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -532,10 +532,6 @@ void RasterizerVulkan::Clear() {
    scheduler.Record([clear_depth = regs.clear_depth, clear_stencil = regs.clear_stencil,
                      clear_rect, aspect_flags](vk::CommandBuffer cmdbuf) {
-        VkClearValue clear_value;
-        clear_value.depthStencil.depth = clear_depth;
-        clear_value.depthStencil.stencil = clear_stencil;
        VkClearAttachment attachment;
        attachment.aspectMask = aspect_flags;
        attachment.colorAttachment = 0;
diff --git a/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp b/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
index 97429cc59..cd7d7a4e4 100644
--- a/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
+++ b/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
@@ -685,13 +685,19 @@ private:
        }
        t_smem_uint = TypePointer(spv::StorageClass::Workgroup, t_uint);
-        const u32 smem_size = specialization.shared_memory_size;
+        u32 smem_size = specialization.shared_memory_size * 4;
        if (smem_size == 0) {
            // Avoid declaring an empty array.
            return;
        }
-        const auto element_count = static_cast<u32>(Common::AlignUp(smem_size, 4) / 4);
+        const u32 limit = device.GetMaxComputeSharedMemorySize();
-        const Id type_array = TypeArray(t_uint, Constant(t_uint, element_count));
+        if (smem_size > limit) {
+            LOG_ERROR(Render_Vulkan, "Shared memory size {} is clamped to host's limit {}",
+                      smem_size, limit);
+            smem_size = limit;
+        }
+        const Id type_array = TypeArray(t_uint, Constant(t_uint, smem_size / 4));
        const Id type_pointer = TypePointer(spv::StorageClass::Workgroup, type_array);
        Name(type_pointer, "SharedMemory");
@@ -700,9 +706,9 @@ private:
    }
    void DeclareInternalFlags() {
-        constexpr std::array names = {"zero", "sign", "carry", "overflow"};
+        static constexpr std::array names{"zero", "sign", "carry", "overflow"};
        for (std::size_t flag = 0; flag < INTERNAL_FLAGS_COUNT; ++flag) {
-            const auto flag_code = static_cast<InternalFlag>(flag);
            const Id id = OpVariable(t_prv_bool, spv::StorageClass::Private, v_false);
            internal_flags[flag] = AddGlobalVariable(Name(id, names[flag]));
        }
@@ -2798,7 +2804,6 @@ private:
    std::map<GlobalMemoryBase, Id> global_buffers;
    std::map<u32, TexelBuffer> uniform_texels;
    std::map<u32, SampledImage> sampled_images;
-    std::map<u32, TexelBuffer> storage_texels;
    std::map<u32, StorageImage> images;
    std::array<Id, Maxwell::NumRenderTargets> frag_colors{};
diff --git a/src/video_core/renderer_vulkan/vk_swapchain.cpp b/src/video_core/renderer_vulkan/vk_swapchain.cpp
index c25e312b6..6bfd2abae 100644
--- a/src/video_core/renderer_vulkan/vk_swapchain.cpp
+++ b/src/video_core/renderer_vulkan/vk_swapchain.cpp
@@ -156,6 +156,7 @@ void VKSwapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities,
        .minImageCount = requested_image_count,
        .imageFormat = surface_format.format,
        .imageColorSpace = surface_format.colorSpace,
+        .imageExtent = {},
        .imageArrayLayers = 1,
        .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
        .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
@@ -204,6 +205,7 @@ void VKSwapchain::CreateImageViews() {
        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
+        .image = {},
        .viewType = VK_IMAGE_VIEW_TYPE_2D,
        .format = image_format,
        .components =
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
index 9bc18c21a..efd4bb13b 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
@@ -138,6 +138,7 @@ VkImageCreateInfo GenerateImageCreateInfo(const VKDevice& device, const SurfaceP
        .flags = 0,
        .imageType = SurfaceTargetToImage(params.target),
        .format = format,
+        .extent = {},
        .mipLevels = params.num_levels,
        .arrayLayers = static_cast<u32>(params.GetNumLayers()),
        .samples = VK_SAMPLE_COUNT_1_BIT,
@@ -235,7 +236,7 @@ void CachedSurface::UploadTexture(const std::vector<u8>& staging_buffer) {
 void CachedSurface::DownloadTexture(std::vector<u8>& staging_buffer) {
    UNIMPLEMENTED_IF(params.IsBuffer());
-    if (params.pixel_format == VideoCore::Surface::PixelFormat::A1B5G5R5U) {
+    if (params.pixel_format == VideoCore::Surface::PixelFormat::A1B5G5R5_UNORM) {
        LOG_WARNING(Render_Vulkan, "A1B5G5R5 flushing is stubbed");
    }
@@ -385,7 +386,7 @@ VkImageView CachedSurfaceView::GetImageView(SwizzleSource x_source, SwizzleSourc
    std::array swizzle{MaxwellToVK::SwizzleSource(x_source), MaxwellToVK::SwizzleSource(y_source),
                       MaxwellToVK::SwizzleSource(z_source), MaxwellToVK::SwizzleSource(w_source)};
-    if (params.pixel_format == VideoCore::Surface::PixelFormat::A1B5G5R5U) {
+    if (params.pixel_format == VideoCore::Surface::PixelFormat::A1B5G5R5_UNORM) {
        // A1B5G5R5 is implemented as A1R5G5B5, we have to change the swizzle here.
        std::swap(swizzle[0], swizzle[2]);
    }
@@ -397,11 +398,11 @@ VkImageView CachedSurfaceView::GetImageView(SwizzleSource x_source, SwizzleSourc
        UNIMPLEMENTED_IF(x_source != SwizzleSource::R && x_source != SwizzleSource::G);
        const bool is_first = x_source == SwizzleSource::R;
        switch (params.pixel_format) {
-        case VideoCore::Surface::PixelFormat::Z24S8:
+        case VideoCore::Surface::PixelFormat::D24_UNORM_S8_UINT:
-        case VideoCore::Surface::PixelFormat::Z32FS8:
+        case VideoCore::Surface::PixelFormat::D32_FLOAT_S8_UINT:
            aspect = is_first ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_STENCIL_BIT;
            break;
-        case VideoCore::Surface::PixelFormat::S8Z24:
+        case VideoCore::Surface::PixelFormat::S8_UINT_D24_UNORM:
            aspect = is_first ? VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT;
            break;
        default:
@@ -458,6 +459,7 @@ VkImageView CachedSurfaceView::GetAttachment() {
        .pNext = nullptr,
        .flags = 0,
        .image = surface.GetImageHandle(),
+        .viewType = VK_IMAGE_VIEW_TYPE_1D,
        .format = surface.GetImage().GetFormat(),
        .components =
            {
diff --git a/src/video_core/shader/decode/arithmetic_integer.cpp b/src/video_core/shader/decode/arithmetic_integer.cpp
index a041519b7..73155966f 100644
--- a/src/video_core/shader/decode/arithmetic_integer.cpp
+++ b/src/video_core/shader/decode/arithmetic_integer.cpp
@@ -98,12 +98,12 @@ u32 ShaderIR::DecodeArithmeticInteger(NodeBlock& bb, u32 pc) {
        op_b = GetOperandAbsNegInteger(op_b, false, instr.iadd3.neg_b, true);
        op_c = GetOperandAbsNegInteger(op_c, false, instr.iadd3.neg_c, true);
-        const Node value = [&]() {
+        const Node value = [&] {
-            const Node add_ab = Operation(OperationCode::IAdd, NO_PRECISE, op_a, op_b);
+            Node add_ab = Operation(OperationCode::IAdd, NO_PRECISE, op_a, op_b);
            if (opcode->get().GetId() != OpCode::Id::IADD3_R) {
                return Operation(OperationCode::IAdd, NO_PRECISE, add_ab, op_c);
            }
-            const Node shifted = [&]() {
+            const Node shifted = [&] {
                switch (instr.iadd3.mode) {
                case Tegra::Shader::IAdd3Mode::RightShift:
                    // TODO(tech4me): According to
diff --git a/src/video_core/shader/decode/image.cpp b/src/video_core/shader/decode/image.cpp
index 07778dc3e..e75ca4fdb 100644
--- a/src/video_core/shader/decode/image.cpp
+++ b/src/video_core/shader/decode/image.cpp
@@ -31,11 +31,11 @@ ComponentType GetComponentType(Tegra::Engines::SamplerDescriptor descriptor,
                               std::size_t component) {
    const TextureFormat format{descriptor.format};
    switch (format) {
-    case TextureFormat::R16_G16_B16_A16:
+    case TextureFormat::R16G16B16A16:
-    case TextureFormat::R32_G32_B32_A32:
+    case TextureFormat::R32G32B32A32:
-    case TextureFormat::R32_G32_B32:
+    case TextureFormat::R32G32B32:
-    case TextureFormat::R32_G32:
+    case TextureFormat::R32G32:
-    case TextureFormat::R16_G16:
+    case TextureFormat::R16G16:
    case TextureFormat::R32:
    case TextureFormat::R16:
    case TextureFormat::R8:
@@ -97,7 +97,7 @@ ComponentType GetComponentType(Tegra::Engines::SamplerDescriptor descriptor,
        break;
    case TextureFormat::B5G6R5:
    case TextureFormat::B6G5R5:
-    case TextureFormat::BF10GF11RF11:
+    case TextureFormat::B10G11R11:
        if (component == 0) {
            return descriptor.b_type;
        }
@@ -108,9 +108,9 @@ ComponentType GetComponentType(Tegra::Engines::SamplerDescriptor descriptor,
            return descriptor.r_type;
        }
        break;
-    case TextureFormat::G8R24:
+    case TextureFormat::R24G8:
-    case TextureFormat::G24R8:
+    case TextureFormat::R8G24:
-    case TextureFormat::G8R8:
+    case TextureFormat::R8G8:
    case TextureFormat::G4R4:
        if (component == 0) {
            return descriptor.g_type;
@@ -137,15 +137,15 @@ bool IsComponentEnabled(std::size_t component_mask, std::size_t component) {
 u32 GetComponentSize(TextureFormat format, std::size_t component) {
    switch (format) {
-    case TextureFormat::R32_G32_B32_A32:
+    case TextureFormat::R32G32B32A32:
        return 32;
-    case TextureFormat::R16_G16_B16_A16:
+    case TextureFormat::R16G16B16A16:
        return 16;
-    case TextureFormat::R32_G32_B32:
+    case TextureFormat::R32G32B32:
        return component <= 2 ? 32 : 0;
-    case TextureFormat::R32_G32:
+    case TextureFormat::R32G32:
        return component <= 1 ? 32 : 0;
-    case TextureFormat::R16_G16:
+    case TextureFormat::R16G16:
        return component <= 1 ? 16 : 0;
    case TextureFormat::R32:
        return component == 0 ? 32 : 0;
@@ -192,7 +192,7 @@ u32 GetComponentSize(TextureFormat format, std::size_t component) {
            return 6;
        }
        return 0;
-    case TextureFormat::BF10GF11RF11:
+    case TextureFormat::B10G11R11:
        if (component == 1 || component == 2) {
            return 11;
        }
@@ -200,7 +200,7 @@ u32 GetComponentSize(TextureFormat format, std::size_t component) {
            return 10;
        }
        return 0;
-    case TextureFormat::G8R24:
+    case TextureFormat::R24G8:
        if (component == 0) {
            return 8;
        }
@@ -208,7 +208,7 @@ u32 GetComponentSize(TextureFormat format, std::size_t component) {
            return 24;
        }
        return 0;
-    case TextureFormat::G24R8:
+    case TextureFormat::R8G24:
        if (component == 0) {
            return 8;
        }
@@ -216,7 +216,7 @@ u32 GetComponentSize(TextureFormat format, std::size_t component) {
            return 24;
        }
        return 0;
-    case TextureFormat::G8R8:
+    case TextureFormat::R8G8:
        return (component == 0 || component == 1) ? 8 : 0;
    case TextureFormat::G4R4:
        return (component == 0 || component == 1) ? 4 : 0;
@@ -231,25 +231,25 @@ std::size_t GetImageComponentMask(TextureFormat format) {
    constexpr u8 B = 0b0100;
    constexpr u8 A = 0b1000;
    switch (format) {
-    case TextureFormat::R32_G32_B32_A32:
+    case TextureFormat::R32G32B32A32:
-    case TextureFormat::R16_G16_B16_A16:
+    case TextureFormat::R16G16B16A16:
    case TextureFormat::A8R8G8B8:
    case TextureFormat::A2B10G10R10:
    case TextureFormat::A4B4G4R4:
    case TextureFormat::A5B5G5R1:
    case TextureFormat::A1B5G5R5:
        return std::size_t{R | G | B | A};
-    case TextureFormat::R32_G32_B32:
+    case TextureFormat::R32G32B32:
    case TextureFormat::R32_B24G8:
    case TextureFormat::B5G6R5:
    case TextureFormat::B6G5R5:
-    case TextureFormat::BF10GF11RF11:
+    case TextureFormat::B10G11R11:
        return std::size_t{R | G | B};
-    case TextureFormat::R32_G32:
+    case TextureFormat::R32G32:
-    case TextureFormat::R16_G16:
+    case TextureFormat::R16G16:
-    case TextureFormat::G8R24:
+    case TextureFormat::R24G8:
-    case TextureFormat::G24R8:
+    case TextureFormat::R8G24:
-    case TextureFormat::G8R8:
+    case TextureFormat::R8G8:
    case TextureFormat::G4R4:
        return std::size_t{R | G};
    case TextureFormat::R32:
diff --git a/src/video_core/shader/decode/other.cpp b/src/video_core/shader/decode/other.cpp
index c0a8f233f..29a7cfbfe 100644
--- a/src/video_core/shader/decode/other.cpp
+++ b/src/video_core/shader/decode/other.cpp
@@ -75,8 +75,7 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
        const Node value = [this, instr] {
            switch (instr.sys20) {
            case SystemVariable::LaneId:
-                LOG_WARNING(HW_GPU, "S2R instruction with LaneId is incomplete");
+                return Operation(OperationCode::ThreadId);
-                return Immediate(0U);
            case SystemVariable::InvocationId:
                return Operation(OperationCode::InvocationId);
            case SystemVariable::Ydirection:
diff --git a/src/video_core/shader/decode/video.cpp b/src/video_core/shader/decode/video.cpp
index 64ba60ea2..1c0957277 100644
--- a/src/video_core/shader/decode/video.cpp
+++ b/src/video_core/shader/decode/video.cpp
@@ -91,29 +91,28 @@ u32 ShaderIR::DecodeVideo(NodeBlock& bb, u32 pc) {
    return pc;
 }
-Node ShaderIR::GetVideoOperand(Node op, bool is_chunk, bool is_signed,
+Node ShaderIR::GetVideoOperand(Node op, bool is_chunk, bool is_signed, VideoType type,
-                               Tegra::Shader::VideoType type, u64 byte_height) {
+                               u64 byte_height) {
    if (!is_chunk) {
        return BitfieldExtract(op, static_cast<u32>(byte_height * 8), 8);
    }
-    const Node zero = Immediate(0);
    switch (type) {
-    case Tegra::Shader::VideoType::Size16_Low:
+    case VideoType::Size16_Low:
        return BitfieldExtract(op, 0, 16);
-    case Tegra::Shader::VideoType::Size16_High:
+    case VideoType::Size16_High:
        return BitfieldExtract(op, 16, 16);
-    case Tegra::Shader::VideoType::Size32:
+    case VideoType::Size32:
        // TODO(Rodrigo): From my hardware tests it becomes a bit "mad" when this type is used
        // (1 * 1 + 0 == 0x5b800000). Until a better explanation is found: abort.
        UNIMPLEMENTED();
-        return zero;
+        return Immediate(0);
-    case Tegra::Shader::VideoType::Invalid:
+    case VideoType::Invalid:
        UNREACHABLE_MSG("Invalid instruction encoding");
-        return zero;
+        return Immediate(0);
    default:
        UNREACHABLE();
-        return zero;
+        return Immediate(0);
    }
 }
diff --git a/src/video_core/shader/decode/xmad.cpp b/src/video_core/shader/decode/xmad.cpp
index c83dc6615..233b8fa42 100644
--- a/src/video_core/shader/decode/xmad.cpp
+++ b/src/video_core/shader/decode/xmad.cpp
@@ -81,20 +81,21 @@ u32 ShaderIR::DecodeXmad(NodeBlock& bb, u32 pc) {
    SetTemporary(bb, 0, product);
    product = GetTemporary(0);
-    const Node original_c = op_c;
+    Node original_c = op_c;
    const Tegra::Shader::XmadMode set_mode = mode; // Workaround to clang compile error
-    op_c = [&]() {
+    op_c = [&] {
        switch (set_mode) {
        case Tegra::Shader::XmadMode::None:
            return original_c;
        case Tegra::Shader::XmadMode::CLo:
-            return BitfieldExtract(original_c, 0, 16);
+            return BitfieldExtract(std::move(original_c), 0, 16);
        case Tegra::Shader::XmadMode::CHi:
-            return BitfieldExtract(original_c, 16, 16);
+            return BitfieldExtract(std::move(original_c), 16, 16);
        case Tegra::Shader::XmadMode::CBcc: {
-            const Node shifted_b = SignedOperation(OperationCode::ILogicalShiftLeft, is_signed_b,
+            Node shifted_b = SignedOperation(OperationCode::ILogicalShiftLeft, is_signed_b,
-                                                   original_b, Immediate(16));
+                                             original_b, Immediate(16));
-            return SignedOperation(OperationCode::IAdd, is_signed_c, original_c, shifted_b);
+            return SignedOperation(OperationCode::IAdd, is_signed_c, std::move(original_c),
+                                   std::move(shifted_b));
        }
        case Tegra::Shader::XmadMode::CSfu: {
            const Node comp_a =
diff --git a/src/video_core/shader/shader_ir.cpp b/src/video_core/shader/shader_ir.cpp
index e322c3402..29d794b34 100644
--- a/src/video_core/shader/shader_ir.cpp
+++ b/src/video_core/shader/shader_ir.cpp
@@ -112,9 +112,9 @@ Node ShaderIR::GetOutputAttribute(Attribute::Index index, u64 element, Node buff
 }
 Node ShaderIR::GetInternalFlag(InternalFlag flag, bool negated) const {
-    const Node node = MakeNode<InternalFlagNode>(flag);
+    Node node = MakeNode<InternalFlagNode>(flag);
    if (negated) {
-        return Operation(OperationCode::LogicalNegate, node);
+        return Operation(OperationCode::LogicalNegate, std::move(node));
    }
    return node;
 }
diff --git a/src/video_core/surface.cpp b/src/video_core/surface.cpp
index bbe93903c..1688267bb 100644
--- a/src/video_core/surface.cpp
+++ b/src/video_core/surface.cpp
@@ -74,117 +74,131 @@ bool SurfaceTargetIsArray(SurfaceTarget target) {
 PixelFormat PixelFormatFromDepthFormat(Tegra::DepthFormat format) {
    switch (format) {
-    case Tegra::DepthFormat::S8_Z24_UNORM:
+    case Tegra::DepthFormat::S8_UINT_Z24_UNORM:
-        return PixelFormat::S8Z24;
+        return PixelFormat::S8_UINT_D24_UNORM;
-    case Tegra::DepthFormat::Z24_S8_UNORM:
+    case Tegra::DepthFormat::D24S8_UNORM:
-        return PixelFormat::Z24S8;
+        return PixelFormat::D24_UNORM_S8_UINT;
-    case Tegra::DepthFormat::Z32_FLOAT:
+    case Tegra::DepthFormat::D32_FLOAT:
-        return PixelFormat::Z32F;
+        return PixelFormat::D32_FLOAT;
-    case Tegra::DepthFormat::Z16_UNORM:
+    case Tegra::DepthFormat::D16_UNORM:
-        return PixelFormat::Z16;
+        return PixelFormat::D16_UNORM;
-    case Tegra::DepthFormat::Z32_S8_X24_FLOAT:
+    case Tegra::DepthFormat::D32_FLOAT_S8X24_UINT:
-        return PixelFormat::Z32FS8;
+        return PixelFormat::D32_FLOAT_S8_UINT;
    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+        UNIMPLEMENTED_MSG("Unimplemented format={}", static_cast<u32>(format));
-        UNREACHABLE();
+        return PixelFormat::S8_UINT_D24_UNORM;
-        return PixelFormat::S8Z24;
    }
 }
 PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format) {
    switch (format) {
-    case Tegra::RenderTargetFormat::RGBA8_SRGB:
+    case Tegra::RenderTargetFormat::R32B32G32A32_FLOAT:
-        return PixelFormat::RGBA8_SRGB;
+        return PixelFormat::R32G32B32A32_FLOAT;
-    case Tegra::RenderTargetFormat::RGBA8_UNORM:
+    case Tegra::RenderTargetFormat::R32G32B32A32_SINT:
-        return PixelFormat::ABGR8U;
+        return PixelFormat::R32G32B32A32_SINT;
-    case Tegra::RenderTargetFormat::RGBA8_SNORM:
+    case Tegra::RenderTargetFormat::R32G32B32A32_UINT:
-        return PixelFormat::ABGR8S;
+        return PixelFormat::R32G32B32A32_UINT;
-    case Tegra::RenderTargetFormat::RGBA8_UINT:
+    case Tegra::RenderTargetFormat::R16G16B16A16_UNORM:
-        return PixelFormat::ABGR8UI;
+        return PixelFormat::R16G16B16A16_UNORM;
-    case Tegra::RenderTargetFormat::BGRA8_SRGB:
+    case Tegra::RenderTargetFormat::R16G16B16A16_SNORM:
-        return PixelFormat::BGRA8_SRGB;
+        return PixelFormat::R16G16B16A16_SNORM;
-    case Tegra::RenderTargetFormat::BGRA8_UNORM:
+    case Tegra::RenderTargetFormat::R16G16B16A16_SINT:
-        return PixelFormat::BGRA8;
+        return PixelFormat::R16G16B16A16_SINT;
-    case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
+    case Tegra::RenderTargetFormat::R16G16B16A16_UINT:
-        return PixelFormat::A2B10G10R10U;
+        return PixelFormat::R16G16B16A16_UINT;
-    case Tegra::RenderTargetFormat::RGBA16_FLOAT:
+    case Tegra::RenderTargetFormat::R16G16B16A16_FLOAT:
-        return PixelFormat::RGBA16F;
+        return PixelFormat::R16G16B16A16_FLOAT;
-    case Tegra::RenderTargetFormat::RGBA16_UNORM:
+    case Tegra::RenderTargetFormat::R32G32_FLOAT:
-        return PixelFormat::RGBA16U;
+        return PixelFormat::R32G32_FLOAT;
-    case Tegra::RenderTargetFormat::RGBA16_SNORM:
+    case Tegra::RenderTargetFormat::R32G32_SINT:
-        return PixelFormat::RGBA16S;
+        return PixelFormat::R32G32_SINT;
-    case Tegra::RenderTargetFormat::RGBA16_UINT:
+    case Tegra::RenderTargetFormat::R32G32_UINT:
-        return PixelFormat::RGBA16UI;
+        return PixelFormat::R32G32_UINT;
-    case Tegra::RenderTargetFormat::RGBA32_FLOAT:
+    case Tegra::RenderTargetFormat::R16G16B16X16_FLOAT:
-        return PixelFormat::RGBA32F;
+        return PixelFormat::R16G16B16X16_FLOAT;
-    case Tegra::RenderTargetFormat::RG32_FLOAT:
+    case Tegra::RenderTargetFormat::B8G8R8A8_UNORM:
-        return PixelFormat::RG32F;
+        return PixelFormat::B8G8R8A8_UNORM;
-    case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
+    case Tegra::RenderTargetFormat::B8G8R8A8_SRGB:
-        return PixelFormat::R11FG11FB10F;
+        return PixelFormat::B8G8R8A8_SRGB;
-    case Tegra::RenderTargetFormat::B5G6R5_UNORM:
+    case Tegra::RenderTargetFormat::A2B10G10R10_UNORM:
-        return PixelFormat::B5G6R5U;
+        return PixelFormat::A2B10G10R10_UNORM;
-    case Tegra::RenderTargetFormat::BGR5A1_UNORM:
+    case Tegra::RenderTargetFormat::A2B10G10R10_UINT:
-        return PixelFormat::A1B5G5R5U;
+        return PixelFormat::A2B10G10R10_UINT;
-    case Tegra::RenderTargetFormat::RGBA32_UINT:
+    case Tegra::RenderTargetFormat::A8B8G8R8_UNORM:
-        return PixelFormat::RGBA32UI;
+        return PixelFormat::A8B8G8R8_UNORM;
-    case Tegra::RenderTargetFormat::R8_UNORM:
+    case Tegra::RenderTargetFormat::A8B8G8R8_SRGB:
-        return PixelFormat::R8U;
+        return PixelFormat::A8B8G8R8_SRGB;
-    case Tegra::RenderTargetFormat::R8_UINT:
+    case Tegra::RenderTargetFormat::A8B8G8R8_SNORM:
-        return PixelFormat::R8UI;
+        return PixelFormat::A8B8G8R8_SNORM;
-    case Tegra::RenderTargetFormat::RG16_FLOAT:
+    case Tegra::RenderTargetFormat::A8B8G8R8_SINT:
-        return PixelFormat::RG16F;
+        return PixelFormat::A8B8G8R8_SINT;
-    case Tegra::RenderTargetFormat::RG16_UINT:
+    case Tegra::RenderTargetFormat::A8B8G8R8_UINT:
-        return PixelFormat::RG16UI;
+        return PixelFormat::A8B8G8R8_UINT;
-    case Tegra::RenderTargetFormat::RG16_SINT:
+    case Tegra::RenderTargetFormat::R16G16_UNORM:
-        return PixelFormat::RG16I;
+        return PixelFormat::R16G16_UNORM;
-    case Tegra::RenderTargetFormat::RG16_UNORM:
+    case Tegra::RenderTargetFormat::R16G16_SNORM:
-        return PixelFormat::RG16;
+        return PixelFormat::R16G16_SNORM;
-    case Tegra::RenderTargetFormat::RG16_SNORM:
+    case Tegra::RenderTargetFormat::R16G16_SINT:
-        return PixelFormat::RG16S;
+        return PixelFormat::R16G16_SINT;
-    case Tegra::RenderTargetFormat::RG8_UNORM:
+    case Tegra::RenderTargetFormat::R16G16_UINT:
-        return PixelFormat::RG8U;
+        return PixelFormat::R16G16_UINT;
-    case Tegra::RenderTargetFormat::RG8_SNORM:
+    case Tegra::RenderTargetFormat::R16G16_FLOAT:
-        return PixelFormat::RG8S;
+        return PixelFormat::R16G16_FLOAT;
-    case Tegra::RenderTargetFormat::RG8_UINT:
+    case Tegra::RenderTargetFormat::B10G11R11_FLOAT:
-        return PixelFormat::RG8UI;
+        return PixelFormat::B10G11R11_FLOAT;
-    case Tegra::RenderTargetFormat::R16_FLOAT:
+    case Tegra::RenderTargetFormat::R32_SINT:
-        return PixelFormat::R16F;
+        return PixelFormat::R32_SINT;
+    case Tegra::RenderTargetFormat::R32_UINT:
+        return PixelFormat::R32_UINT;
+    case Tegra::RenderTargetFormat::R32_FLOAT:
+        return PixelFormat::R32_FLOAT;
+    case Tegra::RenderTargetFormat::R5G6B5_UNORM:
+        return PixelFormat::R5G6B5_UNORM;
+    case Tegra::RenderTargetFormat::A1R5G5B5_UNORM:
+        return PixelFormat::A1R5G5B5_UNORM;
+    case Tegra::RenderTargetFormat::R8G8_UNORM:
+        return PixelFormat::R8G8_UNORM;
+    case Tegra::RenderTargetFormat::R8G8_SNORM:
+        return PixelFormat::R8G8_SNORM;
+    case Tegra::RenderTargetFormat::R8G8_SINT:
+        return PixelFormat::R8G8_SINT;
+    case Tegra::RenderTargetFormat::R8G8_UINT:
+        return PixelFormat::R8G8_UINT;
    case Tegra::RenderTargetFormat::R16_UNORM:
-        return PixelFormat::R16U;
+        return PixelFormat::R16_UNORM;
    case Tegra::RenderTargetFormat::R16_SNORM:
-        return PixelFormat::R16S;
+        return PixelFormat::R16_SNORM;
-    case Tegra::RenderTargetFormat::R16_UINT:
-        return PixelFormat::R16UI;
    case Tegra::RenderTargetFormat::R16_SINT:
-        return PixelFormat::R16I;
+        return PixelFormat::R16_SINT;
-    case Tegra::RenderTargetFormat::R32_FLOAT:
+    case Tegra::RenderTargetFormat::R16_UINT:
-        return PixelFormat::R32F;
+        return PixelFormat::R16_UINT;
-    case Tegra::RenderTargetFormat::R32_SINT:
+    case Tegra::RenderTargetFormat::R16_FLOAT:
-        return PixelFormat::R32I;
+        return PixelFormat::R16_FLOAT;
-    case Tegra::RenderTargetFormat::R32_UINT:
+    case Tegra::RenderTargetFormat::R8_UNORM:
-        return PixelFormat::R32UI;
+        return PixelFormat::R8_UNORM;
-    case Tegra::RenderTargetFormat::RG32_UINT:
+    case Tegra::RenderTargetFormat::R8_SNORM:
-        return PixelFormat::RG32UI;
+        return PixelFormat::R8_SNORM;
-    case Tegra::RenderTargetFormat::RGBX16_FLOAT:
+    case Tegra::RenderTargetFormat::R8_SINT:
-        return PixelFormat::RGBX16F;
+        return PixelFormat::R8_SINT;
+    case Tegra::RenderTargetFormat::R8_UINT:
+        return PixelFormat::R8_UINT;
    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+        UNIMPLEMENTED_MSG("Unimplemented format={}", static_cast<int>(format));
-        UNREACHABLE();
+        return PixelFormat::A8B8G8R8_UNORM;
-        return PixelFormat::RGBA8_SRGB;
    }
 }
 PixelFormat PixelFormatFromGPUPixelFormat(Tegra::FramebufferConfig::PixelFormat format) {
    switch (format) {
-    case Tegra::FramebufferConfig::PixelFormat::ABGR8:
+    case Tegra::FramebufferConfig::PixelFormat::A8B8G8R8_UNORM:
-        return PixelFormat::ABGR8U;
+        return PixelFormat::A8B8G8R8_UNORM;
-    case Tegra::FramebufferConfig::PixelFormat::RGB565:
+    case Tegra::FramebufferConfig::PixelFormat::RGB565_UNORM:
-        return PixelFormat::B5G6R5U;
+        return PixelFormat::R5G6B5_UNORM;
-    case Tegra::FramebufferConfig::PixelFormat::BGRA8:
+    case Tegra::FramebufferConfig::PixelFormat::B8G8R8A8_UNORM:
-        return PixelFormat::BGRA8;
+        return PixelFormat::B8G8R8A8_UNORM;
    default:
        UNIMPLEMENTED_MSG("Unimplemented format={}", static_cast<u32>(format));
-        return PixelFormat::ABGR8U;
+        return PixelFormat::A8B8G8R8_UNORM;
    }
 }
@@ -212,27 +226,27 @@ SurfaceType GetFormatType(PixelFormat pixel_format) {
 bool IsPixelFormatASTC(PixelFormat format) {
    switch (format) {
-    case PixelFormat::ASTC_2D_4X4:
+    case PixelFormat::ASTC_2D_4X4_UNORM:
-    case PixelFormat::ASTC_2D_5X4:
+    case PixelFormat::ASTC_2D_5X4_UNORM:
-    case PixelFormat::ASTC_2D_5X5:
+    case PixelFormat::ASTC_2D_5X5_UNORM:
-    case PixelFormat::ASTC_2D_8X8:
+    case PixelFormat::ASTC_2D_8X8_UNORM:
-    case PixelFormat::ASTC_2D_8X5:
+    case PixelFormat::ASTC_2D_8X5_UNORM:
    case PixelFormat::ASTC_2D_4X4_SRGB:
    case PixelFormat::ASTC_2D_5X4_SRGB:
    case PixelFormat::ASTC_2D_5X5_SRGB:
    case PixelFormat::ASTC_2D_8X8_SRGB:
    case PixelFormat::ASTC_2D_8X5_SRGB:
-    case PixelFormat::ASTC_2D_10X8:
+    case PixelFormat::ASTC_2D_10X8_UNORM:
    case PixelFormat::ASTC_2D_10X8_SRGB:
-    case PixelFormat::ASTC_2D_6X6:
+    case PixelFormat::ASTC_2D_6X6_UNORM:
    case PixelFormat::ASTC_2D_6X6_SRGB:
-    case PixelFormat::ASTC_2D_10X10:
+    case PixelFormat::ASTC_2D_10X10_UNORM:
    case PixelFormat::ASTC_2D_10X10_SRGB:
-    case PixelFormat::ASTC_2D_12X12:
+    case PixelFormat::ASTC_2D_12X12_UNORM:
    case PixelFormat::ASTC_2D_12X12_SRGB:
-    case PixelFormat::ASTC_2D_8X6:
+    case PixelFormat::ASTC_2D_8X6_UNORM:
    case PixelFormat::ASTC_2D_8X6_SRGB:
-    case PixelFormat::ASTC_2D_6X5:
+    case PixelFormat::ASTC_2D_6X5_UNORM:
    case PixelFormat::ASTC_2D_6X5_SRGB:
        return true;
    default:
@@ -242,12 +256,12 @@ bool IsPixelFormatASTC(PixelFormat format) {
 bool IsPixelFormatSRGB(PixelFormat format) {
    switch (format) {
-    case PixelFormat::RGBA8_SRGB:
+    case PixelFormat::A8B8G8R8_SRGB:
-    case PixelFormat::BGRA8_SRGB:
+    case PixelFormat::B8G8R8A8_SRGB:
-    case PixelFormat::DXT1_SRGB:
+    case PixelFormat::BC1_RGBA_SRGB:
-    case PixelFormat::DXT23_SRGB:
+    case PixelFormat::BC2_SRGB:
-    case PixelFormat::DXT45_SRGB:
+    case PixelFormat::BC3_SRGB:
-    case PixelFormat::BC7U_SRGB:
+    case PixelFormat::BC7_SRGB:
    case PixelFormat::ASTC_2D_4X4_SRGB:
    case PixelFormat::ASTC_2D_8X8_SRGB:
    case PixelFormat::ASTC_2D_8X5_SRGB:
@@ -269,25 +283,4 @@ std::pair<u32, u32> GetASTCBlockSize(PixelFormat format) {
    return {GetDefaultBlockWidth(format), GetDefaultBlockHeight(format)};
 }
-bool IsFormatBCn(PixelFormat format) {
-    switch (format) {
-    case PixelFormat::DXT1:
-    case PixelFormat::DXT23:
-    case PixelFormat::DXT45:
-    case PixelFormat::DXN1:
-    case PixelFormat::DXN2SNORM:
-    case PixelFormat::DXN2UNORM:
-    case PixelFormat::BC7U:
-    case PixelFormat::BC6H_UF16:
-    case PixelFormat::BC6H_SF16:
-    case PixelFormat::DXT1_SRGB:
-    case PixelFormat::DXT23_SRGB:
-    case PixelFormat::DXT45_SRGB:
-    case PixelFormat::BC7U_SRGB:
-        return true;
-    default:
-        return false;
-    }
-}
 } // namespace VideoCore::Surface
diff --git a/src/video_core/surface.h b/src/video_core/surface.h
index 6da6a1b97..cfd12fa61 100644
--- a/src/video_core/surface.h
+++ b/src/video_core/surface.h
@@ -15,94 +15,105 @@
 namespace VideoCore::Surface {
 enum class PixelFormat {
-    ABGR8U = 0,
+    A8B8G8R8_UNORM,
-    ABGR8S = 1,
+    A8B8G8R8_SNORM,
-    ABGR8UI = 2,
+    A8B8G8R8_SINT,
-    B5G6R5U = 3,
+    A8B8G8R8_UINT,
-    A2B10G10R10U = 4,
+    R5G6B5_UNORM,
-    A1B5G5R5U = 5,
+    B5G6R5_UNORM,
-    R8U = 6,
+    A1R5G5B5_UNORM,
-    R8UI = 7,
+    A2B10G10R10_UNORM,
-    RGBA16F = 8,
+    A2B10G10R10_UINT,
-    RGBA16U = 9,
+    A1B5G5R5_UNORM,
-    RGBA16S = 10,
+    R8_UNORM,
-    RGBA16UI = 11,
+    R8_SNORM,
-    R11FG11FB10F = 12,
+    R8_SINT,
-    RGBA32UI = 13,
+    R8_UINT,
-    DXT1 = 14,
+    R16G16B16A16_FLOAT,
-    DXT23 = 15,
+    R16G16B16A16_UNORM,
-    DXT45 = 16,
+    R16G16B16A16_SNORM,
-    DXN1 = 17, // This is also known as BC4
+    R16G16B16A16_SINT,
-    DXN2UNORM = 18,
+    R16G16B16A16_UINT,
-    DXN2SNORM = 19,
+    B10G11R11_FLOAT,
-    BC7U = 20,
+    R32G32B32A32_UINT,
-    BC6H_UF16 = 21,
+    BC1_RGBA_UNORM,
-    BC6H_SF16 = 22,
+    BC2_UNORM,
-    ASTC_2D_4X4 = 23,
+    BC3_UNORM,
-    BGRA8 = 24,
+    BC4_UNORM,
-    RGBA32F = 25,
+    BC4_SNORM,
-    RG32F = 26,
+    BC5_UNORM,
-    R32F = 27,
+    BC5_SNORM,
-    R16F = 28,
+    BC7_UNORM,
-    R16U = 29,
+    BC6H_UFLOAT,
-    R16S = 30,
+    BC6H_SFLOAT,
-    R16UI = 31,
+    ASTC_2D_4X4_UNORM,
-    R16I = 32,
+    B8G8R8A8_UNORM,
-    RG16 = 33,
+    R32G32B32A32_FLOAT,
-    RG16F = 34,
+    R32G32B32A32_SINT,
-    RG16UI = 35,
+    R32G32_FLOAT,
-    RG16I = 36,
+    R32G32_SINT,
-    RG16S = 37,
+    R32_FLOAT,
-    RGB32F = 38,
+    R16_FLOAT,
-    RGBA8_SRGB = 39,
+    R16_UNORM,
-    RG8U = 40,
+    R16_SNORM,
-    RG8S = 41,
+    R16_UINT,
-    RG8UI = 42,
+    R16_SINT,
-    RG32UI = 43,
+    R16G16_UNORM,
-    RGBX16F = 44,
+    R16G16_FLOAT,
-    R32UI = 45,
+    R16G16_UINT,
-    R32I = 46,
+    R16G16_SINT,
-    ASTC_2D_8X8 = 47,
+    R16G16_SNORM,
-    ASTC_2D_8X5 = 48,
+    R32G32B32_FLOAT,
-    ASTC_2D_5X4 = 49,
+    A8B8G8R8_SRGB,
-    BGRA8_SRGB = 50,
+    R8G8_UNORM,
-    DXT1_SRGB = 51,
+    R8G8_SNORM,
-    DXT23_SRGB = 52,
+    R8G8_SINT,
-    DXT45_SRGB = 53,
+    R8G8_UINT,
-    BC7U_SRGB = 54,
+    R32G32_UINT,
-    R4G4B4A4U = 55,
+    R16G16B16X16_FLOAT,
-    ASTC_2D_4X4_SRGB = 56,
+    R32_UINT,
-    ASTC_2D_8X8_SRGB = 57,
+    R32_SINT,
-    ASTC_2D_8X5_SRGB = 58,
+    ASTC_2D_8X8_UNORM,
-    ASTC_2D_5X4_SRGB = 59,
+    ASTC_2D_8X5_UNORM,
-    ASTC_2D_5X5 = 60,
+    ASTC_2D_5X4_UNORM,
-    ASTC_2D_5X5_SRGB = 61,
+    B8G8R8A8_SRGB,
-    ASTC_2D_10X8 = 62,
+    BC1_RGBA_SRGB,
-    ASTC_2D_10X8_SRGB = 63,
+    BC2_SRGB,
-    ASTC_2D_6X6 = 64,
+    BC3_SRGB,
-    ASTC_2D_6X6_SRGB = 65,
+    BC7_SRGB,
-    ASTC_2D_10X10 = 66,
+    A4B4G4R4_UNORM,
-    ASTC_2D_10X10_SRGB = 67,
+    ASTC_2D_4X4_SRGB,
-    ASTC_2D_12X12 = 68,
+    ASTC_2D_8X8_SRGB,
-    ASTC_2D_12X12_SRGB = 69,
+    ASTC_2D_8X5_SRGB,
-    ASTC_2D_8X6 = 70,
+    ASTC_2D_5X4_SRGB,
-    ASTC_2D_8X6_SRGB = 71,
+    ASTC_2D_5X5_UNORM,
-    ASTC_2D_6X5 = 72,
+    ASTC_2D_5X5_SRGB,
-    ASTC_2D_6X5_SRGB = 73,
+    ASTC_2D_10X8_UNORM,
-    E5B9G9R9F = 74,
+    ASTC_2D_10X8_SRGB,
+    ASTC_2D_6X6_UNORM,
+    ASTC_2D_6X6_SRGB,
+    ASTC_2D_10X10_UNORM,
+    ASTC_2D_10X10_SRGB,
+    ASTC_2D_12X12_UNORM,
+    ASTC_2D_12X12_SRGB,
+    ASTC_2D_8X6_UNORM,
+    ASTC_2D_8X6_SRGB,
+    ASTC_2D_6X5_UNORM,
+    ASTC_2D_6X5_SRGB,
+    E5B9G9R9_FLOAT,
    MaxColorFormat,
    // Depth formats
-    Z32F = 75,
+    D32_FLOAT = MaxColorFormat,
-    Z16 = 76,
+    D16_UNORM,
    MaxDepthFormat,
    // DepthStencil formats
-    Z24S8 = 77,
+    D24_UNORM_S8_UINT = MaxDepthFormat,
-    S8Z24 = 78,
+    S8_UINT_D24_UNORM,
-    Z32FS8 = 79,
+    D32_FLOAT_S8_UINT,
    MaxDepthStencilFormat,
@@ -130,86 +141,97 @@ enum class SurfaceTarget {
 };
 constexpr std::array<u32, MaxPixelFormat> compression_factor_shift_table = {{
-    0, // ABGR8U
+    0, // A8B8G8R8_UNORM
-    0, // ABGR8S
+    0, // A8B8G8R8_SNORM
-    0, // ABGR8UI
+    0, // A8B8G8R8_SINT
-    0, // B5G6R5U
+    0, // A8B8G8R8_UINT
-    0, // A2B10G10R10U
+    0, // R5G6B5_UNORM
-    0, // A1B5G5R5U
+    0, // B5G6R5_UNORM
-    0, // R8U
+    0, // A1R5G5B5_UNORM
-    0, // R8UI
+    0, // A2B10G10R10_UNORM
-    0, // RGBA16F
+    0, // A2B10G10R10_UINT
-    0, // RGBA16U
+    0, // A1B5G5R5_UNORM
-    0, // RGBA16S
+    0, // R8_UNORM
-    0, // RGBA16UI
+    0, // R8_SNORM
-    0, // R11FG11FB10F
+    0, // R8_SINT
-    0, // RGBA32UI
+    0, // R8_UINT
-    2, // DXT1
+    0, // R16G16B16A16_FLOAT
-    2, // DXT23
+    0, // R16G16B16A16_UNORM
-    2, // DXT45
+    0, // R16G16B16A16_SNORM
-    2, // DXN1
+    0, // R16G16B16A16_SINT
-    2, // DXN2UNORM
+    0, // R16G16B16A16_UINT
-    2, // DXN2SNORM
+    0, // B10G11R11_FLOAT
-    2, // BC7U
+    0, // R32G32B32A32_UINT
-    2, // BC6H_UF16
+    2, // BC1_RGBA_UNORM
-    2, // BC6H_SF16
+    2, // BC2_UNORM
-    2, // ASTC_2D_4X4
+    2, // BC3_UNORM
-    0, // BGRA8
+    2, // BC4_UNORM
-    0, // RGBA32F
+    2, // BC4_SNORM
-    0, // RG32F
+    2, // BC5_UNORM
-    0, // R32F
+    2, // BC5_SNORM
-    0, // R16F
+    2, // BC7_UNORM
-    0, // R16U
+    2, // BC6H_UFLOAT
-    0, // R16S
+    2, // BC6H_SFLOAT
-    0, // R16UI
+    2, // ASTC_2D_4X4_UNORM
-    0, // R16I
+    0, // B8G8R8A8_UNORM
-    0, // RG16
+    0, // R32G32B32A32_FLOAT
-    0, // RG16F
+    0, // R32G32B32A32_SINT
-    0, // RG16UI
+    0, // R32G32_FLOAT
-    0, // RG16I
+    0, // R32G32_SINT
-    0, // RG16S
+    0, // R32_FLOAT
-    0, // RGB32F
+    0, // R16_FLOAT
-    0, // RGBA8_SRGB
+    0, // R16_UNORM
-    0, // RG8U
+    0, // R16_SNORM
-    0, // RG8S
+    0, // R16_UINT
-    0, // RG8UI
+    0, // R16_SINT
-    0, // RG32UI
+    0, // R16G16_UNORM
-    0, // RGBX16F
+    0, // R16G16_FLOAT
-    0, // R32UI
+    0, // R16G16_UINT
-    0, // R32I
+    0, // R16G16_SINT
-    2, // ASTC_2D_8X8
+    0, // R16G16_SNORM
-    2, // ASTC_2D_8X5
+    0, // R32G32B32_FLOAT
-    2, // ASTC_2D_5X4
+    0, // A8B8G8R8_SRGB
-    0, // BGRA8_SRGB
+    0, // R8G8_UNORM
-    2, // DXT1_SRGB
+    0, // R8G8_SNORM
-    2, // DXT23_SRGB
+    0, // R8G8_SINT
-    2, // DXT45_SRGB
+    0, // R8G8_UINT
-    2, // BC7U_SRGB
+    0, // R32G32_UINT
-    0, // R4G4B4A4U
+    0, // R16G16B16X16_FLOAT
+    0, // R32_UINT
+    0, // R32_SINT
+    2, // ASTC_2D_8X8_UNORM
+    2, // ASTC_2D_8X5_UNORM
+    2, // ASTC_2D_5X4_UNORM
+    0, // B8G8R8A8_SRGB
+    2, // BC1_RGBA_SRGB
+    2, // BC2_SRGB
+    2, // BC3_SRGB
+    2, // BC7_SRGB
+    0, // A4B4G4R4_UNORM
    2, // ASTC_2D_4X4_SRGB
    2, // ASTC_2D_8X8_SRGB
    2, // ASTC_2D_8X5_SRGB
    2, // ASTC_2D_5X4_SRGB
-    2, // ASTC_2D_5X5
+    2, // ASTC_2D_5X5_UNORM
    2, // ASTC_2D_5X5_SRGB
-    2, // ASTC_2D_10X8
+    2, // ASTC_2D_10X8_UNORM
    2, // ASTC_2D_10X8_SRGB
-    2, // ASTC_2D_6X6
+    2, // ASTC_2D_6X6_UNORM
    2, // ASTC_2D_6X6_SRGB
-    2, // ASTC_2D_10X10
+    2, // ASTC_2D_10X10_UNORM
    2, // ASTC_2D_10X10_SRGB
-    2, // ASTC_2D_12X12
+    2, // ASTC_2D_12X12_UNORM
    2, // ASTC_2D_12X12_SRGB
-    2, // ASTC_2D_8X6
+    2, // ASTC_2D_8X6_UNORM
    2, // ASTC_2D_8X6_SRGB
-    2, // ASTC_2D_6X5
+    2, // ASTC_2D_6X5_UNORM
    2, // ASTC_2D_6X5_SRGB
-    0, // E5B9G9R9F
+    0, // E5B9G9R9_FLOAT
-    0, // Z32F
+    0, // D32_FLOAT
-    0, // Z16
+    0, // D16_UNORM
-    0, // Z24S8
+    0, // D24_UNORM_S8_UINT
-    0, // S8Z24
+    0, // S8_UINT_D24_UNORM
-    0, // Z32FS8
+    0, // D32_FLOAT_S8_UINT
 }};
 /**
@@ -229,86 +251,97 @@ inline constexpr u32 GetCompressionFactor(PixelFormat format) {
 }
 constexpr std::array<u32, MaxPixelFormat> block_width_table = {{
-    1,  // ABGR8U
+    1,  // A8B8G8R8_UNORM
-    1,  // ABGR8S
+    1,  // A8B8G8R8_SNORM
-    1,  // ABGR8UI
+    1,  // A8B8G8R8_SINT
-    1,  // B5G6R5U
+    1,  // A8B8G8R8_UINT
-    1,  // A2B10G10R10U
+    1,  // R5G6B5_UNORM
-    1,  // A1B5G5R5U
+    1,  // B5G6R5_UNORM
-    1,  // R8U
+    1,  // A1R5G5B5_UNORM
-    1,  // R8UI
+    1,  // A2B10G10R10_UNORM
-    1,  // RGBA16F
+    1,  // A2B10G10R10_UINT
-    1,  // RGBA16U
+    1,  // A1B5G5R5_UNORM
-    1,  // RGBA16S
+    1,  // R8_UNORM
-    1,  // RGBA16UI
+    1,  // R8_SNORM
-    1,  // R11FG11FB10F
+    1,  // R8_SINT
-    1,  // RGBA32UI
+    1,  // R8_UINT
-    4,  // DXT1
+    1,  // R16G16B16A16_FLOAT
-    4,  // DXT23
+    1,  // R16G16B16A16_UNORM
-    4,  // DXT45
+    1,  // R16G16B16A16_SNORM
-    4,  // DXN1
+    1,  // R16G16B16A16_SINT
-    4,  // DXN2UNORM
+    1,  // R16G16B16A16_UINT
-    4,  // DXN2SNORM
+    1,  // B10G11R11_FLOAT
-    4,  // BC7U
+    1,  // R32G32B32A32_UINT
-    4,  // BC6H_UF16
+    4,  // BC1_RGBA_UNORM
-    4,  // BC6H_SF16
+    4,  // BC2_UNORM
-    4,  // ASTC_2D_4X4
+    4,  // BC3_UNORM
-    1,  // BGRA8
+    4,  // BC4_UNORM
-    1,  // RGBA32F
+    4,  // BC4_SNORM
-    1,  // RG32F
+    4,  // BC5_UNORM
-    1,  // R32F
+    4,  // BC5_SNORM
-    1,  // R16F
+    4,  // BC7_UNORM
-    1,  // R16U
+    4,  // BC6H_UFLOAT
-    1,  // R16S
+    4,  // BC6H_SFLOAT
-    1,  // R16UI
+    4,  // ASTC_2D_4X4_UNORM
-    1,  // R16I
+    1,  // B8G8R8A8_UNORM
-    1,  // RG16
+    1,  // R32G32B32A32_FLOAT
-    1,  // RG16F
+    1,  // R32G32B32A32_SINT
-    1,  // RG16UI
+    1,  // R32G32_FLOAT
-    1,  // RG16I
+    1,  // R32G32_SINT
-    1,  // RG16S
+    1,  // R32_FLOAT
-    1,  // RGB32F
+    1,  // R16_FLOAT
-    1,  // RGBA8_SRGB
+    1,  // R16_UNORM
-    1,  // RG8U
+    1,  // R16_SNORM
-    1,  // RG8S
+    1,  // R16_UINT
-    1,  // RG8UI
+    1,  // R16_SINT
-    1,  // RG32UI
+    1,  // R16G16_UNORM
-    1,  // RGBX16F
+    1,  // R16G16_FLOAT
-    1,  // R32UI
+    1,  // R16G16_UINT
-    1,  // R32I
+    1,  // R16G16_SINT
-    8,  // ASTC_2D_8X8
+    1,  // R16G16_SNORM
-    8,  // ASTC_2D_8X5
+    1,  // R32G32B32_FLOAT
-    5,  // ASTC_2D_5X4
+    1,  // A8B8G8R8_SRGB
-    1,  // BGRA8_SRGB
+    1,  // R8G8_UNORM
-    4,  // DXT1_SRGB
+    1,  // R8G8_SNORM
-    4,  // DXT23_SRGB
+    1,  // R8G8_SINT
-    4,  // DXT45_SRGB
+    1,  // R8G8_UINT
-    4,  // BC7U_SRGB
+    1,  // R32G32_UINT
-    1,  // R4G4B4A4U
+    1,  // R16G16B16X16_FLOAT
+    1,  // R32_UINT
+    1,  // R32_SINT
+    8,  // ASTC_2D_8X8_UNORM
+    8,  // ASTC_2D_8X5_UNORM
+    5,  // ASTC_2D_5X4_UNORM
+    1,  // B8G8R8A8_SRGB
+    4,  // BC1_RGBA_SRGB
+    4,  // BC2_SRGB
+    4,  // BC3_SRGB
+    4,  // BC7_SRGB
+    1,  // A4B4G4R4_UNORM
    4,  // ASTC_2D_4X4_SRGB
    8,  // ASTC_2D_8X8_SRGB
    8,  // ASTC_2D_8X5_SRGB
    5,  // ASTC_2D_5X4_SRGB
-    5,  // ASTC_2D_5X5
+    5,  // ASTC_2D_5X5_UNORM
    5,  // ASTC_2D_5X5_SRGB
-    10, // ASTC_2D_10X8
+    10, // ASTC_2D_10X8_UNORM
    10, // ASTC_2D_10X8_SRGB
-    6,  // ASTC_2D_6X6
+    6,  // ASTC_2D_6X6_UNORM
    6,  // ASTC_2D_6X6_SRGB
-    10, // ASTC_2D_10X10
+    10, // ASTC_2D_10X10_UNORM
    10, // ASTC_2D_10X10_SRGB
-    12, // ASTC_2D_12X12
+    12, // ASTC_2D_12X12_UNORM
    12, // ASTC_2D_12X12_SRGB
-    8,  // ASTC_2D_8X6
+    8,  // ASTC_2D_8X6_UNORM
    8,  // ASTC_2D_8X6_SRGB
-    6,  // ASTC_2D_6X5
+    6,  // ASTC_2D_6X5_UNORM
    6,  // ASTC_2D_6X5_SRGB
-    1,  // E5B9G9R9F
+    1,  // E5B9G9R9_FLOAT
-    1,  // Z32F
+    1,  // D32_FLOAT
-    1,  // Z16
+    1,  // D16_UNORM
-    1,  // Z24S8
+    1,  // D24_UNORM_S8_UINT
-    1,  // S8Z24
+    1,  // S8_UINT_D24_UNORM
-    1,  // Z32FS8
+    1,  // D32_FLOAT_S8_UINT
 }};
 static constexpr u32 GetDefaultBlockWidth(PixelFormat format) {
@@ -320,86 +353,97 @@ static constexpr u32 GetDefaultBlockWidth(PixelFormat format) {
 }
 constexpr std::array<u32, MaxPixelFormat> block_height_table = {{
-    1,  // ABGR8U
+    1,  // A8B8G8R8_UNORM
-    1,  // ABGR8S
+    1,  // A8B8G8R8_SNORM
-    1,  // ABGR8UI
+    1,  // A8B8G8R8_SINT
-    1,  // B5G6R5U
+    1,  // A8B8G8R8_UINT
-    1,  // A2B10G10R10U
+    1,  // R5G6B5_UNORM
-    1,  // A1B5G5R5U
+    1,  // B5G6R5_UNORM
-    1,  // R8U
+    1,  // A1R5G5B5_UNORM
-    1,  // R8UI
+    1,  // A2B10G10R10_UNORM
-    1,  // RGBA16F
+    1,  // A2B10G10R10_UINT
-    1,  // RGBA16U
+    1,  // A1B5G5R5_UNORM
-    1,  // RGBA16S
+    1,  // R8_UNORM
-    1,  // RGBA16UI
+    1,  // R8_SNORM
-    1,  // R11FG11FB10F
+    1,  // R8_SINT
-    1,  // RGBA32UI
+    1,  // R8_UINT
-    4,  // DXT1
+    1,  // R16G16B16A16_FLOAT
-    4,  // DXT23
+    1,  // R16G16B16A16_UNORM
-    4,  // DXT45
+    1,  // R16G16B16A16_SNORM
-    4,  // DXN1
+    1,  // R16G16B16A16_SINT
-    4,  // DXN2UNORM
+    1,  // R16G16B16A16_UINT
-    4,  // DXN2SNORM
+    1,  // B10G11R11_FLOAT
-    4,  // BC7U
+    1,  // R32G32B32A32_UINT
-    4,  // BC6H_UF16
+    4,  // BC1_RGBA_UNORM
-    4,  // BC6H_SF16
+    4,  // BC2_UNORM
-    4,  // ASTC_2D_4X4
+    4,  // BC3_UNORM
-    1,  // BGRA8
+    4,  // BC4_UNORM
-    1,  // RGBA32F
+    4,  // BC4_SNORM
-    1,  // RG32F
+    4,  // BC5_UNORM
-    1,  // R32F
+    4,  // BC5_SNORM
-    1,  // R16F
+    4,  // BC7_UNORM
-    1,  // R16U
+    4,  // BC6H_UFLOAT
-    1,  // R16S
+    4,  // BC6H_SFLOAT
-    1,  // R16UI
+    4,  // ASTC_2D_4X4_UNORM
-    1,  // R16I
+    1,  // B8G8R8A8_UNORM
-    1,  // RG16
+    1,  // R32G32B32A32_FLOAT
-    1,  // RG16F
+    1,  // R32G32B32A32_SINT
-    1,  // RG16UI
+    1,  // R32G32_FLOAT
-    1,  // RG16I
+    1,  // R32G32_SINT
-    1,  // RG16S
+    1,  // R32_FLOAT
-    1,  // RGB32F
+    1,  // R16_FLOAT
-    1,  // RGBA8_SRGB
+    1,  // R16_UNORM
-    1,  // RG8U
+    1,  // R16_SNORM
-    1,  // RG8S
+    1,  // R16_UINT
-    1,  // RG8UI
+    1,  // R16_SINT
-    1,  // RG32UI
+    1,  // R16G16_UNORM
-    1,  // RGBX16F
+    1,  // R16G16_FLOAT
-    1,  // R32UI
+    1,  // R16G16_UINT
-    1,  // R32I
+    1,  // R16G16_SINT
-    8,  // ASTC_2D_8X8
+    1,  // R16G16_SNORM
-    5,  // ASTC_2D_8X5
+    1,  // R32G32B32_FLOAT
-    4,  // ASTC_2D_5X4
+    1,  // A8B8G8R8_SRGB
-    1,  // BGRA8_SRGB
+    1,  // R8G8_UNORM
-    4,  // DXT1_SRGB
+    1,  // R8G8_SNORM
-    4,  // DXT23_SRGB
+    1,  // R8G8_SINT
-    4,  // DXT45_SRGB
+    1,  // R8G8_UINT
-    4,  // BC7U_SRGB
+    1,  // R32G32_UINT
-    1,  // R4G4B4A4U
+    1,  // R16G16B16X16_FLOAT
+    1,  // R32_UINT
+    1,  // R32_SINT
+    8,  // ASTC_2D_8X8_UNORM
+    5,  // ASTC_2D_8X5_UNORM
+    4,  // ASTC_2D_5X4_UNORM
+    1,  // B8G8R8A8_SRGB
+    4,  // BC1_RGBA_SRGB
+    4,  // BC2_SRGB
+    4,  // BC3_SRGB
+    4,  // BC7_SRGB
+    1,  // A4B4G4R4_UNORM
    4,  // ASTC_2D_4X4_SRGB
    8,  // ASTC_2D_8X8_SRGB
    5,  // ASTC_2D_8X5_SRGB
    4,  // ASTC_2D_5X4_SRGB
-    5,  // ASTC_2D_5X5
+    5,  // ASTC_2D_5X5_UNORM
    5,  // ASTC_2D_5X5_SRGB
-    8,  // ASTC_2D_10X8
+    8,  // ASTC_2D_10X8_UNORM
    8,  // ASTC_2D_10X8_SRGB
-    6,  // ASTC_2D_6X6
+    6,  // ASTC_2D_6X6_UNORM
    6,  // ASTC_2D_6X6_SRGB
-    10, // ASTC_2D_10X10
+    10, // ASTC_2D_10X10_UNORM
    10, // ASTC_2D_10X10_SRGB
-    12, // ASTC_2D_12X12
+    12, // ASTC_2D_12X12_UNORM
    12, // ASTC_2D_12X12_SRGB
-    6,  // ASTC_2D_8X6
+    6,  // ASTC_2D_8X6_UNORM
    6,  // ASTC_2D_8X6_SRGB
-    5,  // ASTC_2D_6X5
+    5,  // ASTC_2D_6X5_UNORM
    5,  // ASTC_2D_6X5_SRGB
-    1,  // E5B9G9R9F
+    1,  // E5B9G9R9_FLOAT
-    1,  // Z32F
+    1,  // D32_FLOAT
-    1,  // Z16
+    1,  // D16_UNORM
-    1,  // Z24S8
+    1,  // D24_UNORM_S8_UINT
-    1,  // S8Z24
+    1,  // S8_UINT_D24_UNORM
-    1,  // Z32FS8
+    1,  // D32_FLOAT_S8_UINT
 }};
 static constexpr u32 GetDefaultBlockHeight(PixelFormat format) {
@@ -411,86 +455,97 @@ static constexpr u32 GetDefaultBlockHeight(PixelFormat format) {
 }
 constexpr std::array<u32, MaxPixelFormat> bpp_table = {{
-    32,  // ABGR8U
+    32,  // A8B8G8R8_UNORM
-    32,  // ABGR8S
+    32,  // A8B8G8R8_SNORM
-    32,  // ABGR8UI
+    32,  // A8B8G8R8_SINT
-    16,  // B5G6R5U
+    32,  // A8B8G8R8_UINT
-    32,  // A2B10G10R10U
+    16,  // R5G6B5_UNORM
-    16,  // A1B5G5R5U
+    16,  // B5G6R5_UNORM
-    8,   // R8U
+    16,  // A1R5G5B5_UNORM
-    8,   // R8UI
+    32,  // A2B10G10R10_UNORM
-    64,  // RGBA16F
+    32,  // A2B10G10R10_UINT
-    64,  // RGBA16U
+    16,  // A1B5G5R5_UNORM
-    64,  // RGBA16S
+    8,   // R8_UNORM
-    64,  // RGBA16UI
+    8,   // R8_SNORM
-    32,  // R11FG11FB10F
+    8,   // R8_SINT
-    128, // RGBA32UI
+    8,   // R8_UINT
-    64,  // DXT1
+    64,  // R16G16B16A16_FLOAT
-    128, // DXT23
+    64,  // R16G16B16A16_UNORM
-    128, // DXT45
+    64,  // R16G16B16A16_SNORM
-    64,  // DXN1
+    64,  // R16G16B16A16_SINT
-    128, // DXN2UNORM
+    64,  // R16G16B16A16_UINT
-    128, // DXN2SNORM
+    32,  // B10G11R11_FLOAT
-    128, // BC7U
+    128, // R32G32B32A32_UINT
-    128, // BC6H_UF16
+    64,  // BC1_RGBA_UNORM
-    128, // BC6H_SF16
+    128, // BC2_UNORM
-    128, // ASTC_2D_4X4
+    128, // BC3_UNORM
-    32,  // BGRA8
+    64,  // BC4_UNORM
-    128, // RGBA32F
+    64,  // BC4_SNORM
-    64,  // RG32F
+    128, // BC5_UNORM
-    32,  // R32F
+    128, // BC5_SNORM
-    16,  // R16F
+    128, // BC7_UNORM
-    16,  // R16U
+    128, // BC6H_UFLOAT
-    16,  // R16S
+    128, // BC6H_SFLOAT
-    16,  // R16UI
+    128, // ASTC_2D_4X4_UNORM
-    16,  // R16I
+    32,  // B8G8R8A8_UNORM
-    32,  // RG16
+    128, // R32G32B32A32_FLOAT
-    32,  // RG16F
+    128, // R32G32B32A32_SINT
-    32,  // RG16UI
+    64,  // R32G32_FLOAT
-    32,  // RG16I
+    64,  // R32G32_SINT
-    32,  // RG16S
+    32,  // R32_FLOAT
-    96,  // RGB32F
+    16,  // R16_FLOAT
-    32,  // RGBA8_SRGB
+    16,  // R16_UNORM
-    16,  // RG8U
+    16,  // R16_SNORM
-    16,  // RG8S
+    16,  // R16_UINT
-    16,  // RG8UI
+    16,  // R16_SINT
-    64,  // RG32UI
+    32,  // R16G16_UNORM
-    64,  // RGBX16F
+    32,  // R16G16_FLOAT
-    32,  // R32UI
+    32,  // R16G16_UINT
-    32,  // R32I
+    32,  // R16G16_SINT
-    128, // ASTC_2D_8X8
+    32,  // R16G16_SNORM
-    128, // ASTC_2D_8X5
+    96,  // R32G32B32_FLOAT
-    128, // ASTC_2D_5X4
+    32,  // A8B8G8R8_SRGB
-    32,  // BGRA8_SRGB
+    16,  // R8G8_UNORM
-    64,  // DXT1_SRGB
+    16,  // R8G8_SNORM
-    128, // DXT23_SRGB
+    16,  // R8G8_SINT
-    128, // DXT45_SRGB
+    16,  // R8G8_UINT
-    128, // BC7U
+    64,  // R32G32_UINT
-    16,  // R4G4B4A4U
+    64,  // R16G16B16X16_FLOAT
+    32,  // R32_UINT
+    32,  // R32_SINT
+    128, // ASTC_2D_8X8_UNORM
+    128, // ASTC_2D_8X5_UNORM
+    128, // ASTC_2D_5X4_UNORM
+    32,  // B8G8R8A8_SRGB
+    64,  // BC1_RGBA_SRGB
+    128, // BC2_SRGB
+    128, // BC3_SRGB
+    128, // BC7_UNORM
+    16,  // A4B4G4R4_UNORM
    128, // ASTC_2D_4X4_SRGB
    128, // ASTC_2D_8X8_SRGB
    128, // ASTC_2D_8X5_SRGB
    128, // ASTC_2D_5X4_SRGB
-    128, // ASTC_2D_5X5
+    128, // ASTC_2D_5X5_UNORM
    128, // ASTC_2D_5X5_SRGB
-    128, // ASTC_2D_10X8
+    128, // ASTC_2D_10X8_UNORM
    128, // ASTC_2D_10X8_SRGB
-    128, // ASTC_2D_6X6
+    128, // ASTC_2D_6X6_UNORM
    128, // ASTC_2D_6X6_SRGB
-    128, // ASTC_2D_10X10
+    128, // ASTC_2D_10X10_UNORM
    128, // ASTC_2D_10X10_SRGB
-    128, // ASTC_2D_12X12
+    128, // ASTC_2D_12X12_UNORM
    128, // ASTC_2D_12X12_SRGB
-    128, // ASTC_2D_8X6
+    128, // ASTC_2D_8X6_UNORM
    128, // ASTC_2D_8X6_SRGB
-    128, // ASTC_2D_6X5
+    128, // ASTC_2D_6X5_UNORM
    128, // ASTC_2D_6X5_SRGB
-    32,  // E5B9G9R9F
+    32,  // E5B9G9R9_FLOAT
-    32,  // Z32F
+    32,  // D32_FLOAT
-    16,  // Z16
+    16,  // D16_UNORM
-    32,  // Z24S8
+    32,  // D24_UNORM_S8_UINT
-    32,  // S8Z24
+    32,  // S8_UINT_D24_UNORM
-    64,  // Z32FS8
+    64,  // D32_FLOAT_S8_UINT
 }};
 static constexpr u32 GetFormatBpp(PixelFormat format) {
@@ -529,7 +584,4 @@ bool IsPixelFormatSRGB(PixelFormat format);
 std::pair<u32, u32> GetASTCBlockSize(PixelFormat format);
-/// Returns true if the specified PixelFormat is a BCn format, e.g. DXT or DXN
-bool IsFormatBCn(PixelFormat format);
 } // namespace VideoCore::Surface
diff --git a/src/video_core/texture_cache/format_lookup_table.cpp b/src/video_core/texture_cache/format_lookup_table.cpp
index f476f03b0..7d5a75648 100644
--- a/src/video_core/texture_cache/format_lookup_table.cpp
+++ b/src/video_core/texture_cache/format_lookup_table.cpp
@@ -19,8 +19,6 @@ constexpr auto SNORM = ComponentType::SNORM;
 constexpr auto UNORM = ComponentType::UNORM;
 constexpr auto SINT = ComponentType::SINT;
 constexpr auto UINT = ComponentType::UINT;
-constexpr auto SNORM_FORCE_FP16 = ComponentType::SNORM_FORCE_FP16;
-constexpr auto UNORM_FORCE_FP16 = ComponentType::UNORM_FORCE_FP16;
 constexpr auto FLOAT = ComponentType::FLOAT;
 constexpr bool C = false; // Normal color
 constexpr bool S = true;  // Srgb
@@ -41,119 +39,126 @@ struct Table {
    ComponentType alpha_component;
    bool is_srgb;
 };
-constexpr std::array<Table, 78> DefinitionTable = {{
+constexpr std::array<Table, 86> DefinitionTable = {{
-    {TextureFormat::A8R8G8B8, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ABGR8U},
+    {TextureFormat::A8R8G8B8, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::A8B8G8R8_UNORM},
-    {TextureFormat::A8R8G8B8, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::ABGR8S},
+    {TextureFormat::A8R8G8B8, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::A8B8G8R8_SNORM},
-    {TextureFormat::A8R8G8B8, C, UINT, UINT, UINT, UINT, PixelFormat::ABGR8UI},
+    {TextureFormat::A8R8G8B8, C, UINT, UINT, UINT, UINT, PixelFormat::A8B8G8R8_UINT},
-    {TextureFormat::A8R8G8B8, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::RGBA8_SRGB},
+    {TextureFormat::A8R8G8B8, C, SINT, SINT, SINT, SINT, PixelFormat::A8B8G8R8_SINT},
+    {TextureFormat::A8R8G8B8, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::A8B8G8R8_SRGB},
-    {TextureFormat::B5G6R5, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::B5G6R5U},
+    {TextureFormat::B5G6R5, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::B5G6R5_UNORM},
-    {TextureFormat::A2B10G10R10, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::A2B10G10R10U},
+    {TextureFormat::A2B10G10R10, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::A2B10G10R10_UNORM},
+    {TextureFormat::A2B10G10R10, C, UINT, UINT, UINT, UINT, PixelFormat::A2B10G10R10_UINT},
-    {TextureFormat::A1B5G5R5, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::A1B5G5R5U},
+    {TextureFormat::A1B5G5R5, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::A1B5G5R5_UNORM},
-    {TextureFormat::A4B4G4R4, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::R4G4B4A4U},
+    {TextureFormat::A4B4G4R4, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::A4B4G4R4_UNORM},
-    {TextureFormat::R8, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::R8U},
+    {TextureFormat::R8, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::R8_UNORM},
-    {TextureFormat::R8, C, UINT, UINT, UINT, UINT, PixelFormat::R8UI},
+    {TextureFormat::R8, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::R8_SNORM},
+    {TextureFormat::R8, C, UINT, UINT, UINT, UINT, PixelFormat::R8_UINT},
+    {TextureFormat::R8, C, SINT, SINT, SINT, SINT, PixelFormat::R8_SINT},
-    {TextureFormat::G8R8, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::RG8U},
+    {TextureFormat::R8G8, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::R8G8_UNORM},
-    {TextureFormat::G8R8, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::RG8S},
+    {TextureFormat::R8G8, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::R8G8_SNORM},
-    {TextureFormat::G8R8, C, UINT, UINT, UINT, UINT, PixelFormat::RG8UI},
+    {TextureFormat::R8G8, C, UINT, UINT, UINT, UINT, PixelFormat::R8G8_UINT},
+    {TextureFormat::R8G8, C, SINT, SINT, SINT, SINT, PixelFormat::R8G8_SINT},
-    {TextureFormat::R16_G16_B16_A16, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::RGBA16S},
+    {TextureFormat::R16G16B16A16, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::R16G16B16A16_SNORM},
-    {TextureFormat::R16_G16_B16_A16, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::RGBA16U},
+    {TextureFormat::R16G16B16A16, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::R16G16B16A16_UNORM},
-    {TextureFormat::R16_G16_B16_A16, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::RGBA16F},
+    {TextureFormat::R16G16B16A16, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::R16G16B16A16_FLOAT},
-    {TextureFormat::R16_G16_B16_A16, C, UINT, UINT, UINT, UINT, PixelFormat::RGBA16UI},
+    {TextureFormat::R16G16B16A16, C, UINT, UINT, UINT, UINT, PixelFormat::R16G16B16A16_UINT},
+    {TextureFormat::R16G16B16A16, C, SINT, SINT, SINT, SINT, PixelFormat::R16G16B16A16_SINT},
-    {TextureFormat::R16_G16, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::RG16F},
+    {TextureFormat::R16G16, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::R16G16_FLOAT},
-    {TextureFormat::R16_G16, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::RG16},
+    {TextureFormat::R16G16, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::R16G16_UNORM},
-    {TextureFormat::R16_G16, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::RG16S},
+    {TextureFormat::R16G16, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::R16G16_SNORM},
-    {TextureFormat::R16_G16, C, UINT, UINT, UINT, UINT, PixelFormat::RG16UI},
+    {TextureFormat::R16G16, C, UINT, UINT, UINT, UINT, PixelFormat::R16G16_UINT},
-    {TextureFormat::R16_G16, C, SINT, SINT, SINT, SINT, PixelFormat::RG16I},
+    {TextureFormat::R16G16, C, SINT, SINT, SINT, SINT, PixelFormat::R16G16_SINT},
-    {TextureFormat::R16, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::R16F},
+    {TextureFormat::R16, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::R16_FLOAT},
-    {TextureFormat::R16, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::R16U},
+    {TextureFormat::R16, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::R16_UNORM},
-    {TextureFormat::R16, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::R16S},
+    {TextureFormat::R16, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::R16_SNORM},
-    {TextureFormat::R16, C, UINT, UINT, UINT, UINT, PixelFormat::R16UI},
+    {TextureFormat::R16, C, UINT, UINT, UINT, UINT, PixelFormat::R16_UINT},
-    {TextureFormat::R16, C, SINT, SINT, SINT, SINT, PixelFormat::R16I},
+    {TextureFormat::R16, C, SINT, SINT, SINT, SINT, PixelFormat::R16_SINT},
-    {TextureFormat::BF10GF11RF11, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::R11FG11FB10F},
+    {TextureFormat::B10G11R11, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::B10G11R11_FLOAT},
-    {TextureFormat::R32_G32_B32_A32, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::RGBA32F},
+    {TextureFormat::R32G32B32A32, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::R32G32B32A32_FLOAT},
-    {TextureFormat::R32_G32_B32_A32, C, UINT, UINT, UINT, UINT, PixelFormat::RGBA32UI},
+    {TextureFormat::R32G32B32A32, C, UINT, UINT, UINT, UINT, PixelFormat::R32G32B32A32_UINT},
+    {TextureFormat::R32G32B32A32, C, SINT, SINT, SINT, SINT, PixelFormat::R32G32B32A32_SINT},
-    {TextureFormat::R32_G32_B32, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::RGB32F},
+    {TextureFormat::R32G32B32, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::R32G32B32_FLOAT},
-    {TextureFormat::R32_G32, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::RG32F},
+    {TextureFormat::R32G32, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::R32G32_FLOAT},
-    {TextureFormat::R32_G32, C, UINT, UINT, UINT, UINT, PixelFormat::RG32UI},
+    {TextureFormat::R32G32, C, UINT, UINT, UINT, UINT, PixelFormat::R32G32_UINT},
+    {TextureFormat::R32G32, C, SINT, SINT, SINT, SINT, PixelFormat::R32G32_SINT},
-    {TextureFormat::R32, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::R32F},
+    {TextureFormat::R32, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::R32_FLOAT},
-    {TextureFormat::R32, C, UINT, UINT, UINT, UINT, PixelFormat::R32UI},
+    {TextureFormat::R32, C, UINT, UINT, UINT, UINT, PixelFormat::R32_UINT},
-    {TextureFormat::R32, C, SINT, SINT, SINT, SINT, PixelFormat::R32I},
+    {TextureFormat::R32, C, SINT, SINT, SINT, SINT, PixelFormat::R32_SINT},
-    {TextureFormat::E5B9G9R9_SHAREDEXP, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::E5B9G9R9F},
+    {TextureFormat::E5B9G9R9, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::E5B9G9R9_FLOAT},
-    {TextureFormat::ZF32, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::Z32F},
+    {TextureFormat::D32, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::D32_FLOAT},
-    {TextureFormat::Z16, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::Z16},
+    {TextureFormat::D16, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::D16_UNORM},
-    {TextureFormat::S8Z24, C, UINT, UNORM, UNORM, UNORM, PixelFormat::S8Z24},
+    {TextureFormat::S8D24, C, UINT, UNORM, UNORM, UNORM, PixelFormat::S8_UINT_D24_UNORM},
-    {TextureFormat::G24R8, C, UINT, UNORM, UNORM, UNORM, PixelFormat::S8Z24},
+    {TextureFormat::R8G24, C, UINT, UNORM, UNORM, UNORM, PixelFormat::S8_UINT_D24_UNORM},
-    {TextureFormat::ZF32_X24S8, C, FLOAT, UINT, UNORM, UNORM, PixelFormat::Z32FS8},
+    {TextureFormat::D32S8, C, FLOAT, UINT, UNORM, UNORM, PixelFormat::D32_FLOAT_S8_UINT},
-    {TextureFormat::DXT1, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::DXT1},
+    {TextureFormat::BC1_RGBA, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::BC1_RGBA_UNORM},
-    {TextureFormat::DXT1, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::DXT1_SRGB},
+    {TextureFormat::BC1_RGBA, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::BC1_RGBA_SRGB},
-    {TextureFormat::DXT23, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::DXT23},
+    {TextureFormat::BC2, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::BC2_UNORM},
-    {TextureFormat::DXT23, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::DXT23_SRGB},
+    {TextureFormat::BC2, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::BC2_SRGB},
-    {TextureFormat::DXT45, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::DXT45},
+    {TextureFormat::BC3, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::BC3_UNORM},
-    {TextureFormat::DXT45, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::DXT45_SRGB},
+    {TextureFormat::BC3, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::BC3_SRGB},
-    // TODO: Use a different pixel format for SNORM
+    {TextureFormat::BC4, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::BC4_UNORM},
-    {TextureFormat::DXN1, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::DXN1},
+    {TextureFormat::BC4, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::BC4_SNORM},
-    {TextureFormat::DXN1, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::DXN1},
-    {TextureFormat::DXN2, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::DXN2UNORM},
+    {TextureFormat::BC5, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::BC5_UNORM},
-    {TextureFormat::DXN2, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::DXN2SNORM},
+    {TextureFormat::BC5, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::BC5_SNORM},
-    {TextureFormat::BC7U, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::BC7U},
+    {TextureFormat::BC7, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::BC7_UNORM},
-    {TextureFormat::BC7U, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::BC7U_SRGB},
+    {TextureFormat::BC7, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::BC7_SRGB},
-    {TextureFormat::BC6H_SF16, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::BC6H_SF16},
+    {TextureFormat::BC6H_SFLOAT, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::BC6H_SFLOAT},
-    {TextureFormat::BC6H_UF16, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::BC6H_UF16},
+    {TextureFormat::BC6H_UFLOAT, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::BC6H_UFLOAT},
-    {TextureFormat::ASTC_2D_4X4, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_4X4},
+    {TextureFormat::ASTC_2D_4X4, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_4X4_UNORM},
    {TextureFormat::ASTC_2D_4X4, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_4X4_SRGB},
-    {TextureFormat::ASTC_2D_5X4, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_5X4},
+    {TextureFormat::ASTC_2D_5X4, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_5X4_UNORM},
    {TextureFormat::ASTC_2D_5X4, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_5X4_SRGB},
-    {TextureFormat::ASTC_2D_5X5, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_5X5},
+    {TextureFormat::ASTC_2D_5X5, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_5X5_UNORM},
    {TextureFormat::ASTC_2D_5X5, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_5X5_SRGB},
-    {TextureFormat::ASTC_2D_8X8, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_8X8},
+    {TextureFormat::ASTC_2D_8X8, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_8X8_UNORM},
    {TextureFormat::ASTC_2D_8X8, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_8X8_SRGB},
-    {TextureFormat::ASTC_2D_8X5, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_8X5},
+    {TextureFormat::ASTC_2D_8X5, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_8X5_UNORM},
    {TextureFormat::ASTC_2D_8X5, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_8X5_SRGB},
-    {TextureFormat::ASTC_2D_10X8, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_10X8},
+    {TextureFormat::ASTC_2D_10X8, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_10X8_UNORM},
    {TextureFormat::ASTC_2D_10X8, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_10X8_SRGB},
-    {TextureFormat::ASTC_2D_6X6, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_6X6},
+    {TextureFormat::ASTC_2D_6X6, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_6X6_UNORM},
    {TextureFormat::ASTC_2D_6X6, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_6X6_SRGB},
-    {TextureFormat::ASTC_2D_10X10, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_10X10},
+    {TextureFormat::ASTC_2D_10X10, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_10X10_UNORM},
    {TextureFormat::ASTC_2D_10X10, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_10X10_SRGB},
-    {TextureFormat::ASTC_2D_12X12, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_12X12},
+    {TextureFormat::ASTC_2D_12X12, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_12X12_UNORM},
    {TextureFormat::ASTC_2D_12X12, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_12X12_SRGB},
-    {TextureFormat::ASTC_2D_8X6, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_8X6},
+    {TextureFormat::ASTC_2D_8X6, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_8X6_UNORM},
    {TextureFormat::ASTC_2D_8X6, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_8X6_SRGB},
-    {TextureFormat::ASTC_2D_6X5, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_6X5},
+    {TextureFormat::ASTC_2D_6X5, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_6X5_UNORM},
    {TextureFormat::ASTC_2D_6X5, S, UNORM, UNORM, UNORM, UNORM, PixelFormat::ASTC_2D_6X5_SRGB},
 }};
@@ -184,7 +189,7 @@ PixelFormat FormatLookupTable::GetPixelFormat(TextureFormat format, bool is_srgb
                      static_cast<int>(format), is_srgb, static_cast<int>(red_component),
                      static_cast<int>(green_component), static_cast<int>(blue_component),
                      static_cast<int>(alpha_component));
-    return PixelFormat::ABGR8U;
+    return PixelFormat::A8B8G8R8_UNORM;
 }
 void FormatLookupTable::Set(TextureFormat format, bool is_srgb, ComponentType red_component,
diff --git a/src/video_core/texture_cache/surface_base.cpp b/src/video_core/texture_cache/surface_base.cpp
index 0caf3b4f0..dfcf36e0b 100644
--- a/src/video_core/texture_cache/surface_base.cpp
+++ b/src/video_core/texture_cache/surface_base.cpp
@@ -228,7 +228,7 @@ void SurfaceBaseImpl::LoadBuffer(Tegra::MemoryManager& memory_manager,
        }
    }
-    if (!is_converted && params.pixel_format != PixelFormat::S8Z24) {
+    if (!is_converted && params.pixel_format != PixelFormat::S8_UINT_D24_UNORM) {
        return;
    }
diff --git a/src/video_core/texture_cache/surface_params.cpp b/src/video_core/texture_cache/surface_params.cpp
index 921562c1f..9a98f0e98 100644
--- a/src/video_core/texture_cache/surface_params.cpp
+++ b/src/video_core/texture_cache/surface_params.cpp
@@ -74,21 +74,21 @@ SurfaceParams SurfaceParams::CreateForTexture(const FormatLookupTable& lookup_ta
    SurfaceParams params;
    params.is_tiled = tic.IsTiled();
    params.srgb_conversion = tic.IsSrgbConversionEnabled();
-    params.block_width = params.is_tiled ? tic.BlockWidth() : 0,
+    params.block_width = params.is_tiled ? tic.BlockWidth() : 0;
-    params.block_height = params.is_tiled ? tic.BlockHeight() : 0,
+    params.block_height = params.is_tiled ? tic.BlockHeight() : 0;
-    params.block_depth = params.is_tiled ? tic.BlockDepth() : 0,
+    params.block_depth = params.is_tiled ? tic.BlockDepth() : 0;
    params.tile_width_spacing = params.is_tiled ? (1 << tic.tile_width_spacing.Value()) : 1;
    params.pixel_format = lookup_table.GetPixelFormat(
        tic.format, params.srgb_conversion, tic.r_type, tic.g_type, tic.b_type, tic.a_type);
    params.type = GetFormatType(params.pixel_format);
    if (entry.is_shadow && params.type == SurfaceType::ColorTexture) {
        switch (params.pixel_format) {
-        case PixelFormat::R16U:
+        case PixelFormat::R16_UNORM:
-        case PixelFormat::R16F:
+        case PixelFormat::R16_FLOAT:
-            params.pixel_format = PixelFormat::Z16;
+            params.pixel_format = PixelFormat::D16_UNORM;
            break;
-        case PixelFormat::R32F:
+        case PixelFormat::R32_FLOAT:
-            params.pixel_format = PixelFormat::Z32F;
+            params.pixel_format = PixelFormat::D32_FLOAT;
            break;
        default:
            UNIMPLEMENTED_MSG("Unimplemented shadow convert format: {}",
@@ -130,14 +130,13 @@ SurfaceParams SurfaceParams::CreateForImage(const FormatLookupTable& lookup_tabl
    SurfaceParams params;
    params.is_tiled = tic.IsTiled();
    params.srgb_conversion = tic.IsSrgbConversionEnabled();
-    params.block_width = params.is_tiled ? tic.BlockWidth() : 0,
+    params.block_width = params.is_tiled ? tic.BlockWidth() : 0;
-    params.block_height = params.is_tiled ? tic.BlockHeight() : 0,
+    params.block_height = params.is_tiled ? tic.BlockHeight() : 0;
-    params.block_depth = params.is_tiled ? tic.BlockDepth() : 0,
+    params.block_depth = params.is_tiled ? tic.BlockDepth() : 0;
    params.tile_width_spacing = params.is_tiled ? (1 << tic.tile_width_spacing.Value()) : 1;
    params.pixel_format = lookup_table.GetPixelFormat(
        tic.format, params.srgb_conversion, tic.r_type, tic.g_type, tic.b_type, tic.a_type);
    params.type = GetFormatType(params.pixel_format);
-    params.type = GetFormatType(params.pixel_format);
    params.target = ImageTypeToSurfaceTarget(entry.type);
    // TODO: on 1DBuffer we should use the tic info.
    if (tic.IsBuffer()) {
@@ -167,27 +166,30 @@ SurfaceParams SurfaceParams::CreateForImage(const FormatLookupTable& lookup_tabl
 SurfaceParams SurfaceParams::CreateForDepthBuffer(Core::System& system) {
    const auto& regs = system.GPU().Maxwell3D().regs;
-    SurfaceParams params;
-    params.is_tiled = regs.zeta.memory_layout.type ==
-                      Tegra::Engines::Maxwell3D::Regs::InvMemoryLayout::BlockLinear;
-    params.srgb_conversion = false;
-    params.block_width = std::min(regs.zeta.memory_layout.block_width.Value(), 5U);
-    params.block_height = std::min(regs.zeta.memory_layout.block_height.Value(), 5U);
-    params.block_depth = std::min(regs.zeta.memory_layout.block_depth.Value(), 5U);
-    params.tile_width_spacing = 1;
-    params.pixel_format = PixelFormatFromDepthFormat(regs.zeta.format);
-    params.type = GetFormatType(params.pixel_format);
-    params.width = regs.zeta_width;
-    params.height = regs.zeta_height;
-    params.pitch = 0;
-    params.num_levels = 1;
-    params.emulated_levels = 1;
-    const bool is_layered = regs.zeta_layers > 1 && params.block_depth == 0;
+    const auto block_depth = std::min(regs.zeta.memory_layout.block_depth.Value(), 5U);
-    params.is_layered = is_layered;
+    const bool is_layered = regs.zeta_layers > 1 && block_depth == 0;
-    params.target = is_layered ? SurfaceTarget::Texture2DArray : SurfaceTarget::Texture2D;
+    const auto pixel_format = PixelFormatFromDepthFormat(regs.zeta.format);
-    params.depth = is_layered ? regs.zeta_layers.Value() : 1U;
-    return params;
+    return {
+        .is_tiled = regs.zeta.memory_layout.type ==
+                    Tegra::Engines::Maxwell3D::Regs::InvMemoryLayout::BlockLinear,
+        .srgb_conversion = false,
+        .is_layered = is_layered,
+        .block_width = std::min(regs.zeta.memory_layout.block_width.Value(), 5U),
+        .block_height = std::min(regs.zeta.memory_layout.block_height.Value(), 5U),
+        .block_depth = block_depth,
+        .tile_width_spacing = 1,
+        .width = regs.zeta_width,
+        .height = regs.zeta_height,
+        .depth = is_layered ? regs.zeta_layers.Value() : 1U,
+        .pitch = 0,
+        .num_levels = 1,
+        .emulated_levels = 1,
+        .pixel_format = pixel_format,
+        .type = GetFormatType(pixel_format),
+        .target = is_layered ? SurfaceTarget::Texture2DArray : SurfaceTarget::Texture2D,
+    };
 }
 SurfaceParams SurfaceParams::CreateForFramebuffer(Core::System& system, std::size_t index) {
@@ -195,8 +197,8 @@ SurfaceParams SurfaceParams::CreateForFramebuffer(Core::System& system, std::siz
    SurfaceParams params;
    params.is_tiled =
        config.memory_layout.type == Tegra::Engines::Maxwell3D::Regs::InvMemoryLayout::BlockLinear;
-    params.srgb_conversion = config.format == Tegra::RenderTargetFormat::BGRA8_SRGB ||
+    params.srgb_conversion = config.format == Tegra::RenderTargetFormat::B8G8R8A8_SRGB ||
-                             config.format == Tegra::RenderTargetFormat::RGBA8_SRGB;
+                             config.format == Tegra::RenderTargetFormat::A8B8G8R8_SRGB;
    params.block_width = config.memory_layout.block_width;
    params.block_height = config.memory_layout.block_height;
    params.block_depth = config.memory_layout.block_depth;
@@ -233,24 +235,29 @@ SurfaceParams SurfaceParams::CreateForFramebuffer(Core::System& system, std::siz
 SurfaceParams SurfaceParams::CreateForFermiCopySurface(
    const Tegra::Engines::Fermi2D::Regs::Surface& config) {
-    SurfaceParams params{};
+    const bool is_tiled = !config.linear;
-    params.is_tiled = !config.linear;
+    const auto pixel_format = PixelFormatFromRenderTargetFormat(config.format);
-    params.srgb_conversion = config.format == Tegra::RenderTargetFormat::BGRA8_SRGB ||
-                             config.format == Tegra::RenderTargetFormat::RGBA8_SRGB;
+    SurfaceParams params{
-    params.block_width = params.is_tiled ? std::min(config.BlockWidth(), 5U) : 0,
+        .is_tiled = is_tiled,
-    params.block_height = params.is_tiled ? std::min(config.BlockHeight(), 5U) : 0,
+        .srgb_conversion = config.format == Tegra::RenderTargetFormat::B8G8R8A8_SRGB ||
-    params.block_depth = params.is_tiled ? std::min(config.BlockDepth(), 5U) : 0,
+                           config.format == Tegra::RenderTargetFormat::A8B8G8R8_SRGB,
-    params.tile_width_spacing = 1;
+        .block_width = is_tiled ? std::min(config.BlockWidth(), 5U) : 0U,
-    params.pixel_format = PixelFormatFromRenderTargetFormat(config.format);
+        .block_height = is_tiled ? std::min(config.BlockHeight(), 5U) : 0U,
-    params.type = GetFormatType(params.pixel_format);
+        .block_depth = is_tiled ? std::min(config.BlockDepth(), 5U) : 0U,
-    params.width = config.width;
+        .tile_width_spacing = 1,
-    params.height = config.height;
+        .width = config.width,
-    params.pitch = config.pitch;
+        .height = config.height,
-    // TODO(Rodrigo): Try to guess texture arrays from parameters
+        .depth = 1,
-    params.target = SurfaceTarget::Texture2D;
+        .pitch = config.pitch,
-    params.depth = 1;
+        .num_levels = 1,
-    params.num_levels = 1;
+        .emulated_levels = 1,
-    params.emulated_levels = 1;
+        .pixel_format = pixel_format,
+        .type = GetFormatType(pixel_format),
+        // TODO(Rodrigo): Try to guess texture arrays from parameters
+        .target = SurfaceTarget::Texture2D,
+    };
    params.is_layered = params.IsLayered();
    return params;
 }
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index cdcddb225..96c4e4cc2 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -373,9 +373,9 @@ protected:
            siblings_table[static_cast<std::size_t>(b)] = a;
        };
        std::fill(siblings_table.begin(), siblings_table.end(), PixelFormat::Invalid);
-        make_siblings(PixelFormat::Z16, PixelFormat::R16U);
+        make_siblings(PixelFormat::D16_UNORM, PixelFormat::R16_UNORM);
-        make_siblings(PixelFormat::Z32F, PixelFormat::R32F);
+        make_siblings(PixelFormat::D32_FLOAT, PixelFormat::R32_FLOAT);
-        make_siblings(PixelFormat::Z32FS8, PixelFormat::RG32F);
+        make_siblings(PixelFormat::D32_FLOAT_S8_UINT, PixelFormat::R32G32_FLOAT);
        sampled_textures.reserve(64);
    }
@@ -1031,7 +1031,7 @@ private:
        params.pitch = 4;
        params.num_levels = 1;
        params.emulated_levels = 1;
-        params.pixel_format = VideoCore::Surface::PixelFormat::R8U;
+        params.pixel_format = VideoCore::Surface::PixelFormat::R8_UNORM;
        params.type = VideoCore::Surface::SurfaceType::ColorTexture;
        auto surface = CreateSurface(0ULL, params);
        invalid_memory.resize(surface->GetHostSizeInBytes(), 0U);
diff --git a/src/video_core/textures/convert.cpp b/src/video_core/textures/convert.cpp
index f3efa7eb0..962921483 100644
--- a/src/video_core/textures/convert.cpp
+++ b/src/video_core/textures/convert.cpp
@@ -35,7 +35,7 @@ void SwapS8Z24ToZ24S8(u8* data, u32 width, u32 height) {
    S8Z24 s8z24_pixel{};
    Z24S8 z24s8_pixel{};
    constexpr auto bpp{
-        VideoCore::Surface::GetBytesPerPixel(VideoCore::Surface::PixelFormat::S8Z24)};
+        VideoCore::Surface::GetBytesPerPixel(VideoCore::Surface::PixelFormat::S8_UINT_D24_UNORM)};
    for (std::size_t y = 0; y < height; ++y) {
        for (std::size_t x = 0; x < width; ++x) {
            const std::size_t offset{bpp * (y * width + x)};
@@ -73,7 +73,7 @@ void ConvertFromGuestToHost(u8* in_data, u8* out_data, PixelFormat pixel_format,
            in_data, width, height, depth, block_width, block_height);
        std::copy(rgba8_data.begin(), rgba8_data.end(), out_data);
-    } else if (convert_s8z24 && pixel_format == PixelFormat::S8Z24) {
+    } else if (convert_s8z24 && pixel_format == PixelFormat::S8_UINT_D24_UNORM) {
        Tegra::Texture::ConvertS8Z24ToZ24S8(in_data, width, height);
    }
 }
@@ -85,7 +85,7 @@ void ConvertFromHostToGuest(u8* data, PixelFormat pixel_format, u32 width, u32 h
                     static_cast<u32>(pixel_format));
        UNREACHABLE();
-    } else if (convert_s8z24 && pixel_format == PixelFormat::S8Z24) {
+    } else if (convert_s8z24 && pixel_format == PixelFormat::S8_UINT_D24_UNORM) {
        Tegra::Texture::ConvertZ24S8ToS8Z24(data, width, height);
    }
 }
diff --git a/src/video_core/textures/decoders.cpp b/src/video_core/textures/decoders.cpp
index 98beabef1..474ae620a 100644
--- a/src/video_core/textures/decoders.cpp
+++ b/src/video_core/textures/decoders.cpp
@@ -184,53 +184,6 @@ void CopySwizzledData(u32 width, u32 height, u32 depth, u32 bytes_per_pixel,
    }
 }
-u32 BytesPerPixel(TextureFormat format) {
-    switch (format) {
-    case TextureFormat::DXT1:
-    case TextureFormat::DXN1:
-        // In this case a 'pixel' actually refers to a 4x4 tile.
-        return 8;
-    case TextureFormat::DXT23:
-    case TextureFormat::DXT45:
-    case TextureFormat::DXN2:
-    case TextureFormat::BC7U:
-    case TextureFormat::BC6H_UF16:
-    case TextureFormat::BC6H_SF16:
-        // In this case a 'pixel' actually refers to a 4x4 tile.
-        return 16;
-    case TextureFormat::R32_G32_B32:
-        return 12;
-    case TextureFormat::ASTC_2D_4X4:
-    case TextureFormat::ASTC_2D_5X4:
-    case TextureFormat::ASTC_2D_8X8:
-    case TextureFormat::ASTC_2D_8X5:
-    case TextureFormat::ASTC_2D_10X8:
-    case TextureFormat::ASTC_2D_5X5:
-    case TextureFormat::A8R8G8B8:
-    case TextureFormat::A2B10G10R10:
-    case TextureFormat::BF10GF11RF11:
-    case TextureFormat::R32:
-    case TextureFormat::R16_G16:
-        return 4;
-    case TextureFormat::A1B5G5R5:
-    case TextureFormat::B5G6R5:
-    case TextureFormat::G8R8:
-    case TextureFormat::R16:
-        return 2;
-    case TextureFormat::R8:
-        return 1;
-    case TextureFormat::R16_G16_B16_A16:
-        return 8;
-    case TextureFormat::R32_G32_B32_A32:
-        return 16;
-    case TextureFormat::R32_G32:
-        return 8;
-    default:
-        UNIMPLEMENTED_MSG("Format not implemented");
-        return 1;
-    }
-}
 void UnswizzleTexture(u8* const unswizzled_data, u8* address, u32 tile_size_x, u32 tile_size_y,
                      u32 bytes_per_pixel, u32 width, u32 height, u32 depth, u32 block_height,
                      u32 block_depth, u32 width_spacing) {
@@ -348,48 +301,6 @@ void SwizzleKepler(const u32 width, const u32 height, const u32 dst_x, const u32
    }
 }
-std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat format, u32 width,
-                              u32 height) {
-    std::vector<u8> rgba_data;
-    // TODO(Subv): Implement.
-    switch (format) {
-    case TextureFormat::DXT1:
-    case TextureFormat::DXT23:
-    case TextureFormat::DXT45:
-    case TextureFormat::DXN1:
-    case TextureFormat::DXN2:
-    case TextureFormat::BC7U:
-    case TextureFormat::BC6H_UF16:
-    case TextureFormat::BC6H_SF16:
-    case TextureFormat::ASTC_2D_4X4:
-    case TextureFormat::ASTC_2D_8X8:
-    case TextureFormat::ASTC_2D_5X5:
-    case TextureFormat::ASTC_2D_10X8:
-    case TextureFormat::A8R8G8B8:
-    case TextureFormat::A2B10G10R10:
-    case TextureFormat::A1B5G5R5:
-    case TextureFormat::B5G6R5:
-    case TextureFormat::R8:
-    case TextureFormat::G8R8:
-    case TextureFormat::BF10GF11RF11:
-    case TextureFormat::R32_G32_B32_A32:
-    case TextureFormat::R32_G32:
-    case TextureFormat::R32:
-    case TextureFormat::R16:
-    case TextureFormat::R16_G16:
-    case TextureFormat::R32_G32_B32:
-        // TODO(Subv): For the time being just forward the same data without any decoding.
-        rgba_data = texture_data;
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Format not implemented");
-        break;
-    }
-    return rgba_data;
-}
 std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
                          u32 block_height, u32 block_depth) {
    if (tiled) {
diff --git a/src/video_core/textures/decoders.h b/src/video_core/textures/decoders.h
index 232b696b3..d6fe35d37 100644
--- a/src/video_core/textures/decoders.h
+++ b/src/video_core/textures/decoders.h
@@ -38,10 +38,6 @@ void CopySwizzledData(u32 width, u32 height, u32 depth, u32 bytes_per_pixel,
                      u32 out_bytes_per_pixel, u8* swizzled_data, u8* unswizzled_data,
                      bool unswizzle, u32 block_height, u32 block_depth, u32 width_spacing);
-/// Decodes an unswizzled texture into a A8R8G8B8 texture.
-std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat format, u32 width,
-                              u32 height);
 /// This function calculates the correct size of a texture depending if it's tiled or not.
 std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
                          u32 block_height, u32 block_depth);
diff --git a/src/video_core/textures/texture.h b/src/video_core/textures/texture.h
index eba05aced..0574fef12 100644
--- a/src/video_core/textures/texture.h
+++ b/src/video_core/textures/texture.h
@@ -12,10 +12,10 @@
 namespace Tegra::Texture {
 enum class TextureFormat : u32 {
-    R32_G32_B32_A32 = 0x01,
+    R32G32B32A32 = 0x01,
-    R32_G32_B32 = 0x02,
+    R32G32B32 = 0x02,
-    R16_G16_B16_A16 = 0x03,
+    R16G16B16A16 = 0x03,
-    R32_G32 = 0x04,
+    R32G32 = 0x04,
    R32_B24G8 = 0x05,
    ETC2_RGB = 0x06,
    X8B8G8R8 = 0x07,
@@ -23,19 +23,19 @@ enum class TextureFormat : u32 {
    A2B10G10R10 = 0x09,
    ETC2_RGB_PTA = 0x0a,
    ETC2_RGBA = 0x0b,
-    R16_G16 = 0x0c,
+    R16G16 = 0x0c,
-    G8R24 = 0x0d,
+    R24G8 = 0x0d,
-    G24R8 = 0x0e,
+    R8G24 = 0x0e,
    R32 = 0x0f,
-    BC6H_SF16 = 0x10,
+    BC6H_SFLOAT = 0x10,
-    BC6H_UF16 = 0x11,
+    BC6H_UFLOAT = 0x11,
    A4B4G4R4 = 0x12,
    A5B5G5R1 = 0x13,
    A1B5G5R5 = 0x14,
    B5G6R5 = 0x15,
    B6G5R5 = 0x16,
-    BC7U = 0x17,
+    BC7 = 0x17,
-    G8R8 = 0x18,
+    R8G8 = 0x18,
    EAC = 0x19,
    EACX2 = 0x1a,
    R16 = 0x1b,
@@ -43,23 +43,23 @@ enum class TextureFormat : u32 {
    R8 = 0x1d,
    G4R4 = 0x1e,
    R1 = 0x1f,
-    E5B9G9R9_SHAREDEXP = 0x20,
+    E5B9G9R9 = 0x20,
-    BF10GF11RF11 = 0x21,
+    B10G11R11 = 0x21,
    G8B8G8R8 = 0x22,
    B8G8R8G8 = 0x23,
-    DXT1 = 0x24,
+    BC1_RGBA = 0x24,
-    DXT23 = 0x25,
+    BC2 = 0x25,
-    DXT45 = 0x26,
+    BC3 = 0x26,
-    DXN1 = 0x27,
+    BC4 = 0x27,
-    DXN2 = 0x28,
+    BC5 = 0x28,
-    S8Z24 = 0x29,
+    S8D24 = 0x29,
    X8Z24 = 0x2a,
-    Z24S8 = 0x2b,
+    D24S8 = 0x2b,
    X4V4Z24__COV4R4V = 0x2c,
    X4V4Z24__COV8R8V = 0x2d,
    V8Z24__COV4R12V = 0x2e,
-    ZF32 = 0x2f,
+    D32 = 0x2f,
-    ZF32_X24S8 = 0x30,
+    D32S8 = 0x30,
    X8Z24_X20V4S8__COV4R4V = 0x31,
    X8Z24_X20V4S8__COV8R8V = 0x32,
    ZF32_X20V4X8__COV4R4V = 0x33,
@@ -69,7 +69,7 @@ enum class TextureFormat : u32 {
    X8Z24_X16V8S8__COV4R12V = 0x37,
    ZF32_X16V8X8__COV4R12V = 0x38,
    ZF32_X16V8S8__COV4R12V = 0x39,
-    Z16 = 0x3a,
+    D16 = 0x3a,
    V8Z24__COV8R24V = 0x3b,
    X8Z24_X16V8S8__COV8R24V = 0x3c,
    ZF32_X16V8X8__COV8R24V = 0x3d,
@@ -375,7 +375,4 @@ struct FullTextureInfo {
    TSCEntry tsc;
 };
-/// Returns the number of bytes per pixel of the input texture format.
-u32 BytesPerPixel(TextureFormat format);
 } // namespace Tegra::Texture
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index 11633fd90..cb71b8d11 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -665,8 +665,6 @@ void Config::ReadRendererValues() {
                      QStringLiteral("use_asynchronous_shaders"), false);
    ReadSettingGlobal(Settings::values.use_fast_gpu_time, QStringLiteral("use_fast_gpu_time"),
                      true);
-    ReadSettingGlobal(Settings::values.force_30fps_mode, QStringLiteral("force_30fps_mode"), false);
    ReadSettingGlobal(Settings::values.bg_red, QStringLiteral("bg_red"), 0.0);
    ReadSettingGlobal(Settings::values.bg_green, QStringLiteral("bg_green"), 0.0);
    ReadSettingGlobal(Settings::values.bg_blue, QStringLiteral("bg_blue"), 0.0);
@@ -1168,9 +1166,6 @@ void Config::SaveRendererValues() {
                       Settings::values.use_asynchronous_shaders, false);
    WriteSettingGlobal(QStringLiteral("use_fast_gpu_time"), Settings::values.use_fast_gpu_time,
                       true);
-    WriteSettingGlobal(QStringLiteral("force_30fps_mode"), Settings::values.force_30fps_mode,
-                       false);
    // Cast to double because Qt's written float values are not human-readable
    WriteSettingGlobal(QStringLiteral("bg_red"), Settings::values.bg_red, 0.0);
    WriteSettingGlobal(QStringLiteral("bg_green"), Settings::values.bg_green, 0.0);
diff --git a/src/yuzu/configuration/configuration_shared.cpp b/src/yuzu/configuration/configuration_shared.cpp
index bb47c3933..f9becab6e 100644
--- a/src/yuzu/configuration/configuration_shared.cpp
+++ b/src/yuzu/configuration/configuration_shared.cpp
@@ -4,17 +4,20 @@
 #include <QCheckBox>
 #include <QComboBox>
+#include <QObject>
+#include <QString>
 #include "core/settings.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_per_game.h"
 void ConfigurationShared::ApplyPerGameSetting(Settings::Setting<bool>* setting,
-                                              const QCheckBox* checkbox) {
+                                              const QCheckBox* checkbox,
-    if (checkbox->checkState() == Qt::PartiallyChecked) {
+                                              const CheckState& tracker) {
+    if (tracker == CheckState::Global) {
        setting->SetGlobal(true);
    } else {
        setting->SetGlobal(false);
-        setting->SetValue(checkbox->checkState() == Qt::Checked);
+        setting->SetValue(checkbox->checkState());
    }
 }
@@ -69,8 +72,69 @@ void ConfigurationShared::SetPerGameSetting(
                                                           ConfigurationShared::USE_GLOBAL_OFFSET);
 }
-void ConfigurationShared::InsertGlobalItem(QComboBox* combobox) {
+void ConfigurationShared::SetHighlight(QWidget* widget, const std::string& name, bool highlighted) {
-    const QString use_global_text = ConfigurePerGame::tr("Use global configuration");
+    if (highlighted) {
+        widget->setStyleSheet(QStringLiteral("QWidget#%1 { background-color:rgba(0,203,255,0.5) }")
+                                  .arg(QString::fromStdString(name)));
+    } else {
+        widget->setStyleSheet(QStringLiteral("QWidget#%1 { background-color:rgba(0,0,0,0) }")
+                                  .arg(QString::fromStdString(name)));
+    }
+    widget->show();
+}
+void ConfigurationShared::SetColoredTristate(QCheckBox* checkbox, const std::string& name,
+                                             const Settings::Setting<bool>& setting,
+                                             CheckState& tracker) {
+    if (setting.UsingGlobal()) {
+        tracker = CheckState::Global;
+    } else {
+        tracker = (setting.GetValue() == setting.GetValue(true)) ? CheckState::On : CheckState::Off;
+    }
+    SetHighlight(checkbox, name, tracker != CheckState::Global);
+    QObject::connect(checkbox, &QCheckBox::clicked, checkbox,
+                     [checkbox, name, setting, &tracker]() {
+                         tracker = static_cast<CheckState>((static_cast<int>(tracker) + 1) %
+                                                           static_cast<int>(CheckState::Count));
+                         if (tracker == CheckState::Global) {
+                             checkbox->setChecked(setting.GetValue(true));
+                         }
+                         SetHighlight(checkbox, name, tracker != CheckState::Global);
+                     });
+}
+void ConfigurationShared::SetColoredTristate(QCheckBox* checkbox, const std::string& name,
+                                             bool global, bool state, bool global_state,
+                                             CheckState& tracker) {
+    if (global) {
+        tracker = CheckState::Global;
+    } else {
+        tracker = (state == global_state) ? CheckState::On : CheckState::Off;
+    }
+    SetHighlight(checkbox, name, tracker != CheckState::Global);
+    QObject::connect(checkbox, &QCheckBox::clicked, checkbox,
+                     [checkbox, name, global_state, &tracker]() {
+                         tracker = static_cast<CheckState>((static_cast<int>(tracker) + 1) %
+                                                           static_cast<int>(CheckState::Count));
+                         if (tracker == CheckState::Global) {
+                             checkbox->setChecked(global_state);
+                         }
+                         SetHighlight(checkbox, name, tracker != CheckState::Global);
+                     });
+}
+void ConfigurationShared::SetColoredComboBox(QComboBox* combobox, QWidget* target,
+                                             const std::string& target_name, int global) {
+    InsertGlobalItem(combobox, global);
+    QObject::connect(combobox, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), target,
+                     [target, target_name](int index) {
+                         ConfigurationShared::SetHighlight(target, target_name, index != 0);
+                     });
+}
+void ConfigurationShared::InsertGlobalItem(QComboBox* combobox, int global_index) {
+    const QString use_global_text =
+        ConfigurePerGame::tr("Use global configuration (%1)").arg(combobox->itemText(global_index));
    combobox->insertItem(ConfigurationShared::USE_GLOBAL_INDEX, use_global_text);
    combobox->insertSeparator(ConfigurationShared::USE_GLOBAL_SEPARATOR_INDEX);
 }
diff --git a/src/yuzu/configuration/configuration_shared.h b/src/yuzu/configuration/configuration_shared.h
index b11b1b950..003148c68 100644
--- a/src/yuzu/configuration/configuration_shared.h
+++ b/src/yuzu/configuration/configuration_shared.h
@@ -15,9 +15,17 @@ constexpr int USE_GLOBAL_INDEX = 0;
 constexpr int USE_GLOBAL_SEPARATOR_INDEX = 1;
 constexpr int USE_GLOBAL_OFFSET = 2;
+enum class CheckState {
+    Off,
+    On,
+    Global,
+    Count,
+};
 // Global-aware apply and set functions
-void ApplyPerGameSetting(Settings::Setting<bool>* setting, const QCheckBox* checkbox);
+void ApplyPerGameSetting(Settings::Setting<bool>* setting, const QCheckBox* checkbox,
+                         const CheckState& tracker);
 void ApplyPerGameSetting(Settings::Setting<int>* setting, const QComboBox* combobox);
 void ApplyPerGameSetting(Settings::Setting<Settings::RendererBackend>* setting,
                         const QComboBox* combobox);
@@ -31,6 +39,14 @@ void SetPerGameSetting(QComboBox* combobox,
 void SetPerGameSetting(QComboBox* combobox,
                       const Settings::Setting<Settings::GPUAccuracy>* setting);
-void InsertGlobalItem(QComboBox* combobox);
+void SetHighlight(QWidget* widget, const std::string& name, bool highlighted);
+void SetColoredTristate(QCheckBox* checkbox, const std::string& name,
+                        const Settings::Setting<bool>& setting, CheckState& tracker);
+void SetColoredTristate(QCheckBox* checkbox, const std::string& name, bool global, bool state,
+                        bool global_state, CheckState& tracker);
+void SetColoredComboBox(QComboBox* combobox, QWidget* target, const std::string& target_name,
+                        int global);
+void InsertGlobalItem(QComboBox* combobox, int global_index);
 } // namespace ConfigurationShared
diff --git a/src/yuzu/configuration/configure_audio.cpp b/src/yuzu/configuration/configure_audio.cpp
index cc021beec..fea632531 100644
--- a/src/yuzu/configuration/configure_audio.cpp
+++ b/src/yuzu/configuration/configure_audio.cpp
@@ -49,12 +49,9 @@ void ConfigureAudio::SetConfiguration() {
    ui->volume_slider->setValue(Settings::values.volume.GetValue() * ui->volume_slider->maximum());
-    if (Settings::configuring_global) {
+    ui->toggle_audio_stretching->setChecked(Settings::values.enable_audio_stretching.GetValue());
-        ui->toggle_audio_stretching->setChecked(
-            Settings::values.enable_audio_stretching.GetValue());
+    if (!Settings::configuring_global) {
-    } else {
-        ConfigurationShared::SetPerGameSetting(ui->toggle_audio_stretching,
-                                               &Settings::values.enable_audio_stretching);
        if (Settings::values.volume.UsingGlobal()) {
            ui->volume_combo_box->setCurrentIndex(0);
            ui->volume_slider->setEnabled(false);
@@ -62,6 +59,8 @@ void ConfigureAudio::SetConfiguration() {
            ui->volume_combo_box->setCurrentIndex(1);
            ui->volume_slider->setEnabled(true);
        }
+        ConfigurationShared::SetHighlight(ui->volume_layout, "volume_layout",
+                                          !Settings::values.volume.UsingGlobal());
    }
    SetVolumeIndicatorText(ui->volume_slider->sliderPosition());
 }
@@ -120,7 +119,8 @@ void ConfigureAudio::ApplyConfiguration() {
        }
    } else {
        ConfigurationShared::ApplyPerGameSetting(&Settings::values.enable_audio_stretching,
-                                                 ui->toggle_audio_stretching);
+                                                 ui->toggle_audio_stretching,
+                                                 enable_audio_stretching);
        if (ui->volume_combo_box->currentIndex() == 0) {
            Settings::values.volume.SetGlobal(true);
        } else {
@@ -173,9 +173,14 @@ void ConfigureAudio::SetupPerGameUI() {
        return;
    }
-    ui->toggle_audio_stretching->setTristate(true);
+    ConfigurationShared::SetColoredTristate(ui->toggle_audio_stretching, "toggle_audio_stretching",
+                                            Settings::values.enable_audio_stretching,
+                                            enable_audio_stretching);
    connect(ui->volume_combo_box, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated),
-            this, [this](int index) { ui->volume_slider->setEnabled(index == 1); });
+            this, [this](int index) {
+                ui->volume_slider->setEnabled(index == 1);
+                ConfigurationShared::SetHighlight(ui->volume_layout, "volume_layout", index == 1);
+            });
    ui->output_sink_combo_box->setVisible(false);
    ui->output_sink_label->setVisible(false);
diff --git a/src/yuzu/configuration/configure_audio.h b/src/yuzu/configuration/configure_audio.h
index d84f4a682..9dbd3d93e 100644
--- a/src/yuzu/configuration/configure_audio.h
+++ b/src/yuzu/configuration/configure_audio.h
@@ -7,6 +7,10 @@
 #include <memory>
 #include <QWidget>
+namespace ConfigurationShared {
+enum class CheckState;
+}
 namespace Ui {
 class ConfigureAudio;
 }
@@ -37,4 +41,6 @@ private:
    void SetupPerGameUI();
    std::unique_ptr<Ui::ConfigureAudio> ui;
+    ConfigurationShared::CheckState enable_audio_stretching;
 };
diff --git a/src/yuzu/configuration/configure_audio.ui b/src/yuzu/configuration/configure_audio.ui
index 862ccb988..9bd0cca96 100644
--- a/src/yuzu/configuration/configure_audio.ui
+++ b/src/yuzu/configuration/configure_audio.ui
@@ -56,80 +56,91 @@
       </layout>
      </item>
      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_2">
+       <widget class="QWidget" name="volume_layout" native="true">
-        <property name="topMargin">
+        <layout class="QHBoxLayout" name="horizontalLayout_2">
-         <number>0</number>
+         <property name="leftMargin">
-        </property>
+          <number>0</number>
-        <item>
+         </property>
-         <widget class="QComboBox" name="volume_combo_box">
+         <property name="topMargin">
-          <item>
+          <number>0</number>
+         </property>
+         <property name="rightMargin">
+          <number>0</number>
+         </property>
+         <property name="bottomMargin">
+          <number>0</number>
+         </property>
+         <item>
+          <widget class="QComboBox" name="volume_combo_box">
+           <item>
+            <property name="text">
+             <string>Use global volume</string>
+            </property>
+           </item>
+           <item>
+            <property name="text">
+             <string>Set volume:</string>
+            </property>
+           </item>
+          </widget>
+         </item>
+         <item>
+          <widget class="QLabel" name="volume_label">
           <property name="text">
-            <string>Use global volume</string>
+            <string>Volume:</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <spacer name="horizontalSpacer">
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>30</width>
+             <height>20</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+         <item>
+          <widget class="QSlider" name="volume_slider">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+           <property name="maximum">
+            <number>100</number>
+           </property>
+           <property name="pageStep">
+            <number>10</number>
+           </property>
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QLabel" name="volume_indicator">
+           <property name="minimumSize">
+            <size>
+             <width>32</width>
+             <height>0</height>
+            </size>
           </property>
-          </item>
-          <item>
           <property name="text">
-            <string>Set volume:</string>
+            <string>0 %</string>
           </property>
-          </item>
+           <property name="alignment">
-         </widget>
+            <set>Qt::AlignCenter</set>
-        </item>
+           </property>
-        <item>
+          </widget>
-         <widget class="QLabel" name="volume_label">
+         </item>
-          <property name="text">
+        </layout>
-           <string>Volume:</string>
+       </widget>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <spacer name="horizontalSpacer">
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-          <property name="sizeHint" stdset="0">
-           <size>
-            <width>30</width>
-            <height>20</height>
-           </size>
-          </property>
-         </spacer>
-        </item>
-        <item>
-         <widget class="QSlider" name="volume_slider">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="maximum">
-           <number>100</number>
-          </property>
-          <property name="pageStep">
-           <number>10</number>
-          </property>
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QLabel" name="volume_indicator">
-          <property name="minimumSize">
-           <size>
-            <width>32</width>
-            <height>0</height>
-           </size>
-          </property>
-          <property name="text">
-           <string>0 %</string>
-          </property>
-          <property name="alignment">
-           <set>Qt::AlignCenter</set>
-          </property>
-         </widget>
-        </item>
-       </layout>
      </item>
     </layout>
    </widget>
diff --git a/src/yuzu/configuration/configure_debug.ui b/src/yuzu/configuration/configure_debug.ui
index 272bdd6b8..9d6feb9f7 100644
--- a/src/yuzu/configuration/configure_debug.ui
+++ b/src/yuzu/configuration/configure_debug.ui
@@ -171,26 +171,6 @@
     </property>
     <layout class="QVBoxLayout" name="verticalLayout_6">
      <item>
-       <widget class="QCheckBox" name="dump_decompressed_nso">
-        <property name="whatsThis">
-         <string>When checked, any NSO yuzu tries to load or patch will be copied decompressed to the yuzu/dump directory.</string>
-        </property>
-        <property name="text">
-         <string>Dump Decompressed NSOs</string>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <widget class="QCheckBox" name="dump_exefs">
-        <property name="whatsThis">
-         <string>When checked, any game that yuzu loads will have its ExeFS dumped to the yuzu/dump directory.</string>
-        </property>
-        <property name="text">
-         <string>Dump ExeFS</string>
-        </property>
-       </widget>
-      </item>
-      <item>
       <widget class="QCheckBox" name="reporting_services">
        <property name="text">
         <string>Enable Verbose Reporting Services</string>
@@ -257,8 +237,6 @@
  <tabstop>open_log_button</tabstop>
  <tabstop>homebrew_args_edit</tabstop>
  <tabstop>enable_graphics_debugging</tabstop>
-  <tabstop>dump_decompressed_nso</tabstop>
-  <tabstop>dump_exefs</tabstop>
  <tabstop>reporting_services</tabstop>
  <tabstop>quest_flag</tabstop>
 </tabstops>
diff --git a/src/yuzu/configuration/configure_general.cpp b/src/yuzu/configuration/configure_general.cpp
index 20316c9cc..c0dbd9855 100644
--- a/src/yuzu/configuration/configure_general.cpp
+++ b/src/yuzu/configuration/configure_general.cpp
@@ -19,9 +19,10 @@ ConfigureGeneral::ConfigureGeneral(QWidget* parent)
    SetConfiguration();
-    connect(ui->toggle_frame_limit, &QCheckBox::stateChanged, ui->frame_limit, [this]() {
+    if (Settings::configuring_global) {
-        ui->frame_limit->setEnabled(ui->toggle_frame_limit->checkState() == Qt::Checked);
+        connect(ui->toggle_frame_limit, &QCheckBox::clicked, ui->frame_limit,
-    });
+                [this]() { ui->frame_limit->setEnabled(ui->toggle_frame_limit->isChecked()); });
+    }
 }
 ConfigureGeneral::~ConfigureGeneral() = default;
@@ -40,17 +41,12 @@ void ConfigureGeneral::SetConfiguration() {
    ui->toggle_frame_limit->setChecked(Settings::values.use_frame_limit.GetValue());
    ui->frame_limit->setValue(Settings::values.frame_limit.GetValue());
-    if (!Settings::configuring_global) {
+    if (Settings::configuring_global) {
-        if (Settings::values.use_multi_core.UsingGlobal()) {
+        ui->frame_limit->setEnabled(Settings::values.use_frame_limit.GetValue());
-            ui->use_multi_core->setCheckState(Qt::PartiallyChecked);
+    } else {
-        }
+        ui->frame_limit->setEnabled(Settings::values.use_frame_limit.GetValue() &&
-        if (Settings::values.use_frame_limit.UsingGlobal()) {
+                                    use_frame_limit != ConfigurationShared::CheckState::Global);
-            ui->toggle_frame_limit->setCheckState(Qt::PartiallyChecked);
-        }
    }
-    ui->frame_limit->setEnabled(ui->toggle_frame_limit->checkState() == Qt::Checked &&
-                                ui->toggle_frame_limit->isEnabled());
 }
 void ConfigureGeneral::ApplyConfiguration() {
@@ -71,9 +67,9 @@ void ConfigureGeneral::ApplyConfiguration() {
        }
    } else {
        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_multi_core,
-                                                 ui->use_multi_core);
+                                                 ui->use_multi_core, use_multi_core);
-        bool global_frame_limit = ui->toggle_frame_limit->checkState() == Qt::PartiallyChecked;
+        bool global_frame_limit = use_frame_limit == ConfigurationShared::CheckState::Global;
        Settings::values.use_frame_limit.SetGlobal(global_frame_limit);
        Settings::values.frame_limit.SetGlobal(global_frame_limit);
        if (!global_frame_limit) {
@@ -109,6 +105,13 @@ void ConfigureGeneral::SetupPerGameUI() {
    ui->toggle_background_pause->setVisible(false);
    ui->toggle_hide_mouse->setVisible(false);
-    ui->toggle_frame_limit->setTristate(true);
+    ConfigurationShared::SetColoredTristate(ui->toggle_frame_limit, "toggle_frame_limit",
-    ui->use_multi_core->setTristate(true);
+                                            Settings::values.use_frame_limit, use_frame_limit);
+    ConfigurationShared::SetColoredTristate(ui->use_multi_core, "use_multi_core",
+                                            Settings::values.use_multi_core, use_multi_core);
+    connect(ui->toggle_frame_limit, &QCheckBox::clicked, ui->frame_limit, [this]() {
+        ui->frame_limit->setEnabled(ui->toggle_frame_limit->isChecked() &&
+                                    (use_frame_limit != ConfigurationShared::CheckState::Global));
+    });
 }
diff --git a/src/yuzu/configuration/configure_general.h b/src/yuzu/configuration/configure_general.h
index 9c785c22e..323ffbd8f 100644
--- a/src/yuzu/configuration/configure_general.h
+++ b/src/yuzu/configuration/configure_general.h
@@ -7,6 +7,10 @@
 #include <memory>
 #include <QWidget>
+namespace ConfigurationShared {
+enum class CheckState;
+}
 class HotkeyRegistry;
 namespace Ui {
@@ -31,4 +35,7 @@ private:
    void SetupPerGameUI();
    std::unique_ptr<Ui::ConfigureGeneral> ui;
+    ConfigurationShared::CheckState use_frame_limit;
+    ConfigurationShared::CheckState use_multi_core;
 };
diff --git a/src/yuzu/configuration/configure_graphics.cpp b/src/yuzu/configuration/configure_graphics.cpp
index cb4706bd6..3e42531c3 100644
--- a/src/yuzu/configuration/configure_graphics.cpp
+++ b/src/yuzu/configuration/configure_graphics.cpp
@@ -31,8 +31,14 @@ ConfigureGraphics::ConfigureGraphics(QWidget* parent)
    SetConfiguration();
-    connect(ui->api, qOverload<int>(&QComboBox::currentIndexChanged), this,
+    connect(ui->api, qOverload<int>(&QComboBox::currentIndexChanged), this, [this] {
-            [this] { UpdateDeviceComboBox(); });
+        UpdateDeviceComboBox();
+        if (!Settings::configuring_global) {
+            ConfigurationShared::SetHighlight(ui->api_layout, "api_layout",
+                                              ui->api->currentIndex() !=
+                                                  ConfigurationShared::USE_GLOBAL_INDEX);
+        }
+    });
    connect(ui->device, qOverload<int>(&QComboBox::activated), this,
            [this](int device) { UpdateDeviceSelection(device); });
@@ -65,25 +71,26 @@ void ConfigureGraphics::SetConfiguration() {
    ui->api->setEnabled(runtime_lock);
    ui->use_asynchronous_gpu_emulation->setEnabled(runtime_lock);
    ui->use_disk_shader_cache->setEnabled(runtime_lock);
+    ui->use_disk_shader_cache->setChecked(Settings::values.use_disk_shader_cache.GetValue());
+    ui->use_asynchronous_gpu_emulation->setChecked(
+        Settings::values.use_asynchronous_gpu_emulation.GetValue());
    if (Settings::configuring_global) {
        ui->api->setCurrentIndex(static_cast<int>(Settings::values.renderer_backend.GetValue()));
        ui->aspect_ratio_combobox->setCurrentIndex(Settings::values.aspect_ratio.GetValue());
-        ui->use_disk_shader_cache->setChecked(Settings::values.use_disk_shader_cache.GetValue());
-        ui->use_asynchronous_gpu_emulation->setChecked(
-            Settings::values.use_asynchronous_gpu_emulation.GetValue());
    } else {
-        ConfigurationShared::SetPerGameSetting(ui->use_disk_shader_cache,
-                                               &Settings::values.use_disk_shader_cache);
-        ConfigurationShared::SetPerGameSetting(ui->use_asynchronous_gpu_emulation,
-                                               &Settings::values.use_asynchronous_gpu_emulation);
        ConfigurationShared::SetPerGameSetting(ui->api, &Settings::values.renderer_backend);
+        ConfigurationShared::SetHighlight(ui->api_layout, "api_layout",
+                                          !Settings::values.renderer_backend.UsingGlobal());
        ConfigurationShared::SetPerGameSetting(ui->aspect_ratio_combobox,
                                               &Settings::values.aspect_ratio);
        ui->bg_combobox->setCurrentIndex(Settings::values.bg_red.UsingGlobal() ? 0 : 1);
        ui->bg_button->setEnabled(!Settings::values.bg_red.UsingGlobal());
+        ConfigurationShared::SetHighlight(ui->ar_label, "ar_label",
+                                          !Settings::values.aspect_ratio.UsingGlobal());
+        ConfigurationShared::SetHighlight(ui->bg_layout, "bg_layout",
+                                          !Settings::values.bg_red.UsingGlobal());
    }
    UpdateBackgroundColorButton(QColor::fromRgbF(Settings::values.bg_red.GetValue(),
@@ -135,9 +142,10 @@ void ConfigureGraphics::ApplyConfiguration() {
                                                 ui->aspect_ratio_combobox);
        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_disk_shader_cache,
-                                                 ui->use_disk_shader_cache);
+                                                 ui->use_disk_shader_cache, use_disk_shader_cache);
        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_asynchronous_gpu_emulation,
-                                                 ui->use_asynchronous_gpu_emulation);
+                                                 ui->use_asynchronous_gpu_emulation,
+                                                 use_asynchronous_gpu_emulation);
        if (ui->bg_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
            Settings::values.bg_red.SetGlobal(true);
@@ -241,10 +249,20 @@ void ConfigureGraphics::SetupPerGameUI() {
    }
    connect(ui->bg_combobox, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), this,
-            [this](int index) { ui->bg_button->setEnabled(index == 1); });
+            [this](int index) {
+                ui->bg_button->setEnabled(index == 1);
-    ui->use_disk_shader_cache->setTristate(true);
+                ConfigurationShared::SetHighlight(ui->bg_layout, "bg_layout", index == 1);
-    ui->use_asynchronous_gpu_emulation->setTristate(true);
+            });
-    ConfigurationShared::InsertGlobalItem(ui->aspect_ratio_combobox);
-    ConfigurationShared::InsertGlobalItem(ui->api);
+    ConfigurationShared::SetColoredTristate(ui->use_disk_shader_cache, "use_disk_shader_cache",
+                                            Settings::values.use_disk_shader_cache,
+                                            use_disk_shader_cache);
+    ConfigurationShared::SetColoredTristate(
+        ui->use_asynchronous_gpu_emulation, "use_asynchronous_gpu_emulation",
+        Settings::values.use_asynchronous_gpu_emulation, use_asynchronous_gpu_emulation);
+    ConfigurationShared::SetColoredComboBox(ui->aspect_ratio_combobox, ui->ar_label, "ar_label",
+                                            Settings::values.aspect_ratio.GetValue(true));
+    ConfigurationShared::InsertGlobalItem(
+        ui->api, static_cast<int>(Settings::values.renderer_backend.GetValue(true)));
 }
diff --git a/src/yuzu/configuration/configure_graphics.h b/src/yuzu/configuration/configure_graphics.h
index 24f01c739..b4961f719 100644
--- a/src/yuzu/configuration/configure_graphics.h
+++ b/src/yuzu/configuration/configure_graphics.h
@@ -10,6 +10,10 @@
 #include <QWidget>
 #include "core/settings.h"
+namespace ConfigurationShared {
+enum class CheckState;
+}
 namespace Ui {
 class ConfigureGraphics;
 }
@@ -42,6 +46,9 @@ private:
    std::unique_ptr<Ui::ConfigureGraphics> ui;
    QColor bg_color;
+    ConfigurationShared::CheckState use_disk_shader_cache;
+    ConfigurationShared::CheckState use_asynchronous_gpu_emulation;
    std::vector<QString> vulkan_devices;
    u32 vulkan_device{};
 };
diff --git a/src/yuzu/configuration/configure_graphics.ui b/src/yuzu/configuration/configure_graphics.ui
index 62418fc14..62aa337e7 100644
--- a/src/yuzu/configuration/configure_graphics.ui
+++ b/src/yuzu/configuration/configure_graphics.ui
@@ -6,7 +6,7 @@
   <rect>
    <x>0</x>
    <y>0</y>
-    <width>400</width>
+    <width>437</width>
    <height>321</height>
   </rect>
  </property>
@@ -23,43 +23,56 @@
       </property>
       <layout class="QVBoxLayout" name="verticalLayout_3">
        <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_4">
+         <widget class="QWidget" name="api_layout" native="true">
-          <item>
+          <layout class="QGridLayout" name="gridLayout">
-           <widget class="QLabel" name="label_2">
+           <property name="leftMargin">
-            <property name="text">
+            <number>0</number>
-             <string>API:</string>
+           </property>
-            </property>
+           <property name="topMargin">
-           </widget>
+            <number>0</number>
-          </item>
+           </property>
-          <item>
+           <property name="rightMargin">
-           <widget class="QComboBox" name="api">
+            <number>0</number>
-            <item>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <property name="horizontalSpacing">
+            <number>6</number>
+           </property>
+           <item row="0" column="0">
+            <widget class="QLabel" name="api_label">
             <property name="text">
-              <string notr="true">OpenGL</string>
+              <string>API:</string>
             </property>
-            </item>
+            </widget>
-            <item>
+           </item>
+           <item row="0" column="1">
+            <widget class="QComboBox" name="api">
+             <item>
+              <property name="text">
+               <string notr="true">OpenGL</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string notr="true">Vulkan</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QLabel" name="device_label">
             <property name="text">
-              <string notr="true">Vulkan</string>
+              <string>Device:</string>
             </property>
-            </item>
+            </widget>
-           </widget>
+           </item>
-          </item>
+           <item row="1" column="1">
-         </layout>
+            <widget class="QComboBox" name="device"/>
-        </item>
+           </item>
-        <item>
+          </layout>
-         <layout class="QHBoxLayout" name="horizontalLayout_5">
+         </widget>
-          <item>
-           <widget class="QLabel" name="label_3">
-            <property name="text">
-             <string>Device:</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QComboBox" name="device"/>
-          </item>
-         </layout>
        </item>
       </layout>
      </widget>
@@ -85,96 +98,133 @@
         </widget>
        </item>
        <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_6">
+         <widget class="QWidget" name="aspect_ratio_layout" native="true">
-          <item>
+          <layout class="QHBoxLayout" name="horizontalLayout_6">
-           <widget class="QLabel" name="ar_label">
+           <property name="leftMargin">
-            <property name="text">
+            <number>0</number>
-             <string>Aspect Ratio:</string>
+           </property>
-            </property>
+           <property name="topMargin">
-           </widget>
+            <number>0</number>
-          </item>
+           </property>
-          <item>
+           <property name="rightMargin">
-           <widget class="QComboBox" name="aspect_ratio_combobox">
+            <number>0</number>
-            <item>
+           </property>
-             <property name="text">
+           <property name="bottomMargin">
-              <string>Default (16:9)</string>
+            <number>0</number>
-             </property>
+           </property>
-            </item>
+           <item>
-            <item>
+            <widget class="QLabel" name="ar_label">
-             <property name="text">
-              <string>Force 4:3</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>Force 21:9</string>
-             </property>
-            </item>
-            <item>
             <property name="text">
-              <string>Stretch to Window</string>
+              <string>Aspect Ratio:</string>
             </property>
-            </item>
+            </widget>
-           </widget>
+           </item>
-          </item>
+           <item>
-         </layout>
+            <widget class="QComboBox" name="aspect_ratio_combobox">
+             <item>
+              <property name="text">
+               <string>Default (16:9)</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Force 4:3</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Force 21:9</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Stretch to Window</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+          </layout>
+         </widget>
        </item>
        <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_3">
+         <widget class="QWidget" name="bg_layout" native="true">
-          <item>
+          <property name="sizePolicy">
-           <widget class="QComboBox" name="bg_combobox">
+           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
-            <property name="currentText">
+            <horstretch>0</horstretch>
-             <string>Use global background color</string>
+            <verstretch>0</verstretch>
-            </property>
+           </sizepolicy>
-            <property name="currentIndex">
+          </property>
-             <number>0</number>
+          <layout class="QHBoxLayout" name="horizontalLayout_3">
-            </property>
+           <property name="spacing">
-            <property name="maxVisibleItems">
+            <number>6</number>
-             <number>10</number>
+           </property>
-            </property>
+           <property name="leftMargin">
-            <item>
+            <number>0</number>
-             <property name="text">
+           </property>
+           <property name="topMargin">
+            <number>0</number>
+           </property>
+           <property name="rightMargin">
+            <number>0</number>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <widget class="QComboBox" name="bg_combobox">
+             <property name="currentText">
              <string>Use global background color</string>
             </property>
-            </item>
+             <property name="currentIndex">
-            <item>
+              <number>0</number>
+             </property>
+             <property name="maxVisibleItems">
+              <number>10</number>
+             </property>
+             <item>
+              <property name="text">
+               <string>Use global background color</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Set background color:</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="bg_label">
             <property name="text">
-              <string>Set background color:</string>
+              <string>Background Color:</string>
             </property>
-            </item>
+            </widget>
-           </widget>
+           </item>
-          </item>
+           <item>
-          <item>
+            <spacer name="horizontalSpacer">
-           <widget class="QLabel" name="bg_label">
+             <property name="orientation">
-            <property name="text">
+              <enum>Qt::Horizontal</enum>
-             <string>Background Color:</string>
+             </property>
-            </property>
+             <property name="sizeHint" stdset="0">
-           </widget>
+              <size>
-          </item>
+               <width>40</width>
-          <item>
+               <height>20</height>
-           <spacer name="horizontalSpacer">
+              </size>
-            <property name="orientation">
+             </property>
-             <enum>Qt::Horizontal</enum>
+            </spacer>
-            </property>
+           </item>
-            <property name="sizeHint" stdset="0">
+           <item>
-             <size>
+            <widget class="QPushButton" name="bg_button">
-              <width>40</width>
+             <property name="maximumSize">
-              <height>20</height>
+              <size>
-             </size>
+               <width>40</width>
-            </property>
+               <height>16777215</height>
-           </spacer>
+              </size>
-          </item>
+             </property>
-          <item>
+            </widget>
-           <widget class="QPushButton" name="bg_button">
+           </item>
-            <property name="maximumSize">
+          </layout>
-             <size>
+         </widget>
-              <width>40</width>
-              <height>16777215</height>
-             </size>
-            </property>
-           </widget>
-          </item>
-         </layout>
        </item>
       </layout>
      </widget>
diff --git a/src/yuzu/configuration/configure_graphics_advanced.cpp b/src/yuzu/configuration/configure_graphics_advanced.cpp
index ce30188cd..c5d1a778c 100644
--- a/src/yuzu/configuration/configure_graphics_advanced.cpp
+++ b/src/yuzu/configuration/configure_graphics_advanced.cpp
@@ -25,35 +25,26 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
    ui->use_vsync->setEnabled(runtime_lock);
    ui->use_assembly_shaders->setEnabled(runtime_lock);
    ui->use_asynchronous_shaders->setEnabled(runtime_lock);
-    ui->force_30fps_mode->setEnabled(runtime_lock);
    ui->anisotropic_filtering_combobox->setEnabled(runtime_lock);
+    ui->use_vsync->setChecked(Settings::values.use_vsync.GetValue());
+    ui->use_assembly_shaders->setChecked(Settings::values.use_assembly_shaders.GetValue());
+    ui->use_asynchronous_shaders->setChecked(Settings::values.use_asynchronous_shaders.GetValue());
+    ui->use_fast_gpu_time->setChecked(Settings::values.use_fast_gpu_time.GetValue());
    if (Settings::configuring_global) {
        ui->gpu_accuracy->setCurrentIndex(
            static_cast<int>(Settings::values.gpu_accuracy.GetValue()));
-        ui->use_vsync->setChecked(Settings::values.use_vsync.GetValue());
-        ui->use_assembly_shaders->setChecked(Settings::values.use_assembly_shaders.GetValue());
-        ui->use_asynchronous_shaders->setChecked(
-            Settings::values.use_asynchronous_shaders.GetValue());
-        ui->use_fast_gpu_time->setChecked(Settings::values.use_fast_gpu_time.GetValue());
-        ui->force_30fps_mode->setChecked(Settings::values.force_30fps_mode.GetValue());
        ui->anisotropic_filtering_combobox->setCurrentIndex(
            Settings::values.max_anisotropy.GetValue());
    } else {
        ConfigurationShared::SetPerGameSetting(ui->gpu_accuracy, &Settings::values.gpu_accuracy);
-        ConfigurationShared::SetPerGameSetting(ui->use_vsync, &Settings::values.use_vsync);
-        ConfigurationShared::SetPerGameSetting(ui->use_assembly_shaders,
-                                               &Settings::values.use_assembly_shaders);
-        ConfigurationShared::SetPerGameSetting(ui->use_asynchronous_shaders,
-                                               &Settings::values.use_asynchronous_shaders);
-        ConfigurationShared::SetPerGameSetting(ui->use_asynchronous_shaders,
-                                               &Settings::values.use_asynchronous_shaders);
-        ConfigurationShared::SetPerGameSetting(ui->use_fast_gpu_time,
-                                               &Settings::values.use_fast_gpu_time);
-        ConfigurationShared::SetPerGameSetting(ui->force_30fps_mode,
-                                               &Settings::values.force_30fps_mode);
        ConfigurationShared::SetPerGameSetting(ui->anisotropic_filtering_combobox,
                                               &Settings::values.max_anisotropy);
+        ConfigurationShared::SetHighlight(ui->label_gpu_accuracy, "label_gpu_accuracy",
+                                          !Settings::values.gpu_accuracy.UsingGlobal());
+        ConfigurationShared::SetHighlight(ui->af_label, "af_label",
+                                          !Settings::values.max_anisotropy.UsingGlobal());
    }
 }
@@ -85,9 +76,6 @@ void ConfigureGraphicsAdvanced::ApplyConfiguration() {
        if (Settings::values.use_fast_gpu_time.UsingGlobal()) {
            Settings::values.use_fast_gpu_time.SetValue(ui->use_fast_gpu_time->isChecked());
        }
-        if (Settings::values.force_30fps_mode.UsingGlobal()) {
-            Settings::values.force_30fps_mode.SetValue(ui->force_30fps_mode->isChecked());
-        }
        if (Settings::values.max_anisotropy.UsingGlobal()) {
            Settings::values.max_anisotropy.SetValue(
                ui->anisotropic_filtering_combobox->currentIndex());
@@ -95,17 +83,15 @@ void ConfigureGraphicsAdvanced::ApplyConfiguration() {
    } else {
        ConfigurationShared::ApplyPerGameSetting(&Settings::values.max_anisotropy,
                                                 ui->anisotropic_filtering_combobox);
-        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vsync, ui->use_vsync);
+        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vsync, ui->use_vsync,
+                                                 use_vsync);
        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_assembly_shaders,
-                                                 ui->use_assembly_shaders);
+                                                 ui->use_assembly_shaders, use_assembly_shaders);
-        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_asynchronous_shaders,
-                                                 ui->use_asynchronous_shaders);
        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_asynchronous_shaders,
-                                                 ui->use_asynchronous_shaders);
+                                                 ui->use_asynchronous_shaders,
+                                                 use_asynchronous_shaders);
        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_fast_gpu_time,
-                                                 ui->use_fast_gpu_time);
+                                                 ui->use_fast_gpu_time, use_fast_gpu_time);
-        ConfigurationShared::ApplyPerGameSetting(&Settings::values.force_30fps_mode,
-                                                 ui->force_30fps_mode);
        ConfigurationShared::ApplyPerGameSetting(&Settings::values.max_anisotropy,
                                                 ui->anisotropic_filtering_combobox);
@@ -139,18 +125,26 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
        ui->use_asynchronous_shaders->setEnabled(
            Settings::values.use_asynchronous_shaders.UsingGlobal());
        ui->use_fast_gpu_time->setEnabled(Settings::values.use_fast_gpu_time.UsingGlobal());
-        ui->force_30fps_mode->setEnabled(Settings::values.force_30fps_mode.UsingGlobal());
        ui->anisotropic_filtering_combobox->setEnabled(
            Settings::values.max_anisotropy.UsingGlobal());
        return;
    }
-    ConfigurationShared::InsertGlobalItem(ui->gpu_accuracy);
+    ConfigurationShared::SetColoredTristate(ui->use_vsync, "use_vsync", Settings::values.use_vsync,
-    ui->use_vsync->setTristate(true);
+                                            use_vsync);
-    ui->use_assembly_shaders->setTristate(true);
+    ConfigurationShared::SetColoredTristate(ui->use_assembly_shaders, "use_assembly_shaders",
-    ui->use_asynchronous_shaders->setTristate(true);
+                                            Settings::values.use_assembly_shaders,
-    ui->use_fast_gpu_time->setTristate(true);
+                                            use_assembly_shaders);
-    ui->force_30fps_mode->setTristate(true);
+    ConfigurationShared::SetColoredTristate(
-    ConfigurationShared::InsertGlobalItem(ui->anisotropic_filtering_combobox);
+        ui->use_asynchronous_shaders, "use_asynchronous_shaders",
+        Settings::values.use_asynchronous_shaders, use_asynchronous_shaders);
+    ConfigurationShared::SetColoredTristate(ui->use_fast_gpu_time, "use_fast_gpu_time",
+                                            Settings::values.use_fast_gpu_time, use_fast_gpu_time);
+    ConfigurationShared::SetColoredComboBox(
+        ui->gpu_accuracy, ui->label_gpu_accuracy, "label_gpu_accuracy",
+        static_cast<int>(Settings::values.gpu_accuracy.GetValue(true)));
+    ConfigurationShared::SetColoredComboBox(
+        ui->anisotropic_filtering_combobox, ui->af_label, "af_label",
+        static_cast<int>(Settings::values.max_anisotropy.GetValue(true)));
 }
diff --git a/src/yuzu/configuration/configure_graphics_advanced.h b/src/yuzu/configuration/configure_graphics_advanced.h
index c043588ff..e61b571c7 100644
--- a/src/yuzu/configuration/configure_graphics_advanced.h
+++ b/src/yuzu/configuration/configure_graphics_advanced.h
@@ -7,6 +7,10 @@
 #include <memory>
 #include <QWidget>
+namespace ConfigurationShared {
+enum class CheckState;
+}
 namespace Ui {
 class ConfigureGraphicsAdvanced;
 }
@@ -29,4 +33,9 @@ private:
    void SetupPerGameUI();
    std::unique_ptr<Ui::ConfigureGraphicsAdvanced> ui;
+    ConfigurationShared::CheckState use_vsync;
+    ConfigurationShared::CheckState use_assembly_shaders;
+    ConfigurationShared::CheckState use_asynchronous_shaders;
+    ConfigurationShared::CheckState use_fast_gpu_time;
 };
diff --git a/src/yuzu/configuration/configure_graphics_advanced.ui b/src/yuzu/configuration/configure_graphics_advanced.ui
index 71e7dfe5e..a793c803d 100644
--- a/src/yuzu/configuration/configure_graphics_advanced.ui
+++ b/src/yuzu/configuration/configure_graphics_advanced.ui
@@ -6,7 +6,7 @@
   <rect>
    <x>0</x>
    <y>0</y>
-    <width>400</width>
+    <width>404</width>
    <height>321</height>
   </rect>
  </property>
@@ -23,34 +23,48 @@
       </property>
       <layout class="QVBoxLayout" name="verticalLayout_3">
        <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_2">
+         <widget class="QWidget" name="gpu_accuracy_layout" native="true">
-          <item>
+          <layout class="QHBoxLayout" name="horizontalLayout_2">
-           <widget class="QLabel" name="label_gpu_accuracy">
+           <property name="leftMargin">
-            <property name="text">
+            <number>0</number>
-             <string>Accuracy Level:</string>
+           </property>
-            </property>
+           <property name="topMargin">
-           </widget>
+            <number>0</number>
-          </item>
+           </property>
-          <item>
+           <property name="rightMargin">
-           <widget class="QComboBox" name="gpu_accuracy">
+            <number>0</number>
-            <item>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <widget class="QLabel" name="label_gpu_accuracy">
             <property name="text">
-              <string notr="true">Normal</string>
+              <string>Accuracy Level:</string>
             </property>
-            </item>
+            </widget>
-            <item>
+           </item>
-             <property name="text">
+           <item>
-              <string notr="true">High</string>
+            <widget class="QComboBox" name="gpu_accuracy">
-             </property>
+             <item>
-            </item>
+              <property name="text">
-            <item>
+               <string notr="true">Normal</string>
-             <property name="text">
+              </property>
-              <string notr="true">Extreme(very slow)</string>
+             </item>
-             </property>
+             <item>
-            </item>
+              <property name="text">
-           </widget>
+               <string notr="true">High</string>
-          </item>
+              </property>
-         </layout>
+             </item>
+             <item>
+              <property name="text">
+               <string notr="true">Extreme(very slow)</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+          </layout>
+         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="use_vsync">
@@ -83,13 +97,6 @@
         </widget>
        </item>
        <item>
-         <widget class="QCheckBox" name="force_30fps_mode">
-          <property name="text">
-           <string>Force 30 FPS mode</string>
-          </property>
-         </widget>
-        </item>
-        <item>
         <widget class="QCheckBox" name="use_fast_gpu_time">
          <property name="text">
           <string>Use Fast GPU Time</string>
@@ -97,44 +104,58 @@
         </widget>
        </item>
        <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_1">
+         <widget class="QWidget" name="af_layout" native="true">
-          <item>
+          <layout class="QHBoxLayout" name="horizontalLayout_1">
-           <widget class="QLabel" name="af_label">
+           <property name="leftMargin">
-            <property name="text">
+            <number>0</number>
-             <string>Anisotropic Filtering:</string>
+           </property>
-            </property>
+           <property name="topMargin">
-           </widget>
+            <number>0</number>
-          </item>
+           </property>
-          <item>
+           <property name="rightMargin">
-           <widget class="QComboBox" name="anisotropic_filtering_combobox">
+            <number>0</number>
-            <item>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <widget class="QLabel" name="af_label">
             <property name="text">
-              <string>Default</string>
+              <string>Anisotropic Filtering:</string>
             </property>
-            </item>
+            </widget>
-            <item>
+           </item>
-             <property name="text">
+           <item>
-              <string>2x</string>
+            <widget class="QComboBox" name="anisotropic_filtering_combobox">
-             </property>
+             <item>
-            </item>
+              <property name="text">
-            <item>
+               <string>Default</string>
-             <property name="text">
+              </property>
-              <string>4x</string>
+             </item>
-             </property>
+             <item>
-            </item>
+              <property name="text">
-            <item>
+               <string>2x</string>
-             <property name="text">
+              </property>
-              <string>8x</string>
+             </item>
-             </property>
+             <item>
-            </item>
+              <property name="text">
-            <item>
+               <string>4x</string>
-             <property name="text">
+              </property>
-              <string>16x</string>
+             </item>
-             </property>
+             <item>
-            </item>
+              <property name="text">
-           </widget>
+               <string>8x</string>
-          </item>
+              </property>
-         </layout>
+             </item>
+             <item>
+              <property name="text">
+               <string>16x</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+          </layout>
+         </widget>
        </item>
       </layout>
      </widget>
diff --git a/src/yuzu/configuration/configure_system.cpp b/src/yuzu/configuration/configure_system.cpp
index 68e02738b..0c4daf147 100644
--- a/src/yuzu/configuration/configure_system.cpp
+++ b/src/yuzu/configuration/configure_system.cpp
@@ -67,21 +67,21 @@ void ConfigureSystem::SetConfiguration() {
    const auto rtc_time = Settings::values.custom_rtc.GetValue().value_or(
        std::chrono::seconds(QDateTime::currentSecsSinceEpoch()));
+    ui->rng_seed_checkbox->setChecked(Settings::values.rng_seed.GetValue().has_value());
+    ui->rng_seed_edit->setEnabled(Settings::values.rng_seed.GetValue().has_value() &&
+                                  Settings::values.rng_seed.UsingGlobal());
+    ui->rng_seed_edit->setText(rng_seed);
+    ui->custom_rtc_checkbox->setChecked(Settings::values.custom_rtc.GetValue().has_value());
+    ui->custom_rtc_edit->setEnabled(Settings::values.custom_rtc.GetValue().has_value() &&
+                                    Settings::values.rng_seed.UsingGlobal());
+    ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time.count()));
    if (Settings::configuring_global) {
        ui->combo_language->setCurrentIndex(Settings::values.language_index.GetValue());
        ui->combo_region->setCurrentIndex(Settings::values.region_index.GetValue());
        ui->combo_time_zone->setCurrentIndex(Settings::values.time_zone_index.GetValue());
        ui->combo_sound->setCurrentIndex(Settings::values.sound_index.GetValue());
-        ui->rng_seed_checkbox->setChecked(Settings::values.rng_seed.GetValue().has_value());
-        ui->rng_seed_edit->setEnabled(Settings::values.rng_seed.GetValue().has_value() &&
-                                      Settings::values.rng_seed.UsingGlobal());
-        ui->rng_seed_edit->setText(rng_seed);
-        ui->custom_rtc_checkbox->setChecked(Settings::values.custom_rtc.GetValue().has_value());
-        ui->custom_rtc_edit->setEnabled(Settings::values.custom_rtc.GetValue().has_value() &&
-                                        Settings::values.rng_seed.UsingGlobal());
-        ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time.count()));
    } else {
        ConfigurationShared::SetPerGameSetting(ui->combo_language,
                                               &Settings::values.language_index);
@@ -90,27 +90,14 @@ void ConfigureSystem::SetConfiguration() {
                                               &Settings::values.time_zone_index);
        ConfigurationShared::SetPerGameSetting(ui->combo_sound, &Settings::values.sound_index);
-        if (Settings::values.rng_seed.UsingGlobal()) {
+        ConfigurationShared::SetHighlight(ui->label_language, "label_language",
-            ui->rng_seed_checkbox->setCheckState(Qt::PartiallyChecked);
+                                          !Settings::values.language_index.UsingGlobal());
-        } else {
+        ConfigurationShared::SetHighlight(ui->label_region, "label_region",
-            ui->rng_seed_checkbox->setCheckState(
+                                          !Settings::values.region_index.UsingGlobal());
-                Settings::values.rng_seed.GetValue().has_value() ? Qt::Checked : Qt::Unchecked);
+        ConfigurationShared::SetHighlight(ui->label_timezone, "label_timezone",
-            ui->rng_seed_edit->setEnabled(Settings::values.rng_seed.GetValue().has_value());
+                                          !Settings::values.time_zone_index.UsingGlobal());
-            if (Settings::values.rng_seed.GetValue().has_value()) {
+        ConfigurationShared::SetHighlight(ui->label_sound, "label_sound",
-                ui->rng_seed_edit->setText(rng_seed);
+                                          !Settings::values.sound_index.UsingGlobal());
-            }
-        }
-        if (Settings::values.custom_rtc.UsingGlobal()) {
-            ui->custom_rtc_checkbox->setCheckState(Qt::PartiallyChecked);
-        } else {
-            ui->custom_rtc_checkbox->setCheckState(
-                Settings::values.custom_rtc.GetValue().has_value() ? Qt::Checked : Qt::Unchecked);
-            ui->custom_rtc_edit->setEnabled(Settings::values.custom_rtc.GetValue().has_value());
-            if (Settings::values.custom_rtc.GetValue().has_value()) {
-                ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time.count()));
-            }
-        }
    }
 }
@@ -161,37 +148,44 @@ void ConfigureSystem::ApplyConfiguration() {
                                                 ui->combo_time_zone);
        ConfigurationShared::ApplyPerGameSetting(&Settings::values.sound_index, ui->combo_sound);
-        switch (ui->rng_seed_checkbox->checkState()) {
+        switch (use_rng_seed) {
-        case Qt::Checked:
+        case ConfigurationShared::CheckState::On:
-            Settings::values.rng_seed.SetGlobal(false);
+        case ConfigurationShared::CheckState::Off:
-            Settings::values.rng_seed.SetValue(ui->rng_seed_edit->text().toULongLong(nullptr, 16));
-            break;
-        case Qt::Unchecked:
            Settings::values.rng_seed.SetGlobal(false);
-            Settings::values.rng_seed.SetValue(std::nullopt);
+            if (ui->rng_seed_checkbox->isChecked()) {
+                Settings::values.rng_seed.SetValue(
+                    ui->rng_seed_edit->text().toULongLong(nullptr, 16));
+            } else {
+                Settings::values.rng_seed.SetValue(std::nullopt);
+            }
            break;
-        case Qt::PartiallyChecked:
+        case ConfigurationShared::CheckState::Global:
            Settings::values.rng_seed.SetGlobal(false);
            Settings::values.rng_seed.SetValue(std::nullopt);
            Settings::values.rng_seed.SetGlobal(true);
            break;
+        case ConfigurationShared::CheckState::Count:
+            break;
        }
-        switch (ui->custom_rtc_checkbox->checkState()) {
+        switch (use_custom_rtc) {
-        case Qt::Checked:
+        case ConfigurationShared::CheckState::On:
-            Settings::values.custom_rtc.SetGlobal(false);
+        case ConfigurationShared::CheckState::Off:
-            Settings::values.custom_rtc.SetValue(
-                std::chrono::seconds(ui->custom_rtc_edit->dateTime().toSecsSinceEpoch()));
-            break;
-        case Qt::Unchecked:
            Settings::values.custom_rtc.SetGlobal(false);
-            Settings::values.custom_rtc.SetValue(std::nullopt);
+            if (ui->custom_rtc_checkbox->isChecked()) {
+                Settings::values.custom_rtc.SetValue(
+                    std::chrono::seconds(ui->custom_rtc_edit->dateTime().toSecsSinceEpoch()));
+            } else {
+                Settings::values.custom_rtc.SetValue(std::nullopt);
+            }
            break;
-        case Qt::PartiallyChecked:
+        case ConfigurationShared::CheckState::Global:
            Settings::values.custom_rtc.SetGlobal(false);
            Settings::values.custom_rtc.SetValue(std::nullopt);
            Settings::values.custom_rtc.SetGlobal(true);
            break;
+        case ConfigurationShared::CheckState::Count:
+            break;
        }
    }
@@ -229,10 +223,23 @@ void ConfigureSystem::SetupPerGameUI() {
        return;
    }
-    ConfigurationShared::InsertGlobalItem(ui->combo_language);
+    ConfigurationShared::SetColoredComboBox(ui->combo_language, ui->label_language,
-    ConfigurationShared::InsertGlobalItem(ui->combo_region);
+                                            "label_language",
-    ConfigurationShared::InsertGlobalItem(ui->combo_time_zone);
+                                            Settings::values.language_index.GetValue(true));
-    ConfigurationShared::InsertGlobalItem(ui->combo_sound);
+    ConfigurationShared::SetColoredComboBox(ui->combo_region, ui->label_region, "label_region",
-    ui->rng_seed_checkbox->setTristate(true);
+                                            Settings::values.region_index.GetValue(true));
-    ui->custom_rtc_checkbox->setTristate(true);
+    ConfigurationShared::SetColoredComboBox(ui->combo_time_zone, ui->label_timezone,
+                                            "label_timezone",
+                                            Settings::values.time_zone_index.GetValue(true));
+    ConfigurationShared::SetColoredComboBox(ui->combo_sound, ui->label_sound, "label_sound",
+                                            Settings::values.sound_index.GetValue(true));
+    ConfigurationShared::SetColoredTristate(
+        ui->rng_seed_checkbox, "rng_seed_checkbox", Settings::values.rng_seed.UsingGlobal(),
+        Settings::values.rng_seed.GetValue().has_value(),
+        Settings::values.rng_seed.GetValue(true).has_value(), use_rng_seed);
+    ConfigurationShared::SetColoredTristate(
+        ui->custom_rtc_checkbox, "custom_rtc_checkbox", Settings::values.custom_rtc.UsingGlobal(),
+        Settings::values.custom_rtc.GetValue().has_value(),
+        Settings::values.custom_rtc.GetValue(true).has_value(), use_custom_rtc);
 }
diff --git a/src/yuzu/configuration/configure_system.h b/src/yuzu/configuration/configure_system.h
index f317ef8b5..fc5cd2945 100644
--- a/src/yuzu/configuration/configure_system.h
+++ b/src/yuzu/configuration/configure_system.h
@@ -9,6 +9,10 @@
 #include <QList>
 #include <QWidget>
+namespace ConfigurationShared {
+enum class CheckState;
+}
 namespace Ui {
 class ConfigureSystem;
 }
@@ -41,4 +45,7 @@ private:
    int region_index = 0;
    int time_zone_index = 0;
    int sound_index = 0;
+    ConfigurationShared::CheckState use_rng_seed;
+    ConfigurationShared::CheckState use_custom_rtc;
 };
diff --git a/src/yuzu/configuration/configure_system.ui b/src/yuzu/configuration/configure_system.ui
index 9c8cca6dc..53b95658b 100644
--- a/src/yuzu/configuration/configure_system.ui
+++ b/src/yuzu/configuration/configure_system.ui
@@ -21,490 +21,494 @@
       <property name="title">
        <string>System Settings</string>
       </property>
-       <layout class="QGridLayout" name="gridLayout">
+       <layout class="QVBoxLayout" name="verticalLayout_2">
-        <item row="3" column="0">
+        <item>
-         <widget class="QLabel" name="label_sound">
+         <layout class="QGridLayout" name="gridLayout_2">
-          <property name="text">
+          <item row="1" column="0">
-           <string>Sound output mode</string>
+           <widget class="QLabel" name="label_region">
-          </property>
+            <property name="text">
-         </widget>
+             <string>Region:</string>
-        </item>
+            </property>
-        <item row="4" column="0">
+           </widget>
-         <widget class="QLabel" name="label_console_id">
+          </item>
-          <property name="text">
+          <item row="2" column="1">
-           <string>Console ID:</string>
+           <widget class="QComboBox" name="combo_time_zone">
-          </property>
+            <item>
-         </widget>
+             <property name="text">
-        </item>
+              <string>Auto</string>
-        <item row="0" column="1">
+             </property>
-         <widget class="QComboBox" name="combo_language">
+            </item>
-          <property name="toolTip">
+            <item>
-           <string>Note: this can be overridden when region setting is auto-select</string>
+             <property name="text">
-          </property>
+              <string>Default</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Japanese (日本語)</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>CET</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>English</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>CST6CDT</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>French (français)</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>Cuba</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>German (Deutsch)</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>EET</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Italian (italiano)</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>Egypt</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Spanish (español)</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>Eire</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Chinese</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>EST</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Korean (한국어)</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>EST5EDT</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Dutch (Nederlands)</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>GB</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Portuguese (português)</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>GB-Eire</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Russian (Русский)</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>GMT</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Taiwanese</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>GMT+0</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>British English</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>GMT-0</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Canadian French</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>GMT0</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Latin American Spanish</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>Greenwich</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Simplified Chinese</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>Hongkong</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Traditional Chinese (正體中文)</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>HST</string>
-         </widget>
+             </property>
-        </item>
+            </item>
-        <item row="1" column="0">
+            <item>
-         <widget class="QLabel" name="label_region">
+             <property name="text">
-          <property name="text">
+              <string>Iceland</string>
-           <string>Region:</string>
+             </property>
-          </property>
+            </item>
-         </widget>
+            <item>
-        </item>
+             <property name="text">
-        <item row="1" column="1">
+              <string>Iran</string>
-         <widget class="QComboBox" name="combo_region">
+             </property>
-          <item>
+            </item>
-           <property name="text">
+            <item>
-            <string>Japan</string>
+             <property name="text">
-           </property>
+              <string>Israel</string>
-          </item>
+             </property>
-          <item>
+            </item>
-           <property name="text">
+            <item>
-            <string>USA</string>
+             <property name="text">
-           </property>
+              <string>Jamaica</string>
-          </item>
+             </property>
-          <item>
+            </item>
-           <property name="text">
+            <item>
-            <string>Europe</string>
+             <property name="text">
-           </property>
+              <string>Japan</string>
-          </item>
+             </property>
-          <item>
+            </item>
-           <property name="text">
+            <item>
-            <string>Australia</string>
+             <property name="text">
-           </property>
+              <string>Kwajalein</string>
-          </item>
+             </property>
-          <item>
+            </item>
-           <property name="text">
+            <item>
-            <string>China</string>
+             <property name="text">
-           </property>
+              <string>Libya</string>
-          </item>
+             </property>
-          <item>
+            </item>
-           <property name="text">
+            <item>
-            <string>Korea</string>
+             <property name="text">
-           </property>
+              <string>MET</string>
-          </item>
+             </property>
-          <item>
+            </item>
-           <property name="text">
+            <item>
-            <string>Taiwan</string>
+             <property name="text">
-           </property>
+              <string>MST</string>
-          </item>
+             </property>
-         </widget>
+            </item>
-        </item>
+            <item>
-        <item row="2" column="0">
+             <property name="text">
-         <widget class="QLabel" name="label_timezone">
+              <string>MST7MDT</string>
-          <property name="text">
+             </property>
-           <string>Time Zone:</string>
+            </item>
-          </property>
+            <item>
-         </widget>
+             <property name="text">
-        </item>
+              <string>Navajo</string>
-        <item row="2" column="1">
+             </property>
-         <widget class="QComboBox" name="combo_time_zone">
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>Auto</string>
+              <string>NZ</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>Default</string>
+              <string>NZ-CHAT</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>CET</string>
+              <string>Poland</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>CST6CDT</string>
+              <string>Portugal</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>Cuba</string>
+              <string>PRC</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>EET</string>
+              <string>PST8PDT</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>Egypt</string>
+              <string>ROC</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>Eire</string>
+              <string>ROK</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>EST</string>
+              <string>Singapore</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>EST5EDT</string>
+              <string>Turkey</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>GB</string>
+              <string>UCT</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>GB-Eire</string>
+              <string>Universal</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>GMT</string>
+              <string>UTC</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>GMT+0</string>
+              <string>W-SU</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>GMT-0</string>
+              <string>WET</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+            <item>
-           <property name="text">
+             <property name="text">
-            <string>GMT0</string>
+              <string>Zulu</string>
-           </property>
+             </property>
-          </item>
+            </item>
-          <item>
+           </widget>
-           <property name="text">
+          </item>
-            <string>Greenwich</string>
+          <item row="1" column="1">
-           </property>
+           <widget class="QComboBox" name="combo_region">
-          </item>
+            <item>
-          <item>
+             <property name="text">
-           <property name="text">
+              <string>Japan</string>
-            <string>Hongkong</string>
+             </property>
-           </property>
+            </item>
-          </item>
+            <item>
-          <item>
+             <property name="text">
-           <property name="text">
+              <string>USA</string>
-            <string>HST</string>
+             </property>
-           </property>
+            </item>
-          </item>
+            <item>
-          <item>
+             <property name="text">
-           <property name="text">
+              <string>Europe</string>
-            <string>Iceland</string>
+             </property>
-           </property>
+            </item>
-          </item>
+            <item>
-          <item>
+             <property name="text">
-           <property name="text">
+              <string>Australia</string>
-            <string>Iran</string>
+             </property>
-           </property>
+            </item>
-          </item>
+            <item>
-          <item>
+             <property name="text">
-           <property name="text">
+              <string>China</string>
-            <string>Israel</string>
+             </property>
-           </property>
+            </item>
-          </item>
+            <item>
-          <item>
+             <property name="text">
-           <property name="text">
+              <string>Korea</string>
-            <string>Jamaica</string>
+             </property>
-           </property>
+            </item>
-          </item>
+            <item>
-          <item>
+             <property name="text">
-           <property name="text">
+              <string>Taiwan</string>
-            <string>Japan</string>
+             </property>
-           </property>
+            </item>
-          </item>
+           </widget>
-          <item>
+          </item>
-           <property name="text">
+          <item row="2" column="0">
-            <string>Kwajalein</string>
+           <widget class="QLabel" name="label_timezone">
-           </property>
+            <property name="text">
-          </item>
+             <string>Time Zone:</string>
-          <item>
+            </property>
-           <property name="text">
+           </widget>
-            <string>Libya</string>
+          </item>
-           </property>
+          <item row="0" column="1">
-          </item>
+           <widget class="QComboBox" name="combo_language">
-          <item>
+            <property name="toolTip">
-           <property name="text">
+             <string>Note: this can be overridden when region setting is auto-select</string>
-            <string>MET</string>
+            </property>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Japanese (日本語)</string>
-           <property name="text">
+             </property>
-            <string>MST</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>English</string>
-           <property name="text">
+             </property>
-            <string>MST7MDT</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>French (français)</string>
-           <property name="text">
+             </property>
-            <string>Navajo</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>German (Deutsch)</string>
-           <property name="text">
+             </property>
-            <string>NZ</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Italian (italiano)</string>
-           <property name="text">
+             </property>
-            <string>NZ-CHAT</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Spanish (español)</string>
-           <property name="text">
+             </property>
-            <string>Poland</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Chinese</string>
-           <property name="text">
+             </property>
-            <string>Portugal</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Korean (한국어)</string>
-           <property name="text">
+             </property>
-            <string>PRC</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Dutch (Nederlands)</string>
-           <property name="text">
+             </property>
-            <string>PST8PDT</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Portuguese (português)</string>
-           <property name="text">
+             </property>
-            <string>ROC</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Russian (Русский)</string>
-           <property name="text">
+             </property>
-            <string>ROK</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Taiwanese</string>
-           <property name="text">
+             </property>
-            <string>Singapore</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>British English</string>
-           <property name="text">
+             </property>
-            <string>Turkey</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Canadian French</string>
-           <property name="text">
+             </property>
-            <string>UCT</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Latin American Spanish</string>
-           <property name="text">
+             </property>
-            <string>Universal</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Simplified Chinese</string>
-           <property name="text">
+             </property>
-            <string>UTC</string>
+            </item>
-           </property>
+            <item>
-          </item>
+             <property name="text">
-          <item>
+              <string>Traditional Chinese (正體中文)</string>
-           <property name="text">
+             </property>
-            <string>W-SU</string>
+            </item>
-           </property>
+           </widget>
-          </item>
+          </item>
-          <item>
+          <item row="5" column="0">
-           <property name="text">
+           <widget class="QCheckBox" name="custom_rtc_checkbox">
-            <string>WET</string>
+            <property name="text">
-           </property>
+             <string>Custom RTC</string>
-          </item>
+            </property>
-          <item>
+           </widget>
-           <property name="text">
+          </item>
-            <string>Zulu</string>
+          <item row="0" column="0">
-           </property>
+           <widget class="QLabel" name="label_language">
-          </item>
+            <property name="text">
-         </widget>
+             <string>Language</string>
-        </item>
+            </property>
-        <item row="6" column="0">
+           </widget>
-         <widget class="QCheckBox" name="rng_seed_checkbox">
+          </item>
-          <property name="text">
+          <item row="6" column="0">
-           <string>RNG Seed</string>
+           <widget class="QCheckBox" name="rng_seed_checkbox">
-          </property>
+            <property name="text">
-         </widget>
+             <string>RNG Seed</string>
-        </item>
+            </property>
-        <item row="3" column="1">
+           </widget>
-         <widget class="QComboBox" name="combo_sound">
+          </item>
-          <item>
+          <item row="3" column="1">
-           <property name="text">
+           <widget class="QComboBox" name="combo_sound">
-            <string>Mono</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>Mono</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Stereo</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>Stereo</string>
-          <item>
+             </property>
-           <property name="text">
+            </item>
-            <string>Surround</string>
+            <item>
-           </property>
+             <property name="text">
-          </item>
+              <string>Surround</string>
-         </widget>
+             </property>
-        </item>
+            </item>
-        <item row="0" column="0">
+           </widget>
-         <widget class="QLabel" name="label_language">
+          </item>
-          <property name="text">
+          <item row="4" column="0">
-           <string>Language</string>
+           <widget class="QLabel" name="label_console_id">
-          </property>
+            <property name="text">
-         </widget>
+             <string>Console ID:</string>
-        </item>
+            </property>
-        <item row="4" column="1">
+           </widget>
-         <widget class="QPushButton" name="button_regenerate_console_id">
+          </item>
-          <property name="sizePolicy">
+          <item row="3" column="0">
-           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+           <widget class="QLabel" name="label_sound">
-            <horstretch>0</horstretch>
+            <property name="text">
-            <verstretch>0</verstretch>
+             <string>Sound output mode</string>
-           </sizepolicy>
+            </property>
-          </property>
+           </widget>
-          <property name="layoutDirection">
+          </item>
-           <enum>Qt::RightToLeft</enum>
+          <item row="5" column="1">
-          </property>
+           <widget class="QDateTimeEdit" name="custom_rtc_edit">
-          <property name="text">
+            <property name="minimumDate">
-           <string>Regenerate</string>
+             <date>
-          </property>
+              <year>1970</year>
-         </widget>
+              <month>1</month>
-        </item>
+              <day>1</day>
-        <item row="5" column="0">
+             </date>
-         <widget class="QCheckBox" name="custom_rtc_checkbox">
+            </property>
-          <property name="text">
+            <property name="displayFormat">
-           <string>Custom RTC</string>
+             <string>d MMM yyyy h:mm:ss AP</string>
-          </property>
+            </property>
-         </widget>
+           </widget>
-        </item>
+          </item>
-        <item row="5" column="1">
+          <item row="6" column="1">
-         <widget class="QDateTimeEdit" name="custom_rtc_edit">
+           <widget class="QLineEdit" name="rng_seed_edit">
-          <property name="minimumDate">
+            <property name="sizePolicy">
-           <date>
+             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
-            <year>1970</year>
+              <horstretch>0</horstretch>
-            <month>1</month>
+              <verstretch>0</verstretch>
-            <day>1</day>
+             </sizepolicy>
-           </date>
+            </property>
-          </property>
+            <property name="font">
-          <property name="displayFormat">
+             <font>
-           <string>d MMM yyyy h:mm:ss AP</string>
+              <family>Lucida Console</family>
-          </property>
+             </font>
-         </widget>
+            </property>
-        </item>
+            <property name="inputMask">
-        <item row="6" column="1">
+             <string notr="true">HHHHHHHH</string>
-         <widget class="QLineEdit" name="rng_seed_edit">
+            </property>
-          <property name="sizePolicy">
+            <property name="maxLength">
-           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+             <number>8</number>
-            <horstretch>0</horstretch>
+            </property>
-            <verstretch>0</verstretch>
+           </widget>
-           </sizepolicy>
+          </item>
-          </property>
+          <item row="4" column="1">
-          <property name="font">
+           <widget class="QPushButton" name="button_regenerate_console_id">
-           <font>
+            <property name="sizePolicy">
-            <family>Lucida Console</family>
+             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-           </font>
+              <horstretch>0</horstretch>
-          </property>
+              <verstretch>0</verstretch>
-          <property name="inputMask">
+             </sizepolicy>
-           <string notr="true">HHHHHHHH</string>
+            </property>
-          </property>
+            <property name="layoutDirection">
-          <property name="maxLength">
+             <enum>Qt::RightToLeft</enum>
-           <number>8</number>
+            </property>
-          </property>
+            <property name="text">
-         </widget>
+             <string>Regenerate</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
        </item>
       </layout>
      </widget>
diff --git a/src/yuzu/debugger/wait_tree.cpp b/src/yuzu/debugger/wait_tree.cpp
index f391a41a9..3439cb333 100644
--- a/src/yuzu/debugger/wait_tree.cpp
+++ b/src/yuzu/debugger/wait_tree.cpp
@@ -38,7 +38,10 @@ constexpr std::array<std::array<Qt::GlobalColor, 2>, 10> WaitTreeColors{{
 bool IsDarkTheme() {
    const auto& theme = UISettings::values.theme;
-    return theme == QStringLiteral("qdarkstyle") || theme == QStringLiteral("colorful_dark");
+    return theme == QStringLiteral("qdarkstyle") ||
+           theme == QStringLiteral("qdarkstyle_midnight_blue") ||
+           theme == QStringLiteral("colorful_dark") ||
+           theme == QStringLiteral("colorful_midnight_blue");
 }
 } // namespace
diff --git a/src/yuzu/game_list.cpp b/src/yuzu/game_list.cpp
index ab7fc7a24..62acc3720 100644
--- a/src/yuzu/game_list.cpp
+++ b/src/yuzu/game_list.cpp
@@ -474,28 +474,56 @@ void GameList::PopupContextMenu(const QPoint& menu_location) {
 void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, std::string path) {
    QAction* open_save_location = context_menu.addAction(tr("Open Save Data Location"));
-    QAction* open_lfs_location = context_menu.addAction(tr("Open Mod Data Location"));
+    QAction* open_mod_location = context_menu.addAction(tr("Open Mod Data Location"));
    QAction* open_transferable_shader_cache =
        context_menu.addAction(tr("Open Transferable Shader Cache"));
    context_menu.addSeparator();
+    QMenu* remove_menu = context_menu.addMenu(tr("Remove"));
+    QAction* remove_update = remove_menu->addAction(tr("Remove Installed Update"));
+    QAction* remove_dlc = remove_menu->addAction(tr("Remove All Installed DLC"));
+    QAction* remove_shader_cache = remove_menu->addAction(tr("Remove Shader Cache"));
+    QAction* remove_custom_config = remove_menu->addAction(tr("Remove Custom Configuration"));
+    remove_menu->addSeparator();
+    QAction* remove_all_content = remove_menu->addAction(tr("Remove All Installed Contents"));
    QAction* dump_romfs = context_menu.addAction(tr("Dump RomFS"));
    QAction* copy_tid = context_menu.addAction(tr("Copy Title ID to Clipboard"));
    QAction* navigate_to_gamedb_entry = context_menu.addAction(tr("Navigate to GameDB entry"));
    context_menu.addSeparator();
    QAction* properties = context_menu.addAction(tr("Properties"));
-    open_save_location->setEnabled(program_id != 0);
+    open_save_location->setVisible(program_id != 0);
+    open_mod_location->setVisible(program_id != 0);
+    open_transferable_shader_cache->setVisible(program_id != 0);
+    remove_update->setVisible(program_id != 0);
+    remove_dlc->setVisible(program_id != 0);
+    remove_shader_cache->setVisible(program_id != 0);
+    remove_all_content->setVisible(program_id != 0);
    auto it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
    navigate_to_gamedb_entry->setVisible(it != compatibility_list.end() && program_id != 0);
    connect(open_save_location, &QAction::triggered, [this, program_id, path]() {
        emit OpenFolderRequested(GameListOpenTarget::SaveData, path);
    });
-    connect(open_lfs_location, &QAction::triggered, [this, program_id, path]() {
+    connect(open_mod_location, &QAction::triggered, [this, program_id, path]() {
        emit OpenFolderRequested(GameListOpenTarget::ModData, path);
    });
    connect(open_transferable_shader_cache, &QAction::triggered,
            [this, program_id]() { emit OpenTransferableShaderCacheRequested(program_id); });
+    connect(remove_all_content, &QAction::triggered, [this, program_id]() {
+        emit RemoveInstalledEntryRequested(program_id, InstalledEntryType::Game);
+    });
+    connect(remove_update, &QAction::triggered, [this, program_id]() {
+        emit RemoveInstalledEntryRequested(program_id, InstalledEntryType::Update);
+    });
+    connect(remove_dlc, &QAction::triggered, [this, program_id]() {
+        emit RemoveInstalledEntryRequested(program_id, InstalledEntryType::AddOnContent);
+    });
+    connect(remove_shader_cache, &QAction::triggered, [this, program_id]() {
+        emit RemoveFileRequested(program_id, GameListRemoveTarget::ShaderCache);
+    });
+    connect(remove_custom_config, &QAction::triggered, [this, program_id]() {
+        emit RemoveFileRequested(program_id, GameListRemoveTarget::CustomConfiguration);
+    });
    connect(dump_romfs, &QAction::triggered,
            [this, program_id, path]() { emit DumpRomFSRequested(program_id, path); });
    connect(copy_tid, &QAction::triggered,
diff --git a/src/yuzu/game_list.h b/src/yuzu/game_list.h
index a38cb2fc3..483835cce 100644
--- a/src/yuzu/game_list.h
+++ b/src/yuzu/game_list.h
@@ -39,6 +39,17 @@ enum class GameListOpenTarget {
    ModData,
 };
+enum class GameListRemoveTarget {
+    ShaderCache,
+    CustomConfiguration,
+};
+enum class InstalledEntryType {
+    Game,
+    Update,
+    AddOnContent,
+};
 class GameList : public QWidget {
    Q_OBJECT
@@ -75,6 +86,8 @@ signals:
    void ShouldCancelWorker();
    void OpenFolderRequested(GameListOpenTarget target, const std::string& game_path);
    void OpenTransferableShaderCacheRequested(u64 program_id);
+    void RemoveInstalledEntryRequested(u64 program_id, InstalledEntryType type);
+    void RemoveFileRequested(u64 program_id, GameListRemoveTarget target);
    void DumpRomFSRequested(u64 program_id, const std::string& game_path);
    void CopyTIDRequested(u64 program_id);
    void NavigateToGamedbEntryRequested(u64 program_id,
@@ -117,8 +130,6 @@ private:
    friend class GameListSearchField;
 };
-Q_DECLARE_METATYPE(GameListOpenTarget);
 class GameListPlaceholder : public QWidget {
    Q_OBJECT
 public:
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index e6a1a80a3..e26cec78c 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -847,6 +847,9 @@ void GMainWindow::ConnectWidgetEvents() {
    connect(game_list, &GameList::OpenFolderRequested, this, &GMainWindow::OnGameListOpenFolder);
    connect(game_list, &GameList::OpenTransferableShaderCacheRequested, this,
            &GMainWindow::OnTransferableShaderCacheOpenFile);
+    connect(game_list, &GameList::RemoveInstalledEntryRequested, this,
+            &GMainWindow::OnGameListRemoveInstalledEntry);
+    connect(game_list, &GameList::RemoveFileRequested, this, &GMainWindow::OnGameListRemoveFile);
    connect(game_list, &GameList::DumpRomFSRequested, this, &GMainWindow::OnGameListDumpRomFS);
    connect(game_list, &GameList::CopyTIDRequested, this, &GMainWindow::OnGameListCopyTID);
    connect(game_list, &GameList::NavigateToGamedbEntryRequested, this,
@@ -1257,7 +1260,6 @@ void GMainWindow::OnGameListOpenFolder(GameListOpenTarget target, const std::str
    case GameListOpenTarget::SaveData: {
        open_target = tr("Save Data");
        const std::string nand_dir = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir);
-        ASSERT(program_id != 0);
        if (has_user_save) {
            // User save data
@@ -1322,14 +1324,12 @@ void GMainWindow::OnGameListOpenFolder(GameListOpenTarget target, const std::str
 }
 void GMainWindow::OnTransferableShaderCacheOpenFile(u64 program_id) {
-    ASSERT(program_id != 0);
    const QString shader_dir =
        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::ShaderDir));
-    const QString tranferable_shader_cache_folder_path =
+    const QString transferable_shader_cache_folder_path =
        shader_dir + QStringLiteral("opengl") + QDir::separator() + QStringLiteral("transferable");
    const QString transferable_shader_cache_file_path =
-        tranferable_shader_cache_folder_path + QDir::separator() +
+        transferable_shader_cache_folder_path + QDir::separator() +
        QString::fromStdString(fmt::format("{:016X}.bin", program_id));
    if (!QFile::exists(transferable_shader_cache_file_path)) {
@@ -1350,7 +1350,7 @@ void GMainWindow::OnTransferableShaderCacheOpenFile(u64 program_id) {
    param << QDir::toNativeSeparators(transferable_shader_cache_file_path);
    QProcess::startDetached(explorer, param);
 #else
-    QDesktopServices::openUrl(QUrl::fromLocalFile(tranferable_shader_cache_folder_path));
+    QDesktopServices::openUrl(QUrl::fromLocalFile(transferable_shader_cache_folder_path));
 #endif
 }
@@ -1394,6 +1394,174 @@ static bool RomFSRawCopy(QProgressDialog& dialog, const FileSys::VirtualDir& src
    return true;
 }
+void GMainWindow::OnGameListRemoveInstalledEntry(u64 program_id, InstalledEntryType type) {
+    const QString entry_type = [this, type] {
+        switch (type) {
+        case InstalledEntryType::Game:
+            return tr("Contents");
+        case InstalledEntryType::Update:
+            return tr("Update");
+        case InstalledEntryType::AddOnContent:
+            return tr("DLC");
+        default:
+            return QString{};
+        }
+    }();
+    if (QMessageBox::question(
+            this, tr("Remove Entry"), tr("Remove Installed Game %1?").arg(entry_type),
+            QMessageBox::Yes | QMessageBox::No, QMessageBox::No) != QMessageBox::Yes) {
+        return;
+    }
+    switch (type) {
+    case InstalledEntryType::Game:
+        RemoveBaseContent(program_id, entry_type);
+        [[fallthrough]];
+    case InstalledEntryType::Update:
+        RemoveUpdateContent(program_id, entry_type);
+        if (type != InstalledEntryType::Game) {
+            break;
+        }
+        [[fallthrough]];
+    case InstalledEntryType::AddOnContent:
+        RemoveAddOnContent(program_id, entry_type);
+        break;
+    }
+    FileUtil::DeleteDirRecursively(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir) + DIR_SEP +
+                                   "game_list");
+    game_list->PopulateAsync(UISettings::values.game_dirs);
+}
+void GMainWindow::RemoveBaseContent(u64 program_id, const QString& entry_type) {
+    const auto& fs_controller = Core::System::GetInstance().GetFileSystemController();
+    const auto res = fs_controller.GetUserNANDContents()->RemoveExistingEntry(program_id) ||
+                     fs_controller.GetSDMCContents()->RemoveExistingEntry(program_id);
+    if (res) {
+        QMessageBox::information(this, tr("Successfully Removed"),
+                                 tr("Successfully removed the installed base game."));
+    } else {
+        QMessageBox::warning(
+            this, tr("Error Removing %1").arg(entry_type),
+            tr("The base game is not installed in the NAND and cannot be removed."));
+    }
+}
+void GMainWindow::RemoveUpdateContent(u64 program_id, const QString& entry_type) {
+    const auto update_id = program_id | 0x800;
+    const auto& fs_controller = Core::System::GetInstance().GetFileSystemController();
+    const auto res = fs_controller.GetUserNANDContents()->RemoveExistingEntry(update_id) ||
+                     fs_controller.GetSDMCContents()->RemoveExistingEntry(update_id);
+    if (res) {
+        QMessageBox::information(this, tr("Successfully Removed"),
+                                 tr("Successfully removed the installed update."));
+    } else {
+        QMessageBox::warning(this, tr("Error Removing %1").arg(entry_type),
+                             tr("There is no update installed for this title."));
+    }
+}
+void GMainWindow::RemoveAddOnContent(u64 program_id, const QString& entry_type) {
+    u32 count{};
+    const auto& fs_controller = Core::System::GetInstance().GetFileSystemController();
+    const auto dlc_entries = Core::System::GetInstance().GetContentProvider().ListEntriesFilter(
+        FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
+    for (const auto& entry : dlc_entries) {
+        if ((entry.title_id & DLC_BASE_TITLE_ID_MASK) == program_id) {
+            const auto res =
+                fs_controller.GetUserNANDContents()->RemoveExistingEntry(entry.title_id) ||
+                fs_controller.GetSDMCContents()->RemoveExistingEntry(entry.title_id);
+            if (res) {
+                ++count;
+            }
+        }
+    }
+    if (count == 0) {
+        QMessageBox::warning(this, tr("Error Removing %1").arg(entry_type),
+                             tr("There are no DLC installed for this title."));
+        return;
+    }
+    QMessageBox::information(this, tr("Successfully Removed"),
+                             tr("Successfully removed %1 installed DLC.").arg(count));
+}
+void GMainWindow::OnGameListRemoveFile(u64 program_id, GameListRemoveTarget target) {
+    const QString question = [this, target] {
+        switch (target) {
+        case GameListRemoveTarget::ShaderCache:
+            return tr("Delete Transferable Shader Cache?");
+        case GameListRemoveTarget::CustomConfiguration:
+            return tr("Remove Custom Game Configuration?");
+        default:
+            return QString{};
+        }
+    }();
+    if (QMessageBox::question(this, tr("Remove File"), question, QMessageBox::Yes | QMessageBox::No,
+                              QMessageBox::No) != QMessageBox::Yes) {
+        return;
+    }
+    switch (target) {
+    case GameListRemoveTarget::ShaderCache:
+        RemoveTransferableShaderCache(program_id);
+        break;
+    case GameListRemoveTarget::CustomConfiguration:
+        RemoveCustomConfiguration(program_id);
+        break;
+    }
+}
+void GMainWindow::RemoveTransferableShaderCache(u64 program_id) {
+    const QString shader_dir =
+        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::ShaderDir));
+    const QString transferable_shader_cache_folder_path =
+        shader_dir + QStringLiteral("opengl") + QDir::separator() + QStringLiteral("transferable");
+    const QString transferable_shader_cache_file_path =
+        transferable_shader_cache_folder_path + QDir::separator() +
+        QString::fromStdString(fmt::format("{:016X}.bin", program_id));
+    if (!QFile::exists(transferable_shader_cache_file_path)) {
+        QMessageBox::warning(this, tr("Error Removing Transferable Shader Cache"),
+                             tr("A shader cache for this title does not exist."));
+        return;
+    }
+    if (QFile::remove(transferable_shader_cache_file_path)) {
+        QMessageBox::information(this, tr("Successfully Removed"),
+                                 tr("Successfully removed the transferable shader cache."));
+    } else {
+        QMessageBox::warning(this, tr("Error Removing Transferable Shader Cache"),
+                             tr("Failed to remove the transferable shader cache."));
+    }
+}
+void GMainWindow::RemoveCustomConfiguration(u64 program_id) {
+    const QString config_dir =
+        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir));
+    const QString custom_config_file_path =
+        config_dir + QString::fromStdString(fmt::format("{:016X}.ini", program_id));
+    if (!QFile::exists(custom_config_file_path)) {
+        QMessageBox::warning(this, tr("Error Removing Custom Configuration"),
+                             tr("A custom configuration for this title does not exist."));
+        return;
+    }
+    if (QFile::remove(custom_config_file_path)) {
+        QMessageBox::information(this, tr("Successfully Removed"),
+                                 tr("Successfully removed the custom game configuration."));
+    } else {
+        QMessageBox::warning(this, tr("Error Removing Custom Configuration"),
+                             tr("Failed to remove the custom game configuration."));
+    }
+}
 void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_path) {
    const auto failed = [this] {
        QMessageBox::warning(this, tr("RomFS Extraction Failed!"),
@@ -1655,7 +1823,7 @@ void GMainWindow::OnMenuInstallToNAND() {
    ui.action_Install_File_NAND->setEnabled(false);
-    install_progress = new QProgressDialog(QStringLiteral(""), tr("Cancel"), 0, total_size, this);
+    install_progress = new QProgressDialog(QString{}, tr("Cancel"), 0, total_size, this);
    install_progress->setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint &
                                     ~Qt::WindowMaximizeButtonHint);
    install_progress->setAttribute(Qt::WA_DeleteOnClose, true);
@@ -1705,18 +1873,18 @@ void GMainWindow::OnMenuInstallToNAND() {
    install_progress->close();
    const QString install_results =
-        (new_files.isEmpty() ? QStringLiteral("")
+        (new_files.isEmpty() ? QString{}
                             : tr("%n file(s) were newly installed\n", "", new_files.size())) +
        (overwritten_files.isEmpty()
-             ? QStringLiteral("")
+             ? QString{}
             : tr("%n file(s) were overwritten\n", "", overwritten_files.size())) +
-        (failed_files.isEmpty() ? QStringLiteral("")
+        (failed_files.isEmpty() ? QString{}
                                : tr("%n file(s) failed to install\n", "", failed_files.size()));
    QMessageBox::information(this, tr("Install Results"), install_results);
-    game_list->PopulateAsync(UISettings::values.game_dirs);
    FileUtil::DeleteDirRecursively(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir) + DIR_SEP +
                                   "game_list");
+    game_list->PopulateAsync(UISettings::values.game_dirs);
    ui.action_Install_File_NAND->setEnabled(true);
 }
@@ -2213,8 +2381,7 @@ void GMainWindow::UpdateStatusBar() {
    if (shaders_building != 0) {
        shader_building_label->setText(
-            tr("Building: %1 shader").arg(shaders_building) +
+            tr("Building: %n shader(s)", "", static_cast<int>(shaders_building)));
-            (shaders_building != 1 ? QString::fromStdString("s") : QString::fromStdString("")));
        shader_building_label->setVisible(true);
    } else {
        shader_building_label->setVisible(false);
diff --git a/src/yuzu/main.h b/src/yuzu/main.h
index db573d606..73a44a3bf 100644
--- a/src/yuzu/main.h
+++ b/src/yuzu/main.h
@@ -32,6 +32,8 @@ class QPushButton;
 class QProgressDialog;
 class WaitTreeWidget;
 enum class GameListOpenTarget;
+enum class GameListRemoveTarget;
+enum class InstalledEntryType;
 class GameListPlaceholder;
 namespace Core::Frontend {
@@ -198,6 +200,8 @@ private slots:
    void OnGameListLoadFile(QString game_path);
    void OnGameListOpenFolder(GameListOpenTarget target, const std::string& game_path);
    void OnTransferableShaderCacheOpenFile(u64 program_id);
+    void OnGameListRemoveInstalledEntry(u64 program_id, InstalledEntryType type);
+    void OnGameListRemoveFile(u64 program_id, GameListRemoveTarget target);
    void OnGameListDumpRomFS(u64 program_id, const std::string& game_path);
    void OnGameListCopyTID(u64 program_id);
    void OnGameListNavigateToGamedbEntry(u64 program_id,
@@ -229,6 +233,11 @@ private slots:
    void OnLanguageChanged(const QString& locale);
 private:
+    void RemoveBaseContent(u64 program_id, const QString& entry_type);
+    void RemoveUpdateContent(u64 program_id, const QString& entry_type);
+    void RemoveAddOnContent(u64 program_id, const QString& entry_type);
+    void RemoveTransferableShaderCache(u64 program_id);
+    void RemoveCustomConfiguration(u64 program_id);
    std::optional<u64> SelectRomFSDumpTarget(const FileSys::ContentProvider&, u64 program_id);
    InstallResult InstallNSPXCI(const QString& filename);
    InstallResult InstallNCA(const QString& filename);
diff --git a/src/yuzu/uisettings.cpp b/src/yuzu/uisettings.cpp
index 738c4b2fc..a51175f36 100644
--- a/src/yuzu/uisettings.cpp
+++ b/src/yuzu/uisettings.cpp
@@ -11,6 +11,8 @@ const Themes themes{{
    {"Light Colorful", "colorful"},
    {"Dark", "qdarkstyle"},
    {"Dark Colorful", "colorful_dark"},
+    {"Midnight Blue", "qdarkstyle_midnight_blue"},
+    {"Midnight Blue Colorful", "colorful_midnight_blue"},
 }};
 Values values = {};
diff --git a/src/yuzu/uisettings.h b/src/yuzu/uisettings.h
index e82318d50..bbfeafc55 100644
--- a/src/yuzu/uisettings.h
+++ b/src/yuzu/uisettings.h
@@ -24,7 +24,7 @@ struct Shortcut {
    ContextualShortcut shortcut;
 };
-using Themes = std::array<std::pair<const char*, const char*>, 4>;
+using Themes = std::array<std::pair<const char*, const char*>, 6>;
 extern const Themes themes;
 struct GameDir {