fix license header

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -31,7 +31,6 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
     ENABLE_BUFFER_HISTORY("enable_buffer_history"),
     USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),
-    ENABLE_GPU_BUFFER_READBACK("enable_gpu_buffer_readback"),
     SYNC_MEMORY_OPERATIONS("sync_memory_operations"),
     BUFFER_REORDER_DISABLE("disable_buffer_reorder"),
     RENDERER_DEBUG("debug"),
@@ -84,10 +83,9 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     ENABLE_OVERLAY("enable_overlay"),
 
     // GPU Logging
+    GPU_LOGGING_ENABLED("gpu_logging_enabled"),
     GPU_LOG_VULKAN_CALLS("gpu_log_vulkan_calls"),
     GPU_LOG_SHADER_DUMPS("gpu_log_shader_dumps"),
-    DUMP_GUEST_SHADERS("dump_guest_shaders"),
-    DUMP_MACROS("dump_macros"),
     GPU_LOG_MEMORY_TRACKING("gpu_log_memory_tracking"),
     GPU_LOG_DRIVER_DEBUG("gpu_log_driver_debug"),
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -806,13 +806,6 @@ abstract class SettingsItem(
                     descriptionId = R.string.enable_buffer_history_description
                 )
             )
-            put(
-                SwitchSetting(
-                    BooleanSetting.ENABLE_GPU_BUFFER_READBACK,
-                    titleId = R.string.enable_gpu_buffer_readback,
-                    descriptionId = R.string.enable_gpu_buffer_readback_description
-                )
-            )
             put(
                 SwitchSetting(
                     BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS,
@@ -938,6 +931,13 @@ abstract class SettingsItem(
             )
 
             // GPU Logging settings
+            put(
+                SwitchSetting(
+                    BooleanSetting.GPU_LOGGING_ENABLED,
+                    titleId = R.string.gpu_logging_enabled,
+                    descriptionId = R.string.gpu_logging_enabled_description
+                )
+            )
             put(
                 SingleChoiceSetting(
                     ByteSetting.GPU_LOG_LEVEL,
@@ -954,13 +954,6 @@ abstract class SettingsItem(
                     descriptionId = R.string.gpu_log_vulkan_calls_description
                 )
             )
-            put(
-                SwitchSetting(
-                    BooleanSetting.DUMP_GUEST_SHADERS,
-                    titleId = R.string.dump_guest_shaders,
-                    descriptionId = R.string.dump_guest_shaders_description
-                )
-            )
             put(
                 SwitchSetting(
                     BooleanSetting.GPU_LOG_SHADER_DUMPS,
@@ -968,13 +961,6 @@ abstract class SettingsItem(
                     descriptionId = R.string.gpu_log_shader_dumps_description
                 )
             )
-            put(
-                SwitchSetting(
-                    BooleanSetting.DUMP_MACROS,
-                    titleId = R.string.dump_macros,
-                    descriptionId = R.string.dump_macros_description
-                )
-            )
             put(
                 SwitchSetting(
                     BooleanSetting.GPU_LOG_MEMORY_TRACKING,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -292,7 +292,6 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.RENDERER_FORCE_MAX_CLOCK.key)
             add(BooleanSetting.RENDERER_REACTIVE_FLUSHING.key)
             add(BooleanSetting.ENABLE_BUFFER_HISTORY.key)
-            add(BooleanSetting.ENABLE_GPU_BUFFER_READBACK.key)
             add(BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS.key)
 
             add(HeaderSetting(R.string.hacks))
@@ -1289,17 +1288,14 @@ class SettingsFragmentPresenter(
             add(ShortSetting.DEBUG_KNOBS.key)
             add(StringSetting.PROGRAM_ARGS.key)
 
-            if (!NativeConfig.isPerGameConfigLoaded()) {
-                add(HeaderSetting(R.string.gpu_logging_header))
-                add(ByteSetting.GPU_LOG_LEVEL.key)
-                add(BooleanSetting.GPU_LOG_VULKAN_CALLS.key)
-                add(BooleanSetting.DUMP_GUEST_SHADERS.key)
-                add(BooleanSetting.GPU_LOG_SHADER_DUMPS.key)
-                add(BooleanSetting.DUMP_MACROS.key)
-                add(BooleanSetting.GPU_LOG_MEMORY_TRACKING.key)
-                add(BooleanSetting.GPU_LOG_DRIVER_DEBUG.key)
-                add(IntSetting.GPU_LOG_RING_BUFFER_SIZE.key)
-            }
+            add(HeaderSetting(R.string.gpu_logging_header))
+            add(BooleanSetting.GPU_LOGGING_ENABLED.key)
+            add(ByteSetting.GPU_LOG_LEVEL.key)
+            add(BooleanSetting.GPU_LOG_VULKAN_CALLS.key)
+            add(BooleanSetting.GPU_LOG_SHADER_DUMPS.key)
+            add(BooleanSetting.GPU_LOG_MEMORY_TRACKING.key)
+            add(BooleanSetting.GPU_LOG_DRIVER_DEBUG.key)
+            add(IntSetting.GPU_LOG_RING_BUFFER_SIZE.key)
         }
     }
 

src/android/app/src/main/res/values-ar/strings.xml

@@ -569,6 +569,8 @@
 
     <!-- GPU Logging strings -->
     <string name="gpu_logging_header">تسجيل وحدة معالجة الرسومات</string>
+    <string name="gpu_logging_enabled">تمكين تسجيل وحدة معالجة الرسومات</string>
+    <string name="gpu_logging_enabled_description">تسجيل عمليات وحدة معالجة الرسومات في ملف eden_gpu.log لتصحيح أخطاء برامج تشغيل Adreno</string>
     <string name="gpu_log_level">مستوى السجل</string>
     <string name="gpu_log_level_description">مستوى التفاصيل لسجلات وحدة معالجة الرسومات (كلما زاد المستوى، زادت التفاصيل وزادت التكاليف الإضافية)</string>
     <string name="gpu_log_vulkan_calls">تسجيل استدعاءات واجهة برمجة تطبيقات Vulkan</string>

src/android/app/src/main/res/values-es/strings.xml

@@ -563,6 +563,8 @@
 
     <!-- GPU Logging strings -->
     <string name="gpu_logging_header">Registros de la GPU</string>
+    <string name="gpu_logging_enabled">Activar los registros de la GPU</string>
+    <string name="gpu_logging_enabled_description">Registra las operaciones de la GPU en eden_gpu.log para la depuración de los controladores de Adreno</string>
     <string name="gpu_log_level">Nivel de registros</string>
     <string name="gpu_log_level_description">Nivel de detalle de los registros de la GPU (más alto = más detalles, más sobrecarga)</string>
     <string name="gpu_log_vulkan_calls">Registros de llamadas del API de Vulkan</string>

src/android/app/src/main/res/values-fr/strings.xml

@@ -525,6 +525,7 @@
 
     <!-- GPU Logging strings -->
     <string name="gpu_logging_header">Journalisation GPU</string>
+    <string name="gpu_logging_enabled">Activer la journalisation GPU</string>
     <string name="gpu_log_level">Niveau de journalisation</string>
     <string name="gpu_log_vulkan_calls">Journaliser les appels API Vulkan</string>
     <string name="gpu_log_shader_dumps">Extraire les shaders</string>

src/android/app/src/main/res/values-ru/strings.xml

@@ -562,6 +562,8 @@
 
     <!-- GPU Logging strings -->
     <string name="gpu_logging_header">Ведение журнала ГПУ</string>
+    <string name="gpu_logging_enabled">Включить ведение журнала ГПУ</string>
+    <string name="gpu_logging_enabled_description">Записывать операции ГПУ в файл eden_gpu.log для отладки драйверов Adreno</string>
     <string name="gpu_log_level">Уровень журналирования</string>
     <string name="gpu_log_level_description">Уровень детализации логов ГПУ (больше значение = больше деталей, выше нагрузка)</string>
     <string name="gpu_log_vulkan_calls">Записывать вызовы Vulkan API</string>

src/android/app/src/main/res/values-uk/strings.xml

@@ -565,6 +565,8 @@
 
     <!-- GPU Logging strings -->
     <string name="gpu_logging_header">Журналювання ГП</string>
+    <string name="gpu_logging_enabled">Увімкнути журналювання ГП</string>
+    <string name="gpu_logging_enabled_description">Журналювати операції ГП до eden_gpu.log для зневадження драйверів Adreno</string>
     <string name="gpu_log_level">Рівень журналювання</string>
     <string name="gpu_log_level_description">Рівень подробиць у журналі ГП (вищий = більше подробиць, більший вплив на швидкодію)</string>
     <string name="gpu_log_vulkan_calls">Записувати виклики API Vulkan</string>

src/android/app/src/main/res/values-zh-rCN/strings.xml

@@ -559,6 +559,8 @@
 
     <!-- GPU Logging strings -->
     <string name="gpu_logging_header">GPU 日志</string>
+    <string name="gpu_logging_enabled">启用 GPU 日志</string>
+    <string name="gpu_logging_enabled_description">将 GPU 操作记录至 eden_gpu.log 以供调试 Adreno 驱动</string>
     <string name="gpu_log_level">日志等级</string>
     <string name="gpu_log_level_description">GPU 日志的详细级别(数值越高 = 细节越多,开销越大)</string>
     <string name="gpu_log_vulkan_calls">记录 Vulkan API 调用</string>

src/android/app/src/main/res/values/strings.xml

@@ -503,8 +503,6 @@
     <string name="renderer_reactive_flushing_description">Improves rendering accuracy in some games at the cost of performance.</string>
     <string name="enable_buffer_history">Enable buffer history</string>
     <string name="enable_buffer_history_description">Enables access to previous buffer states. This option may improve rendering quality and performance consistency in some games.</string>
-    <string name="enable_gpu_buffer_readback">Enable GPU Buffer Readback</string>
-    <string name="enable_gpu_buffer_readback_description">Preserves GPU-modified buffer data by reading it back before uploads. Some games require this to render certain effects properly. May cause issues if the hardware cannot handle the additional workload.</string>
     <string name="use_optimized_vertex_buffers">Optimized Vertex Buffers</string>
     <string name="use_optimized_vertex_buffers_description">Enables optimized vertex buffer binding for improved performance. Requires Mesa 26.0+ Turnip drivers/ QCOM drivers. Will crash on older Turnip drivers (25.3 and below).</string>
 
@@ -577,16 +575,14 @@
 
     <!-- GPU Logging strings -->
     <string name="gpu_logging_header">GPU Logging</string>
+    <string name="gpu_logging_enabled">Enable GPU Logging</string>
+    <string name="gpu_logging_enabled_description">Log GPU operations to eden_gpu.log for debugging Adreno drivers</string>
     <string name="gpu_log_level">Log Level</string>
     <string name="gpu_log_level_description">Detail level for GPU logs (higher = more detail, more overhead)</string>
     <string name="gpu_log_vulkan_calls">Log Vulkan API Calls</string>
     <string name="gpu_log_vulkan_calls_description">Track all Vulkan API calls in ring buffer</string>
-    <string name="gpu_log_shader_dumps">Dump SPIR-V Shaders</string>
-    <string name="gpu_log_shader_dumps_description">Save recompiled SPIR-V binaries (.spv) to dump folder. Inspect with spirv-dis/spirv-cross/spirv-val.</string>
-    <string name="dump_guest_shaders">Dump Guest (Maxwell) Shaders</string>
-    <string name="dump_guest_shaders_description">Save Maxwell guest shader bytecode files (*.ash) to dump folder. Inspect with nvdisasm.</string>
-    <string name="dump_macros">Dump Maxwell Macros</string>
-    <string name="dump_macros_description">Save Maxwell macro program files (*.macro) to dump folder. Inspect with envydis.</string>
+    <string name="gpu_log_shader_dumps">Dump Shaders</string>
+    <string name="gpu_log_shader_dumps_description">Save compiled shader SPIR-V to files</string>
     <string name="gpu_log_memory_tracking">Track GPU Memory</string>
     <string name="gpu_log_memory_tracking_description">Monitor GPU memory allocations and deallocations</string>
     <string name="gpu_log_driver_debug">Driver Debug Info</string>

src/common/CMakeLists.txt

@@ -50,6 +50,7 @@ add_library(
     elf.h
     error.cpp
     error.h
+    expected.h
     fiber.cpp
     fiber.h
     fixed_point.h

src/common/expected.h

@@ -0,0 +1,986 @@
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// This is based on the proposed implementation of std::expected (P0323)
+// https://github.com/TartanLlama/expected/blob/master/include/tl/expected.hpp
+
+#pragma once
+
+#include <type_traits>
+#include <utility>
+
+namespace Common {
+
+template <typename T, typename E>
+class Expected;
+
+template <typename E>
+class Unexpected {
+public:
+    Unexpected() = delete;
+
+    constexpr explicit Unexpected(const E& e) : m_val{e} {}
+
+    constexpr explicit Unexpected(E&& e) : m_val{std::move(e)} {}
+
+    constexpr E& value() & {
+        return m_val;
+    }
+
+    constexpr const E& value() const& {
+        return m_val;
+    }
+
+    constexpr E&& value() && {
+        return std::move(m_val);
+    }
+
+    constexpr const E&& value() const&& {
+        return std::move(m_val);
+    }
+
+private:
+    E m_val;
+};
+
+template <typename E>
+constexpr auto operator<=>(const Unexpected<E>& lhs, const Unexpected<E>& rhs) {
+    return lhs.value() <=> rhs.value();
+}
+
+struct unexpect_t {
+    constexpr explicit unexpect_t() = default;
+};
+
+namespace detail {
+
+struct no_init_t {
+    constexpr explicit no_init_t() = default;
+};
+
+/**
+ * This specialization is for when T is not trivially destructible,
+ * so the destructor must be called on destruction of `expected'
+ * Additionally, this requires E to be trivially destructible
+ */
+template <typename T, typename E, bool = std::is_trivially_destructible_v<T>>
+    requires std::is_trivially_destructible_v<E>
+struct expected_storage_base {
+    constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}
+
+    constexpr expected_storage_base(no_init_t) : m_has_val{false} {}
+
+    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
+    constexpr expected_storage_base(std::in_place_t, Args&&... args)
+        : m_val{std::forward<Args>(args)...}, m_has_val{true} {}
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
+                  nullptr>
+    constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)
+        : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}
+
+    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
+    constexpr explicit expected_storage_base(unexpect_t, Args&&... args)
+        : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
+                  nullptr>
+    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,
+                                             Args&&... args)
+        : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}
+
+    ~expected_storage_base() {
+        if (m_has_val) {
+            m_val.~T();
+        }
+    }
+
+    union {
+        T m_val;
+        Unexpected<E> m_unexpect;
+    };
+
+    bool m_has_val;
+};
+
+/**
+ * This specialization is for when T is trivially destructible,
+ * so the destructor of `expected` can be trivial
+ * Additionally, this requires E to be trivially destructible
+ */
+template <typename T, typename E>
+    requires std::is_trivially_destructible_v<E>
+struct expected_storage_base<T, E, true> {
+    constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}
+
+    constexpr expected_storage_base(no_init_t) : m_has_val{false} {}
+
+    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
+    constexpr expected_storage_base(std::in_place_t, Args&&... args)
+        : m_val{std::forward<Args>(args)...}, m_has_val{true} {}
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
+                  nullptr>
+    constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)
+        : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}
+
+    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
+    constexpr explicit expected_storage_base(unexpect_t, Args&&... args)
+        : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
+                  nullptr>
+    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,
+                                             Args&&... args)
+        : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}
+
+    ~expected_storage_base() = default;
+
+    union {
+        T m_val;
+        Unexpected<E> m_unexpect;
+    };
+
+    bool m_has_val;
+};
+
+template <typename T, typename E>
+struct expected_operations_base : expected_storage_base<T, E> {
+    using expected_storage_base<T, E>::expected_storage_base;
+
+    template <typename... Args>
+    void construct(Args&&... args) noexcept {
+        new (std::addressof(this->m_val)) T{std::forward<Args>(args)...};
+        this->m_has_val = true;
+    }
+
+    template <typename Rhs>
+    void construct_with(Rhs&& rhs) noexcept {
+        new (std::addressof(this->m_val)) T{std::forward<Rhs>(rhs).get()};
+        this->m_has_val = true;
+    }
+
+    template <typename... Args>
+    void construct_error(Args&&... args) noexcept {
+        new (std::addressof(this->m_unexpect)) Unexpected<E>{std::forward<Args>(args)...};
+        this->m_has_val = false;
+    }
+
+    void assign(const expected_operations_base& rhs) noexcept {
+        if (!this->m_has_val && rhs.m_has_val) {
+            geterr().~Unexpected<E>();
+            construct(rhs.get());
+        } else {
+            assign_common(rhs);
+        }
+    }
+
+    void assign(expected_operations_base&& rhs) noexcept {
+        if (!this->m_has_val && rhs.m_has_val) {
+            geterr().~Unexpected<E>();
+            construct(std::move(rhs).get());
+        } else {
+            assign_common(rhs);
+        }
+    }
+
+    template <typename Rhs>
+    void assign_common(Rhs&& rhs) {
+        if (this->m_has_val) {
+            if (rhs.m_has_val) {
+                get() = std::forward<Rhs>(rhs).get();
+            } else {
+                destroy_val();
+                construct_error(std::forward<Rhs>(rhs).geterr());
+            }
+        } else {
+            if (!rhs.m_has_val) {
+                geterr() = std::forward<Rhs>(rhs).geterr();
+            }
+        }
+    }
+
+    bool has_value() const {
+        return this->m_has_val;
+    }
+
+    constexpr T& get() & {
+        return this->m_val;
+    }
+
+    constexpr const T& get() const& {
+        return this->m_val;
+    }
+
+    constexpr T&& get() && {
+        return std::move(this->m_val);
+    }
+
+    constexpr const T&& get() const&& {
+        return std::move(this->m_val);
+    }
+
+    constexpr Unexpected<E>& geterr() & {
+        return this->m_unexpect;
+    }
+
+    constexpr const Unexpected<E>& geterr() const& {
+        return this->m_unexpect;
+    }
+
+    constexpr Unexpected<E>&& geterr() && {
+        return std::move(this->m_unexpect);
+    }
+
+    constexpr const Unexpected<E>&& geterr() const&& {
+        return std::move(this->m_unexpect);
+    }
+
+    constexpr void destroy_val() {
+        get().~T();
+    }
+};
+
+/**
+ * This manages conditionally having a trivial copy constructor
+ * This specialization is for when T is trivially copy constructible
+ * Additionally, this requires E to be trivially copy constructible
+ */
+template <typename T, typename E, bool = std::is_trivially_copy_constructible_v<T>>
+    requires std::is_trivially_copy_constructible_v<E>
+struct expected_copy_base : expected_operations_base<T, E> {
+    using expected_operations_base<T, E>::expected_operations_base;
+};
+
+/**
+ * This specialization is for when T is not trivially copy constructible
+ * Additionally, this requires E to be trivially copy constructible
+ */
+template <typename T, typename E>
+    requires std::is_trivially_copy_constructible_v<E>
+struct expected_copy_base<T, E, false> : expected_operations_base<T, E> {
+    using expected_operations_base<T, E>::expected_operations_base;
+
+    expected_copy_base() = default;
+
+    expected_copy_base(const expected_copy_base& rhs)
+        : expected_operations_base<T, E>{no_init_t{}} {
+        if (rhs.has_value()) {
+            this->construct_with(rhs);
+        } else {
+            this->construct_error(rhs.geterr());
+        }
+    }
+
+    expected_copy_base(expected_copy_base&&) = default;
+
+    expected_copy_base& operator=(const expected_copy_base&) = default;
+
+    expected_copy_base& operator=(expected_copy_base&&) = default;
+};
+
+/**
+ * This manages conditionally having a trivial move constructor
+ * This specialization is for when T is trivially move constructible
+ * Additionally, this requires E to be trivially move constructible
+ */
+template <typename T, typename E, bool = std::is_trivially_move_constructible_v<T>>
+    requires std::is_trivially_move_constructible_v<E>
+struct expected_move_base : expected_copy_base<T, E> {
+    using expected_copy_base<T, E>::expected_copy_base;
+};
+
+/**
+ * This specialization is for when T is not trivially move constructible
+ * Additionally, this requires E to be trivially move constructible
+ */
+template <typename T, typename E>
+    requires std::is_trivially_move_constructible_v<E>
+struct expected_move_base<T, E, false> : expected_copy_base<T, E> {
+    using expected_copy_base<T, E>::expected_copy_base;
+
+    expected_move_base() = default;
+
+    expected_move_base(const expected_move_base&) = default;
+
+    expected_move_base(expected_move_base&& rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
+        : expected_copy_base<T, E>{no_init_t{}} {
+        if (rhs.has_value()) {
+            this->construct_with(std::move(rhs));
+        } else {
+            this->construct_error(std::move(rhs.geterr()));
+        }
+    }
+
+    expected_move_base& operator=(const expected_move_base&) = default;
+
+    expected_move_base& operator=(expected_move_base&&) = default;
+};
+
+/**
+ * This manages conditionally having a trivial copy assignment operator
+ * This specialization is for when T is trivially copy assignable
+ * Additionally, this requires E to be trivially copy assignable
+ */
+template <typename T, typename E,
+          bool = std::conjunction_v<std::is_trivially_copy_assignable<T>,
+                                    std::is_trivially_copy_constructible<T>,
+                                    std::is_trivially_destructible<T>>>
+    requires std::conjunction_v<std::is_trivially_copy_assignable<E>,
+                                std::is_trivially_copy_constructible<E>,
+                                std::is_trivially_destructible<E>>
+struct expected_copy_assign_base : expected_move_base<T, E> {
+    using expected_move_base<T, E>::expected_move_base;
+};
+
+/**
+ * This specialization is for when T is not trivially copy assignable
+ * Additionally, this requires E to be trivially copy assignable
+ */
+template <typename T, typename E>
+    requires std::conjunction_v<std::is_trivially_copy_assignable<E>,
+                                std::is_trivially_copy_constructible<E>,
+                                std::is_trivially_destructible<E>>
+struct expected_copy_assign_base<T, E, false> : expected_move_base<T, E> {
+    using expected_move_base<T, E>::expected_move_base;
+
+    expected_copy_assign_base() = default;
+
+    expected_copy_assign_base(const expected_copy_assign_base&) = default;
+
+    expected_copy_assign_base(expected_copy_assign_base&&) = default;
+
+    expected_copy_assign_base& operator=(const expected_copy_assign_base& rhs) {
+        this->assign(rhs);
+        return *this;
+    }
+
+    expected_copy_assign_base& operator=(expected_copy_assign_base&&) = default;
+};
+
+/**
+ * This manages conditionally having a trivial move assignment operator
+ * This specialization is for when T is trivially move assignable
+ * Additionally, this requires E to be trivially move assignable
+ */
+template <typename T, typename E,
+          bool = std::conjunction_v<std::is_trivially_move_assignable<T>,
+                                    std::is_trivially_move_constructible<T>,
+                                    std::is_trivially_destructible<T>>>
+    requires std::conjunction_v<std::is_trivially_move_assignable<E>,
+                                std::is_trivially_move_constructible<E>,
+                                std::is_trivially_destructible<E>>
+struct expected_move_assign_base : expected_copy_assign_base<T, E> {
+    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
+};
+
+/**
+ * This specialization is for when T is not trivially move assignable
+ * Additionally, this requires E to be trivially move assignable
+ */
+template <typename T, typename E>
+    requires std::conjunction_v<std::is_trivially_move_assignable<E>,
+                                std::is_trivially_move_constructible<E>,
+                                std::is_trivially_destructible<E>>
+struct expected_move_assign_base<T, E, false> : expected_copy_assign_base<T, E> {
+    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
+
+    expected_move_assign_base() = default;
+
+    expected_move_assign_base(const expected_move_assign_base&) = default;
+
+    expected_move_assign_base(expected_move_assign_base&&) = default;
+
+    expected_move_assign_base& operator=(const expected_move_assign_base&) = default;
+
+    expected_move_assign_base& operator=(expected_move_assign_base&& rhs) noexcept(
+        std::conjunction_v<std::is_nothrow_move_constructible<T>,
+                           std::is_nothrow_move_assignable<T>>) {
+        this->assign(std::move(rhs));
+        return *this;
+    }
+};
+
+/**
+ * expected_delete_ctor_base will conditionally delete copy and move constructors
+ * depending on whether T is copy/move constructible
+ * Additionally, this requires E to be copy/move constructible
+ */
+template <typename T, typename E, bool EnableCopy = std::is_copy_constructible_v<T>,
+          bool EnableMove = std::is_move_constructible_v<T>>
+    requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
+struct expected_delete_ctor_base {
+    expected_delete_ctor_base() = default;
+    expected_delete_ctor_base(const expected_delete_ctor_base&) = default;
+    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;
+    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
+    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
+};
+
+template <typename T, typename E>
+    requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
+struct expected_delete_ctor_base<T, E, true, false> {
+    expected_delete_ctor_base() = default;
+    expected_delete_ctor_base(const expected_delete_ctor_base&) = default;
+    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;
+    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
+    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
+};
+
+template <typename T, typename E>
+    requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
+struct expected_delete_ctor_base<T, E, false, true> {
+    expected_delete_ctor_base() = default;
+    expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;
+    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;
+    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
+    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
+};
+
+template <typename T, typename E>
+    requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
+struct expected_delete_ctor_base<T, E, false, false> {
+    expected_delete_ctor_base() = default;
+    expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;
+    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;
+    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
+    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
+};
+
+/**
+ * expected_delete_assign_base will conditionally delete copy and move assignment operators
+ * depending on whether T is copy/move constructible + assignable
+ * Additionally, this requires E to be copy/move constructible + assignable
+ */
+template <
+    typename T, typename E,
+    bool EnableCopy = std::conjunction_v<std::is_copy_constructible<T>, std::is_copy_assignable<T>>,
+    bool EnableMove = std::conjunction_v<std::is_move_constructible<T>, std::is_move_assignable<T>>>
+    requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
+                                std::is_copy_assignable<E>, std::is_move_assignable<E>>
+struct expected_delete_assign_base {
+    expected_delete_assign_base() = default;
+    expected_delete_assign_base(const expected_delete_assign_base&) = default;
+    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
+    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;
+    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;
+};
+
+template <typename T, typename E>
+    requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
+                                std::is_copy_assignable<E>, std::is_move_assignable<E>>
+struct expected_delete_assign_base<T, E, true, false> {
+    expected_delete_assign_base() = default;
+    expected_delete_assign_base(const expected_delete_assign_base&) = default;
+    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
+    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;
+    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;
+};
+
+template <typename T, typename E>
+    requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
+                                std::is_copy_assignable<E>, std::is_move_assignable<E>>
+struct expected_delete_assign_base<T, E, false, true> {
+    expected_delete_assign_base() = default;
+    expected_delete_assign_base(const expected_delete_assign_base&) = default;
+    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
+    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;
+    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;
+};
+
+template <typename T, typename E>
+    requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
+                                std::is_copy_assignable<E>, std::is_move_assignable<E>>
+struct expected_delete_assign_base<T, E, false, false> {
+    expected_delete_assign_base() = default;
+    expected_delete_assign_base(const expected_delete_assign_base&) = default;
+    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
+    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;
+    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;
+};
+
+/**
+ * This is needed to be able to construct the expected_default_ctor_base which follows,
+ * while still conditionally deleting the default constructor.
+ */
+struct default_constructor_tag {
+    constexpr explicit default_constructor_tag() = default;
+};
+
+/**
+ * expected_default_ctor_base will ensure that expected
+ * has a deleted default constructor if T is not default constructible
+ * This specialization is for when T is default constructible
+ */
+template <typename T, typename E, bool Enable = std::is_default_constructible_v<T>>
+struct expected_default_ctor_base {
+    constexpr expected_default_ctor_base() noexcept = default;
+    constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;
+    constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;
+    expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;
+    expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;
+
+    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
+};
+
+template <typename T, typename E>
+struct expected_default_ctor_base<T, E, false> {
+    constexpr expected_default_ctor_base() noexcept = delete;
+    constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;
+    constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;
+    expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;
+    expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;
+
+    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
+};
+
+template <typename T, typename E, typename U>
+using expected_enable_forward_value =
+    std::enable_if_t<std::is_constructible_v<T, U&&> &&
+                     !std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> &&
+                     !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
+                     !std::is_same_v<Unexpected<E>, std::remove_cvref_t<U>>>;
+
+template <typename T, typename E, typename U, typename G, typename UR, typename GR>
+using expected_enable_from_other = std::enable_if_t<
+    std::is_constructible_v<T, UR> && std::is_constructible_v<E, GR> &&
+    !std::is_constructible_v<T, Expected<U, G>&> && !std::is_constructible_v<T, Expected<U, G>&&> &&
+    !std::is_constructible_v<T, const Expected<U, G>&> &&
+    !std::is_constructible_v<T, const Expected<U, G>&&> &&
+    !std::is_convertible_v<Expected<U, G>&, T> && !std::is_convertible_v<Expected<U, G>&&, T> &&
+    !std::is_convertible_v<const Expected<U, G>&, T> &&
+    !std::is_convertible_v<const Expected<U, G>&&, T>>;
+
+} // namespace detail
+
+template <typename T, typename E>
+class Expected : private detail::expected_move_assign_base<T, E>,
+                 private detail::expected_delete_ctor_base<T, E>,
+                 private detail::expected_delete_assign_base<T, E>,
+                 private detail::expected_default_ctor_base<T, E> {
+public:
+    using value_type = T;
+    using error_type = E;
+    using unexpected_type = Unexpected<E>;
+
+    constexpr Expected() = default;
+    constexpr Expected(const Expected&) = default;
+    constexpr Expected(Expected&&) = default;
+    Expected& operator=(const Expected&) = default;
+    Expected& operator=(Expected&&) = default;
+
+    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
+    constexpr Expected(std::in_place_t, Args&&... args)
+        : impl_base{std::in_place, std::forward<Args>(args)...},
+          ctor_base{detail::default_constructor_tag{}} {}
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
+                  nullptr>
+    constexpr Expected(std::in_place_t, std::initializer_list<U> il, Args&&... args)
+        : impl_base{std::in_place, il, std::forward<Args>(args)...},
+          ctor_base{detail::default_constructor_tag{}} {}
+
+    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,
+              std::enable_if_t<!std::is_convertible_v<const G&, E>>* = nullptr>
+    constexpr explicit Expected(const Unexpected<G>& e)
+        : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}
+
+    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,
+              std::enable_if_t<std::is_convertible_v<const G&, E>>* = nullptr>
+    constexpr Expected(Unexpected<G> const& e)
+        : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}
+
+    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
+              std::enable_if_t<!std::is_convertible_v<G&&, E>>* = nullptr>
+    constexpr explicit Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
+        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
+                                                             detail::default_constructor_tag{}} {}
+
+    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
+              std::enable_if_t<std::is_convertible_v<G&&, E>>* = nullptr>
+    constexpr Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
+        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
+                                                             detail::default_constructor_tag{}} {}
+
+    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
+    constexpr explicit Expected(unexpect_t, Args&&... args)
+        : impl_base{unexpect_t{}, std::forward<Args>(args)...},
+          ctor_base{detail::default_constructor_tag{}} {}
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
+                  nullptr>
+    constexpr explicit Expected(unexpect_t, std::initializer_list<U> il, Args&&... args)
+        : impl_base{unexpect_t{}, il, std::forward<Args>(args)...},
+          ctor_base{detail::default_constructor_tag{}} {}
+
+    template <typename U, typename G,
+              std::enable_if_t<!(std::is_convertible_v<U const&, T> &&
+                                 std::is_convertible_v<G const&, E>)>* = nullptr,
+              detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>
+    constexpr explicit Expected(const Expected<U, G>& rhs)
+        : ctor_base{detail::default_constructor_tag{}} {
+        if (rhs.has_value()) {
+            this->construct(*rhs);
+        } else {
+            this->construct_error(rhs.error());
+        }
+    }
+
+    template <typename U, typename G,
+              std::enable_if_t<(std::is_convertible_v<U const&, T> &&
+                                std::is_convertible_v<G const&, E>)>* = nullptr,
+              detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>
+    constexpr Expected(const Expected<U, G>& rhs) : ctor_base{detail::default_constructor_tag{}} {
+        if (rhs.has_value()) {
+            this->construct(*rhs);
+        } else {
+            this->construct_error(rhs.error());
+        }
+    }
+
+    template <typename U, typename G,
+              std::enable_if_t<!(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =
+                  nullptr,
+              detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>
+    constexpr explicit Expected(Expected<U, G>&& rhs)
+        : ctor_base{detail::default_constructor_tag{}} {
+        if (rhs.has_value()) {
+            this->construct(std::move(*rhs));
+        } else {
+            this->construct_error(std::move(rhs.error()));
+        }
+    }
+
+    template <typename U, typename G,
+              std::enable_if_t<(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =
+                  nullptr,
+              detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>
+    constexpr Expected(Expected<U, G>&& rhs) : ctor_base{detail::default_constructor_tag{}} {
+        if (rhs.has_value()) {
+            this->construct(std::move(*rhs));
+        } else {
+            this->construct_error(std::move(rhs.error()));
+        }
+    }
+
+    template <typename U = T, std::enable_if_t<!std::is_convertible_v<U&&, T>>* = nullptr,
+              detail::expected_enable_forward_value<T, E, U>* = nullptr>
+    constexpr explicit Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}
+
+    template <typename U = T, std::enable_if_t<std::is_convertible_v<U&&, T>>* = nullptr,
+              detail::expected_enable_forward_value<T, E, U>* = nullptr>
+    constexpr Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}
+
+    template <typename U = T, typename G = T,
+              std::enable_if_t<std::is_nothrow_constructible_v<T, U&&>>* = nullptr,
+              std::enable_if_t<(
+                  !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
+                  !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&
+                  std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&
+                  std::is_nothrow_move_constructible_v<E>)>* = nullptr>
+    Expected& operator=(U&& v) {
+        if (has_value()) {
+            val() = std::forward<U>(v);
+        } else {
+            err().~Unexpected<E>();
+            new (valptr()) T{std::forward<U>(v)};
+            this->m_has_val = true;
+        }
+
+        return *this;
+    }
+
+    template <typename U = T, typename G = T,
+              std::enable_if_t<!std::is_nothrow_constructible_v<T, U&&>>* = nullptr,
+              std::enable_if_t<(
+                  !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
+                  !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&
+                  std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&
+                  std::is_nothrow_move_constructible_v<E>)>* = nullptr>
+    Expected& operator=(U&& v) {
+        if (has_value()) {
+            val() = std::forward<U>(v);
+        } else {
+            auto tmp = std::move(err());
+            err().~Unexpected<E>();
+            new (valptr()) T{std::forward<U>(v)};
+            this->m_has_val = true;
+        }
+
+        return *this;
+    }
+
+    template <typename G = E, std::enable_if_t<std::is_nothrow_copy_constructible_v<G> &&
+                                               std::is_assignable_v<G&, G>>* = nullptr>
+    Expected& operator=(const Unexpected<G>& rhs) {
+        if (!has_value()) {
+            err() = rhs;
+        } else {
+            this->destroy_val();
+            new (errptr()) Unexpected<E>{rhs};
+            this->m_has_val = false;
+        }
+
+        return *this;
+    }
+
+    template <typename G = E, std::enable_if_t<std::is_nothrow_move_constructible_v<G> &&
+                                               std::is_move_assignable_v<G>>* = nullptr>
+    Expected& operator=(Unexpected<G>&& rhs) noexcept {
+        if (!has_value()) {
+            err() = std::move(rhs);
+        } else {
+            this->destroy_val();
+            new (errptr()) Unexpected<E>{std::move(rhs)};
+            this->m_has_val = false;
+        }
+
+        return *this;
+    }
+
+    template <typename... Args,
+              std::enable_if_t<std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>
+    void emplace(Args&&... args) {
+        if (has_value()) {
+            val() = T{std::forward<Args>(args)...};
+        } else {
+            err().~Unexpected<E>();
+            new (valptr()) T{std::forward<Args>(args)...};
+            this->m_has_val = true;
+        }
+    }
+
+    template <typename... Args,
+              std::enable_if_t<!std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>
+    void emplace(Args&&... args) {
+        if (has_value()) {
+            val() = T{std::forward<Args>(args)...};
+        } else {
+            auto tmp = std::move(err());
+            err().~Unexpected<E>();
+            new (valptr()) T{std::forward<Args>(args)...};
+            this->m_has_val = true;
+        }
+    }
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
+                                                               Args&&...>>* = nullptr>
+    void emplace(std::initializer_list<U> il, Args&&... args) {
+        if (has_value()) {
+            T t{il, std::forward<Args>(args)...};
+            val() = std::move(t);
+        } else {
+            err().~Unexpected<E>();
+            new (valptr()) T{il, std::forward<Args>(args)...};
+            this->m_has_val = true;
+        }
+    }
+
+    template <typename U, typename... Args,
+              std::enable_if_t<!std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
+                                                                Args&&...>>* = nullptr>
+    void emplace(std::initializer_list<U> il, Args&&... args) {
+        if (has_value()) {
+            T t{il, std::forward<Args>(args)...};
+            val() = std::move(t);
+        } else {
+            auto tmp = std::move(err());
+            err().~Unexpected<E>();
+            new (valptr()) T{il, std::forward<Args>(args)...};
+            this->m_has_val = true;
+        }
+    }
+
+    constexpr T* operator->() {
+        return valptr();
+    }
+
+    constexpr const T* operator->() const {
+        return valptr();
+    }
+
+    template <typename U = T>
+    constexpr U& operator*() & {
+        return val();
+    }
+
+    template <typename U = T>
+    constexpr const U& operator*() const& {
+        return val();
+    }
+
+    template <typename U = T>
+    constexpr U&& operator*() && {
+        return std::move(val());
+    }
+
+    template <typename U = T>
+    constexpr const U&& operator*() const&& {
+        return std::move(val());
+    }
+
+    constexpr bool has_value() const noexcept {
+        return this->m_has_val;
+    }
+
+    constexpr explicit operator bool() const noexcept {
+        return this->m_has_val;
+    }
+
+    template <typename U = T>
+    constexpr U& value() & {
+        return val();
+    }
+
+    template <typename U = T>
+    constexpr const U& value() const& {
+        return val();
+    }
+
+    template <typename U = T>
+    constexpr U&& value() && {
+        return std::move(val());
+    }
+
+    template <typename U = T>
+    constexpr const U&& value() const&& {
+        return std::move(val());
+    }
+
+    constexpr E& error() & {
+        return err().value();
+    }
+
+    constexpr const E& error() const& {
+        return err().value();
+    }
+
+    constexpr E&& error() && {
+        return std::move(err().value());
+    }
+
+    constexpr const E&& error() const&& {
+        return std::move(err().value());
+    }
+
+    template <typename U>
+    constexpr T value_or(U&& v) const& {
+        static_assert(std::is_copy_constructible_v<T> && std::is_convertible_v<U&&, T>,
+                      "T must be copy-constructible and convertible from U&&");
+        return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));
+    }
+
+    template <typename U>
+    constexpr T value_or(U&& v) && {
+        static_assert(std::is_move_constructible_v<T> && std::is_convertible_v<U&&, T>,
+                      "T must be move-constructible and convertible from U&&");
+        return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
+    }
+
+private:
+    static_assert(!std::is_reference_v<T>, "T must not be a reference");
+    static_assert(!std::is_same_v<T, std::remove_cv_t<std::in_place_t>>,
+                  "T must not be std::in_place_t");
+    static_assert(!std::is_same_v<T, std::remove_cv_t<unexpect_t>>, "T must not be unexpect_t");
+    static_assert(!std::is_same_v<T, std::remove_cv_t<Unexpected<E>>>,
+                  "T must not be Unexpected<E>");
+    static_assert(!std::is_reference_v<E>, "E must not be a reference");
+
+    T* valptr() {
+        return std::addressof(this->m_val);
+    }
+
+    const T* valptr() const {
+        return std::addressof(this->m_val);
+    }
+
+    Unexpected<E>* errptr() {
+        return std::addressof(this->m_unexpect);
+    }
+
+    const Unexpected<E>* errptr() const {
+        return std::addressof(this->m_unexpect);
+    }
+
+    template <typename U = T>
+    constexpr U& val() {
+        return this->m_val;
+    }
+
+    template <typename U = T>
+    constexpr const U& val() const {
+        return this->m_val;
+    }
+
+    constexpr Unexpected<E>& err() {
+        return this->m_unexpect;
+    }
+
+    constexpr const Unexpected<E>& err() const {
+        return this->m_unexpect;
+    }
+
+    using impl_base = detail::expected_move_assign_base<T, E>;
+    using ctor_base = detail::expected_default_ctor_base<T, E>;
+};
+
+template <typename T, typename E, typename U, typename F>
+constexpr bool operator==(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {
+    return (lhs.has_value() != rhs.has_value())
+               ? false
+               : (!lhs.has_value() ? lhs.error() == rhs.error() : *lhs == *rhs);
+}
+
+template <typename T, typename E, typename U, typename F>
+constexpr bool operator!=(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {
+    return !operator==(lhs, rhs);
+}
+
+template <typename T, typename E, typename U>
+constexpr bool operator==(const Expected<T, E>& x, const U& v) {
+    return x.has_value() ? *x == v : false;
+}
+
+template <typename T, typename E, typename U>
+constexpr bool operator==(const U& v, const Expected<T, E>& x) {
+    return x.has_value() ? *x == v : false;
+}
+
+template <typename T, typename E, typename U>
+constexpr bool operator!=(const Expected<T, E>& x, const U& v) {
+    return !operator==(x, v);
+}
+
+template <typename T, typename E, typename U>
+constexpr bool operator!=(const U& v, const Expected<T, E>& x) {
+    return !operator==(v, x);
+}
+
+template <typename T, typename E>
+constexpr bool operator==(const Expected<T, E>& x, const Unexpected<E>& e) {
+    return x.has_value() ? false : x.error() == e.value();
+}
+
+template <typename T, typename E>
+constexpr bool operator==(const Unexpected<E>& e, const Expected<T, E>& x) {
+    return x.has_value() ? false : x.error() == e.value();
+}
+
+template <typename T, typename E>
+constexpr bool operator!=(const Expected<T, E>& x, const Unexpected<E>& e) {
+    return !operator==(x, e);
+}
+
+template <typename T, typename E>
+constexpr bool operator!=(const Unexpected<E>& e, const Expected<T, E>& x) {
+    return !operator==(e, x);
+}
+
+} // namespace Common

src/common/lru_cache.h

@@ -0,0 +1,142 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <deque>
+#include <memory>
+#include <type_traits>
+
+#include "common/common_types.h"
+
+namespace Common {
+
+template <class Traits>
+class LeastRecentlyUsedCache {
+    using ObjectType = typename Traits::ObjectType;
+    using TickType = typename Traits::TickType;
+
+    struct Item {
+        ObjectType obj;
+        TickType tick;
+        Item* next{};
+        Item* prev{};
+    };
+
+public:
+    LeastRecentlyUsedCache() : first_item{}, last_item{} {}
+    ~LeastRecentlyUsedCache() = default;
+
+    size_t Insert(ObjectType obj, TickType tick) {
+        const auto new_id = Build();
+        auto& item = item_pool[new_id];
+        item.obj = obj;
+        item.tick = tick;
+        Attach(item);
+        return new_id;
+    }
+
+    void Touch(size_t id, TickType tick) {
+        auto& item = item_pool[id];
+        if (item.tick >= tick) {
+            return;
+        }
+        item.tick = tick;
+        if (&item == last_item) {
+            return;
+        }
+        Detach(item);
+        Attach(item);
+    }
+
+    void Free(size_t id) {
+        auto& item = item_pool[id];
+        Detach(item);
+        item.prev = nullptr;
+        item.next = nullptr;
+        free_items.push_back(id);
+    }
+
+    template <typename Func>
+    void ForEachItemBelow(TickType tick, Func&& func) {
+        static constexpr bool RETURNS_BOOL =
+            std::is_same_v<std::invoke_result_t<Func, ObjectType>, bool>;
+        Item* iterator = first_item;
+        while (iterator) {
+            if (static_cast<s64>(tick) - static_cast<s64>(iterator->tick) < 0) {
+                return;
+            }
+            Item* next = iterator->next;
+            if constexpr (RETURNS_BOOL) {
+                if (func(iterator->obj)) {
+                    return;
+                }
+            } else {
+                func(iterator->obj);
+            }
+            iterator = next;
+        }
+    }
+
+private:
+    size_t Build() {
+        if (free_items.empty()) {
+            const size_t item_id = item_pool.size();
+            auto& item = item_pool.emplace_back();
+            item.next = nullptr;
+            item.prev = nullptr;
+            return item_id;
+        }
+        const size_t item_id = free_items.front();
+        free_items.pop_front();
+        auto& item = item_pool[item_id];
+        item.next = nullptr;
+        item.prev = nullptr;
+        return item_id;
+    }
+
+    void Attach(Item& item) {
+        if (!first_item) {
+            first_item = &item;
+        }
+        if (!last_item) {
+            last_item = &item;
+        } else {
+            item.prev = last_item;
+            last_item->next = &item;
+            item.next = nullptr;
+            last_item = &item;
+        }
+    }
+
+    void Detach(Item& item) {
+        if (item.prev) {
+            item.prev->next = item.next;
+        }
+        if (item.next) {
+            item.next->prev = item.prev;
+        }
+        if (&item == first_item) {
+            first_item = item.next;
+            if (first_item) {
+                first_item->prev = nullptr;
+            }
+        }
+        if (&item == last_item) {
+            last_item = item.prev;
+            if (last_item) {
+                last_item->next = nullptr;
+            }
+        }
+    }
+
+    std::deque<Item> item_pool;
+    std::deque<size_t> free_items;
+    Item* first_item{};
+    Item* last_item{};
+};
+
+} // namespace Common

src/common/settings.cpp

@@ -54,6 +54,7 @@ SWITCHABLE(CpuBackend, true);
 SWITCHABLE(CpuAccuracy, true);
 SWITCHABLE(FullscreenMode, true);
 SWITCHABLE(GpuAccuracy, true);
+SWITCHABLE(GpuLogLevel, true);
 SWITCHABLE(Language, true);
 SWITCHABLE(MemoryLayout, true);
 SWITCHABLE(NvdecEmulation, false);
@@ -212,16 +213,6 @@ bool IsNceEnabled() {
     return is_nce_enabled;
 }
 
-static u64 current_program_id = 0;
-
-void SetCurrentProgramID(u64 program_id) {
-    current_program_id = program_id;
-}
-
-u64 GetCurrentProgramID() {
-    return current_program_id;
-}
-
 bool IsDockedMode() {
     return values.use_docked_mode.GetValue() == Settings::ConsoleMode::Docked;
 }

src/common/settings.h

@@ -573,13 +573,6 @@ struct Values {
         false,
 #endif
         "rescale_hack", Category::RendererHacks};
-    SwitchableSetting<bool> enable_gpu_buffer_readback{linkage,
-                                                       false,
-                                                       "enable_gpu_buffer_readback",
-                                                       Category::RendererAdvanced,
-                                                       Specialization::Default,
-                                                       true,
-                                                       true};
 
     SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                      Category::RendererHacks};
@@ -795,8 +788,8 @@ struct Values {
                                                 false};  // runtime_modifiable_ — startup-only
     Setting<bool> dump_exefs{linkage, false, "dump_exefs", Category::Debugging};
     Setting<bool> dump_nso{linkage, false, "dump_nso", Category::Debugging};
-    Setting<bool> dump_guest_shaders{
-                               linkage, false, "dump_guest_shaders", Category::DebuggingGraphics, Specialization::Default,
+    Setting<bool> dump_shaders{
+                               linkage, false, "dump_shaders", Category::DebuggingGraphics, Specialization::Default,
                                false};
     Setting<bool> dump_macros{
                               linkage, false, "dump_macros", Category::DebuggingGraphics, Specialization::Default, false};
@@ -820,8 +813,9 @@ struct Values {
     Setting<bool> disable_web_applet{linkage, true, "disable_web_applet", Category::Debugging};
 
     // GPU Logging
-    Setting<GpuLogLevel> gpu_log_level{linkage, GpuLogLevel::Off, "gpu_log_level",
-                                       Category::Debugging};
+    Setting<bool> gpu_logging_enabled{linkage, false, "gpu_logging_enabled", Category::Debugging};
+    SwitchableSetting<GpuLogLevel> gpu_log_level{linkage, GpuLogLevel::Standard, "gpu_log_level",
+                                                   Category::Debugging};
     Setting<bool> gpu_log_vulkan_calls{linkage, true, "gpu_log_vulkan_calls", Category::Debugging};
     Setting<bool> gpu_log_shader_dumps{linkage, false, "gpu_log_shader_dumps", Category::Debugging};
     Setting<bool> gpu_log_memory_tracking{linkage, true, "gpu_log_memory_tracking",
@@ -882,9 +876,6 @@ bool IsFastmemEnabled();
 void SetNceEnabled(bool is_64bit);
 bool IsNceEnabled();
 
-void SetCurrentProgramID(u64 program_id);
-u64 GetCurrentProgramID();
-
 bool IsOpenGL();
 
 bool IsDockedMode();

src/core/core.cpp

@@ -326,9 +326,6 @@ struct System::Impl {
 
         LOG_INFO(Core, "Loading {} ({:016X}) ...", name, params.program_id);
 
-        // Expose program id to dump sites and other global readers.
-        Settings::SetCurrentProgramID(params.program_id);
-
         // Track launch time for frontend launches
         LaunchTimestampCache::SaveLaunchTimestamp(params.program_id);
 
@@ -350,7 +347,7 @@ struct System::Impl {
 
         // Register with applet manager
         // All threads are started, begin main process execution, now that we're in the clear
-        applet_manager.CreateAndInsertByFrontendAppletParameters(std::move(process), params);
+        applet_manager.CreateAndInsertByFrontendAppletParameters(std::make_unique<Service::Process>(*std::move(process)), params);
 
         if (Settings::values.gamecard_inserted) {
             if (Settings::values.gamecard_current_game) {

src/core/hle/result.h

@@ -10,6 +10,7 @@
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/expected.h"
 
 // All the constants in this file come from <https://switchbrew.org/wiki/Error_codes>
 

src/core/hle/service/am/applet.h

@@ -109,10 +109,6 @@ struct Applet {
     std::list<std::shared_ptr<Applet>> child_applets{};
     bool is_completed{};
 
-    std::shared_ptr<Applet> reserved_applet{};
-    bool unwind_after_reserved{};
-    bool is_winding{};
-
     // Self state
     bool exit_locked{};
     s32 fatal_section_count{};

src/core/hle/service/am/applet_data_broker.cpp

@@ -25,13 +25,6 @@ void AppletStorageChannel::Push(Kernel::KernelCore& kernel, std::shared_ptr<ISto
     m_event.Signal(kernel);
 }
 
-void AppletStorageChannel::Unpop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage) {
-    std::scoped_lock lk{m_lock};
-
-    m_data.emplace_front(std::move(storage));
-    m_event.Signal(kernel);
-}
-
 Result AppletStorageChannel::Pop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage>* out_storage) {
     std::scoped_lock lk{m_lock};
 

src/core/hle/service/am/applet_data_broker.h

@@ -26,7 +26,6 @@ public:
     ~AppletStorageChannel();
 
     void Push(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage);
-    void Unpop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage);
     Result Pop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage>* out_storage);
     Kernel::KReadableEvent* GetEvent();
 

src/core/hle/service/am/applet_manager.cpp

@@ -267,7 +267,7 @@ void AppletManager::SetWindowSystem(WindowSystem* window_system) {
 
     if (Settings::values.enable_overlay && m_window_system->GetOverlayDisplayApplet() == nullptr) {
         if (auto overlay_process = CreateProcess(m_system, static_cast<u64>(AppletProgramId::OverlayDisplay), 0, 0)) {
-            auto overlay_applet = std::make_shared<Applet>(m_system, std::move(overlay_process), false);
+            auto overlay_applet = std::make_shared<Applet>(m_system, std::make_unique<Service::Process>(*std::move(overlay_process)), false);
             overlay_applet->program_id = static_cast<u64>(AppletProgramId::OverlayDisplay);
             overlay_applet->applet_id = AppletId::OverlayDisplay;
             overlay_applet->type = AppletType::OverlayApplet;

src/core/hle/service/am/frontend/applet_web_browser.cpp

@@ -4,7 +4,6 @@
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "applet_web_browser_types.h"
 #include "common/assert.h"
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
@@ -371,13 +370,16 @@ void WebBrowser::ExtractOfflineRomFS() {
 
 void WebBrowser::WebBrowserExit(WebExitReason exit_reason, std::string last_url) {
     const bool use_tlv_output =
-        (web_arg_header.shim_kind == ShimKind::Share && web_applet_version >= WebAppletVersion::Version196608)
-        || (web_arg_header.shim_kind == ShimKind::Web && web_applet_version >= WebAppletVersion::Version524288)
-        || (web_arg_header.shim_kind == ShimKind::Lhub);
+        (web_arg_header.shim_kind == ShimKind::Share &&
+         web_applet_version >= WebAppletVersion::Version196608) ||
+        (web_arg_header.shim_kind == ShimKind::Web &&
+         web_applet_version >= WebAppletVersion::Version524288) ||
+        (web_arg_header.shim_kind == ShimKind::Lhub);
 
     // https://switchbrew.org/wiki/Internet_Browser#TLVs
     if (use_tlv_output) {
-        LOG_DEBUG(Service_AM, "Using TLV output: exit_reason={}, last_url={}, last_url_size={}", exit_reason, last_url, last_url.size());
+        LOG_DEBUG(Service_AM, "Using TLV output: exit_reason={}, last_url={}, last_url_size={}",
+                  exit_reason, last_url, last_url.size());
 
         // storage size for TLVs is 0x2000 bytes (as per switchbrew documentation)
         constexpr size_t TLV_STORAGE_SIZE = 0x2000;
@@ -598,14 +600,11 @@ void WebBrowser::ExecuteShare() {
 
 void WebBrowser::ExecuteWeb() {
     LOG_INFO(Service_AM, "Opening external URL at {}", external_url);
-    frontend.OpenExternalWebPage(external_url, [this](WebExitReason exit_reason, std::string last_url) {
-        // Offline and web applets must be explicitly exited from because they respect exit state
-        // Unlike the other web stuffs
-        if (exit_reason == WebExitReason::ExitRequested || exit_reason == WebExitReason::EndButtonPressed)
-            exit_reason = (web_arg_header.shim_kind == ShimKind::Web || web_arg_header.shim_kind == ShimKind::Offline)
-                ? WebExitReason::ExitRequested : WebExitReason::EndButtonPressed;
-        WebBrowserExit(exit_reason, last_url);
-    });
+
+    frontend.OpenExternalWebPage(external_url,
+                                 [this](WebExitReason exit_reason, std::string last_url) {
+                                     WebBrowserExit(exit_reason, last_url);
+                                 });
 }
 
 void WebBrowser::ExecuteWifi() {

src/core/hle/service/am/hid_registration.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -15,10 +12,7 @@ namespace Service::AM {
 
 HidRegistration::HidRegistration(Core::System& system, Process& process) : m_process(process) {
     m_hid_server = system.ServiceManager().GetService<HID::IHidServer>("hid", true);
-    this->RegisterCurrentProcess();
-}
 
-void HidRegistration::RegisterCurrentProcess() {
     if (m_process.IsInitialized()) {
         m_hid_server->GetResourceManager()->RegisterAppletResourceUserId(m_process.GetProcessId(),
                                                                          true);

src/core/hle/service/am/hid_registration.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -27,7 +24,6 @@ public:
     explicit HidRegistration(Core::System& system, Process& process);
     ~HidRegistration();
 
-    void RegisterCurrentProcess();
     void EnableAppletToGetInput(bool enable);
 
 private:

src/core/hle/service/am/lifecycle_manager.cpp

@@ -171,18 +171,6 @@ void LifecycleManager::SignalSystemEventIfNeeded(Kernel::KernelCore& kernel) {
     }
 }
 
-void LifecycleManager::ResetForRelaunch() {
-    m_unordered_messages.clear();
-
-    m_activity_state = ActivityState::BackgroundVisible;
-    m_requested_focus_state = FocusState{};
-    m_acknowledged_focus_state = FocusState{};
-    m_has_focus_state_changed = true;
-
-    m_suspend_mode = SuspendMode::NoOverride;
-    m_forced_suspend = false;
-}
-
 bool LifecycleManager::PopMessage(Kernel::KernelCore& kernel, AppletMessage* out_message) {
     const auto message = this->PopMessageInOrderOfPriority();
     this->SignalSystemEventIfNeeded(kernel);

src/core/hle/service/am/lifecycle_manager.h

@@ -138,8 +138,6 @@ public:
     void PushUnorderedMessage(Kernel::KernelCore& kernel, AppletMessage message);
     bool PopMessage(Kernel::KernelCore& kernel, AppletMessage* out_message);
 
-    void ResetForRelaunch();
-
 private:
     FocusState GetFocusStateWhileForegroundObscured() const;
     FocusState GetFocusStateWhileBackground(bool is_obscured) const;

src/core/hle/service/am/process_creation.cpp

@@ -40,23 +40,23 @@ namespace {
     }
 }
 
-[[nodiscard]] inline std::unique_ptr<Process> CreateProcessImpl(std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
+[[nodiscard]] inline std::optional<Process> CreateProcessImpl(std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
     // Get the appropriate loader to parse this NCA.
     out_loader = Loader::GetLoader(system, file, program_id, program_index);
     // Ensure we have a loader which can parse the NCA.
     if (out_loader) {
         // Try to load the process.
-        auto process = std::make_unique<Process>(system);
+        auto process = std::make_optional<Process>(system);
         if (process->Initialize(*out_loader, out_load_result)) {
             return process;
         }
     }
-    return nullptr;
+    return std::nullopt;
 }
 
 } // Anonymous namespace
 
-std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation) {
+std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation) {
     // Attempt to load program NCA.
     FileSys::VirtualFile nca_raw{};
 
@@ -66,7 +66,7 @@ std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8
 
     // Ensure we retrieved a program NCA.
     if (!nca_raw) {
-        return nullptr;
+        return std::nullopt;
     }
 
     // Ensure we have a suitable version.
@@ -76,7 +76,7 @@ std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8
             (nca.GetKeyGeneration() < minimum_key_generation ||
              nca.GetKeyGeneration() > maximum_key_generation)) {
             LOG_WARNING(Service_LDR, "Skipping program {:016X} with generation {}", program_id, nca.GetKeyGeneration());
-            return nullptr;
+            return std::nullopt;
         }
     }
 
@@ -85,7 +85,7 @@ std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8
     return CreateProcessImpl(loader, status, system, nca_raw, program_id, 0);
 }
 
-std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
+std::optional<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
     if (auto process = CreateProcessImpl(out_loader, out_load_result, system, file, program_id, program_index); process) {
         FileSys::NACP nacp;
         if (out_loader->ReadControlData(nacp) == Loader::ResultStatus::Success) {
@@ -110,23 +110,7 @@ std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control,
         system.GetARPManager().Register(launch.title_id, launch, out_control);
         return process;
     }
-    return nullptr;
-}
-
-bool ReinitializeProcess(Core::System& system, Process& process, u64 program_id) {
-    auto& storage = system.GetContentProviderUnion();
-    const auto nca_raw = storage.GetEntryRaw(program_id, FileSys::ContentRecordType::Program);
-    if (!nca_raw) {
-        return false;
-    }
-
-    auto loader = Loader::GetLoader(system, nca_raw, program_id, 0);
-    if (!loader) {
-        return false;
-    }
-
-    Loader::ResultStatus status{};
-    return process.Initialize(*loader, status);
+    return std::nullopt;
 }
 
 } // namespace Service::AM

src/core/hle/service/am/process_creation.h

@@ -27,9 +27,7 @@ class Process;
 
 namespace Service::AM {
 
-std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation);
-std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index);
-
-bool ReinitializeProcess(Core::System& system, Process& process, u64 program_id);
+std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation);
+std::optional<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index);
 
 } // namespace Service::AM

src/core/hle/service/am/service/application_creator.cpp

@@ -35,9 +35,9 @@ Result CreateGuestApplication(SharedPointer<IApplicationAccessor>* out_applicati
     std::unique_ptr<Loader::AppLoader> loader;
     Loader::ResultStatus result;
     auto process = CreateApplicationProcess(control, loader, result, system, nca_raw, program_id, 0);
-    R_UNLESS(process != nullptr, ResultUnknown);
+    R_UNLESS(process != std::nullopt, ResultUnknown);
 
-    const auto applet = std::make_shared<Applet>(system, std::move(process), true);
+    const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), true);
     applet->program_id = program_id;
     applet->applet_id = AppletId::Application;
     applet->type = AppletType::Application;
@@ -88,9 +88,9 @@ Result IApplicationCreator::CreateSystemApplication(
     std::vector<u8> control;
     std::unique_ptr<Loader::AppLoader> loader;
     auto process = CreateProcess(system, application_id, 1, 22);
-    R_UNLESS(process != nullptr, ResultUnknown);
+    R_UNLESS(process != std::nullopt, ResultUnknown);
 
-    const auto applet = std::make_shared<Applet>(system, std::move(process), true);
+    const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), true);
     applet->program_id = application_id;
     applet->applet_id = AppletId::Starter;
     applet->type = AppletType::LibraryApplet;

src/core/hle/service/am/service/library_applet_accessor.cpp

@@ -75,7 +75,7 @@ ILibraryAppletAccessor::ILibraryAppletAccessor(Core::System& system_,
         {105, D<&ILibraryAppletAccessor::GetPopOutDataEvent>, "GetPopOutDataEvent"},
         {106, D<&ILibraryAppletAccessor::GetPopInteractiveOutDataEvent>, "GetPopInteractiveOutDataEvent"},
         {110, nullptr, "NeedsToExitProcess"},
-        {120, D<&ILibraryAppletAccessor::GetLibraryAppletInfo>, "GetLibraryAppletInfo"},
+        {120, nullptr, "GetLibraryAppletInfo"},
         {150, nullptr, "RequestForAppletToGetForeground"},
         {160, D<&ILibraryAppletAccessor::GetIndirectLayerConsumerHandle>, "GetIndirectLayerConsumerHandle"}, //2.0.0+
         {170, D<&ILibraryAppletAccessor::Unknown170>, "Unknown170"}, //22.0.0+
@@ -218,16 +218,6 @@ Result ILibraryAppletAccessor::GetIndirectLayerConsumerHandle(Out<u64> out_handl
     R_SUCCEED();
 }
 
-Result ILibraryAppletAccessor::GetLibraryAppletInfo(
-    Out<LibraryAppletInfo> out_library_applet_info) {
-    LOG_INFO(Service_AM, "called");
-    *out_library_applet_info = {
-        .applet_id = m_applet->applet_id,
-        .library_applet_mode = m_applet->library_applet_mode,
-    };
-    R_SUCCEED();
-}
-
 Result ILibraryAppletAccessor::Unknown170(OutCopyHandle<Kernel::KReadableEvent> out_event) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
     *out_event = m_applet->unknown_event.GetHandle();

src/core/hle/service/am/service/library_applet_accessor.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include "core/hle/service/am/service/library_applet_self_accessor.h"
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 
@@ -22,10 +21,6 @@ public:
                                     std::shared_ptr<Applet> applet);
     ~ILibraryAppletAccessor();
 
-    std::shared_ptr<Applet> GetApplet() const {
-        return m_applet;
-    }
-
 private:
     Result GetAppletStateChangedEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result IsCompleted(Out<bool> out_is_completed);
@@ -42,7 +37,6 @@ private:
     Result GetPopOutDataEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result GetPopInteractiveOutDataEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result GetIndirectLayerConsumerHandle(Out<u64> out_handle);
-    Result GetLibraryAppletInfo(Out<LibraryAppletInfo> out_library_applet_info);
     Result Unknown170(OutCopyHandle<Kernel::KReadableEvent> out_event);
 
     void FrontendExecute();

src/core/hle/service/am/service/library_applet_creator.cpp

@@ -123,7 +123,7 @@ std::shared_ptr<ILibraryAppletAccessor> CreateGuestApplet(Core::System& system,
 
     auto process = CreateProcess(system, program_id, Firmware1400, Firmware2200);
     if (process) {
-        const auto applet = std::make_shared<Applet>(system, std::move(process), false);
+        const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), false);
         applet->program_id = program_id;
         applet->applet_id = applet_id;
         applet->type = AppletType::LibraryApplet;

src/core/hle/service/am/service/library_applet_self_accessor.cpp

@@ -233,9 +233,8 @@ Result ILibraryAppletSelfAccessor::ReportVisibleErrorWithErrorContext(
     R_SUCCEED();
 }
 
-Result ILibraryAppletSelfAccessor::UnpopInData(SharedPointer<IStorage> storage) {
-    LOG_INFO(Service_AM, "called");
-    m_broker->GetInData().Unpop(system.Kernel(), storage);
+Result ILibraryAppletSelfAccessor::UnpopInData() {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
     R_SUCCEED();
 }
 

src/core/hle/service/am/service/library_applet_self_accessor.h

@@ -72,7 +72,7 @@ private:
     Result ReportVisibleError(ErrorCode error_code);
     Result ReportVisibleErrorWithErrorContext(
         ErrorCode error_code, InLargeData<ErrorContext, BufferAttr_HipcMapAlias> error_context);
-    Result UnpopInData(SharedPointer<IStorage> storage);
+    Result UnpopInData();
     Result GetMainAppletApplicationDesiredLanguage(Out<u64> out_desired_language);
     Result GetCurrentApplicationId(Out<u64> out_application_id);
     Result GetMainAppletAvailableUsers(Out<bool> out_can_select_any_user, Out<s32> out_users_count,

src/core/hle/service/am/service/process_winding_controller.cpp

@@ -1,11 +1,9 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "core/core.h"
-#include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/frontend/applets.h"
 #include "core/hle/service/am/service/library_applet_accessor.h"
 #include "core/hle/service/am/service/process_winding_controller.h"
@@ -45,18 +43,6 @@ Result IProcessWindingController::OpenCallingLibraryApplet(
     Out<SharedPointer<ILibraryAppletAccessor>> out_calling_library_applet) {
     LOG_INFO(Service_AM, "called");
 
-    std::shared_ptr<Applet> reserved_applet;
-    {
-        std::scoped_lock lk{m_applet->lock};
-        reserved_applet = std::move(m_applet->reserved_applet);
-    }
-
-    if (reserved_applet != nullptr) {
-        *out_calling_library_applet = std::make_shared<ILibraryAppletAccessor>(
-            system, reserved_applet->caller_applet_broker, reserved_applet);
-        R_SUCCEED();
-    }
-
     const auto caller_applet = m_applet->caller_applet.lock();
     if (caller_applet == nullptr) {
         LOG_ERROR(Service_AM, "No caller applet available");
@@ -88,82 +74,22 @@ Result IProcessWindingController::PopContext(Out<SharedPointer<IStorage>> out_co
 }
 
 Result IProcessWindingController::CancelWindingReservation() {
-    LOG_INFO(Service_AM, "called");
-
-    std::scoped_lock lk{m_applet->lock};
-    m_applet->reserved_applet.reset();
-    m_applet->unwind_after_reserved = false;
-
+    LOG_WARNING(Service_AM, "STUBBED");
     R_SUCCEED();
 }
 
 Result IProcessWindingController::WindAndDoReserved() {
-    LOG_INFO(Service_AM, "called");
-
-    std::shared_ptr<Applet> reserved_applet;
-    {
-        std::scoped_lock lk{m_applet->lock};
-
-        reserved_applet = m_applet->reserved_applet;
-        m_applet->display_layer_manager.SetWindowVisibility(false);
-        m_applet->exit_locked = false;
-        system.SetExitLocked(false);
-    }
-
-    if (reserved_applet) {
-        {
-            std::scoped_lock lk{m_applet->lock};
-            m_applet->is_winding = true;
-        }
-
-        {
-            std::scoped_lock lk{reserved_applet->lock};
-            reserved_applet->window_visible = true;
-            reserved_applet->process->Run();
-        }
-
-        if (reserved_applet->frontend) {
-            reserved_applet->frontend->Initialize();
-            reserved_applet->frontend->Execute();
-        }
-    } else {
-        LOG_WARNING(Service_AM, "called without a reserved applet to start");
-    }
-
-    m_applet->process->Terminate();
-
+    LOG_WARNING(Service_AM, "STUBBED");
     R_SUCCEED();
 }
 
-Result IProcessWindingController::ReserveToStartAndWaitAndUnwindThis(
-    SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor) {
-    LOG_INFO(Service_AM, "called");
-
-    if (reserved_applet_accessor == nullptr) {
-        LOG_ERROR(Service_AM, "No applet accessor provided");
-        R_THROW(ResultUnknown);
-    }
-
-    std::scoped_lock lk{m_applet->lock};
-    m_applet->reserved_applet = reserved_applet_accessor->GetApplet();
-    m_applet->unwind_after_reserved = true;
-
+Result IProcessWindingController::ReserveToStartAndWaitAndUnwindThis() {
+    LOG_WARNING(Service_AM, "STUBBED");
     R_SUCCEED();
 }
 
-Result IProcessWindingController::ReserveToStartAndWait(
-    SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor) {
-    LOG_INFO(Service_AM, "called");
-
-    if (reserved_applet_accessor == nullptr) {
-        LOG_ERROR(Service_AM, "No applet accessor provided");
-        R_THROW(ResultUnknown);
-    }
-
-    std::scoped_lock lk{m_applet->lock};
-    m_applet->reserved_applet = reserved_applet_accessor->GetApplet();
-    m_applet->unwind_after_reserved = false;
-
+Result IProcessWindingController::ReserveToStartAndWait() {
+    LOG_WARNING(Service_AM, "STUBBED");
     R_SUCCEED();
 }
 

src/core/hle/service/am/service/process_winding_controller.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -29,9 +29,8 @@ private:
     Result PopContext(Out<SharedPointer<IStorage>> out_context);
     Result CancelWindingReservation();
     Result WindAndDoReserved();
-    Result ReserveToStartAndWaitAndUnwindThis(
-        SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor);
-    Result ReserveToStartAndWait(SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor);
+    Result ReserveToStartAndWaitAndUnwindThis();
+    Result ReserveToStartAndWait();
 
     const std::shared_ptr<Applet> m_applet;
 };

src/core/hle/service/am/window_system.cpp

@@ -9,7 +9,6 @@
 #include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/applet_manager.h"
 #include "core/hle/service/am/event_observer.h"
-#include "core/hle/service/am/process_creation.h"
 #include "core/hle/service/am/window_system.h"
 
 namespace Service::AM {
@@ -241,37 +240,6 @@ void WindowSystem::PruneTerminatedAppletsLocked() {
             continue;
         }
 
-        // A winding applet has had its own process killed but is kept alive as a transparent slot
-        // while the reserved applet running in its place finishes (see WindAndDoReserved()).
-        if (applet->is_winding) {
-            if (!applet->child_applets.empty()) {
-                it = std::next(it);
-                continue;
-            }
-
-            const bool unwind = applet->unwind_after_reserved;
-            applet->is_winding = false;
-            applet->unwind_after_reserved = false;
-
-            if (unwind && this->RestartAppletProcessLocked(applet.get())) {
-                const u64 new_aruid = applet->aruid.pid;
-                const auto next = std::next(it);
-
-                if (new_aruid != aruid) {
-                    auto node = m_applets.extract(it);
-                    node.key() = new_aruid;
-                    m_applets.insert(std::move(node));
-                }
-
-                applet->process->Run();
-                m_event_observer->RequestUpdate();
-                it = next;
-                continue;
-            }
-
-            applet->reserved_applet.reset();
-        }
-
         // Terminated, so ensure all child applets are terminated.
         if (!applet->child_applets.empty()) {
             this->TerminateChildAppletsLocked(applet.get());
@@ -333,28 +301,6 @@ void WindowSystem::PruneTerminatedAppletsLocked() {
     }
 }
 
-bool WindowSystem::RestartAppletProcessLocked(Applet* applet) {
-    if (!ReinitializeProcess(m_system, *applet->process, applet->program_id)) {
-        LOG_ERROR(Service_AM, "Failed to restart winding applet_id={}",
-                  static_cast<u32>(applet->applet_id));
-        return false;
-    }
-
-    applet->aruid.pid = applet->process->GetProcessId();
-    applet->is_process_running = false;
-    applet->is_completed = false;
-
-    applet->hid_registration.RegisterCurrentProcess();
-
-    applet->lifecycle_manager.ResetForRelaunch();
-    applet->is_activity_runnable = false;
-
-    applet->launch_reason.flag = 1;
-
-    m_event_observer->TrackAppletProcess(*applet);
-    return true;
-}
-
 bool WindowSystem::LockHomeMenuIntoForegroundLocked() {
     // If the home menu is not locked into foreground, then there's nothing to do.
     if (m_home_menu == nullptr || !m_home_menu_foreground_locked) {
@@ -406,9 +352,6 @@ void WindowSystem::UpdateAppletStateLocked(Applet* applet, bool is_foreground, b
     const bool has_obscuring_child_applets = [&] {
         for (const auto& child_applet : applet->child_applets) {
             std::scoped_lock lk2{child_applet->lock};
-            if (child_applet->is_winding) {
-                return true;
-            }
             const auto mode = child_applet->library_applet_mode;
             if (child_applet->is_process_running && child_applet->window_visible &&
                 (mode == LibraryAppletMode::AllForeground ||

src/core/hle/service/am/window_system.h

@@ -61,7 +61,6 @@ public:
 
 private:
     void PruneTerminatedAppletsLocked();
-    bool RestartAppletProcessLocked(Applet* applet);
     bool LockHomeMenuIntoForegroundLocked();
     void TerminateChildAppletsLocked(Applet* applet);
     void UpdateAppletStateLocked(Applet* applet, bool is_foreground, bool overlay_blocking = false);

src/core/hle/service/sockets/bsd.cpp

@@ -24,6 +24,9 @@
 #include "network/network.h"
 #include <common/settings.h>
 
+using Common::Expected;
+using Common::Unexpected;
+
 namespace Service::Sockets {
 
 namespace {
@@ -461,22 +464,13 @@ void BSD::DuplicateSocket(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     auto input = rp.PopRaw<InputParameters>();
 
+    Expected<s32, Errno> res = DuplicateSocketImpl(input.fd);
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
-
-    auto const res_v = DuplicateSocketImpl(input.fd);
-    if (auto* res = std::get_if<s32>(&res_v)) {
-        rb.PushRaw(OutputParameters{
-            .ret = *res,
-            .bsd_errno = Errno::SUCCESS,
-        });
-    } else {
-        auto* err = std::get_if<Errno>(&res_v);
-        rb.PushRaw(OutputParameters{
-            .ret = 0,
-            .bsd_errno = *err,
-        });
-    }
+    rb.PushRaw(OutputParameters{
+        .ret = res.value_or(0),
+        .bsd_errno = res ? Errno::SUCCESS : res.error(),
+    });
 }
 
 void BSD::EventFd(HLERequestContext& ctx) {
@@ -983,15 +977,15 @@ Errno BSD::CloseImpl(s32 fd) {
     return bsd_errno;
 }
 
-std::variant<s32, Errno> BSD::DuplicateSocketImpl(s32 fd) {
+Expected<s32, Errno> BSD::DuplicateSocketImpl(s32 fd) {
     if (!IsFileDescriptorValid(fd)) {
-        return Errno::BADF;
+        return Unexpected(Errno::BADF);
     }
 
     const s32 new_fd = FindFreeFileDescriptorHandle();
     if (new_fd < 0) {
         LOG_ERROR(Service, "No more file descriptors available");
-        return Errno::MFILE;
+        return Unexpected(Errno::MFILE);
     }
 
     file_descriptors[new_fd] = FileDescriptor{

src/core/hle/service/sockets/bsd.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -8,9 +8,9 @@
 #include <memory>
 #include <span>
 #include <vector>
-#include <variant>
 
 #include "common/common_types.h"
+#include "common/expected.h"
 #include "common/socket_types.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sockets/sockets.h"
@@ -35,7 +35,7 @@ public:
     // These methods are called from SSL; the first two are also called from
     // this class for the corresponding IPC methods.
     // On the real device, the SSL service makes IPC calls to this service.
-    std::variant<s32, Errno> DuplicateSocketImpl(s32 fd);
+    Common::Expected<s32, Errno> DuplicateSocketImpl(s32 fd);
     Errno CloseImpl(s32 fd);
     std::optional<std::shared_ptr<Network::SocketBase>> GetSocket(s32 fd);
 

src/core/hle/service/sockets/sfdnsres.cpp

@@ -88,12 +88,11 @@ static const constexpr std::array blockedDomains = {
     "sun.hac.lp1.d4c.nintendo.net",
     "phoenix-api.wbagora.com", //hogwarts legacy
     "battle.net",
-    "microsoft.com", // Minecraft dungeons + other games
+    "microsoft.com", //minecraft dungeons + other games
     "mojang.com",
     "xboxlive.com",
     "api.epicgames.dev", // marvel cosmic invasion +?
-    "minecraftservices.com",
-    "508223012e5a5ff19f30a391b2bdadc0.my.2k.com", // Civilization 5
+    "minecraftservices.com"
 };
 
 static bool IsBlockedHost(const std::string& host) {
@@ -208,15 +207,16 @@ static std::pair<u32, GetAddrInfoError> GetHostByNameRequestImpl(HLERequestConte
         return {0, GetAddrInfoError::AGAIN};
     }
 
-    auto res_v = Network::GetAddressInfo(host, /*service*/ std::nullopt);
-    if (auto* res = std::get_if<std::vector<Network::AddrInfo>>(&res_v)) {
-        const std::vector<u8> data = SerializeAddrInfoAsHostEnt(*res, host);
-        const u32 data_size = u32(data.size());
-        ctx.WriteBuffer(data, 0);
-        return {data_size, GetAddrInfoError::SUCCESS};
+    auto res = Network::GetAddressInfo(host, /*service*/ std::nullopt);
+    if (!res.has_value()) {
+        return {0, Translate(res.error())};
     }
-    auto* err = std::get_if<Network::GetAddrInfoError>(&res_v);
-    return {0, Translate(*err)};
+
+    const std::vector<u8> data = SerializeAddrInfoAsHostEnt(res.value(), host);
+    const u32 data_size = static_cast<u32>(data.size());
+    ctx.WriteBuffer(data, 0);
+
+    return {data_size, GetAddrInfoError::SUCCESS};
 }
 
 void SFDNSRES::GetHostByNameRequest(HLERequestContext& ctx) {
@@ -332,15 +332,16 @@ static std::pair<u32, GetAddrInfoError> GetAddrInfoRequestImpl(HLERequestContext
 
     // Serialized hints are also passed in a buffer, but are ignored for now.
 
-    auto res_v = Network::GetAddressInfo(host, service);
-    if (auto* res = std::get_if<std::vector<Network::AddrInfo>>(&res_v)) {
-        const std::vector<u8> data = SerializeAddrInfo(*res, host);
-        const u32 data_size = u32(data.size());
-        ctx.WriteBuffer(data, 0);
-        return {data_size, GetAddrInfoError::SUCCESS};
+    auto res = Network::GetAddressInfo(host, service);
+    if (!res.has_value()) {
+        return {0, Translate(res.error())};
     }
-    auto* err = std::get_if<Network::GetAddrInfoError>(&res_v);
-    return {0, Translate(*err)};
+
+    const std::vector<u8> data = SerializeAddrInfo(res.value(), host);
+    const u32 data_size = static_cast<u32>(data.size());
+    ctx.WriteBuffer(data, 0);
+
+    return {data_size, GetAddrInfoError::SUCCESS};
 }
 
 void SFDNSRES::GetAddrInfoRequest(HLERequestContext& ctx) {

src/core/hle/service/ssl/ssl.cpp

@@ -160,26 +160,29 @@ private:
         auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD>("bsd:u");
         ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
 
-        auto const res_v = bsd->DuplicateSocketImpl(fd);
-        if (auto *res = std::get_if<s32>(&res_v)) {
-            const s32 duplicated_fd = *res;
-            if (do_not_close_socket) {
-                *out_fd = duplicated_fd;
-            } else {
-                *out_fd = -1;
-                fd_to_close = duplicated_fd;
-            }
-            std::optional<std::shared_ptr<Network::SocketBase>> sock = bsd->GetSocket(duplicated_fd);
-            if (!sock.has_value()) {
-                LOG_ERROR(Service_SSL, "invalid socket fd {} after duplication", duplicated_fd);
-                return ResultInvalidSocket;
-            }
-            socket = std::move(*sock);
-            backend->SetSocket(socket);
-            return ResultSuccess;
+        auto res = bsd->DuplicateSocketImpl(fd);
+        if (!res.has_value()) {
+            LOG_ERROR(Service_SSL, "Failed to duplicate socket with fd {}", fd);
+            return ResultInvalidSocket;
         }
-        LOG_ERROR(Service_SSL, "Failed to duplicate socket with fd {}", fd);
-        return ResultInvalidSocket;
+
+        const s32 duplicated_fd = *res;
+
+        if (do_not_close_socket) {
+            *out_fd = duplicated_fd;
+        } else {
+            *out_fd = -1;
+            fd_to_close = duplicated_fd;
+        }
+
+        std::optional<std::shared_ptr<Network::SocketBase>> sock = bsd->GetSocket(duplicated_fd);
+        if (!sock.has_value()) {
+            LOG_ERROR(Service_SSL, "invalid socket fd {} after duplication", duplicated_fd);
+            return ResultInvalidSocket;
+        }
+        socket = std::move(*sock);
+        backend->SetSocket(socket);
+        return ResultSuccess;
     }
 
     Result SetHostNameImpl(const std::string& hostname) {

src/core/internal_network/network.cpp

@@ -28,6 +28,7 @@
 
 #include "common/assert.h"
 #include "common/common_types.h"
+#include "common/expected.h"
 #include "common/logging.h"
 #include "common/settings.h"
 #include "core/internal_network/network.h"
@@ -732,14 +733,15 @@ u32 IPv4AddressToInteger(IPv4Address ip_addr) {
            static_cast<u32>(ip_addr[2]) << 8 | static_cast<u32>(ip_addr[3]);
 }
 
-std::variant<std::vector<AddrInfo>, GetAddrInfoError> GetAddressInfo(
+Common::Expected<std::vector<AddrInfo>, GetAddrInfoError> GetAddressInfo(
     const std::string& host, const std::optional<std::string>& service) {
     addrinfo hints{};
     hints.ai_family = AF_INET; // Switch only supports IPv4.
     addrinfo* addrinfo;
-    s32 gai_err = getaddrinfo(host.c_str(), service.has_value() ? service->c_str() : nullptr, &hints, &addrinfo);
+    s32 gai_err = getaddrinfo(host.c_str(), service.has_value() ? service->c_str() : nullptr,
+                              &hints, &addrinfo);
     if (gai_err != 0) {
-        return TranslateGetAddrInfoErrorFromNative(gai_err);
+        return Common::Unexpected(TranslateGetAddrInfoErrorFromNative(gai_err));
     }
     std::vector<AddrInfo> ret;
     for (auto* current = addrinfo; current; current = current->ai_next) {

src/core/internal_network/network.h

@@ -9,7 +9,6 @@
 #include <array>
 #include <optional>
 #include <vector>
-#include <variant>
 
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -125,6 +124,7 @@ std::string IPv4AddressToString(IPv4Address ip_addr);
 u32 IPv4AddressToInteger(IPv4Address ip_addr);
 
 // named to avoid name collision with Windows macro
-std::variant<std::vector<AddrInfo>, GetAddrInfoError> GetAddressInfo(const std::string& host, const std::optional<std::string>& service);
+Common::Expected<std::vector<AddrInfo>, GetAddrInfoError> GetAddressInfo(
+    const std::string& host, const std::optional<std::string>& service);
 
 } // namespace Network

src/qt_common/config/shared_translation.cpp

@@ -229,8 +229,6 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
     INSERT(Settings, dma_accuracy, tr("DMA Accuracy:"),
            tr("Controls the DMA precision accuracy. Safe precision fixes issues in some games but "
               "may degrade performance."));
-    INSERT(Settings, enable_gpu_buffer_readback, tr("Enable GPU buffer readback"),
-           tr("Preserves GPU-modified buffer data by reading it back before uploads.\nSome games require this to render certain effects properly.\nMay cause issues if the hardware cannot handle the additional workload."));
     INSERT(Settings, use_asynchronous_shaders, tr("Enable asynchronous shader compilation"),
            tr("May reduce shader stutter."));
     INSERT(Settings, fast_gpu_time, tr("Fast GPU Time"),

src/video_core/buffer_cache/buffer_base.h

@@ -109,12 +109,12 @@ public:
         return static_cast<u32>(other_cpu_addr - cpu_addr);
     }
 
-    u64 GetFrameTick() const noexcept {
-        return frame_tick;
+    size_t getLRUID() const noexcept {
+        return lru_id;
     }
 
-    void SetFrameTick(u64 tick) noexcept {
-        frame_tick = tick;
+    void setLRUID(size_t lru_id_) {
+        lru_id = lru_id_;
     }
 
     size_t SizeBytes() const {
@@ -125,7 +125,7 @@ private:
     VAddr cpu_addr = 0;
     BufferFlagBits flags{};
     int stream_score = 0;
-    u64 frame_tick = 0;
+    size_t lru_id = SIZE_MAX;
     size_t size_bytes = 0;
 };
 

src/video_core/buffer_cache/buffer_cache.h

@@ -58,22 +58,17 @@ void BufferCache<P>::RunGarbageCollector() {
     const bool aggressive_gc = total_used_memory >= critical_memory;
     const u64 ticks_to_destroy = aggressive_gc ? 60 : 120;
     int num_iterations = aggressive_gc ? 64 : 32;
-    const u64 threshold = frame_tick - ticks_to_destroy;
-    boost::container::small_vector<BufferId, 64> expired;
-    for (auto [id, buffer] : slot_buffers) {
-        if (buffer->GetFrameTick() < threshold) {
-            expired.push_back(id);
-        }
-    }
-    for (const auto buffer_id : expired) {
+    const auto clean_up = [this, &num_iterations](BufferId buffer_id) {
         if (num_iterations == 0) {
-            break;
+            return true;
         }
         --num_iterations;
         auto& buffer = slot_buffers[buffer_id];
         DownloadBufferMemory(buffer);
         DeleteBuffer(buffer_id);
-    }
+        return false;
+    };
+    lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, clean_up);
 }
 
 template <class P>
@@ -1596,9 +1591,10 @@ void BufferCache<P>::ChangeRegister(BufferId buffer_id) {
     const auto size = buffer.SizeBytes();
     if (insert) {
         total_used_memory += Common::AlignUp(size, 1024);
-        buffer.SetFrameTick(frame_tick);
+        buffer.setLRUID(lru_cache.Insert(buffer_id, frame_tick));
     } else {
         total_used_memory -= Common::AlignUp(size, 1024);
+        lru_cache.Free(buffer.getLRUID());
     }
     const DAddr device_addr_begin = buffer.CpuAddr();
     const DAddr device_addr_end = device_addr_begin + size;
@@ -1616,7 +1612,7 @@ void BufferCache<P>::ChangeRegister(BufferId buffer_id) {
 template <class P>
 void BufferCache<P>::TouchBuffer(Buffer& buffer, BufferId buffer_id) noexcept {
     if (buffer_id != NULL_BUFFER_ID) {
-        buffer.SetFrameTick(frame_tick);
+        lru_cache.Touch(buffer.getLRUID(), frame_tick);
     }
 }
 
@@ -1638,17 +1634,15 @@ bool BufferCache<P>::SynchronizeBuffer(Buffer& buffer, DAddr device_addr, u32 si
     if (total_size_bytes == 0) {
         return true;
     }
-    if (Settings::values.enable_gpu_buffer_readback.GetValue()) {
-        u64 min_offset = (std::numeric_limits<u64>::max)();
-        u64 max_offset = 0;
-        for (const auto& copy : upload_copies) {
-            min_offset = (std::min)(min_offset, copy.dst_offset);
-            max_offset = (std::max)(max_offset, copy.dst_offset + copy.size);
-        }
-        const DAddr sync_addr = buffer.CpuAddr() + min_offset;
-        const u64 sync_size = max_offset - min_offset;
-        DownloadBufferMemory(buffer, sync_addr, sync_size);
+    u64 min_offset = (std::numeric_limits<u64>::max)();
+    u64 max_offset = 0;
+    for (const auto& copy : upload_copies) {
+        min_offset = (std::min)(min_offset, copy.dst_offset);
+        max_offset = (std::max)(max_offset, copy.dst_offset + copy.size);
     }
+    const DAddr sync_addr = buffer.CpuAddr() + min_offset;
+    const u64 sync_size = max_offset - min_offset;
+    DownloadBufferMemory(buffer, sync_addr, sync_size);
     const std::span<BufferCopy> copies_span(upload_copies.data(), upload_copies.size());
     UploadMemory(buffer, total_size_bytes, largest_copy, copies_span);
     any_buffer_uploaded = true;

src/video_core/buffer_cache/buffer_cache_base.h

@@ -23,6 +23,7 @@
 #include "common/common_types.h"
 #include "common/div_ceil.h"
 #include "common/literals.h"
+#include "common/lru_cache.h"
 #include "common/range_sets.h"
 #include "common/scope_exit.h"
 #include "common/settings.h"
@@ -505,6 +506,11 @@ private:
     size_t immediate_buffer_capacity = 0;
     Common::ScratchBuffer<u8> immediate_buffer_alloc;
 
+    struct LRUItemParams {
+        using ObjectType = BufferId;
+        using TickType = u64;
+    };
+    Common::LeastRecentlyUsedCache<LRUItemParams> lru_cache;
     u64 frame_tick = 0;
     u64 total_used_memory = 0;
     u64 minimum_memory = 0;

src/video_core/dma_pusher.cpp

@@ -117,35 +117,7 @@ void DmaPusher::ProcessCommands(std::span<const CommandHeader> commands) {
             dma_state.is_last_call = true;
             index += max_write;
         } else if (dma_state.method_count) {
-            if (!dma_state.non_incrementing && !dma_increment_once &&
-                dma_state.method >= non_puller_methods) {
-                auto subchannel = subchannels[dma_state.subchannel];
-                const u32 available = u32(std::min<size_t>(
-                    index + dma_state.method_count, commands.size()) - index);
-                u32 batch = 0;
-                u32 method = dma_state.method;
-                while (batch < available) {
-                    const bool needs_exec =
-                        (method < Engines::EngineInterface::EXECUTION_MASK_TABLE_SIZE)
-                            ? subchannel->execution_mask[method]
-                            : subchannel->execution_mask_default;
-                    if (needs_exec) break;
-                    batch++;
-                    method++;
-                }
-                if (batch > 0) {
-                    auto& sink = subchannel->method_sink;
-                    sink.reserve(sink.size() + batch);
-                    for (u32 j = 0; j < batch; j++) {
-                        sink.emplace_back(dma_state.method + j, commands[index + j].argument);
-                    }
-                    dma_state.method += batch;
-                    dma_state.method_count -= batch;
-                    index += batch;
-                    continue;
-                }
-            }
-            auto const command_header = commands[index];
+            auto const command_header = commands[index]; //can copy
             dma_state.dma_word_offset = u32(index * sizeof(u32));
             dma_state.is_last_call = dma_state.method_count <= 1;
             CallMethod(command_header.argument);
@@ -204,11 +176,7 @@ void DmaPusher::CallMethod(u32 argument) {
         });
     } else {
         auto subchannel = subchannels[dma_state.subchannel];
-        const bool needs_execution =
-            (dma_state.method < Engines::EngineInterface::EXECUTION_MASK_TABLE_SIZE)
-                ? subchannel->execution_mask[dma_state.method]
-                : subchannel->execution_mask_default;
-        if (!needs_execution) {
+        if (!subchannel->execution_mask[dma_state.method]) {
             subchannel->method_sink.emplace_back(dma_state.method, argument);
         } else {
             subchannel->ConsumeSink(system);

src/video_core/engines/draw_manager.cpp

@@ -4,8 +4,6 @@
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <cstring>
-
 #include "common/settings.h"
 #include "video_core/dirty_flags.h"
 #include "video_core/engines/maxwell_3d.h"
@@ -132,44 +130,6 @@ void Maxwell3D::DrawManager::SetInlineIndexBuffer(Maxwell3D& maxwell3d, u32 inde
     draw_state.draw_mode = DrawMode::InlineIndex;
 }
 
-void Maxwell3D::DrawManager::SetInlineIndexBuffer(Maxwell3D& maxwell3d, u32 method,
-                                                  const u32* base_start, u32 amount) {
-    auto& index_buffer = draw_state.inline_index_draw_indexes;
-    switch (method) {
-    case MAXWELL3D_REG_INDEX(draw_inline_index): {
-        const auto* const bytes = reinterpret_cast<const u8*>(base_start);
-        index_buffer.insert(index_buffer.end(), bytes, bytes + size_t(amount) * sizeof(u32));
-        break;
-    }
-    case MAXWELL3D_REG_INDEX(inline_index_2x16.even): {
-        const size_t offset = index_buffer.size();
-        index_buffer.resize(offset + size_t(amount) * 2 * sizeof(u32));
-        u8* dst = index_buffer.data() + offset;
-        for (u32 i = 0; i < amount; ++i) {
-            const u32 word = base_start[i];
-            const u32 indexes[2]{word & 0xFFFF, word >> 16};
-            std::memcpy(dst, indexes, sizeof(indexes));
-            dst += sizeof(indexes);
-        }
-        break;
-    }
-    case MAXWELL3D_REG_INDEX(inline_index_4x8.index0): {
-        const size_t offset = index_buffer.size();
-        index_buffer.resize(offset + size_t(amount) * 4 * sizeof(u32));
-        u8* dst = index_buffer.data() + offset;
-        for (u32 i = 0; i < amount; ++i) {
-            const u32 word = base_start[i];
-            const u32 indexes[4]{word & 0xFF, (word >> 8) & 0xFF, (word >> 16) & 0xFF,
-                                 word >> 24};
-            std::memcpy(dst, indexes, sizeof(indexes));
-            dst += sizeof(indexes);
-        }
-        break;
-    }
-    }
-    draw_state.draw_mode = DrawMode::InlineIndex;
-}
-
 void Maxwell3D::DrawManager::DrawBegin(Maxwell3D& maxwell3d) {
     auto reset_instance_count = maxwell3d.regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::First;
     auto increment_instance_count = maxwell3d.regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Subsequent;

src/video_core/engines/engine_interface.h

@@ -6,8 +6,9 @@
 
 #pragma once
 
-#include <array>
-#include <boost/container/small_vector.hpp>
+#include <bitset>
+#include <limits>
+#include <vector>
 
 #include "common/common_types.h"
 
@@ -42,15 +43,10 @@ public:
         }
     }
 
-    static constexpr size_t EXECUTION_MASK_TABLE_SIZE = 0xE00;
-
-    std::array<u8, EXECUTION_MASK_TABLE_SIZE> execution_mask{};
-    bool execution_mask_default{};
-    boost::container::small_vector<std::pair<u32, u32>, 64> method_sink{};
+    std::bitset<(std::numeric_limits<u16>::max)()> execution_mask{};
+    std::vector<std::pair<u32, u32>> method_sink{};
     GPUVAddr current_dma_segment;
-    /// @brief Indicates whether the current DMA segment is dirty.
     bool current_dirty{};
-
 protected:
     virtual void ConsumeSinkImpl(Core::System& system) {
         for (auto [method, value] : method_sink) {

src/video_core/engines/fermi_2d.cpp

@@ -26,7 +26,7 @@ Fermi2D::Fermi2D(MemoryManager& memory_manager_) : memory_manager{memory_manager
     regs.src.depth = 1;
     regs.dst.depth = 1;
 
-    execution_mask.fill(0);
+    execution_mask.reset();
     execution_mask[FERMI2D_REG_INDEX(pixels_from_memory.src_y0) + 1] = true;
 }
 

src/video_core/engines/kepler_compute.cpp

@@ -20,7 +20,7 @@ KeplerCompute::KeplerCompute(MemoryManager& memory_manager_)
     : memory_manager{memory_manager_}
     , upload_state{memory_manager, regs.upload}
 {
-    execution_mask.fill(0);
+    execution_mask.reset();
     execution_mask[KEPLER_COMPUTE_REG_INDEX(exec_upload)] = true;
     execution_mask[KEPLER_COMPUTE_REG_INDEX(data_upload)] = true;
     execution_mask[KEPLER_COMPUTE_REG_INDEX(launch)] = true;

src/video_core/engines/kepler_memory.cpp

@@ -23,7 +23,7 @@ KeplerMemory::~KeplerMemory() = default;
 void KeplerMemory::BindRasterizer(VideoCore::RasterizerInterface* rasterizer_) {
     upload_state.BindRasterizer(rasterizer_);
 
-    execution_mask.fill(0);
+    execution_mask.reset();
     execution_mask[KEPLERMEMORY_REG_INDEX(exec)] = true;
     execution_mask[KEPLERMEMORY_REG_INDEX(data)] = true;
 }

src/video_core/engines/maxwell_3d.cpp

@@ -4,14 +4,8 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <algorithm>
 #include <cstring>
 #include <optional>
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#include <intrin.h>
-#endif
-
 #include "common/assert.h"
 #include "common/bit_util.h"
 #include "common/scope_exit.h"
@@ -28,16 +22,6 @@
 
 namespace Tegra::Engines {
 
-namespace {
-inline void PrefetchLine(const void* addr) {
-#if defined(_MSC_VER) && !defined(__clang__)
-    _mm_prefetch(static_cast<const char*>(addr), _MM_HINT_T0);
-#else
-    __builtin_prefetch(addr, 0, 1);
-#endif
-}
-} // namespace
-
 /// First register id that is actually a Macro call.
 constexpr u32 MacroRegistersStart = 0xE00;
 
@@ -53,10 +37,9 @@ Maxwell3D::Maxwell3D(MemoryManager& memory_manager_)
 {
     dirty.flags.flip();
     InitializeRegisterDefaults();
-    execution_mask.fill(0);
-    for (size_t i = 0; i < EXECUTION_MASK_TABLE_SIZE; i++)
+    execution_mask.reset();
+    for (size_t i = 0; i < execution_mask.size(); i++)
         execution_mask[i] = IsMethodExecutable(u32(i));
-    execution_mask_default = true;
 }
 
 Maxwell3D::~Maxwell3D() = default;
@@ -299,44 +282,18 @@ u32 Maxwell3D::ProcessShadowRam(u32 method, u32 argument) {
 }
 
 void Maxwell3D::ConsumeSinkImpl(Core::System& system) {
-    std::stable_sort(method_sink.begin(), method_sink.end(),
-                     [](const auto& a, const auto& b) { return a.first < b.first; });
-
-    const auto sink_size = method_sink.size();
     const auto control = shadow_state.shadow_ram_control;
     if (control == Regs::ShadowRamControl::Track || control == Regs::ShadowRamControl::TrackWithFilter) {
-        for (size_t i = 0; i < sink_size; ++i) {
-            const auto [method, value] = method_sink[i];
-            if (i + 1 < sink_size) {
-                const u32 next = method_sink[i + 1].first;
-                PrefetchLine(&regs.reg_array[next]);
-                PrefetchLine(&shadow_state.reg_array[next]);
-                PrefetchLine(&dirty.tables[0][next]);
-            }
+        for (auto [method, value] : method_sink) {
             shadow_state.reg_array[method] = value;
             ProcessDirtyRegisters(method, value);
         }
     } else if (control == Regs::ShadowRamControl::Replay) {
-        for (size_t i = 0; i < sink_size; ++i) {
-            const auto [method, value] = method_sink[i];
-            if (i + 1 < sink_size) {
-                const u32 next = method_sink[i + 1].first;
-                PrefetchLine(&regs.reg_array[next]);
-                PrefetchLine(&shadow_state.reg_array[next]);
-                PrefetchLine(&dirty.tables[0][next]);
-            }
+        for (auto [method, value] : method_sink)
             ProcessDirtyRegisters(method, shadow_state.reg_array[method]);
-        }
     } else {
-        for (size_t i = 0; i < sink_size; ++i) {
-            const auto [method, value] = method_sink[i];
-            if (i + 1 < sink_size) {
-                const u32 next = method_sink[i + 1].first;
-                PrefetchLine(&regs.reg_array[next]);
-                PrefetchLine(&dirty.tables[0][next]);
-            }
+        for (auto [method, value] : method_sink)
             ProcessDirtyRegisters(method, value);
-        }
     }
     method_sink.clear();
 }
@@ -479,14 +436,6 @@ void Maxwell3D::CallMultiMethod(Core::System& system, u32 method, const u32* bas
         upload_state.ProcessData(base_start, amount);
         return;
     }
-    case MAXWELL3D_REG_INDEX(draw_inline_index):
-    case MAXWELL3D_REG_INDEX(inline_index_2x16.even):
-    case MAXWELL3D_REG_INDEX(inline_index_4x8.index0):
-        if (shadow_state.shadow_ram_control != Regs::ShadowRamControl::Replay) {
-            ProcessInlineIndexMultiData(method, base_start, amount);
-            break;
-        }
-        [[fallthrough]];
     default:
         for (u32 i = 0; i < amount; i++) {
             CallMethod(system, method, base_start[i], methods_pending - i <= 1);
@@ -673,15 +622,6 @@ void Maxwell3D::ProcessCBData(u32 value) {
     ProcessCBMultiData(&value, 1);
 }
 
-void Maxwell3D::ProcessInlineIndexMultiData(u32 method, const u32* start_base, u32 amount) {
-    if (amount == 0) {
-        return;
-    }
-    const u32 argument = ProcessShadowRam(method, start_base[amount - 1]);
-    ProcessDirtyRegisters(method, argument);
-    draw_manager.SetInlineIndexBuffer(*this, method, start_base, amount);
-}
-
 Texture::TICEntry Maxwell3D::GetTICEntry(u32 tic_index) const {
     const GPUVAddr tic_address_gpu{regs.tex_header.Address() +
                                    tic_index * sizeof(Texture::TICEntry)};

src/video_core/engines/maxwell_3d.h

@@ -3077,7 +3077,6 @@ public:
         void DrawArrayIndirect(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology);
         void DrawIndexedIndirect(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 index_first, u32 index_count);
         void SetInlineIndexBuffer(Maxwell3D& maxwell3d, u32 index);
-        void SetInlineIndexBuffer(Maxwell3D& maxwell3d, u32 method, const u32* base_start, u32 amount);
         void DrawBegin(Maxwell3D& maxwell3d);
         void DrawEnd(Maxwell3D& maxwell3d, u32 instance_count = 1, bool force_draw = false);
         void DrawIndexSmall(Maxwell3D& maxwell3d, u32 argument);
@@ -3194,8 +3193,6 @@ public:
     void ProcessCBData(u32 value);
     void ProcessCBMultiData(const u32* start_base, u32 amount);
 
-    void ProcessInlineIndexMultiData(u32 method, const u32* start_base, u32 amount);
-
 private:
     void InitializeRegisterDefaults();
 

src/video_core/engines/maxwell_dma.cpp

@@ -24,7 +24,7 @@ using namespace Texture;
 MaxwellDMA::MaxwellDMA(MemoryManager& memory_manager_)
     : memory_manager{memory_manager_}
 {
-    execution_mask.fill(0);
+    execution_mask.reset();
     execution_mask[offsetof(Regs, launch_dma) / sizeof(u32)] = true;
 }
 

src/video_core/gpu_logging/gpu_logging.cpp

@@ -4,7 +4,6 @@
 #include "video_core/gpu_logging/gpu_logging.h"
 
 #include <fmt/format.h>
-#include <mutex>
 #include <thread>
 
 #include "common/fs/file.h"
@@ -281,12 +280,13 @@ void GPULogger::LogMemoryDeallocation(uintptr_t memory) {
 }
 
 void GPULogger::LogShaderCompilation(const std::string& shader_name,
-                                     const std::string& shader_info) {
+                                     const std::string& shader_info,
+                                     std::span<const u32> spirv_code) {
     if (!initialized || current_level == LogLevel::Off) {
         return;
     }
 
-    if (current_level < LogLevel::Verbose) {
+    if (!dump_shaders && current_level < LogLevel::Verbose) {
         return;
     }
 
@@ -294,36 +294,38 @@ void GPULogger::LogShaderCompilation(const std::string& shader_name,
         std::chrono::steady_clock::now().time_since_epoch());
 
     const auto log_entry = fmt::format("[{}] [Shader] Compiled: {} ({})\n",
-                                       FormatTimestamp(timestamp), shader_name, shader_info);
+                                      FormatTimestamp(timestamp), shader_name, shader_info);
     WriteToLog(log_entry);
-}
 
-bool IsActive() noexcept {
-    return Settings::values.gpu_log_level.GetValue() != Settings::GpuLogLevel::Off;
-}
+    // Dump SPIR-V binary if enabled and we have data
+    if (dump_shaders && !spirv_code.empty()) {
+        using namespace Common::FS;
+        const auto& log_dir = GetEdenPath(EdenPath::LogDir);
+        const auto shaders_dir = log_dir / "shaders";
 
-void DumpSpirvShader(u64 shader_hash, std::span<const u32> spirv_code) {
-    if (spirv_code.empty()) {
-        return;
+        // Create directory on first dump
+        if (!shader_dump_dir_created) {
+            [[maybe_unused]] const bool created = CreateDir(shaders_dir);
+            shader_dump_dir_created = true;
+        }
+
+        // Write SPIR-V binary file
+        const auto shader_path = shaders_dir / fmt::format("{}.spv", shader_name);
+        auto shader_file = std::make_unique<Common::FS::IOFile>(
+            shader_path, FileAccessMode::Write, FileType::BinaryFile);
+
+        if (shader_file->IsOpen()) {
+            const size_t bytes_to_write = spirv_code.size() * sizeof(u32);
+            static_cast<void>(shader_file->WriteSpan(spirv_code));
+            shader_file->Close();
+
+            const auto dump_log = fmt::format("[{}] [Shader] Dumped SPIR-V: {} ({} bytes)\n",
+                FormatTimestamp(timestamp), shader_path.string(), bytes_to_write);
+            WriteToLog(dump_log);
+        } else {
+            LOG_WARNING(Render_Vulkan, "[GPU Logging] Failed to dump shader: {}", shader_path.string());
+        }
     }
-
-    using namespace Common::FS;
-    const auto& dump_dir = GetEdenPath(EdenPath::DumpDir);
-
-    // Ensure DumpDir exists once. CreateDir is idempotent, so guarded to skip the syscall.
-    static std::once_flag dump_dir_flag;
-    std::call_once(dump_dir_flag, [&dump_dir]() {
-        [[maybe_unused]] const bool created = CreateDir(dump_dir);
-    });
-
-    const auto shader_path = dump_dir / fmt::format("{:016x}_{:016x}.spv",
-                                                    Settings::GetCurrentProgramID(), shader_hash);
-    Common::FS::IOFile shader_file(shader_path, FileAccessMode::Write, FileType::BinaryFile);
-    if (!shader_file.IsOpen()) {
-        LOG_WARNING(Render_Vulkan, "[Shader Dump] Failed to open {}", shader_path.string());
-        return;
-    }
-    static_cast<void>(shader_file.WriteSpan(spirv_code));
 }
 
 void GPULogger::LogPipelineStateChange(const std::string& state_info) {
@@ -655,6 +657,10 @@ void GPULogger::EnableVulkanCallTracking(bool enabled) {
     track_vulkan_calls = enabled;
 }
 
+void GPULogger::EnableShaderDumps(bool enabled) {
+    dump_shaders = enabled;
+}
+
 void GPULogger::EnableMemoryTracking(bool enabled) {
     track_memory = enabled;
 }

src/video_core/gpu_logging/gpu_logging.h

@@ -87,7 +87,8 @@ public:
     void LogVulkanCall(const std::string& call_name, const std::string& params, int result);
     void LogMemoryAllocation(uintptr_t memory, u64 size, u32 memory_flags);
     void LogMemoryDeallocation(uintptr_t memory);
-    void LogShaderCompilation(const std::string& shader_name, const std::string& shader_info);
+    void LogShaderCompilation(const std::string& shader_name, const std::string& shader_info,
+                              std::span<const u32> spirv_code = {});
     void LogPipelineStateChange(const std::string& state_info);
     void LogDriverDebugInfo(const std::string& debug_info);
 
@@ -120,6 +121,7 @@ public:
     // Settings
     void SetLogLevel(LogLevel level);
     void EnableVulkanCallTracking(bool enabled);
+    void EnableShaderDumps(bool enabled);
     void EnableMemoryTracking(bool enabled);
     void EnableDriverDebugInfo(bool enabled);
     void SetRingBufferSize(size_t entries);
@@ -169,6 +171,7 @@ private:
 
     // Feature flags
     bool track_vulkan_calls = true;
+    bool dump_shaders = false;
     bool track_memory = false;
     bool capture_driver_debug = false;
 
@@ -176,16 +179,15 @@ private:
     std::set<std::string> used_extensions;
     mutable std::mutex extension_mutex;
 
+    // Shader dump directory (created on demand)
+    bool shader_dump_dir_created = false;
+
     // Stored state for crash dumps
     std::string stored_driver_debug_info;
     std::string stored_pipeline_state;
     mutable std::mutex state_mutex;
 };
 
-[[nodiscard]] bool IsActive() noexcept;
-
-void DumpSpirvShader(u64 shader_hash, std::span<const u32> spirv_code);
-
 // Helper to get stage name from index
 inline const char* GetShaderStageName(size_t stage_index) {
     static constexpr std::array<const char*, 5> stage_names{

src/video_core/macro.cpp

@@ -1328,14 +1328,22 @@ Macro::Opcode MacroJITx64Impl::GetOpCode() const {
 #endif
 
 static void Dump(u64 hash, std::span<const u32> code, bool decompiled = false) {
-    const auto dump_dir{Common::FS::GetEdenPath(Common::FS::EdenPath::DumpDir)};
-    if (!Common::FS::CreateDir(dump_dir)) {
-        LOG_ERROR(Common_Filesystem, "Failed to create dump directory");
+    const auto base_dir{Common::FS::GetEdenPath(Common::FS::EdenPath::DumpDir)};
+    const auto macro_dir{base_dir / "macros"};
+    if (!Common::FS::CreateDir(base_dir) || !Common::FS::CreateDir(macro_dir)) {
+        LOG_ERROR(Common_Filesystem, "Failed to create macro dump directories");
         return;
     }
-    const char* const variant_suffix = decompiled ? "jit" : "raw";
-    const auto name{dump_dir / fmt::format("{:016x}_{:016x}_{}.macro",
-                                           Settings::GetCurrentProgramID(), hash, variant_suffix)};
+    auto name{macro_dir / fmt::format("{:016x}.macro", hash)};
+
+    if (decompiled) {
+        auto new_name{macro_dir / fmt::format("decompiled_{:016x}.macro", hash)};
+        if (Common::FS::Exists(name)) {
+            (void)Common::FS::RenameFile(name, new_name);
+            return;
+        }
+        name = new_name;
+    }
 
     std::fstream macro_file(name, std::ios::out | std::ios::binary);
     if (!macro_file) {

src/video_core/query_cache/query_cache.h

@@ -287,7 +287,6 @@ void QueryCacheBase<Traits>::CounterReport(GPUVAddr addr, QueryType counter_type
             u32 value = static_cast<u32>(query_base->value);
             std::memcpy(pointer, &value, sizeof(value));
         }
-        query_base->flags |= QueryFlagBits::IsGuestSynced;
         if (!is_synced) [[likely]] {
             impl->pending_unregister.push_back(query_location);
         }
@@ -570,12 +569,10 @@ bool QueryCacheBase<Traits>::SemiFlushQueryDirty(QueryCacheBase<Traits>::QueryLo
         auto* ptr = impl->device_memory.template GetPointer<u8>(query_base->guest_address);
         if (True(query_base->flags & QueryFlagBits::HasTimestamp)) {
             std::memcpy(ptr, &query_base->value, sizeof(query_base->value));
-            query_base->flags |= QueryFlagBits::IsGuestSynced;
             return false;
         }
         u32 value_l = static_cast<u32>(query_base->value);
         std::memcpy(ptr, &value_l, sizeof(value_l));
-        query_base->flags |= QueryFlagBits::IsGuestSynced;
         return false;
     }
     return True(query_base->flags & QueryFlagBits::IsHostManaged) &&

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -481,7 +481,7 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
         const u32 cfg_offset = u32(env.StartAddress() + sizeof(Shader::ProgramHeader));
         Shader::Maxwell::Flow::CFG cfg(env, pools.flow_block, cfg_offset, index == 0);
 
-        if (Settings::values.dump_guest_shaders) {
+        if (Settings::values.dump_shaders) {
             env.Dump(hash, key.unique_hashes[index]);
         }
 
@@ -578,7 +578,7 @@ std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
 
     Shader::Maxwell::Flow::CFG cfg{env, pools.flow_block, env.StartAddress()};
 
-    if (Settings::values.dump_guest_shaders) {
+    if (Settings::values.dump_shaders) {
         env.Dump(hash, key.unique_hash);
     }
 

src/video_core/renderer_vulkan/blit_image.cpp

@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
+#include <array>
 
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
 
@@ -135,15 +136,18 @@ VkPipelineInputAssemblyStateCreateInfo GetPipelineInputAssemblyStateCreateInfo(c
         .primitiveRestartEnable = device.IsMoltenVK() ? VK_TRUE : VK_FALSE,
     };
 }
-constexpr VkPipelineViewportStateCreateInfo PIPELINE_VIEWPORT_STATE_CREATE_INFO{
-    .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
-    .pNext = nullptr,
-    .flags = 0,
-    .viewportCount = 1,
-    .pViewports = nullptr,
-    .scissorCount = 1,
-    .pScissors = nullptr,
-};
+VkPipelineViewportStateCreateInfo GetPipelineViewportStateCreateInfo(const Device& device) {
+    const u32 viewport_count = device.GetViewportCount();
+    return VkPipelineViewportStateCreateInfo{
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .viewportCount = viewport_count,
+        .pViewports = nullptr,
+        .scissorCount = viewport_count,
+        .pScissors = nullptr,
+    };
+}
 constexpr VkPipelineRasterizationStateCreateInfo PIPELINE_RASTERIZATION_STATE_CREATE_INFO{
     .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
     .pNext = nullptr,
@@ -361,7 +365,7 @@ void UpdateTwoTexturesDescriptorSet(const Device& device, VkDescriptorSet descri
     device.GetLogical().UpdateDescriptorSets(write_descriptor_sets, nullptr);
 }
 
-void BindBlitState(vk::CommandBuffer cmdbuf, const Region2D& dst_region) {
+void BindBlitState(const Device& device, vk::CommandBuffer cmdbuf, const Region2D& dst_region) {
     const VkOffset2D offset{
         .x = (std::min)(dst_region.start.x, dst_region.end.x),
         .y = (std::min)(dst_region.start.y, dst_region.end.y),
@@ -383,13 +387,17 @@ void BindBlitState(vk::CommandBuffer cmdbuf, const Region2D& dst_region) {
         .offset = offset,
         .extent = extent,
     };
-    cmdbuf.SetViewport(0, viewport);
-    cmdbuf.SetScissor(0, scissor);
+    const u32 viewport_count = device.GetViewportCount();
+    const std::array<VkViewport, 2> viewports{viewport, viewport};
+    const std::array<VkRect2D, 2> scissors{scissor, scissor};
+    cmdbuf.SetViewport(0, vk::Span<VkViewport>(viewports.data(), viewport_count));
+    cmdbuf.SetScissor(0, vk::Span<VkRect2D>(scissors.data(), viewport_count));
 }
 
-void BindBlitState(vk::CommandBuffer cmdbuf, VkPipelineLayout layout, const Region2D& dst_region,
-                   const Region2D& src_region, const Extent3D& src_size = {1, 1, 1}) {
-    BindBlitState(cmdbuf, dst_region);
+void BindBlitState(const Device& device, vk::CommandBuffer cmdbuf, VkPipelineLayout layout,
+                   const Region2D& dst_region, const Region2D& src_region,
+                   const Extent3D& src_size = {1, 1, 1}) {
+    BindBlitState(device, cmdbuf, dst_region);
     const float scale_x = static_cast<float>(src_region.end.x - src_region.start.x) /
                           static_cast<float>(src_size.width);
     const float scale_y = static_cast<float>(src_region.end.y - src_region.start.y) /
@@ -559,7 +567,7 @@ void BlitImageHelper::BlitColor(const Framebuffer* dst_framebuffer, const ImageV
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
                                   nullptr);
-        BindBlitState(cmdbuf, layout, dst_region, src_region);
+        BindBlitState(device, cmdbuf, layout, dst_region, src_region);
         cmdbuf.Draw(3, 1, 0, 0);
     });
     scheduler.InvalidateState();
@@ -585,7 +593,7 @@ void BlitImageHelper::BlitColor(const Framebuffer* dst_framebuffer, VkImageView
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
                                   nullptr);
-        BindBlitState(cmdbuf, layout, dst_region, src_region, src_size);
+        BindBlitState(device, cmdbuf, layout, dst_region, src_region, src_size);
         cmdbuf.Draw(3, 1, 0, 0);
         cmdbuf.EndRenderPass();
     });
@@ -621,7 +629,7 @@ void BlitImageHelper::BlitDepthStencil(const Framebuffer* dst_framebuffer,
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
                                   nullptr);
-        BindBlitState(cmdbuf, layout, dst_region, src_region);
+        BindBlitState(device, cmdbuf, layout, dst_region, src_region);
         cmdbuf.Draw(3, 1, 0, 0);
     });
     scheduler.InvalidateState();
@@ -702,13 +710,13 @@ void BlitImageHelper::ClearColor(const Framebuffer* dst_framebuffer, u8 color_ma
     const VkPipelineLayout layout = *clear_color_pipeline_layout;
     scheduler.RequestRenderpass(dst_framebuffer);
     scheduler.Record(
-        [pipeline, layout, color_mask, clear_color, dst_region](vk::CommandBuffer cmdbuf) {
+        [pipeline, layout, color_mask, clear_color, dst_region, this](vk::CommandBuffer cmdbuf) {
             cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
             const std::array blend_color = {
                 (color_mask & 0x1) ? 1.0f : 0.0f, (color_mask & 0x2) ? 1.0f : 0.0f,
                 (color_mask & 0x4) ? 1.0f : 0.0f, (color_mask & 0x8) ? 1.0f : 0.0f};
             cmdbuf.SetBlendConstants(blend_color.data());
-            BindBlitState(cmdbuf, dst_region);
+            BindBlitState(device, cmdbuf, dst_region);
             cmdbuf.PushConstants(layout, VK_SHADER_STAGE_FRAGMENT_BIT, clear_color);
             cmdbuf.Draw(3, 1, 0, 0);
         });
@@ -728,11 +736,11 @@ void BlitImageHelper::ClearDepthStencil(const Framebuffer* dst_framebuffer, bool
     const VkPipeline pipeline = FindOrEmplaceClearStencilPipeline(key);
     const VkPipelineLayout layout = *clear_color_pipeline_layout;
     scheduler.RequestRenderpass(dst_framebuffer);
-    scheduler.Record([pipeline, layout, clear_depth, dst_region](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([pipeline, layout, clear_depth, dst_region, this](vk::CommandBuffer cmdbuf) {
         constexpr std::array blend_constants{0.0f, 0.0f, 0.0f, 0.0f};
         cmdbuf.SetBlendConstants(blend_constants.data());
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
-        BindBlitState(cmdbuf, dst_region);
+        BindBlitState(device, cmdbuf, dst_region);
         cmdbuf.PushConstants(layout, VK_SHADER_STAGE_FRAGMENT_BIT, clear_depth);
         cmdbuf.Draw(3, 1, 0, 0);
     });
@@ -775,8 +783,11 @@ void BlitImageHelper::Convert(VkPipeline pipeline, const Framebuffer* dst_frameb
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
                                   nullptr);
-        cmdbuf.SetViewport(0, viewport);
-        cmdbuf.SetScissor(0, scissor);
+        const u32 viewport_count = device.GetViewportCount();
+        const std::array<VkViewport, 2> viewports{viewport, viewport};
+        const std::array<VkRect2D, 2> scissors{scissor, scissor};
+        cmdbuf.SetViewport(0, vk::Span<VkViewport>(viewports.data(), viewport_count));
+        cmdbuf.SetScissor(0, vk::Span<VkRect2D>(scissors.data(), viewport_count));
         cmdbuf.PushConstants(layout, VK_SHADER_STAGE_VERTEX_BIT, push_constants);
         cmdbuf.Draw(3, 1, 0, 0);
     });
@@ -821,8 +832,11 @@ void BlitImageHelper::ConvertDepthStencil(VkPipeline pipeline, const Framebuffer
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
                                   nullptr);
-        cmdbuf.SetViewport(0, viewport);
-        cmdbuf.SetScissor(0, scissor);
+        const u32 viewport_count = device.GetViewportCount();
+        const std::array<VkViewport, 2> viewports{viewport, viewport};
+        const std::array<VkRect2D, 2> scissors{scissor, scissor};
+        cmdbuf.SetViewport(0, vk::Span<VkViewport>(viewports.data(), viewport_count));
+        cmdbuf.SetScissor(0, vk::Span<VkRect2D>(scissors.data(), viewport_count));
         cmdbuf.PushConstants(layout, VK_SHADER_STAGE_VERTEX_BIT, push_constants);
         cmdbuf.Draw(3, 1, 0, 0);
     });
@@ -860,6 +874,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceColorPipeline(const BlitImagePipelineKe
         .blendConstants = {0.0f, 0.0f, 0.0f, 0.0f},
     };
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
+    const VkPipelineViewportStateCreateInfo viewport_ci = GetPipelineViewportStateCreateInfo(device);
     blit_color_pipelines.push_back(device.GetLogical().CreateGraphicsPipeline({
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
@@ -869,7 +884,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceColorPipeline(const BlitImagePipelineKe
         .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
         .pInputAssemblyState = &input_assembly_ci,
         .pTessellationState = nullptr,
-        .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+        .pViewportState = &viewport_ci,
         .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
         .pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .pDepthStencilState = nullptr,
@@ -892,6 +907,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceDepthStencilPipeline(const BlitImagePip
     blit_depth_stencil_keys.push_back(key);
     const std::array stages = MakeStages(*full_screen_vert, *blit_depth_stencil_frag);
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
+    const VkPipelineViewportStateCreateInfo viewport_ci = GetPipelineViewportStateCreateInfo(device);
     blit_depth_stencil_pipelines.push_back(device.GetLogical().CreateGraphicsPipeline({
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
@@ -901,7 +917,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceDepthStencilPipeline(const BlitImagePip
         .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
         .pInputAssemblyState = &input_assembly_ci,
         .pTessellationState = nullptr,
-        .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+        .pViewportState = &viewport_ci,
         .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
         .pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .pDepthStencilState = &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
@@ -945,6 +961,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceClearColorPipeline(const BlitImagePipel
         .blendConstants = {0.0f, 0.0f, 0.0f, 0.0f},
     };
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
+    const VkPipelineViewportStateCreateInfo viewport_ci = GetPipelineViewportStateCreateInfo(device);
     clear_color_pipelines.push_back(device.GetLogical().CreateGraphicsPipeline({
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
@@ -954,7 +971,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceClearColorPipeline(const BlitImagePipel
         .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
         .pInputAssemblyState = &input_assembly_ci,
         .pTessellationState = nullptr,
-        .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+        .pViewportState = &viewport_ci,
         .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
         .pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .pDepthStencilState = &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
@@ -1001,6 +1018,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceClearStencilPipeline(
         .maxDepthBounds = 0.0f,
     };
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
+    const VkPipelineViewportStateCreateInfo viewport_ci = GetPipelineViewportStateCreateInfo(device);
     clear_stencil_pipelines.push_back(device.GetLogical().CreateGraphicsPipeline({
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
@@ -1010,7 +1028,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceClearStencilPipeline(
         .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
         .pInputAssemblyState = &input_assembly_ci,
         .pTessellationState = nullptr,
-        .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+        .pViewportState = &viewport_ci,
         .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
         .pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .pDepthStencilState = &depth_stencil_ci,
@@ -1032,6 +1050,7 @@ void BlitImageHelper::ConvertDepthToColorPipeline(vk::Pipeline& pipeline, VkRend
     VkShaderModule frag_shader = *convert_float_to_depth_frag;
     const std::array stages = MakeStages(*full_screen_vert, frag_shader);
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
+    const VkPipelineViewportStateCreateInfo viewport_ci = GetPipelineViewportStateCreateInfo(device);
     pipeline = device.GetLogical().CreateGraphicsPipeline(VkGraphicsPipelineCreateInfo{
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
@@ -1041,7 +1060,7 @@ void BlitImageHelper::ConvertDepthToColorPipeline(vk::Pipeline& pipeline, VkRend
         .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
         .pInputAssemblyState = &input_assembly_ci,
         .pTessellationState = nullptr,
-        .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+        .pViewportState = &viewport_ci,
         .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
         .pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .pDepthStencilState = &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
@@ -1062,6 +1081,7 @@ void BlitImageHelper::ConvertColorToDepthPipeline(vk::Pipeline& pipeline, VkRend
     VkShaderModule frag_shader = *convert_depth_to_float_frag;
     const std::array stages = MakeStages(*full_screen_vert, frag_shader);
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
+    const VkPipelineViewportStateCreateInfo viewport_ci = GetPipelineViewportStateCreateInfo(device);
     pipeline = device.GetLogical().CreateGraphicsPipeline(VkGraphicsPipelineCreateInfo{
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
@@ -1071,7 +1091,7 @@ void BlitImageHelper::ConvertColorToDepthPipeline(vk::Pipeline& pipeline, VkRend
         .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
         .pInputAssemblyState = &input_assembly_ci,
         .pTessellationState = nullptr,
-        .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+        .pViewportState = &viewport_ci,
         .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
         .pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .pDepthStencilState = &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
@@ -1093,6 +1113,7 @@ void BlitImageHelper::ConvertPipelineEx(vk::Pipeline& pipeline, VkRenderPass ren
     }
     const std::array stages = MakeStages(*full_screen_vert, *module);
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
+    const VkPipelineViewportStateCreateInfo viewport_ci = GetPipelineViewportStateCreateInfo(device);
     pipeline = device.GetLogical().CreateGraphicsPipeline(VkGraphicsPipelineCreateInfo{
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
@@ -1102,7 +1123,7 @@ void BlitImageHelper::ConvertPipelineEx(vk::Pipeline& pipeline, VkRenderPass ren
         .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
         .pInputAssemblyState = &input_assembly_ci,
         .pTessellationState = nullptr,
-        .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+        .pViewportState = &viewport_ci,
         .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
         .pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .pDepthStencilState = is_target_depth ? &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO : nullptr,
@@ -1135,6 +1156,7 @@ void BlitImageHelper::ConvertPipeline(vk::Pipeline& pipeline, VkRenderPass rende
         is_target_depth ? *convert_float_to_depth_frag : *convert_depth_to_float_frag;
     const std::array stages = MakeStages(*full_screen_vert, frag_shader);
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
+    const VkPipelineViewportStateCreateInfo viewport_ci = GetPipelineViewportStateCreateInfo(device);
     pipeline = device.GetLogical().CreateGraphicsPipeline(VkGraphicsPipelineCreateInfo{
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
@@ -1144,7 +1166,7 @@ void BlitImageHelper::ConvertPipeline(vk::Pipeline& pipeline, VkRenderPass rende
         .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
         .pInputAssemblyState = &input_assembly_ci,
         .pTessellationState = nullptr,
-        .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+        .pViewportState = &viewport_ci,
         .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
         .pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .pDepthStencilState = is_target_depth ? &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO : nullptr,

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -62,7 +62,6 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
     extended_dynamic_state_2_logic_op.Assign(features.has_extended_dynamic_state_2_logic_op ? 1 : 0);
     extended_dynamic_state_3_blend.Assign(features.has_extended_dynamic_state_3_blend ? 1 : 0);
     extended_dynamic_state_3_enables.Assign(features.has_extended_dynamic_state_3_enables ? 1 : 0);
-    dynamic_state3_depth_clamp_enable.Assign(features.has_dynamic_state3_depth_clamp_enable ? 1 : 0);
     dynamic_vertex_input.Assign(features.has_dynamic_vertex_input ? 1 : 0);
     xfb_enabled.Assign(regs.transform_feedback_enabled != 0);
     ndc_minus_one_to_one.Assign(regs.depth_mode == Maxwell::DepthMode::MinusOneToOne ? 1 : 0);

src/video_core/renderer_vulkan/fixed_pipeline_state.h

@@ -208,7 +208,6 @@ struct FixedPipelineState {
         BitField<12, 2, u32> tessellation_spacing;
         BitField<14, 1, u32> tessellation_clockwise;
         BitField<15, 5, u32> patch_control_points_minus_one;
-        BitField<20, 1, u32> dynamic_state3_depth_clamp_enable;
 
         BitField<24, 4, Maxwell::PrimitiveTopology> topology;
         BitField<28, 4, Tegra::Texture::MsaaMode> msaa_mode;

src/video_core/renderer_vulkan/present/fsr.cpp

@@ -183,10 +183,10 @@ VkImageView FSR::Draw(const Device& device, Scheduler& scheduler, size_t image_i
     UpdateDescriptorSets(device, source_image_view, image_index);
 
     scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([=](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([=, &device](vk::CommandBuffer cmdbuf) {
         TransitionImageLayout(cmdbuf, source_image, VK_IMAGE_LAYOUT_GENERAL);
         TransitionImageLayout(cmdbuf, easu_image, VK_IMAGE_LAYOUT_GENERAL);
-        BeginRenderPass(cmdbuf, renderpass, easu_framebuffer, extent);
+        BeginRenderPass(device, cmdbuf, renderpass, easu_framebuffer, extent);
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, easu_pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0,
                                   easu_descriptor_set, {});
@@ -196,7 +196,7 @@ VkImageView FSR::Draw(const Device& device, Scheduler& scheduler, size_t image_i
 
         TransitionImageLayout(cmdbuf, easu_image, VK_IMAGE_LAYOUT_GENERAL);
         TransitionImageLayout(cmdbuf, rcas_image, VK_IMAGE_LAYOUT_GENERAL);
-        BeginRenderPass(cmdbuf, renderpass, rcas_framebuffer, extent);
+        BeginRenderPass(device, cmdbuf, renderpass, rcas_framebuffer, extent);
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, rcas_pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0,
                                   rcas_descriptor_set, {});

src/video_core/renderer_vulkan/present/fxaa.cpp

@@ -129,10 +129,10 @@ void FXAA::Draw(const Device& device, Scheduler& scheduler, size_t image_index,
     UpdateDescriptorSets(device, *inout_image_view, image_index);
 
     scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([=](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([=, &device](vk::CommandBuffer cmdbuf) {
         TransitionImageLayout(cmdbuf, input_image, VK_IMAGE_LAYOUT_GENERAL);
         TransitionImageLayout(cmdbuf, output_image, VK_IMAGE_LAYOUT_GENERAL);
-        BeginRenderPass(cmdbuf, renderpass, framebuffer, extent);
+        BeginRenderPass(device, cmdbuf, renderpass, framebuffer, extent);
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set, {});
         cmdbuf.Draw(3, 1, 0, 0);

src/video_core/renderer_vulkan/present/sgsr.cpp

@@ -125,10 +125,10 @@ VkImageView SGSR::Draw(const Device& device, Scheduler& scheduler, size_t image_
     UpdateDescriptorSets(device, source_image_view, image_index);
 
     scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([=](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([=, &device](vk::CommandBuffer cmdbuf) {
         TransitionImageLayout(cmdbuf, source_image, VK_IMAGE_LAYOUT_GENERAL);
         TransitionImageLayout(cmdbuf, output_image, VK_IMAGE_LAYOUT_GENERAL);
-        BeginRenderPass(cmdbuf, renderpass, framebuffer, extent);
+        BeginRenderPass(device, cmdbuf, renderpass, framebuffer, extent);
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set, {});
         cmdbuf.PushConstants(layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, viewport_con);

src/video_core/renderer_vulkan/present/smaa.cpp

@@ -237,10 +237,10 @@ void SMAA::Draw(const Device& device, Scheduler& scheduler, size_t image_index,
     UpdateDescriptorSets(device, *inout_image_view, image_index);
 
     scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([=, this](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([=, this, &device](vk::CommandBuffer cmdbuf) {
         TransitionImageLayout(cmdbuf, input_image, VK_IMAGE_LAYOUT_GENERAL);
         TransitionImageLayout(cmdbuf, edges_image, VK_IMAGE_LAYOUT_GENERAL);
-        BeginRenderPass(cmdbuf, *m_renderpasses[EdgeDetection], edge_detection_framebuffer,
+        BeginRenderPass(device, cmdbuf, *m_renderpasses[EdgeDetection], edge_detection_framebuffer,
                         m_extent);
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipelines[EdgeDetection]);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS,
@@ -251,7 +251,7 @@ void SMAA::Draw(const Device& device, Scheduler& scheduler, size_t image_index,
 
         TransitionImageLayout(cmdbuf, edges_image, VK_IMAGE_LAYOUT_GENERAL);
         TransitionImageLayout(cmdbuf, blend_image, VK_IMAGE_LAYOUT_GENERAL);
-        BeginRenderPass(cmdbuf, *m_renderpasses[BlendingWeightCalculation],
+        BeginRenderPass(device, cmdbuf, *m_renderpasses[BlendingWeightCalculation],
                         blending_weight_calculation_framebuffer, m_extent);
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS,
                             *m_pipelines[BlendingWeightCalculation]);
@@ -263,7 +263,7 @@ void SMAA::Draw(const Device& device, Scheduler& scheduler, size_t image_index,
 
         TransitionImageLayout(cmdbuf, blend_image, VK_IMAGE_LAYOUT_GENERAL);
         TransitionImageLayout(cmdbuf, output_image, VK_IMAGE_LAYOUT_GENERAL);
-        BeginRenderPass(cmdbuf, *m_renderpasses[NeighborhoodBlending],
+        BeginRenderPass(device, cmdbuf, *m_renderpasses[NeighborhoodBlending],
                         neighborhood_blending_framebuffer, m_extent);
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipelines[NeighborhoodBlending]);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS,

src/video_core/renderer_vulkan/present/util.cpp

@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/assert.h"
+#include <array>
 #include <ranges>
 #include <vulkan/vulkan_core.h>
 #include "video_core/renderer_vulkan/present/util.h"
@@ -408,14 +409,14 @@ static vk::Pipeline CreateWrappedPipelineImpl(
         .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
         .primitiveRestartEnable = device.IsMoltenVK() ? VK_TRUE : VK_FALSE,
     };
-
-    constexpr VkPipelineViewportStateCreateInfo viewport_state_ci{
+    const u32 viewport_count = device.GetViewportCount();
+    const VkPipelineViewportStateCreateInfo viewport_state_ci{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
         .pNext = nullptr,
         .flags = 0,
-        .viewportCount = 1,
+        .viewportCount = viewport_count,
         .pViewports = nullptr,
-        .scissorCount = 1,
+        .scissorCount = viewport_count,
         .pScissors = nullptr,
     };
 
@@ -669,8 +670,8 @@ void ClearColorImage(vk::CommandBuffer& cmdbuf, VkImage image) {
     cmdbuf.ClearColorImage(image, VK_IMAGE_LAYOUT_GENERAL, {}, subresources);
 }
 
-void BeginRenderPass(vk::CommandBuffer& cmdbuf, VkRenderPass render_pass, VkFramebuffer framebuffer,
-                     VkExtent2D extent) {
+void BeginRenderPass(const Device& device, vk::CommandBuffer& cmdbuf, VkRenderPass render_pass,
+                     VkFramebuffer framebuffer, VkExtent2D extent) {
     const VkRenderPassBeginInfo renderpass_bi{
         .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
         .pNext = nullptr,
@@ -697,8 +698,11 @@ void BeginRenderPass(vk::CommandBuffer& cmdbuf, VkRenderPass render_pass, VkFram
         .offset = {0, 0},
         .extent = extent,
     };
-    cmdbuf.SetViewport(0, viewport);
-    cmdbuf.SetScissor(0, scissor);
+    const u32 viewport_count = device.GetViewportCount();
+    const std::array<VkViewport, 2> viewports{viewport, viewport};
+    const std::array<VkRect2D, 2> scissors{scissor, scissor};
+    cmdbuf.SetViewport(0, vk::Span<VkViewport>(viewports.data(), viewport_count));
+    cmdbuf.SetScissor(0, vk::Span<VkRect2D>(scissors.data(), viewport_count));
 }
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/present/util.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -59,7 +59,7 @@ vk::Sampler CreateBilinearSampler(const Device& device);
 vk::Sampler CreateNearestNeighborSampler(const Device& device);
 vk::Sampler CreateCubicSampler(const Device& device, VkCubicFilterWeightsQCOM qcom_weights);
 
-void BeginRenderPass(vk::CommandBuffer& cmdbuf, VkRenderPass render_pass, VkFramebuffer framebuffer,
-                     VkExtent2D extent);
+void BeginRenderPass(const Device& device, vk::CommandBuffer& cmdbuf, VkRenderPass render_pass,
+                     VkFramebuffer framebuffer, VkExtent2D extent);
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/present/window_adapt_pass.cpp

@@ -69,7 +69,7 @@ void WindowAdaptPass::Draw(const Device& device, RasterizerVulkan& rasterizer, S
         layer_it++;
     }
 
-    scheduler.Record([=](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([=, &device](vk::CommandBuffer cmdbuf) {
         const f32 bg_red = Settings::values.bg_red.GetValue() / 255.0f;
         const f32 bg_green = Settings::values.bg_green.GetValue() / 255.0f;
         const f32 bg_blue = Settings::values.bg_blue.GetValue() / 255.0f;
@@ -91,7 +91,7 @@ void WindowAdaptPass::Draw(const Device& device, RasterizerVulkan& rasterizer, S
             .layerCount = 1,
         };
 
-        BeginRenderPass(cmdbuf, renderpass, host_framebuffer, render_area);
+        BeginRenderPass(device, cmdbuf, renderpass, host_framebuffer, render_area);
         cmdbuf.ClearAttachments({clear_attachment}, {clear_rect});
 
         for (size_t i = 0; i < layer_count; i++) {

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -87,7 +87,7 @@ ComputePipeline::ComputePipeline(const Device& device_, Scheduler& scheduler, vk
         }, *pipeline_cache);
 
         // Log compute pipeline creation
-        if (GPU::Logging::IsActive()) {
+        if (Settings::values.gpu_logging_enabled.GetValue()) {
             GPU::Logging::GPULogger::GetInstance().LogPipelineStateChange(
                 "ComputePipeline created"
             );
@@ -223,7 +223,7 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
     }
 
     // Log compute pipeline binding
-    if (GPU::Logging::IsActive() &&
+    if (Settings::values.gpu_logging_enabled.GetValue() &&
         Settings::values.gpu_log_vulkan_calls.GetValue()) {
         GPU::Logging::GPULogger::GetInstance().LogPipelineBind(true, "compute pipeline");
     }

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -532,7 +532,7 @@ void GraphicsPipeline::ConfigureDraw(const RescalingPushConstant& rescaling,
     const bool bind_pipeline{scheduler.UpdateGraphicsPipeline(this)};
 
     // Log graphics pipeline binding
-    if (bind_pipeline && GPU::Logging::IsActive() &&
+    if (bind_pipeline && Settings::values.gpu_logging_enabled.GetValue() &&
         Settings::values.gpu_log_vulkan_calls.GetValue()) {
         const std::string pipeline_info = fmt::format("hash=0x{:016x}", key.Hash());
         GPU::Logging::GPULogger::GetInstance().LogPipelineBind(false, pipeline_info);
@@ -907,7 +907,7 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
 
     // EDS3 - Enables (composite: per-feature)
     if (key.state.extended_dynamic_state_3_enables) {
-        if (key.state.dynamic_state3_depth_clamp_enable != 0) {
+        if (device.SupportsDynamicState3DepthClampEnable()) {
             dynamic_states.push_back(VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT);
         }
         if (device.SupportsDynamicState3LogicOpEnable()) {
@@ -986,7 +986,7 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
     }, *pipeline_cache);
 
     // Log graphics pipeline creation
-    if (GPU::Logging::IsActive()) {
+    if (Settings::values.gpu_logging_enabled.GetValue()) {
         const std::string pipeline_info = fmt::format(
             "GraphicsPipeline created: stages={}, attachments={}",
             shader_stages.size(),

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -492,9 +492,7 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
         device.IsExtExtendedDynamicState3BlendingSupported();
     dynamic_features.has_extended_dynamic_state_3_enables =
         device.IsExtExtendedDynamicState3EnablesSupported();
-    dynamic_features.has_dynamic_state3_depth_clamp_enable =
-        dynamic_features.has_extended_dynamic_state_3_enables &&
-        device.SupportsDynamicState3DepthClampEnable();
+    dynamic_features.has_dynamic_state3_depth_clamp_enable = false;
     dynamic_features.has_dynamic_state3_logic_op_enable =
         device.SupportsDynamicState3LogicOpEnable();
     dynamic_features.has_dynamic_state3_line_stipple_enable =
@@ -753,7 +751,7 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
             programs[index] = MergeDualVertexPrograms(program_va, program_vb, env);
         }
 
-        if (Settings::values.dump_guest_shaders) {
+        if (Settings::values.dump_shaders) {
             env.Dump(hash, key.unique_hashes[index]);
         }
 
@@ -785,22 +783,14 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
         device.SaveShader(code);
         modules[stage_index] = BuildShader(device, code);
 
-        // Text log + .spv dump. Text log is gated by gpu_log_level != Off; .spv dump
-        // is independent and gated only by gpu_log_shader_dumps.
-        const bool should_log = GPU::Logging::IsActive();
-        const bool should_dump = Settings::values.gpu_log_shader_dumps.GetValue();
-        if (should_log || should_dump) {
+        // Log shader compilation to GPU logger (with SPIR-V binary dump if enabled)
+        if (Settings::values.gpu_logging_enabled.GetValue()) {
             static constexpr std::array stage_names{"vertex", "tess_control", "tess_eval", "geometry", "fragment"};
             const std::string shader_name = fmt::format("shader_{:016x}_{}", key.unique_hashes[index], stage_names[stage_index]);
-            if (should_log) {
-                const std::string shader_info = fmt::format("SPIR-V size: {} bytes, hash: {:016x}",
-                    code.size() * sizeof(u32), key.unique_hashes[index]);
-                GPU::Logging::GPULogger::GetInstance().LogShaderCompilation(shader_name, shader_info);
-            }
-            if (should_dump) {
-                GPU::Logging::DumpSpirvShader(key.unique_hashes[index],
-                                              std::span<const u32>(code.data(), code.size()));
-            }
+            const std::string shader_info = fmt::format("SPIR-V size: {} bytes, hash: {:016x}",
+                code.size() * sizeof(u32), key.unique_hashes[index]);
+            GPU::Logging::GPULogger::GetInstance().LogShaderCompilation(shader_name, shader_info,
+                std::span<const u32>(code.data(), code.size()));
         }
 
         if (device.HasDebuggingToolAttached()) {
@@ -889,7 +879,7 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
     Shader::Maxwell::Flow::CFG cfg{env, pools.flow_block, env.StartAddress()};
 
     // Dump it before error.
-    if (Settings::values.dump_guest_shaders) {
+    if (Settings::values.dump_shaders) {
         env.Dump(hash, key.unique_hash);
     }
 
@@ -911,20 +901,13 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
     device.SaveShader(code);
     vk::ShaderModule spv_module{BuildShader(device, code)};
 
-    // Text log + .spv dump. Same split as the graphics path.
-    const bool should_log = GPU::Logging::IsActive();
-    const bool should_dump = Settings::values.gpu_log_shader_dumps.GetValue();
-    if (should_log || should_dump) {
+    // Log compute shader compilation to GPU logger (with SPIR-V binary dump if enabled)
+    if (Settings::values.gpu_logging_enabled.GetValue()) {
         const std::string shader_name = fmt::format("shader_{:016x}_compute", key.unique_hash);
-        if (should_log) {
-            const std::string shader_info = fmt::format("SPIR-V size: {} bytes, hash: {:016x}",
-                code.size() * sizeof(u32), key.unique_hash);
-            GPU::Logging::GPULogger::GetInstance().LogShaderCompilation(shader_name, shader_info);
-        }
-        if (should_dump) {
-            GPU::Logging::DumpSpirvShader(key.unique_hash,
-                                          std::span<const u32>(code.data(), code.size()));
-        }
+        const std::string shader_info = fmt::format("SPIR-V size: {} bytes, hash: {:016x}",
+            code.size() * sizeof(u32), key.unique_hash);
+        GPU::Logging::GPULogger::GetInstance().LogShaderCompilation(shader_name, shader_info,
+            std::span<const u32>(code.data(), code.size()));
     }
 
     if (device.HasDebuggingToolAttached()) {

src/video_core/renderer_vulkan/vk_pipeline_cache.h

@@ -113,10 +113,6 @@ public:
 
     [[nodiscard]] ComputePipeline* CurrentComputePipeline();
 
-    [[nodiscard]] bool SupportsDynamicState3DepthClampEnable() const {
-        return dynamic_features.has_dynamic_state3_depth_clamp_enable;
-    }
-
     void LoadDiskResources(u64 title_id, std::stop_token stop_loading,
                            const VideoCore::DiskResourceLoadCallback& callback);
 

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -218,7 +218,8 @@ public:
         }
         PauseCounter();
         const auto driver_id = device.GetDriverID();
-        if (driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
+        if (driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+            driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
             pending_sync.clear();
             sync_values_stash.clear();
             return;

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -270,7 +270,7 @@ void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
         });
 
         // Log draw call
-        if (GPU::Logging::IsActive() &&
+        if (Settings::values.gpu_logging_enabled.GetValue() &&
             Settings::values.gpu_log_vulkan_calls.GetValue()) {
             const std::string params = is_indexed ?
                 fmt::format("vertices={}, instances={}, firstIndex={}, baseVertex={}, baseInstance={}",
@@ -331,7 +331,7 @@ void RasterizerVulkan::DrawIndirect() {
         });
 
         // Log indirect draw call
-        if (GPU::Logging::IsActive() &&
+        if (Settings::values.gpu_logging_enabled.GetValue() &&
             Settings::values.gpu_log_vulkan_calls.GetValue()) {
             const std::string log_params = fmt::format("drawCount={}, stride={}",
                 params.max_draw_counts, params.stride);
@@ -585,7 +585,7 @@ void RasterizerVulkan::DispatchCompute() {
     scheduler.Record([dim](vk::CommandBuffer cmdbuf) { cmdbuf.Dispatch(dim[0], dim[1], dim[2]); });
 
     // Log compute dispatch
-    if (GPU::Logging::IsActive() &&
+    if (Settings::values.gpu_logging_enabled.GetValue() &&
         Settings::values.gpu_log_vulkan_calls.GetValue()) {
         const std::string params = fmt::format("groupCountX={}, groupCountY={}, groupCountZ={}",
             dim[0], dim[1], dim[2]);
@@ -1110,7 +1110,7 @@ void RasterizerVulkan::HandleTransformFeedback() {
                               regs.transform_feedback_enabled);
     if (regs.transform_feedback_enabled != 0) {
         // Log extension usage for transform feedback
-        if (GPU::Logging::IsActive()) {
+        if (Settings::values.gpu_logging_enabled.GetValue()) {
             GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
                 "VK_EXT_transform_feedback", "HandleTransformFeedback");
         }
@@ -1578,7 +1578,7 @@ void RasterizerVulkan::UpdateDepthClampEnable(Tegra::Engines::Maxwell3D::Regs& r
     if (!state_tracker.TouchDepthClampEnable()) {
         return;
     }
-    if (!pipeline_cache.SupportsDynamicState3DepthClampEnable()) {
+    if (!device.SupportsDynamicState3DepthClampEnable()) {
         return;
     }
     bool is_enabled = !(regs.viewport_clip_control.geometry_clip ==

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -181,7 +181,7 @@ void Scheduler::RequestRenderpass(const Framebuffer* framebuffer) {
     state.render_area = render_area;
 
     // Log render pass begin
-    if (GPU::Logging::IsActive() &&
+    if (Settings::values.gpu_logging_enabled.GetValue() &&
         Settings::values.gpu_log_vulkan_calls.GetValue()) {
         const std::string render_pass_info = fmt::format(
             "renderArea={}x{}, numImages={}",
@@ -292,7 +292,7 @@ u64 Scheduler::SubmitExecution(VkSemaphore signal_semaphore, VkSemaphore wait_se
                     cmdbuf, upload_cmdbuf, signal_semaphore, wait_semaphore, signal_value)) {
         case VK_SUCCESS:
             // Log successful queue submission
-            if (GPU::Logging::IsActive() &&
+            if (Settings::values.gpu_logging_enabled.GetValue() &&
                 Settings::values.gpu_log_vulkan_calls.GetValue()) {
                 GPU::Logging::GPULogger::GetInstance().LogVulkanCall(
                     "vkQueueSubmit", "", VK_SUCCESS);
@@ -335,7 +335,7 @@ void Scheduler::EndRenderPass()
         query_cache->CounterClose(VideoCommon::QueryType::StreamingByteCount);
 
         // Log render pass end
-        if (GPU::Logging::IsActive() &&
+        if (Settings::values.gpu_logging_enabled.GetValue() &&
             Settings::values.gpu_log_vulkan_calls.GetValue()) {
             GPU::Logging::GPULogger::GetInstance().LogRenderPassEnd();
         }

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include <atomic>
 #include <condition_variable>
 #include <cstddef>
 #include <functional>
@@ -93,12 +92,10 @@ public:
         requires std::is_invocable_v<T, vk::CommandBuffer, vk::CommandBuffer>
     void RecordWithUploadBuffer(T&& command) {
         if (chunk->Record(command)) {
-            record_serial.fetch_add(1, std::memory_order_relaxed);
             return;
         }
         DispatchWork();
         (void)chunk->Record(command);
-        record_serial.fetch_add(1, std::memory_order_relaxed);
     }
 
     template <typename T>
@@ -120,11 +117,6 @@ public:
         return master_semaphore->IsFree(tick);
     }
 
-    /// Returns a monotonic serial incremented for every recorded command callback.
-    [[nodiscard]] u64 CurrentRecordSerial() const noexcept {
-        return record_serial.load(std::memory_order_relaxed);
-    }
-
     /// Waits for the given GPU tick, optionally pacing frames.
     void Wait(u64 tick, double target_fps = 0.0) {
         if (tick > 0) {
@@ -306,7 +298,6 @@ private:
     u64 frame_counter{};
 
     u64 last_submitted_tick = 0;
-    std::atomic<u64> record_serial{0};
 };
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -2332,7 +2332,7 @@ Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& t
     if (has_custom_border_colors) {
         pnext = &border_ci;
         // Log extension usage for custom border color
-        if (GPU::Logging::IsActive()) {
+        if (Settings::values.gpu_logging_enabled.GetValue()) {
             GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
                 "VK_EXT_custom_border_color", "Sampler::Sampler");
         }

src/video_core/shader_environment.cpp

@@ -18,7 +18,6 @@
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
 #include "common/logging.h"
-#include "common/settings.h"
 #include <ranges>
 #include "shader_recompiler/environment.h"
 #include "video_core/engines/kepler_compute.h"
@@ -74,36 +73,36 @@ static Shader::TexturePixelFormat ConvertTexturePixelFormat(const Tegra::Texture
 static std::string_view StageToPrefix(Shader::Stage stage) {
     switch (stage) {
     case Shader::Stage::VertexB:
-        return "vs";
+        return "VB";
     case Shader::Stage::TessellationControl:
-        return "tc";
+        return "TC";
     case Shader::Stage::TessellationEval:
-        return "te";
+        return "TE";
     case Shader::Stage::Geometry:
-        return "gs";
+        return "GS";
     case Shader::Stage::Fragment:
-        return "fs";
+        return "FS";
     case Shader::Stage::Compute:
-        return "cs";
+        return "CS";
     case Shader::Stage::VertexA:
-        return "va";
+        return "VA";
     default:
-        return "uk";
+        return "UK";
     }
 }
 
-static void DumpImpl(u64 /*pipeline_hash*/, u64 shader_hash, std::span<const u64> code,
+static void DumpImpl(u64 pipeline_hash, u64 shader_hash, std::span<const u64> code,
                      [[maybe_unused]] u32 read_highest, [[maybe_unused]] u32 read_lowest,
                      u32 initial_offset, Shader::Stage stage) {
-    const auto dump_dir{Common::FS::GetEdenPath(Common::FS::EdenPath::DumpDir)};
-    if (!Common::FS::CreateDir(dump_dir)) {
-        LOG_ERROR(Common_Filesystem, "Failed to create dump directory");
+    const auto shader_dir{Common::FS::GetEdenPath(Common::FS::EdenPath::DumpDir)};
+    const auto base_dir{shader_dir / "shaders"};
+    if (!Common::FS::CreateDir(shader_dir) || !Common::FS::CreateDir(base_dir)) {
+        LOG_ERROR(Common_Filesystem, "Failed to create shader dump directories");
         return;
     }
     const auto prefix = StageToPrefix(stage);
-    const auto name{dump_dir /
-                    fmt::format("{:016x}_{:016x}_{}.ash",
-                                Settings::GetCurrentProgramID(), shader_hash, prefix)};
+    const auto name{base_dir /
+                    fmt::format("{:016x}_{}_{:016x}.ash", pipeline_hash, prefix, shader_hash)};
     std::fstream shader_file(name, std::ios::out | std::ios::binary);
     ASSERT(initial_offset % sizeof(u64) == 0);
     const size_t jump_index = initial_offset / sizeof(u64);

src/video_core/texture_cache/image_base.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -105,7 +102,7 @@ struct ImageBase {
     VAddr cpu_addr_end = 0;
 
     u64 modification_tick = 0;
-    u64 last_use_tick = 0;
+    size_t lru_index = SIZE_MAX;
 
     std::array<u32, MAX_MIP_LEVELS> mip_level_offsets{};
 

src/video_core/texture_cache/texture_cache.h

@@ -159,54 +159,11 @@ void TextureCache<P>::RunGarbageCollector() {
         }
         return false;
     };
-
-    const auto CollectBelow = [this](u64 threshold) {
-        boost::container::small_vector<ImageId, 64> expired;
-        for (auto [id, image] : slot_images) {
-            if (image->last_use_tick < threshold) {
-                expired.push_back(id);
-            }
-        }
-        return expired;
-    };
-
-    // Aggressively clear massive sparse textures
-    if (total_used_memory >= expected_memory) {
-        auto candidates = CollectBelow(frame_tick);
-        for (const auto image_id : candidates) {
-            auto& image = slot_images[image_id];
-            if (image.info.is_sparse &&
-                image.guest_size_bytes >= 256_MiB &&
-                image.allocation_tick < frame_tick - 3) {
-                LOG_DEBUG(HW_GPU, "GC targeting old sparse texture at 0x{:X} ({} MiB, age: {} frames)",
-                         image.gpu_addr, image.guest_size_bytes / (1024 * 1024),
-                         frame_tick - image.allocation_tick);
-                if (Cleanup(image_id)) {
-                    break;
-                }
-            }
-        }
-    }
-
     Configure(false);
-    {
-        auto expired = CollectBelow(frame_tick - ticks_to_destroy);
-        for (const auto image_id : expired) {
-            if (Cleanup(image_id)) {
-                break;
-            }
-        }
-    }
-
-    // If pressure is still too high, prune aggressively.
+    lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, Cleanup);
     if (total_used_memory >= critical_memory) {
         Configure(true);
-        auto expired = CollectBelow(frame_tick - ticks_to_destroy);
-        for (const auto image_id : expired) {
-            if (Cleanup(image_id)) {
-                break;
-            }
-        }
+        lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, Cleanup);
     }
 }
 
@@ -1908,7 +1865,7 @@ std::pair<u32, u32> TextureCache<P>::PrepareDmaImage(ImageId dst_id, GPUVAddr ba
     const auto base = image.TryFindBase(base_addr);
     PrepareImage(dst_id, mark_as_modified, false);
     const auto& new_image = slot_images[dst_id];
-    new_image.last_use_tick = frame_tick;
+    lru_cache.Touch(new_image.lru_index, frame_tick);
     return std::make_pair(base->level, base->layer);
 }
 
@@ -2235,7 +2192,7 @@ void TextureCache<P>::RegisterImage(ImageId image_id) {
         tentative_size = TranscodedAstcSize(tentative_size, image.info.format);
     }
     total_used_memory += Common::AlignUp(tentative_size, 1024);
-    image.last_use_tick = frame_tick;
+    image.lru_index = lru_cache.Insert(image_id, frame_tick);
 
     ForEachGPUPage(image.gpu_addr, image.guest_size_bytes, [this, image_id](u64 page) {
         (*channel_state->gpu_page_table)[page].push_back(image_id);
@@ -2269,7 +2226,7 @@ void TextureCache<P>::UnregisterImage(ImageId image_id) {
                "Trying to unregister an already registered image");
     image.flags &= ~ImageFlagBits::Registered;
     image.flags &= ~ImageFlagBits::BadOverlap;
-
+    lru_cache.Free(image.lru_index);
     const auto& clear_page_table =
         [image_id](u64 page, ankerl::unordered_dense::map<u64, std::vector<ImageId>, Common::IdentityHash<u64>>& selected_page_table) {
             const auto page_it = selected_page_table.find(page);
@@ -2597,7 +2554,7 @@ void TextureCache<P>::PrepareImage(ImageId image_id, bool is_modification, bool
     if (is_modification) {
         MarkModification(image);
     }
-    image.last_use_tick = frame_tick;
+    lru_cache.Touch(image.lru_index, frame_tick);
 }
 
 template <class P>

src/video_core/texture_cache/texture_cache_base.h

@@ -23,7 +23,7 @@
 #include "common/common_types.h"
 #include "common/hash.h"
 #include "common/literals.h"
-
+#include "common/lru_cache.h"
 #include <ranges>
 #include "common/scratch_buffer.h"
 #include "common/slot_vector.h"
@@ -485,7 +485,11 @@ private:
     std::deque<std::vector<AsyncBuffer>> async_buffers;
     std::deque<AsyncBuffer> async_buffers_death_ring;
 
-
+    struct LRUItemParams {
+        using ObjectType = ImageId;
+        using TickType = u64;
+    };
+    Common::LeastRecentlyUsedCache<LRUItemParams> lru_cache;
 
  #ifdef YUZU_LEGACY
     static constexpr size_t TICKS_TO_DESTROY = 6;

src/video_core/vulkan_common/vulkan_debug_callback.cpp

@@ -76,7 +76,7 @@ VkBool32 DebugUtilCallback(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
     }
 
     // Route to GPU logger for tracking Vulkan validation messages
-    if (GPU::Logging::IsActive() &&
+    if (Settings::values.gpu_logging_enabled.GetValue() &&
         Settings::values.gpu_log_vulkan_calls.GetValue()) {
         // Convert severity to result code for logging (negative = error)
         int result_code = 0;

src/video_core/vulkan_common/vulkan_device.cpp

@@ -441,6 +441,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     const bool is_mvk = driver_id == VK_DRIVER_ID_MOLTENVK;
     const bool is_qualcomm = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
     const bool is_turnip = driver_id == VK_DRIVER_ID_MESA_TURNIP;
+    const bool is_arm = driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
 
     if (!is_suitable)
         LOG_WARNING(Render_Vulkan, "Unsuitable driver - continuing anyways");
@@ -656,6 +657,11 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         properties.properties.limits.maxVertexInputBindings = 32;
     }
 
+    if (is_arm && SupportsMultiViewport()) {
+        LOG_WARNING(Render_Vulkan, "ARM driver requires setting multiple viewports on command buffer reuse");
+        requires_setting_multi_viewports_on_cmdbuf_reuse = true;
+    }
+
     const auto dyna_state = Settings::values.dyna_state.GetValue();
 
     // Base dynamic states (VIEWPORT, SCISSOR, DEPTH_BIAS, etc.) are ALWAYS active in vk_graphics_pipeline.cpp
@@ -1518,10 +1524,7 @@ std::vector<VkDeviceQueueCreateInfo> Device::GetDeviceQueueCreateInfos() const {
 }
 
 void Device::InitializeGPULogging() {
-    // Get log level from settings — Off is the disable.
-    const auto log_level = static_cast<GPU::Logging::LogLevel>(
-        static_cast<u32>(Settings::values.gpu_log_level.GetValue()));
-    if (log_level == GPU::Logging::LogLevel::Off) {
+    if (!Settings::values.gpu_logging_enabled.GetValue()) {
         return;
     }
 
@@ -1535,12 +1538,18 @@ void Device::InitializeGPULogging() {
         detected_driver = GPU::Logging::DriverType::Qualcomm;
     }
 
+    // Get log level from settings
+    const auto log_level = static_cast<GPU::Logging::LogLevel>(
+        static_cast<u32>(Settings::values.gpu_log_level.GetValue()));
+
     // Initialize GPU logger
     GPU::Logging::GPULogger::GetInstance().Initialize(log_level, detected_driver);
 
     // Configure feature flags
     GPU::Logging::GPULogger::GetInstance().EnableVulkanCallTracking(
         Settings::values.gpu_log_vulkan_calls.GetValue());
+    GPU::Logging::GPULogger::GetInstance().EnableShaderDumps(
+        Settings::values.gpu_log_shader_dumps.GetValue());
     GPU::Logging::GPULogger::GetInstance().EnableMemoryTracking(
         Settings::values.gpu_log_memory_tracking.GetValue());
     GPU::Logging::GPULogger::GetInstance().EnableDriverDebugInfo(

src/video_core/vulkan_common/vulkan_device.h

@@ -834,6 +834,10 @@ public:
         return features2.features.multiViewport;
     }
 
+    u32 GetViewportCount() const noexcept {
+        return requires_setting_multi_viewports_on_cmdbuf_reuse ? 2U : 1U;
+    }
+
     /// Returns true if the device supports VK_KHR_maintenance1.
     bool IsKhrMaintenance1Supported() const {
         return extensions.maintenance1;
@@ -1046,6 +1050,7 @@ private:
     bool supports_d24_depth{};                 ///< Supports D24 depth buffers.
     bool cant_blit_msaa{};                     ///< Does not support MSAA<->MSAA blitting.
     bool must_emulate_scaled_formats{};        ///< Requires scaled vertex format emulation
+    bool requires_setting_multi_viewports_on_cmdbuf_reuse{}; ///< ARM workaround to always set 2+ viewports.
     bool dynamic_state3_blending{};            ///< Has blending features of dynamic_state3.
     bool dynamic_state3_enables{};             ///< Has at least one enable feature of dynamic_state3.
     bool dynamic_state3_depth_clamp_enable{};

src/video_core/vulkan_common/vulkan_memory_allocator.cpp

@@ -111,7 +111,7 @@ namespace Vulkan {
             : allocator{alloc}, allocation{a}, memory{info.deviceMemory},
               offset{info.offset}, size{info.size}, mapped_ptr{info.pMappedData} {
         // Log GPU memory allocation
-        if (GPU::Logging::IsActive() &&
+        if (Settings::values.gpu_logging_enabled.GetValue() &&
             Settings::values.gpu_log_memory_tracking.GetValue()) {
             GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(
                 reinterpret_cast<uintptr_t>(memory),
@@ -179,7 +179,7 @@ namespace Vulkan {
     void MemoryCommit::Release() {
         if (allocation && allocator) {
             // Log GPU memory deallocation
-            if (GPU::Logging::IsActive() &&
+            if (Settings::values.gpu_logging_enabled.GetValue() &&
                 Settings::values.gpu_log_memory_tracking.GetValue() &&
                 memory != VK_NULL_HANDLE) {
                 GPU::Logging::GPULogger::GetInstance().LogMemoryDeallocation(
@@ -243,7 +243,7 @@ namespace Vulkan {
         vk::Check(vmaCreateImage(allocator, &ci, &alloc_ci, &handle, &allocation, &alloc_info));
 
         // Log GPU memory allocation for images
-        if (GPU::Logging::IsActive() &&
+        if (Settings::values.gpu_logging_enabled.GetValue() &&
             Settings::values.gpu_log_memory_tracking.GetValue()) {
             GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(
                 reinterpret_cast<uintptr_t>(alloc_info.deviceMemory),
@@ -281,7 +281,7 @@ namespace Vulkan {
         vmaGetAllocationMemoryProperties(allocator, allocation, &property_flags);
 
         // Log GPU memory allocation for buffers
-        if (GPU::Logging::IsActive() &&
+        if (Settings::values.gpu_logging_enabled.GetValue() &&
             Settings::values.gpu_log_memory_tracking.GetValue()) {
             GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(
                 reinterpret_cast<uintptr_t>(alloc_info.deviceMemory),

src/yuzu/configuration/configure_debug.cpp

@@ -81,8 +81,8 @@ void ConfigureDebug::SetConfiguration() {
     ui->enable_shader_feedback->setChecked(Settings::values.renderer_shader_feedback.GetValue());
     ui->enable_nsight_aftermath->setEnabled(runtime_lock);
     ui->enable_nsight_aftermath->setChecked(Settings::values.enable_nsight_aftermath.GetValue());
-    ui->dump_guest_shaders->setEnabled(runtime_lock);
-    ui->dump_guest_shaders->setChecked(Settings::values.dump_guest_shaders.GetValue());
+    ui->dump_shaders->setEnabled(runtime_lock);
+    ui->dump_shaders->setChecked(Settings::values.dump_shaders.GetValue());
     ui->dump_macros->setEnabled(runtime_lock);
     ui->dump_macros->setChecked(Settings::values.dump_macros.GetValue());
     ui->disable_macro_jit->setEnabled(runtime_lock);
@@ -94,12 +94,6 @@ void ConfigureDebug::SetConfiguration() {
         Settings::values.disable_shader_loop_safety_checks.GetValue());
     ui->perform_vulkan_check->setChecked(Settings::values.perform_vulkan_check.GetValue());
     ui->debug_knobs_spinbox->setValue(Settings::values.debug_knobs.GetValue());
-
-    ui->gpu_log_level->setEnabled(runtime_lock);
-    ui->gpu_log_level->setCurrentIndex(
-        static_cast<int>(Settings::values.gpu_log_level.GetValue()));
-    ui->gpu_log_shader_dumps->setEnabled(runtime_lock);
-    ui->gpu_log_shader_dumps->setChecked(Settings::values.gpu_log_shader_dumps.GetValue());
 #ifdef YUZU_USE_QT_WEB_ENGINE
     ui->disable_web_applet->setChecked(Settings::values.disable_web_applet.GetValue());
 #else
@@ -129,7 +123,7 @@ void ConfigureDebug::ApplyConfiguration() {
     Settings::values.disable_buffer_reorder = ui->disable_buffer_reorder->isChecked();
     Settings::values.renderer_shader_feedback = ui->enable_shader_feedback->isChecked();
     Settings::values.enable_nsight_aftermath = ui->enable_nsight_aftermath->isChecked();
-    Settings::values.dump_guest_shaders = ui->dump_guest_shaders->isChecked();
+    Settings::values.dump_shaders = ui->dump_shaders->isChecked();
     Settings::values.dump_macros = ui->dump_macros->isChecked();
     Settings::values.disable_shader_loop_safety_checks =
         ui->disable_loop_safety_checks->isChecked();
@@ -141,9 +135,6 @@ void ConfigureDebug::ApplyConfiguration() {
     Settings::values.serial_battery = ui->serial_battery_edit->text().toUInt();
     Settings::values.serial_unit = ui->serial_board_edit->text().toUInt();
     Settings::values.debug_knobs = ui->debug_knobs_spinbox->value();
-    Settings::values.gpu_log_level =
-        static_cast<Settings::GpuLogLevel>(ui->gpu_log_level->currentIndex());
-    Settings::values.gpu_log_shader_dumps = ui->gpu_log_shader_dumps->isChecked();
     Debugger::ToggleConsole();
     Common::Log::Filter filter;
     filter.ParseFilterString(Settings::values.log_filter.GetValue());

src/yuzu/configuration/configure_debug.ui

@@ -157,7 +157,7 @@
          <string>Logging</string>
         </property>
         <layout class="QGridLayout" name="gridLayout_1">
-         <item row="0" column="0" colspan="4">
+         <item row="0" column="0" colspan="2">
           <widget class="QWidget" name="logging_widget" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
@@ -197,77 +197,7 @@
            </layout>
           </widget>
          </item>
-         <item row="1" column="0">
-          <widget class="QWidget" name="gpu_log_level_widget" native="true">
-           <property name="sizePolicy">
-            <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
-             <horstretch>0</horstretch>
-             <verstretch>0</verstretch>
-            </sizepolicy>
-           </property>
-           <layout class="QHBoxLayout" name="gpu_log_level_layout">
-            <property name="leftMargin">
-             <number>0</number>
-            </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="QLabel" name="gpu_log_level_label">
-              <property name="text">
-               <string>GPU Logging/Level</string>
-              </property>
-             </widget>
-            </item>
-            <item>
-             <widget class="QComboBox" name="gpu_log_level">
-              <property name="toolTip">
-               <string>Detail level for GPU logs. Off disables logging entirely.</string>
-              </property>
-              <item>
-               <property name="text">
-                <string>Off</string>
-               </property>
-              </item>
-              <item>
-               <property name="text">
-                <string>Errors</string>
-               </property>
-              </item>
-              <item>
-               <property name="text">
-                <string>Standard</string>
-               </property>
-              </item>
-              <item>
-               <property name="text">
-                <string>Verbose</string>
-               </property>
-              </item>
-              <item>
-               <property name="text">
-                <string>All</string>
-               </property>
-              </item>
-             </widget>
-            </item>
-           </layout>
-          </widget>
-         </item>
-         <item row="1" column="1">
-          <widget class="QCheckBox" name="toggle_console">
-           <property name="text">
-            <string>Show Log in Console</string>
-           </property>
-          </widget>
-         </item>
-         <item row="1" column="2">
+         <item row="2" column="0">
           <widget class="QCheckBox" name="extended_logging">
            <property name="enabled">
             <bool>true</bool>
@@ -280,20 +210,15 @@
            </property>
           </widget>
          </item>
-         <item row="1" column="3">
+         <item row="1" column="0">
+          <widget class="QCheckBox" name="toggle_console">
+           <property name="text">
+            <string>Show Log in Console</string>
+           </property>
+          </widget>
+         </item>
+         <item row="1" column="1">
           <widget class="QPushButton" name="open_log_button">
-           <property name="sizePolicy">
-            <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
-             <horstretch>1</horstretch>
-             <verstretch>0</verstretch>
-            </sizepolicy>
-           </property>
-           <property name="minimumSize">
-            <size>
-             <width>250</width>
-             <height>0</height>
-            </size>
-           </property>
            <property name="text">
             <string>Open Log Location</string>
            </property>
@@ -345,7 +270,7 @@
            </property>
           </widget>
          </item>
-         <item row="9" column="0">
+         <item row="8" column="0">
           <widget class="QCheckBox" name="dump_macros">
            <property name="enabled">
             <bool>true</bool>
@@ -369,15 +294,15 @@
           </widget>
          </item>
          <item row="6" column="0">
-          <widget class="QCheckBox" name="dump_guest_shaders">
+          <widget class="QCheckBox" name="dump_shaders">
            <property name="enabled">
             <bool>true</bool>
            </property>
            <property name="toolTip">
-            <string>When checked, it will dump original Maxwell guest shader bytecode (the input to the recompiler) as .ash files under DumpDir/shaders/. Useful for inspection with nvdisasm.</string>
+            <string>When checked, it will dump all the original assembler shaders from the disk shader cache or game as found</string>
            </property>
            <property name="text">
-            <string>Dump Guest (Maxwell) Shaders</string>
+            <string>Dump Game Shaders</string>
            </property>
           </widget>
          </item>
@@ -388,7 +313,7 @@
            </property>
           </widget>
          </item>
-         <item row="8" column="0">
+         <item row="7" column="0">
           <widget class="QCheckBox" name="disable_macro_jit">
            <property name="enabled">
             <bool>true</bool>
@@ -401,7 +326,7 @@
            </property>
           </widget>
          </item>
-         <item row="10" column="0">
+         <item row="9" column="0">
           <widget class="QCheckBox" name="disable_macro_hle">
            <property name="enabled">
             <bool>true</bool>
@@ -427,7 +352,7 @@
            </property>
           </widget>
          </item>
-         <item row="11" column="0">
+         <item row="10" column="0">
           <spacer name="verticalSpacer_5">
            <property name="orientation">
             <enum>Qt::Orientation::Vertical</enum>
@@ -463,16 +388,6 @@
            </property>
           </widget>
          </item>
-         <item row="7" column="0">
-          <widget class="QCheckBox" name="gpu_log_shader_dumps">
-           <property name="toolTip">
-            <string>When checked, it will dump the recompiler's output SPIR-V binaries (.spv) under LogDir/shaders/. Inspect via SPIRV-Tools (spirv-dis / spirv-cross / spirv-val) or RenderDoc.</string>
-           </property>
-           <property name="text">
-            <string>Dump SPIR-V Shaders</string>
-           </property>
-          </widget>
-         </item>
         </layout>
        </widget>
       </item>
@@ -599,65 +514,31 @@
            </layout>
           </widget>
          </item>
-         <item row="8" column="0">
-          <widget class="QWidget" name="debug_knobs_widget" native="true">
-           <property name="sizePolicy">
-            <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
-             <horstretch>0</horstretch>
-             <verstretch>0</verstretch>
-            </sizepolicy>
-           </property>
-           <layout class="QHBoxLayout" name="horizontalLayout_debug_knobs">
-            <property name="leftMargin">
-             <number>0</number>
-            </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="QLabel" name="label_debug_knobs">
-              <property name="sizePolicy">
-               <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
-                <horstretch>0</horstretch>
-                <verstretch>0</verstretch>
-               </sizepolicy>
-              </property>
-              <property name="text">
-               <string>Debug Knobs:</string>
-              </property>
-             </widget>
-            </item>
-            <item>
-             <widget class="QSpinBox" name="debug_knobs_spinbox">
-              <property name="minimum">
-               <number>0</number>
-              </property>
-              <property name="maximum">
-               <number>65535</number>
-              </property>
-              <property name="toolTip">
-               <string>Bitmask for quick development toggles</string>
-              </property>
-              <property name="statusTip">
-               <string>Set debug knobs (bitmask)</string>
-              </property>
-              <property name="whatsThis">
-               <string>16-bit debug knob set for quick development toggles</string>
-              </property>
-              <property name="suffix">
-               <string> (bitmask)</string>
-              </property>
-             </widget>
-            </item>
-           </layout>
-          </widget>
-         </item>
+          <item row="8" column="0">
+            <widget class="QSpinBox" name="debug_knobs_spinbox">
+                <property name="minimum">
+                <number>0</number>
+                </property>
+                <property name="maximum">
+                <number>65535</number>
+                </property>
+                <property name="toolTip">
+                <string>Bitmask for quick development toggles</string>
+                </property>
+                <property name="statusTip">
+                <string>Set debug knobs (bitmask)</string>
+                </property>
+                <property name="whatsThis">
+                <string>16-bit debug knob set for quick development toggles</string>
+                </property>
+                <property name="suffix">
+                <string> (bitmask)</string>
+                </property>
+                <property name="prefix">
+                <string>Debug Knobs: </string>
+                </property>
+            </widget>
+          </item>
          <item row="7" column="0">
           <widget class="QWidget" name="serial_board_widget" native="true">
            <property name="sizePolicy">
@@ -698,7 +579,7 @@
            </layout>
           </widget>
          </item>
-         <item row="20" column="0">
+         <item row="0" column="0">
           <spacer name="verticalSpacer_3">
            <property name="orientation">
             <enum>Qt::Orientation::Vertical</enum>