144 files changed, 2173 insertions, 1790 deletions
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 1e977e8a8..71efbb40d 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -62,6 +62,12 @@ else()
        -Wno-unused-parameter
    )
+    # TODO: Remove when we update to a GCC compiler that enables this
+    #       by default (i.e. GCC 10 or newer).
+    if (CMAKE_CXX_COMPILER_ID STREQUAL GNU)
+        add_compile_options(-fconcepts)
+    endif()
    if (ARCHITECTURE_x86_64)
        add_compile_options("-mcx16")
    endif()
diff --git a/src/audio_core/cubeb_sink.cpp b/src/audio_core/cubeb_sink.cpp
index 41bf5cd4d..c27df946c 100644
--- a/src/audio_core/cubeb_sink.cpp
+++ b/src/audio_core/cubeb_sink.cpp
@@ -78,7 +78,7 @@ public:
                const s16 surround_left{samples[i + 4]};
                const s16 surround_right{samples[i + 5]};
                // Not used in the ATSC reference implementation
-                [[maybe_unused]] const s16 low_frequency_effects { samples[i + 3] };
+                [[maybe_unused]] const s16 low_frequency_effects{samples[i + 3]};
                constexpr s32 clev{707}; // center mixing level coefficient
                constexpr s32 slev{707}; // surround mixing level coefficient
diff --git a/src/audio_core/stream.cpp b/src/audio_core/stream.cpp
index f80ab92e4..7be5d5087 100644
--- a/src/audio_core/stream.cpp
+++ b/src/audio_core/stream.cpp
@@ -36,9 +36,10 @@ Stream::Stream(Core::Timing::CoreTiming& core_timing, u32 sample_rate, Format fo
               ReleaseCallback&& release_callback, SinkStream& sink_stream, std::string&& name_)
    : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)},
      sink_stream{sink_stream}, core_timing{core_timing}, name{std::move(name_)} {
+    release_event =
-    release_event = Core::Timing::CreateEvent(
+        Core::Timing::CreateEvent(name, [this](std::uintptr_t, std::chrono::nanoseconds ns_late) {
-        name, [this](u64, std::chrono::nanoseconds ns_late) { ReleaseActiveBuffer(ns_late); });
+            ReleaseActiveBuffer(ns_late);
+        });
 }
 void Stream::Play() {
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index d120c8d3d..78c3bfb3b 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -110,6 +110,7 @@ add_library(common STATIC
    common_funcs.h
    common_paths.h
    common_types.h
+    concepts.h
    dynamic_library.cpp
    dynamic_library.h
    fiber.cpp
diff --git a/src/common/atomic_ops.cpp b/src/common/atomic_ops.cpp
index 1098e21ff..1612d0e67 100644
--- a/src/common/atomic_ops.cpp
+++ b/src/common/atomic_ops.cpp
@@ -14,50 +14,55 @@ namespace Common {
 #if _MSC_VER
-bool AtomicCompareAndSwap(u8 volatile* pointer, u8 value, u8 expected) {
+bool AtomicCompareAndSwap(volatile u8* pointer, u8 value, u8 expected) {
-    u8 result = _InterlockedCompareExchange8((char*)pointer, value, expected);
+    const u8 result =
+        _InterlockedCompareExchange8(reinterpret_cast<volatile char*>(pointer), value, expected);
    return result == expected;
 }
-bool AtomicCompareAndSwap(u16 volatile* pointer, u16 value, u16 expected) {
+bool AtomicCompareAndSwap(volatile u16* pointer, u16 value, u16 expected) {
-    u16 result = _InterlockedCompareExchange16((short*)pointer, value, expected);
+    const u16 result =
+        _InterlockedCompareExchange16(reinterpret_cast<volatile short*>(pointer), value, expected);
    return result == expected;
 }
-bool AtomicCompareAndSwap(u32 volatile* pointer, u32 value, u32 expected) {
+bool AtomicCompareAndSwap(volatile u32* pointer, u32 value, u32 expected) {
-    u32 result = _InterlockedCompareExchange((long*)pointer, value, expected);
+    const u32 result =
+        _InterlockedCompareExchange(reinterpret_cast<volatile long*>(pointer), value, expected);
    return result == expected;
 }
-bool AtomicCompareAndSwap(u64 volatile* pointer, u64 value, u64 expected) {
+bool AtomicCompareAndSwap(volatile u64* pointer, u64 value, u64 expected) {
-    u64 result = _InterlockedCompareExchange64((__int64*)pointer, value, expected);
+    const u64 result = _InterlockedCompareExchange64(reinterpret_cast<volatile __int64*>(pointer),
+                                                     value, expected);
    return result == expected;
 }
-bool AtomicCompareAndSwap(u64 volatile* pointer, u128 value, u128 expected) {
+bool AtomicCompareAndSwap(volatile u64* pointer, u128 value, u128 expected) {
-    return _InterlockedCompareExchange128((__int64*)pointer, value[1], value[0],
+    return _InterlockedCompareExchange128(reinterpret_cast<volatile __int64*>(pointer), value[1],
-                                          (__int64*)expected.data()) != 0;
+                                          value[0],
+                                          reinterpret_cast<__int64*>(expected.data())) != 0;
 }
 #else
-bool AtomicCompareAndSwap(u8 volatile* pointer, u8 value, u8 expected) {
+bool AtomicCompareAndSwap(volatile u8* pointer, u8 value, u8 expected) {
    return __sync_bool_compare_and_swap(pointer, expected, value);
 }
-bool AtomicCompareAndSwap(u16 volatile* pointer, u16 value, u16 expected) {
+bool AtomicCompareAndSwap(volatile u16* pointer, u16 value, u16 expected) {
    return __sync_bool_compare_and_swap(pointer, expected, value);
 }
-bool AtomicCompareAndSwap(u32 volatile* pointer, u32 value, u32 expected) {
+bool AtomicCompareAndSwap(volatile u32* pointer, u32 value, u32 expected) {
    return __sync_bool_compare_and_swap(pointer, expected, value);
 }
-bool AtomicCompareAndSwap(u64 volatile* pointer, u64 value, u64 expected) {
+bool AtomicCompareAndSwap(volatile u64* pointer, u64 value, u64 expected) {
    return __sync_bool_compare_and_swap(pointer, expected, value);
 }
-bool AtomicCompareAndSwap(u64 volatile* pointer, u128 value, u128 expected) {
+bool AtomicCompareAndSwap(volatile u64* pointer, u128 value, u128 expected) {
    unsigned __int128 value_a;
    unsigned __int128 expected_a;
    std::memcpy(&value_a, value.data(), sizeof(u128));
diff --git a/src/common/atomic_ops.h b/src/common/atomic_ops.h
index e6181d521..8d6b73c00 100644
--- a/src/common/atomic_ops.h
+++ b/src/common/atomic_ops.h
@@ -8,10 +8,10 @@
 namespace Common {
-bool AtomicCompareAndSwap(u8 volatile* pointer, u8 value, u8 expected);
+bool AtomicCompareAndSwap(volatile u8* pointer, u8 value, u8 expected);
-bool AtomicCompareAndSwap(u16 volatile* pointer, u16 value, u16 expected);
+bool AtomicCompareAndSwap(volatile u16* pointer, u16 value, u16 expected);
-bool AtomicCompareAndSwap(u32 volatile* pointer, u32 value, u32 expected);
+bool AtomicCompareAndSwap(volatile u32* pointer, u32 value, u32 expected);
-bool AtomicCompareAndSwap(u64 volatile* pointer, u64 value, u64 expected);
+bool AtomicCompareAndSwap(volatile u64* pointer, u64 value, u64 expected);
-bool AtomicCompareAndSwap(u64 volatile* pointer, u128 value, u128 expected);
+bool AtomicCompareAndSwap(volatile u64* pointer, u128 value, u128 expected);
 } // namespace Common
diff --git a/src/common/common_paths.h b/src/common/common_paths.h
index 076752d3b..3c593d5f6 100644
--- a/src/common/common_paths.h
+++ b/src/common/common_paths.h
@@ -35,6 +35,7 @@
 #define KEYS_DIR "keys"
 #define LOAD_DIR "load"
 #define DUMP_DIR "dump"
+#define SCREENSHOTS_DIR "screenshots"
 #define SHADER_DIR "shader"
 #define LOG_DIR "log"
diff --git a/src/common/concepts.h b/src/common/concepts.h
new file mode 100644
index 000000000..54252e778
--- /dev/null
+++ b/src/common/concepts.h
@@ -0,0 +1,34 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#pragma once
+namespace Common {
+#include <type_traits>
+// Check if type is like an STL container
+template <typename T>
+concept IsSTLContainer = requires(T t) {
+    typename T::value_type;
+    typename T::iterator;
+    typename T::const_iterator;
+    // TODO(ogniK): Replace below is std::same_as<void> when MSVC supports it.
+    t.begin();
+    t.end();
+    t.cbegin();
+    t.cend();
+    t.data();
+    t.size();
+};
+// TODO: Replace with std::derived_from when the <concepts> header
+//       is available on all supported platforms.
+template <typename Derived, typename Base>
+concept DerivedFrom = requires {
+    std::is_base_of_v<Base, Derived>;
+    std::is_convertible_v<const volatile Derived*, const volatile Base*>;
+};
+} // namespace Common
diff --git a/src/common/detached_tasks.cpp b/src/common/detached_tasks.cpp
index f268d6021..f2b4939df 100644
--- a/src/common/detached_tasks.cpp
+++ b/src/common/detached_tasks.cpp
@@ -34,8 +34,7 @@ void DetachedTasks::AddTask(std::function<void()> task) {
        std::unique_lock lock{instance->mutex};
        --instance->count;
        std::notify_all_at_thread_exit(instance->cv, std::move(lock));
-    })
+    }).detach();
-        .detach();
 }
 } // namespace Common
diff --git a/src/common/file_util.cpp b/src/common/file_util.cpp
index 45b750e1e..4ede9f72c 100644
--- a/src/common/file_util.cpp
+++ b/src/common/file_util.cpp
@@ -695,6 +695,7 @@ const std::string& GetUserPath(UserPath path, const std::string& new_path) {
        paths.emplace(UserPath::NANDDir, user_path + NAND_DIR DIR_SEP);
        paths.emplace(UserPath::LoadDir, user_path + LOAD_DIR DIR_SEP);
        paths.emplace(UserPath::DumpDir, user_path + DUMP_DIR DIR_SEP);
+        paths.emplace(UserPath::ScreenshotsDir, user_path + SCREENSHOTS_DIR DIR_SEP);
        paths.emplace(UserPath::ShaderDir, user_path + SHADER_DIR DIR_SEP);
        paths.emplace(UserPath::SysDataDir, user_path + SYSDATA_DIR DIR_SEP);
        paths.emplace(UserPath::KeysDir, user_path + KEYS_DIR DIR_SEP);
diff --git a/src/common/file_util.h b/src/common/file_util.h
index f7a0c33fa..187b93161 100644
--- a/src/common/file_util.h
+++ b/src/common/file_util.h
@@ -32,6 +32,7 @@ enum class UserPath {
    SDMCDir,
    LoadDir,
    DumpDir,
+    ScreenshotsDir,
    ShaderDir,
    SysDataDir,
    UserDir,
diff --git a/src/common/hex_util.cpp b/src/common/hex_util.cpp
index c2f6cf0f6..74f52dd11 100644
--- a/src/common/hex_util.cpp
+++ b/src/common/hex_util.cpp
@@ -3,21 +3,9 @@
 // Refer to the license.txt file included.
 #include "common/hex_util.h"
-#include "common/logging/log.h"
 namespace Common {
-u8 ToHexNibble(char c1) {
-    if (c1 >= 65 && c1 <= 70)
-        return c1 - 55;
-    if (c1 >= 97 && c1 <= 102)
-        return c1 - 87;
-    if (c1 >= 48 && c1 <= 57)
-        return c1 - 48;
-    LOG_ERROR(Common, "Invalid hex digit: 0x{:02X}", c1);
-    return 0;
-}
 std::vector<u8> HexStringToVector(std::string_view str, bool little_endian) {
    std::vector<u8> out(str.size() / 2);
    if (little_endian) {
@@ -30,26 +18,4 @@ std::vector<u8> HexStringToVector(std::string_view str, bool little_endian) {
    return out;
 }
-std::array<u8, 16> operator""_array16(const char* str, std::size_t len) {
-    if (len != 32) {
-        LOG_ERROR(Common,
-                  "Attempting to parse string to array that is not of correct size (expected=32, "
-                  "actual={}).",
-                  len);
-        return {};
-    }
-    return HexStringToArray<16>(str);
-}
-std::array<u8, 32> operator""_array32(const char* str, std::size_t len) {
-    if (len != 64) {
-        LOG_ERROR(Common,
-                  "Attempting to parse string to array that is not of correct size (expected=64, "
-                  "actual={}).",
-                  len);
-        return {};
-    }
-    return HexStringToArray<32>(str);
-}
 } // namespace Common
diff --git a/src/common/hex_util.h b/src/common/hex_util.h
index bb4736f96..a0a0e78a4 100644
--- a/src/common/hex_util.h
+++ b/src/common/hex_util.h
@@ -14,19 +14,31 @@
 namespace Common {
-u8 ToHexNibble(char c1);
+constexpr u8 ToHexNibble(char c) {
+    if (c >= 65 && c <= 70) {
+        return c - 55;
+    }
+    if (c >= 97 && c <= 102) {
+        return c - 87;
+    }
+    return c - 48;
+}
 std::vector<u8> HexStringToVector(std::string_view str, bool little_endian);
 template <std::size_t Size, bool le = false>
-std::array<u8, Size> HexStringToArray(std::string_view str) {
+constexpr std::array<u8, Size> HexStringToArray(std::string_view str) {
    std::array<u8, Size> out{};
    if constexpr (le) {
-        for (std::size_t i = 2 * Size - 2; i <= 2 * Size; i -= 2)
+        for (std::size_t i = 2 * Size - 2; i <= 2 * Size; i -= 2) {
            out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]);
+        }
    } else {
-        for (std::size_t i = 0; i < 2 * Size; i += 2)
+        for (std::size_t i = 0; i < 2 * Size; i += 2) {
            out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]);
+        }
    }
    return out;
 }
@@ -48,7 +60,12 @@ std::string HexToString(const ContiguousContainer& data, bool upper = true) {
    return out;
 }
-std::array<u8, 0x10> operator"" _array16(const char* str, std::size_t len);
+constexpr std::array<u8, 16> AsArray(const char (&data)[17]) {
-std::array<u8, 0x20> operator"" _array32(const char* str, std::size_t len);
+    return HexStringToArray<16>(data);
+}
+constexpr std::array<u8, 32> AsArray(const char (&data)[65]) {
+    return HexStringToArray<32>(data);
+}
 } // namespace Common
diff --git a/src/common/logging/backend.cpp b/src/common/logging/backend.cpp
index 04bc3128f..62cfde397 100644
--- a/src/common/logging/backend.cpp
+++ b/src/common/logging/backend.cpp
@@ -113,19 +113,19 @@ private:
    Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
                      const char* function, std::string message) const {
        using std::chrono::duration_cast;
+        using std::chrono::microseconds;
        using std::chrono::steady_clock;
-        Entry entry;
+        return {
-        entry.timestamp =
+            .timestamp = duration_cast<microseconds>(steady_clock::now() - time_origin),
-            duration_cast<std::chrono::microseconds>(steady_clock::now() - time_origin);
+            .log_class = log_class,
-        entry.log_class = log_class;
+            .log_level = log_level,
-        entry.log_level = log_level;
+            .filename = filename,
-        entry.filename = filename;
+            .line_num = line_nr,
-        entry.line_num = line_nr;
+            .function = function,
-        entry.function = function;
+            .message = std::move(message),
-        entry.message = std::move(message);
+            .final_entry = false,
+        };
-        return entry;
    }
    std::mutex writing_mutex;
diff --git a/src/common/logging/backend.h b/src/common/logging/backend.h
index fc338c70d..e5d702568 100644
--- a/src/common/logging/backend.h
+++ b/src/common/logging/backend.h
@@ -21,19 +21,13 @@ class Filter;
 */
 struct Entry {
    std::chrono::microseconds timestamp;
-    Class log_class;
+    Class log_class{};
-    Level log_level;
+    Level log_level{};
-    const char* filename;
+    const char* filename = nullptr;
-    unsigned int line_num;
+    unsigned int line_num = 0;
    std::string function;
    std::string message;
    bool final_entry = false;
-    Entry() = default;
-    Entry(Entry&& o) = default;
-    Entry& operator=(Entry&& o) = default;
-    Entry& operator=(const Entry& o) = default;
 };
 /**
diff --git a/src/common/math_util.h b/src/common/math_util.h
index 83ef0201f..abca3177c 100644
--- a/src/common/math_util.h
+++ b/src/common/math_util.h
@@ -54,6 +54,6 @@ struct Rectangle {
 };
 template <typename T>
-Rectangle(T, T, T, T)->Rectangle<T>;
+Rectangle(T, T, T, T) -> Rectangle<T>;
 } // namespace Common
diff --git a/src/common/string_util.h b/src/common/string_util.h
index 583fd05e6..023dff5dc 100644
--- a/src/common/string_util.h
+++ b/src/common/string_util.h
@@ -74,16 +74,4 @@ std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, std::size_t
 std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer,
                                                        std::size_t max_len);
-/**
- * Attempts to trim an arbitrary prefix from `path`, leaving only the part starting at `root`. It's
- * intended to be used to strip a system-specific build directory from the `__FILE__` macro,
- * leaving only the path relative to the sources root.
- *
- * @param path The input file path as a null-terminated string
- * @param root The name of the root source directory as a null-terminated string. Path up to and
- *             including the last occurrence of this name will be stripped
- * @return A pointer to the same string passed as `path`, but starting at the trimmed portion
- */
-const char* TrimSourcePath(const char* path, const char* root = "src");
 } // namespace Common
diff --git a/src/common/virtual_buffer.cpp b/src/common/virtual_buffer.cpp
index b426f4747..b009cb500 100644
--- a/src/common/virtual_buffer.cpp
+++ b/src/common/virtual_buffer.cpp
@@ -5,16 +5,7 @@
 #ifdef _WIN32
 #include <windows.h>
 #else
-#include <stdio.h>
 #include <sys/mman.h>
-#include <sys/types.h>
-#if defined __APPLE__ || defined __FreeBSD__ || defined __OpenBSD__
-#include <sys/sysctl.h>
-#elif defined __HAIKU__
-#include <OS.h>
-#else
-#include <sys/sysinfo.h>
-#endif
 #endif
 #include "common/assert.h"
@@ -38,7 +29,7 @@ void* AllocateMemoryPages(std::size_t size) {
    return base;
 }
-void FreeMemoryPages(void* base, std::size_t size) {
+void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) {
    if (!base) {
        return;
    }
diff --git a/src/core/core.cpp b/src/core/core.cpp
index e598c0e2b..42277e2cd 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -146,7 +146,7 @@ struct System::Impl {
    ResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
        LOG_DEBUG(HW_Memory, "initialized OK");
-        device_memory = std::make_unique<Core::DeviceMemory>(system);
+        device_memory = std::make_unique<Core::DeviceMemory>();
        is_multicore = Settings::values.use_multi_core.GetValue();
        is_async_gpu = is_multicore || Settings::values.use_asynchronous_gpu_emulation.GetValue();
diff --git a/src/core/core_timing.cpp b/src/core/core_timing.cpp
index b5feb3f24..71af26ec5 100644
--- a/src/core/core_timing.cpp
+++ b/src/core/core_timing.cpp
@@ -23,7 +23,7 @@ std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callbac
 struct CoreTiming::Event {
    u64 time;
    u64 fifo_order;
-    u64 userdata;
+    std::uintptr_t user_data;
    std::weak_ptr<EventType> type;
    // Sort by time, unless the times are the same, in which case sort by
@@ -58,7 +58,7 @@ void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {
    event_fifo_id = 0;
    shutting_down = false;
    ticks = 0;
-    const auto empty_timed_callback = [](u64, std::chrono::nanoseconds) {};
+    const auto empty_timed_callback = [](std::uintptr_t, std::chrono::nanoseconds) {};
    ev_lost = CreateEvent("_lost_event", empty_timed_callback);
    if (is_multicore) {
        timer_thread = std::make_unique<std::thread>(ThreadEntry, std::ref(*this));
@@ -107,22 +107,24 @@ bool CoreTiming::HasPendingEvents() const {
 }
 void CoreTiming::ScheduleEvent(std::chrono::nanoseconds ns_into_future,
-                               const std::shared_ptr<EventType>& event_type, u64 userdata) {
+                               const std::shared_ptr<EventType>& event_type,
+                               std::uintptr_t user_data) {
    {
        std::scoped_lock scope{basic_lock};
        const u64 timeout = static_cast<u64>((GetGlobalTimeNs() + ns_into_future).count());
-        event_queue.emplace_back(Event{timeout, event_fifo_id++, userdata, event_type});
+        event_queue.emplace_back(Event{timeout, event_fifo_id++, user_data, event_type});
        std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
    }
    event.Set();
 }
-void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type, u64 userdata) {
+void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type,
+                                 std::uintptr_t user_data) {
    std::scoped_lock scope{basic_lock};
    const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
-        return e.type.lock().get() == event_type.get() && e.userdata == userdata;
+        return e.type.lock().get() == event_type.get() && e.user_data == user_data;
    });
    // Removing random items breaks the invariant so we have to re-establish it.
@@ -197,7 +199,7 @@ std::optional<s64> CoreTiming::Advance() {
        if (const auto event_type{evt.type.lock()}) {
            event_type->callback(
-                evt.userdata, std::chrono::nanoseconds{static_cast<s64>(global_timer - evt.time)});
+                evt.user_data, std::chrono::nanoseconds{static_cast<s64>(global_timer - evt.time)});
        }
        basic_lock.lock();
diff --git a/src/core/core_timing.h b/src/core/core_timing.h
index 120c74e46..b0b6036e4 100644
--- a/src/core/core_timing.h
+++ b/src/core/core_timing.h
@@ -22,7 +22,8 @@
 namespace Core::Timing {
 /// A callback that may be scheduled for a particular core timing event.
-using TimedCallback = std::function<void(u64 userdata, std::chrono::nanoseconds ns_late)>;
+using TimedCallback =
+    std::function<void(std::uintptr_t user_data, std::chrono::nanoseconds ns_late)>;
 /// Contains the characteristics of a particular event.
 struct EventType {
@@ -94,9 +95,9 @@ public:
    /// Schedules an event in core timing
    void ScheduleEvent(std::chrono::nanoseconds ns_into_future,
-                       const std::shared_ptr<EventType>& event_type, u64 userdata = 0);
+                       const std::shared_ptr<EventType>& event_type, std::uintptr_t user_data = 0);
-    void UnscheduleEvent(const std::shared_ptr<EventType>& event_type, u64 userdata);
+    void UnscheduleEvent(const std::shared_ptr<EventType>& event_type, std::uintptr_t user_data);
    /// We only permit one event of each type in the queue at a time.
    void RemoveEvent(const std::shared_ptr<EventType>& event_type);
diff --git a/src/core/cpu_manager.cpp b/src/core/cpu_manager.cpp
index 32afcf3ae..358943429 100644
--- a/src/core/cpu_manager.cpp
+++ b/src/core/cpu_manager.cpp
@@ -52,15 +52,15 @@ void CpuManager::Shutdown() {
 }
 std::function<void(void*)> CpuManager::GetGuestThreadStartFunc() {
-    return std::function<void(void*)>(GuestThreadFunction);
+    return GuestThreadFunction;
 }
 std::function<void(void*)> CpuManager::GetIdleThreadStartFunc() {
-    return std::function<void(void*)>(IdleThreadFunction);
+    return IdleThreadFunction;
 }
 std::function<void(void*)> CpuManager::GetSuspendThreadStartFunc() {
-    return std::function<void(void*)>(SuspendThreadFunction);
+    return SuspendThreadFunction;
 }
 void CpuManager::GuestThreadFunction(void* cpu_manager_) {
diff --git a/src/core/crypto/aes_util.cpp b/src/core/crypto/aes_util.cpp
index 4be76bb43..330996b24 100644
--- a/src/core/crypto/aes_util.cpp
+++ b/src/core/crypto/aes_util.cpp
@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include <array>
 #include <mbedtls/cipher.h>
 #include "common/assert.h"
 #include "common/logging/log.h"
@@ -10,8 +11,10 @@
 namespace Core::Crypto {
 namespace {
-std::vector<u8> CalculateNintendoTweak(std::size_t sector_id) {
+using NintendoTweak = std::array<u8, 16>;
-    std::vector<u8> out(0x10);
+NintendoTweak CalculateNintendoTweak(std::size_t sector_id) {
+    NintendoTweak out{};
    for (std::size_t i = 0xF; i <= 0xF; --i) {
        out[i] = sector_id & 0xFF;
        sector_id >>= 8;
@@ -64,13 +67,6 @@ AESCipher<Key, KeySize>::~AESCipher() {
 }
 template <typename Key, std::size_t KeySize>
-void AESCipher<Key, KeySize>::SetIV(std::vector<u8> iv) {
-    ASSERT_MSG((mbedtls_cipher_set_iv(&ctx->encryption_context, iv.data(), iv.size()) ||
-                mbedtls_cipher_set_iv(&ctx->decryption_context, iv.data(), iv.size())) == 0,
-               "Failed to set IV on mbedtls ciphers.");
-}
-template <typename Key, std::size_t KeySize>
 void AESCipher<Key, KeySize>::Transcode(const u8* src, std::size_t size, u8* dest, Op op) const {
    auto* const context = op == Op::Encrypt ? &ctx->encryption_context : &ctx->decryption_context;
@@ -124,6 +120,13 @@ void AESCipher<Key, KeySize>::XTSTranscode(const u8* src, std::size_t size, u8*
    }
 }
+template <typename Key, std::size_t KeySize>
+void AESCipher<Key, KeySize>::SetIVImpl(const u8* data, std::size_t size) {
+    ASSERT_MSG((mbedtls_cipher_set_iv(&ctx->encryption_context, data, size) ||
+                mbedtls_cipher_set_iv(&ctx->decryption_context, data, size)) == 0,
+               "Failed to set IV on mbedtls ciphers.");
+}
 template class AESCipher<Key128>;
 template class AESCipher<Key256>;
 } // namespace Core::Crypto
diff --git a/src/core/crypto/aes_util.h b/src/core/crypto/aes_util.h
index edc4ab910..e2a304186 100644
--- a/src/core/crypto/aes_util.h
+++ b/src/core/crypto/aes_util.h
@@ -6,7 +6,6 @@
 #include <memory>
 #include <type_traits>
-#include <vector>
 #include "common/common_types.h"
 #include "core/file_sys/vfs.h"
@@ -32,10 +31,12 @@ class AESCipher {
 public:
    AESCipher(Key key, Mode mode);
    ~AESCipher();
-    void SetIV(std::vector<u8> iv);
+    template <typename ContiguousContainer>
+    void SetIV(const ContiguousContainer& container) {
+        SetIVImpl(std::data(container), std::size(container));
+    }
    template <typename Source, typename Dest>
    void Transcode(const Source* src, std::size_t size, Dest* dest, Op op) const {
@@ -59,6 +60,8 @@ public:
                      std::size_t sector_size, Op op);
 private:
+    void SetIVImpl(const u8* data, std::size_t size);
    std::unique_ptr<CipherContext> ctx;
 };
 } // namespace Core::Crypto
diff --git a/src/core/crypto/ctr_encryption_layer.cpp b/src/core/crypto/ctr_encryption_layer.cpp
index 902841c77..5c84bb0a4 100644
--- a/src/core/crypto/ctr_encryption_layer.cpp
+++ b/src/core/crypto/ctr_encryption_layer.cpp
@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include <algorithm>
 #include <cstring>
 #include "common/assert.h"
 #include "core/crypto/ctr_encryption_layer.h"
@@ -10,8 +11,7 @@ namespace Core::Crypto {
 CTREncryptionLayer::CTREncryptionLayer(FileSys::VirtualFile base_, Key128 key_,
                                       std::size_t base_offset)
-    : EncryptionLayer(std::move(base_)), base_offset(base_offset), cipher(key_, Mode::CTR),
+    : EncryptionLayer(std::move(base_)), base_offset(base_offset), cipher(key_, Mode::CTR) {}
-      iv(16, 0) {}
 std::size_t CTREncryptionLayer::Read(u8* data, std::size_t length, std::size_t offset) const {
    if (length == 0)
@@ -39,9 +39,8 @@ std::size_t CTREncryptionLayer::Read(u8* data, std::size_t length, std::size_t o
    return read + Read(data + read, length - read, offset + read);
 }
-void CTREncryptionLayer::SetIV(const std::vector<u8>& iv_) {
+void CTREncryptionLayer::SetIV(const IVData& iv_) {
-    const auto length = std::min(iv_.size(), iv.size());
+    iv = iv_;
-    iv.assign(iv_.cbegin(), iv_.cbegin() + length);
 }
 void CTREncryptionLayer::UpdateIV(std::size_t offset) const {
diff --git a/src/core/crypto/ctr_encryption_layer.h b/src/core/crypto/ctr_encryption_layer.h
index a7bf810f4..a2429f001 100644
--- a/src/core/crypto/ctr_encryption_layer.h
+++ b/src/core/crypto/ctr_encryption_layer.h
@@ -4,7 +4,8 @@
 #pragma once
-#include <vector>
+#include <array>
 #include "core/crypto/aes_util.h"
 #include "core/crypto/encryption_layer.h"
 #include "core/crypto/key_manager.h"
@@ -14,18 +15,20 @@ namespace Core::Crypto {
 // Sits on top of a VirtualFile and provides CTR-mode AES decription.
 class CTREncryptionLayer : public EncryptionLayer {
 public:
+    using IVData = std::array<u8, 16>;
    CTREncryptionLayer(FileSys::VirtualFile base, Key128 key, std::size_t base_offset);
    std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override;
-    void SetIV(const std::vector<u8>& iv);
+    void SetIV(const IVData& iv);
 private:
    std::size_t base_offset;
    // Must be mutable as operations modify cipher contexts.
    mutable AESCipher<Key128> cipher;
-    mutable std::vector<u8> iv;
+    mutable IVData iv{};
    void UpdateIV(std::size_t offset) const;
 };
diff --git a/src/core/crypto/key_manager.cpp b/src/core/crypto/key_manager.cpp
index f87fe0abc..c09f7ad41 100644
--- a/src/core/crypto/key_manager.cpp
+++ b/src/core/crypto/key_manager.cpp
@@ -40,12 +40,14 @@ namespace Core::Crypto {
 constexpr u64 CURRENT_CRYPTO_REVISION = 0x5;
 constexpr u64 FULL_TICKET_SIZE = 0x400;
-using namespace Common;
+using Common::AsArray;
-const std::array<SHA256Hash, 2> eticket_source_hashes{
+// clang-format off
-    "B71DB271DC338DF380AA2C4335EF8873B1AFD408E80B3582D8719FC81C5E511C"_array32, // eticket_rsa_kek_source
+constexpr std::array eticket_source_hashes{
-    "E8965A187D30E57869F562D04383C996DE487BBA5761363D2D4D32391866A85C"_array32, // eticket_rsa_kekek_source
+    AsArray("B71DB271DC338DF380AA2C4335EF8873B1AFD408E80B3582D8719FC81C5E511C"), // eticket_rsa_kek_source
+    AsArray("E8965A187D30E57869F562D04383C996DE487BBA5761363D2D4D32391866A85C"), // eticket_rsa_kekek_source
 };
+// clang-format on
 const std::map<std::pair<S128KeyType, u64>, std::string> KEYS_VARIABLE_LENGTH{
    {{S128KeyType::Master, 0}, "master_key_"},
diff --git a/src/core/crypto/partition_data_manager.cpp b/src/core/crypto/partition_data_manager.cpp
index 7ed71ac3a..3e96f7516 100644
--- a/src/core/crypto/partition_data_manager.cpp
+++ b/src/core/crypto/partition_data_manager.cpp
@@ -27,7 +27,7 @@
 #include "core/file_sys/vfs_offset.h"
 #include "core/file_sys/vfs_vector.h"
-using namespace Common;
+using Common::AsArray;
 namespace Core::Crypto {
@@ -47,105 +47,123 @@ struct Package2Header {
 };
 static_assert(sizeof(Package2Header) == 0x200, "Package2Header has incorrect size.");
-const std::array<SHA256Hash, 0x10> source_hashes{
+// clang-format off
-    "B24BD293259DBC7AC5D63F88E60C59792498E6FC5443402C7FFE87EE8B61A3F0"_array32, // keyblob_mac_key_source
+constexpr std::array source_hashes{
-    "7944862A3A5C31C6720595EFD302245ABD1B54CCDCF33000557681E65C5664A4"_array32, // master_key_source
+    AsArray("B24BD293259DBC7AC5D63F88E60C59792498E6FC5443402C7FFE87EE8B61A3F0"), // keyblob_mac_key_source
-    "21E2DF100FC9E094DB51B47B9B1D6E94ED379DB8B547955BEF8FE08D8DD35603"_array32, // package2_key_source
+    AsArray("7944862A3A5C31C6720595EFD302245ABD1B54CCDCF33000557681E65C5664A4"), // master_key_source
-    "FC02B9D37B42D7A1452E71444F1F700311D1132E301A83B16062E72A78175085"_array32, // aes_kek_generation_source
+    AsArray("21E2DF100FC9E094DB51B47B9B1D6E94ED379DB8B547955BEF8FE08D8DD35603"), // package2_key_source
-    "FBD10056999EDC7ACDB96098E47E2C3606230270D23281E671F0F389FC5BC585"_array32, // aes_key_generation_source
+    AsArray("FC02B9D37B42D7A1452E71444F1F700311D1132E301A83B16062E72A78175085"), // aes_kek_generation_source
-    "C48B619827986C7F4E3081D59DB2B460C84312650E9A8E6B458E53E8CBCA4E87"_array32, // titlekek_source
+    AsArray("FBD10056999EDC7ACDB96098E47E2C3606230270D23281E671F0F389FC5BC585"), // aes_key_generation_source
-    "04AD66143C726B2A139FB6B21128B46F56C553B2B3887110304298D8D0092D9E"_array32, // key_area_key_application_source
+    AsArray("C48B619827986C7F4E3081D59DB2B460C84312650E9A8E6B458E53E8CBCA4E87"), // titlekek_source
-    "FD434000C8FF2B26F8E9A9D2D2C12F6BE5773CBB9DC86300E1BD99F8EA33A417"_array32, // key_area_key_ocean_source
+    AsArray("04AD66143C726B2A139FB6B21128B46F56C553B2B3887110304298D8D0092D9E"), // key_area_key_application_source
-    "1F17B1FD51AD1C2379B58F152CA4912EC2106441E51722F38700D5937A1162F7"_array32, // key_area_key_system_source
+    AsArray("FD434000C8FF2B26F8E9A9D2D2C12F6BE5773CBB9DC86300E1BD99F8EA33A417"), // key_area_key_ocean_source
-    "6B2ED877C2C52334AC51E59ABFA7EC457F4A7D01E46291E9F2EAA45F011D24B7"_array32, // sd_card_kek_source
+    AsArray("1F17B1FD51AD1C2379B58F152CA4912EC2106441E51722F38700D5937A1162F7"), // key_area_key_system_source
-    "D482743563D3EA5DCDC3B74E97C9AC8A342164FA041A1DC80F17F6D31E4BC01C"_array32, // sd_card_save_key_source
+    AsArray("6B2ED877C2C52334AC51E59ABFA7EC457F4A7D01E46291E9F2EAA45F011D24B7"), // sd_card_kek_source
-    "2E751CECF7D93A2B957BD5FFCB082FD038CC2853219DD3092C6DAB9838F5A7CC"_array32, // sd_card_nca_key_source
+    AsArray("D482743563D3EA5DCDC3B74E97C9AC8A342164FA041A1DC80F17F6D31E4BC01C"), // sd_card_save_key_source
-    "1888CAED5551B3EDE01499E87CE0D86827F80820EFB275921055AA4E2ABDFFC2"_array32, // header_kek_source
+    AsArray("2E751CECF7D93A2B957BD5FFCB082FD038CC2853219DD3092C6DAB9838F5A7CC"), // sd_card_nca_key_source
-    "8F783E46852DF6BE0BA4E19273C4ADBAEE16380043E1B8C418C4089A8BD64AA6"_array32, // header_key_source
+    AsArray("1888CAED5551B3EDE01499E87CE0D86827F80820EFB275921055AA4E2ABDFFC2"), // header_kek_source
-    "D1757E52F1AE55FA882EC690BC6F954AC46A83DC22F277F8806BD55577C6EED7"_array32, // rsa_kek_seed3
+    AsArray("8F783E46852DF6BE0BA4E19273C4ADBAEE16380043E1B8C418C4089A8BD64AA6"), // header_key_source
-    "FC02B9D37B42D7A1452E71444F1F700311D1132E301A83B16062E72A78175085"_array32, // rsa_kek_mask0
+    AsArray("D1757E52F1AE55FA882EC690BC6F954AC46A83DC22F277F8806BD55577C6EED7"), // rsa_kek_seed3
+    AsArray("FC02B9D37B42D7A1452E71444F1F700311D1132E301A83B16062E72A78175085"), // rsa_kek_mask0
 };
+// clang-format on
-const std::array<SHA256Hash, 0x20> keyblob_source_hashes{
-    "8A06FE274AC491436791FDB388BCDD3AB9943BD4DEF8094418CDAC150FD73786"_array32, // keyblob_key_source_00
+// clang-format off
-    "2D5CAEB2521FEF70B47E17D6D0F11F8CE2C1E442A979AD8035832C4E9FBCCC4B"_array32, // keyblob_key_source_01
+constexpr std::array keyblob_source_hashes{
-    "61C5005E713BAE780641683AF43E5F5C0E03671117F702F401282847D2FC6064"_array32, // keyblob_key_source_02
+    AsArray("8A06FE274AC491436791FDB388BCDD3AB9943BD4DEF8094418CDAC150FD73786"), // keyblob_key_source_00
-    "8E9795928E1C4428E1B78F0BE724D7294D6934689C11B190943923B9D5B85903"_array32, // keyblob_key_source_03
+    AsArray("2D5CAEB2521FEF70B47E17D6D0F11F8CE2C1E442A979AD8035832C4E9FBCCC4B"), // keyblob_key_source_01
-    "95FA33AF95AFF9D9B61D164655B32710ED8D615D46C7D6CC3CC70481B686B402"_array32, // keyblob_key_source_04
+    AsArray("61C5005E713BAE780641683AF43E5F5C0E03671117F702F401282847D2FC6064"), // keyblob_key_source_02
-    "3F5BE7B3C8B1ABD8C10B4B703D44766BA08730562C172A4FE0D6B866B3E2DB3E"_array32, // keyblob_key_source_05
+    AsArray("8E9795928E1C4428E1B78F0BE724D7294D6934689C11B190943923B9D5B85903"), // keyblob_key_source_03
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_06
+    AsArray("95FA33AF95AFF9D9B61D164655B32710ED8D615D46C7D6CC3CC70481B686B402"), // keyblob_key_source_04
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_07
+    AsArray("3F5BE7B3C8B1ABD8C10B4B703D44766BA08730562C172A4FE0D6B866B3E2DB3E"), // keyblob_key_source_05
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_06
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_08
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_07
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_09
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_0A
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_08
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_0B
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_09
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_0C
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0A
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_0D
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0B
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_0E
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0C
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_0F
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0D
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0E
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_10
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0F
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_11
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_12
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_10
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_13
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_11
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_14
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_12
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_15
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_13
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_16
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_14
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_17
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_15
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_16
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_18
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_17
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_19
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_1A
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_18
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_1B
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_19
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_1C
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1A
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_1D
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1B
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_1E
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1C
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_1F
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1D
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1E
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1F
 };
+// clang-format on
-const std::array<SHA256Hash, 0x20> master_key_hashes{
-    "0EE359BE3C864BB0782E1D70A718A0342C551EED28C369754F9C4F691BECF7CA"_array32, // master_key_00
+// clang-format off
-    "4FE707B7E4ABDAF727C894AAF13B1351BFE2AC90D875F73B2E20FA94B9CC661E"_array32, // master_key_01
+constexpr std::array master_key_hashes{
-    "79277C0237A2252EC3DFAC1F7C359C2B3D121E9DB15BB9AB4C2B4408D2F3AE09"_array32, // master_key_02
+    AsArray("0EE359BE3C864BB0782E1D70A718A0342C551EED28C369754F9C4F691BECF7CA"), // master_key_00
-    "4F36C565D13325F65EE134073C6A578FFCB0008E02D69400836844EAB7432754"_array32, // master_key_03
+    AsArray("4FE707B7E4ABDAF727C894AAF13B1351BFE2AC90D875F73B2E20FA94B9CC661E"), // master_key_01
-    "75FF1D95D26113550EE6FCC20ACB58E97EDEB3A2FF52543ED5AEC63BDCC3DA50"_array32, // master_key_04
+    AsArray("79277C0237A2252EC3DFAC1F7C359C2B3D121E9DB15BB9AB4C2B4408D2F3AE09"), // master_key_02
-    "EBE2BCD6704673EC0F88A187BB2AD9F1CC82B718C389425941BDC194DC46B0DD"_array32, // master_key_05
+    AsArray("4F36C565D13325F65EE134073C6A578FFCB0008E02D69400836844EAB7432754"), // master_key_03
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_06
+    AsArray("75FF1D95D26113550EE6FCC20ACB58E97EDEB3A2FF52543ED5AEC63BDCC3DA50"), // master_key_04
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_07
+    AsArray("EBE2BCD6704673EC0F88A187BB2AD9F1CC82B718C389425941BDC194DC46B0DD"), // master_key_05
+    AsArray("9497E6779F5D840F2BBA1DE4E95BA1D6F21EFC94717D5AE5CA37D7EC5BD37A19"), // master_key_06
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_08
+    AsArray("4EC96B8CB01B8DCE382149443430B2B6EBCB2983348AFA04A25E53609DABEDF6"), // master_key_07
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_09
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_0A
+    AsArray("2998E2E23609BC2675FF062A2D64AF5B1B78DFF463B24119D64A1B64F01B2D51"), // master_key_08
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_0B
+    AsArray("9D486A98067C44B37CF173D3BF577891EB6081FF6B4A166347D9DBBF7025076B"), // master_key_09
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_0C
+    AsArray("4EC5A237A75A083A9C5F6CF615601522A7F822D06BD4BA32612C9CEBBB29BD45"), // master_key_0A
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_0D
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0B
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_0E
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0C
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_0F
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0D
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0E
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_10
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0F
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_11
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_12
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_10
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_13
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_11
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_14
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_12
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_15
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_13
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_16
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_14
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_17
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_15
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_16
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_18
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_17
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_19
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1A
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_18
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1B
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_19
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1C
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1A
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1D
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1B
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1E
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1C
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1F
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1D
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1E
+    AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1F
 };
+// clang-format on
+static constexpr u8 CalculateMaxKeyblobSourceHash() {
+    const auto is_zero = [](const auto& data) {
+        // TODO: Replace with std::all_of whenever mingw decides to update their
+        //       libraries to include the constexpr variant of it.
+        for (const auto element : data) {
+            if (element != 0) {
+                return false;
+            }
+        }
+        return true;
+    };
-static u8 CalculateMaxKeyblobSourceHash() {
    for (s8 i = 0x1F; i >= 0; --i) {
-        if (keyblob_source_hashes[i] != SHA256Hash{})
+        if (!is_zero(keyblob_source_hashes[i])) {
            return static_cast<u8>(i + 1);
+        }
    }
    return 0;
@@ -346,10 +364,9 @@ FileSys::VirtualFile PartitionDataManager::GetPackage2Raw(Package2Type type) con
 }
 static bool AttemptDecrypt(const std::array<u8, 16>& key, Package2Header& header) {
-    const std::vector<u8> iv(header.header_ctr.begin(), header.header_ctr.end());
    Package2Header temp = header;
    AESCipher<Key128> cipher(key, Mode::CTR);
-    cipher.SetIV(iv);
+    cipher.SetIV(header.header_ctr);
    cipher.Transcode(&temp.header_ctr, sizeof(Package2Header) - 0x100, &temp.header_ctr,
                     Op::Decrypt);
    if (temp.magic == Common::MakeMagic('P', 'K', '2', '1')) {
@@ -388,7 +405,7 @@ void PartitionDataManager::DecryptPackage2(const std::array<Key128, 0x20>& packa
    auto c = a->ReadAllBytes();
    AESCipher<Key128> cipher(package2_keys[revision], Mode::CTR);
-    cipher.SetIV({header.section_ctr[1].begin(), header.section_ctr[1].end()});
+    cipher.SetIV(header.section_ctr[1]);
    cipher.Transcode(c.data(), c.size(), c.data(), Op::Decrypt);
    const auto ini_file = std::make_shared<FileSys::VectorVfsFile>(c);
diff --git a/src/core/device_memory.cpp b/src/core/device_memory.cpp
index 51097ced3..0c4b440ed 100644
--- a/src/core/device_memory.cpp
+++ b/src/core/device_memory.cpp
@@ -2,14 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-#include "core/core.h"
 #include "core/device_memory.h"
-#include "core/memory.h"
 namespace Core {
-DeviceMemory::DeviceMemory(System& system) : buffer{DramMemoryMap::Size}, system{system} {}
+DeviceMemory::DeviceMemory() : buffer{DramMemoryMap::Size} {}
 DeviceMemory::~DeviceMemory() = default;
 } // namespace Core
diff --git a/src/core/device_memory.h b/src/core/device_memory.h
index 9efa088d0..5b1ae28f3 100644
--- a/src/core/device_memory.h
+++ b/src/core/device_memory.h
@@ -4,14 +4,11 @@
 #pragma once
-#include "common/assert.h"
+#include "common/common_types.h"
-#include "common/common_funcs.h"
 #include "common/virtual_buffer.h"
 namespace Core {
-class System;
 namespace DramMemoryMap {
 enum : u64 {
    Base = 0x80000000ULL,
@@ -26,7 +23,7 @@ enum : u64 {
 class DeviceMemory : NonCopyable {
 public:
-    explicit DeviceMemory(Core::System& system);
+    explicit DeviceMemory();
    ~DeviceMemory();
    template <typename T>
@@ -45,7 +42,6 @@ public:
 private:
    Common::VirtualBuffer<u8> buffer;
-    Core::System& system;
 };
 } // namespace Core
diff --git a/src/core/file_sys/content_archive.cpp b/src/core/file_sys/content_archive.cpp
index 473245d5a..5039341c7 100644
--- a/src/core/file_sys/content_archive.cpp
+++ b/src/core/file_sys/content_archive.cpp
@@ -495,9 +495,10 @@ VirtualFile NCA::Decrypt(const NCASectionHeader& s_header, VirtualFile in, u64 s
            auto out = std::make_shared<Core::Crypto::CTREncryptionLayer>(std::move(in), *key,
                                                                          starting_offset);
-            std::vector<u8> iv(16);
+            Core::Crypto::CTREncryptionLayer::IVData iv{};
-            for (u8 i = 0; i < 8; ++i)
+            for (std::size_t i = 0; i < 8; ++i) {
-                iv[i] = s_header.raw.section_ctr[0x8 - i - 1];
+                iv[i] = s_header.raw.section_ctr[8 - i - 1];
+            }
            out->SetIV(iv);
            return std::static_pointer_cast<VfsFile>(out);
        }
diff --git a/src/core/file_sys/mode.h b/src/core/file_sys/mode.h
index c95205668..2b4f21073 100644
--- a/src/core/file_sys/mode.h
+++ b/src/core/file_sys/mode.h
@@ -4,6 +4,7 @@
 #pragma once
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 namespace FileSys {
@@ -11,13 +12,11 @@ namespace FileSys {
 enum class Mode : u32 {
    Read = 1,
    Write = 2,
-    ReadWrite = 3,
+    ReadWrite = Read | Write,
    Append = 4,
-    WriteAppend = 6,
+    WriteAppend = Write | Append,
 };
-inline u32 operator&(Mode lhs, Mode rhs) {
+DECLARE_ENUM_FLAG_OPERATORS(Mode)
-    return static_cast<u32>(lhs) & static_cast<u32>(rhs);
-}
 } // namespace FileSys
diff --git a/src/core/file_sys/nca_patch.cpp b/src/core/file_sys/nca_patch.cpp
index 0090cc6c4..fe7375e84 100644
--- a/src/core/file_sys/nca_patch.cpp
+++ b/src/core/file_sys/nca_patch.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 #include <algorithm>
+#include <array>
 #include <cstddef>
 #include <cstring>
@@ -66,7 +67,7 @@ std::size_t BKTR::Read(u8* data, std::size_t length, std::size_t offset) const {
    Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(key, Core::Crypto::Mode::CTR);
    // Calculate AES IV
-    std::vector<u8> iv(16);
+    std::array<u8, 16> iv{};
    auto subsection_ctr = subsection.ctr;
    auto offset_iv = section_offset + base_offset;
    for (std::size_t i = 0; i < section_ctr.size(); ++i)
diff --git a/src/core/file_sys/patch_manager.cpp b/src/core/file_sys/patch_manager.cpp
index c47ff863e..729dbb5f4 100644
--- a/src/core/file_sys/patch_manager.cpp
+++ b/src/core/file_sys/patch_manager.cpp
@@ -288,8 +288,8 @@ std::optional<std::vector<Core::Memory::CheatEntry>> ReadCheatFileFromFolder(
    }
    Core::Memory::TextCheatParser parser;
-    return parser.Parse(
+    return parser.Parse(system,
-        system, std::string_view(reinterpret_cast<const char* const>(data.data()), data.size()));
+                        std::string_view(reinterpret_cast<const char*>(data.data()), data.size()));
 }
 } // Anonymous namespace
diff --git a/src/core/file_sys/registered_cache.cpp b/src/core/file_sys/registered_cache.cpp
index 37351c561..f831487dd 100644
--- a/src/core/file_sys/registered_cache.cpp
+++ b/src/core/file_sys/registered_cache.cpp
@@ -344,15 +344,18 @@ VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
 static std::optional<NcaID> CheckMapForContentRecord(const std::map<u64, CNMT>& map, u64 title_id,
                                                     ContentRecordType type) {
-    if (map.find(title_id) == map.end())
+    const auto cmnt_iter = map.find(title_id);
-        return {};
+    if (cmnt_iter == map.cend()) {
+        return std::nullopt;
-    const auto& cnmt = map.at(title_id);
+    }
-    const auto iter = std::find_if(cnmt.GetContentRecords().begin(), cnmt.GetContentRecords().end(),
+    const auto& cnmt = cmnt_iter->second;
+    const auto& content_records = cnmt.GetContentRecords();
+    const auto iter = std::find_if(content_records.cbegin(), content_records.cend(),
                                   [type](const ContentRecord& rec) { return rec.type == type; });
-    if (iter == cnmt.GetContentRecords().end())
+    if (iter == content_records.cend()) {
-        return {};
+        return std::nullopt;
+    }
    return std::make_optional(iter->nca_id);
 }
@@ -467,14 +470,16 @@ VirtualFile RegisteredCache::GetEntryUnparsed(u64 title_id, ContentRecordType ty
 std::optional<u32> RegisteredCache::GetEntryVersion(u64 title_id) const {
    const auto meta_iter = meta.find(title_id);
-    if (meta_iter != meta.end())
+    if (meta_iter != meta.cend()) {
        return meta_iter->second.GetTitleVersion();
+    }
    const auto yuzu_meta_iter = yuzu_meta.find(title_id);
-    if (yuzu_meta_iter != yuzu_meta.end())
+    if (yuzu_meta_iter != yuzu_meta.cend()) {
        return yuzu_meta_iter->second.GetTitleVersion();
+    }
-    return {};
+    return std::nullopt;
 }
 VirtualFile RegisteredCache::GetEntryRaw(u64 title_id, ContentRecordType type) const {
@@ -547,56 +552,6 @@ InstallResult RegisteredCache::InstallEntry(const XCI& xci, bool overwrite_if_ex
    return InstallEntry(*xci.GetSecurePartitionNSP(), overwrite_if_exists, copy);
 }
-bool RegisteredCache::RemoveExistingEntry(u64 title_id) {
-    const auto delete_nca = [this](const NcaID& id) {
-        const auto path = GetRelativePathFromNcaID(id, false, true, false);
-        if (dir->GetFileRelative(path) == nullptr) {
-            return false;
-        }
-        Core::Crypto::SHA256Hash hash{};
-        mbedtls_sha256_ret(id.data(), id.size(), hash.data(), 0);
-        const auto dirname = fmt::format("000000{:02X}", hash[0]);
-        const auto dir2 = GetOrCreateDirectoryRelative(dir, dirname);
-        const auto res = dir2->DeleteFile(fmt::format("{}.nca", Common::HexToString(id, false)));
-        return res;
-    };
-    // If an entry exists in the registered cache, remove it
-    if (HasEntry(title_id, ContentRecordType::Meta)) {
-        LOG_INFO(Loader,
-                 "Previously installed entry (v{}) for title_id={:016X} detected! "
-                 "Attempting to remove...",
-                 GetEntryVersion(title_id).value_or(0), title_id);
-        // Get all the ncas associated with the current CNMT and delete them
-        const auto meta_old_id =
-            GetNcaIDFromMetadata(title_id, ContentRecordType::Meta).value_or(NcaID{});
-        const auto program_id =
-            GetNcaIDFromMetadata(title_id, ContentRecordType::Program).value_or(NcaID{});
-        const auto data_id =
-            GetNcaIDFromMetadata(title_id, ContentRecordType::Data).value_or(NcaID{});
-        const auto control_id =
-            GetNcaIDFromMetadata(title_id, ContentRecordType::Control).value_or(NcaID{});
-        const auto html_id =
-            GetNcaIDFromMetadata(title_id, ContentRecordType::HtmlDocument).value_or(NcaID{});
-        const auto legal_id =
-            GetNcaIDFromMetadata(title_id, ContentRecordType::LegalInformation).value_or(NcaID{});
-        delete_nca(meta_old_id);
-        delete_nca(program_id);
-        delete_nca(data_id);
-        delete_nca(control_id);
-        delete_nca(html_id);
-        delete_nca(legal_id);
-        return true;
-    }
-    return false;
-}
 InstallResult RegisteredCache::InstallEntry(const NSP& nsp, bool overwrite_if_exists,
                                            const VfsCopyFunction& copy) {
    const auto ncas = nsp.GetNCAsCollapsed();
@@ -692,6 +647,57 @@ InstallResult RegisteredCache::InstallEntry(const NCA& nca, TitleType type,
    return RawInstallNCA(nca, copy, overwrite_if_exists, c_rec.nca_id);
 }
+bool RegisteredCache::RemoveExistingEntry(u64 title_id) const {
+    const auto delete_nca = [this](const NcaID& id) {
+        const auto path = GetRelativePathFromNcaID(id, false, true, false);
+        const bool isFile = dir->GetFileRelative(path) != nullptr;
+        const bool isDir = dir->GetDirectoryRelative(path) != nullptr;
+        if (isFile) {
+            return dir->DeleteFile(path);
+        } else if (isDir) {
+            return dir->DeleteSubdirectoryRecursive(path);
+        }
+        return false;
+    };
+    // If an entry exists in the registered cache, remove it
+    if (HasEntry(title_id, ContentRecordType::Meta)) {
+        LOG_INFO(Loader,
+                 "Previously installed entry (v{}) for title_id={:016X} detected! "
+                 "Attempting to remove...",
+                 GetEntryVersion(title_id).value_or(0), title_id);
+        // Get all the ncas associated with the current CNMT and delete them
+        const auto meta_old_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::Meta).value_or(NcaID{});
+        const auto program_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::Program).value_or(NcaID{});
+        const auto data_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::Data).value_or(NcaID{});
+        const auto control_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::Control).value_or(NcaID{});
+        const auto html_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::HtmlDocument).value_or(NcaID{});
+        const auto legal_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::LegalInformation).value_or(NcaID{});
+        const auto deleted_meta = delete_nca(meta_old_id);
+        const auto deleted_program = delete_nca(program_id);
+        const auto deleted_data = delete_nca(data_id);
+        const auto deleted_control = delete_nca(control_id);
+        const auto deleted_html = delete_nca(html_id);
+        const auto deleted_legal = delete_nca(legal_id);
+        return deleted_meta && (deleted_meta || deleted_program || deleted_data ||
+                                deleted_control || deleted_html || deleted_legal);
+    }
+    return false;
+}
 InstallResult RegisteredCache::RawInstallNCA(const NCA& nca, const VfsCopyFunction& copy,
                                             bool overwrite_if_exists,
                                             std::optional<NcaID> override_id) {
diff --git a/src/core/file_sys/registered_cache.h b/src/core/file_sys/registered_cache.h
index 29cf0d40c..5b414b0f0 100644
--- a/src/core/file_sys/registered_cache.h
+++ b/src/core/file_sys/registered_cache.h
@@ -133,9 +133,9 @@ public:
    // Parsing function defines the conversion from raw file to NCA. If there are other steps
    // besides creating the NCA from the file (e.g. NAX0 on SD Card), that should go in a custom
    // parsing function.
-    explicit RegisteredCache(VirtualDir dir,
+    explicit RegisteredCache(
-                             ContentProviderParsingFunction parsing_function =
+        VirtualDir dir, ContentProviderParsingFunction parsing_function =
-                                 [](const VirtualFile& file, const NcaID& id) { return file; });
+                            [](const VirtualFile& file, const NcaID& id) { return file; });
    ~RegisteredCache() override;
    void Refresh() override;
@@ -155,9 +155,6 @@ public:
        std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
        std::optional<u64> title_id = {}) const override;
-    // Removes an existing entry based on title id
-    bool RemoveExistingEntry(u64 title_id);
    // Raw copies all the ncas from the xci/nsp to the csache. Does some quick checks to make sure
    // there is a meta NCA and all of them are accessible.
    InstallResult InstallEntry(const XCI& xci, bool overwrite_if_exists = false,
@@ -172,6 +169,9 @@ public:
    InstallResult InstallEntry(const NCA& nca, TitleType type, bool overwrite_if_exists = false,
                               const VfsCopyFunction& copy = &VfsRawCopy);
+    // Removes an existing entry based on title id
+    bool RemoveExistingEntry(u64 title_id) const;
 private:
    template <typename T>
    void IterateAllMetadata(std::vector<T>& out,
diff --git a/src/core/file_sys/savedata_factory.cpp b/src/core/file_sys/savedata_factory.cpp
index adfd2c1a4..ba4efee3a 100644
--- a/src/core/file_sys/savedata_factory.cpp
+++ b/src/core/file_sys/savedata_factory.cpp
@@ -17,23 +17,23 @@ constexpr char SAVE_DATA_SIZE_FILENAME[] = ".yuzu_save_size";
 namespace {
-void PrintSaveDataDescriptorWarnings(SaveDataDescriptor meta) {
+void PrintSaveDataAttributeWarnings(SaveDataAttribute meta) {
    if (meta.type == SaveDataType::SystemSaveData || meta.type == SaveDataType::SaveData) {
        if (meta.zero_1 != 0) {
            LOG_WARNING(Service_FS,
-                        "Possibly incorrect SaveDataDescriptor, type is "
+                        "Possibly incorrect SaveDataAttribute, type is "
                        "SystemSaveData||SaveData but offset 0x28 is non-zero ({:016X}).",
                        meta.zero_1);
        }
        if (meta.zero_2 != 0) {
            LOG_WARNING(Service_FS,
-                        "Possibly incorrect SaveDataDescriptor, type is "
+                        "Possibly incorrect SaveDataAttribute, type is "
                        "SystemSaveData||SaveData but offset 0x30 is non-zero ({:016X}).",
                        meta.zero_2);
        }
        if (meta.zero_3 != 0) {
            LOG_WARNING(Service_FS,
-                        "Possibly incorrect SaveDataDescriptor, type is "
+                        "Possibly incorrect SaveDataAttribute, type is "
                        "SystemSaveData||SaveData but offset 0x38 is non-zero ({:016X}).",
                        meta.zero_3);
        }
@@ -41,33 +41,32 @@ void PrintSaveDataDescriptorWarnings(SaveDataDescriptor meta) {
    if (meta.type == SaveDataType::SystemSaveData && meta.title_id != 0) {
        LOG_WARNING(Service_FS,
-                    "Possibly incorrect SaveDataDescriptor, type is SystemSaveData but title_id is "
+                    "Possibly incorrect SaveDataAttribute, type is SystemSaveData but title_id is "
                    "non-zero ({:016X}).",
                    meta.title_id);
    }
    if (meta.type == SaveDataType::DeviceSaveData && meta.user_id != u128{0, 0}) {
        LOG_WARNING(Service_FS,
-                    "Possibly incorrect SaveDataDescriptor, type is DeviceSaveData but user_id is "
+                    "Possibly incorrect SaveDataAttribute, type is DeviceSaveData but user_id is "
                    "non-zero ({:016X}{:016X})",
                    meta.user_id[1], meta.user_id[0]);
    }
 }
-bool ShouldSaveDataBeAutomaticallyCreated(SaveDataSpaceId space, const SaveDataDescriptor& desc) {
+bool ShouldSaveDataBeAutomaticallyCreated(SaveDataSpaceId space, const SaveDataAttribute& attr) {
-    return desc.type == SaveDataType::CacheStorage || desc.type == SaveDataType::TemporaryStorage ||
+    return attr.type == SaveDataType::CacheStorage || attr.type == SaveDataType::TemporaryStorage ||
           (space == SaveDataSpaceId::NandUser && ///< Normal Save Data -- Current Title & User
-            (desc.type == SaveDataType::SaveData || desc.type == SaveDataType::DeviceSaveData) &&
+            (attr.type == SaveDataType::SaveData || attr.type == SaveDataType::DeviceSaveData) &&
-            desc.title_id == 0 && desc.save_id == 0);
+            attr.title_id == 0 && attr.save_id == 0);
 }
 } // Anonymous namespace
-std::string SaveDataDescriptor::DebugInfo() const {
+std::string SaveDataAttribute::DebugInfo() const {
-    return fmt::format("[type={:02X}, title_id={:016X}, user_id={:016X}{:016X}, "
+    return fmt::format("[title_id={:016X}, user_id={:016X}{:016X}, save_id={:016X}, type={:02X}, "
-                       "save_id={:016X}, "
                       "rank={}, index={}]",
-                       static_cast<u8>(type), title_id, user_id[1], user_id[0], save_id,
+                       title_id, user_id[1], user_id[0], save_id, static_cast<u8>(type),
                       static_cast<u8>(rank), index);
 }
@@ -80,8 +79,8 @@ SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save
 SaveDataFactory::~SaveDataFactory() = default;
 ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
-                                              const SaveDataDescriptor& meta) const {
+                                              const SaveDataAttribute& meta) const {
-    PrintSaveDataDescriptorWarnings(meta);
+    PrintSaveDataAttributeWarnings(meta);
    const auto save_directory =
        GetFullPath(space, meta.type, meta.title_id, meta.user_id, meta.save_id);
@@ -98,7 +97,7 @@ ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
 }
 ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
-                                            const SaveDataDescriptor& meta) const {
+                                            const SaveDataAttribute& meta) const {
    const auto save_directory =
        GetFullPath(space, meta.type, meta.title_id, meta.user_id, meta.save_id);
diff --git a/src/core/file_sys/savedata_factory.h b/src/core/file_sys/savedata_factory.h
index 991e57aa1..6625bbbd8 100644
--- a/src/core/file_sys/savedata_factory.h
+++ b/src/core/file_sys/savedata_factory.h
@@ -21,6 +21,7 @@ enum class SaveDataSpaceId : u8 {
    TemporaryStorage = 3,
    SdCardUser = 4,
    ProperSystem = 100,
+    SafeMode = 101,
 };
 enum class SaveDataType : u8 {
@@ -30,28 +31,50 @@ enum class SaveDataType : u8 {
    DeviceSaveData = 3,
    TemporaryStorage = 4,
    CacheStorage = 5,
+    SystemBcat = 6,
 };
 enum class SaveDataRank : u8 {
-    Primary,
+    Primary = 0,
-    Secondary,
+    Secondary = 1,
 };
-struct SaveDataDescriptor {
+enum class SaveDataFlags : u32 {
-    u64_le title_id;
+    None = (0 << 0),
+    KeepAfterResettingSystemSaveData = (1 << 0),
+    KeepAfterRefurbishment = (1 << 1),
+    KeepAfterResettingSystemSaveDataWithoutUserSaveData = (1 << 2),
+    NeedsSecureDelete = (1 << 3),
+};
+struct SaveDataAttribute {
+    u64 title_id;
    u128 user_id;
-    u64_le save_id;
+    u64 save_id;
    SaveDataType type;
    SaveDataRank rank;
-    u16_le index;
+    u16 index;
    INSERT_PADDING_BYTES(4);
-    u64_le zero_1;
+    u64 zero_1;
-    u64_le zero_2;
+    u64 zero_2;
-    u64_le zero_3;
+    u64 zero_3;
    std::string DebugInfo() const;
 };
-static_assert(sizeof(SaveDataDescriptor) == 0x40, "SaveDataDescriptor has incorrect size.");
+static_assert(sizeof(SaveDataAttribute) == 0x40, "SaveDataAttribute has incorrect size.");
+struct SaveDataExtraData {
+    SaveDataAttribute attr;
+    u64 owner_id;
+    s64 timestamp;
+    SaveDataFlags flags;
+    INSERT_PADDING_BYTES(4);
+    s64 available_size;
+    s64 journal_size;
+    s64 commit_id;
+    std::array<u8, 0x190> unused;
+};
+static_assert(sizeof(SaveDataExtraData) == 0x200, "SaveDataExtraData has incorrect size.");
 struct SaveDataSize {
    u64 normal;
@@ -64,8 +87,8 @@ public:
    explicit SaveDataFactory(VirtualDir dir);
    ~SaveDataFactory();
-    ResultVal<VirtualDir> Create(SaveDataSpaceId space, const SaveDataDescriptor& meta) const;
+    ResultVal<VirtualDir> Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const;
-    ResultVal<VirtualDir> Open(SaveDataSpaceId space, const SaveDataDescriptor& meta) const;
+    ResultVal<VirtualDir> Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const;
    VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const;
diff --git a/src/core/file_sys/system_archive/mii_model.cpp b/src/core/file_sys/system_archive/mii_model.cpp
index 61bb67945..d65c7d234 100644
--- a/src/core/file_sys/system_archive/mii_model.cpp
+++ b/src/core/file_sys/system_archive/mii_model.cpp
@@ -27,18 +27,12 @@ VirtualDir MiiModel() {
    auto out = std::make_shared<VectorVfsDirectory>(std::vector<VirtualFile>{},
                                                    std::vector<VirtualDir>{}, "data");
-    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::TEXTURE_LOW_LINEAR.size()>>(
+    out->AddFile(MakeArrayFile(MiiModelData::TEXTURE_LOW_LINEAR, "NXTextureLowLinear.dat"));
-        MiiModelData::TEXTURE_LOW_LINEAR, "NXTextureLowLinear.dat"));
+    out->AddFile(MakeArrayFile(MiiModelData::TEXTURE_LOW_SRGB, "NXTextureLowSRGB.dat"));
-    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::TEXTURE_LOW_SRGB.size()>>(
+    out->AddFile(MakeArrayFile(MiiModelData::TEXTURE_MID_LINEAR, "NXTextureMidLinear.dat"));
-        MiiModelData::TEXTURE_LOW_SRGB, "NXTextureLowSRGB.dat"));
+    out->AddFile(MakeArrayFile(MiiModelData::TEXTURE_MID_SRGB, "NXTextureMidSRGB.dat"));
-    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::TEXTURE_MID_LINEAR.size()>>(
+    out->AddFile(MakeArrayFile(MiiModelData::SHAPE_HIGH, "ShapeHigh.dat"));
-        MiiModelData::TEXTURE_MID_LINEAR, "NXTextureMidLinear.dat"));
+    out->AddFile(MakeArrayFile(MiiModelData::SHAPE_MID, "ShapeMid.dat"));
-    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::TEXTURE_MID_SRGB.size()>>(
-        MiiModelData::TEXTURE_MID_SRGB, "NXTextureMidSRGB.dat"));
-    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::SHAPE_HIGH.size()>>(
-        MiiModelData::SHAPE_HIGH, "ShapeHigh.dat"));
-    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::SHAPE_MID.size()>>(
-        MiiModelData::SHAPE_MID, "ShapeMid.dat"));
    return out;
 }
diff --git a/src/core/file_sys/system_archive/ng_word.cpp b/src/core/file_sys/system_archive/ng_word.cpp
index f4443784d..100d3c5db 100644
--- a/src/core/file_sys/system_archive/ng_word.cpp
+++ b/src/core/file_sys/system_archive/ng_word.cpp
@@ -24,19 +24,18 @@ constexpr std::array<u8, 30> WORD_TXT{
 } // namespace NgWord1Data
 VirtualDir NgWord1() {
-    std::vector<VirtualFile> files(NgWord1Data::NUMBER_WORD_TXT_FILES);
+    std::vector<VirtualFile> files;
+    files.reserve(NgWord1Data::NUMBER_WORD_TXT_FILES);
    for (std::size_t i = 0; i < files.size(); ++i) {
-        files[i] = std::make_shared<ArrayVfsFile<NgWord1Data::WORD_TXT.size()>>(
+        files.push_back(MakeArrayFile(NgWord1Data::WORD_TXT, fmt::format("{}.txt", i)));
-            NgWord1Data::WORD_TXT, fmt::format("{}.txt", i));
    }
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord1Data::WORD_TXT.size()>>(
+    files.push_back(MakeArrayFile(NgWord1Data::WORD_TXT, "common.txt"));
-        NgWord1Data::WORD_TXT, "common.txt"));
+    files.push_back(MakeArrayFile(NgWord1Data::VERSION_DAT, "version.dat"));
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord1Data::VERSION_DAT.size()>>(
-        NgWord1Data::VERSION_DAT, "version.dat"));
-    return std::make_shared<VectorVfsDirectory>(files, std::vector<VirtualDir>{}, "data");
+    return std::make_shared<VectorVfsDirectory>(std::move(files), std::vector<VirtualDir>{},
+                                                "data");
 }
 namespace NgWord2Data {
@@ -55,27 +54,22 @@ constexpr std::array<u8, 0x2C> AC_NX_DATA{
 } // namespace NgWord2Data
 VirtualDir NgWord2() {
-    std::vector<VirtualFile> files(NgWord2Data::NUMBER_AC_NX_FILES * 3);
+    std::vector<VirtualFile> files;
+    files.reserve(NgWord2Data::NUMBER_AC_NX_FILES * 3);
    for (std::size_t i = 0; i < NgWord2Data::NUMBER_AC_NX_FILES; ++i) {
-        files[3 * i] = std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
+        files.push_back(MakeArrayFile(NgWord2Data::AC_NX_DATA, fmt::format("ac_{}_b1_nx", i)));
-            NgWord2Data::AC_NX_DATA, fmt::format("ac_{}_b1_nx", i));
+        files.push_back(MakeArrayFile(NgWord2Data::AC_NX_DATA, fmt::format("ac_{}_b2_nx", i)));
-        files[3 * i + 1] = std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
+        files.push_back(MakeArrayFile(NgWord2Data::AC_NX_DATA, fmt::format("ac_{}_not_b_nx", i)));
-            NgWord2Data::AC_NX_DATA, fmt::format("ac_{}_b2_nx", i));
-        files[3 * i + 2] = std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-            NgWord2Data::AC_NX_DATA, fmt::format("ac_{}_not_b_nx", i));
    }
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
+    files.push_back(MakeArrayFile(NgWord2Data::AC_NX_DATA, "ac_common_b1_nx"));
-        NgWord2Data::AC_NX_DATA, "ac_common_b1_nx"));
+    files.push_back(MakeArrayFile(NgWord2Data::AC_NX_DATA, "ac_common_b2_nx"));
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
+    files.push_back(MakeArrayFile(NgWord2Data::AC_NX_DATA, "ac_common_not_b_nx"));
-        NgWord2Data::AC_NX_DATA, "ac_common_b2_nx"));
+    files.push_back(MakeArrayFile(NgWord2Data::VERSION_DAT, "version.dat"));
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-        NgWord2Data::AC_NX_DATA, "ac_common_not_b_nx"));
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord2Data::VERSION_DAT.size()>>(
-        NgWord2Data::VERSION_DAT, "version.dat"));
-    return std::make_shared<VectorVfsDirectory>(files, std::vector<VirtualDir>{}, "data");
+    return std::make_shared<VectorVfsDirectory>(std::move(files), std::vector<VirtualDir>{},
+                                                "data");
 }
 } // namespace FileSys::SystemArchive
diff --git a/src/core/file_sys/system_archive/time_zone_binary.cpp b/src/core/file_sys/system_archive/time_zone_binary.cpp
index 9806bd197..8fd005012 100644
--- a/src/core/file_sys/system_archive/time_zone_binary.cpp
+++ b/src/core/file_sys/system_archive/time_zone_binary.cpp
@@ -2,6 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include <array>
+#include <vector>
 #include "common/swap.h"
 #include "core/file_sys/system_archive/time_zone_binary.h"
 #include "core/file_sys/vfs_vector.h"
@@ -615,43 +618,49 @@ static constexpr std::array<u8, 9633> LOCATION_NAMES{
    0x0a};
 static VirtualFile GenerateDefaultTimeZoneFile() {
-    struct {
+    struct TimeZoneInfo {
        s64_be at;
-        INSERT_PADDING_BYTES(7);
+        std::array<u8, 7> padding1;
        std::array<char, 4> time_zone_chars;
-        INSERT_PADDING_BYTES(2);
+        std::array<u8, 2> padding2;
        std::array<char, 6> time_zone_name;
-    } time_zone_info{};
+    };
-    const VirtualFile file{std::make_shared<VectorVfsFile>(
+    VirtualFile file{std::make_shared<VectorVfsFile>(
-        std::vector<u8>(sizeof(Service::Time::TimeZone::TzifHeader) + sizeof(time_zone_info)),
+        std::vector<u8>(sizeof(Service::Time::TimeZone::TzifHeader) + sizeof(TimeZoneInfo)),
        "GMT")};
-    Service::Time::TimeZone::TzifHeader header{};
+    const Service::Time::TimeZone::TzifHeader header{
-    header.magic = 0x545a6966;
+        .magic = 0x545a6966,
-    header.version = 0x32;
+        .version = 0x32,
-    header.ttis_gmt_count = 0x1;
+        .ttis_gmt_count = 1,
-    header.ttis_std_count = 0x1;
+        .ttis_std_count = 1,
-    header.time_count = 0x1;
+        .time_count = 1,
-    header.type_count = 0x1;
+        .type_count = 1,
-    header.char_count = 0x4;
+        .char_count = 4,
+    };
    file->WriteObject(header, 0);
-    time_zone_info.at = 0xf8;
+    const TimeZoneInfo time_zone_info{
-    time_zone_info.time_zone_chars = {'G', 'M', 'T', '\0'};
+        .at = 0xf8,
-    time_zone_info.time_zone_name = {'\n', 'G', 'M', 'T', '0', '\n'};
+        .padding1 = {},
+        .time_zone_chars = {'G', 'M', 'T', '\0'},
+        .padding2 = {},
+        .time_zone_name = {'\n', 'G', 'M', 'T', '0', '\n'},
+    };
    file->WriteObject(time_zone_info, sizeof(Service::Time::TimeZone::TzifHeader));
    return file;
 }
 VirtualDir TimeZoneBinary() {
-    const std::vector<VirtualDir> root_dirs{std::make_shared<VectorVfsDirectory>(
+    std::vector<VirtualDir> root_dirs{std::make_shared<VectorVfsDirectory>(
        std::vector<VirtualFile>{GenerateDefaultTimeZoneFile()}, std::vector<VirtualDir>{},
        "zoneinfo")};
-    const std::vector<VirtualFile> root_files{
+    std::vector<VirtualFile> root_files{MakeArrayFile(LOCATION_NAMES, "binaryList.txt")};
-        std::make_shared<ArrayVfsFile<LOCATION_NAMES.size()>>(LOCATION_NAMES, "binaryList.txt")};
-    return std::make_shared<VectorVfsDirectory>(root_files, root_dirs, "data");
+    return std::make_shared<VectorVfsDirectory>(std::move(root_files), std::move(root_dirs),
+                                                "data");
 }
 } // namespace FileSys::SystemArchive
diff --git a/src/core/file_sys/vfs_real.cpp b/src/core/file_sys/vfs_real.cpp
index 96ce5957c..0db0091f6 100644
--- a/src/core/file_sys/vfs_real.cpp
+++ b/src/core/file_sys/vfs_real.cpp
@@ -18,20 +18,22 @@ static std::string ModeFlagsToString(Mode mode) {
    std::string mode_str;
    // Calculate the correct open mode for the file.
-    if (mode & Mode::Read && mode & Mode::Write) {
+    if (True(mode & Mode::Read) && True(mode & Mode::Write)) {
-        if (mode & Mode::Append)
+        if (True(mode & Mode::Append)) {
            mode_str = "a+";
-        else
+        } else {
            mode_str = "r+";
+        }
    } else {
-        if (mode & Mode::Read)
+        if (True(mode & Mode::Read)) {
            mode_str = "r";
-        else if (mode & Mode::Append)
+        } else if (True(mode & Mode::Append)) {
            mode_str = "a";
-        else if (mode & Mode::Write)
+        } else if (True(mode & Mode::Write)) {
            mode_str = "w";
-        else
+        } else {
            UNREACHABLE_MSG("Invalid file open mode: {:02X}", static_cast<u8>(mode));
+        }
    }
    mode_str += "b";
@@ -73,8 +75,9 @@ VirtualFile RealVfsFilesystem::OpenFile(std::string_view path_, Mode perms) {
        }
    }
-    if (!FileUtil::Exists(path) && (perms & Mode::WriteAppend) != 0)
+    if (!FileUtil::Exists(path) && True(perms & Mode::WriteAppend)) {
        FileUtil::CreateEmptyFile(path);
+    }
    auto backing = std::make_shared<FileUtil::IOFile>(path, ModeFlagsToString(perms).c_str());
    cache[path] = backing;
@@ -247,11 +250,11 @@ std::shared_ptr<VfsDirectory> RealVfsFile::GetContainingDirectory() const {
 }
 bool RealVfsFile::IsWritable() const {
-    return (perms & Mode::WriteAppend) != 0;
+    return True(perms & Mode::WriteAppend);
 }
 bool RealVfsFile::IsReadable() const {
-    return (perms & Mode::ReadWrite) != 0;
+    return True(perms & Mode::ReadWrite);
 }
 std::size_t RealVfsFile::Read(u8* data, std::size_t length, std::size_t offset) const {
@@ -319,8 +322,9 @@ RealVfsDirectory::RealVfsDirectory(RealVfsFilesystem& base_, const std::string&
      path_components(FileUtil::SplitPathComponents(path)),
      parent_components(FileUtil::SliceVector(path_components, 0, path_components.size() - 1)),
      perms(perms_) {
-    if (!FileUtil::Exists(path) && perms & Mode::WriteAppend)
+    if (!FileUtil::Exists(path) && True(perms & Mode::WriteAppend)) {
        FileUtil::CreateDir(path);
+    }
 }
 RealVfsDirectory::~RealVfsDirectory() = default;
@@ -371,11 +375,11 @@ std::vector<std::shared_ptr<VfsDirectory>> RealVfsDirectory::GetSubdirectories()
 }
 bool RealVfsDirectory::IsWritable() const {
-    return (perms & Mode::WriteAppend) != 0;
+    return True(perms & Mode::WriteAppend);
 }
 bool RealVfsDirectory::IsReadable() const {
-    return (perms & Mode::ReadWrite) != 0;
+    return True(perms & Mode::ReadWrite);
 }
 std::string RealVfsDirectory::GetName() const {
diff --git a/src/core/file_sys/vfs_vector.h b/src/core/file_sys/vfs_vector.h
index ac36cb2ee..95d3da2f2 100644
--- a/src/core/file_sys/vfs_vector.h
+++ b/src/core/file_sys/vfs_vector.h
@@ -4,7 +4,11 @@
 #pragma once
+#include <array>
 #include <cstring>
+#include <memory>
+#include <string>
+#include <vector>
 #include "core/file_sys/vfs.h"
 namespace FileSys {
@@ -13,7 +17,8 @@ namespace FileSys {
 template <std::size_t size>
 class ArrayVfsFile : public VfsFile {
 public:
-    ArrayVfsFile(std::array<u8, size> data, std::string name = "", VirtualDir parent = nullptr)
+    explicit ArrayVfsFile(const std::array<u8, size>& data, std::string name = "",
+                          VirtualDir parent = nullptr)
        : data(data), name(std::move(name)), parent(std::move(parent)) {}
    std::string GetName() const override {
@@ -61,6 +66,12 @@ private:
    VirtualDir parent;
 };
+template <std::size_t Size, typename... Args>
+std::shared_ptr<ArrayVfsFile<Size>> MakeArrayFile(const std::array<u8, Size>& data,
+                                                  Args&&... args) {
+    return std::make_shared<ArrayVfsFile<Size>>(data, std::forward<Args>(args)...);
+}
 // An implementation of VfsFile that is backed by a vector optionally supplied upon construction
 class VectorVfsFile : public VfsFile {
 public:
diff --git a/src/core/file_sys/xts_archive.cpp b/src/core/file_sys/xts_archive.cpp
index 86e06ccb9..81413c684 100644
--- a/src/core/file_sys/xts_archive.cpp
+++ b/src/core/file_sys/xts_archive.cpp
@@ -70,14 +70,18 @@ NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
 NAX::~NAX() = default;
 Loader::ResultStatus NAX::Parse(std::string_view path) {
-    if (file->ReadObject(header.get()) != sizeof(NAXHeader))
+    if (file == nullptr) {
+        return Loader::ResultStatus::ErrorNullFile;
+    }
+    if (file->ReadObject(header.get()) != sizeof(NAXHeader)) {
        return Loader::ResultStatus::ErrorBadNAXHeader;
+    }
-    if (header->magic != Common::MakeMagic('N', 'A', 'X', '0'))
+    if (header->magic != Common::MakeMagic('N', 'A', 'X', '0')) {
        return Loader::ResultStatus::ErrorBadNAXHeader;
+    }
-    if (file->GetSize() < NAX_HEADER_PADDING_SIZE + header->file_size)
+    if (file->GetSize() < NAX_HEADER_PADDING_SIZE + header->file_size) {
        return Loader::ResultStatus::ErrorIncorrectNAXFileSize;
+    }
    keys.DeriveSDSeedLazy();
    std::array<Core::Crypto::Key256, 2> sd_keys{};
diff --git a/src/core/hardware_interrupt_manager.cpp b/src/core/hardware_interrupt_manager.cpp
index efc1030c1..645f26e91 100644
--- a/src/core/hardware_interrupt_manager.cpp
+++ b/src/core/hardware_interrupt_manager.cpp
@@ -11,8 +11,8 @@
 namespace Core::Hardware {
 InterruptManager::InterruptManager(Core::System& system_in) : system(system_in) {
-    gpu_interrupt_event =
+    gpu_interrupt_event = Core::Timing::CreateEvent(
-        Core::Timing::CreateEvent("GPUInterrupt", [this](u64 message, std::chrono::nanoseconds) {
+        "GPUInterrupt", [this](std::uintptr_t message, std::chrono::nanoseconds) {
            auto nvdrv = system.ServiceManager().GetService<Service::Nvidia::NVDRV>("nvdrv");
            const u32 syncpt = static_cast<u32>(message >> 32);
            const u32 value = static_cast<u32>(message);
diff --git a/src/core/hle/ipc_helpers.h b/src/core/hle/ipc_helpers.h
index 0dc6a4a43..1b503331f 100644
--- a/src/core/hle/ipc_helpers.h
+++ b/src/core/hle/ipc_helpers.h
@@ -229,6 +229,8 @@ inline void ResponseBuilder::Push(u32 value) {
 template <typename T>
 void ResponseBuilder::PushRaw(const T& value) {
+    static_assert(std::is_trivially_copyable_v<T>,
+                  "It's undefined behavior to use memcpy with non-trivially copyable objects");
    std::memcpy(cmdbuf + index, &value, sizeof(T));
    index += (sizeof(T) + 3) / 4; // round up to word length
 }
@@ -384,6 +386,8 @@ inline s32 RequestParser::Pop() {
 template <typename T>
 void RequestParser::PopRaw(T& value) {
+    static_assert(std::is_trivially_copyable_v<T>,
+                  "It's undefined behavior to use memcpy with non-trivially copyable objects");
    std::memcpy(&value, cmdbuf + index, sizeof(T));
    index += (sizeof(T) + 3) / 4; // round up to word length
 }
diff --git a/src/core/hle/kernel/address_arbiter.cpp b/src/core/hle/kernel/address_arbiter.cpp
index df0debe1b..b882eaa0f 100644
--- a/src/core/hle/kernel/address_arbiter.cpp
+++ b/src/core/hle/kernel/address_arbiter.cpp
@@ -81,7 +81,7 @@ ResultCode AddressArbiter::IncrementAndSignalToAddressIfEqual(VAddr address, s32
    do {
        current_value = monitor.ExclusiveRead32(current_core, address);
-        if (current_value != value) {
+        if (current_value != static_cast<u32>(value)) {
            return ERR_INVALID_STATE;
        }
        current_value++;
diff --git a/src/core/hle/kernel/hle_ipc.cpp b/src/core/hle/kernel/hle_ipc.cpp
index 9277b5d08..81f85643b 100644
--- a/src/core/hle/kernel/hle_ipc.cpp
+++ b/src/core/hle/kernel/hle_ipc.cpp
@@ -293,13 +293,15 @@ std::vector<u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) const {
                           BufferDescriptorA()[buffer_index].Size()};
    if (is_buffer_a) {
-        ASSERT_OR_EXECUTE_MSG(BufferDescriptorA().size() > buffer_index, { return buffer; },
+        ASSERT_OR_EXECUTE_MSG(
-                              "BufferDescriptorA invalid buffer_index {}", buffer_index);
+            BufferDescriptorA().size() > buffer_index, { return buffer; },
+            "BufferDescriptorA invalid buffer_index {}", buffer_index);
        buffer.resize(BufferDescriptorA()[buffer_index].Size());
        memory.ReadBlock(BufferDescriptorA()[buffer_index].Address(), buffer.data(), buffer.size());
    } else {
-        ASSERT_OR_EXECUTE_MSG(BufferDescriptorX().size() > buffer_index, { return buffer; },
+        ASSERT_OR_EXECUTE_MSG(
-                              "BufferDescriptorX invalid buffer_index {}", buffer_index);
+            BufferDescriptorX().size() > buffer_index, { return buffer; },
+            "BufferDescriptorX invalid buffer_index {}", buffer_index);
        buffer.resize(BufferDescriptorX()[buffer_index].Size());
        memory.ReadBlock(BufferDescriptorX()[buffer_index].Address(), buffer.data(), buffer.size());
    }
@@ -324,16 +326,16 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
    }
    if (is_buffer_b) {
-        ASSERT_OR_EXECUTE_MSG(BufferDescriptorB().size() > buffer_index &&
+        ASSERT_OR_EXECUTE_MSG(
-                                  BufferDescriptorB()[buffer_index].Size() >= size,
+            BufferDescriptorB().size() > buffer_index &&
-                              { return 0; }, "BufferDescriptorB is invalid, index={}, size={}",
+                BufferDescriptorB()[buffer_index].Size() >= size,
-                              buffer_index, size);
+            { return 0; }, "BufferDescriptorB is invalid, index={}, size={}", buffer_index, size);
        memory.WriteBlock(BufferDescriptorB()[buffer_index].Address(), buffer, size);
    } else {
-        ASSERT_OR_EXECUTE_MSG(BufferDescriptorC().size() > buffer_index &&
+        ASSERT_OR_EXECUTE_MSG(
-                                  BufferDescriptorC()[buffer_index].Size() >= size,
+            BufferDescriptorC().size() > buffer_index &&
-                              { return 0; }, "BufferDescriptorC is invalid, index={}, size={}",
+                BufferDescriptorC()[buffer_index].Size() >= size,
-                              buffer_index, size);
+            { return 0; }, "BufferDescriptorC is invalid, index={}, size={}", buffer_index, size);
        memory.WriteBlock(BufferDescriptorC()[buffer_index].Address(), buffer, size);
    }
@@ -344,12 +346,14 @@ std::size_t HLERequestContext::GetReadBufferSize(std::size_t buffer_index) const
    const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
                           BufferDescriptorA()[buffer_index].Size()};
    if (is_buffer_a) {
-        ASSERT_OR_EXECUTE_MSG(BufferDescriptorA().size() > buffer_index, { return 0; },
+        ASSERT_OR_EXECUTE_MSG(
-                              "BufferDescriptorA invalid buffer_index {}", buffer_index);
+            BufferDescriptorA().size() > buffer_index, { return 0; },
+            "BufferDescriptorA invalid buffer_index {}", buffer_index);
        return BufferDescriptorA()[buffer_index].Size();
    } else {
-        ASSERT_OR_EXECUTE_MSG(BufferDescriptorX().size() > buffer_index, { return 0; },
+        ASSERT_OR_EXECUTE_MSG(
-                              "BufferDescriptorX invalid buffer_index {}", buffer_index);
+            BufferDescriptorX().size() > buffer_index, { return 0; },
+            "BufferDescriptorX invalid buffer_index {}", buffer_index);
        return BufferDescriptorX()[buffer_index].Size();
    }
 }
@@ -358,12 +362,14 @@ std::size_t HLERequestContext::GetWriteBufferSize(std::size_t buffer_index) cons
    const bool is_buffer_b{BufferDescriptorB().size() > buffer_index &&
                           BufferDescriptorB()[buffer_index].Size()};
    if (is_buffer_b) {
-        ASSERT_OR_EXECUTE_MSG(BufferDescriptorB().size() > buffer_index, { return 0; },
+        ASSERT_OR_EXECUTE_MSG(
-                              "BufferDescriptorB invalid buffer_index {}", buffer_index);
+            BufferDescriptorB().size() > buffer_index, { return 0; },
+            "BufferDescriptorB invalid buffer_index {}", buffer_index);
        return BufferDescriptorB()[buffer_index].Size();
    } else {
-        ASSERT_OR_EXECUTE_MSG(BufferDescriptorC().size() > buffer_index, { return 0; },
+        ASSERT_OR_EXECUTE_MSG(
-                              "BufferDescriptorC invalid buffer_index {}", buffer_index);
+            BufferDescriptorC().size() > buffer_index, { return 0; },
+            "BufferDescriptorC invalid buffer_index {}", buffer_index);
        return BufferDescriptorC()[buffer_index].Size();
    }
    return 0;
diff --git a/src/core/hle/kernel/hle_ipc.h b/src/core/hle/kernel/hle_ipc.h
index b31673928..f3277b766 100644
--- a/src/core/hle/kernel/hle_ipc.h
+++ b/src/core/hle/kernel/hle_ipc.h
@@ -13,6 +13,7 @@
 #include <vector>
 #include <boost/container/small_vector.hpp>
 #include "common/common_types.h"
+#include "common/concepts.h"
 #include "common/swap.h"
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/object.h"
@@ -193,23 +194,24 @@ public:
    /* Helper function to write a buffer using the appropriate buffer descriptor
     *
-     * @tparam ContiguousContainer an arbitrary container that satisfies the
+     * @tparam T an arbitrary container that satisfies the
-     *         ContiguousContainer concept in the C++ standard library.
+     *         ContiguousContainer concept in the C++ standard library or a trivially copyable type.
     *
-     * @param container    The container to write the data of into a buffer.
+     * @param data         The container/data to write into a buffer.
     * @param buffer_index The buffer in particular to write to.
     */
-    template <typename ContiguousContainer,
+    template <typename T, typename = std::enable_if_t<!std::is_pointer_v<T>>>
-              typename = std::enable_if_t<!std::is_pointer_v<ContiguousContainer>>>
+    std::size_t WriteBuffer(const T& data, std::size_t buffer_index = 0) const {
-    std::size_t WriteBuffer(const ContiguousContainer& container,
+        if constexpr (Common::IsSTLContainer<T>) {
-                            std::size_t buffer_index = 0) const {
+            using ContiguousType = typename T::value_type;
-        using ContiguousType = typename ContiguousContainer::value_type;
+            static_assert(std::is_trivially_copyable_v<ContiguousType>,
+                          "Container to WriteBuffer must contain trivially copyable objects");
-        static_assert(std::is_trivially_copyable_v<ContiguousType>,
+            return WriteBuffer(std::data(data), std::size(data) * sizeof(ContiguousType),
-                      "Container to WriteBuffer must contain trivially copyable objects");
+                               buffer_index);
+        } else {
-        return WriteBuffer(std::data(container), std::size(container) * sizeof(ContiguousType),
+            static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
-                           buffer_index);
+            return WriteBuffer(&data, sizeof(T), buffer_index);
+        }
    }
    /// Helper function to get the size of the input buffer
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 8dd4a2637..cabe8d418 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -145,7 +145,7 @@ struct KernelCore::Impl {
    void InitializePreemption(KernelCore& kernel) {
        preemption_event = Core::Timing::CreateEvent(
-            "PreemptionCallback", [this, &kernel](u64, std::chrono::nanoseconds) {
+            "PreemptionCallback", [this, &kernel](std::uintptr_t, std::chrono::nanoseconds) {
                {
                    SchedulerLock lock(kernel);
                    global_scheduler.PreemptThreads();
diff --git a/src/core/hle/kernel/memory/page_table.cpp b/src/core/hle/kernel/memory/page_table.cpp
index 5d6aac00f..a3fadb533 100644
--- a/src/core/hle/kernel/memory/page_table.cpp
+++ b/src/core/hle/kernel/memory/page_table.cpp
@@ -604,7 +604,6 @@ ResultCode PageTable::MapPages(VAddr addr, const PageLinkedList& page_linked_lis
        if (const auto result{
                Operate(cur_addr, node.GetNumPages(), perm, OperationType::Map, node.GetAddress())};
            result.IsError()) {
-            const MemoryInfo info{block_manager->FindBlock(cur_addr).GetMemoryInfo()};
            const std::size_t num_pages{(addr - cur_addr) / PageSize};
            ASSERT(
@@ -852,11 +851,12 @@ ResultCode PageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) {
        return result;
    }
-    block_manager->UpdateLock(addr, size / PageSize,
+    block_manager->UpdateLock(
-                              [](MemoryBlockManager::iterator block, MemoryPermission perm) {
+        addr, size / PageSize,
-                                  block->ShareToDevice(perm);
+        [](MemoryBlockManager::iterator block, MemoryPermission perm) {
-                              },
+            block->ShareToDevice(perm);
-                              perm);
+        },
+        perm);
    return RESULT_SUCCESS;
 }
@@ -874,11 +874,12 @@ ResultCode PageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size)
        return result;
    }
-    block_manager->UpdateLock(addr, size / PageSize,
+    block_manager->UpdateLock(
-                              [](MemoryBlockManager::iterator block, MemoryPermission perm) {
+        addr, size / PageSize,
-                                  block->UnshareToDevice(perm);
+        [](MemoryBlockManager::iterator block, MemoryPermission perm) {
-                              },
+            block->UnshareToDevice(perm);
-                              perm);
+        },
+        perm);
    return RESULT_SUCCESS;
 }
diff --git a/src/core/hle/kernel/scheduler.cpp b/src/core/hle/kernel/scheduler.cpp
index f93e5e4b0..a4b234424 100644
--- a/src/core/hle/kernel/scheduler.cpp
+++ b/src/core/hle/kernel/scheduler.cpp
@@ -131,7 +131,8 @@ u32 GlobalScheduler::SelectThreads() {
    u32 cores_needing_context_switch{};
    for (u32 core = 0; core < Core::Hardware::NUM_CPU_CORES; core++) {
        Scheduler& sched = kernel.Scheduler(core);
-        ASSERT(top_threads[core] == nullptr || top_threads[core]->GetProcessorID() == core);
+        ASSERT(top_threads[core] == nullptr ||
+               static_cast<u32>(top_threads[core]->GetProcessorID()) == core);
        if (update_thread(top_threads[core], sched)) {
            cores_needing_context_switch |= (1ul << core);
        }
@@ -663,32 +664,26 @@ void Scheduler::Reload() {
 }
 void Scheduler::SwitchContextStep2() {
-    Thread* previous_thread = current_thread_prev.get();
-    Thread* new_thread = selected_thread.get();
    // Load context of new thread
-    Process* const previous_process =
+    if (selected_thread) {
-        previous_thread != nullptr ? previous_thread->GetOwnerProcess() : nullptr;
+        ASSERT_MSG(selected_thread->GetSchedulingStatus() == ThreadSchedStatus::Runnable,
-    if (new_thread) {
-        ASSERT_MSG(new_thread->GetSchedulingStatus() == ThreadSchedStatus::Runnable,
                   "Thread must be runnable.");
        // Cancel any outstanding wakeup events for this thread
-        new_thread->SetIsRunning(true);
+        selected_thread->SetIsRunning(true);
-        new_thread->last_running_ticks = system.CoreTiming().GetCPUTicks();
+        selected_thread->last_running_ticks = system.CoreTiming().GetCPUTicks();
-        new_thread->SetWasRunning(false);
+        selected_thread->SetWasRunning(false);
        auto* const thread_owner_process = current_thread->GetOwnerProcess();
        if (thread_owner_process != nullptr) {
            system.Kernel().MakeCurrentProcess(thread_owner_process);
        }
-        if (!new_thread->IsHLEThread()) {
+        if (!selected_thread->IsHLEThread()) {
-            Core::ARM_Interface& cpu_core = new_thread->ArmInterface();
+            Core::ARM_Interface& cpu_core = selected_thread->ArmInterface();
-            cpu_core.LoadContext(new_thread->GetContext32());
+            cpu_core.LoadContext(selected_thread->GetContext32());
-            cpu_core.LoadContext(new_thread->GetContext64());
+            cpu_core.LoadContext(selected_thread->GetContext64());
-            cpu_core.SetTlsAddress(new_thread->GetTLSAddress());
+            cpu_core.SetTlsAddress(selected_thread->GetTLSAddress());
-            cpu_core.SetTPIDR_EL0(new_thread->GetTPIDR_EL0());
+            cpu_core.SetTPIDR_EL0(selected_thread->GetTPIDR_EL0());
            cpu_core.ChangeProcessorID(this->core_id);
            cpu_core.ClearExclusiveState();
        }
diff --git a/src/core/hle/kernel/server_session.cpp b/src/core/hle/kernel/server_session.cpp
index af22f4c33..7e6391c6c 100644
--- a/src/core/hle/kernel/server_session.cpp
+++ b/src/core/hle/kernel/server_session.cpp
@@ -33,8 +33,10 @@ ResultVal<std::shared_ptr<ServerSession>> ServerSession::Create(KernelCore& kern
                                                                std::string name) {
    std::shared_ptr<ServerSession> session{std::make_shared<ServerSession>(kernel)};
-    session->request_event = Core::Timing::CreateEvent(
+    session->request_event =
-        name, [session](u64, std::chrono::nanoseconds) { session->CompleteSyncRequest(); });
+        Core::Timing::CreateEvent(name, [session](std::uintptr_t, std::chrono::nanoseconds) {
+            session->CompleteSyncRequest();
+        });
    session->name = std::move(name);
    session->parent = std::move(parent);
diff --git a/src/core/hle/kernel/time_manager.cpp b/src/core/hle/kernel/time_manager.cpp
index 88b01b751..95f2446c9 100644
--- a/src/core/hle/kernel/time_manager.cpp
+++ b/src/core/hle/kernel/time_manager.cpp
@@ -16,14 +16,14 @@ namespace Kernel {
 TimeManager::TimeManager(Core::System& system_) : system{system_} {
    time_manager_event_type = Core::Timing::CreateEvent(
-        "Kernel::TimeManagerCallback", [this](u64 thread_handle, std::chrono::nanoseconds) {
+        "Kernel::TimeManagerCallback",
-            SchedulerLock lock(system.Kernel());
+        [this](std::uintptr_t thread_handle, std::chrono::nanoseconds) {
-            Handle proper_handle = static_cast<Handle>(thread_handle);
+            const SchedulerLock lock(system.Kernel());
+            const auto proper_handle = static_cast<Handle>(thread_handle);
            if (cancelled_events[proper_handle]) {
                return;
            }
-            std::shared_ptr<Thread> thread =
+            auto thread = this->system.Kernel().RetrieveThreadFromGlobalHandleTable(proper_handle);
-                this->system.Kernel().RetrieveThreadFromGlobalHandleTable(proper_handle);
            thread->OnWakeUp();
        });
 }
diff --git a/src/core/hle/service/acc/acc.cpp b/src/core/hle/service/acc/acc.cpp
index 8ac856ec3..63e4aeca0 100644
--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -286,9 +286,7 @@ protected:
        ProfileBase profile_base{};
        ProfileData data{};
        if (profile_manager.GetProfileBaseAndData(user_id, profile_base, data)) {
-            std::array<u8, sizeof(ProfileData)> raw_data;
+            ctx.WriteBuffer(data);
-            std::memcpy(raw_data.data(), &data, sizeof(ProfileData));
-            ctx.WriteBuffer(raw_data);
            IPC::ResponseBuilder rb{ctx, 16};
            rb.Push(RESULT_SUCCESS);
            rb.PushRaw(profile_base);
@@ -333,7 +331,7 @@ protected:
        std::vector<u8> buffer(size);
        image.ReadBytes(buffer.data(), buffer.size());
-        ctx.WriteBuffer(buffer.data(), buffer.size());
+        ctx.WriteBuffer(buffer);
        rb.Push<u32>(size);
    }
diff --git a/src/core/hle/service/acc/profile_manager.cpp b/src/core/hle/service/acc/profile_manager.cpp
index eb8c81645..a98d57b5c 100644
--- a/src/core/hle/service/acc/profile_manager.cpp
+++ b/src/core/hle/service/acc/profile_manager.cpp
@@ -58,7 +58,7 @@ ProfileManager::~ProfileManager() {
 /// internal management of the users profiles
 std::optional<std::size_t> ProfileManager::AddToProfiles(const ProfileInfo& profile) {
    if (user_count >= MAX_USERS) {
-        return {};
+        return std::nullopt;
    }
    profiles[user_count] = profile;
    return user_count++;
@@ -101,13 +101,14 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, const ProfileUsername& usern
                    [&uuid](const ProfileInfo& profile) { return uuid == profile.user_uuid; })) {
        return ERROR_USER_ALREADY_EXISTS;
    }
-    ProfileInfo profile;
-    profile.user_uuid = uuid;
+    return AddUser({
-    profile.username = username;
+        .user_uuid = uuid,
-    profile.data = {};
+        .username = username,
-    profile.creation_time = 0x0;
+        .creation_time = 0,
-    profile.is_open = false;
+        .data = {},
-    return AddUser(profile);
+        .is_open = false,
+    });
 }
 /// Creates a new user on the system. This function allows a much simpler method of registration
@@ -126,7 +127,7 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, const std::string& username)
 std::optional<UUID> ProfileManager::GetUser(std::size_t index) const {
    if (index >= MAX_USERS) {
-        return {};
+        return std::nullopt;
    }
    return profiles[index].user_uuid;
@@ -135,13 +136,13 @@ std::optional<UUID> ProfileManager::GetUser(std::size_t index) const {
 /// Returns a users profile index based on their user id.
 std::optional<std::size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
    if (!uuid) {
-        return {};
+        return std::nullopt;
    }
    const auto iter = std::find_if(profiles.begin(), profiles.end(),
                                   [&uuid](const ProfileInfo& p) { return p.user_uuid == uuid; });
    if (iter == profiles.end()) {
-        return {};
+        return std::nullopt;
    }
    return static_cast<std::size_t>(std::distance(profiles.begin(), iter));
@@ -339,7 +340,13 @@ void ProfileManager::ParseUserSaveFile() {
            continue;
        }
-        AddUser({user.uuid, user.username, user.timestamp, user.extra_data, false});
+        AddUser({
+            .user_uuid = user.uuid,
+            .username = user.username,
+            .creation_time = user.timestamp,
+            .data = user.extra_data,
+            .is_open = false,
+        });
    }
    std::stable_partition(profiles.begin(), profiles.end(),
@@ -350,11 +357,13 @@ void ProfileManager::WriteUserSaveFile() {
    ProfileDataRaw raw{};
    for (std::size_t i = 0; i < MAX_USERS; ++i) {
-        raw.users[i].username = profiles[i].username;
+        raw.users[i] = {
-        raw.users[i].uuid2 = profiles[i].user_uuid;
+            .uuid = profiles[i].user_uuid,
-        raw.users[i].uuid = profiles[i].user_uuid;
+            .uuid2 = profiles[i].user_uuid,
-        raw.users[i].timestamp = profiles[i].creation_time;
+            .timestamp = profiles[i].creation_time,
-        raw.users[i].extra_data = profiles[i].data;
+            .username = profiles[i].username,
+            .extra_data = profiles[i].data,
+        };
    }
    const auto raw_path =
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index 4e7a0bec9..7d92b25a3 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -378,7 +378,11 @@ void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext&
 }
 void ISelfController::SetScreenShotPermission(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
+    IPC::RequestParser rp{ctx};
+    const auto permission = rp.PopEnum<ScreenshotPermission>();
+    LOG_DEBUG(Service_AM, "called, permission={}", permission);
+    screenshot_permission = permission;
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
@@ -1342,12 +1346,12 @@ void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_AM, "called, uid={:016X}{:016X}", user_id[1], user_id[0]);
-    FileSys::SaveDataDescriptor descriptor{};
+    FileSys::SaveDataAttribute attribute{};
-    descriptor.title_id = system.CurrentProcess()->GetTitleID();
+    attribute.title_id = system.CurrentProcess()->GetTitleID();
-    descriptor.user_id = user_id;
+    attribute.user_id = user_id;
-    descriptor.type = FileSys::SaveDataType::SaveData;
+    attribute.type = FileSys::SaveDataType::SaveData;
    const auto res = system.GetFileSystemController().CreateSaveData(
-        FileSys::SaveDataSpaceId::NandUser, descriptor);
+        FileSys::SaveDataSpaceId::NandUser, attribute);
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(res.Code());
@@ -1405,7 +1409,6 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
    // Get supported languages from NACP, if possible
    // Default to 0 (all languages supported)
    u32 supported_languages = 0;
-    FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID()};
    const auto res = [this] {
        const auto title_id = system.CurrentProcess()->GetTitleID();
diff --git a/src/core/hle/service/am/am.h b/src/core/hle/service/am/am.h
index 6cfb11b48..6e69796ec 100644
--- a/src/core/hle/service/am/am.h
+++ b/src/core/hle/service/am/am.h
@@ -149,6 +149,12 @@ private:
    void GetAccumulatedSuspendedTickValue(Kernel::HLERequestContext& ctx);
    void GetAccumulatedSuspendedTickChangedEvent(Kernel::HLERequestContext& ctx);
+    enum class ScreenshotPermission : u32 {
+        Inherit = 0,
+        Enable = 1,
+        Disable = 2,
+    };
    Core::System& system;
    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
    Kernel::EventPair launchable_event;
@@ -157,6 +163,7 @@ private:
    u32 idle_time_detection_extension = 0;
    u64 num_fatal_sections_entered = 0;
    bool is_auto_sleep_disabled = false;
+    ScreenshotPermission screenshot_permission = ScreenshotPermission::Inherit;
 };
 class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {
diff --git a/src/core/hle/service/am/applets/software_keyboard.cpp b/src/core/hle/service/am/applets/software_keyboard.cpp
index fbe3686ae..289da2619 100644
--- a/src/core/hle/service/am/applets/software_keyboard.cpp
+++ b/src/core/hle/service/am/applets/software_keyboard.cpp
@@ -13,11 +13,23 @@
 namespace Service::AM::Applets {
+namespace {
+enum class Request : u32 {
+    Finalize = 0x4,
+    SetUserWordInfo = 0x6,
+    SetCustomizeDic = 0x7,
+    Calc = 0xa,
+    SetCustomizedDictionaries = 0xb,
+    UnsetCustomizedDictionaries = 0xc,
+    UnknownD = 0xd,
+    UnknownE = 0xe,
+};
+constexpr std::size_t SWKBD_INLINE_INIT_SIZE = 0x8;
 constexpr std::size_t SWKBD_OUTPUT_BUFFER_SIZE = 0x7D8;
 constexpr std::size_t SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE = 0x7D4;
 constexpr std::size_t DEFAULT_MAX_LENGTH = 500;
 constexpr bool INTERACTIVE_STATUS_OK = false;
+} // Anonymous namespace
 static Core::Frontend::SoftwareKeyboardParameters ConvertToFrontendParameters(
    KeyboardConfig config, std::u16string initial_text) {
    Core::Frontend::SoftwareKeyboardParameters params{};
@@ -47,6 +59,7 @@ SoftwareKeyboard::~SoftwareKeyboard() = default;
 void SoftwareKeyboard::Initialize() {
    complete = false;
+    is_inline = false;
    initial_text.clear();
    final_data.clear();
@@ -56,6 +69,11 @@ void SoftwareKeyboard::Initialize() {
    ASSERT(keyboard_config_storage != nullptr);
    const auto& keyboard_config = keyboard_config_storage->GetData();
+    if (keyboard_config.size() == SWKBD_INLINE_INIT_SIZE) {
+        is_inline = true;
+        return;
+    }
    ASSERT(keyboard_config.size() >= sizeof(KeyboardConfig));
    std::memcpy(&config, keyboard_config.data(), sizeof(KeyboardConfig));
@@ -87,16 +105,32 @@ void SoftwareKeyboard::ExecuteInteractive() {
    const auto storage = broker.PopInteractiveDataToApplet();
    ASSERT(storage != nullptr);
    const auto data = storage->GetData();
-    const auto status = static_cast<bool>(data[0]);
+    if (!is_inline) {
+        const auto status = static_cast<bool>(data[0]);
-    if (status == INTERACTIVE_STATUS_OK) {
+        if (status == INTERACTIVE_STATUS_OK) {
-        complete = true;
+            complete = true;
+        } else {
+            std::array<char16_t, SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE / 2 - 2> string;
+            std::memcpy(string.data(), data.data() + 4, string.size() * 2);
+            frontend.SendTextCheckDialog(
+                Common::UTF16StringFromFixedZeroTerminatedBuffer(string.data(), string.size()),
+                [this] { broker.SignalStateChanged(); });
+        }
    } else {
-        std::array<char16_t, SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE / 2 - 2> string;
+        Request request{};
-        std::memcpy(string.data(), data.data() + 4, string.size() * 2);
+        std::memcpy(&request, data.data(), sizeof(Request));
-        frontend.SendTextCheckDialog(
-            Common::UTF16StringFromFixedZeroTerminatedBuffer(string.data(), string.size()),
+        switch (request) {
-            [this] { broker.SignalStateChanged(); });
+        case Request::Calc: {
+            broker.PushNormalDataFromApplet(
+                std::make_shared<IStorage>(std::move(std::vector<u8>{1})));
+            broker.SignalStateChanged();
+            break;
+        }
+        default:
+            UNIMPLEMENTED_MSG("Request {:X} is not implemented", request);
+            break;
+        }
    }
 }
@@ -108,9 +142,10 @@ void SoftwareKeyboard::Execute() {
    }
    const auto parameters = ConvertToFrontendParameters(config, initial_text);
+    if (!is_inline) {
-    frontend.RequestText([this](std::optional<std::u16string> text) { WriteText(std::move(text)); },
+        frontend.RequestText(
-                         parameters);
+            [this](std::optional<std::u16string> text) { WriteText(std::move(text)); }, parameters);
+    }
 }
 void SoftwareKeyboard::WriteText(std::optional<std::u16string> text) {
diff --git a/src/core/hle/service/am/applets/software_keyboard.h b/src/core/hle/service/am/applets/software_keyboard.h
index ef4801fc6..5a3824b5a 100644
--- a/src/core/hle/service/am/applets/software_keyboard.h
+++ b/src/core/hle/service/am/applets/software_keyboard.h
@@ -78,6 +78,7 @@ private:
    KeyboardConfig config;
    std::u16string initial_text;
    bool complete = false;
+    bool is_inline = false;
    std::vector<u8> final_data;
 };
diff --git a/src/core/hle/service/am/applets/web_browser.cpp b/src/core/hle/service/am/applets/web_browser.cpp
index 9f30e167d..4157fbf39 100644
--- a/src/core/hle/service/am/applets/web_browser.cpp
+++ b/src/core/hle/service/am/applets/web_browser.cpp
@@ -551,7 +551,8 @@ void WebBrowser::ExecuteShop() {
 }
 void WebBrowser::ExecuteOffline() {
-    frontend.OpenPageLocal(filename, [this] { UnpackRomFS(); }, [this] { Finalize(); });
+    frontend.OpenPageLocal(
+        filename, [this] { UnpackRomFS(); }, [this] { Finalize(); });
 }
 } // namespace Service::AM::Applets
diff --git a/src/core/hle/service/audio/audout_u.cpp b/src/core/hle/service/audio/audout_u.cpp
index 106e89743..9b4910e53 100644
--- a/src/core/hle/service/audio/audout_u.cpp
+++ b/src/core/hle/service/audio/audout_u.cpp
@@ -71,7 +71,7 @@ public:
        stream = audio_core.OpenStream(system.CoreTiming(), audio_params.sample_rate,
                                       audio_params.channel_count, std::move(unique_name),
-                                       [=]() { buffer_event.writable->Signal(); });
+                                       [this] { buffer_event.writable->Signal(); });
    }
 private:
@@ -206,7 +206,7 @@ private:
    AudioCore::StreamPtr stream;
    std::string device_name;
-    [[maybe_unused]] AudoutParams audio_params {};
+    [[maybe_unused]] AudoutParams audio_params{};
    /// This is the event handle used to check if the audio buffer was released
    Kernel::EventPair buffer_event;
diff --git a/src/core/hle/service/audio/hwopus.cpp b/src/core/hle/service/audio/hwopus.cpp
index d19513cbb..f1d81602c 100644
--- a/src/core/hle/service/audio/hwopus.cpp
+++ b/src/core/hle/service/audio/hwopus.cpp
@@ -92,7 +92,7 @@ private:
        if (performance) {
            rb.Push<u64>(*performance);
        }
-        ctx.WriteBuffer(samples.data(), samples.size() * sizeof(s16));
+        ctx.WriteBuffer(samples);
    }
    bool DecodeOpusData(u32& consumed, u32& sample_count, const std::vector<u8>& input,
diff --git a/src/core/hle/service/bcat/backend/boxcat.cpp b/src/core/hle/service/bcat/backend/boxcat.cpp
index d29e78d7e..51c2ba964 100644
--- a/src/core/hle/service/bcat/backend/boxcat.cpp
+++ b/src/core/hle/service/bcat/backend/boxcat.cpp
@@ -365,8 +365,7 @@ bool Boxcat::Synchronize(TitleIDVersion title, ProgressServiceBackend& progress)
    std::thread([this, title, &progress] {
        SynchronizeInternal(applet_manager, dir_getter, title, progress);
-    })
+    }).detach();
-        .detach();
    return true;
 }
@@ -377,8 +376,7 @@ bool Boxcat::SynchronizeDirectory(TitleIDVersion title, std::string name,
    std::thread([this, title, name, &progress] {
        SynchronizeInternal(applet_manager, dir_getter, title, progress, name);
-    })
+    }).detach();
-        .detach();
    return true;
 }
diff --git a/src/core/hle/service/bcat/module.cpp b/src/core/hle/service/bcat/module.cpp
index 603b64d4f..db0e06ca1 100644
--- a/src/core/hle/service/bcat/module.cpp
+++ b/src/core/hle/service/bcat/module.cpp
@@ -112,7 +112,7 @@ private:
    void GetImpl(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_BCAT, "called");
-        ctx.WriteBuffer(&impl, sizeof(DeliveryCacheProgressImpl));
+        ctx.WriteBuffer(impl);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
diff --git a/src/core/hle/service/es/es.cpp b/src/core/hle/service/es/es.cpp
index a41c73c48..c2737a365 100644
--- a/src/core/hle/service/es/es.cpp
+++ b/src/core/hle/service/es/es.cpp
@@ -160,7 +160,7 @@ private:
            return;
        }
-        ctx.WriteBuffer(key.data(), key.size());
+        ctx.WriteBuffer(key);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp
index c66124998..4490f8e4c 100644
--- a/src/core/hle/service/filesystem/filesystem.cpp
+++ b/src/core/hle/service/filesystem/filesystem.cpp
@@ -311,7 +311,7 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFS(
 }
 ResultVal<FileSys::VirtualDir> FileSystemController::CreateSaveData(
-    FileSys::SaveDataSpaceId space, const FileSys::SaveDataDescriptor& save_struct) const {
+    FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const {
    LOG_TRACE(Service_FS, "Creating Save Data for space_id={:01X}, save_struct={}",
              static_cast<u8>(space), save_struct.DebugInfo());
@@ -323,15 +323,15 @@ ResultVal<FileSys::VirtualDir> FileSystemController::CreateSaveData(
 }
 ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveData(
-    FileSys::SaveDataSpaceId space, const FileSys::SaveDataDescriptor& descriptor) const {
+    FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& attribute) const {
    LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}",
-              static_cast<u8>(space), descriptor.DebugInfo());
+              static_cast<u8>(space), attribute.DebugInfo());
    if (save_data_factory == nullptr) {
        return FileSys::ERROR_ENTITY_NOT_FOUND;
    }
-    return save_data_factory->Open(space, descriptor);
+    return save_data_factory->Open(space, attribute);
 }
 ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveDataSpace(
diff --git a/src/core/hle/service/filesystem/filesystem.h b/src/core/hle/service/filesystem/filesystem.h
index 1b0a6a949..6dbbf0b2b 100644
--- a/src/core/hle/service/filesystem/filesystem.h
+++ b/src/core/hle/service/filesystem/filesystem.h
@@ -31,7 +31,7 @@ enum class SaveDataSpaceId : u8;
 enum class SaveDataType : u8;
 enum class StorageId : u8;
-struct SaveDataDescriptor;
+struct SaveDataAttribute;
 struct SaveDataSize;
 } // namespace FileSys
@@ -69,9 +69,9 @@ public:
    ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
                                              FileSys::ContentRecordType type) const;
    ResultVal<FileSys::VirtualDir> CreateSaveData(
-        FileSys::SaveDataSpaceId space, const FileSys::SaveDataDescriptor& save_struct) const;
+        FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const;
    ResultVal<FileSys::VirtualDir> OpenSaveData(
-        FileSys::SaveDataSpaceId space, const FileSys::SaveDataDescriptor& save_struct) const;
+        FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const;
    ResultVal<FileSys::VirtualDir> OpenSaveDataSpace(FileSys::SaveDataSpaceId space) const;
    ResultVal<FileSys::VirtualDir> OpenSDMC() const;
    ResultVal<FileSys::VirtualDir> OpenBISPartition(FileSys::BisPartitionId id) const;
diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp
index 20c331b77..26fd87f58 100644
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -696,8 +696,8 @@ FSP_SRV::FSP_SRV(FileSystemController& fsc, const Core::Reporter& reporter)
        {67, nullptr, "FindSaveDataWithFilter"},
        {68, nullptr, "OpenSaveDataInfoReaderBySaveDataFilter"},
        {69, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataAttribute"},
-        {70, nullptr, "WriteSaveDataFileSystemExtraDataBySaveDataAttribute"},
+        {70, &FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute, "WriteSaveDataFileSystemExtraDataBySaveDataAttribute"},
-        {71, nullptr, "ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute"},
+        {71, &FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute, "ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute"},
        {80, nullptr, "OpenSaveDataMetaFile"},
        {81, nullptr, "OpenSaveDataTransferManager"},
        {82, nullptr, "OpenSaveDataTransferManagerVersion2"},
@@ -812,7 +812,7 @@ void FSP_SRV::OpenSdCardFileSystem(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::CreateSaveDataFileSystem(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    auto save_struct = rp.PopRaw<FileSys::SaveDataDescriptor>();
+    auto save_struct = rp.PopRaw<FileSys::SaveDataAttribute>();
    [[maybe_unused]] auto save_create_struct = rp.PopRaw<std::array<u8, 0x40>>();
    u128 uid = rp.PopRaw<u128>();
@@ -826,17 +826,18 @@ void FSP_SRV::CreateSaveDataFileSystem(Kernel::HLERequestContext& ctx) {
 }
 void FSP_SRV::OpenSaveDataFileSystem(Kernel::HLERequestContext& ctx) {
-    LOG_INFO(Service_FS, "called.");
+    IPC::RequestParser rp{ctx};
    struct Parameters {
-        FileSys::SaveDataSpaceId save_data_space_id;
+        FileSys::SaveDataSpaceId space_id;
-        FileSys::SaveDataDescriptor descriptor;
+        FileSys::SaveDataAttribute attribute;
    };
-    IPC::RequestParser rp{ctx};
    const auto parameters = rp.PopRaw<Parameters>();
-    auto dir = fsc.OpenSaveData(parameters.save_data_space_id, parameters.descriptor);
+    LOG_INFO(Service_FS, "called.");
+    auto dir = fsc.OpenSaveData(parameters.space_id, parameters.attribute);
    if (dir.Failed()) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 0};
        rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
@@ -844,13 +845,18 @@ void FSP_SRV::OpenSaveDataFileSystem(Kernel::HLERequestContext& ctx) {
    }
    FileSys::StorageId id;
-    if (parameters.save_data_space_id == FileSys::SaveDataSpaceId::NandUser) {
+    switch (parameters.space_id) {
+    case FileSys::SaveDataSpaceId::NandUser:
        id = FileSys::StorageId::NandUser;
-    } else if (parameters.save_data_space_id == FileSys::SaveDataSpaceId::SdCardSystem ||
+        break;
-               parameters.save_data_space_id == FileSys::SaveDataSpaceId::SdCardUser) {
+    case FileSys::SaveDataSpaceId::SdCardSystem:
+    case FileSys::SaveDataSpaceId::SdCardUser:
        id = FileSys::StorageId::SdCard;
-    } else {
+        break;
+    case FileSys::SaveDataSpaceId::NandSystem:
        id = FileSys::StorageId::NandSystem;
+        break;
    }
    auto filesystem =
@@ -876,22 +882,31 @@ void FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId(Kernel::HLERequestContext&
    rb.PushIpcInterface<ISaveDataInfoReader>(std::make_shared<ISaveDataInfoReader>(space, fsc));
 }
-void FSP_SRV::SetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
+void FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
+    LOG_WARNING(Service_FS, "(STUBBED) called.");
-    log_mode = rp.PopEnum<LogMode>();
-    LOG_DEBUG(Service_FS, "called, log_mode={:08X}", static_cast<u32>(log_mode));
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
-void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
+void FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
-    LOG_DEBUG(Service_FS, "called");
+    Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        FileSys::SaveDataSpaceId space_id;
+        FileSys::SaveDataAttribute attribute;
+    };
+    const auto parameters = rp.PopRaw<Parameters>();
+    // Stub this to None for now, backend needs an impl to read/write the SaveDataExtraData
+    constexpr auto flags = static_cast<u32>(FileSys::SaveDataFlags::None);
+    LOG_WARNING(Service_FS, "(STUBBED) called, flags={}", flags);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(log_mode);
+    rb.Push(flags);
 }
 void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
@@ -966,6 +981,24 @@ void FSP_SRV::OpenPatchDataStorageByCurrentProcess(Kernel::HLERequestContext& ct
    rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
 }
+void FSP_SRV::SetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    log_mode = rp.PopEnum<LogMode>();
+    LOG_DEBUG(Service_FS, "called, log_mode={:08X}", static_cast<u32>(log_mode));
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_FS, "called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushEnum(log_mode);
+}
 void FSP_SRV::OutputAccessLogToSdCard(Kernel::HLERequestContext& ctx) {
    const auto raw = ctx.ReadBuffer();
    auto log = Common::StringFromFixedZeroTerminatedBuffer(
diff --git a/src/core/hle/service/filesystem/fsp_srv.h b/src/core/hle/service/filesystem/fsp_srv.h
index dfb3e395b..4964e874e 100644
--- a/src/core/hle/service/filesystem/fsp_srv.h
+++ b/src/core/hle/service/filesystem/fsp_srv.h
@@ -43,11 +43,13 @@ private:
    void OpenSaveDataFileSystem(Kernel::HLERequestContext& ctx);
    void OpenReadOnlySaveDataFileSystem(Kernel::HLERequestContext& ctx);
    void OpenSaveDataInfoReaderBySaveDataSpaceId(Kernel::HLERequestContext& ctx);
-    void SetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
+    void WriteSaveDataFileSystemExtraDataBySaveDataAttribute(Kernel::HLERequestContext& ctx);
-    void GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
+    void ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(Kernel::HLERequestContext& ctx);
    void OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
    void OpenDataStorageByDataId(Kernel::HLERequestContext& ctx);
    void OpenPatchDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
+    void SetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
+    void GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
    void OutputAccessLogToSdCard(Kernel::HLERequestContext& ctx);
    void GetAccessLogVersionInfo(Kernel::HLERequestContext& ctx);
    void OpenMultiCommitManager(Kernel::HLERequestContext& ctx);
diff --git a/src/core/hle/service/hid/controllers/debug_pad.cpp b/src/core/hle/service/hid/controllers/debug_pad.cpp
index cb35919e9..ad251ed4a 100644
--- a/src/core/hle/service/hid/controllers/debug_pad.cpp
+++ b/src/core/hle/service/hid/controllers/debug_pad.cpp
@@ -39,33 +39,36 @@ void Controller_DebugPad::OnUpdate(const Core::Timing::CoreTiming& core_timing,
    cur_entry.sampling_number = last_entry.sampling_number + 1;
    cur_entry.sampling_number2 = cur_entry.sampling_number;
-    cur_entry.attribute.connected.Assign(1);
-    auto& pad = cur_entry.pad_state;
-    using namespace Settings::NativeButton;
+    if (Settings::values.debug_pad_enabled) {
-    pad.a.Assign(buttons[A - BUTTON_HID_BEGIN]->GetStatus());
+        cur_entry.attribute.connected.Assign(1);
-    pad.b.Assign(buttons[B - BUTTON_HID_BEGIN]->GetStatus());
+        auto& pad = cur_entry.pad_state;
-    pad.x.Assign(buttons[X - BUTTON_HID_BEGIN]->GetStatus());
-    pad.y.Assign(buttons[Y - BUTTON_HID_BEGIN]->GetStatus());
-    pad.l.Assign(buttons[L - BUTTON_HID_BEGIN]->GetStatus());
-    pad.r.Assign(buttons[R - BUTTON_HID_BEGIN]->GetStatus());
-    pad.zl.Assign(buttons[ZL - BUTTON_HID_BEGIN]->GetStatus());
-    pad.zr.Assign(buttons[ZR - BUTTON_HID_BEGIN]->GetStatus());
-    pad.plus.Assign(buttons[Plus - BUTTON_HID_BEGIN]->GetStatus());
-    pad.minus.Assign(buttons[Minus - BUTTON_HID_BEGIN]->GetStatus());
-    pad.d_left.Assign(buttons[DLeft - BUTTON_HID_BEGIN]->GetStatus());
-    pad.d_up.Assign(buttons[DUp - BUTTON_HID_BEGIN]->GetStatus());
-    pad.d_right.Assign(buttons[DRight - BUTTON_HID_BEGIN]->GetStatus());
-    pad.d_down.Assign(buttons[DDown - BUTTON_HID_BEGIN]->GetStatus());
-    const auto [stick_l_x_f, stick_l_y_f] =
+        using namespace Settings::NativeButton;
-        analogs[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetStatus();
+        pad.a.Assign(buttons[A - BUTTON_HID_BEGIN]->GetStatus());
-    const auto [stick_r_x_f, stick_r_y_f] =
+        pad.b.Assign(buttons[B - BUTTON_HID_BEGIN]->GetStatus());
-        analogs[static_cast<std::size_t>(JoystickId::Joystick_Right)]->GetStatus();
+        pad.x.Assign(buttons[X - BUTTON_HID_BEGIN]->GetStatus());
-    cur_entry.l_stick.x = static_cast<s32>(stick_l_x_f * HID_JOYSTICK_MAX);
+        pad.y.Assign(buttons[Y - BUTTON_HID_BEGIN]->GetStatus());
-    cur_entry.l_stick.y = static_cast<s32>(stick_l_y_f * HID_JOYSTICK_MAX);
+        pad.l.Assign(buttons[L - BUTTON_HID_BEGIN]->GetStatus());
-    cur_entry.r_stick.x = static_cast<s32>(stick_r_x_f * HID_JOYSTICK_MAX);
+        pad.r.Assign(buttons[R - BUTTON_HID_BEGIN]->GetStatus());
-    cur_entry.r_stick.y = static_cast<s32>(stick_r_y_f * HID_JOYSTICK_MAX);
+        pad.zl.Assign(buttons[ZL - BUTTON_HID_BEGIN]->GetStatus());
+        pad.zr.Assign(buttons[ZR - BUTTON_HID_BEGIN]->GetStatus());
+        pad.plus.Assign(buttons[Plus - BUTTON_HID_BEGIN]->GetStatus());
+        pad.minus.Assign(buttons[Minus - BUTTON_HID_BEGIN]->GetStatus());
+        pad.d_left.Assign(buttons[DLeft - BUTTON_HID_BEGIN]->GetStatus());
+        pad.d_up.Assign(buttons[DUp - BUTTON_HID_BEGIN]->GetStatus());
+        pad.d_right.Assign(buttons[DRight - BUTTON_HID_BEGIN]->GetStatus());
+        pad.d_down.Assign(buttons[DDown - BUTTON_HID_BEGIN]->GetStatus());
+        const auto [stick_l_x_f, stick_l_y_f] =
+            analogs[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetStatus();
+        const auto [stick_r_x_f, stick_r_y_f] =
+            analogs[static_cast<std::size_t>(JoystickId::Joystick_Right)]->GetStatus();
+        cur_entry.l_stick.x = static_cast<s32>(stick_l_x_f * HID_JOYSTICK_MAX);
+        cur_entry.l_stick.y = static_cast<s32>(stick_l_y_f * HID_JOYSTICK_MAX);
+        cur_entry.r_stick.x = static_cast<s32>(stick_r_x_f * HID_JOYSTICK_MAX);
+        cur_entry.r_stick.y = static_cast<s32>(stick_r_y_f * HID_JOYSTICK_MAX);
+    }
    std::memcpy(data, &shared_memory, sizeof(SharedMemory));
 }
diff --git a/src/core/hle/service/hid/controllers/keyboard.cpp b/src/core/hle/service/hid/controllers/keyboard.cpp
index feae89525..0b896d5ad 100644
--- a/src/core/hle/service/hid/controllers/keyboard.cpp
+++ b/src/core/hle/service/hid/controllers/keyboard.cpp
@@ -40,15 +40,16 @@ void Controller_Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing,
    cur_entry.key.fill(0);
    cur_entry.modifier = 0;
+    if (Settings::values.keyboard_enabled) {
-    for (std::size_t i = 0; i < keyboard_keys.size(); ++i) {
+        for (std::size_t i = 0; i < keyboard_keys.size(); ++i) {
-        cur_entry.key[i / KEYS_PER_BYTE] |= (keyboard_keys[i]->GetStatus() << (i % KEYS_PER_BYTE));
+            cur_entry.key[i / KEYS_PER_BYTE] |=
-    }
+                (keyboard_keys[i]->GetStatus() << (i % KEYS_PER_BYTE));
+        }
-    for (std::size_t i = 0; i < keyboard_mods.size(); ++i) {
-        cur_entry.modifier |= (keyboard_mods[i]->GetStatus() << i);
+        for (std::size_t i = 0; i < keyboard_mods.size(); ++i) {
+            cur_entry.modifier |= (keyboard_mods[i]->GetStatus() << i);
+        }
    }
    std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(SharedMemory));
 }
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 680290cbd..1e95b7580 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -77,8 +77,9 @@ IAppletResource::IAppletResource(Core::System& system)
    // Register update callbacks
    pad_update_event = Core::Timing::CreateEvent(
-        "HID::UpdatePadCallback", [this](u64 userdata, std::chrono::nanoseconds ns_late) {
+        "HID::UpdatePadCallback",
-            UpdateControllers(userdata, ns_late);
+        [this](std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
+            UpdateControllers(user_data, ns_late);
        });
    // TODO(shinyquagsire23): Other update callbacks? (accel, gyro?)
@@ -108,7 +109,8 @@ void IAppletResource::GetSharedMemoryHandle(Kernel::HLERequestContext& ctx) {
    rb.PushCopyObjects(shared_mem);
 }
-void IAppletResource::UpdateControllers(u64 userdata, std::chrono::nanoseconds ns_late) {
+void IAppletResource::UpdateControllers(std::uintptr_t user_data,
+                                        std::chrono::nanoseconds ns_late) {
    auto& core_timing = system.CoreTiming();
    const bool should_reload = Settings::values.is_device_reload_pending.exchange(false);
diff --git a/src/core/hle/service/hid/hid.h b/src/core/hle/service/hid/hid.h
index c6f0a2584..efb07547f 100644
--- a/src/core/hle/service/hid/hid.h
+++ b/src/core/hle/service/hid/hid.h
@@ -64,7 +64,7 @@ private:
    }
    void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx);
-    void UpdateControllers(u64 userdata, std::chrono::nanoseconds ns_late);
+    void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
    std::shared_ptr<Kernel::SharedMemory> shared_mem;
diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp
index 64a526b9e..d8cd10e31 100644
--- a/src/core/hle/service/ldr/ldr.cpp
+++ b/src/core/hle/service/ldr/ldr.cpp
@@ -310,7 +310,7 @@ public:
    ResultVal<VAddr> MapProcessCodeMemory(Kernel::Process* process, VAddr baseAddress,
                                          u64 size) const {
-        for (int retry{}; retry < MAXIMUM_MAP_RETRIES; retry++) {
+        for (std::size_t retry = 0; retry < MAXIMUM_MAP_RETRIES; retry++) {
            auto& page_table{process->PageTable()};
            const VAddr addr{GetRandomMapRegion(page_table, size)};
            const ResultCode result{page_table.MapProcessCodeMemory(addr, baseAddress, size)};
@@ -331,8 +331,7 @@ public:
    ResultVal<VAddr> MapNro(Kernel::Process* process, VAddr nro_addr, std::size_t nro_size,
                            VAddr bss_addr, std::size_t bss_size, std::size_t size) const {
+        for (std::size_t retry = 0; retry < MAXIMUM_MAP_RETRIES; retry++) {
-        for (int retry{}; retry < MAXIMUM_MAP_RETRIES; retry++) {
            auto& page_table{process->PageTable()};
            VAddr addr{};
diff --git a/src/core/hle/service/nfp/nfp.cpp b/src/core/hle/service/nfp/nfp.cpp
index 4b79eb81d..5e2d769a4 100644
--- a/src/core/hle/service/nfp/nfp.cpp
+++ b/src/core/hle/service/nfp/nfp.cpp
@@ -127,7 +127,7 @@ private:
        const u32 array_size = rp.Pop<u32>();
        LOG_DEBUG(Service_NFP, "called, array_size={}", array_size);
-        ctx.WriteBuffer(&device_handle, sizeof(device_handle));
+        ctx.WriteBuffer(device_handle);
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
@@ -220,7 +220,7 @@ private:
        tag_info.protocol = 1; // TODO(ogniK): Figure out actual values
        tag_info.tag_type = 2;
-        ctx.WriteBuffer(&tag_info, sizeof(TagInfo));
+        ctx.WriteBuffer(tag_info);
        rb.Push(RESULT_SUCCESS);
    }
@@ -237,7 +237,7 @@ private:
        IPC::ResponseBuilder rb{ctx, 2};
        auto amiibo = nfp_interface.GetAmiiboBuffer();
-        ctx.WriteBuffer(&amiibo.model_info, sizeof(amiibo.model_info));
+        ctx.WriteBuffer(amiibo.model_info);
        rb.Push(RESULT_SUCCESS);
    }
@@ -283,7 +283,7 @@ private:
        CommonInfo common_info{};
        common_info.application_area_size = 0;
-        ctx.WriteBuffer(&common_info, sizeof(CommonInfo));
+        ctx.WriteBuffer(common_info);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
index 195421cc0..d4ba88147 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
@@ -16,11 +16,12 @@
 #include "video_core/renderer_base.h"
 namespace Service::Nvidia::Devices {
 namespace NvErrCodes {
-enum {
+constexpr u32 Success{};
-    InvalidNmapHandle = -22,
+constexpr u32 OutOfMemory{static_cast<u32>(-12)};
-};
+constexpr u32 InvalidInput{static_cast<u32>(-22)};
-}
+} // namespace NvErrCodes
 nvhost_as_gpu::nvhost_as_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
    : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
@@ -49,8 +50,9 @@ u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, const std:
        break;
    }
-    if (static_cast<IoctlCommand>(command.cmd.Value()) == IoctlCommand::IocRemapCommand)
+    if (static_cast<IoctlCommand>(command.cmd.Value()) == IoctlCommand::IocRemapCommand) {
        return Remap(input, output);
+    }
    UNIMPLEMENTED_MSG("Unimplemented ioctl command");
    return 0;
@@ -59,6 +61,7 @@ u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, const std:
 u32 nvhost_as_gpu::InitalizeEx(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlInitalizeEx params{};
    std::memcpy(&params, input.data(), input.size());
    LOG_WARNING(Service_NVDRV, "(STUBBED) called, big_page_size=0x{:X}", params.big_page_size);
    return 0;
@@ -67,53 +70,61 @@ u32 nvhost_as_gpu::InitalizeEx(const std::vector<u8>& input, std::vector<u8>& ou
 u32 nvhost_as_gpu::AllocateSpace(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlAllocSpace params{};
    std::memcpy(&params, input.data(), input.size());
    LOG_DEBUG(Service_NVDRV, "called, pages={:X}, page_size={:X}, flags={:X}", params.pages,
              params.page_size, params.flags);
-    auto& gpu = system.GPU();
+    const auto size{static_cast<u64>(params.pages) * static_cast<u64>(params.page_size)};
-    const u64 size{static_cast<u64>(params.pages) * static_cast<u64>(params.page_size)};
+    if ((params.flags & AddressSpaceFlags::FixedOffset) != AddressSpaceFlags::None) {
-    if (params.flags & 1) {
+        params.offset = *system.GPU().MemoryManager().AllocateFixed(params.offset, size);
-        params.offset = gpu.MemoryManager().AllocateSpace(params.offset, size, 1);
    } else {
-        params.offset = gpu.MemoryManager().AllocateSpace(size, params.align);
+        params.offset = system.GPU().MemoryManager().Allocate(size, params.align);
+    }
+    auto result{NvErrCodes::Success};
+    if (!params.offset) {
+        LOG_CRITICAL(Service_NVDRV, "allocation failed for size {}", size);
+        result = NvErrCodes::OutOfMemory;
    }
    std::memcpy(output.data(), &params, output.size());
-    return 0;
+    return result;
 }
 u32 nvhost_as_gpu::Remap(const std::vector<u8>& input, std::vector<u8>& output) {
-    std::size_t num_entries = input.size() / sizeof(IoctlRemapEntry);
+    const auto num_entries = input.size() / sizeof(IoctlRemapEntry);
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, num_entries=0x{:X}", num_entries);
+    LOG_DEBUG(Service_NVDRV, "called, num_entries=0x{:X}", num_entries);
+    auto result{NvErrCodes::Success};
    std::vector<IoctlRemapEntry> entries(num_entries);
    std::memcpy(entries.data(), input.data(), input.size());
-    auto& gpu = system.GPU();
    for (const auto& entry : entries) {
-        LOG_WARNING(Service_NVDRV, "remap entry, offset=0x{:X} handle=0x{:X} pages=0x{:X}",
+        LOG_DEBUG(Service_NVDRV, "remap entry, offset=0x{:X} handle=0x{:X} pages=0x{:X}",
-                    entry.offset, entry.nvmap_handle, entry.pages);
+                  entry.offset, entry.nvmap_handle, entry.pages);
-        GPUVAddr offset = static_cast<GPUVAddr>(entry.offset) << 0x10;
-        auto object = nvmap_dev->GetObject(entry.nvmap_handle);
+        const auto object{nvmap_dev->GetObject(entry.nvmap_handle)};
        if (!object) {
-            LOG_CRITICAL(Service_NVDRV, "nvmap {} is an invalid handle!", entry.nvmap_handle);
+            LOG_CRITICAL(Service_NVDRV, "invalid nvmap_handle={:X}", entry.nvmap_handle);
-            std::memcpy(output.data(), entries.data(), output.size());
+            result = NvErrCodes::InvalidInput;
-            return static_cast<u32>(NvErrCodes::InvalidNmapHandle);
+            break;
        }
-        ASSERT(object->status == nvmap::Object::Status::Allocated);
+        const auto offset{static_cast<GPUVAddr>(entry.offset) << 0x10};
+        const auto size{static_cast<u64>(entry.pages) << 0x10};
+        const auto map_offset{static_cast<u64>(entry.map_offset) << 0x10};
+        const auto addr{system.GPU().MemoryManager().Map(object->addr + map_offset, offset, size)};
-        const u64 size = static_cast<u64>(entry.pages) << 0x10;
+        if (!addr) {
-        ASSERT(size <= object->size);
+            LOG_CRITICAL(Service_NVDRV, "map returned an invalid address!");
-        const u64 map_offset = static_cast<u64>(entry.map_offset) << 0x10;
+            result = NvErrCodes::InvalidInput;
+            break;
-        const GPUVAddr returned =
+        }
-            gpu.MemoryManager().MapBufferEx(object->addr + map_offset, offset, size);
-        ASSERT(returned == offset);
    }
    std::memcpy(output.data(), entries.data(), output.size());
-    return 0;
+    return result;
 }
 u32 nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output) {
@@ -126,44 +137,76 @@ u32 nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8>& ou
              params.flags, params.nvmap_handle, params.buffer_offset, params.mapping_size,
              params.offset);
-    if (!params.nvmap_handle) {
+    const auto object{nvmap_dev->GetObject(params.nvmap_handle)};
-        return 0;
+    if (!object) {
+        LOG_CRITICAL(Service_NVDRV, "invalid nvmap_handle={:X}", params.nvmap_handle);
+        std::memcpy(output.data(), &params, output.size());
+        return NvErrCodes::InvalidInput;
    }
-    auto object = nvmap_dev->GetObject(params.nvmap_handle);
-    ASSERT(object);
-    // We can only map objects that have already been assigned a CPU address.
-    ASSERT(object->status == nvmap::Object::Status::Allocated);
-    ASSERT(params.buffer_offset == 0);
    // The real nvservices doesn't make a distinction between handles and ids, and
    // object can only have one handle and it will be the same as its id. Assert that this is the
    // case to prevent unexpected behavior.
    ASSERT(object->id == params.nvmap_handle);
    auto& gpu = system.GPU();
-    if (params.flags & 1) {
+    u64 page_size{params.page_size};
-        params.offset = gpu.MemoryManager().MapBufferEx(object->addr, params.offset, object->size);
+    if (!page_size) {
-    } else {
+        page_size = object->align;
-        params.offset = gpu.MemoryManager().MapBufferEx(object->addr, object->size);
+    }
+    if ((params.flags & AddressSpaceFlags::Remap) != AddressSpaceFlags::None) {
+        if (const auto buffer_map{FindBufferMap(params.offset)}; buffer_map) {
+            const auto cpu_addr{static_cast<VAddr>(buffer_map->CpuAddr() + params.buffer_offset)};
+            const auto gpu_addr{static_cast<GPUVAddr>(params.offset + params.buffer_offset)};
+            if (!gpu.MemoryManager().Map(cpu_addr, gpu_addr, params.mapping_size)) {
+                LOG_CRITICAL(Service_NVDRV,
+                             "remap failed, flags={:X}, nvmap_handle={:X}, buffer_offset={}, "
+                             "mapping_size = {}, offset={}",
+                             params.flags, params.nvmap_handle, params.buffer_offset,
+                             params.mapping_size, params.offset);
+                std::memcpy(output.data(), &params, output.size());
+                return NvErrCodes::InvalidInput;
+            }
+            std::memcpy(output.data(), &params, output.size());
+            return NvErrCodes::Success;
+        } else {
+            LOG_CRITICAL(Service_NVDRV, "address not mapped offset={}", params.offset);
+            std::memcpy(output.data(), &params, output.size());
+            return NvErrCodes::InvalidInput;
+        }
    }
-    // Create a new mapping entry for this operation.
+    // We can only map objects that have already been assigned a CPU address.
-    ASSERT_MSG(buffer_mappings.find(params.offset) == buffer_mappings.end(),
+    ASSERT(object->status == nvmap::Object::Status::Allocated);
-               "Offset is already mapped");
+    const auto physical_address{object->addr + params.buffer_offset};
+    u64 size{params.mapping_size};
+    if (!size) {
+        size = object->size;
+    }
-    BufferMapping mapping{};
+    const bool is_alloc{(params.flags & AddressSpaceFlags::FixedOffset) == AddressSpaceFlags::None};
-    mapping.nvmap_handle = params.nvmap_handle;
+    if (is_alloc) {
-    mapping.offset = params.offset;
+        params.offset = gpu.MemoryManager().MapAllocate(physical_address, size, page_size);
-    mapping.size = object->size;
+    } else {
+        params.offset = gpu.MemoryManager().Map(physical_address, params.offset, size);
+    }
-    buffer_mappings[params.offset] = mapping;
+    auto result{NvErrCodes::Success};
+    if (!params.offset) {
+        LOG_CRITICAL(Service_NVDRV, "failed to map size={}", size);
+        result = NvErrCodes::InvalidInput;
+    } else {
+        AddBufferMap(params.offset, size, physical_address, is_alloc);
+    }
    std::memcpy(output.data(), &params, output.size());
-    return 0;
+    return result;
 }
 u32 nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
@@ -172,24 +215,20 @@ u32 nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& ou
    LOG_DEBUG(Service_NVDRV, "called, offset=0x{:X}", params.offset);
-    const auto itr = buffer_mappings.find(params.offset);
+    if (const auto size{RemoveBufferMap(params.offset)}; size) {
-    if (itr == buffer_mappings.end()) {
+        system.GPU().MemoryManager().Unmap(params.offset, *size);
-        LOG_WARNING(Service_NVDRV, "Tried to unmap an invalid offset 0x{:X}", params.offset);
+    } else {
-        // Hardware tests shows that unmapping an already unmapped buffer always returns successful
+        LOG_ERROR(Service_NVDRV, "invalid offset=0x{:X}", params.offset);
-        // and doesn't fail.
-        return 0;
    }
-    params.offset = system.GPU().MemoryManager().UnmapBuffer(params.offset, itr->second.size);
-    buffer_mappings.erase(itr->second.offset);
    std::memcpy(output.data(), &params, output.size());
-    return 0;
+    return NvErrCodes::Success;
 }
 u32 nvhost_as_gpu::BindChannel(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlBindChannel params{};
    std::memcpy(&params, input.data(), input.size());
    LOG_DEBUG(Service_NVDRV, "called, fd={:X}", params.fd);
    channel = params.fd;
@@ -199,6 +238,7 @@ u32 nvhost_as_gpu::BindChannel(const std::vector<u8>& input, std::vector<u8>& ou
 u32 nvhost_as_gpu::GetVARegions(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlGetVaRegions params{};
    std::memcpy(&params, input.data(), input.size());
    LOG_WARNING(Service_NVDRV, "(STUBBED) called, buf_addr={:X}, buf_size={:X}", params.buf_addr,
                params.buf_size);
@@ -210,9 +250,43 @@ u32 nvhost_as_gpu::GetVARegions(const std::vector<u8>& input, std::vector<u8>& o
    params.regions[1].offset = 0x04000000;
    params.regions[1].page_size = 0x10000;
    params.regions[1].pages = 0x1bffff;
    // TODO(ogniK): This probably can stay stubbed but should add support way way later
    std::memcpy(output.data(), &params, output.size());
    return 0;
 }
+std::optional<nvhost_as_gpu::BufferMap> nvhost_as_gpu::FindBufferMap(GPUVAddr gpu_addr) const {
+    const auto end{buffer_mappings.upper_bound(gpu_addr)};
+    for (auto iter{buffer_mappings.begin()}; iter != end; ++iter) {
+        if (gpu_addr >= iter->second.StartAddr() && gpu_addr < iter->second.EndAddr()) {
+            return iter->second;
+        }
+    }
+    return {};
+}
+void nvhost_as_gpu::AddBufferMap(GPUVAddr gpu_addr, std::size_t size, VAddr cpu_addr,
+                                 bool is_allocated) {
+    buffer_mappings[gpu_addr] = {gpu_addr, size, cpu_addr, is_allocated};
+}
+std::optional<std::size_t> nvhost_as_gpu::RemoveBufferMap(GPUVAddr gpu_addr) {
+    if (const auto iter{buffer_mappings.find(gpu_addr)}; iter != buffer_mappings.end()) {
+        std::size_t size{};
+        if (iter->second.IsAllocated()) {
+            size = iter->second.Size();
+        }
+        buffer_mappings.erase(iter);
+        return size;
+    }
+    return {};
+}
 } // namespace Service::Nvidia::Devices
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h
index f79fcc065..9a0cdff0c 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h
+++ b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h
@@ -4,9 +4,12 @@
 #pragma once
+#include <map>
 #include <memory>
-#include <unordered_map>
+#include <optional>
 #include <vector>
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
@@ -15,6 +18,13 @@ namespace Service::Nvidia::Devices {
 class nvmap;
+enum class AddressSpaceFlags : u32 {
+    None = 0x0,
+    FixedOffset = 0x1,
+    Remap = 0x100,
+};
+DECLARE_ENUM_FLAG_OPERATORS(AddressSpaceFlags);
 class nvhost_as_gpu final : public nvdevice {
 public:
    explicit nvhost_as_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
@@ -25,6 +35,45 @@ public:
              IoctlVersion version) override;
 private:
+    class BufferMap final {
+    public:
+        constexpr BufferMap() = default;
+        constexpr BufferMap(GPUVAddr start_addr, std::size_t size)
+            : start_addr{start_addr}, end_addr{start_addr + size} {}
+        constexpr BufferMap(GPUVAddr start_addr, std::size_t size, VAddr cpu_addr,
+                            bool is_allocated)
+            : start_addr{start_addr}, end_addr{start_addr + size}, cpu_addr{cpu_addr},
+              is_allocated{is_allocated} {}
+        constexpr VAddr StartAddr() const {
+            return start_addr;
+        }
+        constexpr VAddr EndAddr() const {
+            return end_addr;
+        }
+        constexpr std::size_t Size() const {
+            return end_addr - start_addr;
+        }
+        constexpr VAddr CpuAddr() const {
+            return cpu_addr;
+        }
+        constexpr bool IsAllocated() const {
+            return is_allocated;
+        }
+    private:
+        GPUVAddr start_addr{};
+        GPUVAddr end_addr{};
+        VAddr cpu_addr{};
+        bool is_allocated{};
+    };
    enum class IoctlCommand : u32_le {
        IocInitalizeExCommand = 0x40284109,
        IocAllocateSpaceCommand = 0xC0184102,
@@ -49,7 +98,7 @@ private:
    struct IoctlAllocSpace {
        u32_le pages;
        u32_le page_size;
-        u32_le flags;
+        AddressSpaceFlags flags;
        INSERT_PADDING_WORDS(1);
        union {
            u64_le offset;
@@ -69,18 +118,18 @@ private:
    static_assert(sizeof(IoctlRemapEntry) == 20, "IoctlRemapEntry is incorrect size");
    struct IoctlMapBufferEx {
-        u32_le flags; // bit0: fixed_offset, bit2: cacheable
+        AddressSpaceFlags flags; // bit0: fixed_offset, bit2: cacheable
-        u32_le kind;  // -1 is default
+        u32_le kind;             // -1 is default
        u32_le nvmap_handle;
        u32_le page_size; // 0 means don't care
-        u64_le buffer_offset;
+        s64_le buffer_offset;
        u64_le mapping_size;
-        u64_le offset;
+        s64_le offset;
    };
    static_assert(sizeof(IoctlMapBufferEx) == 40, "IoctlMapBufferEx is incorrect size");
    struct IoctlUnmapBuffer {
-        u64_le offset;
+        s64_le offset;
    };
    static_assert(sizeof(IoctlUnmapBuffer) == 8, "IoctlUnmapBuffer is incorrect size");
@@ -106,15 +155,6 @@ private:
    static_assert(sizeof(IoctlGetVaRegions) == 16 + sizeof(IoctlVaRegion) * 2,
                  "IoctlGetVaRegions is incorrect size");
-    struct BufferMapping {
-        u64 offset;
-        u64 size;
-        u32 nvmap_handle;
-    };
-    /// Map containing the nvmap object mappings in GPU memory.
-    std::unordered_map<u64, BufferMapping> buffer_mappings;
    u32 channel{};
    u32 InitalizeEx(const std::vector<u8>& input, std::vector<u8>& output);
@@ -125,7 +165,14 @@ private:
    u32 BindChannel(const std::vector<u8>& input, std::vector<u8>& output);
    u32 GetVARegions(const std::vector<u8>& input, std::vector<u8>& output);
+    std::optional<BufferMap> FindBufferMap(GPUVAddr gpu_addr) const;
+    void AddBufferMap(GPUVAddr gpu_addr, std::size_t size, VAddr cpu_addr, bool is_allocated);
+    std::optional<std::size_t> RemoveBufferMap(GPUVAddr gpu_addr);
    std::shared_ptr<nvmap> nvmap_dev;
+    // This is expected to be ordered, therefore we must use a map, not unordered_map
+    std::map<GPUVAddr, BufferMap> buffer_mappings;
 };
 } // namespace Service::Nvidia::Devices
diff --git a/src/core/hle/service/nvdrv/devices/nvmap.cpp b/src/core/hle/service/nvdrv/devices/nvmap.cpp
index 8c742316c..9436e16ad 100644
--- a/src/core/hle/service/nvdrv/devices/nvmap.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvmap.cpp
@@ -18,7 +18,12 @@ enum {
 };
 }
-nvmap::nvmap(Core::System& system) : nvdevice(system) {}
+nvmap::nvmap(Core::System& system) : nvdevice(system) {
+    // Handle 0 appears to be used when remapping, so we create a placeholder empty nvmap object to
+    // represent this.
+    CreateObject(0);
+}
 nvmap::~nvmap() = default;
 VAddr nvmap::GetObjectAddress(u32 handle) const {
@@ -50,6 +55,21 @@ u32 nvmap::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<
    return 0;
 }
+u32 nvmap::CreateObject(u32 size) {
+    // Create a new nvmap object and obtain a handle to it.
+    auto object = std::make_shared<Object>();
+    object->id = next_id++;
+    object->size = size;
+    object->status = Object::Status::Created;
+    object->refcount = 1;
+    const u32 handle = next_handle++;
+    handles.insert_or_assign(handle, std::move(object));
+    return handle;
+}
 u32 nvmap::IocCreate(const std::vector<u8>& input, std::vector<u8>& output) {
    IocCreateParams params;
    std::memcpy(&params, input.data(), sizeof(params));
@@ -59,17 +79,8 @@ u32 nvmap::IocCreate(const std::vector<u8>& input, std::vector<u8>& output) {
        LOG_ERROR(Service_NVDRV, "Size is 0");
        return static_cast<u32>(NvErrCodes::InvalidValue);
    }
-    // Create a new nvmap object and obtain a handle to it.
-    auto object = std::make_shared<Object>();
-    object->id = next_id++;
-    object->size = params.size;
-    object->status = Object::Status::Created;
-    object->refcount = 1;
-    u32 handle = next_handle++;
-    handles[handle] = std::move(object);
-    params.handle = handle;
+    params.handle = CreateObject(params.size);
    std::memcpy(output.data(), &params, sizeof(params));
    return 0;
diff --git a/src/core/hle/service/nvdrv/devices/nvmap.h b/src/core/hle/service/nvdrv/devices/nvmap.h
index 73c2e8809..84624be00 100644
--- a/src/core/hle/service/nvdrv/devices/nvmap.h
+++ b/src/core/hle/service/nvdrv/devices/nvmap.h
@@ -49,10 +49,10 @@ public:
 private:
    /// Id to use for the next handle that is created.
-    u32 next_handle = 1;
+    u32 next_handle = 0;
    /// Id to use for the next object that is created.
-    u32 next_id = 1;
+    u32 next_id = 0;
    /// Mapping of currently allocated handles to the objects they represent.
    std::unordered_map<u32, std::shared_ptr<Object>> handles;
@@ -119,6 +119,8 @@ private:
    };
    static_assert(sizeof(IocGetIdParams) == 8, "IocGetIdParams has wrong size");
+    u32 CreateObject(u32 size);
    u32 IocCreate(const std::vector<u8>& input, std::vector<u8>& output);
    u32 IocAlloc(const std::vector<u8>& input, std::vector<u8>& output);
    u32 IocGetId(const std::vector<u8>& input, std::vector<u8>& output);
diff --git a/src/core/hle/service/nvdrv/interface.cpp b/src/core/hle/service/nvdrv/interface.cpp
index deaf0808b..88fbfa9b0 100644
--- a/src/core/hle/service/nvdrv/interface.cpp
+++ b/src/core/hle/service/nvdrv/interface.cpp
@@ -60,24 +60,24 @@ void NVDRV::IoctlBase(Kernel::HLERequestContext& ctx, IoctlVersion version) {
    if (ctrl.must_delay) {
        ctrl.fresh_call = false;
-        ctx.SleepClientThread("NVServices::DelayedResponse", ctrl.timeout,
+        ctx.SleepClientThread(
-                              [=](std::shared_ptr<Kernel::Thread> thread,
+            "NVServices::DelayedResponse", ctrl.timeout,
-                                  Kernel::HLERequestContext& ctx,
+            [=, this](std::shared_ptr<Kernel::Thread> thread, Kernel::HLERequestContext& ctx_,
-                                  Kernel::ThreadWakeupReason reason) {
+                      Kernel::ThreadWakeupReason reason) {
-                                  IoctlCtrl ctrl2{ctrl};
+                IoctlCtrl ctrl2{ctrl};
-                                  std::vector<u8> tmp_output = output;
+                std::vector<u8> tmp_output = output;
-                                  std::vector<u8> tmp_output2 = output2;
+                std::vector<u8> tmp_output2 = output2;
-                                  u32 result = nvdrv->Ioctl(fd, command, input, input2, tmp_output,
+                const u32 ioctl_result = nvdrv->Ioctl(fd, command, input, input2, tmp_output,
-                                                            tmp_output2, ctrl2, version);
+                                                      tmp_output2, ctrl2, version);
-                                  ctx.WriteBuffer(tmp_output, 0);
+                ctx_.WriteBuffer(tmp_output, 0);
-                                  if (version == IoctlVersion::Version3) {
+                if (version == IoctlVersion::Version3) {
-                                      ctx.WriteBuffer(tmp_output2, 1);
+                    ctx_.WriteBuffer(tmp_output2, 1);
-                                  }
+                }
-                                  IPC::ResponseBuilder rb{ctx, 3};
+                IPC::ResponseBuilder rb{ctx_, 3};
-                                  rb.Push(RESULT_SUCCESS);
+                rb.Push(RESULT_SUCCESS);
-                                  rb.Push(result);
+                rb.Push(ioctl_result);
-                              },
+            },
-                              nvdrv->GetEventWriteable(ctrl.event_id));
+            nvdrv->GetEventWriteable(ctrl.event_id));
    } else {
        ctx.WriteBuffer(output);
        if (version == IoctlVersion::Version3) {
diff --git a/src/core/hle/service/nvflinger/buffer_queue.cpp b/src/core/hle/service/nvflinger/buffer_queue.cpp
index caca80dde..637b310d7 100644
--- a/src/core/hle/service/nvflinger/buffer_queue.cpp
+++ b/src/core/hle/service/nvflinger/buffer_queue.cpp
@@ -24,13 +24,13 @@ BufferQueue::~BufferQueue() = default;
 void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer) {
    LOG_WARNING(Service, "Adding graphics buffer {}", slot);
-    Buffer buffer{};
-    buffer.slot = slot;
-    buffer.igbp_buffer = igbp_buffer;
-    buffer.status = Buffer::Status::Free;
    free_buffers.push_back(slot);
+    queue.push_back({
+        .slot = slot,
+        .status = Buffer::Status::Free,
+        .igbp_buffer = igbp_buffer,
+    });
-    queue.emplace_back(buffer);
    buffer_wait_event.writable->Signal();
 }
@@ -38,7 +38,7 @@ std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> BufferQueue::Dequeue
                                                                                       u32 height) {
    if (free_buffers.empty()) {
-        return {};
+        return std::nullopt;
    }
    auto f_itr = free_buffers.begin();
@@ -69,7 +69,7 @@ std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> BufferQueue::Dequeue
    }
    if (itr == queue.end()) {
-        return {};
+        return std::nullopt;
    }
    itr->status = Buffer::Status::Dequeued;
@@ -103,14 +103,15 @@ std::optional<std::reference_wrapper<const BufferQueue::Buffer>> BufferQueue::Ac
    auto itr = queue.end();
    // Iterate to find a queued buffer matching the requested slot.
    while (itr == queue.end() && !queue_sequence.empty()) {
-        u32 slot = queue_sequence.front();
+        const u32 slot = queue_sequence.front();
        itr = std::find_if(queue.begin(), queue.end(), [&slot](const Buffer& buffer) {
            return buffer.status == Buffer::Status::Queued && buffer.slot == slot;
        });
        queue_sequence.pop_front();
    }
-    if (itr == queue.end())
+    if (itr == queue.end()) {
-        return {};
+        return std::nullopt;
+    }
    itr->status = Buffer::Status::Acquired;
    return *itr;
 }
diff --git a/src/core/hle/service/nvflinger/nvflinger.cpp b/src/core/hle/service/nvflinger/nvflinger.cpp
index 789856118..f644a460d 100644
--- a/src/core/hle/service/nvflinger/nvflinger.cpp
+++ b/src/core/hle/service/nvflinger/nvflinger.cpp
@@ -67,8 +67,8 @@ NVFlinger::NVFlinger(Core::System& system) : system(system) {
    // Schedule the screen composition events
    composition_event = Core::Timing::CreateEvent(
-        "ScreenComposition", [this](u64, std::chrono::nanoseconds ns_late) {
+        "ScreenComposition", [this](std::uintptr_t, std::chrono::nanoseconds ns_late) {
-            Lock();
+            const auto guard = Lock();
            Compose();
            const auto ticks = std::chrono::nanoseconds{GetNextTicks()};
diff --git a/src/core/hle/service/nvflinger/nvflinger.h b/src/core/hle/service/nvflinger/nvflinger.h
index e4959a9af..1ebe949c0 100644
--- a/src/core/hle/service/nvflinger/nvflinger.h
+++ b/src/core/hle/service/nvflinger/nvflinger.h
@@ -54,12 +54,12 @@ public:
    /// Opens the specified display and returns the ID.
    ///
    /// If an invalid display name is provided, then an empty optional is returned.
-    std::optional<u64> OpenDisplay(std::string_view name);
+    [[nodiscard]] std::optional<u64> OpenDisplay(std::string_view name);
    /// Creates a layer on the specified display and returns the layer ID.
    ///
    /// If an invalid display ID is specified, then an empty optional is returned.
-    std::optional<u64> CreateLayer(u64 display_id);
+    [[nodiscard]] std::optional<u64> CreateLayer(u64 display_id);
    /// Closes a layer on all displays for the given layer ID.
    void CloseLayer(u64 layer_id);
@@ -67,41 +67,41 @@ public:
    /// Finds the buffer queue ID of the specified layer in the specified display.
    ///
    /// If an invalid display ID or layer ID is provided, then an empty optional is returned.
-    std::optional<u32> FindBufferQueueId(u64 display_id, u64 layer_id) const;
+    [[nodiscard]] std::optional<u32> FindBufferQueueId(u64 display_id, u64 layer_id) const;
    /// Gets the vsync event for the specified display.
    ///
    /// If an invalid display ID is provided, then nullptr is returned.
-    std::shared_ptr<Kernel::ReadableEvent> FindVsyncEvent(u64 display_id) const;
+    [[nodiscard]] std::shared_ptr<Kernel::ReadableEvent> FindVsyncEvent(u64 display_id) const;
    /// Obtains a buffer queue identified by the ID.
-    BufferQueue& FindBufferQueue(u32 id);
+    [[nodiscard]] BufferQueue& FindBufferQueue(u32 id);
    /// Obtains a buffer queue identified by the ID.
-    const BufferQueue& FindBufferQueue(u32 id) const;
+    [[nodiscard]] const BufferQueue& FindBufferQueue(u32 id) const;
    /// Performs a composition request to the emulated nvidia GPU and triggers the vsync events when
    /// finished.
    void Compose();
-    s64 GetNextTicks() const;
+    [[nodiscard]] s64 GetNextTicks() const;
-    std::unique_lock<std::mutex> Lock() {
+    [[nodiscard]] std::unique_lock<std::mutex> Lock() const {
        return std::unique_lock{*guard};
    }
 private:
    /// Finds the display identified by the specified ID.
-    VI::Display* FindDisplay(u64 display_id);
+    [[nodiscard]] VI::Display* FindDisplay(u64 display_id);
    /// Finds the display identified by the specified ID.
-    const VI::Display* FindDisplay(u64 display_id) const;
+    [[nodiscard]] const VI::Display* FindDisplay(u64 display_id) const;
    /// Finds the layer identified by the specified ID in the desired display.
-    VI::Layer* FindLayer(u64 display_id, u64 layer_id);
+    [[nodiscard]] VI::Layer* FindLayer(u64 display_id, u64 layer_id);
    /// Finds the layer identified by the specified ID in the desired display.
-    const VI::Layer* FindLayer(u64 display_id, u64 layer_id) const;
+    [[nodiscard]] const VI::Layer* FindLayer(u64 display_id, u64 layer_id) const;
    static void VSyncThread(NVFlinger& nv_flinger);
diff --git a/src/core/hle/service/set/set.cpp b/src/core/hle/service/set/set.cpp
index 34fe2fd82..e64777668 100644
--- a/src/core/hle/service/set/set.cpp
+++ b/src/core/hle/service/set/set.cpp
@@ -106,7 +106,7 @@ void GetKeyCodeMapImpl(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    ctx.WriteBuffer(&layout, sizeof(KeyboardLayout));
+    ctx.WriteBuffer(layout);
 }
 } // Anonymous namespace
diff --git a/src/core/hle/service/sm/sm.h b/src/core/hle/service/sm/sm.h
index b06d2f103..aabf166b7 100644
--- a/src/core/hle/service/sm/sm.h
+++ b/src/core/hle/service/sm/sm.h
@@ -9,6 +9,7 @@
 #include <type_traits>
 #include <unordered_map>
+#include "common/concepts.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/server_port.h"
@@ -56,10 +57,8 @@ public:
    ResultVal<std::shared_ptr<Kernel::ClientPort>> GetServicePort(const std::string& name);
    ResultVal<std::shared_ptr<Kernel::ClientSession>> ConnectToService(const std::string& name);
-    template <typename T>
+    template <Common::DerivedFrom<Kernel::SessionRequestHandler> T>
    std::shared_ptr<T> GetService(const std::string& service_name) const {
-        static_assert(std::is_base_of_v<Kernel::SessionRequestHandler, T>,
-                      "Not a base of ServiceFrameworkBase");
        auto service = registered_services.find(service_name);
        if (service == registered_services.end()) {
            LOG_DEBUG(Service, "Can't find service: {}", service_name);
diff --git a/src/core/hle/service/time/time.cpp b/src/core/hle/service/time/time.cpp
index 13e4b3818..ee4fa4b48 100644
--- a/src/core/hle/service/time/time.cpp
+++ b/src/core/hle/service/time/time.cpp
@@ -290,7 +290,7 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    ctx.WriteBuffer(&clock_snapshot, sizeof(Clock::ClockSnapshot));
+    ctx.WriteBuffer(clock_snapshot);
 }
 void Module::Interface::GetClockSnapshotFromSystemClockContext(Kernel::HLERequestContext& ctx) {
@@ -313,7 +313,7 @@ void Module::Interface::GetClockSnapshotFromSystemClockContext(Kernel::HLEReques
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    ctx.WriteBuffer(&clock_snapshot, sizeof(Clock::ClockSnapshot));
+    ctx.WriteBuffer(clock_snapshot);
 }
 void Module::Interface::CalculateStandardUserSystemClockDifferenceByUser(
diff --git a/src/core/hle/service/time/time_zone_content_manager.cpp b/src/core/hle/service/time/time_zone_content_manager.cpp
index c070d6e97..320672add 100644
--- a/src/core/hle/service/time/time_zone_content_manager.cpp
+++ b/src/core/hle/service/time/time_zone_content_manager.cpp
@@ -73,10 +73,8 @@ TimeZoneContentManager::TimeZoneContentManager(TimeManager& time_manager, Core::
    std::string location_name;
    const auto timezone_setting = Settings::GetTimeZoneString();
-    if (timezone_setting == "auto") {
+    if (timezone_setting == "auto" || timezone_setting == "default") {
        location_name = Common::TimeZone::GetDefaultTimeZone();
-    } else if (timezone_setting == "default") {
-        location_name = location_name;
    } else {
        location_name = timezone_setting;
    }
diff --git a/src/core/hle/service/time/time_zone_service.cpp b/src/core/hle/service/time/time_zone_service.cpp
index db57ae069..ff3a10b3e 100644
--- a/src/core/hle/service/time/time_zone_service.cpp
+++ b/src/core/hle/service/time/time_zone_service.cpp
@@ -142,7 +142,7 @@ void ITimeZoneService::ToPosixTime(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.PushRaw<u32>(1); // Number of times we're returning
-    ctx.WriteBuffer(&posix_time, sizeof(s64));
+    ctx.WriteBuffer(posix_time);
 }
 void ITimeZoneService::ToPosixTimeWithMyRule(Kernel::HLERequestContext& ctx) {
@@ -164,7 +164,7 @@ void ITimeZoneService::ToPosixTimeWithMyRule(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.PushRaw<u32>(1); // Number of times we're returning
-    ctx.WriteBuffer(&posix_time, sizeof(s64));
+    ctx.WriteBuffer(posix_time);
 }
 } // namespace Service::Time
diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp
index ea7b4ae13..480d34725 100644
--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -511,7 +511,7 @@ private:
        LOG_DEBUG(Service_VI, "called. id=0x{:08X} transaction={:X}, flags=0x{:08X}", id,
                  static_cast<u32>(transaction), flags);
-        nv_flinger->Lock();
+        const auto guard = nv_flinger->Lock();
        auto& buffer_queue = nv_flinger->FindBufferQueue(id);
        switch (transaction) {
@@ -548,10 +548,10 @@ private:
                // Wait the current thread until a buffer becomes available
                ctx.SleepClientThread(
                    "IHOSBinderDriver::DequeueBuffer", UINT64_MAX,
-                    [=](std::shared_ptr<Kernel::Thread> thread, Kernel::HLERequestContext& ctx,
+                    [=, this](std::shared_ptr<Kernel::Thread> thread,
-                        Kernel::ThreadWakeupReason reason) {
+                              Kernel::HLERequestContext& ctx, Kernel::ThreadWakeupReason reason) {
                        // Repeat TransactParcel DequeueBuffer when a buffer is available
-                        nv_flinger->Lock();
+                        const auto guard = nv_flinger->Lock();
                        auto& buffer_queue = nv_flinger->FindBufferQueue(id);
                        auto result = buffer_queue.DequeueBuffer(width, height);
                        ASSERT_MSG(result != std::nullopt, "Could not dequeue buffer.");
@@ -1199,6 +1199,23 @@ private:
        }
    }
+    void GetIndirectLayerImageRequiredMemoryInfo(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto width = rp.Pop<u64>();
+        const auto height = rp.Pop<u64>();
+        LOG_DEBUG(Service_VI, "called width={}, height={}", width, height);
+        constexpr std::size_t base_size = 0x20000;
+        constexpr std::size_t alignment = 0x1000;
+        const auto texture_size = width * height * 4;
+        const auto out_size = (texture_size + base_size - 1) / base_size * base_size;
+        IPC::ResponseBuilder rb{ctx, 6};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(out_size);
+        rb.Push(alignment);
+    }
    static ResultVal<ConvertedScaleMode> ConvertScalingModeImpl(NintendoScaleMode mode) {
        switch (mode) {
        case NintendoScaleMode::None:
@@ -1243,7 +1260,8 @@ IApplicationDisplayService::IApplicationDisplayService(
        {2102, &IApplicationDisplayService::ConvertScalingMode, "ConvertScalingMode"},
        {2450, nullptr, "GetIndirectLayerImageMap"},
        {2451, nullptr, "GetIndirectLayerImageCropMap"},
-        {2460, nullptr, "GetIndirectLayerImageRequiredMemoryInfo"},
+        {2460, &IApplicationDisplayService::GetIndirectLayerImageRequiredMemoryInfo,
+         "GetIndirectLayerImageRequiredMemoryInfo"},
        {5202, &IApplicationDisplayService::GetDisplayVsyncEvent, "GetDisplayVsyncEvent"},
        {5203, nullptr, "GetDisplayVsyncEventForDebug"},
    };
diff --git a/src/core/loader/loader.cpp b/src/core/loader/loader.cpp
index 59ca7091a..7c48e55e1 100644
--- a/src/core/loader/loader.cpp
+++ b/src/core/loader/loader.cpp
@@ -3,8 +3,10 @@
 // Refer to the license.txt file included.
 #include <memory>
+#include <optional>
 #include <ostream>
 #include <string>
+#include "common/concepts.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
@@ -21,27 +23,41 @@
 namespace Loader {
-FileType IdentifyFile(FileSys::VirtualFile file) {
+namespace {
-    FileType type;
-#define CHECK_TYPE(loader)                                                                         \
-    type = AppLoader_##loader::IdentifyType(file);                                                 \
-    if (FileType::Error != type)                                                                   \
-        return type;
-    CHECK_TYPE(DeconstructedRomDirectory)
+template <Common::DerivedFrom<AppLoader> T>
-    CHECK_TYPE(ELF)
+std::optional<FileType> IdentifyFileLoader(FileSys::VirtualFile file) {
-    CHECK_TYPE(NSO)
+    const auto file_type = T::IdentifyType(file);
-    CHECK_TYPE(NRO)
+    if (file_type != FileType::Error) {
-    CHECK_TYPE(NCA)
+        return file_type;
-    CHECK_TYPE(XCI)
+    }
-    CHECK_TYPE(NAX)
+    return std::nullopt;
-    CHECK_TYPE(NSP)
+}
-    CHECK_TYPE(KIP)
-#undef CHECK_TYPE
+} // namespace
-    return FileType::Unknown;
+FileType IdentifyFile(FileSys::VirtualFile file) {
+    if (const auto romdir_type = IdentifyFileLoader<AppLoader_DeconstructedRomDirectory>(file)) {
+        return *romdir_type;
+    } else if (const auto elf_type = IdentifyFileLoader<AppLoader_ELF>(file)) {
+        return *elf_type;
+    } else if (const auto nso_type = IdentifyFileLoader<AppLoader_NSO>(file)) {
+        return *nso_type;
+    } else if (const auto nro_type = IdentifyFileLoader<AppLoader_NRO>(file)) {
+        return *nro_type;
+    } else if (const auto nca_type = IdentifyFileLoader<AppLoader_NCA>(file)) {
+        return *nca_type;
+    } else if (const auto xci_type = IdentifyFileLoader<AppLoader_XCI>(file)) {
+        return *xci_type;
+    } else if (const auto nax_type = IdentifyFileLoader<AppLoader_NAX>(file)) {
+        return *nax_type;
+    } else if (const auto nsp_type = IdentifyFileLoader<AppLoader_NSP>(file)) {
+        return *nsp_type;
+    } else if (const auto kip_type = IdentifyFileLoader<AppLoader_KIP>(file)) {
+        return *kip_type;
+    } else {
+        return FileType::Unknown;
+    }
 }
 FileType GuessFromFilename(const std::string& name) {
diff --git a/src/core/memory.cpp b/src/core/memory.cpp
index 2c5588933..86d17c6cb 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -704,7 +704,7 @@ struct Memory::Impl {
        u8* page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS];
        if (page_pointer != nullptr) {
            // NOTE: Avoid adding any extra logic to this fast-path block
-            T volatile* pointer = reinterpret_cast<T volatile*>(&page_pointer[vaddr]);
+            auto* pointer = reinterpret_cast<volatile T*>(&page_pointer[vaddr]);
            return Common::AtomicCompareAndSwap(pointer, data, expected);
        }
@@ -720,9 +720,8 @@ struct Memory::Impl {
        case Common::PageType::RasterizerCachedMemory: {
            u8* host_ptr{GetPointerFromRasterizerCachedMemory(vaddr)};
            system.GPU().InvalidateRegion(vaddr, sizeof(T));
-            T volatile* pointer = reinterpret_cast<T volatile*>(&host_ptr);
+            auto* pointer = reinterpret_cast<volatile T*>(&host_ptr);
            return Common::AtomicCompareAndSwap(pointer, data, expected);
-            break;
        }
        default:
            UNREACHABLE();
@@ -734,7 +733,7 @@ struct Memory::Impl {
        u8* const page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS];
        if (page_pointer != nullptr) {
            // NOTE: Avoid adding any extra logic to this fast-path block
-            u64 volatile* pointer = reinterpret_cast<u64 volatile*>(&page_pointer[vaddr]);
+            auto* pointer = reinterpret_cast<volatile u64*>(&page_pointer[vaddr]);
            return Common::AtomicCompareAndSwap(pointer, data, expected);
        }
@@ -750,9 +749,8 @@ struct Memory::Impl {
        case Common::PageType::RasterizerCachedMemory: {
            u8* host_ptr{GetPointerFromRasterizerCachedMemory(vaddr)};
            system.GPU().InvalidateRegion(vaddr, sizeof(u128));
-            u64 volatile* pointer = reinterpret_cast<u64 volatile*>(&host_ptr);
+            auto* pointer = reinterpret_cast<volatile u64*>(&host_ptr);
            return Common::AtomicCompareAndSwap(pointer, data, expected);
-            break;
        }
        default:
            UNREACHABLE();
diff --git a/src/core/memory/cheat_engine.cpp b/src/core/memory/cheat_engine.cpp
index ced41b1fe..e503118dd 100644
--- a/src/core/memory/cheat_engine.cpp
+++ b/src/core/memory/cheat_engine.cpp
@@ -42,7 +42,7 @@ u64 StandardVmCallbacks::HidKeysDown() {
    if (applet_resource == nullptr) {
        LOG_WARNING(CheatEngine,
                    "Attempted to read input state, but applet resource is not initialized!");
-        return false;
+        return 0;
    }
    const auto press_state =
@@ -188,28 +188,40 @@ CheatEngine::~CheatEngine() {
 }
 void CheatEngine::Initialize() {
-    event = Core::Timing::CreateEvent("CheatEngine::FrameCallback::" +
+    event = Core::Timing::CreateEvent(
-                                          Common::HexToString(metadata.main_nso_build_id),
+        "CheatEngine::FrameCallback::" + Common::HexToString(metadata.main_nso_build_id),
-                                      [this](u64 userdata, std::chrono::nanoseconds ns_late) {
+        [this](std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
-                                          FrameCallback(userdata, ns_late);
+            FrameCallback(user_data, ns_late);
-                                      });
+        });
    core_timing.ScheduleEvent(CHEAT_ENGINE_NS, event);
    metadata.process_id = system.CurrentProcess()->GetProcessID();
    metadata.title_id = system.CurrentProcess()->GetTitleID();
    const auto& page_table = system.CurrentProcess()->PageTable();
-    metadata.heap_extents = {page_table.GetHeapRegionStart(), page_table.GetHeapRegionSize()};
+    metadata.heap_extents = {
-    metadata.address_space_extents = {page_table.GetAddressSpaceStart(),
+        .base = page_table.GetHeapRegionStart(),
-                                      page_table.GetAddressSpaceSize()};
+        .size = page_table.GetHeapRegionSize(),
-    metadata.alias_extents = {page_table.GetAliasCodeRegionStart(),
+    };
-                              page_table.GetAliasCodeRegionSize()};
+    metadata.address_space_extents = {
+        .base = page_table.GetAddressSpaceStart(),
+        .size = page_table.GetAddressSpaceSize(),
+    };
+    metadata.alias_extents = {
+        .base = page_table.GetAliasCodeRegionStart(),
+        .size = page_table.GetAliasCodeRegionSize(),
+    };
    is_pending_reload.exchange(true);
 }
 void CheatEngine::SetMainMemoryParameters(VAddr main_region_begin, u64 main_region_size) {
-    metadata.main_nso_extents = {main_region_begin, main_region_size};
+    metadata.main_nso_extents = {
+        .base = main_region_begin,
+        .size = main_region_size,
+    };
 }
 void CheatEngine::Reload(std::vector<CheatEntry> cheats) {
@@ -219,7 +231,7 @@ void CheatEngine::Reload(std::vector<CheatEntry> cheats) {
 MICROPROFILE_DEFINE(Cheat_Engine, "Add-Ons", "Cheat Engine", MP_RGB(70, 200, 70));
-void CheatEngine::FrameCallback(u64, std::chrono::nanoseconds ns_late) {
+void CheatEngine::FrameCallback(std::uintptr_t, std::chrono::nanoseconds ns_late) {
    if (is_pending_reload.exchange(false)) {
        vm.LoadProgram(cheats);
    }
diff --git a/src/core/memory/cheat_engine.h b/src/core/memory/cheat_engine.h
index d4068cf84..fa039a831 100644
--- a/src/core/memory/cheat_engine.h
+++ b/src/core/memory/cheat_engine.h
@@ -72,7 +72,7 @@ public:
    void Reload(std::vector<CheatEntry> cheats);
 private:
-    void FrameCallback(u64 userdata, std::chrono::nanoseconds ns_late);
+    void FrameCallback(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
    DmntCheatVm vm;
    CheatProcessMetadata metadata;
diff --git a/src/core/memory/dmnt_cheat_vm.cpp b/src/core/memory/dmnt_cheat_vm.cpp
index 2e7da23fe..48be80c12 100644
--- a/src/core/memory/dmnt_cheat_vm.cpp
+++ b/src/core/memory/dmnt_cheat_vm.cpp
@@ -313,30 +313,32 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
    switch (opcode_type) {
    case CheatVmOpcodeType::StoreStatic: {
-        StoreStaticOpcode store_static{};
        // 0TMR00AA AAAAAAAA YYYYYYYY (YYYYYYYY)
        // Read additional words.
        const u32 second_dword = GetNextDword();
-        store_static.bit_width = (first_dword >> 24) & 0xF;
+        const u32 bit_width = (first_dword >> 24) & 0xF;
-        store_static.mem_type = static_cast<MemoryAccessType>((first_dword >> 20) & 0xF);
-        store_static.offset_register = ((first_dword >> 16) & 0xF);
+        opcode.opcode = StoreStaticOpcode{
-        store_static.rel_address =
+            .bit_width = bit_width,
-            (static_cast<u64>(first_dword & 0xFF) << 32ul) | static_cast<u64>(second_dword);
+            .mem_type = static_cast<MemoryAccessType>((first_dword >> 20) & 0xF),
-        store_static.value = GetNextVmInt(store_static.bit_width);
+            .offset_register = (first_dword >> 16) & 0xF,
-        opcode.opcode = store_static;
+            .rel_address = (static_cast<u64>(first_dword & 0xFF) << 32) | second_dword,
+            .value = GetNextVmInt(bit_width),
+        };
    } break;
    case CheatVmOpcodeType::BeginConditionalBlock: {
-        BeginConditionalOpcode begin_cond{};
        // 1TMC00AA AAAAAAAA YYYYYYYY (YYYYYYYY)
        // Read additional words.
        const u32 second_dword = GetNextDword();
-        begin_cond.bit_width = (first_dword >> 24) & 0xF;
+        const u32 bit_width = (first_dword >> 24) & 0xF;
-        begin_cond.mem_type = static_cast<MemoryAccessType>((first_dword >> 20) & 0xF);
-        begin_cond.cond_type = static_cast<ConditionalComparisonType>((first_dword >> 16) & 0xF);
+        opcode.opcode = BeginConditionalOpcode{
-        begin_cond.rel_address =
+            .bit_width = bit_width,
-            (static_cast<u64>(first_dword & 0xFF) << 32ul) | static_cast<u64>(second_dword);
+            .mem_type = static_cast<MemoryAccessType>((first_dword >> 20) & 0xF),
-        begin_cond.value = GetNextVmInt(begin_cond.bit_width);
+            .cond_type = static_cast<ConditionalComparisonType>((first_dword >> 16) & 0xF),
-        opcode.opcode = begin_cond;
+            .rel_address = (static_cast<u64>(first_dword & 0xFF) << 32) | second_dword,
+            .value = GetNextVmInt(bit_width),
+        };
    } break;
    case CheatVmOpcodeType::EndConditionalBlock: {
        // 20000000
@@ -344,12 +346,14 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
        opcode.opcode = EndConditionalOpcode{};
    } break;
    case CheatVmOpcodeType::ControlLoop: {
-        ControlLoopOpcode ctrl_loop{};
        // 300R0000 VVVVVVVV
        // 310R0000
        // Parse register, whether loop start or loop end.
-        ctrl_loop.start_loop = ((first_dword >> 24) & 0xF) == 0;
+        ControlLoopOpcode ctrl_loop{
-        ctrl_loop.reg_index = ((first_dword >> 20) & 0xF);
+            .start_loop = ((first_dword >> 24) & 0xF) == 0,
+            .reg_index = (first_dword >> 20) & 0xF,
+            .num_iters = 0,
+        };
        // Read number of iters if loop start.
        if (ctrl_loop.start_loop) {
@@ -358,66 +362,65 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
        opcode.opcode = ctrl_loop;
    } break;
    case CheatVmOpcodeType::LoadRegisterStatic: {
-        LoadRegisterStaticOpcode ldr_static{};
        // 400R0000 VVVVVVVV VVVVVVVV
        // Read additional words.
-        ldr_static.reg_index = ((first_dword >> 16) & 0xF);
+        opcode.opcode = LoadRegisterStaticOpcode{
-        ldr_static.value =
+            .reg_index = (first_dword >> 16) & 0xF,
-            (static_cast<u64>(GetNextDword()) << 32ul) | static_cast<u64>(GetNextDword());
+            .value = (static_cast<u64>(GetNextDword()) << 32) | GetNextDword(),
-        opcode.opcode = ldr_static;
+        };
    } break;
    case CheatVmOpcodeType::LoadRegisterMemory: {
-        LoadRegisterMemoryOpcode ldr_memory{};
        // 5TMRI0AA AAAAAAAA
        // Read additional words.
        const u32 second_dword = GetNextDword();
-        ldr_memory.bit_width = (first_dword >> 24) & 0xF;
+        opcode.opcode = LoadRegisterMemoryOpcode{
-        ldr_memory.mem_type = static_cast<MemoryAccessType>((first_dword >> 20) & 0xF);
+            .bit_width = (first_dword >> 24) & 0xF,
-        ldr_memory.reg_index = ((first_dword >> 16) & 0xF);
+            .mem_type = static_cast<MemoryAccessType>((first_dword >> 20) & 0xF),
-        ldr_memory.load_from_reg = ((first_dword >> 12) & 0xF) != 0;
+            .reg_index = ((first_dword >> 16) & 0xF),
-        ldr_memory.rel_address =
+            .load_from_reg = ((first_dword >> 12) & 0xF) != 0,
-            (static_cast<u64>(first_dword & 0xFF) << 32ul) | static_cast<u64>(second_dword);
+            .rel_address = (static_cast<u64>(first_dword & 0xFF) << 32) | second_dword,
-        opcode.opcode = ldr_memory;
+        };
    } break;
    case CheatVmOpcodeType::StoreStaticToAddress: {
-        StoreStaticToAddressOpcode str_static{};
        // 6T0RIor0 VVVVVVVV VVVVVVVV
        // Read additional words.
-        str_static.bit_width = (first_dword >> 24) & 0xF;
+        opcode.opcode = StoreStaticToAddressOpcode{
-        str_static.reg_index = ((first_dword >> 16) & 0xF);
+            .bit_width = (first_dword >> 24) & 0xF,
-        str_static.increment_reg = ((first_dword >> 12) & 0xF) != 0;
+            .reg_index = (first_dword >> 16) & 0xF,
-        str_static.add_offset_reg = ((first_dword >> 8) & 0xF) != 0;
+            .increment_reg = ((first_dword >> 12) & 0xF) != 0,
-        str_static.offset_reg_index = ((first_dword >> 4) & 0xF);
+            .add_offset_reg = ((first_dword >> 8) & 0xF) != 0,
-        str_static.value =
+            .offset_reg_index = (first_dword >> 4) & 0xF,
-            (static_cast<u64>(GetNextDword()) << 32ul) | static_cast<u64>(GetNextDword());
+            .value = (static_cast<u64>(GetNextDword()) << 32) | GetNextDword(),
-        opcode.opcode = str_static;
+        };
    } break;
    case CheatVmOpcodeType::PerformArithmeticStatic: {
-        PerformArithmeticStaticOpcode perform_math_static{};
        // 7T0RC000 VVVVVVVV
        // Read additional words.
-        perform_math_static.bit_width = (first_dword >> 24) & 0xF;
+        opcode.opcode = PerformArithmeticStaticOpcode{
-        perform_math_static.reg_index = ((first_dword >> 16) & 0xF);
+            .bit_width = (first_dword >> 24) & 0xF,
-        perform_math_static.math_type =
+            .reg_index = ((first_dword >> 16) & 0xF),
-            static_cast<RegisterArithmeticType>((first_dword >> 12) & 0xF);
+            .math_type = static_cast<RegisterArithmeticType>((first_dword >> 12) & 0xF),
-        perform_math_static.value = GetNextDword();
+            .value = GetNextDword(),
-        opcode.opcode = perform_math_static;
+        };
    } break;
    case CheatVmOpcodeType::BeginKeypressConditionalBlock: {
-        BeginKeypressConditionalOpcode begin_keypress_cond{};
        // 8kkkkkkk
        // Just parse the mask.
-        begin_keypress_cond.key_mask = first_dword & 0x0FFFFFFF;
+        opcode.opcode = BeginKeypressConditionalOpcode{
-        opcode.opcode = begin_keypress_cond;
+            .key_mask = first_dword & 0x0FFFFFFF,
+        };
    } break;
    case CheatVmOpcodeType::PerformArithmeticRegister: {
-        PerformArithmeticRegisterOpcode perform_math_reg{};
        // 9TCRSIs0 (VVVVVVVV (VVVVVVVV))
-        perform_math_reg.bit_width = (first_dword >> 24) & 0xF;
+        PerformArithmeticRegisterOpcode perform_math_reg{
-        perform_math_reg.math_type = static_cast<RegisterArithmeticType>((first_dword >> 20) & 0xF);
+            .bit_width = (first_dword >> 24) & 0xF,
-        perform_math_reg.dst_reg_index = ((first_dword >> 16) & 0xF);
+            .math_type = static_cast<RegisterArithmeticType>((first_dword >> 20) & 0xF),
-        perform_math_reg.src_reg_1_index = ((first_dword >> 12) & 0xF);
+            .dst_reg_index = (first_dword >> 16) & 0xF,
-        perform_math_reg.has_immediate = ((first_dword >> 8) & 0xF) != 0;
+            .src_reg_1_index = (first_dword >> 12) & 0xF,
+            .src_reg_2_index = 0,
+            .has_immediate = ((first_dword >> 8) & 0xF) != 0,
+            .value = {},
+        };
        if (perform_math_reg.has_immediate) {
            perform_math_reg.src_reg_2_index = 0;
            perform_math_reg.value = GetNextVmInt(perform_math_reg.bit_width);
@@ -427,7 +430,6 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
        opcode.opcode = perform_math_reg;
    } break;
    case CheatVmOpcodeType::StoreRegisterToAddress: {
-        StoreRegisterToAddressOpcode str_register{};
        // ATSRIOxa (aaaaaaaa)
        // A = opcode 10
        // T = bit width
@@ -439,20 +441,23 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
        //  Relative Address
        // x = offset register (for offset type 1), memory type (for offset type 3)
        // a = relative address (for offset type 2+3)
-        str_register.bit_width = (first_dword >> 24) & 0xF;
+        StoreRegisterToAddressOpcode str_register{
-        str_register.str_reg_index = ((first_dword >> 20) & 0xF);
+            .bit_width = (first_dword >> 24) & 0xF,
-        str_register.addr_reg_index = ((first_dword >> 16) & 0xF);
+            .str_reg_index = (first_dword >> 20) & 0xF,
-        str_register.increment_reg = ((first_dword >> 12) & 0xF) != 0;
+            .addr_reg_index = (first_dword >> 16) & 0xF,
-        str_register.ofs_type = static_cast<StoreRegisterOffsetType>(((first_dword >> 8) & 0xF));
+            .increment_reg = ((first_dword >> 12) & 0xF) != 0,
-        str_register.ofs_reg_index = ((first_dword >> 4) & 0xF);
+            .ofs_type = static_cast<StoreRegisterOffsetType>(((first_dword >> 8) & 0xF)),
+            .mem_type = MemoryAccessType::MainNso,
+            .ofs_reg_index = (first_dword >> 4) & 0xF,
+            .rel_address = 0,
+        };
        switch (str_register.ofs_type) {
        case StoreRegisterOffsetType::None:
        case StoreRegisterOffsetType::Reg:
            // Nothing more to do
            break;
        case StoreRegisterOffsetType::Imm:
-            str_register.rel_address =
+            str_register.rel_address = (static_cast<u64>(first_dword & 0xF) << 32) | GetNextDword();
-                ((static_cast<u64>(first_dword & 0xF) << 32ul) | static_cast<u64>(GetNextDword()));
            break;
        case StoreRegisterOffsetType::MemReg:
            str_register.mem_type = static_cast<MemoryAccessType>((first_dword >> 4) & 0xF);
@@ -460,8 +465,7 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
        case StoreRegisterOffsetType::MemImm:
        case StoreRegisterOffsetType::MemImmReg:
            str_register.mem_type = static_cast<MemoryAccessType>((first_dword >> 4) & 0xF);
-            str_register.rel_address =
+            str_register.rel_address = (static_cast<u64>(first_dword & 0xF) << 32) | GetNextDword();
-                ((static_cast<u64>(first_dword & 0xF) << 32ul) | static_cast<u64>(GetNextDword()));
            break;
        default:
            str_register.ofs_type = StoreRegisterOffsetType::None;
@@ -470,7 +474,6 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
        opcode.opcode = str_register;
    } break;
    case CheatVmOpcodeType::BeginRegisterConditionalBlock: {
-        BeginRegisterConditionalOpcode begin_reg_cond{};
        // C0TcSX##
        // C0TcS0Ma aaaaaaaa
        // C0TcS1Mr
@@ -492,11 +495,19 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
        // r = offset register.
        // X = other register.
        // V = value.
-        begin_reg_cond.bit_width = (first_dword >> 20) & 0xF;
-        begin_reg_cond.cond_type =
+        BeginRegisterConditionalOpcode begin_reg_cond{
-            static_cast<ConditionalComparisonType>((first_dword >> 16) & 0xF);
+            .bit_width = (first_dword >> 20) & 0xF,
-        begin_reg_cond.val_reg_index = ((first_dword >> 12) & 0xF);
+            .cond_type = static_cast<ConditionalComparisonType>((first_dword >> 16) & 0xF),
-        begin_reg_cond.comp_type = static_cast<CompareRegisterValueType>((first_dword >> 8) & 0xF);
+            .val_reg_index = (first_dword >> 12) & 0xF,
+            .comp_type = static_cast<CompareRegisterValueType>((first_dword >> 8) & 0xF),
+            .mem_type = MemoryAccessType::MainNso,
+            .addr_reg_index = 0,
+            .other_reg_index = 0,
+            .ofs_reg_index = 0,
+            .rel_address = 0,
+            .value = {},
+        };
        switch (begin_reg_cond.comp_type) {
        case CompareRegisterValueType::StaticValue:
@@ -508,26 +519,25 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
        case CompareRegisterValueType::MemoryRelAddr:
            begin_reg_cond.mem_type = static_cast<MemoryAccessType>((first_dword >> 4) & 0xF);
            begin_reg_cond.rel_address =
-                ((static_cast<u64>(first_dword & 0xF) << 32ul) | static_cast<u64>(GetNextDword()));
+                (static_cast<u64>(first_dword & 0xF) << 32) | GetNextDword();
            break;
        case CompareRegisterValueType::MemoryOfsReg:
            begin_reg_cond.mem_type = static_cast<MemoryAccessType>((first_dword >> 4) & 0xF);
            begin_reg_cond.ofs_reg_index = (first_dword & 0xF);
            break;
        case CompareRegisterValueType::RegisterRelAddr:
-            begin_reg_cond.addr_reg_index = ((first_dword >> 4) & 0xF);
+            begin_reg_cond.addr_reg_index = (first_dword >> 4) & 0xF;
            begin_reg_cond.rel_address =
-                ((static_cast<u64>(first_dword & 0xF) << 32ul) | static_cast<u64>(GetNextDword()));
+                (static_cast<u64>(first_dword & 0xF) << 32) | GetNextDword();
            break;
        case CompareRegisterValueType::RegisterOfsReg:
-            begin_reg_cond.addr_reg_index = ((first_dword >> 4) & 0xF);
+            begin_reg_cond.addr_reg_index = (first_dword >> 4) & 0xF;
-            begin_reg_cond.ofs_reg_index = (first_dword & 0xF);
+            begin_reg_cond.ofs_reg_index = first_dword & 0xF;
            break;
        }
        opcode.opcode = begin_reg_cond;
    } break;
    case CheatVmOpcodeType::SaveRestoreRegister: {
-        SaveRestoreRegisterOpcode save_restore_reg{};
        // C10D0Sx0
        // C1 = opcode 0xC1
        // D = destination index.
@@ -535,36 +545,37 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
        // x = 3 if clearing reg, 2 if clearing saved value, 1 if saving a register, 0 if restoring
        // a register.
        // NOTE: If we add more save slots later, current encoding is backwards compatible.
-        save_restore_reg.dst_index = (first_dword >> 16) & 0xF;
+        opcode.opcode = SaveRestoreRegisterOpcode{
-        save_restore_reg.src_index = (first_dword >> 8) & 0xF;
+            .dst_index = (first_dword >> 16) & 0xF,
-        save_restore_reg.op_type = static_cast<SaveRestoreRegisterOpType>((first_dword >> 4) & 0xF);
+            .src_index = (first_dword >> 8) & 0xF,
-        opcode.opcode = save_restore_reg;
+            .op_type = static_cast<SaveRestoreRegisterOpType>((first_dword >> 4) & 0xF),
+        };
    } break;
    case CheatVmOpcodeType::SaveRestoreRegisterMask: {
-        SaveRestoreRegisterMaskOpcode save_restore_regmask{};
        // C2x0XXXX
        // C2 = opcode 0xC2
        // x = 3 if clearing reg, 2 if clearing saved value, 1 if saving, 0 if restoring.
        // X = 16-bit bitmask, bit i --> save or restore register i.
-        save_restore_regmask.op_type =
+        SaveRestoreRegisterMaskOpcode save_restore_regmask{
-            static_cast<SaveRestoreRegisterOpType>((first_dword >> 20) & 0xF);
+            .op_type = static_cast<SaveRestoreRegisterOpType>((first_dword >> 20) & 0xF),
+            .should_operate = {},
+        };
        for (std::size_t i = 0; i < NumRegisters; i++) {
-            save_restore_regmask.should_operate[i] = (first_dword & (1u << i)) != 0;
+            save_restore_regmask.should_operate[i] = (first_dword & (1U << i)) != 0;
        }
        opcode.opcode = save_restore_regmask;
    } break;
    case CheatVmOpcodeType::ReadWriteStaticRegister: {
-        ReadWriteStaticRegisterOpcode rw_static_reg{};
        // C3000XXx
        // C3 = opcode 0xC3.
        // XX = static register index.
        // x  = register index.
-        rw_static_reg.static_idx = ((first_dword >> 4) & 0xFF);
+        opcode.opcode = ReadWriteStaticRegisterOpcode{
-        rw_static_reg.idx = (first_dword & 0xF);
+            .static_idx = (first_dword >> 4) & 0xFF,
-        opcode.opcode = rw_static_reg;
+            .idx = first_dword & 0xF,
+        };
    } break;
    case CheatVmOpcodeType::DebugLog: {
-        DebugLogOpcode debug_log{};
        // FFFTIX##
        // FFFTI0Ma aaaaaaaa
        // FFFTI1Mr
@@ -583,31 +594,36 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
        // a = relative address.
        // r = offset register.
        // X = value register.
-        debug_log.bit_width = (first_dword >> 16) & 0xF;
+        DebugLogOpcode debug_log{
-        debug_log.log_id = ((first_dword >> 12) & 0xF);
+            .bit_width = (first_dword >> 16) & 0xF,
-        debug_log.val_type = static_cast<DebugLogValueType>((first_dword >> 8) & 0xF);
+            .log_id = (first_dword >> 12) & 0xF,
+            .val_type = static_cast<DebugLogValueType>((first_dword >> 8) & 0xF),
+            .mem_type = MemoryAccessType::MainNso,
+            .addr_reg_index = 0,
+            .val_reg_index = 0,
+            .ofs_reg_index = 0,
+            .rel_address = 0,
+        };
        switch (debug_log.val_type) {
        case DebugLogValueType::RegisterValue:
-            debug_log.val_reg_index = ((first_dword >> 4) & 0xF);
+            debug_log.val_reg_index = (first_dword >> 4) & 0xF;
            break;
        case DebugLogValueType::MemoryRelAddr:
            debug_log.mem_type = static_cast<MemoryAccessType>((first_dword >> 4) & 0xF);
-            debug_log.rel_address =
+            debug_log.rel_address = (static_cast<u64>(first_dword & 0xF) << 32) | GetNextDword();
-                ((static_cast<u64>(first_dword & 0xF) << 32ul) | static_cast<u64>(GetNextDword()));
            break;
        case DebugLogValueType::MemoryOfsReg:
            debug_log.mem_type = static_cast<MemoryAccessType>((first_dword >> 4) & 0xF);
-            debug_log.ofs_reg_index = (first_dword & 0xF);
+            debug_log.ofs_reg_index = first_dword & 0xF;
            break;
        case DebugLogValueType::RegisterRelAddr:
-            debug_log.addr_reg_index = ((first_dword >> 4) & 0xF);
+            debug_log.addr_reg_index = (first_dword >> 4) & 0xF;
-            debug_log.rel_address =
+            debug_log.rel_address = (static_cast<u64>(first_dword & 0xF) << 32) | GetNextDword();
-                ((static_cast<u64>(first_dword & 0xF) << 32ul) | static_cast<u64>(GetNextDword()));
            break;
        case DebugLogValueType::RegisterOfsReg:
-            debug_log.addr_reg_index = ((first_dword >> 4) & 0xF);
+            debug_log.addr_reg_index = (first_dword >> 4) & 0xF;
-            debug_log.ofs_reg_index = (first_dword & 0xF);
+            debug_log.ofs_reg_index = first_dword & 0xF;
            break;
        }
        opcode.opcode = debug_log;
diff --git a/src/core/perf_stats.cpp b/src/core/perf_stats.cpp
index 29339ead7..b899ac884 100644
--- a/src/core/perf_stats.cpp
+++ b/src/core/perf_stats.cpp
@@ -74,15 +74,16 @@ void PerfStats::EndGameFrame() {
    game_frames += 1;
 }
-double PerfStats::GetMeanFrametime() {
+double PerfStats::GetMeanFrametime() const {
    std::lock_guard lock{object_mutex};
    if (current_index <= IgnoreFrames) {
        return 0;
    }
    const double sum = std::accumulate(perf_history.begin() + IgnoreFrames,
                                       perf_history.begin() + current_index, 0.0);
-    return sum / (current_index - IgnoreFrames);
+    return sum / static_cast<double>(current_index - IgnoreFrames);
 }
 PerfStatsResults PerfStats::GetAndResetStats(microseconds current_system_time_us) {
@@ -94,12 +95,13 @@ PerfStatsResults PerfStats::GetAndResetStats(microseconds current_system_time_us
    const auto system_us_per_second = (current_system_time_us - reset_point_system_us) / interval;
-    PerfStatsResults results{};
+    const PerfStatsResults results{
-    results.system_fps = static_cast<double>(system_frames) / interval;
+        .system_fps = static_cast<double>(system_frames) / interval,
-    results.game_fps = static_cast<double>(game_frames) / interval;
+        .game_fps = static_cast<double>(game_frames) / interval,
-    results.frametime = duration_cast<DoubleSecs>(accumulated_frametime).count() /
+        .frametime = duration_cast<DoubleSecs>(accumulated_frametime).count() /
-                        static_cast<double>(system_frames);
+                     static_cast<double>(system_frames),
-    results.emulation_speed = system_us_per_second.count() / 1'000'000.0;
+        .emulation_speed = system_us_per_second.count() / 1'000'000.0,
+    };
    // Reset counters
    reset_point = now;
@@ -111,7 +113,7 @@ PerfStatsResults PerfStats::GetAndResetStats(microseconds current_system_time_us
    return results;
 }
-double PerfStats::GetLastFrameTimeScale() {
+double PerfStats::GetLastFrameTimeScale() const {
    std::lock_guard lock{object_mutex};
    constexpr double FRAME_LENGTH = 1.0 / 60;
diff --git a/src/core/perf_stats.h b/src/core/perf_stats.h
index d9a64f072..69256b960 100644
--- a/src/core/perf_stats.h
+++ b/src/core/perf_stats.h
@@ -30,7 +30,6 @@ struct PerfStatsResults {
 class PerfStats {
 public:
    explicit PerfStats(u64 title_id);
    ~PerfStats();
    using Clock = std::chrono::high_resolution_clock;
@@ -42,18 +41,18 @@ public:
    PerfStatsResults GetAndResetStats(std::chrono::microseconds current_system_time_us);
    /**
-     * Returns the Arthimetic Mean of all frametime values stored in the performance history.
+     * Returns the arithmetic mean of all frametime values stored in the performance history.
     */
-    double GetMeanFrametime();
+    double GetMeanFrametime() const;
    /**
     * Gets the ratio between walltime and the emulated time of the previous system frame. This is
     * useful for scaling inputs or outputs moving between the two time domains.
     */
-    double GetLastFrameTimeScale();
+    double GetLastFrameTimeScale() const;
 private:
-    std::mutex object_mutex{};
+    mutable std::mutex object_mutex;
    /// Title ID for the game that is running. 0 if there is no game running yet
    u64 title_id{0};
@@ -61,7 +60,7 @@ private:
    std::size_t current_index{0};
    /// Stores an hour of historical frametime data useful for processing and tracking performance
    /// regressions with code changes.
-    std::array<double, 216000> perf_history = {};
+    std::array<double, 216000> perf_history{};
    /// Point when the cumulative counters were reset
    Clock::time_point reset_point = Clock::now();
diff --git a/src/core/settings.cpp b/src/core/settings.cpp
index 44252dd81..416b2d866 100644
--- a/src/core/settings.cpp
+++ b/src/core/settings.cpp
@@ -173,7 +173,6 @@ void RestoreGlobalState() {
    values.use_assembly_shaders.SetGlobal(true);
    values.use_asynchronous_shaders.SetGlobal(true);
    values.use_fast_gpu_time.SetGlobal(true);
-    values.force_30fps_mode.SetGlobal(true);
    values.bg_red.SetGlobal(true);
    values.bg_green.SetGlobal(true);
    values.bg_blue.SetGlobal(true);
diff --git a/src/core/settings.h b/src/core/settings.h
index 386233fdf..bb145f193 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -435,7 +435,6 @@ struct Values {
    Setting<bool> use_vsync;
    Setting<bool> use_assembly_shaders;
    Setting<bool> use_asynchronous_shaders;
-    Setting<bool> force_30fps_mode;
    Setting<bool> use_fast_gpu_time;
    Setting<float> bg_red;
diff --git a/src/core/tools/freezer.cpp b/src/core/tools/freezer.cpp
index 27b894b51..5c674a099 100644
--- a/src/core/tools/freezer.cpp
+++ b/src/core/tools/freezer.cpp
@@ -55,10 +55,11 @@ void MemoryWriteWidth(Core::Memory::Memory& memory, u32 width, VAddr addr, u64 v
 Freezer::Freezer(Core::Timing::CoreTiming& core_timing_, Core::Memory::Memory& memory_)
    : core_timing{core_timing_}, memory{memory_} {
-    event = Core::Timing::CreateEvent("MemoryFreezer::FrameCallback",
+    event = Core::Timing::CreateEvent(
-                                      [this](u64 userdata, std::chrono::nanoseconds ns_late) {
+        "MemoryFreezer::FrameCallback",
-                                          FrameCallback(userdata, ns_late);
+        [this](std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
-                                      });
+            FrameCallback(user_data, ns_late);
+        });
    core_timing.ScheduleEvent(memory_freezer_ns, event);
 }
@@ -106,28 +107,21 @@ void Freezer::Unfreeze(VAddr address) {
    LOG_DEBUG(Common_Memory, "Unfreezing memory for address={:016X}", address);
-    entries.erase(
+    std::erase_if(entries, [address](const Entry& entry) { return entry.address == address; });
-        std::remove_if(entries.begin(), entries.end(),
-                       [&address](const Entry& entry) { return entry.address == address; }),
-        entries.end());
 }
 bool Freezer::IsFrozen(VAddr address) const {
    std::lock_guard lock{entries_mutex};
-    return std::find_if(entries.begin(), entries.end(), [&address](const Entry& entry) {
+    return FindEntry(address) != entries.cend();
-               return entry.address == address;
-           }) != entries.end();
 }
 void Freezer::SetFrozenValue(VAddr address, u64 value) {
    std::lock_guard lock{entries_mutex};
-    const auto iter = std::find_if(entries.begin(), entries.end(), [&address](const Entry& entry) {
+    const auto iter = FindEntry(address);
-        return entry.address == address;
-    });
-    if (iter == entries.end()) {
+    if (iter == entries.cend()) {
        LOG_ERROR(Common_Memory,
                  "Tried to set freeze value for address={:016X} that is not frozen!", address);
        return;
@@ -142,11 +136,9 @@ void Freezer::SetFrozenValue(VAddr address, u64 value) {
 std::optional<Freezer::Entry> Freezer::GetEntry(VAddr address) const {
    std::lock_guard lock{entries_mutex};
-    const auto iter = std::find_if(entries.begin(), entries.end(), [&address](const Entry& entry) {
+    const auto iter = FindEntry(address);
-        return entry.address == address;
-    });
-    if (iter == entries.end()) {
+    if (iter == entries.cend()) {
        return std::nullopt;
    }
@@ -159,7 +151,17 @@ std::vector<Freezer::Entry> Freezer::GetEntries() const {
    return entries;
 }
-void Freezer::FrameCallback(u64, std::chrono::nanoseconds ns_late) {
+Freezer::Entries::iterator Freezer::FindEntry(VAddr address) {
+    return std::find_if(entries.begin(), entries.end(),
+                        [address](const Entry& entry) { return entry.address == address; });
+}
+Freezer::Entries::const_iterator Freezer::FindEntry(VAddr address) const {
+    return std::find_if(entries.begin(), entries.end(),
+                        [address](const Entry& entry) { return entry.address == address; });
+}
+void Freezer::FrameCallback(std::uintptr_t, std::chrono::nanoseconds ns_late) {
    if (!IsActive()) {
        LOG_DEBUG(Common_Memory, "Memory freezer has been deactivated, ending callback events.");
        return;
diff --git a/src/core/tools/freezer.h b/src/core/tools/freezer.h
index 8438783d5..0fdb701a7 100644
--- a/src/core/tools/freezer.h
+++ b/src/core/tools/freezer.h
@@ -73,13 +73,18 @@ public:
    std::vector<Entry> GetEntries() const;
 private:
-    void FrameCallback(u64 userdata, std::chrono::nanoseconds ns_late);
+    using Entries = std::vector<Entry>;
+    Entries::iterator FindEntry(VAddr address);
+    Entries::const_iterator FindEntry(VAddr address) const;
+    void FrameCallback(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
    void FillEntryReads();
    std::atomic_bool active{false};
    mutable std::mutex entries_mutex;
-    std::vector<Entry> entries;
+    Entries entries;
    std::shared_ptr<Core::Timing::EventType> event;
    Core::Timing::CoreTiming& core_timing;
diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp
index 02d06876f..74759ea7d 100644
--- a/src/input_common/gcadapter/gc_adapter.cpp
+++ b/src/input_common/gcadapter/gc_adapter.cpp
@@ -254,7 +254,7 @@ void Adapter::GetGCEndpoint(libusb_device* device) {
                              sizeof(clear_payload), nullptr, 16);
    adapter_thread_running = true;
-    adapter_input_thread = std::thread([=] { Read(); }); // Read input
+    adapter_input_thread = std::thread(&Adapter::Read, this);
 }
 Adapter::~Adapter() {
@@ -265,7 +265,9 @@ void Adapter::Reset() {
    if (adapter_thread_running) {
        adapter_thread_running = false;
    }
-    adapter_input_thread.join();
+    if (adapter_input_thread.joinable()) {
+        adapter_input_thread.join();
+    }
    adapter_controllers_status.fill(ControllerTypes::None);
    get_origin.fill(true);
diff --git a/src/input_common/gcadapter/gc_poller.cpp b/src/input_common/gcadapter/gc_poller.cpp
index 96e22d3ad..b346fdf8e 100644
--- a/src/input_common/gcadapter/gc_poller.cpp
+++ b/src/input_common/gcadapter/gc_poller.cpp
@@ -76,8 +76,7 @@ std::unique_ptr<Input::ButtonDevice> GCButtonFactory::Create(const Common::Param
    // button is not an axis/stick button
    if (button_id != PAD_STICK_ID) {
-        auto button = std::make_unique<GCButton>(port, button_id, adapter.get());
+        return std::make_unique<GCButton>(port, button_id, adapter.get());
-        return std::move(button);
    }
    // For Axis buttons, used by the binary sticks.
@@ -149,19 +148,17 @@ void GCButtonFactory::EndConfiguration() {
 class GCAnalog final : public Input::AnalogDevice {
 public:
-    GCAnalog(int port_, int axis_x_, int axis_y_, float deadzone_, GCAdapter::Adapter* adapter)
+    GCAnalog(int port_, int axis_x_, int axis_y_, float deadzone_, GCAdapter::Adapter* adapter,
+             float range_)
        : port(port_), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_), gcadapter(adapter),
          origin_value_x(adapter->GetOriginValue(port_, axis_x_)),
-          origin_value_y(adapter->GetOriginValue(port_, axis_y_)) {}
+          origin_value_y(adapter->GetOriginValue(port_, axis_y_)), range(range_) {}
    float GetAxis(int axis) const {
        if (gcadapter->DeviceConnected(port)) {
            std::lock_guard lock{mutex};
            const auto origin_value = axis % 2 == 0 ? origin_value_x : origin_value_y;
-            // division is not by a perfect 128 to account for some variance in center location
+            return (gcadapter->GetPadState()[port].axes.at(axis) - origin_value) / (100.0f * range);
-            // e.g. my device idled at 131 in X, 120 in Y, and full range of motion was in range
-            // [20-230]
-            return (gcadapter->GetPadState()[port].axes.at(axis) - origin_value) / 95.0f;
        }
        return 0.0f;
    }
@@ -216,6 +213,7 @@ private:
    GCAdapter::Adapter* gcadapter;
    const float origin_value_x;
    const float origin_value_y;
+    const float range;
    mutable std::mutex mutex;
 };
@@ -235,8 +233,9 @@ std::unique_ptr<Input::AnalogDevice> GCAnalogFactory::Create(const Common::Param
    const int axis_x = params.Get("axis_x", 0);
    const int axis_y = params.Get("axis_y", 1);
    const float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, .99f);
+    const float range = std::clamp(params.Get("range", 1.0f), 0.50f, 1.50f);
-    return std::make_unique<GCAnalog>(port, axis_x, axis_y, deadzone, adapter.get());
+    return std::make_unique<GCAnalog>(port, axis_x, axis_y, deadzone, adapter.get(), range);
 }
 void GCAnalogFactory::BeginConfiguration() {
@@ -264,7 +263,8 @@ Common::ParamPackage GCAnalogFactory::GetNextInput() {
            if (analog_x_axis == -1) {
                analog_x_axis = axis;
                controller_number = static_cast<int>(port);
-            } else if (analog_y_axis == -1 && analog_x_axis != axis && controller_number == port) {
+            } else if (analog_y_axis == -1 && analog_x_axis != axis &&
+                       controller_number == static_cast<int>(port)) {
                analog_y_axis = axis;
            }
        }
diff --git a/src/input_common/sdl/sdl_impl.cpp b/src/input_common/sdl/sdl_impl.cpp
index 675b477fa..d76c279d3 100644
--- a/src/input_common/sdl/sdl_impl.cpp
+++ b/src/input_common/sdl/sdl_impl.cpp
@@ -66,14 +66,14 @@ public:
        state.axes.insert_or_assign(axis, value);
    }
-    float GetAxis(int axis) const {
+    float GetAxis(int axis, float range) const {
        std::lock_guard lock{mutex};
-        return state.axes.at(axis) / 32767.0f;
+        return state.axes.at(axis) / (32767.0f * range);
    }
-    std::tuple<float, float> GetAnalog(int axis_x, int axis_y) const {
+    std::tuple<float, float> GetAnalog(int axis_x, int axis_y, float range) const {
-        float x = GetAxis(axis_x);
+        float x = GetAxis(axis_x, range);
-        float y = GetAxis(axis_y);
+        float y = GetAxis(axis_y, range);
        y = -y; // 3DS uses an y-axis inverse from SDL
        // Make sure the coordinates are in the unit circle,
@@ -313,7 +313,7 @@ public:
          trigger_if_greater(trigger_if_greater_) {}
    bool GetStatus() const override {
-        const float axis_value = joystick->GetAxis(axis);
+        const float axis_value = joystick->GetAxis(axis, 1.0f);
        if (trigger_if_greater) {
            return axis_value > threshold;
        }
@@ -329,11 +329,13 @@ private:
 class SDLAnalog final : public Input::AnalogDevice {
 public:
-    SDLAnalog(std::shared_ptr<SDLJoystick> joystick_, int axis_x_, int axis_y_, float deadzone_)
+    SDLAnalog(std::shared_ptr<SDLJoystick> joystick_, int axis_x_, int axis_y_, float deadzone_,
-        : joystick(std::move(joystick_)), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_) {}
+              float range_)
+        : joystick(std::move(joystick_)), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_),
+          range(range_) {}
    std::tuple<float, float> GetStatus() const override {
-        const auto [x, y] = joystick->GetAnalog(axis_x, axis_y);
+        const auto [x, y] = joystick->GetAnalog(axis_x, axis_y, range);
        const float r = std::sqrt((x * x) + (y * y));
        if (r > deadzone) {
            return std::make_tuple(x / r * (r - deadzone) / (1 - deadzone),
@@ -363,6 +365,7 @@ private:
    const int axis_x;
    const int axis_y;
    const float deadzone;
+    const float range;
 };
 /// A button device factory that creates button devices from SDL joystick
@@ -458,13 +461,13 @@ public:
        const int axis_x = params.Get("axis_x", 0);
        const int axis_y = params.Get("axis_y", 1);
        const float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, .99f);
+        const float range = std::clamp(params.Get("range", 1.0f), 0.50f, 1.50f);
        auto joystick = state.GetSDLJoystickByGUID(guid, port);
        // This is necessary so accessing GetAxis with axis_x and axis_y won't crash
        joystick->SetAxis(axis_x, 0);
        joystick->SetAxis(axis_y, 0);
-        return std::make_unique<SDLAnalog>(joystick, axis_x, axis_y, deadzone);
+        return std::make_unique<SDLAnalog>(joystick, axis_x, axis_y, deadzone, range);
    }
 private:
diff --git a/src/input_common/udp/client.cpp b/src/input_common/udp/client.cpp
index e63c73c4f..3f4eaf448 100644
--- a/src/input_common/udp/client.cpp
+++ b/src/input_common/udp/client.cpp
@@ -9,7 +9,6 @@
 #include <functional>
 #include <thread>
 #include <boost/asio.hpp>
-#include <boost/bind.hpp>
 #include "common/logging/log.h"
 #include "input_common/udp/client.h"
 #include "input_common/udp/protocol.h"
@@ -225,8 +224,7 @@ void TestCommunication(const std::string& host, u16 port, u8 pad_index, u32 clie
        } else {
            failure_callback();
        }
-    })
+    }).detach();
-        .detach();
 }
 CalibrationConfigurationJob::CalibrationConfigurationJob(
@@ -280,8 +278,7 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
        complete_event.Wait();
        socket.Stop();
        worker_thread.join();
-    })
+    }).detach();
-        .detach();
 }
 CalibrationConfigurationJob::~CalibrationConfigurationJob() {
diff --git a/src/tests/core/core_timing.cpp b/src/tests/core/core_timing.cpp
index 244463a47..b35459152 100644
--- a/src/tests/core/core_timing.cpp
+++ b/src/tests/core/core_timing.cpp
@@ -25,10 +25,10 @@ std::bitset<CB_IDS.size()> callbacks_ran_flags;
 u64 expected_callback = 0;
 template <unsigned int IDX>
-void HostCallbackTemplate(u64 userdata, std::chrono::nanoseconds ns_late) {
+void HostCallbackTemplate(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
    static_assert(IDX < CB_IDS.size(), "IDX out of range");
    callbacks_ran_flags.set(IDX);
-    REQUIRE(CB_IDS[IDX] == userdata);
+    REQUIRE(CB_IDS[IDX] == user_data);
    REQUIRE(CB_IDS[IDX] == CB_IDS[calls_order[expected_callback]]);
    delays[IDX] = ns_late.count();
    ++expected_callback;
@@ -46,20 +46,16 @@ struct ScopeInit final {
    Core::Timing::CoreTiming core_timing;
 };
-#pragma optimize("", off)
 u64 TestTimerSpeed(Core::Timing::CoreTiming& core_timing) {
-    u64 start = core_timing.GetGlobalTimeNs().count();
+    const u64 start = core_timing.GetGlobalTimeNs().count();
-    u64 placebo = 0;
+    volatile u64 placebo = 0;
    for (std::size_t i = 0; i < 1000; i++) {
-        placebo += core_timing.GetGlobalTimeNs().count();
+        placebo = placebo + core_timing.GetGlobalTimeNs().count();
    }
-    u64 end = core_timing.GetGlobalTimeNs().count();
+    const u64 end = core_timing.GetGlobalTimeNs().count();
-    return (end - start);
+    return end - start;
 }
-#pragma optimize("", on)
 } // Anonymous namespace
 TEST_CASE("CoreTiming[BasicOrder]", "[core]") {
diff --git a/src/video_core/compatible_formats.h b/src/video_core/compatible_formats.h
index d1082566d..51766349b 100644
--- a/src/video_core/compatible_formats.h
+++ b/src/video_core/compatible_formats.h
@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#pragma once
 #include <array>
 #include <bitset>
 #include <cstddef>
diff --git a/src/video_core/engines/maxwell_dma.cpp b/src/video_core/engines/maxwell_dma.cpp
index a2d3d7823..e88290754 100644
--- a/src/video_core/engines/maxwell_dma.cpp
+++ b/src/video_core/engines/maxwell_dma.cpp
@@ -94,7 +94,8 @@ void MaxwellDMA::CopyPitchToPitch() {
 }
 void MaxwellDMA::CopyBlockLinearToPitch() {
-    ASSERT(regs.src_params.block_size.depth == 0);
+    UNIMPLEMENTED_IF(regs.src_params.block_size.depth != 0);
+    UNIMPLEMENTED_IF(regs.src_params.layer != 0);
    // Optimized path for micro copies.
    const size_t dst_size = static_cast<size_t>(regs.pitch_out) * regs.line_count;
@@ -123,17 +124,12 @@ void MaxwellDMA::CopyBlockLinearToPitch() {
        write_buffer.resize(dst_size);
    }
-    if (Settings::IsGPULevelExtreme()) {
+    memory_manager.ReadBlock(regs.offset_in, read_buffer.data(), src_size);
-        memory_manager.ReadBlock(regs.offset_in, read_buffer.data(), src_size);
+    memory_manager.ReadBlock(regs.offset_out, write_buffer.data(), dst_size);
-        memory_manager.ReadBlock(regs.offset_out, write_buffer.data(), dst_size);
-    } else {
-        memory_manager.ReadBlockUnsafe(regs.offset_in, read_buffer.data(), src_size);
-        memory_manager.ReadBlockUnsafe(regs.offset_out, write_buffer.data(), dst_size);
-    }
    UnswizzleSubrect(regs.line_length_in, regs.line_count, regs.pitch_out, width, bytes_per_pixel,
-                     read_buffer.data() + src_layer_size * src_params.layer, write_buffer.data(),
+                     block_height, src_params.origin.x, src_params.origin.y, write_buffer.data(),
-                     block_height, src_params.origin.x, src_params.origin.y);
+                     read_buffer.data());
    memory_manager.WriteBlock(regs.offset_out, write_buffer.data(), dst_size);
 }
@@ -198,7 +194,6 @@ void MaxwellDMA::FastCopyBlockLinearToPitch() {
    if (read_buffer.size() < src_size) {
        read_buffer.resize(src_size);
    }
    if (write_buffer.size() < dst_size) {
        write_buffer.resize(dst_size);
    }
@@ -212,8 +207,8 @@ void MaxwellDMA::FastCopyBlockLinearToPitch() {
    }
    UnswizzleSubrect(regs.line_length_in, regs.line_count, regs.pitch_out, regs.src_params.width,
-                     bytes_per_pixel, read_buffer.data(), write_buffer.data(),
+                     bytes_per_pixel, regs.src_params.block_size.height, pos_x, pos_y,
-                     regs.src_params.block_size.height, pos_x, pos_y);
+                     write_buffer.data(), read_buffer.data());
    memory_manager.WriteBlock(regs.offset_out, write_buffer.data(), dst_size);
 }
diff --git a/src/video_core/gpu.cpp b/src/video_core/gpu.cpp
index 8e19c3373..512578c8b 100644
--- a/src/video_core/gpu.cpp
+++ b/src/video_core/gpu.cpp
@@ -81,7 +81,7 @@ void GPU::WaitFence(u32 syncpoint_id, u32 value) {
    }
    MICROPROFILE_SCOPE(GPU_wait);
    std::unique_lock lock{sync_mutex};
-    sync_cv.wait(lock, [=]() { return syncpoints[syncpoint_id].load() >= value; });
+    sync_cv.wait(lock, [=, this] { return syncpoints[syncpoint_id].load() >= value; });
 }
 void GPU::IncrementSyncPoint(const u32 syncpoint_id) {
diff --git a/src/video_core/gpu.h b/src/video_core/gpu.h
index 19a34c402..ebfc7b0c7 100644
--- a/src/video_core/gpu.h
+++ b/src/video_core/gpu.h
@@ -252,7 +252,7 @@ public:
    const Tegra::DmaPusher& DmaPusher() const;
    struct Regs {
-        static constexpr size_t NUM_REGS = 0x100;
+        static constexpr size_t NUM_REGS = 0x40;
        union {
            struct {
@@ -271,7 +271,7 @@ public:
                u32 semaphore_trigger;
                INSERT_UNION_PADDING_WORDS(0xC);
-                // The puser and the puller share the reference counter, the pusher only has read
+                // The pusher and the puller share the reference counter, the pusher only has read
                // access
                u32 reference_count;
                INSERT_UNION_PADDING_WORDS(0x5);
diff --git a/src/video_core/memory_manager.cpp b/src/video_core/memory_manager.cpp
index ff5505d12..844164645 100644
--- a/src/video_core/memory_manager.cpp
+++ b/src/video_core/memory_manager.cpp
@@ -4,7 +4,6 @@
 #include "common/alignment.h"
 #include "common/assert.h"
-#include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/process.h"
@@ -16,121 +15,137 @@
 namespace Tegra {
 MemoryManager::MemoryManager(Core::System& system, VideoCore::RasterizerInterface& rasterizer)
-    : rasterizer{rasterizer}, system{system} {
+    : system{system}, rasterizer{rasterizer}, page_table(page_table_size) {}
-    page_table.Resize(address_space_width, page_bits, false);
-    // Initialize the map with a single free region covering the entire managed space.
-    VirtualMemoryArea initial_vma;
-    initial_vma.size = address_space_end;
-    vma_map.emplace(initial_vma.base, initial_vma);
-    UpdatePageTableForVMA(initial_vma);
-}
 MemoryManager::~MemoryManager() = default;
-GPUVAddr MemoryManager::AllocateSpace(u64 size, u64 align) {
+GPUVAddr MemoryManager::UpdateRange(GPUVAddr gpu_addr, PageEntry page_entry, std::size_t size) {
-    const u64 aligned_size{Common::AlignUp(size, page_size)};
+    u64 remaining_size{size};
-    const GPUVAddr gpu_addr{FindFreeRegion(address_space_base, aligned_size)};
+    for (u64 offset{}; offset < size; offset += page_size) {
+        if (remaining_size < page_size) {
-    AllocateMemory(gpu_addr, 0, aligned_size);
+            SetPageEntry(gpu_addr + offset, page_entry + offset, remaining_size);
+        } else {
+            SetPageEntry(gpu_addr + offset, page_entry + offset);
+        }
+        remaining_size -= page_size;
+    }
    return gpu_addr;
 }
-GPUVAddr MemoryManager::AllocateSpace(GPUVAddr gpu_addr, u64 size, u64 align) {
+GPUVAddr MemoryManager::Map(VAddr cpu_addr, GPUVAddr gpu_addr, std::size_t size) {
-    const u64 aligned_size{Common::AlignUp(size, page_size)};
+    return UpdateRange(gpu_addr, cpu_addr, size);
+}
-    AllocateMemory(gpu_addr, 0, aligned_size);
-    return gpu_addr;
+GPUVAddr MemoryManager::MapAllocate(VAddr cpu_addr, std::size_t size, std::size_t align) {
+    return Map(cpu_addr, *FindFreeRange(size, align), size);
 }
-GPUVAddr MemoryManager::MapBufferEx(VAddr cpu_addr, u64 size) {
+void MemoryManager::Unmap(GPUVAddr gpu_addr, std::size_t size) {
-    const u64 aligned_size{Common::AlignUp(size, page_size)};
+    if (!size) {
-    const GPUVAddr gpu_addr{FindFreeRegion(address_space_base, aligned_size)};
+        return;
+    }
-    MapBackingMemory(gpu_addr, system.Memory().GetPointer(cpu_addr), aligned_size, cpu_addr);
+    // Flush and invalidate through the GPU interface, to be asynchronous if possible.
-    ASSERT(
+    system.GPU().FlushAndInvalidateRegion(*GpuToCpuAddress(gpu_addr), size);
-        system.CurrentProcess()->PageTable().LockForDeviceAddressSpace(cpu_addr, size).IsSuccess());
-    return gpu_addr;
+    UpdateRange(gpu_addr, PageEntry::State::Unmapped, size);
 }
-GPUVAddr MemoryManager::MapBufferEx(VAddr cpu_addr, GPUVAddr gpu_addr, u64 size) {
+std::optional<GPUVAddr> MemoryManager::AllocateFixed(GPUVAddr gpu_addr, std::size_t size) {
-    ASSERT((gpu_addr & page_mask) == 0);
+    for (u64 offset{}; offset < size; offset += page_size) {
+        if (!GetPageEntry(gpu_addr + offset).IsUnmapped()) {
+            return {};
+        }
+    }
-    const u64 aligned_size{Common::AlignUp(size, page_size)};
+    return UpdateRange(gpu_addr, PageEntry::State::Allocated, size);
+}
-    MapBackingMemory(gpu_addr, system.Memory().GetPointer(cpu_addr), aligned_size, cpu_addr);
+GPUVAddr MemoryManager::Allocate(std::size_t size, std::size_t align) {
-    ASSERT(
+    return *AllocateFixed(*FindFreeRange(size, align), size);
-        system.CurrentProcess()->PageTable().LockForDeviceAddressSpace(cpu_addr, size).IsSuccess());
-    return gpu_addr;
 }
-GPUVAddr MemoryManager::UnmapBuffer(GPUVAddr gpu_addr, u64 size) {
+void MemoryManager::TryLockPage(PageEntry page_entry, std::size_t size) {
-    ASSERT((gpu_addr & page_mask) == 0);
+    if (!page_entry.IsValid()) {
+        return;
+    }
-    const u64 aligned_size{Common::AlignUp(size, page_size)};
+    ASSERT(system.CurrentProcess()
-    const auto cpu_addr = GpuToCpuAddress(gpu_addr);
+               ->PageTable()
-    ASSERT(cpu_addr);
+               .LockForDeviceAddressSpace(page_entry.ToAddress(), size)
+               .IsSuccess());
+}
-    // Flush and invalidate through the GPU interface, to be asynchronous if possible.
+void MemoryManager::TryUnlockPage(PageEntry page_entry, std::size_t size) {
-    system.GPU().FlushAndInvalidateRegion(*cpu_addr, aligned_size);
+    if (!page_entry.IsValid()) {
+        return;
+    }
-    UnmapRange(gpu_addr, aligned_size);
    ASSERT(system.CurrentProcess()
               ->PageTable()
-               .UnlockForDeviceAddressSpace(cpu_addr.value(), size)
+               .UnlockForDeviceAddressSpace(page_entry.ToAddress(), size)
               .IsSuccess());
-    return gpu_addr;
 }
-GPUVAddr MemoryManager::FindFreeRegion(GPUVAddr region_start, u64 size) const {
+PageEntry MemoryManager::GetPageEntry(GPUVAddr gpu_addr) const {
-    // Find the first Free VMA.
+    return page_table[PageEntryIndex(gpu_addr)];
-    const VMAHandle vma_handle{
+}
-        std::find_if(vma_map.begin(), vma_map.end(), [region_start, size](const auto& vma) {
-            if (vma.second.type != VirtualMemoryArea::Type::Unmapped) {
-                return false;
-            }
-            const VAddr vma_end{vma.second.base + vma.second.size};
+void MemoryManager::SetPageEntry(GPUVAddr gpu_addr, PageEntry page_entry, std::size_t size) {
-            return vma_end > region_start && vma_end >= region_start + size;
+    // TODO(bunnei): We should lock/unlock device regions. This currently causes issues due to
-        })};
+    // improper tracking, but should be fixed in the future.
-    if (vma_handle == vma_map.end()) {
+    //// Unlock the old page
-        return {};
+    // TryUnlockPage(page_table[PageEntryIndex(gpu_addr)], size);
-    }
-    return std::max(region_start, vma_handle->second.base);
+    //// Lock the new page
-}
+    // TryLockPage(page_entry, size);
-bool MemoryManager::IsAddressValid(GPUVAddr addr) const {
+    page_table[PageEntryIndex(gpu_addr)] = page_entry;
-    return (addr >> page_bits) < page_table.pointers.size();
 }
-std::optional<VAddr> MemoryManager::GpuToCpuAddress(GPUVAddr addr) const {
+std::optional<GPUVAddr> MemoryManager::FindFreeRange(std::size_t size, std::size_t align) const {
-    if (!IsAddressValid(addr)) {
+    if (!align) {
-        return {};
+        align = page_size;
+    } else {
+        align = Common::AlignUp(align, page_size);
    }
-    const VAddr cpu_addr{page_table.backing_addr[addr >> page_bits]};
+    u64 available_size{};
-    if (cpu_addr) {
+    GPUVAddr gpu_addr{address_space_start};
-        return cpu_addr + (addr & page_mask);
+    while (gpu_addr + available_size < address_space_size) {
+        if (GetPageEntry(gpu_addr + available_size).IsUnmapped()) {
+            available_size += page_size;
+            if (available_size >= size) {
+                return gpu_addr;
+            }
+        } else {
+            gpu_addr += available_size + page_size;
+            available_size = 0;
+            const auto remainder{gpu_addr % align};
+            if (remainder) {
+                gpu_addr = (gpu_addr - remainder) + align;
+            }
+        }
    }
    return {};
 }
-template <typename T>
+std::optional<VAddr> MemoryManager::GpuToCpuAddress(GPUVAddr gpu_addr) const {
-T MemoryManager::Read(GPUVAddr addr) const {
+    const auto page_entry{GetPageEntry(gpu_addr)};
-    if (!IsAddressValid(addr)) {
+    if (!page_entry.IsValid()) {
        return {};
    }
-    const u8* page_pointer{GetPointer(addr)};
+    return page_entry.ToAddress() + (gpu_addr & page_mask);
-    if (page_pointer) {
+}
+template <typename T>
+T MemoryManager::Read(GPUVAddr addr) const {
+    if (auto page_pointer{GetPointer(addr)}; page_pointer) {
        // NOTE: Avoid adding any extra logic to this fast-path block
        T value;
        std::memcpy(&value, page_pointer, sizeof(T));
@@ -144,12 +159,7 @@ T MemoryManager::Read(GPUVAddr addr) const {
 template <typename T>
 void MemoryManager::Write(GPUVAddr addr, T data) {
-    if (!IsAddressValid(addr)) {
+    if (auto page_pointer{GetPointer(addr)}; page_pointer) {
-        return;
-    }
-    u8* page_pointer{GetPointer(addr)};
-    if (page_pointer) {
        // NOTE: Avoid adding any extra logic to this fast-path block
        std::memcpy(page_pointer, &data, sizeof(T));
        return;
@@ -167,66 +177,49 @@ template void MemoryManager::Write<u16>(GPUVAddr addr, u16 data);
 template void MemoryManager::Write<u32>(GPUVAddr addr, u32 data);
 template void MemoryManager::Write<u64>(GPUVAddr addr, u64 data);
-u8* MemoryManager::GetPointer(GPUVAddr addr) {
+u8* MemoryManager::GetPointer(GPUVAddr gpu_addr) {
-    if (!IsAddressValid(addr)) {
+    if (!GetPageEntry(gpu_addr).IsValid()) {
        return {};
    }
-    auto& memory = system.Memory();
+    const auto address{GpuToCpuAddress(gpu_addr)};
+    if (!address) {
-    const VAddr page_addr{page_table.backing_addr[addr >> page_bits]};
+        return {};
-    if (page_addr != 0) {
-        return memory.GetPointer(page_addr + (addr & page_mask));
    }
-    LOG_ERROR(HW_GPU, "Unknown GetPointer @ 0x{:016X}", addr);
+    return system.Memory().GetPointer(*address);
-    return {};
 }
-const u8* MemoryManager::GetPointer(GPUVAddr addr) const {
+const u8* MemoryManager::GetPointer(GPUVAddr gpu_addr) const {
-    if (!IsAddressValid(addr)) {
+    if (!GetPageEntry(gpu_addr).IsValid()) {
        return {};
    }
-    const auto& memory = system.Memory();
+    const auto address{GpuToCpuAddress(gpu_addr)};
+    if (!address) {
-    const VAddr page_addr{page_table.backing_addr[addr >> page_bits]};
+        return {};
-    if (page_addr != 0) {
-        return memory.GetPointer(page_addr + (addr & page_mask));
    }
-    LOG_ERROR(HW_GPU, "Unknown GetPointer @ 0x{:016X}", addr);
+    return system.Memory().GetPointer(*address);
-    return {};
-}
-bool MemoryManager::IsBlockContinuous(const GPUVAddr start, const std::size_t size) const {
-    const std::size_t inner_size = size - 1;
-    const GPUVAddr end = start + inner_size;
-    const auto host_ptr_start = reinterpret_cast<std::uintptr_t>(GetPointer(start));
-    const auto host_ptr_end = reinterpret_cast<std::uintptr_t>(GetPointer(end));
-    const auto range = static_cast<std::size_t>(host_ptr_end - host_ptr_start);
-    return range == inner_size;
 }
-void MemoryManager::ReadBlock(GPUVAddr gpu_src_addr, void* dest_buffer,
+void MemoryManager::ReadBlock(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size) const {
-                              const std::size_t size) const {
    std::size_t remaining_size{size};
    std::size_t page_index{gpu_src_addr >> page_bits};
    std::size_t page_offset{gpu_src_addr & page_mask};
-    auto& memory = system.Memory();
    while (remaining_size > 0) {
        const std::size_t copy_amount{
            std::min(static_cast<std::size_t>(page_size) - page_offset, remaining_size)};
-        const VAddr src_addr{page_table.backing_addr[page_index] + page_offset};
+        if (const auto page_addr{GpuToCpuAddress(page_index << page_bits)}; page_addr) {
-        // Flush must happen on the rasterizer interface, such that memory is always synchronous
+            const auto src_addr{*page_addr + page_offset};
-        // when it is read (even when in asynchronous GPU mode). Fixes Dead Cells title menu.
-        rasterizer.FlushRegion(src_addr, copy_amount);
+            // Flush must happen on the rasterizer interface, such that memory is always synchronous
-        memory.ReadBlockUnsafe(src_addr, dest_buffer, copy_amount);
+            // when it is read (even when in asynchronous GPU mode). Fixes Dead Cells title menu.
+            rasterizer.FlushRegion(src_addr, copy_amount);
+            system.Memory().ReadBlockUnsafe(src_addr, dest_buffer, copy_amount);
+        }
        page_index++;
        page_offset = 0;
@@ -241,18 +234,17 @@ void MemoryManager::ReadBlockUnsafe(GPUVAddr gpu_src_addr, void* dest_buffer,
    std::size_t page_index{gpu_src_addr >> page_bits};
    std::size_t page_offset{gpu_src_addr & page_mask};
-    auto& memory = system.Memory();
    while (remaining_size > 0) {
        const std::size_t copy_amount{
            std::min(static_cast<std::size_t>(page_size) - page_offset, remaining_size)};
-        const u8* page_pointer = page_table.pointers[page_index];
-        if (page_pointer) {
+        if (const auto page_addr{GpuToCpuAddress(page_index << page_bits)}; page_addr) {
-            const VAddr src_addr{page_table.backing_addr[page_index] + page_offset};
+            const auto src_addr{*page_addr + page_offset};
-            memory.ReadBlockUnsafe(src_addr, dest_buffer, copy_amount);
+            system.Memory().ReadBlockUnsafe(src_addr, dest_buffer, copy_amount);
        } else {
            std::memset(dest_buffer, 0, copy_amount);
        }
        page_index++;
        page_offset = 0;
        dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
@@ -260,23 +252,23 @@ void MemoryManager::ReadBlockUnsafe(GPUVAddr gpu_src_addr, void* dest_buffer,
    }
 }
-void MemoryManager::WriteBlock(GPUVAddr gpu_dest_addr, const void* src_buffer,
+void MemoryManager::WriteBlock(GPUVAddr gpu_dest_addr, const void* src_buffer, std::size_t size) {
-                               const std::size_t size) {
    std::size_t remaining_size{size};
    std::size_t page_index{gpu_dest_addr >> page_bits};
    std::size_t page_offset{gpu_dest_addr & page_mask};
-    auto& memory = system.Memory();
    while (remaining_size > 0) {
        const std::size_t copy_amount{
            std::min(static_cast<std::size_t>(page_size) - page_offset, remaining_size)};
-        const VAddr dest_addr{page_table.backing_addr[page_index] + page_offset};
+        if (const auto page_addr{GpuToCpuAddress(page_index << page_bits)}; page_addr) {
-        // Invalidate must happen on the rasterizer interface, such that memory is always
+            const auto dest_addr{*page_addr + page_offset};
-        // synchronous when it is written (even when in asynchronous GPU mode).
-        rasterizer.InvalidateRegion(dest_addr, copy_amount);
+            // Invalidate must happen on the rasterizer interface, such that memory is always
-        memory.WriteBlockUnsafe(dest_addr, src_buffer, copy_amount);
+            // synchronous when it is written (even when in asynchronous GPU mode).
+            rasterizer.InvalidateRegion(dest_addr, copy_amount);
+            system.Memory().WriteBlockUnsafe(dest_addr, src_buffer, copy_amount);
+        }
        page_index++;
        page_offset = 0;
@@ -286,21 +278,20 @@ void MemoryManager::WriteBlock(GPUVAddr gpu_dest_addr, const void* src_buffer,
 }
 void MemoryManager::WriteBlockUnsafe(GPUVAddr gpu_dest_addr, const void* src_buffer,
-                                     const std::size_t size) {
+                                     std::size_t size) {
    std::size_t remaining_size{size};
    std::size_t page_index{gpu_dest_addr >> page_bits};
    std::size_t page_offset{gpu_dest_addr & page_mask};
-    auto& memory = system.Memory();
    while (remaining_size > 0) {
        const std::size_t copy_amount{
            std::min(static_cast<std::size_t>(page_size) - page_offset, remaining_size)};
-        u8* page_pointer = page_table.pointers[page_index];
-        if (page_pointer) {
+        if (const auto page_addr{GpuToCpuAddress(page_index << page_bits)}; page_addr) {
-            const VAddr dest_addr{page_table.backing_addr[page_index] + page_offset};
+            const auto dest_addr{*page_addr + page_offset};
-            memory.WriteBlockUnsafe(dest_addr, src_buffer, copy_amount);
+            system.Memory().WriteBlockUnsafe(dest_addr, src_buffer, copy_amount);
        }
        page_index++;
        page_offset = 0;
        src_buffer = static_cast<const u8*>(src_buffer) + copy_amount;
@@ -308,273 +299,26 @@ void MemoryManager::WriteBlockUnsafe(GPUVAddr gpu_dest_addr, const void* src_buf
    }
 }
-void MemoryManager::CopyBlock(GPUVAddr gpu_dest_addr, GPUVAddr gpu_src_addr,
+void MemoryManager::CopyBlock(GPUVAddr gpu_dest_addr, GPUVAddr gpu_src_addr, std::size_t size) {
-                              const std::size_t size) {
    std::vector<u8> tmp_buffer(size);
    ReadBlock(gpu_src_addr, tmp_buffer.data(), size);
    WriteBlock(gpu_dest_addr, tmp_buffer.data(), size);
 }
 void MemoryManager::CopyBlockUnsafe(GPUVAddr gpu_dest_addr, GPUVAddr gpu_src_addr,
-                                    const std::size_t size) {
+                                    std::size_t size) {
    std::vector<u8> tmp_buffer(size);
    ReadBlockUnsafe(gpu_src_addr, tmp_buffer.data(), size);
    WriteBlockUnsafe(gpu_dest_addr, tmp_buffer.data(), size);
 }
 bool MemoryManager::IsGranularRange(GPUVAddr gpu_addr, std::size_t size) {
-    const VAddr addr = page_table.backing_addr[gpu_addr >> page_bits];
+    const auto cpu_addr{GpuToCpuAddress(gpu_addr)};
-    const std::size_t page = (addr & Core::Memory::PAGE_MASK) + size;
+    if (!cpu_addr) {
-    return page <= Core::Memory::PAGE_SIZE;
-}
-void MemoryManager::MapPages(GPUVAddr base, u64 size, u8* memory, Common::PageType type,
-                             VAddr backing_addr) {
-    LOG_DEBUG(HW_GPU, "Mapping {} onto {:016X}-{:016X}", fmt::ptr(memory), base * page_size,
-              (base + size) * page_size);
-    const VAddr end{base + size};
-    ASSERT_MSG(end <= page_table.pointers.size(), "out of range mapping at {:016X}",
-               base + page_table.pointers.size());
-    if (memory == nullptr) {
-        while (base != end) {
-            page_table.pointers[base] = nullptr;
-            page_table.backing_addr[base] = 0;
-            base += 1;
-        }
-    } else {
-        while (base != end) {
-            page_table.pointers[base] = memory;
-            page_table.backing_addr[base] = backing_addr;
-            base += 1;
-            memory += page_size;
-            backing_addr += page_size;
-        }
-    }
-}
-void MemoryManager::MapMemoryRegion(GPUVAddr base, u64 size, u8* target, VAddr backing_addr) {
-    ASSERT_MSG((size & page_mask) == 0, "non-page aligned size: {:016X}", size);
-    ASSERT_MSG((base & page_mask) == 0, "non-page aligned base: {:016X}", base);
-    MapPages(base / page_size, size / page_size, target, Common::PageType::Memory, backing_addr);
-}
-void MemoryManager::UnmapRegion(GPUVAddr base, u64 size) {
-    ASSERT_MSG((size & page_mask) == 0, "non-page aligned size: {:016X}", size);
-    ASSERT_MSG((base & page_mask) == 0, "non-page aligned base: {:016X}", base);
-    MapPages(base / page_size, size / page_size, nullptr, Common::PageType::Unmapped);
-}
-bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const {
-    ASSERT(base + size == next.base);
-    if (type != next.type) {
-        return {};
-    }
-    if (type == VirtualMemoryArea::Type::Allocated && (offset + size != next.offset)) {
-        return {};
-    }
-    if (type == VirtualMemoryArea::Type::Mapped && backing_memory + size != next.backing_memory) {
-        return {};
-    }
-    return true;
-}
-MemoryManager::VMAHandle MemoryManager::FindVMA(GPUVAddr target) const {
-    if (target >= address_space_end) {
-        return vma_map.end();
-    } else {
-        return std::prev(vma_map.upper_bound(target));
-    }
-}
-MemoryManager::VMAIter MemoryManager::Allocate(VMAIter vma_handle) {
-    VirtualMemoryArea& vma{vma_handle->second};
-    vma.type = VirtualMemoryArea::Type::Allocated;
-    vma.backing_addr = 0;
-    vma.backing_memory = {};
-    UpdatePageTableForVMA(vma);
-    return MergeAdjacent(vma_handle);
-}
-MemoryManager::VMAHandle MemoryManager::AllocateMemory(GPUVAddr target, std::size_t offset,
-                                                       u64 size) {
-    // This is the appropriately sized VMA that will turn into our allocation.
-    VMAIter vma_handle{CarveVMA(target, size)};
-    VirtualMemoryArea& vma{vma_handle->second};
-    ASSERT(vma.size == size);
-    vma.offset = offset;
-    return Allocate(vma_handle);
-}
-MemoryManager::VMAHandle MemoryManager::MapBackingMemory(GPUVAddr target, u8* memory, u64 size,
-                                                         VAddr backing_addr) {
-    // This is the appropriately sized VMA that will turn into our allocation.
-    VMAIter vma_handle{CarveVMA(target, size)};
-    VirtualMemoryArea& vma{vma_handle->second};
-    ASSERT(vma.size == size);
-    vma.type = VirtualMemoryArea::Type::Mapped;
-    vma.backing_memory = memory;
-    vma.backing_addr = backing_addr;
-    UpdatePageTableForVMA(vma);
-    return MergeAdjacent(vma_handle);
-}
-void MemoryManager::UnmapRange(GPUVAddr target, u64 size) {
-    VMAIter vma{CarveVMARange(target, size)};
-    const VAddr target_end{target + size};
-    const VMAIter end{vma_map.end()};
-    // The comparison against the end of the range must be done using addresses since VMAs can be
-    // merged during this process, causing invalidation of the iterators.
-    while (vma != end && vma->second.base < target_end) {
-        // Unmapped ranges return to allocated state and can be reused
-        // This behavior is used by Super Mario Odyssey, Sonic Forces, and likely other games
-        vma = std::next(Allocate(vma));
-    }
-    ASSERT(FindVMA(target)->second.size >= size);
-}
-MemoryManager::VMAIter MemoryManager::StripIterConstness(const VMAHandle& iter) {
-    // This uses a neat C++ trick to convert a const_iterator to a regular iterator, given
-    // non-const access to its container.
-    return vma_map.erase(iter, iter); // Erases an empty range of elements
-}
-MemoryManager::VMAIter MemoryManager::CarveVMA(GPUVAddr base, u64 size) {
-    ASSERT_MSG((size & page_mask) == 0, "non-page aligned size: 0x{:016X}", size);
-    ASSERT_MSG((base & page_mask) == 0, "non-page aligned base: 0x{:016X}", base);
-    VMAIter vma_handle{StripIterConstness(FindVMA(base))};
-    if (vma_handle == vma_map.end()) {
-        // Target address is outside the managed range
-        return {};
-    }
-    const VirtualMemoryArea& vma{vma_handle->second};
-    if (vma.type == VirtualMemoryArea::Type::Mapped) {
-        // Region is already allocated
-        return vma_handle;
-    }
-    const VAddr start_in_vma{base - vma.base};
-    const VAddr end_in_vma{start_in_vma + size};
-    ASSERT_MSG(end_in_vma <= vma.size, "region size 0x{:016X} is less than required size 0x{:016X}",
-               vma.size, end_in_vma);
-    if (end_in_vma < vma.size) {
-        // Split VMA at the end of the allocated region
-        SplitVMA(vma_handle, end_in_vma);
-    }
-    if (start_in_vma != 0) {
-        // Split VMA at the start of the allocated region
-        vma_handle = SplitVMA(vma_handle, start_in_vma);
-    }
-    return vma_handle;
-}
-MemoryManager::VMAIter MemoryManager::CarveVMARange(GPUVAddr target, u64 size) {
-    ASSERT_MSG((size & page_mask) == 0, "non-page aligned size: 0x{:016X}", size);
-    ASSERT_MSG((target & page_mask) == 0, "non-page aligned base: 0x{:016X}", target);
-    const VAddr target_end{target + size};
-    ASSERT(target_end >= target);
-    ASSERT(size > 0);
-    VMAIter begin_vma{StripIterConstness(FindVMA(target))};
-    const VMAIter i_end{vma_map.lower_bound(target_end)};
-    if (std::any_of(begin_vma, i_end, [](const auto& entry) {
-            return entry.second.type == VirtualMemoryArea::Type::Unmapped;
-        })) {
        return {};
    }
+    const std::size_t page{(*cpu_addr & Core::Memory::PAGE_MASK) + size};
-    if (target != begin_vma->second.base) {
+    return page <= Core::Memory::PAGE_SIZE;
-        begin_vma = SplitVMA(begin_vma, target - begin_vma->second.base);
-    }
-    VMAIter end_vma{StripIterConstness(FindVMA(target_end))};
-    if (end_vma != vma_map.end() && target_end != end_vma->second.base) {
-        end_vma = SplitVMA(end_vma, target_end - end_vma->second.base);
-    }
-    return begin_vma;
-}
-MemoryManager::VMAIter MemoryManager::SplitVMA(VMAIter vma_handle, u64 offset_in_vma) {
-    VirtualMemoryArea& old_vma{vma_handle->second};
-    VirtualMemoryArea new_vma{old_vma}; // Make a copy of the VMA
-    // For now, don't allow no-op VMA splits (trying to split at a boundary) because it's probably
-    // a bug. This restriction might be removed later.
-    ASSERT(offset_in_vma < old_vma.size);
-    ASSERT(offset_in_vma > 0);
-    old_vma.size = offset_in_vma;
-    new_vma.base += offset_in_vma;
-    new_vma.size -= offset_in_vma;
-    switch (new_vma.type) {
-    case VirtualMemoryArea::Type::Unmapped:
-        break;
-    case VirtualMemoryArea::Type::Allocated:
-        new_vma.offset += offset_in_vma;
-        break;
-    case VirtualMemoryArea::Type::Mapped:
-        new_vma.backing_memory += offset_in_vma;
-        break;
-    }
-    ASSERT(old_vma.CanBeMergedWith(new_vma));
-    return vma_map.emplace_hint(std::next(vma_handle), new_vma.base, new_vma);
-}
-MemoryManager::VMAIter MemoryManager::MergeAdjacent(VMAIter iter) {
-    const VMAIter next_vma{std::next(iter)};
-    if (next_vma != vma_map.end() && iter->second.CanBeMergedWith(next_vma->second)) {
-        iter->second.size += next_vma->second.size;
-        vma_map.erase(next_vma);
-    }
-    if (iter != vma_map.begin()) {
-        VMAIter prev_vma{std::prev(iter)};
-        if (prev_vma->second.CanBeMergedWith(iter->second)) {
-            prev_vma->second.size += iter->second.size;
-            vma_map.erase(iter);
-            iter = prev_vma;
-        }
-    }
-    return iter;
-}
-void MemoryManager::UpdatePageTableForVMA(const VirtualMemoryArea& vma) {
-    switch (vma.type) {
-    case VirtualMemoryArea::Type::Unmapped:
-        UnmapRegion(vma.base, vma.size);
-        break;
-    case VirtualMemoryArea::Type::Allocated:
-        MapMemoryRegion(vma.base, vma.size, nullptr, vma.backing_addr);
-        break;
-    case VirtualMemoryArea::Type::Mapped:
-        MapMemoryRegion(vma.base, vma.size, vma.backing_memory, vma.backing_addr);
-        break;
-    }
 }
 } // namespace Tegra
diff --git a/src/video_core/memory_manager.h b/src/video_core/memory_manager.h
index 87658e87a..681bd9588 100644
--- a/src/video_core/memory_manager.h
+++ b/src/video_core/memory_manager.h
@@ -6,9 +6,9 @@
 #include <map>
 #include <optional>
+#include <vector>
 #include "common/common_types.h"
-#include "common/page_table.h"
 namespace VideoCore {
 class RasterizerInterface;
@@ -20,45 +20,57 @@ class System;
 namespace Tegra {
-/**
+class PageEntry final {
- * Represents a VMA in an address space. A VMA is a contiguous region of virtual addressing space
+public:
- * with homogeneous attributes across its extents. In this particular implementation each VMA is
+    enum class State : u32 {
- * also backed by a single host memory allocation.
+        Unmapped = static_cast<u32>(-1),
- */
+        Allocated = static_cast<u32>(-2),
-struct VirtualMemoryArea {
-    enum class Type : u8 {
-        Unmapped,
-        Allocated,
-        Mapped,
    };
-    /// Virtual base address of the region.
+    constexpr PageEntry() = default;
-    GPUVAddr base{};
+    constexpr PageEntry(State state) : state{state} {}
-    /// Size of the region.
+    constexpr PageEntry(VAddr addr) : state{static_cast<State>(addr >> ShiftBits)} {}
-    u64 size{};
-    /// Memory area mapping type.
+    constexpr bool IsUnmapped() const {
-    Type type{Type::Unmapped};
+        return state == State::Unmapped;
-    /// CPU memory mapped address corresponding to this memory area.
+    }
-    VAddr backing_addr{};
-    /// Offset into the backing_memory the mapping starts from.
+    constexpr bool IsAllocated() const {
-    std::size_t offset{};
+        return state == State::Allocated;
-    /// Pointer backing this VMA.
+    }
-    u8* backing_memory{};
+    constexpr bool IsValid() const {
-    /// Tests if this area can be merged to the right with `next`.
+        return !IsUnmapped() && !IsAllocated();
-    bool CanBeMergedWith(const VirtualMemoryArea& next) const;
+    }
+    constexpr VAddr ToAddress() const {
+        if (!IsValid()) {
+            return {};
+        }
+        return static_cast<VAddr>(state) << ShiftBits;
+    }
+    constexpr PageEntry operator+(u64 offset) {
+        // If this is a reserved value, offsets do not apply
+        if (!IsValid()) {
+            return *this;
+        }
+        return PageEntry{(static_cast<VAddr>(state) << ShiftBits) + offset};
+    }
+private:
+    static constexpr std::size_t ShiftBits{12};
+    State state{State::Unmapped};
 };
+static_assert(sizeof(PageEntry) == 4, "PageEntry is too large");
 class MemoryManager final {
 public:
    explicit MemoryManager(Core::System& system, VideoCore::RasterizerInterface& rasterizer);
    ~MemoryManager();
-    GPUVAddr AllocateSpace(u64 size, u64 align);
-    GPUVAddr AllocateSpace(GPUVAddr addr, u64 size, u64 align);
-    GPUVAddr MapBufferEx(VAddr cpu_addr, u64 size);
-    GPUVAddr MapBufferEx(VAddr cpu_addr, GPUVAddr addr, u64 size);
-    GPUVAddr UnmapBuffer(GPUVAddr addr, u64 size);
    std::optional<VAddr> GpuToCpuAddress(GPUVAddr addr) const;
    template <typename T>
@@ -70,9 +82,6 @@ public:
    u8* GetPointer(GPUVAddr addr);
    const u8* GetPointer(GPUVAddr addr) const;
-    /// Returns true if the block is continuous in host memory, false otherwise
-    bool IsBlockContinuous(GPUVAddr start, std::size_t size) const;
    /**
     * ReadBlock and WriteBlock are full read and write operations over virtual
     * GPU Memory. It's important to use these when GPU memory may not be continuous
@@ -98,92 +107,43 @@ public:
    void CopyBlockUnsafe(GPUVAddr gpu_dest_addr, GPUVAddr gpu_src_addr, std::size_t size);
    /**
-     * IsGranularRange checks if a gpu region can be simply read with a pointer
+     * IsGranularRange checks if a gpu region can be simply read with a pointer.
     */
    bool IsGranularRange(GPUVAddr gpu_addr, std::size_t size);
-private:
+    GPUVAddr Map(VAddr cpu_addr, GPUVAddr gpu_addr, std::size_t size);
-    using VMAMap = std::map<GPUVAddr, VirtualMemoryArea>;
+    GPUVAddr MapAllocate(VAddr cpu_addr, std::size_t size, std::size_t align);
-    using VMAHandle = VMAMap::const_iterator;
+    std::optional<GPUVAddr> AllocateFixed(GPUVAddr gpu_addr, std::size_t size);
-    using VMAIter = VMAMap::iterator;
+    GPUVAddr Allocate(std::size_t size, std::size_t align);
+    void Unmap(GPUVAddr gpu_addr, std::size_t size);
-    bool IsAddressValid(GPUVAddr addr) const;
-    void MapPages(GPUVAddr base, u64 size, u8* memory, Common::PageType type,
-                  VAddr backing_addr = 0);
-    void MapMemoryRegion(GPUVAddr base, u64 size, u8* target, VAddr backing_addr);
-    void UnmapRegion(GPUVAddr base, u64 size);
-    /// Finds the VMA in which the given address is included in, or `vma_map.end()`.
-    VMAHandle FindVMA(GPUVAddr target) const;
-    VMAHandle AllocateMemory(GPUVAddr target, std::size_t offset, u64 size);
-    /**
-     * Maps an unmanaged host memory pointer at a given address.
-     *
-     * @param target       The guest address to start the mapping at.
-     * @param memory       The memory to be mapped.
-     * @param size         Size of the mapping in bytes.
-     * @param backing_addr The base address of the range to back this mapping.
-     */
-    VMAHandle MapBackingMemory(GPUVAddr target, u8* memory, u64 size, VAddr backing_addr);
-    /// Unmaps a range of addresses, splitting VMAs as necessary.
-    void UnmapRange(GPUVAddr target, u64 size);
-    /// Converts a VMAHandle to a mutable VMAIter.
-    VMAIter StripIterConstness(const VMAHandle& iter);
-    /// Marks as the specified VMA as allocated.
-    VMAIter Allocate(VMAIter vma);
-    /**
-     * Carves a VMA of a specific size at the specified address by splitting Free VMAs while doing
-     * the appropriate error checking.
-     */
-    VMAIter CarveVMA(GPUVAddr base, u64 size);
-    /**
-     * Splits the edges of the given range of non-Free VMAs so that there is a VMA split at each
-     * end of the range.
-     */
-    VMAIter CarveVMARange(GPUVAddr base, u64 size);
-    /**
-     * Splits a VMA in two, at the specified offset.
-     * @returns the right side of the split, with the original iterator becoming the left side.
-     */
-    VMAIter SplitVMA(VMAIter vma, u64 offset_in_vma);
-    /**
+private:
-     * Checks for and merges the specified VMA with adjacent ones if possible.
+    PageEntry GetPageEntry(GPUVAddr gpu_addr) const;
-     * @returns the merged VMA or the original if no merging was possible.
+    void SetPageEntry(GPUVAddr gpu_addr, PageEntry page_entry, std::size_t size = page_size);
-     */
+    GPUVAddr UpdateRange(GPUVAddr gpu_addr, PageEntry page_entry, std::size_t size);
-    VMAIter MergeAdjacent(VMAIter vma);
+    std::optional<GPUVAddr> FindFreeRange(std::size_t size, std::size_t align) const;
-    /// Updates the pages corresponding to this VMA so they match the VMA's attributes.
+    void TryLockPage(PageEntry page_entry, std::size_t size);
-    void UpdatePageTableForVMA(const VirtualMemoryArea& vma);
+    void TryUnlockPage(PageEntry page_entry, std::size_t size);
-    /// Finds a free (unmapped region) of the specified size starting at the specified address.
+    static constexpr std::size_t PageEntryIndex(GPUVAddr gpu_addr) {
-    GPUVAddr FindFreeRegion(GPUVAddr region_start, u64 size) const;
+        return (gpu_addr >> page_bits) & page_table_mask;
+    }
-private:
+    static constexpr u64 address_space_size = 1ULL << 40;
+    static constexpr u64 address_space_start = 1ULL << 32;
    static constexpr u64 page_bits{16};
    static constexpr u64 page_size{1 << page_bits};
    static constexpr u64 page_mask{page_size - 1};
+    static constexpr u64 page_table_bits{24};
+    static constexpr u64 page_table_size{1 << page_table_bits};
+    static constexpr u64 page_table_mask{page_table_size - 1};
-    /// Address space in bits, according to Tegra X1 TRM
+    Core::System& system;
-    static constexpr u32 address_space_width{40};
-    /// Start address for mapping, this is fairly arbitrary but must be non-zero.
-    static constexpr GPUVAddr address_space_base{0x100000};
-    /// End of address space, based on address space in bits.
-    static constexpr GPUVAddr address_space_end{1ULL << address_space_width};
-    Common::PageTable page_table;
-    VMAMap vma_map;
    VideoCore::RasterizerInterface& rasterizer;
-    Core::System& system;
+    std::vector<PageEntry> page_table;
 };
 } // namespace Tegra
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp
index 03e82c599..cb284db77 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp
@@ -178,16 +178,11 @@ RasterizerOpenGL::RasterizerOpenGL(Core::System& system, Core::Frontend::EmuWind
    if (device.UseAsynchronousShaders()) {
        // Max worker threads we should allow
-        constexpr auto MAX_THREADS = 2u;
+        constexpr u32 MAX_THREADS = 4;
-        // Amount of threads we should reserve for other parts of yuzu
+        // Deduce how many threads we can use
-        constexpr auto RESERVED_THREADS = 6u;
+        const u32 threads_used = std::thread::hardware_concurrency() / 4;
-        // Get the amount of threads we can use(this can return zero)
-        const auto cpu_thread_count =
-            std::max(RESERVED_THREADS, std::thread::hardware_concurrency());
-        // Deduce how many "extra" threads we have to use.
-        const auto max_threads_unused = cpu_thread_count - RESERVED_THREADS;
        // Always allow at least 1 thread regardless of our settings
-        const auto max_worker_count = std::max(1u, max_threads_unused);
+        const auto max_worker_count = std::max(1U, threads_used);
        // Don't use more than MAX_THREADS
        const auto worker_count = std::min(max_worker_count, MAX_THREADS);
        async_shaders.AllocateWorkers(worker_count);
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.cpp b/src/video_core/renderer_opengl/gl_shader_cache.cpp
index be71e1733..eb49a36bf 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -403,7 +403,7 @@ void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
        }
    };
-    const auto num_workers{static_cast<std::size_t>(std::thread::hardware_concurrency() + 1ULL)};
+    const std::size_t num_workers{std::max(1U, std::thread::hardware_concurrency())};
    const std::size_t bucket_size{transferable->size() / num_workers};
    std::vector<std::unique_ptr<Core::Frontend::GraphicsContext>> contexts(num_workers);
    std::vector<std::thread> threads(num_workers);
diff --git a/src/video_core/renderer_vulkan/vk_blit_screen.cpp b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
index ce53e5a6b..a551e3de8 100644
--- a/src/video_core/renderer_vulkan/vk_blit_screen.cpp
+++ b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
@@ -696,6 +696,7 @@ void VKBlitScreen::CreateFramebuffers() {
        .flags = 0,
        .renderPass = *renderpass,
        .attachmentCount = 1,
+        .pAttachments = nullptr,
        .width = size.width,
        .height = size.height,
        .layers = 1,
diff --git a/src/video_core/renderer_vulkan/vk_device.cpp b/src/video_core/renderer_vulkan/vk_device.cpp
index 6245e0d78..0c03e4d83 100644
--- a/src/video_core/renderer_vulkan/vk_device.cpp
+++ b/src/video_core/renderer_vulkan/vk_device.cpp
@@ -771,8 +771,9 @@ std::vector<VkDeviceQueueCreateInfo> VKDevice::GetDeviceQueueCreateInfos() const
            .pNext = nullptr,
            .flags = 0,
            .queueFamilyIndex = queue_family,
+            .queueCount = 1,
+            .pQueuePriorities = nullptr,
        });
-        ci.queueCount = 1;
        ci.pQueuePriorities = &QUEUE_PRIORITY;
    }
diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
index 42b3a744c..418c62bc4 100644
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -261,8 +261,13 @@ VKComputePipeline& VKPipelineCache::GetComputePipeline(const ComputePipelineCach
    }
    const Specialization specialization{
+        .base_binding = 0,
        .workgroup_size = key.workgroup_size,
        .shared_memory_size = key.shared_memory_size,
+        .point_size = std::nullopt,
+        .enabled_attributes = {},
+        .attribute_types = {},
+        .ndc_minus_one_to_one = false,
    };
    const SPIRVShader spirv_shader{Decompile(device, shader->GetIR(), ShaderType::Compute,
                                             shader->GetRegistry(), specialization),
diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.cpp b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
index 2ed2004f0..7500e8244 100644
--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -815,8 +815,13 @@ bool RasterizerVulkan::WalkAttachmentOverlaps(const CachedSurfaceView& attachmen
 std::tuple<VkFramebuffer, VkExtent2D> RasterizerVulkan::ConfigureFramebuffers(
    VkRenderPass renderpass) {
-    FramebufferCacheKey key{renderpass, std::numeric_limits<u32>::max(),
+    FramebufferCacheKey key{
-                            std::numeric_limits<u32>::max(), std::numeric_limits<u32>::max()};
+        .renderpass = renderpass,
+        .width = std::numeric_limits<u32>::max(),
+        .height = std::numeric_limits<u32>::max(),
+        .layers = std::numeric_limits<u32>::max(),
+        .views = {},
+    };
    const auto try_push = [&key](const View& view) {
        if (!view) {
diff --git a/src/video_core/renderer_vulkan/vk_sampler_cache.cpp b/src/video_core/renderer_vulkan/vk_sampler_cache.cpp
index 2d5460776..b068888f9 100644
--- a/src/video_core/renderer_vulkan/vk_sampler_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_sampler_cache.cpp
@@ -47,6 +47,7 @@ vk::Sampler VKSamplerCache::CreateSampler(const Tegra::Texture::TSCEntry& tsc) c
    VkSamplerCustomBorderColorCreateInfoEXT border{
        .sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
        .pNext = nullptr,
+        .customBorderColor = {},
        .format = VK_FORMAT_UNDEFINED,
    };
    std::memcpy(&border.customBorderColor, color.data(), sizeof(color));
diff --git a/src/video_core/renderer_vulkan/vk_swapchain.cpp b/src/video_core/renderer_vulkan/vk_swapchain.cpp
index c25e312b6..6bfd2abae 100644
--- a/src/video_core/renderer_vulkan/vk_swapchain.cpp
+++ b/src/video_core/renderer_vulkan/vk_swapchain.cpp
@@ -156,6 +156,7 @@ void VKSwapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities,
        .minImageCount = requested_image_count,
        .imageFormat = surface_format.format,
        .imageColorSpace = surface_format.colorSpace,
+        .imageExtent = {},
        .imageArrayLayers = 1,
        .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
        .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
@@ -204,6 +205,7 @@ void VKSwapchain::CreateImageViews() {
        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
+        .image = {},
        .viewType = VK_IMAGE_VIEW_TYPE_2D,
        .format = image_format,
        .components =
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
index d102e6d27..2c6f54101 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
@@ -138,6 +138,7 @@ VkImageCreateInfo GenerateImageCreateInfo(const VKDevice& device, const SurfaceP
        .flags = 0,
        .imageType = SurfaceTargetToImage(params.target),
        .format = format,
+        .extent = {},
        .mipLevels = params.num_levels,
        .arrayLayers = static_cast<u32>(params.GetNumLayers()),
        .samples = VK_SAMPLE_COUNT_1_BIT,
@@ -458,6 +459,7 @@ VkImageView CachedSurfaceView::GetAttachment() {
        .pNext = nullptr,
        .flags = 0,
        .image = surface.GetImageHandle(),
+        .viewType = VK_IMAGE_VIEW_TYPE_1D,
        .format = surface.GetImage().GetFormat(),
        .components =
            {
@@ -471,6 +473,8 @@ VkImageView CachedSurfaceView::GetAttachment() {
                .aspectMask = aspect_mask,
                .baseMipLevel = base_level,
                .levelCount = num_levels,
+                .baseArrayLayer = 0,
+                .layerCount = 0,
            },
    };
    if (image_view_type == VK_IMAGE_VIEW_TYPE_3D) {
diff --git a/src/video_core/renderer_vulkan/wrapper.h b/src/video_core/renderer_vulkan/wrapper.h
index 71daac9d7..31885ef42 100644
--- a/src/video_core/renderer_vulkan/wrapper.h
+++ b/src/video_core/renderer_vulkan/wrapper.h
@@ -756,8 +756,8 @@ public:
    }
    VkResult GetQueryResults(VkQueryPool query_pool, u32 first, u32 count, std::size_t data_size,
-                             void* data, VkDeviceSize stride, VkQueryResultFlags flags) const
+                             void* data, VkDeviceSize stride,
-        noexcept {
+                             VkQueryResultFlags flags) const noexcept {
        return dld->vkGetQueryPoolResults(handle, query_pool, first, count, data_size, data, stride,
                                          flags);
    }
@@ -849,8 +849,8 @@ public:
        dld->vkCmdBindPipeline(handle, bind_point, pipeline);
    }
-    void BindIndexBuffer(VkBuffer buffer, VkDeviceSize offset, VkIndexType index_type) const
+    void BindIndexBuffer(VkBuffer buffer, VkDeviceSize offset,
-        noexcept {
+                         VkIndexType index_type) const noexcept {
        dld->vkCmdBindIndexBuffer(handle, buffer, offset, index_type);
    }
@@ -863,8 +863,8 @@ public:
        BindVertexBuffers(binding, 1, &buffer, &offset);
    }
-    void Draw(u32 vertex_count, u32 instance_count, u32 first_vertex, u32 first_instance) const
+    void Draw(u32 vertex_count, u32 instance_count, u32 first_vertex,
-        noexcept {
+              u32 first_instance) const noexcept {
        dld->vkCmdDraw(handle, vertex_count, instance_count, first_vertex, first_instance);
    }
@@ -874,15 +874,15 @@ public:
                              first_instance);
    }
-    void ClearAttachments(Span<VkClearAttachment> attachments, Span<VkClearRect> rects) const
+    void ClearAttachments(Span<VkClearAttachment> attachments,
-        noexcept {
+                          Span<VkClearRect> rects) const noexcept {
        dld->vkCmdClearAttachments(handle, attachments.size(), attachments.data(), rects.size(),
                                   rects.data());
    }
    void BlitImage(VkImage src_image, VkImageLayout src_layout, VkImage dst_image,
-                   VkImageLayout dst_layout, Span<VkImageBlit> regions, VkFilter filter) const
+                   VkImageLayout dst_layout, Span<VkImageBlit> regions,
-        noexcept {
+                   VkFilter filter) const noexcept {
        dld->vkCmdBlitImage(handle, src_image, src_layout, dst_image, dst_layout, regions.size(),
                            regions.data(), filter);
    }
@@ -907,8 +907,8 @@ public:
                                    regions.data());
    }
-    void CopyBuffer(VkBuffer src_buffer, VkBuffer dst_buffer, Span<VkBufferCopy> regions) const
+    void CopyBuffer(VkBuffer src_buffer, VkBuffer dst_buffer,
-        noexcept {
+                    Span<VkBufferCopy> regions) const noexcept {
        dld->vkCmdCopyBuffer(handle, src_buffer, dst_buffer, regions.size(), regions.data());
    }
@@ -924,8 +924,8 @@ public:
                                    regions.data());
    }
-    void FillBuffer(VkBuffer dst_buffer, VkDeviceSize dst_offset, VkDeviceSize size, u32 data) const
+    void FillBuffer(VkBuffer dst_buffer, VkDeviceSize dst_offset, VkDeviceSize size,
-        noexcept {
+                    u32 data) const noexcept {
        dld->vkCmdFillBuffer(handle, dst_buffer, dst_offset, size, data);
    }
diff --git a/src/video_core/shader/control_flow.cpp b/src/video_core/shader/control_flow.cpp
index 8d86020f6..336397cdb 100644
--- a/src/video_core/shader/control_flow.cpp
+++ b/src/video_core/shader/control_flow.cpp
@@ -187,24 +187,26 @@ std::optional<std::pair<BufferInfo, u64>> TrackLDC(const CFGRebuildState& state,
 std::optional<u64> TrackSHLRegister(const CFGRebuildState& state, u32& pos,
                                    u64 ldc_tracked_register) {
-    return TrackInstruction<u64>(state, pos,
+    return TrackInstruction<u64>(
-                                 [ldc_tracked_register](auto instr, const auto& opcode) {
+        state, pos,
-                                     return opcode.GetId() == OpCode::Id::SHL_IMM &&
+        [ldc_tracked_register](auto instr, const auto& opcode) {
-                                            instr.gpr0.Value() == ldc_tracked_register;
+            return opcode.GetId() == OpCode::Id::SHL_IMM &&
-                                 },
+                   instr.gpr0.Value() == ldc_tracked_register;
-                                 [](auto instr, const auto&) { return instr.gpr8.Value(); });
+        },
+        [](auto instr, const auto&) { return instr.gpr8.Value(); });
 }
 std::optional<u32> TrackIMNMXValue(const CFGRebuildState& state, u32& pos,
                                   u64 shl_tracked_register) {
-    return TrackInstruction<u32>(state, pos,
+    return TrackInstruction<u32>(
-                                 [shl_tracked_register](auto instr, const auto& opcode) {
+        state, pos,
-                                     return opcode.GetId() == OpCode::Id::IMNMX_IMM &&
+        [shl_tracked_register](auto instr, const auto& opcode) {
-                                            instr.gpr0.Value() == shl_tracked_register;
+            return opcode.GetId() == OpCode::Id::IMNMX_IMM &&
-                                 },
+                   instr.gpr0.Value() == shl_tracked_register;
-                                 [](auto instr, const auto&) {
+        },
-                                     return static_cast<u32>(instr.alu.GetSignedImm20_20() + 1);
+        [](auto instr, const auto&) {
-                                 });
+            return static_cast<u32>(instr.alu.GetSignedImm20_20() + 1);
+        });
 }
 std::optional<BranchIndirectInfo> TrackBranchIndirectInfo(const CFGRebuildState& state, u32 pos) {
diff --git a/src/video_core/shader/decode/memory.cpp b/src/video_core/shader/decode/memory.cpp
index 63adbc4a3..e4739394d 100644
--- a/src/video_core/shader/decode/memory.cpp
+++ b/src/video_core/shader/decode/memory.cpp
@@ -471,9 +471,9 @@ std::tuple<Node, Node, GlobalMemoryBase> ShaderIR::TrackGlobalMemory(NodeBlock&
    const auto [base_address, index, offset] =
        TrackCbuf(addr_register, global_code, static_cast<s64>(global_code.size()));
-    ASSERT_OR_EXECUTE_MSG(base_address != nullptr,
+    ASSERT_OR_EXECUTE_MSG(
-                          { return std::make_tuple(nullptr, nullptr, GlobalMemoryBase{}); },
+        base_address != nullptr, { return std::make_tuple(nullptr, nullptr, GlobalMemoryBase{}); },
-                          "Global memory tracking failed");
+        "Global memory tracking failed");
    bb.push_back(Comment(fmt::format("Base address is c[0x{:x}][0x{:x}]", index, offset)));
diff --git a/src/video_core/texture_cache/surface_params.cpp b/src/video_core/texture_cache/surface_params.cpp
index 9e5fe2374..e614a92df 100644
--- a/src/video_core/texture_cache/surface_params.cpp
+++ b/src/video_core/texture_cache/surface_params.cpp
@@ -74,9 +74,9 @@ SurfaceParams SurfaceParams::CreateForTexture(const FormatLookupTable& lookup_ta
    SurfaceParams params;
    params.is_tiled = tic.IsTiled();
    params.srgb_conversion = tic.IsSrgbConversionEnabled();
-    params.block_width = params.is_tiled ? tic.BlockWidth() : 0,
+    params.block_width = params.is_tiled ? tic.BlockWidth() : 0;
-    params.block_height = params.is_tiled ? tic.BlockHeight() : 0,
+    params.block_height = params.is_tiled ? tic.BlockHeight() : 0;
-    params.block_depth = params.is_tiled ? tic.BlockDepth() : 0,
+    params.block_depth = params.is_tiled ? tic.BlockDepth() : 0;
    params.tile_width_spacing = params.is_tiled ? (1 << tic.tile_width_spacing.Value()) : 1;
    params.pixel_format = lookup_table.GetPixelFormat(
        tic.format, params.srgb_conversion, tic.r_type, tic.g_type, tic.b_type, tic.a_type);
@@ -96,7 +96,6 @@ SurfaceParams SurfaceParams::CreateForTexture(const FormatLookupTable& lookup_ta
        }
        params.type = GetFormatType(params.pixel_format);
    }
-    params.type = GetFormatType(params.pixel_format);
    // TODO: on 1DBuffer we should use the tic info.
    if (tic.IsBuffer()) {
        params.target = SurfaceTarget::TextureBuffer;
@@ -130,14 +129,13 @@ SurfaceParams SurfaceParams::CreateForImage(const FormatLookupTable& lookup_tabl
    SurfaceParams params;
    params.is_tiled = tic.IsTiled();
    params.srgb_conversion = tic.IsSrgbConversionEnabled();
-    params.block_width = params.is_tiled ? tic.BlockWidth() : 0,
+    params.block_width = params.is_tiled ? tic.BlockWidth() : 0;
-    params.block_height = params.is_tiled ? tic.BlockHeight() : 0,
+    params.block_height = params.is_tiled ? tic.BlockHeight() : 0;
-    params.block_depth = params.is_tiled ? tic.BlockDepth() : 0,
+    params.block_depth = params.is_tiled ? tic.BlockDepth() : 0;
    params.tile_width_spacing = params.is_tiled ? (1 << tic.tile_width_spacing.Value()) : 1;
    params.pixel_format = lookup_table.GetPixelFormat(
        tic.format, params.srgb_conversion, tic.r_type, tic.g_type, tic.b_type, tic.a_type);
    params.type = GetFormatType(params.pixel_format);
-    params.type = GetFormatType(params.pixel_format);
    params.target = ImageTypeToSurfaceTarget(entry.type);
    // TODO: on 1DBuffer we should use the tic info.
    if (tic.IsBuffer()) {
@@ -167,27 +165,30 @@ SurfaceParams SurfaceParams::CreateForImage(const FormatLookupTable& lookup_tabl
 SurfaceParams SurfaceParams::CreateForDepthBuffer(Core::System& system) {
    const auto& regs = system.GPU().Maxwell3D().regs;
-    SurfaceParams params;
-    params.is_tiled = regs.zeta.memory_layout.type ==
-                      Tegra::Engines::Maxwell3D::Regs::InvMemoryLayout::BlockLinear;
-    params.srgb_conversion = false;
-    params.block_width = std::min(regs.zeta.memory_layout.block_width.Value(), 5U);
-    params.block_height = std::min(regs.zeta.memory_layout.block_height.Value(), 5U);
-    params.block_depth = std::min(regs.zeta.memory_layout.block_depth.Value(), 5U);
-    params.tile_width_spacing = 1;
-    params.pixel_format = PixelFormatFromDepthFormat(regs.zeta.format);
-    params.type = GetFormatType(params.pixel_format);
-    params.width = regs.zeta_width;
-    params.height = regs.zeta_height;
-    params.pitch = 0;
-    params.num_levels = 1;
-    params.emulated_levels = 1;
-    const bool is_layered = regs.zeta_layers > 1 && params.block_depth == 0;
+    const auto block_depth = std::min(regs.zeta.memory_layout.block_depth.Value(), 5U);
-    params.is_layered = is_layered;
+    const bool is_layered = regs.zeta_layers > 1 && block_depth == 0;
-    params.target = is_layered ? SurfaceTarget::Texture2DArray : SurfaceTarget::Texture2D;
+    const auto pixel_format = PixelFormatFromDepthFormat(regs.zeta.format);
-    params.depth = is_layered ? regs.zeta_layers.Value() : 1U;
-    return params;
+    return {
+        .is_tiled = regs.zeta.memory_layout.type ==
+                    Tegra::Engines::Maxwell3D::Regs::InvMemoryLayout::BlockLinear,
+        .srgb_conversion = false,
+        .is_layered = is_layered,
+        .block_width = std::min(regs.zeta.memory_layout.block_width.Value(), 5U),
+        .block_height = std::min(regs.zeta.memory_layout.block_height.Value(), 5U),
+        .block_depth = block_depth,
+        .tile_width_spacing = 1,
+        .width = regs.zeta_width,
+        .height = regs.zeta_height,
+        .depth = is_layered ? regs.zeta_layers.Value() : 1U,
+        .pitch = 0,
+        .num_levels = 1,
+        .emulated_levels = 1,
+        .pixel_format = pixel_format,
+        .type = GetFormatType(pixel_format),
+        .target = is_layered ? SurfaceTarget::Texture2DArray : SurfaceTarget::Texture2D,
+    };
 }
 SurfaceParams SurfaceParams::CreateForFramebuffer(Core::System& system, std::size_t index) {
@@ -233,24 +234,29 @@ SurfaceParams SurfaceParams::CreateForFramebuffer(Core::System& system, std::siz
 SurfaceParams SurfaceParams::CreateForFermiCopySurface(
    const Tegra::Engines::Fermi2D::Regs::Surface& config) {
-    SurfaceParams params{};
+    const bool is_tiled = !config.linear;
-    params.is_tiled = !config.linear;
+    const auto pixel_format = PixelFormatFromRenderTargetFormat(config.format);
-    params.srgb_conversion = config.format == Tegra::RenderTargetFormat::B8G8R8A8_SRGB ||
-                             config.format == Tegra::RenderTargetFormat::A8B8G8R8_SRGB;
+    SurfaceParams params{
-    params.block_width = params.is_tiled ? std::min(config.BlockWidth(), 5U) : 0,
+        .is_tiled = is_tiled,
-    params.block_height = params.is_tiled ? std::min(config.BlockHeight(), 5U) : 0,
+        .srgb_conversion = config.format == Tegra::RenderTargetFormat::B8G8R8A8_SRGB ||
-    params.block_depth = params.is_tiled ? std::min(config.BlockDepth(), 5U) : 0,
+                           config.format == Tegra::RenderTargetFormat::A8B8G8R8_SRGB,
-    params.tile_width_spacing = 1;
+        .block_width = is_tiled ? std::min(config.BlockWidth(), 5U) : 0U,
-    params.pixel_format = PixelFormatFromRenderTargetFormat(config.format);
+        .block_height = is_tiled ? std::min(config.BlockHeight(), 5U) : 0U,
-    params.type = GetFormatType(params.pixel_format);
+        .block_depth = is_tiled ? std::min(config.BlockDepth(), 5U) : 0U,
-    params.width = config.width;
+        .tile_width_spacing = 1,
-    params.height = config.height;
+        .width = config.width,
-    params.pitch = config.pitch;
+        .height = config.height,
-    // TODO(Rodrigo): Try to guess texture arrays from parameters
+        .depth = 1,
-    params.target = SurfaceTarget::Texture2D;
+        .pitch = config.pitch,
-    params.depth = 1;
+        .num_levels = 1,
-    params.num_levels = 1;
+        .emulated_levels = 1,
-    params.emulated_levels = 1;
+        .pixel_format = pixel_format,
+        .type = GetFormatType(pixel_format),
+        // TODO(Rodrigo): Try to guess texture arrays from parameters
+        .target = SurfaceTarget::Texture2D,
+    };
    params.is_layered = params.IsLayered();
    return params;
 }
diff --git a/src/video_core/textures/decoders.cpp b/src/video_core/textures/decoders.cpp
index 474ae620a..16d46a018 100644
--- a/src/video_core/textures/decoders.cpp
+++ b/src/video_core/textures/decoders.cpp
@@ -228,24 +228,30 @@ void SwizzleSubrect(u32 subrect_width, u32 subrect_height, u32 source_pitch, u32
    }
 }
-void UnswizzleSubrect(u32 subrect_width, u32 subrect_height, u32 dest_pitch, u32 swizzled_width,
+void UnswizzleSubrect(u32 line_length_in, u32 line_count, u32 pitch, u32 width, u32 bytes_per_pixel,
-                      u32 bytes_per_pixel, u8* swizzled_data, u8* unswizzled_data,
+                      u32 block_height, u32 origin_x, u32 origin_y, u8* output, const u8* input) {
-                      u32 block_height_bit, u32 offset_x, u32 offset_y) {
+    const u32 stride = width * bytes_per_pixel;
-    const u32 block_height = 1U << block_height_bit;
+    const u32 gobs_in_x = (stride + GOB_SIZE_X - 1) / GOB_SIZE_X;
-    for (u32 line = 0; line < subrect_height; ++line) {
+    const u32 block_size = gobs_in_x << (GOB_SIZE_SHIFT + block_height);
-        const u32 y2 = line + offset_y;
-        const u32 gob_address_y = (y2 / (GOB_SIZE_Y * block_height)) * GOB_SIZE * block_height +
+    const u32 block_height_mask = (1U << block_height) - 1;
-                                  ((y2 % (GOB_SIZE_Y * block_height)) / GOB_SIZE_Y) * GOB_SIZE;
+    const u32 x_shift = static_cast<u32>(GOB_SIZE_SHIFT) + block_height;
-        const auto& table = LEGACY_SWIZZLE_TABLE[y2 % GOB_SIZE_Y];
-        for (u32 x = 0; x < subrect_width; ++x) {
+    for (u32 line = 0; line < line_count; ++line) {
-            const u32 x2 = (x + offset_x) * bytes_per_pixel;
+        const u32 src_y = line + origin_y;
-            const u32 gob_address = gob_address_y + (x2 / GOB_SIZE_X) * GOB_SIZE * block_height;
+        const auto& table = LEGACY_SWIZZLE_TABLE[src_y % GOB_SIZE_Y];
-            const u32 swizzled_offset = gob_address + table[x2 % GOB_SIZE_X];
-            const u32 unswizzled_offset = line * dest_pitch + x * bytes_per_pixel;
+        const u32 block_y = src_y >> GOB_SIZE_Y_SHIFT;
-            u8* dest_line = unswizzled_data + unswizzled_offset;
+        const u32 src_offset_y = (block_y >> block_height) * block_size +
-            u8* source_addr = swizzled_data + swizzled_offset;
+                                 ((block_y & block_height_mask) << GOB_SIZE_SHIFT);
+        for (u32 column = 0; column < line_length_in; ++column) {
+            const u32 src_x = (column + origin_x) * bytes_per_pixel;
+            const u32 src_offset_x = (src_x >> GOB_SIZE_X_SHIFT) << x_shift;
+            const u32 swizzled_offset = src_offset_y + src_offset_x + table[src_x % GOB_SIZE_X];
+            const u32 unswizzled_offset = line * pitch + column * bytes_per_pixel;
-            std::memcpy(dest_line, source_addr, bytes_per_pixel);
+            std::memcpy(output + unswizzled_offset, input + swizzled_offset, bytes_per_pixel);
        }
    }
 }
@@ -261,7 +267,7 @@ void SwizzleSliceToVoxel(u32 line_length_in, u32 line_count, u32 pitch, u32 widt
    const u32 block_size = gobs_in_x << (GOB_SIZE_SHIFT + block_height + block_depth);
    const u32 block_height_mask = (1U << block_height) - 1;
-    const u32 x_shift = Common::CountTrailingZeroes32(GOB_SIZE << (block_height + block_depth));
+    const u32 x_shift = static_cast<u32>(GOB_SIZE_SHIFT) + block_height + block_depth;
    for (u32 line = 0; line < line_count; ++line) {
        const auto& table = LEGACY_SWIZZLE_TABLE[line % GOB_SIZE_Y];
diff --git a/src/video_core/textures/decoders.h b/src/video_core/textures/decoders.h
index d6fe35d37..01e156bc8 100644
--- a/src/video_core/textures/decoders.h
+++ b/src/video_core/textures/decoders.h
@@ -48,9 +48,8 @@ void SwizzleSubrect(u32 subrect_width, u32 subrect_height, u32 source_pitch, u32
                    u32 block_height_bit, u32 offset_x, u32 offset_y);
 /// Copies a tiled subrectangle into a linear surface.
-void UnswizzleSubrect(u32 subrect_width, u32 subrect_height, u32 dest_pitch, u32 swizzled_width,
+void UnswizzleSubrect(u32 line_length_in, u32 line_count, u32 pitch, u32 width, u32 bytes_per_pixel,
-                      u32 bytes_per_pixel, u8* swizzled_data, u8* unswizzled_data, u32 block_height,
+                      u32 block_height, u32 origin_x, u32 origin_y, u8* output, const u8* input);
-                      u32 offset_x, u32 offset_y);
 /// @brief Swizzles a 2D array of pixels into a 3D texture
 /// @param line_length_in  Number of pixels per line
diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp
index 5738787ac..8fc322b30 100644
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -567,7 +567,7 @@ void GRenderWindow::CaptureScreenshot(u32 res_scale, const QString& screenshot_p
    screenshot_image = QImage(QSize(layout.width, layout.height), QImage::Format_RGB32);
    renderer.RequestScreenshot(
        screenshot_image.bits(),
-        [=] {
+        [=, this] {
            const std::string std_screenshot_path = screenshot_path.toStdString();
            if (screenshot_image.mirrored(false, true).save(screenshot_path)) {
                LOG_INFO(Frontend, "Screenshot saved to \"{}\"", std_screenshot_path);
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index 59a193edd..cb71b8d11 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -578,7 +578,6 @@ void Config::ReadPathValues() {
    UISettings::values.roms_path = ReadSetting(QStringLiteral("romsPath")).toString();
    UISettings::values.symbols_path = ReadSetting(QStringLiteral("symbolsPath")).toString();
-    UISettings::values.screenshot_path = ReadSetting(QStringLiteral("screenshotPath")).toString();
    UISettings::values.game_dir_deprecated =
        ReadSetting(QStringLiteral("gameListRootDir"), QStringLiteral(".")).toString();
    UISettings::values.game_dir_deprecated_deepscan =
@@ -666,8 +665,6 @@ void Config::ReadRendererValues() {
                      QStringLiteral("use_asynchronous_shaders"), false);
    ReadSettingGlobal(Settings::values.use_fast_gpu_time, QStringLiteral("use_fast_gpu_time"),
                      true);
-    ReadSettingGlobal(Settings::values.force_30fps_mode, QStringLiteral("force_30fps_mode"), false);
    ReadSettingGlobal(Settings::values.bg_red, QStringLiteral("bg_red"), 0.0);
    ReadSettingGlobal(Settings::values.bg_green, QStringLiteral("bg_green"), 0.0);
    ReadSettingGlobal(Settings::values.bg_blue, QStringLiteral("bg_blue"), 0.0);
@@ -675,6 +672,22 @@ void Config::ReadRendererValues() {
    qt_config->endGroup();
 }
+void Config::ReadScreenshotValues() {
+    qt_config->beginGroup(QStringLiteral("Screenshots"));
+    UISettings::values.enable_screenshot_save_as =
+        ReadSetting(QStringLiteral("enable_screenshot_save_as"), true).toBool();
+    FileUtil::GetUserPath(
+        FileUtil::UserPath::ScreenshotsDir,
+        qt_config
+            ->value(QStringLiteral("screenshot_path"), QString::fromStdString(FileUtil::GetUserPath(
+                                                           FileUtil::UserPath::ScreenshotsDir)))
+            .toString()
+            .toStdString());
+    qt_config->endGroup();
+}
 void Config::ReadShortcutValues() {
    qt_config->beginGroup(QStringLiteral("Shortcuts"));
@@ -756,6 +769,7 @@ void Config::ReadUIValues() {
    ReadUIGamelistValues();
    ReadUILayoutValues();
    ReadPathValues();
+    ReadScreenshotValues();
    ReadShortcutValues();
    UISettings::values.single_window_mode =
@@ -1085,7 +1099,6 @@ void Config::SavePathValues() {
    WriteSetting(QStringLiteral("romsPath"), UISettings::values.roms_path);
    WriteSetting(QStringLiteral("symbolsPath"), UISettings::values.symbols_path);
-    WriteSetting(QStringLiteral("screenshotPath"), UISettings::values.screenshot_path);
    qt_config->beginWriteArray(QStringLiteral("gamedirs"));
    for (int i = 0; i < UISettings::values.game_dirs.size(); ++i) {
        qt_config->setArrayIndex(i);
@@ -1153,9 +1166,6 @@ void Config::SaveRendererValues() {
                       Settings::values.use_asynchronous_shaders, false);
    WriteSettingGlobal(QStringLiteral("use_fast_gpu_time"), Settings::values.use_fast_gpu_time,
                       true);
-    WriteSettingGlobal(QStringLiteral("force_30fps_mode"), Settings::values.force_30fps_mode,
-                       false);
    // Cast to double because Qt's written float values are not human-readable
    WriteSettingGlobal(QStringLiteral("bg_red"), Settings::values.bg_red, 0.0);
    WriteSettingGlobal(QStringLiteral("bg_green"), Settings::values.bg_green, 0.0);
@@ -1164,6 +1174,17 @@ void Config::SaveRendererValues() {
    qt_config->endGroup();
 }
+void Config::SaveScreenshotValues() {
+    qt_config->beginGroup(QStringLiteral("Screenshots"));
+    WriteSetting(QStringLiteral("enable_screenshot_save_as"),
+                 UISettings::values.enable_screenshot_save_as);
+    WriteSetting(QStringLiteral("screenshot_path"),
+                 QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::ScreenshotsDir)));
+    qt_config->endGroup();
+}
 void Config::SaveShortcutValues() {
    qt_config->beginGroup(QStringLiteral("Shortcuts"));
@@ -1226,6 +1247,7 @@ void Config::SaveUIValues() {
    SaveUIGamelistValues();
    SaveUILayoutValues();
    SavePathValues();
+    SaveScreenshotValues();
    SaveShortcutValues();
    WriteSetting(QStringLiteral("singleWindowMode"), UISettings::values.single_window_mode, true);
diff --git a/src/yuzu/configuration/config.h b/src/yuzu/configuration/config.h
index 8e815f829..e5f39b040 100644
--- a/src/yuzu/configuration/config.h
+++ b/src/yuzu/configuration/config.h
@@ -51,6 +51,7 @@ private:
    void ReadPathValues();
    void ReadCpuValues();
    void ReadRendererValues();
+    void ReadScreenshotValues();
    void ReadShortcutValues();
    void ReadSystemValues();
    void ReadUIValues();
@@ -76,6 +77,7 @@ private:
    void SavePathValues();
    void SaveCpuValues();
    void SaveRendererValues();
+    void SaveScreenshotValues();
    void SaveShortcutValues();
    void SaveSystemValues();
    void SaveUIValues();
diff --git a/src/yuzu/configuration/configure_debug.ui b/src/yuzu/configuration/configure_debug.ui
index 272bdd6b8..9d6feb9f7 100644
--- a/src/yuzu/configuration/configure_debug.ui
+++ b/src/yuzu/configuration/configure_debug.ui
@@ -171,26 +171,6 @@
     </property>
     <layout class="QVBoxLayout" name="verticalLayout_6">
      <item>
-       <widget class="QCheckBox" name="dump_decompressed_nso">
-        <property name="whatsThis">
-         <string>When checked, any NSO yuzu tries to load or patch will be copied decompressed to the yuzu/dump directory.</string>
-        </property>
-        <property name="text">
-         <string>Dump Decompressed NSOs</string>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <widget class="QCheckBox" name="dump_exefs">
-        <property name="whatsThis">
-         <string>When checked, any game that yuzu loads will have its ExeFS dumped to the yuzu/dump directory.</string>
-        </property>
-        <property name="text">
-         <string>Dump ExeFS</string>
-        </property>
-       </widget>
-      </item>
-      <item>
       <widget class="QCheckBox" name="reporting_services">
        <property name="text">
         <string>Enable Verbose Reporting Services</string>
@@ -257,8 +237,6 @@
  <tabstop>open_log_button</tabstop>
  <tabstop>homebrew_args_edit</tabstop>
  <tabstop>enable_graphics_debugging</tabstop>
-  <tabstop>dump_decompressed_nso</tabstop>
-  <tabstop>dump_exefs</tabstop>
  <tabstop>reporting_services</tabstop>
  <tabstop>quest_flag</tabstop>
 </tabstops>
diff --git a/src/yuzu/configuration/configure_graphics_advanced.cpp b/src/yuzu/configuration/configure_graphics_advanced.cpp
index 8b9180811..c5d1a778c 100644
--- a/src/yuzu/configuration/configure_graphics_advanced.cpp
+++ b/src/yuzu/configuration/configure_graphics_advanced.cpp
@@ -25,14 +25,12 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
    ui->use_vsync->setEnabled(runtime_lock);
    ui->use_assembly_shaders->setEnabled(runtime_lock);
    ui->use_asynchronous_shaders->setEnabled(runtime_lock);
-    ui->force_30fps_mode->setEnabled(runtime_lock);
    ui->anisotropic_filtering_combobox->setEnabled(runtime_lock);
    ui->use_vsync->setChecked(Settings::values.use_vsync.GetValue());
    ui->use_assembly_shaders->setChecked(Settings::values.use_assembly_shaders.GetValue());
    ui->use_asynchronous_shaders->setChecked(Settings::values.use_asynchronous_shaders.GetValue());
    ui->use_fast_gpu_time->setChecked(Settings::values.use_fast_gpu_time.GetValue());
-    ui->force_30fps_mode->setChecked(Settings::values.force_30fps_mode.GetValue());
    if (Settings::configuring_global) {
        ui->gpu_accuracy->setCurrentIndex(
@@ -78,9 +76,6 @@ void ConfigureGraphicsAdvanced::ApplyConfiguration() {
        if (Settings::values.use_fast_gpu_time.UsingGlobal()) {
            Settings::values.use_fast_gpu_time.SetValue(ui->use_fast_gpu_time->isChecked());
        }
-        if (Settings::values.force_30fps_mode.UsingGlobal()) {
-            Settings::values.force_30fps_mode.SetValue(ui->force_30fps_mode->isChecked());
-        }
        if (Settings::values.max_anisotropy.UsingGlobal()) {
            Settings::values.max_anisotropy.SetValue(
                ui->anisotropic_filtering_combobox->currentIndex());
@@ -97,8 +92,6 @@ void ConfigureGraphicsAdvanced::ApplyConfiguration() {
                                                 use_asynchronous_shaders);
        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_fast_gpu_time,
                                                 ui->use_fast_gpu_time, use_fast_gpu_time);
-        ConfigurationShared::ApplyPerGameSetting(&Settings::values.force_30fps_mode,
-                                                 ui->force_30fps_mode, force_30fps_mode);
        ConfigurationShared::ApplyPerGameSetting(&Settings::values.max_anisotropy,
                                                 ui->anisotropic_filtering_combobox);
@@ -132,7 +125,6 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
        ui->use_asynchronous_shaders->setEnabled(
            Settings::values.use_asynchronous_shaders.UsingGlobal());
        ui->use_fast_gpu_time->setEnabled(Settings::values.use_fast_gpu_time.UsingGlobal());
-        ui->force_30fps_mode->setEnabled(Settings::values.force_30fps_mode.UsingGlobal());
        ui->anisotropic_filtering_combobox->setEnabled(
            Settings::values.max_anisotropy.UsingGlobal());
@@ -149,8 +141,6 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
        Settings::values.use_asynchronous_shaders, use_asynchronous_shaders);
    ConfigurationShared::SetColoredTristate(ui->use_fast_gpu_time, "use_fast_gpu_time",
                                            Settings::values.use_fast_gpu_time, use_fast_gpu_time);
-    ConfigurationShared::SetColoredTristate(ui->force_30fps_mode, "force_30fps_mode",
-                                            Settings::values.force_30fps_mode, force_30fps_mode);
    ConfigurationShared::SetColoredComboBox(
        ui->gpu_accuracy, ui->label_gpu_accuracy, "label_gpu_accuracy",
        static_cast<int>(Settings::values.gpu_accuracy.GetValue(true)));
diff --git a/src/yuzu/configuration/configure_graphics_advanced.h b/src/yuzu/configuration/configure_graphics_advanced.h
index 3c4f6f7bb..e61b571c7 100644
--- a/src/yuzu/configuration/configure_graphics_advanced.h
+++ b/src/yuzu/configuration/configure_graphics_advanced.h
@@ -38,5 +38,4 @@ private:
    ConfigurationShared::CheckState use_assembly_shaders;
    ConfigurationShared::CheckState use_asynchronous_shaders;
    ConfigurationShared::CheckState use_fast_gpu_time;
-    ConfigurationShared::CheckState force_30fps_mode;
 };
diff --git a/src/yuzu/configuration/configure_graphics_advanced.ui b/src/yuzu/configuration/configure_graphics_advanced.ui
index 6a0d29c27..a793c803d 100644
--- a/src/yuzu/configuration/configure_graphics_advanced.ui
+++ b/src/yuzu/configuration/configure_graphics_advanced.ui
@@ -97,13 +97,6 @@
         </widget>
        </item>
        <item>
-         <widget class="QCheckBox" name="force_30fps_mode">
-          <property name="text">
-           <string>Force 30 FPS mode</string>
-          </property>
-         </widget>
-        </item>
-        <item>
         <widget class="QCheckBox" name="use_fast_gpu_time">
          <property name="text">
           <string>Use Fast GPU Time</string>
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index 00433926d..597defe8c 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -280,39 +280,41 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
        }
        button->setContextMenuPolicy(Qt::CustomContextMenu);
-        connect(button, &QPushButton::clicked, [=] {
+        connect(button, &QPushButton::clicked, [=, this] {
-            HandleClick(button_map[button_id],
+            HandleClick(
-                        [=](Common::ParamPackage params) {
+                button_map[button_id],
-                            // Workaround for ZL & ZR for analog triggers like on XBOX controllors.
+                [=, this](Common::ParamPackage params) {
-                            // Analog triggers (from controllers like the XBOX controller) would not
+                    // Workaround for ZL & ZR for analog triggers like on XBOX controllors.
-                            // work due to a different range of their signals (from 0 to 255 on
+                    // Analog triggers (from controllers like the XBOX controller) would not
-                            // analog triggers instead of -32768 to 32768 on analog joysticks). The
+                    // work due to a different range of their signals (from 0 to 255 on
-                            // SDL driver misinterprets analog triggers as analog joysticks.
+                    // analog triggers instead of -32768 to 32768 on analog joysticks). The
-                            // TODO: reinterpret the signal range for analog triggers to map the
+                    // SDL driver misinterprets analog triggers as analog joysticks.
-                            // values correctly. This is required for the correct emulation of the
+                    // TODO: reinterpret the signal range for analog triggers to map the
-                            // analog triggers of the GameCube controller.
+                    // values correctly. This is required for the correct emulation of the
-                            if (button_id == Settings::NativeButton::ZL ||
+                    // analog triggers of the GameCube controller.
-                                button_id == Settings::NativeButton::ZR) {
+                    if (button_id == Settings::NativeButton::ZL ||
-                                params.Set("direction", "+");
+                        button_id == Settings::NativeButton::ZR) {
-                                params.Set("threshold", "0.5");
+                        params.Set("direction", "+");
-                            }
+                        params.Set("threshold", "0.5");
-                            buttons_param[button_id] = std::move(params);
+                    }
-                        },
+                    buttons_param[button_id] = std::move(params);
-                        InputCommon::Polling::DeviceType::Button);
+                },
-        });
+                InputCommon::Polling::DeviceType::Button);
-        connect(button, &QPushButton::customContextMenuRequested, [=](const QPoint& menu_location) {
-            QMenu context_menu;
-            context_menu.addAction(tr("Clear"), [&] {
-                buttons_param[button_id].Clear();
-                button_map[button_id]->setText(tr("[not set]"));
-            });
-            context_menu.addAction(tr("Restore Default"), [&] {
-                buttons_param[button_id] = Common::ParamPackage{
-                    InputCommon::GenerateKeyboardParam(Config::default_buttons[button_id])};
-                button_map[button_id]->setText(ButtonToText(buttons_param[button_id]));
-            });
-            context_menu.exec(button_map[button_id]->mapToGlobal(menu_location));
        });
+        connect(button, &QPushButton::customContextMenuRequested,
+                [=, this](const QPoint& menu_location) {
+                    QMenu context_menu;
+                    context_menu.addAction(tr("Clear"), [&] {
+                        buttons_param[button_id].Clear();
+                        button_map[button_id]->setText(tr("[not set]"));
+                    });
+                    context_menu.addAction(tr("Restore Default"), [&] {
+                        buttons_param[button_id] = Common::ParamPackage{
+                            InputCommon::GenerateKeyboardParam(Config::default_buttons[button_id])};
+                        button_map[button_id]->setText(ButtonToText(buttons_param[button_id]));
+                    });
+                    context_menu.exec(button_map[button_id]->mapToGlobal(menu_location));
+                });
    }
    for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; analog_id++) {
@@ -323,16 +325,17 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
            }
            analog_button->setContextMenuPolicy(Qt::CustomContextMenu);
-            connect(analog_button, &QPushButton::clicked, [=]() {
+            connect(analog_button, &QPushButton::clicked, [=, this] {
-                HandleClick(analog_map_buttons[analog_id][sub_button_id],
+                HandleClick(
-                            [=](const Common::ParamPackage& params) {
+                    analog_map_buttons[analog_id][sub_button_id],
-                                SetAnalogButton(params, analogs_param[analog_id],
+                    [=, this](const Common::ParamPackage& params) {
-                                                analog_sub_buttons[sub_button_id]);
+                        SetAnalogButton(params, analogs_param[analog_id],
-                            },
+                                        analog_sub_buttons[sub_button_id]);
-                            InputCommon::Polling::DeviceType::Button);
+                    },
+                    InputCommon::Polling::DeviceType::Button);
            });
            connect(analog_button, &QPushButton::customContextMenuRequested,
-                    [=](const QPoint& menu_location) {
+                    [=, this](const QPoint& menu_location) {
                        QMenu context_menu;
                        context_menu.addAction(tr("Clear"), [&] {
                            analogs_param[analog_id].Erase(analog_sub_buttons[sub_button_id]);
@@ -350,7 +353,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
                            menu_location));
                    });
        }
-        connect(analog_map_stick[analog_id], &QPushButton::clicked, [=] {
+        connect(analog_map_stick[analog_id], &QPushButton::clicked, [=, this] {
            if (QMessageBox::information(
                    this, tr("Information"),
                    tr("After pressing OK, first move your joystick horizontally, "
@@ -358,24 +361,28 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
                    QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Ok) {
                HandleClick(
                    analog_map_stick[analog_id],
-                    [=](const Common::ParamPackage& params) { analogs_param[analog_id] = params; },
+                    [=, this](const Common::ParamPackage& params) {
+                        analogs_param[analog_id] = params;
+                    },
                    InputCommon::Polling::DeviceType::Analog);
            }
        });
-        connect(analog_map_deadzone_and_modifier_slider[analog_id], &QSlider::valueChanged, [=] {
+        connect(analog_map_deadzone_and_modifier_slider[analog_id], &QSlider::valueChanged,
-            const float slider_value = analog_map_deadzone_and_modifier_slider[analog_id]->value();
+                [=, this] {
-            if (analogs_param[analog_id].Get("engine", "") == "sdl" ||
+                    const float slider_value =
-                analogs_param[analog_id].Get("engine", "") == "gcpad") {
+                        analog_map_deadzone_and_modifier_slider[analog_id]->value();
-                analog_map_deadzone_and_modifier_slider_label[analog_id]->setText(
+                    if (analogs_param[analog_id].Get("engine", "") == "sdl" ||
-                    tr("Deadzone: %1%").arg(slider_value));
+                        analogs_param[analog_id].Get("engine", "") == "gcpad") {
-                analogs_param[analog_id].Set("deadzone", slider_value / 100.0f);
+                        analog_map_deadzone_and_modifier_slider_label[analog_id]->setText(
-            } else {
+                            tr("Deadzone: %1%").arg(slider_value));
-                analog_map_deadzone_and_modifier_slider_label[analog_id]->setText(
+                        analogs_param[analog_id].Set("deadzone", slider_value / 100.0f);
-                    tr("Modifier Scale: %1%").arg(slider_value));
+                    } else {
-                analogs_param[analog_id].Set("modifier_scale", slider_value / 100.0f);
+                        analog_map_deadzone_and_modifier_slider_label[analog_id]->setText(
-            }
+                            tr("Modifier Scale: %1%").arg(slider_value));
-        });
+                        analogs_param[analog_id].Set("modifier_scale", slider_value / 100.0f);
+                    }
+                });
    }
    connect(ui->buttonClearAll, &QPushButton::clicked, [this] { ClearAll(); });
diff --git a/src/yuzu/configuration/configure_mouse_advanced.cpp b/src/yuzu/configuration/configure_mouse_advanced.cpp
index e0647ea5b..5bcf5ffa8 100644
--- a/src/yuzu/configuration/configure_mouse_advanced.cpp
+++ b/src/yuzu/configuration/configure_mouse_advanced.cpp
@@ -83,25 +83,29 @@ ConfigureMouseAdvanced::ConfigureMouseAdvanced(QWidget* parent)
        }
        button->setContextMenuPolicy(Qt::CustomContextMenu);
-        connect(button, &QPushButton::clicked, [=] {
+        connect(button, &QPushButton::clicked, [=, this] {
            HandleClick(
                button_map[button_id],
-                [=](const Common::ParamPackage& params) { buttons_param[button_id] = params; },
+                [=, this](const Common::ParamPackage& params) {
+                    buttons_param[button_id] = params;
+                },
                InputCommon::Polling::DeviceType::Button);
        });
-        connect(button, &QPushButton::customContextMenuRequested, [=](const QPoint& menu_location) {
+        connect(button, &QPushButton::customContextMenuRequested,
-            QMenu context_menu;
+                [=, this](const QPoint& menu_location) {
-            context_menu.addAction(tr("Clear"), [&] {
+                    QMenu context_menu;
-                buttons_param[button_id].Clear();
+                    context_menu.addAction(tr("Clear"), [&] {
-                button_map[button_id]->setText(tr("[not set]"));
+                        buttons_param[button_id].Clear();
-            });
+                        button_map[button_id]->setText(tr("[not set]"));
-            context_menu.addAction(tr("Restore Default"), [&] {
+                    });
-                buttons_param[button_id] = Common::ParamPackage{
+                    context_menu.addAction(tr("Restore Default"), [&] {
-                    InputCommon::GenerateKeyboardParam(Config::default_mouse_buttons[button_id])};
+                        buttons_param[button_id] =
-                button_map[button_id]->setText(ButtonToText(buttons_param[button_id]));
+                            Common::ParamPackage{InputCommon::GenerateKeyboardParam(
-            });
+                                Config::default_mouse_buttons[button_id])};
-            context_menu.exec(button_map[button_id]->mapToGlobal(menu_location));
+                        button_map[button_id]->setText(ButtonToText(buttons_param[button_id]));
-        });
+                    });
+                    context_menu.exec(button_map[button_id]->mapToGlobal(menu_location));
+                });
    }
    connect(ui->buttonClearAll, &QPushButton::clicked, [this] { ClearAll(); });
diff --git a/src/yuzu/configuration/configure_ui.cpp b/src/yuzu/configuration/configure_ui.cpp
index 24b6c5b72..2c20b68d0 100644
--- a/src/yuzu/configuration/configure_ui.cpp
+++ b/src/yuzu/configuration/configure_ui.cpp
@@ -4,9 +4,11 @@
 #include <array>
 #include <utility>
+#include <QFileDialog>
 #include <QDirIterator>
 #include "common/common_types.h"
+#include "common/file_util.h"
 #include "core/settings.h"
 #include "ui_configure_ui.h"
 #include "yuzu/configuration/configure_ui.h"
@@ -52,9 +54,21 @@ ConfigureUi::ConfigureUi(QWidget* parent) : QWidget(parent), ui(new Ui::Configur
    // Update text ComboBoxes after user interaction.
    connect(ui->row_1_text_combobox, QOverload<int>::of(&QComboBox::activated),
-            [=]() { ConfigureUi::UpdateSecondRowComboBox(); });
+            [this] { ConfigureUi::UpdateSecondRowComboBox(); });
    connect(ui->row_2_text_combobox, QOverload<int>::of(&QComboBox::activated),
-            [=]() { ConfigureUi::UpdateFirstRowComboBox(); });
+            [this] { ConfigureUi::UpdateFirstRowComboBox(); });
+    // Set screenshot path to user specification.
+    connect(ui->screenshot_path_button, &QToolButton::pressed, this, [this] {
+        const QString& filename =
+            QFileDialog::getExistingDirectory(
+                this, tr("Select Screenshots Path..."),
+                QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::ScreenshotsDir))) +
+            QDir::separator();
+        if (!filename.isEmpty()) {
+            ui->screenshot_path_edit->setText(filename);
+        }
+    });
 }
 ConfigureUi::~ConfigureUi() = default;
@@ -66,6 +80,10 @@ void ConfigureUi::ApplyConfiguration() {
    UISettings::values.icon_size = ui->icon_size_combobox->currentData().toUInt();
    UISettings::values.row_1_text_id = ui->row_1_text_combobox->currentData().toUInt();
    UISettings::values.row_2_text_id = ui->row_2_text_combobox->currentData().toUInt();
+    UISettings::values.enable_screenshot_save_as = ui->enable_screenshot_save_as->isChecked();
+    FileUtil::GetUserPath(FileUtil::UserPath::ScreenshotsDir,
+                          ui->screenshot_path_edit->text().toStdString());
    Settings::Apply();
 }
@@ -80,6 +98,10 @@ void ConfigureUi::SetConfiguration() {
    ui->show_add_ons->setChecked(UISettings::values.show_add_ons);
    ui->icon_size_combobox->setCurrentIndex(
        ui->icon_size_combobox->findData(UISettings::values.icon_size));
+    ui->enable_screenshot_save_as->setChecked(UISettings::values.enable_screenshot_save_as);
+    ui->screenshot_path_edit->setText(
+        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::ScreenshotsDir)));
 }
 void ConfigureUi::changeEvent(QEvent* event) {
diff --git a/src/yuzu/configuration/configure_ui.ui b/src/yuzu/configuration/configure_ui.ui
index 0b81747d7..d895b799f 100644
--- a/src/yuzu/configuration/configure_ui.ui
+++ b/src/yuzu/configuration/configure_ui.ui
@@ -6,8 +6,8 @@
   <rect>
    <x>0</x>
    <y>0</y>
-    <width>300</width>
+    <width>363</width>
-    <height>377</height>
+    <height>391</height>
   </rect>
  </property>
  <property name="windowTitle">
@@ -128,6 +128,47 @@
    </widget>
   </item>
   <item>
+    <widget class="QGroupBox" name="screenshots_GroupBox">
+     <property name="title">
+      <string>Screenshots</string>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout_4">
+      <item>
+       <layout class="QVBoxLayout" name="verticalLayout_3">
+        <item>
+         <widget class="QCheckBox" name="enable_screenshot_save_as">
+          <property name="text">
+           <string>Ask Where To Save Screenshots (Windows Only)</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <layout class="QHBoxLayout" name="horizontalLayout_4">
+          <item>
+           <widget class="QLabel" name="label">
+            <property name="text">
+             <string>Screenshots Path: </string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLineEdit" name="screenshot_path_edit"/>
+          </item>
+          <item>
+           <widget class="QToolButton" name="screenshot_path_button">
+            <property name="text">
+             <string>...</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
    <spacer name="verticalSpacer">
     <property name="orientation">
      <enum>Qt::Vertical</enum>
diff --git a/src/yuzu/game_list.cpp b/src/yuzu/game_list.cpp
index ab7fc7a24..62acc3720 100644
--- a/src/yuzu/game_list.cpp
+++ b/src/yuzu/game_list.cpp
@@ -474,28 +474,56 @@ void GameList::PopupContextMenu(const QPoint& menu_location) {
 void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, std::string path) {
    QAction* open_save_location = context_menu.addAction(tr("Open Save Data Location"));
-    QAction* open_lfs_location = context_menu.addAction(tr("Open Mod Data Location"));
+    QAction* open_mod_location = context_menu.addAction(tr("Open Mod Data Location"));
    QAction* open_transferable_shader_cache =
        context_menu.addAction(tr("Open Transferable Shader Cache"));
    context_menu.addSeparator();
+    QMenu* remove_menu = context_menu.addMenu(tr("Remove"));
+    QAction* remove_update = remove_menu->addAction(tr("Remove Installed Update"));
+    QAction* remove_dlc = remove_menu->addAction(tr("Remove All Installed DLC"));
+    QAction* remove_shader_cache = remove_menu->addAction(tr("Remove Shader Cache"));
+    QAction* remove_custom_config = remove_menu->addAction(tr("Remove Custom Configuration"));
+    remove_menu->addSeparator();
+    QAction* remove_all_content = remove_menu->addAction(tr("Remove All Installed Contents"));
    QAction* dump_romfs = context_menu.addAction(tr("Dump RomFS"));
    QAction* copy_tid = context_menu.addAction(tr("Copy Title ID to Clipboard"));
    QAction* navigate_to_gamedb_entry = context_menu.addAction(tr("Navigate to GameDB entry"));
    context_menu.addSeparator();
    QAction* properties = context_menu.addAction(tr("Properties"));
-    open_save_location->setEnabled(program_id != 0);
+    open_save_location->setVisible(program_id != 0);
+    open_mod_location->setVisible(program_id != 0);
+    open_transferable_shader_cache->setVisible(program_id != 0);
+    remove_update->setVisible(program_id != 0);
+    remove_dlc->setVisible(program_id != 0);
+    remove_shader_cache->setVisible(program_id != 0);
+    remove_all_content->setVisible(program_id != 0);
    auto it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
    navigate_to_gamedb_entry->setVisible(it != compatibility_list.end() && program_id != 0);
    connect(open_save_location, &QAction::triggered, [this, program_id, path]() {
        emit OpenFolderRequested(GameListOpenTarget::SaveData, path);
    });
-    connect(open_lfs_location, &QAction::triggered, [this, program_id, path]() {
+    connect(open_mod_location, &QAction::triggered, [this, program_id, path]() {
        emit OpenFolderRequested(GameListOpenTarget::ModData, path);
    });
    connect(open_transferable_shader_cache, &QAction::triggered,
            [this, program_id]() { emit OpenTransferableShaderCacheRequested(program_id); });
+    connect(remove_all_content, &QAction::triggered, [this, program_id]() {
+        emit RemoveInstalledEntryRequested(program_id, InstalledEntryType::Game);
+    });
+    connect(remove_update, &QAction::triggered, [this, program_id]() {
+        emit RemoveInstalledEntryRequested(program_id, InstalledEntryType::Update);
+    });
+    connect(remove_dlc, &QAction::triggered, [this, program_id]() {
+        emit RemoveInstalledEntryRequested(program_id, InstalledEntryType::AddOnContent);
+    });
+    connect(remove_shader_cache, &QAction::triggered, [this, program_id]() {
+        emit RemoveFileRequested(program_id, GameListRemoveTarget::ShaderCache);
+    });
+    connect(remove_custom_config, &QAction::triggered, [this, program_id]() {
+        emit RemoveFileRequested(program_id, GameListRemoveTarget::CustomConfiguration);
+    });
    connect(dump_romfs, &QAction::triggered,
            [this, program_id, path]() { emit DumpRomFSRequested(program_id, path); });
    connect(copy_tid, &QAction::triggered,
diff --git a/src/yuzu/game_list.h b/src/yuzu/game_list.h
index a38cb2fc3..483835cce 100644
--- a/src/yuzu/game_list.h
+++ b/src/yuzu/game_list.h
@@ -39,6 +39,17 @@ enum class GameListOpenTarget {
    ModData,
 };
+enum class GameListRemoveTarget {
+    ShaderCache,
+    CustomConfiguration,
+};
+enum class InstalledEntryType {
+    Game,
+    Update,
+    AddOnContent,
+};
 class GameList : public QWidget {
    Q_OBJECT
@@ -75,6 +86,8 @@ signals:
    void ShouldCancelWorker();
    void OpenFolderRequested(GameListOpenTarget target, const std::string& game_path);
    void OpenTransferableShaderCacheRequested(u64 program_id);
+    void RemoveInstalledEntryRequested(u64 program_id, InstalledEntryType type);
+    void RemoveFileRequested(u64 program_id, GameListRemoveTarget target);
    void DumpRomFSRequested(u64 program_id, const std::string& game_path);
    void CopyTIDRequested(u64 program_id);
    void NavigateToGamedbEntryRequested(u64 program_id,
@@ -117,8 +130,6 @@ private:
    friend class GameListSearchField;
 };
-Q_DECLARE_METATYPE(GameListOpenTarget);
 class GameListPlaceholder : public QWidget {
    Q_OBJECT
 public:
diff --git a/src/yuzu/game_list_worker.cpp b/src/yuzu/game_list_worker.cpp
index 2018150db..643ca6491 100644
--- a/src/yuzu/game_list_worker.cpp
+++ b/src/yuzu/game_list_worker.cpp
@@ -350,6 +350,7 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
 void GameListWorker::run() {
    stop_processing = false;
+    provider->ClearAllEntries();
    for (UISettings::GameDir& game_dir : game_dirs) {
        if (game_dir.path == QStringLiteral("SDMC")) {
@@ -368,9 +369,8 @@ void GameListWorker::run() {
            watch_list.append(game_dir.path);
            auto* const game_list_dir = new GameListDir(game_dir);
            emit DirEntryReady(game_list_dir);
-            provider->ClearAllEntries();
+            ScanFileSystem(ScanTarget::FillManualContentProvider, game_dir.path.toStdString(),
-            ScanFileSystem(ScanTarget::FillManualContentProvider, game_dir.path.toStdString(), 2,
+                           game_dir.deep_scan ? 256 : 0, game_list_dir);
-                           game_list_dir);
            ScanFileSystem(ScanTarget::PopulateGameList, game_dir.path.toStdString(),
                           game_dir.deep_scan ? 256 : 0, game_list_dir);
        }
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 31a635176..592993c36 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -583,7 +583,7 @@ void GMainWindow::InitializeWidgets() {
    renderer_status_button->setObjectName(QStringLiteral("RendererStatusBarButton"));
    renderer_status_button->setCheckable(true);
    renderer_status_button->setFocusPolicy(Qt::NoFocus);
-    connect(renderer_status_button, &QPushButton::toggled, [=](bool checked) {
+    connect(renderer_status_button, &QPushButton::toggled, [this](bool checked) {
        renderer_status_button->setText(checked ? tr("VULKAN") : tr("OPENGL"));
    });
    renderer_status_button->toggle();
@@ -595,7 +595,7 @@ void GMainWindow::InitializeWidgets() {
 #else
    renderer_status_button->setChecked(Settings::values.renderer_backend.GetValue() ==
                                       Settings::RendererBackend::Vulkan);
-    connect(renderer_status_button, &QPushButton::clicked, [=] {
+    connect(renderer_status_button, &QPushButton::clicked, [this] {
        if (emulation_running) {
            return;
        }
@@ -847,6 +847,9 @@ void GMainWindow::ConnectWidgetEvents() {
    connect(game_list, &GameList::OpenFolderRequested, this, &GMainWindow::OnGameListOpenFolder);
    connect(game_list, &GameList::OpenTransferableShaderCacheRequested, this,
            &GMainWindow::OnTransferableShaderCacheOpenFile);
+    connect(game_list, &GameList::RemoveInstalledEntryRequested, this,
+            &GMainWindow::OnGameListRemoveInstalledEntry);
+    connect(game_list, &GameList::RemoveFileRequested, this, &GMainWindow::OnGameListRemoveFile);
    connect(game_list, &GameList::DumpRomFSRequested, this, &GMainWindow::OnGameListDumpRomFS);
    connect(game_list, &GameList::CopyTIDRequested, this, &GMainWindow::OnGameListCopyTID);
    connect(game_list, &GameList::NavigateToGamedbEntryRequested, this,
@@ -1257,7 +1260,6 @@ void GMainWindow::OnGameListOpenFolder(GameListOpenTarget target, const std::str
    case GameListOpenTarget::SaveData: {
        open_target = tr("Save Data");
        const std::string nand_dir = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir);
-        ASSERT(program_id != 0);
        if (has_user_save) {
            // User save data
@@ -1322,14 +1324,12 @@ void GMainWindow::OnGameListOpenFolder(GameListOpenTarget target, const std::str
 }
 void GMainWindow::OnTransferableShaderCacheOpenFile(u64 program_id) {
-    ASSERT(program_id != 0);
    const QString shader_dir =
        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::ShaderDir));
-    const QString tranferable_shader_cache_folder_path =
+    const QString transferable_shader_cache_folder_path =
        shader_dir + QStringLiteral("opengl") + QDir::separator() + QStringLiteral("transferable");
    const QString transferable_shader_cache_file_path =
-        tranferable_shader_cache_folder_path + QDir::separator() +
+        transferable_shader_cache_folder_path + QDir::separator() +
        QString::fromStdString(fmt::format("{:016X}.bin", program_id));
    if (!QFile::exists(transferable_shader_cache_file_path)) {
@@ -1350,7 +1350,7 @@ void GMainWindow::OnTransferableShaderCacheOpenFile(u64 program_id) {
    param << QDir::toNativeSeparators(transferable_shader_cache_file_path);
    QProcess::startDetached(explorer, param);
 #else
-    QDesktopServices::openUrl(QUrl::fromLocalFile(tranferable_shader_cache_folder_path));
+    QDesktopServices::openUrl(QUrl::fromLocalFile(transferable_shader_cache_folder_path));
 #endif
 }
@@ -1394,6 +1394,174 @@ static bool RomFSRawCopy(QProgressDialog& dialog, const FileSys::VirtualDir& src
    return true;
 }
+void GMainWindow::OnGameListRemoveInstalledEntry(u64 program_id, InstalledEntryType type) {
+    const QString entry_type = [this, type] {
+        switch (type) {
+        case InstalledEntryType::Game:
+            return tr("Contents");
+        case InstalledEntryType::Update:
+            return tr("Update");
+        case InstalledEntryType::AddOnContent:
+            return tr("DLC");
+        default:
+            return QString{};
+        }
+    }();
+    if (QMessageBox::question(
+            this, tr("Remove Entry"), tr("Remove Installed Game %1?").arg(entry_type),
+            QMessageBox::Yes | QMessageBox::No, QMessageBox::No) != QMessageBox::Yes) {
+        return;
+    }
+    switch (type) {
+    case InstalledEntryType::Game:
+        RemoveBaseContent(program_id, entry_type);
+        [[fallthrough]];
+    case InstalledEntryType::Update:
+        RemoveUpdateContent(program_id, entry_type);
+        if (type != InstalledEntryType::Game) {
+            break;
+        }
+        [[fallthrough]];
+    case InstalledEntryType::AddOnContent:
+        RemoveAddOnContent(program_id, entry_type);
+        break;
+    }
+    FileUtil::DeleteDirRecursively(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir) + DIR_SEP +
+                                   "game_list");
+    game_list->PopulateAsync(UISettings::values.game_dirs);
+}
+void GMainWindow::RemoveBaseContent(u64 program_id, const QString& entry_type) {
+    const auto& fs_controller = Core::System::GetInstance().GetFileSystemController();
+    const auto res = fs_controller.GetUserNANDContents()->RemoveExistingEntry(program_id) ||
+                     fs_controller.GetSDMCContents()->RemoveExistingEntry(program_id);
+    if (res) {
+        QMessageBox::information(this, tr("Successfully Removed"),
+                                 tr("Successfully removed the installed base game."));
+    } else {
+        QMessageBox::warning(
+            this, tr("Error Removing %1").arg(entry_type),
+            tr("The base game is not installed in the NAND and cannot be removed."));
+    }
+}
+void GMainWindow::RemoveUpdateContent(u64 program_id, const QString& entry_type) {
+    const auto update_id = program_id | 0x800;
+    const auto& fs_controller = Core::System::GetInstance().GetFileSystemController();
+    const auto res = fs_controller.GetUserNANDContents()->RemoveExistingEntry(update_id) ||
+                     fs_controller.GetSDMCContents()->RemoveExistingEntry(update_id);
+    if (res) {
+        QMessageBox::information(this, tr("Successfully Removed"),
+                                 tr("Successfully removed the installed update."));
+    } else {
+        QMessageBox::warning(this, tr("Error Removing %1").arg(entry_type),
+                             tr("There is no update installed for this title."));
+    }
+}
+void GMainWindow::RemoveAddOnContent(u64 program_id, const QString& entry_type) {
+    u32 count{};
+    const auto& fs_controller = Core::System::GetInstance().GetFileSystemController();
+    const auto dlc_entries = Core::System::GetInstance().GetContentProvider().ListEntriesFilter(
+        FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
+    for (const auto& entry : dlc_entries) {
+        if ((entry.title_id & DLC_BASE_TITLE_ID_MASK) == program_id) {
+            const auto res =
+                fs_controller.GetUserNANDContents()->RemoveExistingEntry(entry.title_id) ||
+                fs_controller.GetSDMCContents()->RemoveExistingEntry(entry.title_id);
+            if (res) {
+                ++count;
+            }
+        }
+    }
+    if (count == 0) {
+        QMessageBox::warning(this, tr("Error Removing %1").arg(entry_type),
+                             tr("There are no DLC installed for this title."));
+        return;
+    }
+    QMessageBox::information(this, tr("Successfully Removed"),
+                             tr("Successfully removed %1 installed DLC.").arg(count));
+}
+void GMainWindow::OnGameListRemoveFile(u64 program_id, GameListRemoveTarget target) {
+    const QString question = [this, target] {
+        switch (target) {
+        case GameListRemoveTarget::ShaderCache:
+            return tr("Delete Transferable Shader Cache?");
+        case GameListRemoveTarget::CustomConfiguration:
+            return tr("Remove Custom Game Configuration?");
+        default:
+            return QString{};
+        }
+    }();
+    if (QMessageBox::question(this, tr("Remove File"), question, QMessageBox::Yes | QMessageBox::No,
+                              QMessageBox::No) != QMessageBox::Yes) {
+        return;
+    }
+    switch (target) {
+    case GameListRemoveTarget::ShaderCache:
+        RemoveTransferableShaderCache(program_id);
+        break;
+    case GameListRemoveTarget::CustomConfiguration:
+        RemoveCustomConfiguration(program_id);
+        break;
+    }
+}
+void GMainWindow::RemoveTransferableShaderCache(u64 program_id) {
+    const QString shader_dir =
+        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::ShaderDir));
+    const QString transferable_shader_cache_folder_path =
+        shader_dir + QStringLiteral("opengl") + QDir::separator() + QStringLiteral("transferable");
+    const QString transferable_shader_cache_file_path =
+        transferable_shader_cache_folder_path + QDir::separator() +
+        QString::fromStdString(fmt::format("{:016X}.bin", program_id));
+    if (!QFile::exists(transferable_shader_cache_file_path)) {
+        QMessageBox::warning(this, tr("Error Removing Transferable Shader Cache"),
+                             tr("A shader cache for this title does not exist."));
+        return;
+    }
+    if (QFile::remove(transferable_shader_cache_file_path)) {
+        QMessageBox::information(this, tr("Successfully Removed"),
+                                 tr("Successfully removed the transferable shader cache."));
+    } else {
+        QMessageBox::warning(this, tr("Error Removing Transferable Shader Cache"),
+                             tr("Failed to remove the transferable shader cache."));
+    }
+}
+void GMainWindow::RemoveCustomConfiguration(u64 program_id) {
+    const QString config_dir =
+        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir));
+    const QString custom_config_file_path =
+        config_dir + QString::fromStdString(fmt::format("{:016X}.ini", program_id));
+    if (!QFile::exists(custom_config_file_path)) {
+        QMessageBox::warning(this, tr("Error Removing Custom Configuration"),
+                             tr("A custom configuration for this title does not exist."));
+        return;
+    }
+    if (QFile::remove(custom_config_file_path)) {
+        QMessageBox::information(this, tr("Successfully Removed"),
+                                 tr("Successfully removed the custom game configuration."));
+    } else {
+        QMessageBox::warning(this, tr("Error Removing Custom Configuration"),
+                             tr("Failed to remove the custom game configuration."));
+    }
+}
 void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_path) {
    const auto failed = [this] {
        QMessageBox::warning(this, tr("RomFS Extraction Failed!"),
@@ -1655,7 +1823,7 @@ void GMainWindow::OnMenuInstallToNAND() {
    ui.action_Install_File_NAND->setEnabled(false);
-    install_progress = new QProgressDialog(QStringLiteral(""), tr("Cancel"), 0, total_size, this);
+    install_progress = new QProgressDialog(QString{}, tr("Cancel"), 0, total_size, this);
    install_progress->setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint &
                                     ~Qt::WindowMaximizeButtonHint);
    install_progress->setAttribute(Qt::WA_DeleteOnClose, true);
@@ -1705,18 +1873,18 @@ void GMainWindow::OnMenuInstallToNAND() {
    install_progress->close();
    const QString install_results =
-        (new_files.isEmpty() ? QStringLiteral("")
+        (new_files.isEmpty() ? QString{}
                             : tr("%n file(s) were newly installed\n", "", new_files.size())) +
        (overwritten_files.isEmpty()
-             ? QStringLiteral("")
+             ? QString{}
             : tr("%n file(s) were overwritten\n", "", overwritten_files.size())) +
-        (failed_files.isEmpty() ? QStringLiteral("")
+        (failed_files.isEmpty() ? QString{}
                                : tr("%n file(s) failed to install\n", "", failed_files.size()));
    QMessageBox::information(this, tr("Install Results"), install_results);
-    game_list->PopulateAsync(UISettings::values.game_dirs);
    FileUtil::DeleteDirRecursively(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir) + DIR_SEP +
                                   "game_list");
+    game_list->PopulateAsync(UISettings::values.game_dirs);
    ui.action_Install_File_NAND->setEnabled(true);
 }
@@ -2153,17 +2321,28 @@ void GMainWindow::OnToggleFilterBar() {
 void GMainWindow::OnCaptureScreenshot() {
    OnPauseGame();
-    QFileDialog png_dialog(this, tr("Capture Screenshot"), UISettings::values.screenshot_path,
-                           tr("PNG Image (*.png)"));
+    const u64 title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
-    png_dialog.setAcceptMode(QFileDialog::AcceptSave);
+    const auto screenshot_path =
-    png_dialog.setDefaultSuffix(QStringLiteral("png"));
+        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::ScreenshotsDir));
-    if (png_dialog.exec()) {
+    const auto date =
-        const QString path = png_dialog.selectedFiles().first();
+        QDateTime::currentDateTime().toString(QStringLiteral("yyyy-MM-dd_hh-mm-ss-zzz"));
-        if (!path.isEmpty()) {
+    QString filename = QStringLiteral("%1%2_%3.png")
-            UISettings::values.screenshot_path = QFileInfo(path).path();
+                           .arg(screenshot_path)
-            render_window->CaptureScreenshot(UISettings::values.screenshot_resolution_factor, path);
+                           .arg(title_id, 16, 16, QLatin1Char{'0'})
+                           .arg(date);
+#ifdef _WIN32
+    if (UISettings::values.enable_screenshot_save_as) {
+        filename = QFileDialog::getSaveFileName(this, tr("Capture Screenshot"), filename,
+                                                tr("PNG Image (*.png)"));
+        if (filename.isEmpty()) {
+            OnStartGame();
+            return;
        }
    }
+#endif
+    render_window->CaptureScreenshot(UISettings::values.screenshot_resolution_factor, filename);
    OnStartGame();
 }
@@ -2202,8 +2381,7 @@ void GMainWindow::UpdateStatusBar() {
    if (shaders_building != 0) {
        shader_building_label->setText(
-            tr("Building: %1 shader").arg(shaders_building) +
+            tr("Building: %n shader(s)", "", static_cast<int>(shaders_building)));
-            (shaders_building != 1 ? QString::fromStdString("s") : QString::fromStdString("")));
        shader_building_label->setVisible(true);
    } else {
        shader_building_label->setVisible(false);
diff --git a/src/yuzu/main.h b/src/yuzu/main.h
index db573d606..73a44a3bf 100644
--- a/src/yuzu/main.h
+++ b/src/yuzu/main.h
@@ -32,6 +32,8 @@ class QPushButton;
 class QProgressDialog;
 class WaitTreeWidget;
 enum class GameListOpenTarget;
+enum class GameListRemoveTarget;
+enum class InstalledEntryType;
 class GameListPlaceholder;
 namespace Core::Frontend {
@@ -198,6 +200,8 @@ private slots:
    void OnGameListLoadFile(QString game_path);
    void OnGameListOpenFolder(GameListOpenTarget target, const std::string& game_path);
    void OnTransferableShaderCacheOpenFile(u64 program_id);
+    void OnGameListRemoveInstalledEntry(u64 program_id, InstalledEntryType type);
+    void OnGameListRemoveFile(u64 program_id, GameListRemoveTarget target);
    void OnGameListDumpRomFS(u64 program_id, const std::string& game_path);
    void OnGameListCopyTID(u64 program_id);
    void OnGameListNavigateToGamedbEntry(u64 program_id,
@@ -229,6 +233,11 @@ private slots:
    void OnLanguageChanged(const QString& locale);
 private:
+    void RemoveBaseContent(u64 program_id, const QString& entry_type);
+    void RemoveUpdateContent(u64 program_id, const QString& entry_type);
+    void RemoveAddOnContent(u64 program_id, const QString& entry_type);
+    void RemoveTransferableShaderCache(u64 program_id);
+    void RemoveCustomConfiguration(u64 program_id);
    std::optional<u64> SelectRomFSDumpTarget(const FileSys::ContentProvider&, u64 program_id);
    InstallResult InstallNSPXCI(const QString& filename);
    InstallResult InstallNCA(const QString& filename);
diff --git a/src/yuzu/uisettings.h b/src/yuzu/uisettings.h
index ac7b9aef6..bbfeafc55 100644
--- a/src/yuzu/uisettings.h
+++ b/src/yuzu/uisettings.h
@@ -66,11 +66,11 @@ struct Values {
    // Discord RPC
    bool enable_discord_presence;
+    bool enable_screenshot_save_as;
    u16 screenshot_resolution_factor;
    QString roms_path;
    QString symbols_path;
-    QString screenshot_path;
    QString game_dir_deprecated;
    bool game_dir_deprecated_deepscan;
    QVector<UISettings::GameDir> game_dirs;