78 files changed, 1519 insertions, 765 deletions
diff --git a/src/audio_core/audio_renderer.h b/src/audio_core/audio_renderer.h
index 046417da3..71ba4be40 100644
--- a/src/audio_core/audio_renderer.h
+++ b/src/audio_core/audio_renderer.h
@@ -143,7 +143,7 @@ struct AuxInfo {
    std::array<u8, 24> output_mix_buffers;
    u32_le mix_buffer_count;
    u32_le sample_rate; // Stored in the aux buffer currently
-    u32_le sampe_count;
+    u32_le sample_count;
    u64_le send_buffer_info;
    u64_le send_buffer_base;
diff --git a/src/common/bit_field.h b/src/common/bit_field.h
index bf803da8d..21e07925d 100644
--- a/src/common/bit_field.h
+++ b/src/common/bit_field.h
@@ -117,21 +117,21 @@ private:
    // We don't delete it because we want BitField to be trivially copyable.
    constexpr BitField& operator=(const BitField&) = default;
-    // StorageType is T for non-enum types and the underlying type of T if
+    // UnderlyingType is T for non-enum types and the underlying type of T if
    // T is an enumeration. Note that T is wrapped within an enable_if in the
    // former case to workaround compile errors which arise when using
    // std::underlying_type<T>::type directly.
-    using StorageType = typename std::conditional_t<std::is_enum<T>::value, std::underlying_type<T>,
+    using UnderlyingType = typename std::conditional_t<std::is_enum_v<T>, std::underlying_type<T>,
-                                                    std::enable_if<true, T>>::type;
+                                                       std::enable_if<true, T>>::type;
-    // Unsigned version of StorageType
+    // We store the value as the unsigned type to avoid undefined behaviour on value shifting
-    using StorageTypeU = std::make_unsigned_t<StorageType>;
+    using StorageType = std::make_unsigned_t<UnderlyingType>;
 public:
    /// Constants to allow limited introspection of fields if needed
    static constexpr std::size_t position = Position;
    static constexpr std::size_t bits = Bits;
-    static constexpr StorageType mask = (((StorageTypeU)~0) >> (8 * sizeof(T) - bits)) << position;
+    static constexpr StorageType mask = (((StorageType)~0) >> (8 * sizeof(T) - bits)) << position;
    /**
     * Formats a value by masking and shifting it according to the field parameters. A value
@@ -148,11 +148,12 @@ public:
     * union in a constexpr context.
     */
    static constexpr FORCE_INLINE T ExtractValue(const StorageType& storage) {
-        if (std::numeric_limits<T>::is_signed) {
+        if constexpr (std::numeric_limits<UnderlyingType>::is_signed) {
            std::size_t shift = 8 * sizeof(T) - bits;
-            return (T)((storage << (shift - position)) >> shift);
+            return static_cast<T>(static_cast<UnderlyingType>(storage << (shift - position)) >>
+                                  shift);
        } else {
-            return (T)((storage & mask) >> position);
+            return static_cast<T>((storage & mask) >> position);
        }
    }
diff --git a/src/common/string_util.cpp b/src/common/string_util.cpp
index 731d1db34..14f7037d8 100644
--- a/src/common/string_util.cpp
+++ b/src/common/string_util.cpp
@@ -4,11 +4,10 @@
 #include <algorithm>
 #include <cctype>
-#include <cerrno>
 #include <codecvt>
-#include <cstdio>
 #include <cstdlib>
-#include <cstring>
+#include <locale>
+#include <sstream>
 #include "common/common_paths.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
@@ -33,24 +32,6 @@ std::string ToUpper(std::string str) {
    return str;
 }
-// For Debugging. Read out an u8 array.
-std::string ArrayToString(const u8* data, std::size_t size, int line_len, bool spaces) {
-    std::ostringstream oss;
-    oss << std::setfill('0') << std::hex;
-    for (int line = 0; size; ++data, --size) {
-        oss << std::setw(2) << (int)*data;
-        if (line_len == ++line) {
-            oss << '\n';
-            line = 0;
-        } else if (spaces)
-            oss << ' ';
-    }
-    return oss.str();
-}
 std::string StringFromBuffer(const std::vector<u8>& data) {
    return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
 }
@@ -75,40 +56,6 @@ std::string StripQuotes(const std::string& s) {
        return s;
 }
-bool TryParse(const std::string& str, u32* const output) {
-    char* endptr = nullptr;
-    // Reset errno to a value other than ERANGE
-    errno = 0;
-    unsigned long value = strtoul(str.c_str(), &endptr, 0);
-    if (!endptr || *endptr)
-        return false;
-    if (errno == ERANGE)
-        return false;
-#if ULONG_MAX > UINT_MAX
-    if (value >= 0x100000000ull && value <= 0xFFFFFFFF00000000ull)
-        return false;
-#endif
-    *output = static_cast<u32>(value);
-    return true;
-}
-bool TryParse(const std::string& str, bool* const output) {
-    if ("1" == str || "true" == ToLower(str))
-        *output = true;
-    else if ("0" == str || "false" == ToLower(str))
-        *output = false;
-    else
-        return false;
-    return true;
-}
 std::string StringFromBool(bool value) {
    return value ? "True" : "False";
 }
diff --git a/src/common/string_util.h b/src/common/string_util.h
index 32bf6a19c..08f96533b 100644
--- a/src/common/string_util.h
+++ b/src/common/string_util.h
@@ -5,8 +5,6 @@
 #pragma once
 #include <cstddef>
-#include <iomanip>
-#include <sstream>
 #include <string>
 #include <vector>
 #include "common/common_types.h"
@@ -19,44 +17,13 @@ std::string ToLower(std::string str);
 /// Make a string uppercase
 std::string ToUpper(std::string str);
-std::string ArrayToString(const u8* data, std::size_t size, int line_len = 20, bool spaces = true);
 std::string StringFromBuffer(const std::vector<u8>& data);
 std::string StripSpaces(const std::string& s);
 std::string StripQuotes(const std::string& s);
-// Thousand separator. Turns 12345678 into 12,345,678
-template <typename I>
-std::string ThousandSeparate(I value, int spaces = 0) {
-    std::ostringstream oss;
-// std::locale("") seems to be broken on many platforms
-#if defined _WIN32 || (defined __linux__ && !defined __clang__)
-    oss.imbue(std::locale(""));
-#endif
-    oss << std::setw(spaces) << value;
-    return oss.str();
-}
 std::string StringFromBool(bool value);
-bool TryParse(const std::string& str, bool* output);
-bool TryParse(const std::string& str, u32* output);
-template <typename N>
-static bool TryParse(const std::string& str, N* const output) {
-    std::istringstream iss(str);
-    N tmp = 0;
-    if (iss >> tmp) {
-        *output = tmp;
-        return true;
-    } else
-        return false;
-}
 std::string TabsToSpaces(int tab_size, std::string in);
 void SplitString(const std::string& str, char delim, std::vector<std::string>& output);
diff --git a/src/core/file_sys/bis_factory.cpp b/src/core/file_sys/bis_factory.cpp
index 76a2b7e86..e29f70b3a 100644
--- a/src/core/file_sys/bis_factory.cpp
+++ b/src/core/file_sys/bis_factory.cpp
@@ -8,8 +8,9 @@
 namespace FileSys {
-BISFactory::BISFactory(VirtualDir nand_root_, VirtualDir load_root_)
+BISFactory::BISFactory(VirtualDir nand_root_, VirtualDir load_root_, VirtualDir dump_root_)
    : nand_root(std::move(nand_root_)), load_root(std::move(load_root_)),
+      dump_root(std::move(dump_root_)),
      sysnand_cache(std::make_unique<RegisteredCache>(
          GetOrCreateDirectoryRelative(nand_root, "/system/Contents/registered"))),
      usrnand_cache(std::make_unique<RegisteredCache>(
@@ -32,4 +33,10 @@ VirtualDir BISFactory::GetModificationLoadRoot(u64 title_id) const {
    return GetOrCreateDirectoryRelative(load_root, fmt::format("/{:016X}", title_id));
 }
+VirtualDir BISFactory::GetModificationDumpRoot(u64 title_id) const {
+    if (title_id == 0)
+        return nullptr;
+    return GetOrCreateDirectoryRelative(dump_root, fmt::format("/{:016X}", title_id));
+}
 } // namespace FileSys
diff --git a/src/core/file_sys/bis_factory.h b/src/core/file_sys/bis_factory.h
index 364d309bd..453c11ad2 100644
--- a/src/core/file_sys/bis_factory.h
+++ b/src/core/file_sys/bis_factory.h
@@ -17,17 +17,19 @@ class RegisteredCache;
 /// registered caches.
 class BISFactory {
 public:
-    explicit BISFactory(VirtualDir nand_root, VirtualDir load_root);
+    explicit BISFactory(VirtualDir nand_root, VirtualDir load_root, VirtualDir dump_root);
    ~BISFactory();
    RegisteredCache* GetSystemNANDContents() const;
    RegisteredCache* GetUserNANDContents() const;
    VirtualDir GetModificationLoadRoot(u64 title_id) const;
+    VirtualDir GetModificationDumpRoot(u64 title_id) const;
 private:
    VirtualDir nand_root;
    VirtualDir load_root;
+    VirtualDir dump_root;
    std::unique_ptr<RegisteredCache> sysnand_cache;
    std::unique_ptr<RegisteredCache> usrnand_cache;
diff --git a/src/core/file_sys/card_image.cpp b/src/core/file_sys/card_image.cpp
index 1ece55731..2c145bd09 100644
--- a/src/core/file_sys/card_image.cpp
+++ b/src/core/file_sys/card_image.cpp
@@ -176,7 +176,7 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
    for (const VirtualFile& file : partitions[static_cast<std::size_t>(part)]->GetFiles()) {
        if (file->GetExtension() != "nca")
            continue;
-        auto nca = std::make_shared<NCA>(file);
+        auto nca = std::make_shared<NCA>(file, nullptr, 0, keys);
        // TODO(DarkLordZach): Add proper Rev1+ Support
        if (nca->IsUpdate())
            continue;
diff --git a/src/core/file_sys/card_image.h b/src/core/file_sys/card_image.h
index 8f62571cf..25f5914b6 100644
--- a/src/core/file_sys/card_image.h
+++ b/src/core/file_sys/card_image.h
@@ -9,6 +9,7 @@
 #include <vector>
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "core/crypto/key_manager.h"
 #include "core/file_sys/vfs.h"
 namespace Loader {
@@ -107,5 +108,7 @@ private:
    std::shared_ptr<NSP> secure_partition;
    std::shared_ptr<NCA> program;
    std::vector<std::shared_ptr<NCA>> ncas;
+    Core::Crypto::KeyManager keys;
 };
 } // namespace FileSys
diff --git a/src/core/file_sys/content_archive.cpp b/src/core/file_sys/content_archive.cpp
index b46fe893c..19b6f8600 100644
--- a/src/core/file_sys/content_archive.cpp
+++ b/src/core/file_sys/content_archive.cpp
@@ -101,8 +101,9 @@ static bool IsValidNCA(const NCAHeader& header) {
    return header.magic == Common::MakeMagic('N', 'C', 'A', '3');
 }
-NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_offset)
+NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_offset,
-    : file(std::move(file_)), bktr_base_romfs(std::move(bktr_base_romfs_)) {
+         Core::Crypto::KeyManager keys_)
+    : file(std::move(file_)), bktr_base_romfs(std::move(bktr_base_romfs_)), keys(std::move(keys_)) {
    if (file == nullptr) {
        status = Loader::ResultStatus::ErrorNullFile;
        return;
diff --git a/src/core/file_sys/content_archive.h b/src/core/file_sys/content_archive.h
index 4bba55607..99294cbb4 100644
--- a/src/core/file_sys/content_archive.h
+++ b/src/core/file_sys/content_archive.h
@@ -79,7 +79,8 @@ inline bool IsDirectoryExeFS(const std::shared_ptr<VfsDirectory>& pfs) {
 class NCA : public ReadOnlyVfsDirectory {
 public:
    explicit NCA(VirtualFile file, VirtualFile bktr_base_romfs = nullptr,
-                 u64 bktr_base_ivfc_offset = 0);
+                 u64 bktr_base_ivfc_offset = 0,
+                 Core::Crypto::KeyManager keys = Core::Crypto::KeyManager());
    ~NCA() override;
    Loader::ResultStatus GetStatus() const;
diff --git a/src/core/file_sys/control_metadata.cpp b/src/core/file_sys/control_metadata.cpp
index a012c2be9..c8fa912bf 100644
--- a/src/core/file_sys/control_metadata.cpp
+++ b/src/core/file_sys/control_metadata.cpp
@@ -66,4 +66,10 @@ std::string NACP::GetVersionString() const {
    return Common::StringFromFixedZeroTerminatedBuffer(raw->version_string.data(),
                                                       raw->version_string.size());
 }
+std::vector<u8> NACP::GetRawBytes() const {
+    std::vector<u8> out(sizeof(RawNACP));
+    std::memcpy(out.data(), raw.get(), sizeof(RawNACP));
+    return out;
+}
 } // namespace FileSys
diff --git a/src/core/file_sys/control_metadata.h b/src/core/file_sys/control_metadata.h
index 141f7e056..bfaad46b4 100644
--- a/src/core/file_sys/control_metadata.h
+++ b/src/core/file_sys/control_metadata.h
@@ -81,6 +81,7 @@ public:
    u64 GetTitleId() const;
    u64 GetDLCBaseTitleId() const;
    std::string GetVersionString() const;
+    std::vector<u8> GetRawBytes() const;
 private:
    std::unique_ptr<RawNACP> raw;
diff --git a/src/core/file_sys/errors.h b/src/core/file_sys/errors.h
index fea0593c7..e4a4ee4ab 100644
--- a/src/core/file_sys/errors.h
+++ b/src/core/file_sys/errors.h
@@ -8,25 +8,10 @@
 namespace FileSys {
-namespace ErrCodes {
+constexpr ResultCode ERROR_PATH_NOT_FOUND{ErrorModule::FS, 1};
-enum {
+constexpr ResultCode ERROR_ENTITY_NOT_FOUND{ErrorModule::FS, 1002};
-    NotFound = 1,
+constexpr ResultCode ERROR_SD_CARD_NOT_FOUND{ErrorModule::FS, 2001};
-    TitleNotFound = 1002,
+constexpr ResultCode ERROR_INVALID_OFFSET{ErrorModule::FS, 6061};
-    SdCardNotFound = 2001,
+constexpr ResultCode ERROR_INVALID_SIZE{ErrorModule::FS, 6062};
-    RomFSNotFound = 2520,
-};
-}
-constexpr ResultCode ERROR_PATH_NOT_FOUND(ErrorModule::FS, ErrCodes::NotFound);
-// TODO(bunnei): Replace these with correct errors for Switch OS
-constexpr ResultCode ERROR_INVALID_PATH(-1);
-constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(-1);
-constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(-1);
-constexpr ResultCode ERROR_FILE_NOT_FOUND(-1);
-constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(-1);
-constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(-1);
-constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(-1);
-constexpr ResultCode ERROR_DIRECTORY_NOT_EMPTY(-1);
 } // namespace FileSys
diff --git a/src/core/file_sys/patch_manager.cpp b/src/core/file_sys/patch_manager.cpp
index 0c1156989..8d062eb3e 100644
--- a/src/core/file_sys/patch_manager.cpp
+++ b/src/core/file_sys/patch_manager.cpp
@@ -19,6 +19,7 @@
 #include "core/file_sys/vfs_vector.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
+#include "core/settings.h"
 namespace FileSys {
@@ -119,6 +120,18 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso) const {
    const auto build_id_raw = Common::HexArrayToString(header.build_id);
    const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
+    if (Settings::values.dump_nso) {
+        LOG_INFO(Loader, "Dumping NSO for build_id={}, title_id={:016X}", build_id, title_id);
+        const auto dump_dir = Service::FileSystem::GetModificationDumpRoot(title_id);
+        if (dump_dir != nullptr) {
+            const auto nso_dir = GetOrCreateDirectoryRelative(dump_dir, "/nso");
+            const auto file = nso_dir->CreateFile(fmt::format("{}.nso", build_id));
+            file->Resize(nso.size());
+            file->WriteBytes(nso);
+        }
+    }
    LOG_INFO(Loader, "Patching NSO for build_id={}", build_id);
    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
diff --git a/src/core/file_sys/registered_cache.cpp b/src/core/file_sys/registered_cache.cpp
index 96302a241..a3f8f2f73 100644
--- a/src/core/file_sys/registered_cache.cpp
+++ b/src/core/file_sys/registered_cache.cpp
@@ -106,9 +106,12 @@ static ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
 VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& dir,
                                                       std::string_view path) const {
-    if (dir->GetFileRelative(path) != nullptr)
+    const auto file = dir->GetFileRelative(path);
-        return dir->GetFileRelative(path);
+    if (file != nullptr)
-    if (dir->GetDirectoryRelative(path) != nullptr) {
+        return file;
+    const auto nca_dir = dir->GetDirectoryRelative(path);
+    if (nca_dir != nullptr) {
        const auto nca_dir = dir->GetDirectoryRelative(path);
        VirtualFile file = nullptr;
@@ -225,7 +228,7 @@ void RegisteredCache::ProcessFiles(const std::vector<NcaID>& ids) {
        if (file == nullptr)
            continue;
-        const auto nca = std::make_shared<NCA>(parser(file, id));
+        const auto nca = std::make_shared<NCA>(parser(file, id), nullptr, 0, keys);
        if (nca->GetStatus() != Loader::ResultStatus::Success ||
            nca->GetType() != NCAContentType::Meta) {
            continue;
@@ -315,7 +318,7 @@ std::unique_ptr<NCA> RegisteredCache::GetEntry(u64 title_id, ContentRecordType t
    const auto raw = GetEntryRaw(title_id, type);
    if (raw == nullptr)
        return nullptr;
-    return std::make_unique<NCA>(raw);
+    return std::make_unique<NCA>(raw, nullptr, 0, keys);
 }
 std::unique_ptr<NCA> RegisteredCache::GetEntry(RegisteredCacheEntry entry) const {
diff --git a/src/core/file_sys/registered_cache.h b/src/core/file_sys/registered_cache.h
index 6cfb16017..6b89db8de 100644
--- a/src/core/file_sys/registered_cache.h
+++ b/src/core/file_sys/registered_cache.h
@@ -12,6 +12,7 @@
 #include <vector>
 #include <boost/container/flat_map.hpp>
 #include "common/common_types.h"
+#include "core/crypto/key_manager.h"
 #include "core/file_sys/vfs.h"
 namespace FileSys {
@@ -133,6 +134,8 @@ private:
    VirtualDir dir;
    RegisteredCacheParsingFunction parser;
+    Core::Crypto::KeyManager keys;
    // maps tid -> NcaID of meta
    boost::container::flat_map<u64, NcaID> meta_id;
    // maps tid -> meta
diff --git a/src/core/file_sys/savedata_factory.cpp b/src/core/file_sys/savedata_factory.cpp
index ef1aaebbb..5434f2149 100644
--- a/src/core/file_sys/savedata_factory.cpp
+++ b/src/core/file_sys/savedata_factory.cpp
@@ -83,28 +83,32 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, SaveDataDescr
    return MakeResult<VirtualDir>(std::move(out));
 }
-std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
+VirtualDir SaveDataFactory::GetSaveDataSpaceDirectory(SaveDataSpaceId space) const {
-                                         u128 user_id, u64 save_id) {
+    return dir->GetDirectoryRelative(GetSaveDataSpaceIdPath(space));
-    // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
+}
-    // be interpreted as the title id of the current process.
-    if (type == SaveDataType::SaveData && title_id == 0)
-        title_id = Core::CurrentProcess()->GetTitleID();
-    std::string out;
+std::string SaveDataFactory::GetSaveDataSpaceIdPath(SaveDataSpaceId space) {
    switch (space) {
    case SaveDataSpaceId::NandSystem:
-        out = "/system/";
+        return "/system/";
-        break;
    case SaveDataSpaceId::NandUser:
-        out = "/user/";
+        return "/user/";
-        break;
    case SaveDataSpaceId::TemporaryStorage:
-        out = "/temp/";
+        return "/temp/";
-        break;
    default:
        ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
+        return "/unrecognized/"; ///< To prevent corruption when ignoring asserts.
    }
+}
+std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
+                                         u128 user_id, u64 save_id) {
+    // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
+    // be interpreted as the title id of the current process.
+    if (type == SaveDataType::SaveData && title_id == 0)
+        title_id = Core::CurrentProcess()->GetTitleID();
+    std::string out = GetSaveDataSpaceIdPath(space);
    switch (type) {
    case SaveDataType::SystemSaveData:
diff --git a/src/core/file_sys/savedata_factory.h b/src/core/file_sys/savedata_factory.h
index d69ef6741..2a0088040 100644
--- a/src/core/file_sys/savedata_factory.h
+++ b/src/core/file_sys/savedata_factory.h
@@ -52,6 +52,9 @@ public:
    ResultVal<VirtualDir> Open(SaveDataSpaceId space, SaveDataDescriptor meta);
+    VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const;
+    static std::string GetSaveDataSpaceIdPath(SaveDataSpaceId space);
    static std::string GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
                                   u128 user_id, u64 save_id);
diff --git a/src/core/file_sys/submission_package.cpp b/src/core/file_sys/submission_package.cpp
index 2aaba4179..e1a4210db 100644
--- a/src/core/file_sys/submission_package.cpp
+++ b/src/core/file_sys/submission_package.cpp
@@ -252,7 +252,7 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
                    continue;
                }
-                auto next_nca = std::make_shared<NCA>(next_file);
+                auto next_nca = std::make_shared<NCA>(next_file, nullptr, 0, keys);
                if (next_nca->GetType() == NCAContentType::Program)
                    program_status[cnmt.GetTitleID()] = next_nca->GetStatus();
                if (next_nca->GetStatus() == Loader::ResultStatus::Success ||
diff --git a/src/core/file_sys/submission_package.h b/src/core/file_sys/submission_package.h
index 338080b7e..9a28ed5bb 100644
--- a/src/core/file_sys/submission_package.h
+++ b/src/core/file_sys/submission_package.h
@@ -70,6 +70,8 @@ private:
    std::map<u64, std::map<ContentRecordType, std::shared_ptr<NCA>>> ncas;
    std::vector<VirtualFile> ticket_files;
+    Core::Crypto::KeyManager keys;
    VirtualFile romfs;
    VirtualDir exefs;
 };
diff --git a/src/core/hle/kernel/errors.h b/src/core/hle/kernel/errors.h
index ee698c8a7..8b58d701d 100644
--- a/src/core/hle/kernel/errors.h
+++ b/src/core/hle/kernel/errors.h
@@ -8,58 +8,28 @@
 namespace Kernel {
-namespace ErrCodes {
+// Confirmed Switch kernel error codes
-enum {
-    // Confirmed Switch OS error codes
-    MaxConnectionsReached = 7,
-    InvalidSize = 101,
-    InvalidAddress = 102,
-    HandleTableFull = 105,
-    InvalidMemoryState = 106,
-    InvalidMemoryPermissions = 108,
-    InvalidMemoryRange = 110,
-    InvalidThreadPriority = 112,
-    InvalidProcessorId = 113,
-    InvalidHandle = 114,
-    InvalidPointer = 115,
-    InvalidCombination = 116,
-    Timeout = 117,
-    SynchronizationCanceled = 118,
-    TooLarge = 119,
-    InvalidEnumValue = 120,
-    NoSuchEntry = 121,
-    AlreadyRegistered = 122,
-    SessionClosed = 123,
-    InvalidState = 125,
-    ResourceLimitExceeded = 132,
-};
-}
-// WARNING: The kernel is quite inconsistent in it's usage of errors code. Make sure to always
+constexpr ResultCode ERR_MAX_CONNECTIONS_REACHED{ErrorModule::Kernel, 7};
-// double check that the code matches before re-using the constant.
+constexpr ResultCode ERR_INVALID_SIZE{ErrorModule::Kernel, 101};
+constexpr ResultCode ERR_INVALID_ADDRESS{ErrorModule::Kernel, 102};
-constexpr ResultCode ERR_HANDLE_TABLE_FULL(ErrorModule::Kernel, ErrCodes::HandleTableFull);
+constexpr ResultCode ERR_HANDLE_TABLE_FULL{ErrorModule::Kernel, 105};
-constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE(ErrorModule::Kernel, ErrCodes::SessionClosed);
+constexpr ResultCode ERR_INVALID_ADDRESS_STATE{ErrorModule::Kernel, 106};
-constexpr ResultCode ERR_PORT_NAME_TOO_LONG(ErrorModule::Kernel, ErrCodes::TooLarge);
+constexpr ResultCode ERR_INVALID_MEMORY_PERMISSIONS{ErrorModule::Kernel, 108};
-constexpr ResultCode ERR_MAX_CONNECTIONS_REACHED(ErrorModule::Kernel,
+constexpr ResultCode ERR_INVALID_MEMORY_RANGE{ErrorModule::Kernel, 110};
-                                                 ErrCodes::MaxConnectionsReached);
+constexpr ResultCode ERR_INVALID_PROCESSOR_ID{ErrorModule::Kernel, 113};
-constexpr ResultCode ERR_INVALID_ENUM_VALUE(ErrorModule::Kernel, ErrCodes::InvalidEnumValue);
+constexpr ResultCode ERR_INVALID_THREAD_PRIORITY{ErrorModule::Kernel, 112};
-constexpr ResultCode ERR_INVALID_COMBINATION_KERNEL(ErrorModule::Kernel,
+constexpr ResultCode ERR_INVALID_HANDLE{ErrorModule::Kernel, 114};
-                                                    ErrCodes::InvalidCombination);
+constexpr ResultCode ERR_INVALID_POINTER{ErrorModule::Kernel, 115};
-constexpr ResultCode ERR_INVALID_ADDRESS(ErrorModule::Kernel, ErrCodes::InvalidAddress);
+constexpr ResultCode ERR_INVALID_COMBINATION{ErrorModule::Kernel, 116};
-constexpr ResultCode ERR_INVALID_ADDRESS_STATE(ErrorModule::Kernel, ErrCodes::InvalidMemoryState);
+constexpr ResultCode RESULT_TIMEOUT{ErrorModule::Kernel, 117};
-constexpr ResultCode ERR_INVALID_MEMORY_PERMISSIONS(ErrorModule::Kernel,
+constexpr ResultCode ERR_SYNCHRONIZATION_CANCELED{ErrorModule::Kernel, 118};
-                                                    ErrCodes::InvalidMemoryPermissions);
+constexpr ResultCode ERR_OUT_OF_RANGE{ErrorModule::Kernel, 119};
-constexpr ResultCode ERR_INVALID_MEMORY_RANGE(ErrorModule::Kernel, ErrCodes::InvalidMemoryRange);
+constexpr ResultCode ERR_INVALID_ENUM_VALUE{ErrorModule::Kernel, 120};
-constexpr ResultCode ERR_INVALID_HANDLE(ErrorModule::Kernel, ErrCodes::InvalidHandle);
+constexpr ResultCode ERR_NOT_FOUND{ErrorModule::Kernel, 121};
-constexpr ResultCode ERR_INVALID_PROCESSOR_ID(ErrorModule::Kernel, ErrCodes::InvalidProcessorId);
+constexpr ResultCode ERR_ALREADY_REGISTERED{ErrorModule::Kernel, 122};
-constexpr ResultCode ERR_INVALID_SIZE(ErrorModule::Kernel, ErrCodes::InvalidSize);
+constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE{ErrorModule::Kernel, 123};
-constexpr ResultCode ERR_ALREADY_REGISTERED(ErrorModule::Kernel, ErrCodes::AlreadyRegistered);
+constexpr ResultCode ERR_INVALID_STATE{ErrorModule::Kernel, 125};
-constexpr ResultCode ERR_INVALID_STATE(ErrorModule::Kernel, ErrCodes::InvalidState);
+constexpr ResultCode ERR_RESOURCE_LIMIT_EXCEEDED{ErrorModule::Kernel, 132};
-constexpr ResultCode ERR_INVALID_THREAD_PRIORITY(ErrorModule::Kernel,
-                                                 ErrCodes::InvalidThreadPriority);
-constexpr ResultCode ERR_INVALID_POINTER(ErrorModule::Kernel, ErrCodes::InvalidPointer);
-constexpr ResultCode ERR_NOT_FOUND(ErrorModule::Kernel, ErrCodes::NoSuchEntry);
-constexpr ResultCode RESULT_TIMEOUT(ErrorModule::Kernel, ErrCodes::Timeout);
 } // namespace Kernel
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index 420218d59..f06b6bb55 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -5,11 +5,9 @@
 #include <algorithm>
 #include <memory>
 #include "common/assert.h"
-#include "common/common_funcs.h"
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/file_sys/program_metadata.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
@@ -17,6 +15,7 @@
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"
+#include "core/settings.h"
 namespace Kernel {
@@ -35,6 +34,11 @@ SharedPtr<Process> Process::Create(KernelCore& kernel, std::string&& name) {
    process->process_id = kernel.CreateNewProcessID();
    process->svc_access_mask.set();
+    std::mt19937 rng(Settings::values.rng_seed.value_or(0));
+    std::uniform_int_distribution<u64> distribution;
+    std::generate(process->random_entropy.begin(), process->random_entropy.end(),
+                  [&] { return distribution(rng); });
    kernel.AppendNewProcess(process);
    return process;
 }
@@ -241,83 +245,15 @@ void Process::LoadModule(CodeSet module_, VAddr base_addr) {
 }
 ResultVal<VAddr> Process::HeapAllocate(VAddr target, u64 size, VMAPermission perms) {
-    if (target < vm_manager.GetHeapRegionBaseAddress() ||
+    return vm_manager.HeapAllocate(target, size, perms);
-        target + size > vm_manager.GetHeapRegionEndAddress() || target + size < target) {
-        return ERR_INVALID_ADDRESS;
-    }
-    if (heap_memory == nullptr) {
-        // Initialize heap
-        heap_memory = std::make_shared<std::vector<u8>>();
-        heap_start = heap_end = target;
-    } else {
-        vm_manager.UnmapRange(heap_start, heap_end - heap_start);
-    }
-    // If necessary, expand backing vector to cover new heap extents.
-    if (target < heap_start) {
-        heap_memory->insert(begin(*heap_memory), heap_start - target, 0);
-        heap_start = target;
-        vm_manager.RefreshMemoryBlockMappings(heap_memory.get());
-    }
-    if (target + size > heap_end) {
-        heap_memory->insert(end(*heap_memory), (target + size) - heap_end, 0);
-        heap_end = target + size;
-        vm_manager.RefreshMemoryBlockMappings(heap_memory.get());
-    }
-    ASSERT(heap_end - heap_start == heap_memory->size());
-    CASCADE_RESULT(auto vma, vm_manager.MapMemoryBlock(target, heap_memory, target - heap_start,
-                                                       size, MemoryState::Heap));
-    vm_manager.Reprotect(vma, perms);
-    heap_used = size;
-    return MakeResult<VAddr>(heap_end - size);
 }
 ResultCode Process::HeapFree(VAddr target, u32 size) {
-    if (target < vm_manager.GetHeapRegionBaseAddress() ||
+    return vm_manager.HeapFree(target, size);
-        target + size > vm_manager.GetHeapRegionEndAddress() || target + size < target) {
-        return ERR_INVALID_ADDRESS;
-    }
-    if (size == 0) {
-        return RESULT_SUCCESS;
-    }
-    ResultCode result = vm_manager.UnmapRange(target, size);
-    if (result.IsError())
-        return result;
-    heap_used -= size;
-    return RESULT_SUCCESS;
 }
 ResultCode Process::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
-    auto vma = vm_manager.FindVMA(src_addr);
+    return vm_manager.MirrorMemory(dst_addr, src_addr, size);
-    ASSERT_MSG(vma != vm_manager.vma_map.end(), "Invalid memory address");
-    ASSERT_MSG(vma->second.backing_block, "Backing block doesn't exist for address");
-    // The returned VMA might be a bigger one encompassing the desired address.
-    auto vma_offset = src_addr - vma->first;
-    ASSERT_MSG(vma_offset + size <= vma->second.size,
-               "Shared memory exceeds bounds of mapped block");
-    const std::shared_ptr<std::vector<u8>>& backing_block = vma->second.backing_block;
-    std::size_t backing_block_offset = vma->second.offset + vma_offset;
-    CASCADE_RESULT(auto new_vma,
-                   vm_manager.MapMemoryBlock(dst_addr, backing_block, backing_block_offset, size,
-                                             MemoryState::Mapped));
-    // Protect mirror with permissions from old region
-    vm_manager.Reprotect(new_vma, vma->second.permissions);
-    // Remove permissions from old region
-    vm_manager.Reprotect(vma, VMAPermission::None);
-    return RESULT_SUCCESS;
 }
 ResultCode Process::UnmapMemory(VAddr dst_addr, VAddr /*src_addr*/, u64 size) {
diff --git a/src/core/hle/kernel/process.h b/src/core/hle/kernel/process.h
index 8d2616c79..cf48787ce 100644
--- a/src/core/hle/kernel/process.h
+++ b/src/core/hle/kernel/process.h
@@ -8,6 +8,7 @@
 #include <bitset>
 #include <cstddef>
 #include <memory>
+#include <random>
 #include <string>
 #include <vector>
 #include <boost/container/static_vector.hpp>
@@ -119,6 +120,8 @@ struct CodeSet final {
 class Process final : public Object {
 public:
+    static constexpr std::size_t RANDOM_ENTROPY_SIZE = 4;
    static SharedPtr<Process> Create(KernelCore& kernel, std::string&& name);
    std::string GetTypeName() const override {
@@ -212,6 +215,11 @@ public:
        total_process_running_time_ticks += ticks;
    }
+    /// Gets 8 bytes of random data for svcGetInfo RandomEntropy
+    u64 GetRandomEntropy(std::size_t index) const {
+        return random_entropy.at(index);
+    }
    /**
     * Loads process-specifics configuration info with metadata provided
     * by an executable.
@@ -292,17 +300,6 @@ private:
    u32 allowed_thread_priority_mask = 0xFFFFFFFF;
    u32 is_virtual_address_memory_enabled = 0;
-    // Memory used to back the allocations in the regular heap. A single vector is used to cover
-    // the entire virtual address space extents that bound the allocations, including any holes.
-    // This makes deallocation and reallocation of holes fast and keeps process memory contiguous
-    // in the emulator address space, allowing Memory::GetPointer to be reasonably safe.
-    std::shared_ptr<std::vector<u8>> heap_memory;
-    // The left/right bounds of the address space covered by heap_memory.
-    VAddr heap_start = 0;
-    VAddr heap_end = 0;
-    u64 heap_used = 0;
    /// The Thread Local Storage area is allocated as processes create threads,
    /// each TLS area is 0x200 bytes, so one page (0x1000) is split up in 8 parts, and each part
    /// holds the TLS for a specific thread. This vector contains which parts are in use for each
@@ -321,6 +318,9 @@ private:
    /// Per-process handle table for storing created object handles in.
    HandleTable handle_table;
+    /// Random values for svcGetInfo RandomEntropy
+    std::array<u64, RANDOM_ENTROPY_SIZE> random_entropy;
    std::string name;
 };
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index 7e8e87c33..2e7c9d094 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -34,6 +34,7 @@
 #include "core/hle/lock.h"
 #include "core/hle/result.h"
 #include "core/hle/service/service.h"
+#include "core/settings.h"
 namespace Kernel {
 namespace {
@@ -122,6 +123,48 @@ static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
    return RESULT_SUCCESS;
 }
+static ResultCode SetMemoryPermission(VAddr addr, u64 size, u32 prot) {
+    LOG_TRACE(Kernel_SVC, "called, addr=0x{:X}, size=0x{:X}, prot=0x{:X}", addr, size, prot);
+    if (!Common::Is4KBAligned(addr)) {
+        return ERR_INVALID_ADDRESS;
+    }
+    if (size == 0 || !Common::Is4KBAligned(size)) {
+        return ERR_INVALID_SIZE;
+    }
+    if (!IsValidAddressRange(addr, size)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+    const auto permission = static_cast<MemoryPermission>(prot);
+    if (permission != MemoryPermission::None && permission != MemoryPermission::Read &&
+        permission != MemoryPermission::ReadWrite) {
+        return ERR_INVALID_MEMORY_PERMISSIONS;
+    }
+    auto* const current_process = Core::CurrentProcess();
+    auto& vm_manager = current_process->VMManager();
+    if (!IsInsideAddressSpace(vm_manager, addr, size)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+    const VMManager::VMAHandle iter = vm_manager.FindVMA(addr);
+    if (iter == vm_manager.vma_map.end()) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+    LOG_WARNING(Kernel_SVC, "Uniformity check on protected memory is not implemented.");
+    // TODO: Performs a uniformity check to make sure only protected memory is changed (it doesn't
+    // make sense to allow changing permissions on kernel memory itself, etc).
+    const auto converted_permissions = SharedMemory::ConvertPermissions(permission);
+    return vm_manager.ReprotectRange(addr, size, converted_permissions);
+}
 static ResultCode SetMemoryAttribute(VAddr addr, u64 size, u32 state0, u32 state1) {
    LOG_WARNING(Kernel_SVC,
                "(STUBBED) called, addr=0x{:X}, size=0x{:X}, state0=0x{:X}, state1=0x{:X}", addr,
@@ -171,7 +214,7 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
    // Read 1 char beyond the max allowed port name to detect names that are too long.
    std::string port_name = Memory::ReadCString(port_name_address, PortNameMaxLength + 1);
    if (port_name.size() > PortNameMaxLength) {
-        return ERR_PORT_NAME_TOO_LONG;
+        return ERR_OUT_OF_RANGE;
    }
    LOG_TRACE(Kernel_SVC, "called port_name={}", port_name);
@@ -267,8 +310,9 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
    static constexpr u64 MaxHandles = 0x40;
-    if (handle_count > MaxHandles)
+    if (handle_count > MaxHandles) {
-        return ResultCode(ErrorModule::Kernel, ErrCodes::TooLarge);
+        return ERR_OUT_OF_RANGE;
+    }
    auto* const thread = GetCurrentThread();
@@ -333,8 +377,7 @@ static ResultCode CancelSynchronization(Handle thread_handle) {
    }
    ASSERT(thread->GetStatus() == ThreadStatus::WaitSynchAny);
-    thread->SetWaitSynchronizationResult(
+    thread->SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
-        ResultCode(ErrorModule::Kernel, ErrCodes::SynchronizationCanceled));
    thread->ResumeFromWait();
    return RESULT_SUCCESS;
 }
@@ -558,7 +601,16 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
        *result = 0;
        break;
    case GetInfoType::RandomEntropy:
-        *result = 0;
+        if (handle != 0) {
+            return ERR_INVALID_HANDLE;
+        }
+        if (info_sub_id >= Process::RANDOM_ENTROPY_SIZE) {
+            return ERR_INVALID_COMBINATION;
+        }
+        *result = current_process->GetRandomEntropy(info_sub_id);
+        return RESULT_SUCCESS;
        break;
    case GetInfoType::ASLRRegionBaseAddr:
        *result = vm_manager.GetASLRRegionBaseAddress();
@@ -591,7 +643,7 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
    case GetInfoType::ThreadTickCount: {
        constexpr u64 num_cpus = 4;
        if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) {
-            return ERR_INVALID_COMBINATION_KERNEL;
+            return ERR_INVALID_COMBINATION;
        }
        const auto thread =
@@ -1184,7 +1236,7 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
    }
    if (mask == 0) {
-        return ResultCode(ErrorModule::Kernel, ErrCodes::InvalidCombination);
+        return ERR_INVALID_COMBINATION;
    }
    /// This value is used to only change the affinity mask without changing the current ideal core.
@@ -1193,12 +1245,12 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
    if (core == OnlyChangeMask) {
        core = thread->GetIdealCore();
    } else if (core >= Core::NUM_CPU_CORES && core != static_cast<u32>(-1)) {
-        return ResultCode(ErrorModule::Kernel, ErrCodes::InvalidProcessorId);
+        return ERR_INVALID_PROCESSOR_ID;
    }
    // Error out if the input core isn't enabled in the input mask.
    if (core < Core::NUM_CPU_CORES && (mask & (1ull << core)) == 0) {
-        return ResultCode(ErrorModule::Kernel, ErrCodes::InvalidCombination);
+        return ERR_INVALID_COMBINATION;
    }
    thread->ChangeCore(core, mask);
@@ -1287,7 +1339,7 @@ struct FunctionDef {
 static const FunctionDef SVC_Table[] = {
    {0x00, nullptr, "Unknown"},
    {0x01, SvcWrap<SetHeapSize>, "SetHeapSize"},
-    {0x02, nullptr, "SetMemoryPermission"},
+    {0x02, SvcWrap<SetMemoryPermission>, "SetMemoryPermission"},
    {0x03, SvcWrap<SetMemoryAttribute>, "SetMemoryAttribute"},
    {0x04, SvcWrap<MapMemory>, "MapMemory"},
    {0x05, SvcWrap<UnmapMemory>, "UnmapMemory"},
diff --git a/src/core/hle/kernel/svc_wrap.h b/src/core/hle/kernel/svc_wrap.h
index b09753c80..233a99fb0 100644
--- a/src/core/hle/kernel/svc_wrap.h
+++ b/src/core/hle/kernel/svc_wrap.h
@@ -121,6 +121,11 @@ void SvcWrap() {
    FuncReturn(func(Param(0), Param(1), Param(2)).raw);
 }
+template <ResultCode func(u64, u64, u32)>
+void SvcWrap() {
+    FuncReturn(func(Param(0), Param(1), static_cast<u32>(Param(2))).raw);
+}
 template <ResultCode func(u32, u64, u64, u32)>
 void SvcWrap() {
    FuncReturn(
diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp
index dd5cd9ced..4ffb76818 100644
--- a/src/core/hle/kernel/thread.cpp
+++ b/src/core/hle/kernel/thread.cpp
@@ -142,36 +142,7 @@ void Thread::ResumeFromWait() {
    status = ThreadStatus::Ready;
-    std::optional<s32> new_processor_id = GetNextProcessorId(affinity_mask);
+    ChangeScheduler();
-    if (!new_processor_id) {
-        new_processor_id = processor_id;
-    }
-    if (ideal_core != -1 &&
-        Core::System::GetInstance().Scheduler(ideal_core).GetCurrentThread() == nullptr) {
-        new_processor_id = ideal_core;
-    }
-    ASSERT(*new_processor_id < 4);
-    // Add thread to new core's scheduler
-    auto* next_scheduler = &Core::System::GetInstance().Scheduler(*new_processor_id);
-    if (*new_processor_id != processor_id) {
-        // Remove thread from previous core's scheduler
-        scheduler->RemoveThread(this);
-        next_scheduler->AddThread(this, current_priority);
-    }
-    processor_id = *new_processor_id;
-    // If the thread was ready, unschedule from the previous core and schedule on the new core
-    scheduler->UnscheduleThread(this, current_priority);
-    next_scheduler->ScheduleThread(this, current_priority);
-    // Change thread's scheduler
-    scheduler = next_scheduler;
-    Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
 }
 /**
@@ -364,42 +335,45 @@ void Thread::UpdatePriority() {
 void Thread::ChangeCore(u32 core, u64 mask) {
    ideal_core = core;
    affinity_mask = mask;
+    ChangeScheduler();
+}
+void Thread::ChangeScheduler() {
    if (status != ThreadStatus::Ready) {
        return;
    }
+    auto& system = Core::System::GetInstance();
    std::optional<s32> new_processor_id{GetNextProcessorId(affinity_mask)};
    if (!new_processor_id) {
        new_processor_id = processor_id;
    }
-    if (ideal_core != -1 &&
+    if (ideal_core != -1 && system.Scheduler(ideal_core).GetCurrentThread() == nullptr) {
-        Core::System::GetInstance().Scheduler(ideal_core).GetCurrentThread() == nullptr) {
        new_processor_id = ideal_core;
    }
    ASSERT(*new_processor_id < 4);
    // Add thread to new core's scheduler
-    auto* next_scheduler = &Core::System::GetInstance().Scheduler(*new_processor_id);
+    auto& next_scheduler = system.Scheduler(*new_processor_id);
    if (*new_processor_id != processor_id) {
        // Remove thread from previous core's scheduler
        scheduler->RemoveThread(this);
-        next_scheduler->AddThread(this, current_priority);
+        next_scheduler.AddThread(this, current_priority);
    }
    processor_id = *new_processor_id;
    // If the thread was ready, unschedule from the previous core and schedule on the new core
    scheduler->UnscheduleThread(this, current_priority);
-    next_scheduler->ScheduleThread(this, current_priority);
+    next_scheduler.ScheduleThread(this, current_priority);
    // Change thread's scheduler
-    scheduler = next_scheduler;
+    scheduler = &next_scheduler;
-    Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
+    system.CpuCore(processor_id).PrepareReschedule();
 }
 bool Thread::AllWaitObjectsReady() {
diff --git a/src/core/hle/kernel/thread.h b/src/core/hle/kernel/thread.h
index 4a6e11239..d384d50db 100644
--- a/src/core/hle/kernel/thread.h
+++ b/src/core/hle/kernel/thread.h
@@ -374,6 +374,8 @@ private:
    explicit Thread(KernelCore& kernel);
    ~Thread() override;
+    void ChangeScheduler();
    Core::ARM_Interface::ThreadContext context{};
    u32 thread_id = 0;
diff --git a/src/core/hle/kernel/vm_manager.cpp b/src/core/hle/kernel/vm_manager.cpp
index 1a92c8f70..ec7fd6150 100644
--- a/src/core/hle/kernel/vm_manager.cpp
+++ b/src/core/hle/kernel/vm_manager.cpp
@@ -243,6 +243,85 @@ ResultCode VMManager::ReprotectRange(VAddr target, u64 size, VMAPermission new_p
    return RESULT_SUCCESS;
 }
+ResultVal<VAddr> VMManager::HeapAllocate(VAddr target, u64 size, VMAPermission perms) {
+    if (target < GetHeapRegionBaseAddress() || target + size > GetHeapRegionEndAddress() ||
+        target + size < target) {
+        return ERR_INVALID_ADDRESS;
+    }
+    if (heap_memory == nullptr) {
+        // Initialize heap
+        heap_memory = std::make_shared<std::vector<u8>>();
+        heap_start = heap_end = target;
+    } else {
+        UnmapRange(heap_start, heap_end - heap_start);
+    }
+    // If necessary, expand backing vector to cover new heap extents.
+    if (target < heap_start) {
+        heap_memory->insert(begin(*heap_memory), heap_start - target, 0);
+        heap_start = target;
+        RefreshMemoryBlockMappings(heap_memory.get());
+    }
+    if (target + size > heap_end) {
+        heap_memory->insert(end(*heap_memory), (target + size) - heap_end, 0);
+        heap_end = target + size;
+        RefreshMemoryBlockMappings(heap_memory.get());
+    }
+    ASSERT(heap_end - heap_start == heap_memory->size());
+    CASCADE_RESULT(auto vma, MapMemoryBlock(target, heap_memory, target - heap_start, size,
+                                            MemoryState::Heap));
+    Reprotect(vma, perms);
+    heap_used = size;
+    return MakeResult<VAddr>(heap_end - size);
+}
+ResultCode VMManager::HeapFree(VAddr target, u64 size) {
+    if (target < GetHeapRegionBaseAddress() || target + size > GetHeapRegionEndAddress() ||
+        target + size < target) {
+        return ERR_INVALID_ADDRESS;
+    }
+    if (size == 0) {
+        return RESULT_SUCCESS;
+    }
+    const ResultCode result = UnmapRange(target, size);
+    if (result.IsError()) {
+        return result;
+    }
+    heap_used -= size;
+    return RESULT_SUCCESS;
+}
+ResultCode VMManager::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
+    const auto vma = FindVMA(src_addr);
+    ASSERT_MSG(vma != vma_map.end(), "Invalid memory address");
+    ASSERT_MSG(vma->second.backing_block, "Backing block doesn't exist for address");
+    // The returned VMA might be a bigger one encompassing the desired address.
+    const auto vma_offset = src_addr - vma->first;
+    ASSERT_MSG(vma_offset + size <= vma->second.size,
+               "Shared memory exceeds bounds of mapped block");
+    const std::shared_ptr<std::vector<u8>>& backing_block = vma->second.backing_block;
+    const std::size_t backing_block_offset = vma->second.offset + vma_offset;
+    CASCADE_RESULT(auto new_vma, MapMemoryBlock(dst_addr, backing_block, backing_block_offset, size,
+                                                MemoryState::Mapped));
+    // Protect mirror with permissions from old region
+    Reprotect(new_vma, vma->second.permissions);
+    // Remove permissions from old region
+    Reprotect(vma, VMAPermission::None);
+    return RESULT_SUCCESS;
+}
 void VMManager::RefreshMemoryBlockMappings(const std::vector<u8>* block) {
    // If this ever proves to have a noticeable performance impact, allow users of the function to
    // specify a specific range of addresses to limit the scan to.
@@ -495,8 +574,7 @@ u64 VMManager::GetTotalMemoryUsage() const {
 }
 u64 VMManager::GetTotalHeapUsage() const {
-    LOG_WARNING(Kernel, "(STUBBED) called");
+    return heap_used;
-    return 0x0;
 }
 VAddr VMManager::GetAddressSpaceBaseAddress() const {
diff --git a/src/core/hle/kernel/vm_manager.h b/src/core/hle/kernel/vm_manager.h
index 2447cbb8f..248cc46dc 100644
--- a/src/core/hle/kernel/vm_manager.h
+++ b/src/core/hle/kernel/vm_manager.h
@@ -186,6 +186,11 @@ public:
    /// Changes the permissions of a range of addresses, splitting VMAs as necessary.
    ResultCode ReprotectRange(VAddr target, u64 size, VMAPermission new_perms);
+    ResultVal<VAddr> HeapAllocate(VAddr target, u64 size, VMAPermission perms);
+    ResultCode HeapFree(VAddr target, u64 size);
+    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size);
    /**
     * Scans all VMAs and updates the page table range of any that use the given vector as backing
     * memory. This should be called after any operation that causes reallocation of the vector.
@@ -343,5 +348,15 @@ private:
    VAddr tls_io_region_base = 0;
    VAddr tls_io_region_end = 0;
+    // Memory used to back the allocations in the regular heap. A single vector is used to cover
+    // the entire virtual address space extents that bound the allocations, including any holes.
+    // This makes deallocation and reallocation of holes fast and keeps process memory contiguous
+    // in the emulator address space, allowing Memory::GetPointer to be reasonably safe.
+    std::shared_ptr<std::vector<u8>> heap_memory;
+    // The left/right bounds of the address space covered by heap_memory.
+    VAddr heap_start = 0;
+    VAddr heap_end = 0;
+    u64 heap_used = 0;
 };
 } // namespace Kernel
diff --git a/src/core/hle/result.h b/src/core/hle/result.h
index c6b18cfba..bfb77cc31 100644
--- a/src/core/hle/result.h
+++ b/src/core/hle/result.h
@@ -19,8 +19,6 @@
 enum class ErrorDescription : u32 {
    Success = 0,
    RemoteProcessDead = 301,
-    InvalidOffset = 6061,
-    InvalidLength = 6062,
 };
 /**
diff --git a/src/core/hle/service/acc/acc.cpp b/src/core/hle/service/acc/acc.cpp
index 8318eff5f..c629f9357 100644
--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -252,8 +252,10 @@ void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContex
        rb.PushRaw<u128>(INVALID_UUID);
        return;
    }
-    auto user_list = profile_manager->GetAllUsers();
-    if (user_list.empty()) {
+    const auto user_list = profile_manager->GetAllUsers();
+    if (std::all_of(user_list.begin(), user_list.end(),
+                    [](const auto& user) { return user.uuid == INVALID_UUID; })) {
        rb.Push(ResultCode(-1)); // TODO(ogniK): Find the correct error code
        rb.PushRaw<u128>(INVALID_UUID);
        return;
diff --git a/src/core/hle/service/acc/profile_manager.cpp b/src/core/hle/service/acc/profile_manager.cpp
index c08394e4c..968263846 100644
--- a/src/core/hle/service/acc/profile_manager.cpp
+++ b/src/core/hle/service/acc/profile_manager.cpp
@@ -2,8 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include <cstring>
 #include <random>
+#include <fmt/format.h>
 #include "common/file_util.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
@@ -39,6 +42,19 @@ UUID UUID::Generate() {
    return UUID{distribution(gen), distribution(gen)};
 }
+std::string UUID::Format() const {
+    return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
+}
+std::string UUID::FormatSwitch() const {
+    std::array<u8, 16> s{};
+    std::memcpy(s.data(), uuid.data(), sizeof(u128));
+    return fmt::format("{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{"
+                       ":02x}{:02x}{:02x}{:02x}{:02x}",
+                       s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], s[10], s[11],
+                       s[12], s[13], s[14], s[15]);
+}
 ProfileManager::ProfileManager() {
    ParseUserSaveFile();
@@ -325,11 +341,12 @@ void ProfileManager::ParseUserSaveFile() {
        return;
    }
-    for (std::size_t i = 0; i < MAX_USERS; ++i) {
+    for (const auto& user : data.users) {
-        const auto& user = data.users[i];
+        if (user.uuid == UUID(INVALID_UUID)) {
+            continue;
+        }
-        if (user.uuid != UUID(INVALID_UUID))
+        AddUser({user.uuid, user.username, user.timestamp, {}, false});
-            AddUser({user.uuid, user.username, user.timestamp, {}, false});
    }
    std::stable_partition(profiles.begin(), profiles.end(),
diff --git a/src/core/hle/service/acc/profile_manager.h b/src/core/hle/service/acc/profile_manager.h
index 747c46c20..d2d8e6c6b 100644
--- a/src/core/hle/service/acc/profile_manager.h
+++ b/src/core/hle/service/acc/profile_manager.h
@@ -42,18 +42,9 @@ struct UUID {
    void Invalidate() {
        uuid = INVALID_UUID;
    }
-    std::string Format() const {
-        return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
-    }
-    std::string FormatSwitch() const {
+    std::string Format() const;
-        std::array<u8, 16> s{};
+    std::string FormatSwitch() const;
-        std::memcpy(s.data(), uuid.data(), sizeof(u128));
-        return fmt::format("{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{"
-                           ":02x}{:02x}{:02x}{:02x}{:02x}",
-                           s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], s[10], s[11],
-                           s[12], s[13], s[14], s[15]);
-    }
 };
 static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
diff --git a/src/core/hle/service/audio/audren_u.cpp b/src/core/hle/service/audio/audren_u.cpp
index fac6785a5..d3ea57ea7 100644
--- a/src/core/hle/service/audio/audren_u.cpp
+++ b/src/core/hle/service/audio/audren_u.cpp
@@ -28,13 +28,13 @@ public:
            {1, &IAudioRenderer::GetSampleCount, "GetSampleCount"},
            {2, &IAudioRenderer::GetMixBufferCount, "GetMixBufferCount"},
            {3, &IAudioRenderer::GetState, "GetState"},
-            {4, &IAudioRenderer::RequestUpdate, "RequestUpdate"},
+            {4, &IAudioRenderer::RequestUpdateImpl, "RequestUpdate"},
            {5, &IAudioRenderer::Start, "Start"},
            {6, &IAudioRenderer::Stop, "Stop"},
            {7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
-            {8, nullptr, "SetRenderingTimeLimit"},
+            {8, &IAudioRenderer::SetRenderingTimeLimit, "SetRenderingTimeLimit"},
-            {9, nullptr, "GetRenderingTimeLimit"},
+            {9, &IAudioRenderer::GetRenderingTimeLimit, "GetRenderingTimeLimit"},
-            {10, nullptr, "RequestUpdateAuto"},
+            {10, &IAudioRenderer::RequestUpdateImpl, "RequestUpdateAuto"},
            {11, nullptr, "ExecuteAudioRendererRendering"},
        };
        // clang-format on
@@ -79,7 +79,7 @@ private:
        LOG_DEBUG(Service_Audio, "called");
    }
-    void RequestUpdate(Kernel::HLERequestContext& ctx) {
+    void RequestUpdateImpl(Kernel::HLERequestContext& ctx) {
        ctx.WriteBuffer(renderer->UpdateAudioRenderer(ctx.ReadBuffer()));
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
@@ -110,8 +110,29 @@ private:
        LOG_WARNING(Service_Audio, "(STUBBED) called");
    }
+    void SetRenderingTimeLimit(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        rendering_time_limit_percent = rp.Pop<u32>();
+        ASSERT(rendering_time_limit_percent >= 0 && rendering_time_limit_percent <= 100);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_DEBUG(Service_Audio, "called. rendering_time_limit_percent={}",
+                  rendering_time_limit_percent);
+    }
+    void GetRenderingTimeLimit(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_Audio, "called");
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(rendering_time_limit_percent);
+    }
    Kernel::SharedPtr<Kernel::Event> system_event;
    std::unique_ptr<AudioCore::AudioRenderer> renderer;
+    u32 rendering_time_limit_percent = 100;
 };
 class IAudioDevice final : public ServiceFramework<IAudioDevice> {
diff --git a/src/core/hle/service/audio/hwopus.cpp b/src/core/hle/service/audio/hwopus.cpp
index 783c39503..763e619a4 100644
--- a/src/core/hle/service/audio/hwopus.cpp
+++ b/src/core/hle/service/audio/hwopus.cpp
@@ -77,8 +77,8 @@ private:
        IPC::ResponseBuilder rb{ctx, 6};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(consumed);
-        rb.Push<u64>(performance);
        rb.Push<u32>(sample_count);
+        rb.Push<u64>(performance);
        ctx.WriteBuffer(samples.data(), samples.size() * sizeof(s16));
    }
diff --git a/src/core/hle/service/btdrv/btdrv.cpp b/src/core/hle/service/btdrv/btdrv.cpp
index d0a15cc4c..f3bde6d0d 100644
--- a/src/core/hle/service/btdrv/btdrv.cpp
+++ b/src/core/hle/service/btdrv/btdrv.cpp
@@ -2,12 +2,49 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/event.h"
+#include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/btdrv/btdrv.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 namespace Service::BtDrv {
+class Bt final : public ServiceFramework<Bt> {
+public:
+    explicit Bt() : ServiceFramework{"bt"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Unknown0"},
+            {1, nullptr, "Unknown1"},
+            {2, nullptr, "Unknown2"},
+            {3, nullptr, "Unknown3"},
+            {4, nullptr, "Unknown4"},
+            {5, nullptr, "Unknown5"},
+            {6, nullptr, "Unknown6"},
+            {7, nullptr, "Unknown7"},
+            {8, nullptr, "Unknown8"},
+            {9, &Bt::RegisterEvent, "RegisterEvent"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+private:
+    void RegisterEvent(Kernel::HLERequestContext& ctx) {
+        auto& kernel = Core::System::GetInstance().Kernel();
+        register_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "BT:RegisterEvent");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushCopyObjects(register_event);
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+    }
+    Kernel::SharedPtr<Kernel::Event> register_event;
+};
 class BtDrv final : public ServiceFramework<BtDrv> {
 public:
    explicit BtDrv() : ServiceFramework{"btdrv"} {
@@ -67,6 +104,7 @@ public:
 void InstallInterfaces(SM::ServiceManager& sm) {
    std::make_shared<BtDrv>()->InstallAsService(sm);
+    std::make_shared<Bt>()->InstallAsService(sm);
 }
 } // namespace Service::BtDrv
diff --git a/src/core/hle/service/btm/btm.cpp b/src/core/hle/service/btm/btm.cpp
index b949bfabd..a02f6b53a 100644
--- a/src/core/hle/service/btm/btm.cpp
+++ b/src/core/hle/service/btm/btm.cpp
@@ -6,13 +6,118 @@
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/btm/btm.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
 namespace Service::BTM {
+class IBtmUserCore final : public ServiceFramework<IBtmUserCore> {
+public:
+    explicit IBtmUserCore() : ServiceFramework{"IBtmUserCore"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IBtmUserCore::GetScanEvent, "GetScanEvent"},
+            {1, nullptr, "Unknown1"},
+            {2, nullptr, "Unknown2"},
+            {3, nullptr, "Unknown3"},
+            {4, nullptr, "Unknown4"},
+            {5, nullptr, "Unknown5"},
+            {6, nullptr, "Unknown6"},
+            {7, nullptr, "Unknown7"},
+            {8, nullptr, "Unknown8"},
+            {9, nullptr, "Unknown9"},
+            {10, nullptr, "Unknown10"},
+            {17, &IBtmUserCore::GetConnectionEvent, "GetConnectionEvent"},
+            {18, nullptr, "Unknown18"},
+            {19, nullptr, "Unknown19"},
+            {20, nullptr, "Unknown20"},
+            {21, nullptr, "Unknown21"},
+            {22, nullptr, "Unknown22"},
+            {23, nullptr, "Unknown23"},
+            {24, nullptr, "Unknown24"},
+            {25, nullptr, "Unknown25"},
+            {26, &IBtmUserCore::GetDiscoveryEvent, "AcquireBleServiceDiscoveryEventImpl"},
+            {27, nullptr, "Unknown27"},
+            {28, nullptr, "Unknown28"},
+            {29, nullptr, "Unknown29"},
+            {30, nullptr, "Unknown30"},
+            {31, nullptr, "Unknown31"},
+            {32, nullptr, "Unknown32"},
+            {33, &IBtmUserCore::GetConfigEvent, "GetConfigEvent"},
+            {34, nullptr, "Unknown34"},
+            {35, nullptr, "Unknown35"},
+            {36, nullptr, "Unknown36"},
+            {37, nullptr, "Unknown37"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+private:
+    void GetScanEvent(Kernel::HLERequestContext& ctx) {
+        auto& kernel = Core::System::GetInstance().Kernel();
+        scan_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ScanEvent");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushCopyObjects(scan_event);
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+    }
+    void GetConnectionEvent(Kernel::HLERequestContext& ctx) {
+        auto& kernel = Core::System::GetInstance().Kernel();
+        connection_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+                                                 "IBtmUserCore:ConnectionEvent");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushCopyObjects(connection_event);
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+    }
+    void GetDiscoveryEvent(Kernel::HLERequestContext& ctx) {
+        auto& kernel = Core::System::GetInstance().Kernel();
+        service_discovery =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:Discovery");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushCopyObjects(service_discovery);
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+    }
+    void GetConfigEvent(Kernel::HLERequestContext& ctx) {
+        auto& kernel = Core::System::GetInstance().Kernel();
+        config_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConfigEvent");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushCopyObjects(config_event);
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+    }
+    Kernel::SharedPtr<Kernel::Event> scan_event;
+    Kernel::SharedPtr<Kernel::Event> connection_event;
+    Kernel::SharedPtr<Kernel::Event> service_discovery;
+    Kernel::SharedPtr<Kernel::Event> config_event;
+};
+class BTM_USR final : public ServiceFramework<BTM_USR> {
+public:
+    explicit BTM_USR() : ServiceFramework{"btm:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &BTM_USR::GetCoreImpl, "GetCoreImpl"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+private:
+    void GetCoreImpl(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IBtmUserCore>();
+        LOG_DEBUG(Service_BTM, "called");
+    }
+};
 class BTM final : public ServiceFramework<BTM> {
 public:
    explicit BTM() : ServiceFramework{"btm"} {
@@ -116,6 +221,7 @@ void InstallInterfaces(SM::ServiceManager& sm) {
    std::make_shared<BTM>()->InstallAsService(sm);
    std::make_shared<BTM_DBG>()->InstallAsService(sm);
    std::make_shared<BTM_SYS>()->InstallAsService(sm);
+    std::make_shared<BTM_USR>()->InstallAsService(sm);
 }
 } // namespace Service::BTM
diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp
index e32a7c48e..5d6294016 100644
--- a/src/core/hle/service/filesystem/filesystem.cpp
+++ b/src/core/hle/service/filesystem/filesystem.cpp
@@ -303,25 +303,42 @@ ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
              static_cast<u8>(space), save_struct.DebugInfo());
    if (save_data_factory == nullptr) {
-        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound);
+        return FileSys::ERROR_ENTITY_NOT_FOUND;
    }
    return save_data_factory->Open(space, save_struct);
 }
+ResultVal<FileSys::VirtualDir> OpenSaveDataSpace(FileSys::SaveDataSpaceId space) {
+    LOG_TRACE(Service_FS, "Opening Save Data Space for space_id={:01X}", static_cast<u8>(space));
+    if (save_data_factory == nullptr) {
+        return FileSys::ERROR_ENTITY_NOT_FOUND;
+    }
+    return MakeResult(save_data_factory->GetSaveDataSpaceDirectory(space));
+}
 ResultVal<FileSys::VirtualDir> OpenSDMC() {
    LOG_TRACE(Service_FS, "Opening SDMC");
    if (sdmc_factory == nullptr) {
-        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::SdCardNotFound);
+        return FileSys::ERROR_SD_CARD_NOT_FOUND;
    }
    return sdmc_factory->Open();
 }
-std::unique_ptr<FileSys::RegisteredCacheUnion> GetUnionContents() {
+std::shared_ptr<FileSys::RegisteredCacheUnion> registered_cache_union;
-    return std::make_unique<FileSys::RegisteredCacheUnion>(std::vector<FileSys::RegisteredCache*>{
-        GetSystemNANDContents(), GetUserNANDContents(), GetSDMCContents()});
+std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents() {
+    if (registered_cache_union == nullptr) {
+        registered_cache_union =
+            std::make_shared<FileSys::RegisteredCacheUnion>(std::vector<FileSys::RegisteredCache*>{
+                GetSystemNANDContents(), GetUserNANDContents(), GetSDMCContents()});
+    }
+    return registered_cache_union;
 }
 FileSys::RegisteredCache* GetSystemNANDContents() {
@@ -360,6 +377,15 @@ FileSys::VirtualDir GetModificationLoadRoot(u64 title_id) {
    return bis_factory->GetModificationLoadRoot(title_id);
 }
+FileSys::VirtualDir GetModificationDumpRoot(u64 title_id) {
+    LOG_TRACE(Service_FS, "Opening mod dump root for tid={:016X}", title_id);
+    if (bis_factory == nullptr)
+        return nullptr;
+    return bis_factory->GetModificationDumpRoot(title_id);
+}
 void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
    if (overwrite) {
        bis_factory = nullptr;
@@ -373,13 +399,21 @@ void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
                                          FileSys::Mode::ReadWrite);
    auto load_directory = vfs.OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::LoadDir),
                                            FileSys::Mode::ReadWrite);
+    auto dump_directory = vfs.OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::DumpDir),
+                                            FileSys::Mode::ReadWrite);
-    if (bis_factory == nullptr)
+    if (bis_factory == nullptr) {
-        bis_factory = std::make_unique<FileSys::BISFactory>(nand_directory, load_directory);
+        bis_factory =
-    if (save_data_factory == nullptr)
+            std::make_unique<FileSys::BISFactory>(nand_directory, load_directory, dump_directory);
+    }
+    if (save_data_factory == nullptr) {
        save_data_factory = std::make_unique<FileSys::SaveDataFactory>(std::move(nand_directory));
-    if (sdmc_factory == nullptr)
+    }
+    if (sdmc_factory == nullptr) {
        sdmc_factory = std::make_unique<FileSys::SDMCFactory>(std::move(sd_directory));
+    }
 }
 void InstallInterfaces(SM::ServiceManager& service_manager, FileSys::VfsFilesystem& vfs) {
diff --git a/src/core/hle/service/filesystem/filesystem.h b/src/core/hle/service/filesystem/filesystem.h
index 6ca5c5636..ff9182e84 100644
--- a/src/core/hle/service/filesystem/filesystem.h
+++ b/src/core/hle/service/filesystem/filesystem.h
@@ -45,15 +45,17 @@ ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId stora
                                          FileSys::ContentRecordType type);
 ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
                                            FileSys::SaveDataDescriptor save_struct);
+ResultVal<FileSys::VirtualDir> OpenSaveDataSpace(FileSys::SaveDataSpaceId space);
 ResultVal<FileSys::VirtualDir> OpenSDMC();
-std::unique_ptr<FileSys::RegisteredCacheUnion> GetUnionContents();
+std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents();
 FileSys::RegisteredCache* GetSystemNANDContents();
 FileSys::RegisteredCache* GetUserNANDContents();
 FileSys::RegisteredCache* GetSDMCContents();
 FileSys::VirtualDir GetModificationLoadRoot(u64 title_id);
+FileSys::VirtualDir GetModificationDumpRoot(u64 title_id);
 // Creates the SaveData, SDMC, and BIS Factories. Should be called once and before any function
 // above is called.
diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp
index c1c83a11d..038dc80b1 100644
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -11,6 +11,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
+#include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "core/file_sys/directory.h"
@@ -62,12 +63,12 @@ private:
        // Error checking
        if (length < 0) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
+            rb.Push(FileSys::ERROR_INVALID_SIZE);
            return;
        }
        if (offset < 0) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidOffset));
+            rb.Push(FileSys::ERROR_INVALID_OFFSET);
            return;
        }
@@ -107,12 +108,12 @@ private:
        // Error checking
        if (length < 0) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
+            rb.Push(FileSys::ERROR_INVALID_SIZE);
            return;
        }
        if (offset < 0) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidOffset));
+            rb.Push(FileSys::ERROR_INVALID_OFFSET);
            return;
        }
@@ -138,12 +139,12 @@ private:
        // Error checking
        if (length < 0) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
+            rb.Push(FileSys::ERROR_INVALID_SIZE);
            return;
        }
        if (offset < 0) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidOffset));
+            rb.Push(FileSys::ERROR_INVALID_OFFSET);
            return;
        }
@@ -451,7 +452,147 @@ private:
    VfsDirectoryServiceWrapper backend;
 };
+class ISaveDataInfoReader final : public ServiceFramework<ISaveDataInfoReader> {
+public:
+    explicit ISaveDataInfoReader(FileSys::SaveDataSpaceId space)
+        : ServiceFramework("ISaveDataInfoReader") {
+        static const FunctionInfo functions[] = {
+            {0, &ISaveDataInfoReader::ReadSaveDataInfo, "ReadSaveDataInfo"},
+        };
+        RegisterHandlers(functions);
+        FindAllSaves(space);
+    }
+    void ReadSaveDataInfo(Kernel::HLERequestContext& ctx) {
+        // Calculate how many entries we can fit in the output buffer
+        const u64 count_entries = ctx.GetWriteBufferSize() / sizeof(SaveDataInfo);
+        // Cap at total number of entries.
+        const u64 actual_entries = std::min(count_entries, info.size() - next_entry_index);
+        // Determine data start and end
+        const auto* begin = reinterpret_cast<u8*>(info.data() + next_entry_index);
+        const auto* end = reinterpret_cast<u8*>(info.data() + next_entry_index + actual_entries);
+        const auto range_size = static_cast<std::size_t>(std::distance(begin, end));
+        next_entry_index += actual_entries;
+        // Write the data to memory
+        ctx.WriteBuffer(begin, range_size);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(static_cast<u32>(actual_entries));
+    }
+private:
+    static u64 stoull_be(std::string_view str) {
+        if (str.size() != 16)
+            return 0;
+        const auto bytes = Common::HexStringToArray<0x8>(str);
+        u64 out{};
+        std::memcpy(&out, bytes.data(), sizeof(u64));
+        return Common::swap64(out);
+    }
+    void FindAllSaves(FileSys::SaveDataSpaceId space) {
+        const auto save_root = OpenSaveDataSpace(space);
+        ASSERT(save_root.Succeeded());
+        for (const auto& type : (*save_root)->GetSubdirectories()) {
+            if (type->GetName() == "save") {
+                for (const auto& save_id : type->GetSubdirectories()) {
+                    for (const auto& user_id : save_id->GetSubdirectories()) {
+                        const auto save_id_numeric = stoull_be(save_id->GetName());
+                        auto user_id_numeric = Common::HexStringToArray<0x10>(user_id->GetName());
+                        std::reverse(user_id_numeric.begin(), user_id_numeric.end());
+                        if (save_id_numeric != 0) {
+                            // System Save Data
+                            info.emplace_back(SaveDataInfo{
+                                0,
+                                space,
+                                FileSys::SaveDataType::SystemSaveData,
+                                {},
+                                user_id_numeric,
+                                save_id_numeric,
+                                0,
+                                user_id->GetSize(),
+                                {},
+                            });
+                            continue;
+                        }
+                        for (const auto& title_id : user_id->GetSubdirectories()) {
+                            const auto device =
+                                std::all_of(user_id_numeric.begin(), user_id_numeric.end(),
+                                            [](u8 val) { return val == 0; });
+                            info.emplace_back(SaveDataInfo{
+                                0,
+                                space,
+                                device ? FileSys::SaveDataType::DeviceSaveData
+                                       : FileSys::SaveDataType::SaveData,
+                                {},
+                                user_id_numeric,
+                                save_id_numeric,
+                                stoull_be(title_id->GetName()),
+                                title_id->GetSize(),
+                                {},
+                            });
+                        }
+                    }
+                }
+            } else if (space == FileSys::SaveDataSpaceId::TemporaryStorage) {
+                // Temporary Storage
+                for (const auto& user_id : type->GetSubdirectories()) {
+                    for (const auto& title_id : user_id->GetSubdirectories()) {
+                        if (!title_id->GetFiles().empty() ||
+                            !title_id->GetSubdirectories().empty()) {
+                            auto user_id_numeric =
+                                Common::HexStringToArray<0x10>(user_id->GetName());
+                            std::reverse(user_id_numeric.begin(), user_id_numeric.end());
+                            info.emplace_back(SaveDataInfo{
+                                0,
+                                space,
+                                FileSys::SaveDataType::TemporaryStorage,
+                                {},
+                                user_id_numeric,
+                                stoull_be(type->GetName()),
+                                stoull_be(title_id->GetName()),
+                                title_id->GetSize(),
+                                {},
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    struct SaveDataInfo {
+        u64_le save_id_unknown;
+        FileSys::SaveDataSpaceId space;
+        FileSys::SaveDataType type;
+        INSERT_PADDING_BYTES(0x6);
+        std::array<u8, 0x10> user_id;
+        u64_le save_id;
+        u64_le title_id;
+        u64_le save_image_size;
+        INSERT_PADDING_BYTES(0x28);
+    };
+    static_assert(sizeof(SaveDataInfo) == 0x60, "SaveDataInfo has incorrect size.");
+    std::vector<SaveDataInfo> info;
+    u64 next_entry_index = 0;
+};
 FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
+    // clang-format off
    static const FunctionInfo functions[] = {
        {0, nullptr, "MountContent"},
        {1, &FSP_SRV::Initialize, "Initialize"},
@@ -485,7 +626,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
        {58, nullptr, "ReadSaveDataFileSystemExtraData"},
        {59, nullptr, "WriteSaveDataFileSystemExtraData"},
        {60, nullptr, "OpenSaveDataInfoReader"},
-        {61, nullptr, "OpenSaveDataInfoReaderBySaveDataSpaceId"},
+        {61, &FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId, "OpenSaveDataInfoReaderBySaveDataSpaceId"},
        {62, nullptr, "OpenCacheStorageList"},
        {64, nullptr, "OpenSaveDataInternalStorageFileSystem"},
        {65, nullptr, "UpdateSaveDataMacForDebug"},
@@ -544,6 +685,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
        {1009, nullptr, "GetAndClearMemoryReportInfo"},
        {1100, nullptr, "OverrideSaveDataTransferTokenSignVerificationKey"},
    };
+    // clang-format on
    RegisterHandlers(functions);
 }
@@ -602,7 +744,7 @@ void FSP_SRV::MountSaveData(Kernel::HLERequestContext& ctx) {
    if (dir.Failed()) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 0};
-        rb.Push(ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound));
+        rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
        return;
    }
@@ -618,6 +760,15 @@ void FSP_SRV::OpenReadOnlySaveDataFileSystem(Kernel::HLERequestContext& ctx) {
    MountSaveData(ctx);
 }
+void FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto space = rp.PopRaw<FileSys::SaveDataSpaceId>();
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<ISaveDataInfoReader>(std::make_shared<ISaveDataInfoReader>(space));
+}
 void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service_FS, "(STUBBED) called");
@@ -685,7 +836,7 @@ void FSP_SRV::OpenRomStorage(Kernel::HLERequestContext& ctx) {
              static_cast<u8>(storage_id), title_id);
    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound));
+    rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
 }
 } // namespace Service::FileSystem
diff --git a/src/core/hle/service/filesystem/fsp_srv.h b/src/core/hle/service/filesystem/fsp_srv.h
index 4aa0358cb..e7abec0a3 100644
--- a/src/core/hle/service/filesystem/fsp_srv.h
+++ b/src/core/hle/service/filesystem/fsp_srv.h
@@ -25,6 +25,7 @@ private:
    void CreateSaveData(Kernel::HLERequestContext& ctx);
    void MountSaveData(Kernel::HLERequestContext& ctx);
    void OpenReadOnlySaveDataFileSystem(Kernel::HLERequestContext& ctx);
+    void OpenSaveDataInfoReaderBySaveDataSpaceId(Kernel::HLERequestContext& ctx);
    void GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
    void OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
    void OpenDataStorageByDataId(Kernel::HLERequestContext& ctx);
diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp
index ff9b64be4..205e4fd14 100644
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -40,6 +40,29 @@ enum class JoystickId : std::size_t {
    Joystick_Right,
 };
+static std::size_t NPadIdToIndex(u32 npad_id) {
+    switch (npad_id) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+        return npad_id;
+    case 8:
+    case NPAD_HANDHELD:
+        return 8;
+    case 9:
+    case NPAD_UNKNOWN:
+        return 9;
+    default:
+        UNIMPLEMENTED_MSG("Unknown npad id {}", npad_id);
+        return 0;
+    }
+}
 Controller_NPad::Controller_NPad() = default;
 Controller_NPad::~Controller_NPad() = default;
@@ -288,10 +311,11 @@ void Controller_NPad::OnUpdate(u8* data, std::size_t data_len) {
        switch (controller_type) {
        case NPadControllerType::Handheld:
            handheld_entry.connection_status.raw = 0;
-            handheld_entry.connection_status.IsConnected.Assign(1);
+            handheld_entry.connection_status.IsWired.Assign(1);
-            if (!Settings::values.use_docked_mode) {
+            handheld_entry.connection_status.IsLeftJoyConnected.Assign(1);
-                handheld_entry.connection_status.IsWired.Assign(1);
+            handheld_entry.connection_status.IsRightJoyConnected.Assign(1);
-            }
+            handheld_entry.connection_status.IsLeftJoyWired.Assign(1);
+            handheld_entry.connection_status.IsRightJoyWired.Assign(1);
            handheld_entry.pad_states.raw = pad_state.raw;
            handheld_entry.l_stick = lstick_entry;
            handheld_entry.r_stick = rstick_entry;
@@ -310,6 +334,7 @@ void Controller_NPad::OnUpdate(u8* data, std::size_t data_len) {
            dual_entry.pad_states.raw = pad_state.raw;
            dual_entry.l_stick = lstick_entry;
            dual_entry.r_stick = rstick_entry;
+            break;
        case NPadControllerType::JoyLeft:
            left_entry.connection_status.raw = 0;
@@ -370,16 +395,30 @@ void Controller_NPad::SetSupportedNPadIdTypes(u8* data, std::size_t length) {
    supported_npad_id_types.clear();
    supported_npad_id_types.resize(length / sizeof(u32));
    std::memcpy(supported_npad_id_types.data(), data, length);
+    bool had_controller_update = false;
    for (std::size_t i = 0; i < connected_controllers.size(); i++) {
        auto& controller = connected_controllers[i];
        if (!controller.is_connected) {
            continue;
        }
        if (!IsControllerSupported(PREFERRED_CONTROLLER)) {
-            controller.type = DecideBestController(PREFERRED_CONTROLLER);
+            const auto best_type = DecideBestController(PREFERRED_CONTROLLER);
-            InitNewlyAddedControler(i);
+            const bool is_handheld = (best_type == NPadControllerType::Handheld ||
+                                      PREFERRED_CONTROLLER == NPadControllerType::Handheld);
+            if (is_handheld) {
+                controller.type = NPadControllerType::None;
+                controller.is_connected = false;
+                AddNewController(best_type);
+            } else {
+                controller.type = best_type;
+                InitNewlyAddedControler(i);
+            }
+            had_controller_update = true;
        }
    }
+    if (had_controller_update) {
+        styleset_changed_event->Signal();
+    }
 }
 void Controller_NPad::GetSupportedNpadIdTypes(u32* data, std::size_t max_length) {
@@ -457,15 +496,11 @@ void Controller_NPad::AddNewController(NPadControllerType controller) {
 }
 void Controller_NPad::ConnectNPad(u32 npad_id) {
-    if (npad_id >= connected_controllers.size())
+    connected_controllers[NPadIdToIndex(npad_id)].is_connected = true;
-        return;
-    connected_controllers[npad_id].is_connected = true;
 }
 void Controller_NPad::DisconnectNPad(u32 npad_id) {
-    if (npad_id >= connected_controllers.size())
+    connected_controllers[NPadIdToIndex(npad_id)].is_connected = false;
-        return;
-    connected_controllers[npad_id].is_connected = false;
 }
 Controller_NPad::LedPattern Controller_NPad::GetLedPattern(u32 npad_id) {
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index a45fd4954..39631b14f 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -286,10 +286,10 @@ public:
            {519, nullptr, "GetPalmaOperationResult"},
            {520, nullptr, "ReadPalmaPlayLog"},
            {521, nullptr, "ResetPalmaPlayLog"},
-            {522, nullptr, "SetIsPalmaAllConnectable"},
+            {522, &Hid::SetIsPalmaAllConnectable, "SetIsPalmaAllConnectable"},
            {523, nullptr, "SetIsPalmaPairedConnectable"},
            {524, nullptr, "PairPalma"},
-            {525, nullptr, "SetPalmaBoostMode"},
+            {525, &Hid::SetPalmaBoostMode, "SetPalmaBoostMode"},
            {1000, nullptr, "SetNpadCommunicationMode"},
            {1001, nullptr, "GetNpadCommunicationMode"},
        };
@@ -596,6 +596,18 @@ private:
        rb.Push(RESULT_SUCCESS);
        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
+    void SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
+    void SetPalmaBoostMode(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
 };
 class HidDbg final : public ServiceFramework<HidDbg> {
diff --git a/src/core/hle/service/nfp/nfp.cpp b/src/core/hle/service/nfp/nfp.cpp
index c1af878fe..1d6e7756f 100644
--- a/src/core/hle/service/nfp/nfp.cpp
+++ b/src/core/hle/service/nfp/nfp.cpp
@@ -212,7 +212,7 @@ private:
        IPC::ResponseBuilder rb{ctx, 2};
        auto amiibo = nfp_interface.GetAmiiboBuffer();
        TagInfo tag_info{};
-        std::memcpy(tag_info.uuid.data(), amiibo.uuid.data(), sizeof(tag_info.uuid.size()));
+        tag_info.uuid = amiibo.uuid;
        tag_info.uuid_length = static_cast<u8>(tag_info.uuid.size());
        tag_info.protocol = 1; // TODO(ogniK): Figure out actual values
diff --git a/src/core/hle/service/ns/ns.cpp b/src/core/hle/service/ns/ns.cpp
index 07c1381fe..1d2978f24 100644
--- a/src/core/hle/service/ns/ns.cpp
+++ b/src/core/hle/service/ns/ns.cpp
@@ -2,6 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include "common/logging/log.h"
+#include "core/file_sys/control_metadata.h"
+#include "core/file_sys/patch_manager.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/ns/ns.h"
@@ -118,7 +121,7 @@ public:
            {305, nullptr, "TerminateSystemApplet"},
            {306, nullptr, "LaunchOverlayApplet"},
            {307, nullptr, "TerminateOverlayApplet"},
-            {400, nullptr, "GetApplicationControlData"},
+            {400, &IApplicationManagerInterface::GetApplicationControlData, "GetApplicationControlData"},
            {401, nullptr, "InvalidateAllApplicationControlCache"},
            {402, nullptr, "RequestDownloadApplicationControlData"},
            {403, nullptr, "GetMaxApplicationControlCacheCount"},
@@ -243,6 +246,65 @@ public:
        RegisterHandlers(functions);
    }
+    void GetApplicationControlData(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto flag = rp.PopRaw<u64>();
+        LOG_DEBUG(Service_NS, "called with flag={:016X}", flag);
+        const auto title_id = rp.PopRaw<u64>();
+        const auto size = ctx.GetWriteBufferSize();
+        const FileSys::PatchManager pm{title_id};
+        const auto control = pm.GetControlMetadata();
+        std::vector<u8> out;
+        if (control.first != nullptr) {
+            if (size < 0x4000) {
+                LOG_ERROR(Service_NS,
+                          "output buffer is too small! (actual={:016X}, expected_min=0x4000)",
+                          size);
+                IPC::ResponseBuilder rb{ctx, 2};
+                // TODO(DarkLordZach): Find a better error code for this.
+                rb.Push(ResultCode(-1));
+                return;
+            }
+            out.resize(0x4000);
+            const auto bytes = control.first->GetRawBytes();
+            std::memcpy(out.data(), bytes.data(), bytes.size());
+        } else {
+            LOG_WARNING(Service_NS, "missing NACP data for title_id={:016X}, defaulting to zeros.",
+                        title_id);
+            out.resize(std::min<u64>(0x4000, size));
+        }
+        if (control.second != nullptr) {
+            if (size < 0x4000 + control.second->GetSize()) {
+                LOG_ERROR(Service_NS,
+                          "output buffer is too small! (actual={:016X}, expected_min={:016X})",
+                          size, 0x4000 + control.second->GetSize());
+                IPC::ResponseBuilder rb{ctx, 2};
+                // TODO(DarkLordZach): Find a better error code for this.
+                rb.Push(ResultCode(-1));
+                return;
+            }
+            out.resize(0x4000 + control.second->GetSize());
+            control.second->Read(out.data() + 0x4000, control.second->GetSize());
+        } else {
+            LOG_WARNING(Service_NS, "missing icon data for title_id={:016X}, defaulting to zeros.",
+                        title_id);
+        }
+        ctx.WriteBuffer(out);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(static_cast<u32>(out.size()));
+    }
 };
 class IApplicationVersionInterface final : public ServiceFramework<IApplicationVersionInterface> {
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index a4cf45267..1ec340466 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -80,8 +80,8 @@ namespace Service {
 * Creates a function string for logging, complete with the name (or header code, depending
 * on what's passed in) the port name, and all the cmd_buff arguments.
 */
-static std::string MakeFunctionString(const char* name, const char* port_name,
+[[maybe_unused]] static std::string MakeFunctionString(const char* name, const char* port_name,
-                                      const u32* cmd_buff) {
+                                                       const u32* cmd_buff) {
    // Number of params == bits 0-5 + bits 6-11
    int num_params = (cmd_buff[0] & 0x3F) + ((cmd_buff[0] >> 6) & 0x3F);
diff --git a/src/core/hle/service/spl/module.cpp b/src/core/hle/service/spl/module.cpp
index 44a6717d0..b2de2a818 100644
--- a/src/core/hle/service/spl/module.cpp
+++ b/src/core/hle/service/spl/module.cpp
@@ -3,18 +3,23 @@
 // Refer to the license.txt file included.
 #include <algorithm>
+#include <chrono>
 #include <cstdlib>
+#include <ctime>
+#include <functional>
 #include <vector>
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/spl/csrng.h"
 #include "core/hle/service/spl/module.h"
 #include "core/hle/service/spl/spl.h"
+#include "core/settings.h"
 namespace Service::SPL {
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
-    : ServiceFramework(name), module(std::move(module)) {}
+    : ServiceFramework(name), module(std::move(module)),
+      rng(Settings::values.rng_seed.value_or(std::time(nullptr))) {}
 Module::Interface::~Interface() = default;
@@ -23,8 +28,9 @@ void Module::Interface::GetRandomBytes(Kernel::HLERequestContext& ctx) {
    std::size_t size = ctx.GetWriteBufferSize();
+    std::uniform_int_distribution<u16> distribution(0, std::numeric_limits<u8>::max());
    std::vector<u8> data(size);
-    std::generate(data.begin(), data.end(), std::rand);
+    std::generate(data.begin(), data.end(), [&] { return static_cast<u8>(distribution(rng)); });
    ctx.WriteBuffer(data);
diff --git a/src/core/hle/service/spl/module.h b/src/core/hle/service/spl/module.h
index 48fda6099..afa1f0295 100644
--- a/src/core/hle/service/spl/module.h
+++ b/src/core/hle/service/spl/module.h
@@ -4,6 +4,7 @@
 #pragma once
+#include <random>
 #include "core/hle/service/service.h"
 namespace Service::SPL {
@@ -19,6 +20,9 @@ public:
    protected:
        std::shared_ptr<Module> module;
+    private:
+        std::mt19937 rng;
    };
 };
diff --git a/src/core/hle/service/time/interface.cpp b/src/core/hle/service/time/interface.cpp
index 18a5d71d5..e3cbd7004 100644
--- a/src/core/hle/service/time/interface.cpp
+++ b/src/core/hle/service/time/interface.cpp
@@ -21,7 +21,7 @@ Time::Time(std::shared_ptr<Module> time, const char* name)
        {102, nullptr, "GetStandardUserSystemClockInitialYear"},
        {200, nullptr, "IsStandardNetworkSystemClockAccuracySufficient"},
        {300, nullptr, "CalculateMonotonicSystemClockBaseTimePoint"},
-        {400, nullptr, "GetClockSnapshot"},
+        {400, &Time::GetClockSnapshot, "GetClockSnapshot"},
        {401, nullptr, "GetClockSnapshotFromSystemClockContext"},
        {500, nullptr, "CalculateStandardUserSystemClockDifferenceByUser"},
        {501, nullptr, "CalculateSpanBetween"},
diff --git a/src/core/hle/service/time/time.cpp b/src/core/hle/service/time/time.cpp
index 28fd8debc..85e7b1195 100644
--- a/src/core/hle/service/time/time.cpp
+++ b/src/core/hle/service/time/time.cpp
@@ -15,6 +15,44 @@
 namespace Service::Time {
+static void PosixToCalendar(u64 posix_time, CalendarTime& calendar_time,
+                            CalendarAdditionalInfo& additional_info,
+                            [[maybe_unused]] const TimeZoneRule& /*rule*/) {
+    const std::time_t time(posix_time);
+    const std::tm* tm = std::localtime(&time);
+    if (tm == nullptr) {
+        calendar_time = {};
+        additional_info = {};
+        return;
+    }
+    calendar_time.year = tm->tm_year + 1900;
+    calendar_time.month = tm->tm_mon + 1;
+    calendar_time.day = tm->tm_mday;
+    calendar_time.hour = tm->tm_hour;
+    calendar_time.minute = tm->tm_min;
+    calendar_time.second = tm->tm_sec;
+    additional_info.day_of_week = tm->tm_wday;
+    additional_info.day_of_year = tm->tm_yday;
+    std::memcpy(additional_info.name.data(), "UTC", sizeof("UTC"));
+    additional_info.utc_offset = 0;
+}
+static u64 CalendarToPosix(const CalendarTime& calendar_time,
+                           [[maybe_unused]] const TimeZoneRule& /*rule*/) {
+    std::tm time{};
+    time.tm_year = calendar_time.year - 1900;
+    time.tm_mon = calendar_time.month - 1;
+    time.tm_mday = calendar_time.day;
+    time.tm_hour = calendar_time.hour;
+    time.tm_min = calendar_time.minute;
+    time.tm_sec = calendar_time.second;
+    std::time_t epoch_time = std::mktime(&time);
+    return static_cast<u64>(epoch_time);
+}
 class ISystemClock final : public ServiceFramework<ISystemClock> {
 public:
    ISystemClock() : ServiceFramework("ISystemClock") {
@@ -80,8 +118,8 @@ public:
            {5, nullptr, "GetTimeZoneRuleVersion"},
            {100, &ITimeZoneService::ToCalendarTime, "ToCalendarTime"},
            {101, &ITimeZoneService::ToCalendarTimeWithMyRule, "ToCalendarTimeWithMyRule"},
-            {201, nullptr, "ToPosixTime"},
+            {201, &ITimeZoneService::ToPosixTime, "ToPosixTime"},
-            {202, nullptr, "ToPosixTimeWithMyRule"},
+            {202, &ITimeZoneService::ToPosixTimeWithMyRule, "ToPosixTimeWithMyRule"},
        };
        RegisterHandlers(functions);
    }
@@ -151,24 +189,29 @@ private:
        rb.PushRaw(additional_info);
    }
-    void PosixToCalendar(u64 posix_time, CalendarTime& calendar_time,
+    void ToPosixTime(Kernel::HLERequestContext& ctx) {
-                         CalendarAdditionalInfo& additional_info, const TimeZoneRule& /*rule*/) {
+        // TODO(ogniK): Figure out how to handle multiple times
-        std::time_t t(posix_time);
+        LOG_WARNING(Service_Time, "(STUBBED) called");
-        std::tm* tm = std::localtime(&t);
+        IPC::RequestParser rp{ctx};
-        if (!tm) {
+        auto calendar_time = rp.PopRaw<CalendarTime>();
-            return;
+        auto posix_time = CalendarToPosix(calendar_time, {});
-        }
-        calendar_time.year = tm->tm_year + 1900;
+        IPC::ResponseBuilder rb{ctx, 3};
-        calendar_time.month = tm->tm_mon + 1;
+        rb.Push(RESULT_SUCCESS);
-        calendar_time.day = tm->tm_mday;
+        rb.PushRaw<u32>(1); // Amount of times we're returning
-        calendar_time.hour = tm->tm_hour;
+        ctx.WriteBuffer(&posix_time, sizeof(u64));
-        calendar_time.minute = tm->tm_min;
+    }
-        calendar_time.second = tm->tm_sec;
+    void ToPosixTimeWithMyRule(Kernel::HLERequestContext& ctx) {
-        additional_info.day_of_week = tm->tm_wday;
+        LOG_WARNING(Service_Time, "(STUBBED) called");
-        additional_info.day_of_year = tm->tm_yday;
+        IPC::RequestParser rp{ctx};
-        std::memcpy(additional_info.name.data(), "UTC", sizeof("UTC"));
+        auto calendar_time = rp.PopRaw<CalendarTime>();
-        additional_info.utc_offset = 0;
+        auto posix_time = CalendarToPosix(calendar_time, {});
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw<u32>(1); // Amount of times we're returning
+        ctx.WriteBuffer(&posix_time, sizeof(u64));
    }
 };
@@ -207,6 +250,55 @@ void Module::Interface::GetStandardLocalSystemClock(Kernel::HLERequestContext& c
    LOG_DEBUG(Service_Time, "called");
 }
+void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+    IPC::RequestParser rp{ctx};
+    auto unknown_u8 = rp.PopRaw<u8>();
+    ClockSnapshot clock_snapshot{};
+    const s64 time_since_epoch{std::chrono::duration_cast<std::chrono::seconds>(
+                                   std::chrono::system_clock::now().time_since_epoch())
+                                   .count()};
+    CalendarTime calendar_time{};
+    const std::time_t time(time_since_epoch);
+    const std::tm* tm = std::localtime(&time);
+    if (tm == nullptr) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultCode(-1)); // TODO(ogniK): Find appropriate error code
+        return;
+    }
+    SteadyClockTimePoint steady_clock_time_point{CoreTiming::cyclesToMs(CoreTiming::GetTicks()) /
+                                                 1000};
+    LocationName location_name{"UTC"};
+    calendar_time.year = tm->tm_year + 1900;
+    calendar_time.month = tm->tm_mon + 1;
+    calendar_time.day = tm->tm_mday;
+    calendar_time.hour = tm->tm_hour;
+    calendar_time.minute = tm->tm_min;
+    calendar_time.second = tm->tm_sec;
+    clock_snapshot.system_posix_time = time_since_epoch;
+    clock_snapshot.network_posix_time = time_since_epoch;
+    clock_snapshot.system_calendar_time = calendar_time;
+    clock_snapshot.network_calendar_time = calendar_time;
+    CalendarAdditionalInfo additional_info{};
+    PosixToCalendar(time_since_epoch, calendar_time, additional_info, {});
+    clock_snapshot.system_calendar_info = additional_info;
+    clock_snapshot.network_calendar_info = additional_info;
+    clock_snapshot.steady_clock_timepoint = steady_clock_time_point;
+    clock_snapshot.location_name = location_name;
+    clock_snapshot.clock_auto_adjustment_enabled = 1;
+    clock_snapshot.ipc_u8 = unknown_u8;
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    ctx.WriteBuffer(&clock_snapshot, sizeof(ClockSnapshot));
+}
 Module::Interface::Interface(std::shared_ptr<Module> time, const char* name)
    : ServiceFramework(name), time(std::move(time)) {}
diff --git a/src/core/hle/service/time/time.h b/src/core/hle/service/time/time.h
index 5659ecad3..77871ae07 100644
--- a/src/core/hle/service/time/time.h
+++ b/src/core/hle/service/time/time.h
@@ -5,6 +5,7 @@
 #pragma once
 #include <array>
+#include "common/common_funcs.h"
 #include "core/hle/service/service.h"
 namespace Service::Time {
@@ -53,6 +54,23 @@ struct SystemClockContext {
 static_assert(sizeof(SystemClockContext) == 0x20,
              "SystemClockContext structure has incorrect size");
+struct ClockSnapshot {
+    SystemClockContext user_clock_context;
+    SystemClockContext network_clock_context;
+    s64_le system_posix_time;
+    s64_le network_posix_time;
+    CalendarTime system_calendar_time;
+    CalendarTime network_calendar_time;
+    CalendarAdditionalInfo system_calendar_info;
+    CalendarAdditionalInfo network_calendar_info;
+    SteadyClockTimePoint steady_clock_timepoint;
+    LocationName location_name;
+    u8 clock_auto_adjustment_enabled;
+    u8 ipc_u8;
+    INSERT_PADDING_BYTES(2);
+};
+static_assert(sizeof(ClockSnapshot) == 0xd0, "ClockSnapshot is an invalid size");
 class Module final {
 public:
    class Interface : public ServiceFramework<Interface> {
@@ -65,6 +83,7 @@ public:
        void GetStandardSteadyClock(Kernel::HLERequestContext& ctx);
        void GetTimeZoneService(Kernel::HLERequestContext& ctx);
        void GetStandardLocalSystemClock(Kernel::HLERequestContext& ctx);
+        void GetClockSnapshot(Kernel::HLERequestContext& ctx);
    protected:
        std::shared_ptr<Module> time;
diff --git a/src/core/loader/nro.cpp b/src/core/loader/nro.cpp
index bc8e402a8..c8e491fec 100644
--- a/src/core/loader/nro.cpp
+++ b/src/core/loader/nro.cpp
@@ -12,10 +12,12 @@
 #include "common/swap.h"
 #include "core/core.h"
 #include "core/file_sys/control_metadata.h"
+#include "core/file_sys/romfs_factory.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/vm_manager.h"
+#include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/nro.h"
 #include "core/loader/nso.h"
 #include "core/memory.h"
@@ -208,6 +210,9 @@ ResultStatus AppLoader_NRO::Load(Kernel::Process& process) {
        return ResultStatus::ErrorLoadingNRO;
    }
+    if (romfs != nullptr)
+        Service::FileSystem::RegisterRomFS(std::make_unique<FileSys::RomFSFactory>(*this));
    process.Run(base_address, Kernel::THREADPRIO_DEFAULT, Memory::DEFAULT_STACK_SIZE);
    is_loaded = true;
diff --git a/src/core/loader/nso.cpp b/src/core/loader/nso.cpp
index 68efca5c0..aaf006309 100644
--- a/src/core/loader/nso.cpp
+++ b/src/core/loader/nso.cpp
@@ -154,7 +154,7 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(const FileSys::VfsFile& file, VAd
    program_image.resize(image_size);
    // Apply patches if necessary
-    if (pm && pm->HasNSOPatch(nso_header.build_id)) {
+    if (pm && (pm->HasNSOPatch(nso_header.build_id) || Settings::values.dump_nso)) {
        std::vector<u8> pi_header(program_image.size() + 0x100);
        std::memcpy(pi_header.data(), &nso_header, sizeof(NsoHeader));
        std::memcpy(pi_header.data() + 0x100, program_image.data(), program_image.size());
diff --git a/src/core/settings.h b/src/core/settings.h
index a8954647f..e424479f2 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -6,6 +6,7 @@
 #include <array>
 #include <atomic>
+#include <optional>
 #include <string>
 #include "common/common_types.h"
@@ -114,6 +115,7 @@ struct Values {
    // System
    bool use_docked_mode;
    bool enable_nfc;
+    std::optional<u32> rng_seed;
    s32 current_user;
    s32 language_index;
@@ -157,6 +159,7 @@ struct Values {
    bool use_gdbstub;
    u16 gdbstub_port;
    std::string program_args;
+    bool dump_nso;
    // WebService
    bool enable_telemetry;
diff --git a/src/video_core/engines/maxwell_3d.cpp b/src/video_core/engines/maxwell_3d.cpp
index d1777b25b..6de07ea56 100644
--- a/src/video_core/engines/maxwell_3d.cpp
+++ b/src/video_core/engines/maxwell_3d.cpp
@@ -121,10 +121,8 @@ void Maxwell3D::WriteReg(u32 method, u32 value, u32 remaining_params) {
        debug_context->OnEvent(Tegra::DebugContext::Event::MaxwellCommandLoaded, nullptr);
    }
-    u32 old = regs.reg_array[method];
+    if (regs.reg_array[method] != value) {
-    regs.reg_array[method] = value;
+        regs.reg_array[method] = value;
-    if (value != old) {
        if (method >= MAXWELL3D_REG_INDEX(vertex_attrib_format) &&
            method < MAXWELL3D_REG_INDEX(vertex_attrib_format) + regs.vertex_attrib_format.size()) {
            dirty_flags.vertex_attrib_format = true;
diff --git a/src/video_core/rasterizer_cache.h b/src/video_core/rasterizer_cache.h
index 6d41321fa..bcf0c15a4 100644
--- a/src/video_core/rasterizer_cache.h
+++ b/src/video_core/rasterizer_cache.h
@@ -5,6 +5,7 @@
 #pragma once
 #include <set>
+#include <unordered_map>
 #include <boost/icl/interval_map.hpp>
 #include <boost/range/iterator_range_core.hpp>
@@ -88,29 +89,25 @@ public:
    /// Invalidates everything in the cache
    void InvalidateAll() {
-        while (object_cache.begin() != object_cache.end()) {
+        while (interval_cache.begin() != interval_cache.end()) {
-            Unregister(*object_cache.begin()->second.begin());
+            Unregister(*interval_cache.begin()->second.begin());
        }
    }
 protected:
    /// Tries to get an object from the cache with the specified address
    T TryGet(VAddr addr) const {
-        const ObjectInterval interval{addr};
+        const auto iter = map_cache.find(addr);
-        for (auto& pair : boost::make_iterator_range(object_cache.equal_range(interval))) {
+        if (iter != map_cache.end())
-            for (auto& cached_object : pair.second) {
+            return iter->second;
-                if (cached_object->GetAddr() == addr) {
-                    return cached_object;
-                }
-            }
-        }
        return nullptr;
    }
    /// Register an object into the cache
    void Register(const T& object) {
        object->SetIsRegistered(true);
-        object_cache.add({GetInterval(object), ObjectSet{object}});
+        interval_cache.add({GetInterval(object), ObjectSet{object}});
+        map_cache.insert({object->GetAddr(), object});
        rasterizer.UpdatePagesCachedCount(object->GetAddr(), object->GetSizeInBytes(), 1);
    }
@@ -118,13 +115,13 @@ protected:
    void Unregister(const T& object) {
        object->SetIsRegistered(false);
        rasterizer.UpdatePagesCachedCount(object->GetAddr(), object->GetSizeInBytes(), -1);
        // Only flush if use_accurate_gpu_emulation is enabled, as it incurs a performance hit
        if (Settings::values.use_accurate_gpu_emulation) {
            FlushObject(object);
        }
-        object_cache.subtract({GetInterval(object), ObjectSet{object}});
+        interval_cache.subtract({GetInterval(object), ObjectSet{object}});
+        map_cache.erase(object->GetAddr());
    }
    /// Returns a ticks counter used for tracking when cached objects were last modified
@@ -141,7 +138,7 @@ private:
        std::vector<T> objects;
        const ObjectInterval interval{addr, addr + size};
-        for (auto& pair : boost::make_iterator_range(object_cache.equal_range(interval))) {
+        for (auto& pair : boost::make_iterator_range(interval_cache.equal_range(interval))) {
            for (auto& cached_object : pair.second) {
                if (!cached_object) {
                    continue;
@@ -167,15 +164,17 @@ private:
    }
    using ObjectSet = std::set<T>;
-    using ObjectCache = boost::icl::interval_map<VAddr, ObjectSet>;
+    using ObjectCache = std::unordered_map<VAddr, T>;
-    using ObjectInterval = typename ObjectCache::interval_type;
+    using IntervalCache = boost::icl::interval_map<VAddr, ObjectSet>;
+    using ObjectInterval = typename IntervalCache::interval_type;
    static auto GetInterval(const T& object) {
        return ObjectInterval::right_open(object->GetAddr(),
                                          object->GetAddr() + object->GetSizeInBytes());
    }
-    ObjectCache object_cache; ///< Cache of objects
+    ObjectCache map_cache;
-    u64 modified_ticks{};     ///< Counter of cache state ticks, used for in-order flushing
+    IntervalCache interval_cache; ///< Cache of objects
+    u64 modified_ticks{};         ///< Counter of cache state ticks, used for in-order flushing
    VideoCore::RasterizerInterface& rasterizer;
 };
diff --git a/src/video_core/renderer_base.cpp b/src/video_core/renderer_base.cpp
index 0df3725c2..1482cdb40 100644
--- a/src/video_core/renderer_base.cpp
+++ b/src/video_core/renderer_base.cpp
@@ -5,7 +5,6 @@
 #include "core/frontend/emu_window.h"
 #include "core/settings.h"
 #include "video_core/renderer_base.h"
-#include "video_core/renderer_opengl/gl_rasterizer.h"
 namespace VideoCore {
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
index 894f4f294..b44ecfa1c 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
@@ -314,6 +314,8 @@ static constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex
    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_5X4_SRGB
    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_5X5
    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_5X5_SRGB
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_10X8
+    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_10X8_SRGB
    // Depth formats
    {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, ComponentType::Float, false}, // Z32F
@@ -456,6 +458,8 @@ static constexpr GLConversionArray morton_to_gl_fns = {
        MortonCopy<true, PixelFormat::ASTC_2D_5X4_SRGB>,
        MortonCopy<true, PixelFormat::ASTC_2D_5X5>,
        MortonCopy<true, PixelFormat::ASTC_2D_5X5_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_10X8>,
+        MortonCopy<true, PixelFormat::ASTC_2D_10X8_SRGB>,
        MortonCopy<true, PixelFormat::Z32F>,
        MortonCopy<true, PixelFormat::Z16>,
        MortonCopy<true, PixelFormat::Z24S8>,
@@ -526,6 +530,8 @@ static constexpr GLConversionArray gl_to_morton_fns = {
        nullptr,
        nullptr,
        nullptr,
+        nullptr,
+        nullptr,
        MortonCopy<false, PixelFormat::Z32F>,
        MortonCopy<false, PixelFormat::Z16>,
        MortonCopy<false, PixelFormat::Z24S8>,
@@ -544,8 +550,8 @@ void SwizzleFunc(const GLConversionArray& functions, const SurfaceParams& params
    if (params.is_layered) {
        u64 offset = params.GetMipmapLevelOffset(mip_level);
        u64 offset_gl = 0;
-        u64 layer_size = params.LayerMemorySize();
+        const u64 layer_size = params.LayerMemorySize();
-        u64 gl_size = params.LayerSizeGL(mip_level);
+        const u64 gl_size = params.LayerSizeGL(mip_level);
        for (u32 i = 0; i < params.depth; i++) {
            functions[static_cast<std::size_t>(params.pixel_format)](
                params.MipWidth(mip_level), params.MipBlockHeight(mip_level),
@@ -555,7 +561,7 @@ void SwizzleFunc(const GLConversionArray& functions, const SurfaceParams& params
            offset_gl += gl_size;
        }
    } else {
-        u64 offset = params.GetMipmapLevelOffset(mip_level);
+        const u64 offset = params.GetMipmapLevelOffset(mip_level);
        functions[static_cast<std::size_t>(params.pixel_format)](
            params.MipWidth(mip_level), params.MipBlockHeight(mip_level),
            params.MipHeight(mip_level), params.MipBlockDepth(mip_level), depth, gl_buffer.data(),
@@ -709,18 +715,18 @@ static void FastCopySurface(const Surface& src_surface, const Surface& dst_surfa
 MICROPROFILE_DEFINE(OpenGL_CopySurface, "OpenGL", "CopySurface", MP_RGB(128, 192, 64));
 static void CopySurface(const Surface& src_surface, const Surface& dst_surface,
-                        GLuint copy_pbo_handle, GLenum src_attachment = 0,
+                        const GLuint copy_pbo_handle, const GLenum src_attachment = 0,
-                        GLenum dst_attachment = 0, std::size_t cubemap_face = 0) {
+                        const GLenum dst_attachment = 0, const std::size_t cubemap_face = 0) {
    MICROPROFILE_SCOPE(OpenGL_CopySurface);
    ASSERT_MSG(dst_attachment == 0, "Unimplemented");
    const auto& src_params{src_surface->GetSurfaceParams()};
    const auto& dst_params{dst_surface->GetSurfaceParams()};
-    auto source_format = GetFormatTuple(src_params.pixel_format, src_params.component_type);
+    const auto source_format = GetFormatTuple(src_params.pixel_format, src_params.component_type);
-    auto dest_format = GetFormatTuple(dst_params.pixel_format, dst_params.component_type);
+    const auto dest_format = GetFormatTuple(dst_params.pixel_format, dst_params.component_type);
-    std::size_t buffer_size = std::max(src_params.size_in_bytes, dst_params.size_in_bytes);
+    const std::size_t buffer_size = std::max(src_params.size_in_bytes, dst_params.size_in_bytes);
    glBindBuffer(GL_PIXEL_PACK_BUFFER, copy_pbo_handle);
    glBufferData(GL_PIXEL_PACK_BUFFER, buffer_size, nullptr, GL_STREAM_DRAW_ARB);
@@ -744,13 +750,10 @@ static void CopySurface(const Surface& src_surface, const Surface& dst_surface,
            LOG_DEBUG(HW_GPU, "Trying to upload extra texture data from the CPU during "
                              "reinterpretation but the texture is tiled.");
        }
-        std::size_t remaining_size = dst_params.size_in_bytes - src_params.size_in_bytes;
+        const std::size_t remaining_size = dst_params.size_in_bytes - src_params.size_in_bytes;
-        std::vector<u8> data(remaining_size);
-        std::memcpy(data.data(), Memory::GetPointer(dst_params.addr + src_params.size_in_bytes),
-                    data.size());
        glBufferSubData(GL_PIXEL_PACK_BUFFER, src_params.size_in_bytes, remaining_size,
-                        data.data());
+                        Memory::GetPointer(dst_params.addr + src_params.size_in_bytes));
    }
    glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
@@ -932,7 +935,9 @@ static void ConvertFormatAsNeeded_LoadGLBuffer(std::vector<u8>& data, PixelForma
    case PixelFormat::ASTC_2D_8X8_SRGB:
    case PixelFormat::ASTC_2D_8X5_SRGB:
    case PixelFormat::ASTC_2D_5X4_SRGB:
-    case PixelFormat::ASTC_2D_5X5_SRGB: {
+    case PixelFormat::ASTC_2D_5X5_SRGB:
+    case PixelFormat::ASTC_2D_10X8:
+    case PixelFormat::ASTC_2D_10X8_SRGB: {
        // Convert ASTC pixel formats to RGBA8, as most desktop GPUs do not support ASTC.
        u32 block_width{};
        u32 block_height{};
@@ -967,7 +972,11 @@ static void ConvertFormatAsNeeded_FlushGLBuffer(std::vector<u8>& data, PixelForm
    case PixelFormat::ASTC_2D_4X4:
    case PixelFormat::ASTC_2D_8X8:
    case PixelFormat::ASTC_2D_4X4_SRGB:
-    case PixelFormat::ASTC_2D_8X8_SRGB: {
+    case PixelFormat::ASTC_2D_8X8_SRGB:
+    case PixelFormat::ASTC_2D_5X5:
+    case PixelFormat::ASTC_2D_5X5_SRGB:
+    case PixelFormat::ASTC_2D_10X8:
+    case PixelFormat::ASTC_2D_10X8_SRGB: {
        LOG_CRITICAL(HW_GPU, "Conversion of format {} after texture flushing is not implemented",
                     static_cast<u32>(pixel_format));
        UNREACHABLE();
@@ -1336,6 +1345,7 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
        break;
    case SurfaceTarget::TextureCubemap:
    case SurfaceTarget::Texture3D:
+    case SurfaceTarget::Texture2DArray:
    case SurfaceTarget::TextureCubeArray:
        AccurateCopySurface(old_surface, new_surface);
        break;
diff --git a/src/video_core/renderer_opengl/gl_state.cpp b/src/video_core/renderer_opengl/gl_state.cpp
index 2635f2b0c..98622a058 100644
--- a/src/video_core/renderer_opengl/gl_state.cpp
+++ b/src/video_core/renderer_opengl/gl_state.cpp
@@ -266,7 +266,8 @@ void OpenGLState::ApplyViewport() const {
        const auto& updated = viewports[0];
        if (updated.x != current.x || updated.y != current.y || updated.width != current.width ||
            updated.height != current.height) {
-            glViewport(updated.x, updated.y, updated.width, updated.height);
+            glViewport(static_cast<GLint>(updated.x), static_cast<GLint>(updated.y),
+                       static_cast<GLsizei>(updated.width), static_cast<GLsizei>(updated.height));
        }
        if (updated.depth_range_near != current.depth_range_near ||
            updated.depth_range_far != current.depth_range_far) {
@@ -313,7 +314,7 @@ void OpenGLState::ApplyGlobalBlending() const {
    }
 }
-void OpenGLState::ApplyTargetBlending(int target, bool force) const {
+void OpenGLState::ApplyTargetBlending(std::size_t target, bool force) const {
    const Blend& updated = blend[target];
    const Blend& current = cur_state.blend[target];
    const bool blend_changed = updated.enabled != current.enabled || force;
diff --git a/src/video_core/renderer_opengl/gl_state.h b/src/video_core/renderer_opengl/gl_state.h
index eacca0b9c..e5d1baae6 100644
--- a/src/video_core/renderer_opengl/gl_state.h
+++ b/src/video_core/renderer_opengl/gl_state.h
@@ -208,7 +208,7 @@ private:
    void ApplyPrimitiveRestart() const;
    void ApplyStencilTest() const;
    void ApplyViewport() const;
-    void ApplyTargetBlending(int target, bool force) const;
+    void ApplyTargetBlending(std::size_t target, bool force) const;
    void ApplyGlobalBlending() const;
    void ApplyBlending() const;
    void ApplyLogicOp() const;
diff --git a/src/video_core/surface.cpp b/src/video_core/surface.cpp
index 051ad3964..9582dd2ca 100644
--- a/src/video_core/surface.cpp
+++ b/src/video_core/surface.cpp
@@ -306,6 +306,8 @@ PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
        return is_srgb ? PixelFormat::ASTC_2D_8X8_SRGB : PixelFormat::ASTC_2D_8X8;
    case Tegra::Texture::TextureFormat::ASTC_2D_8X5:
        return is_srgb ? PixelFormat::ASTC_2D_8X5_SRGB : PixelFormat::ASTC_2D_8X5;
+    case Tegra::Texture::TextureFormat::ASTC_2D_10X8:
+        return is_srgb ? PixelFormat::ASTC_2D_10X8_SRGB : PixelFormat::ASTC_2D_10X8;
    case Tegra::Texture::TextureFormat::R16_G16:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
@@ -453,6 +455,8 @@ bool IsPixelFormatASTC(PixelFormat format) {
    case PixelFormat::ASTC_2D_5X5_SRGB:
    case PixelFormat::ASTC_2D_8X8_SRGB:
    case PixelFormat::ASTC_2D_8X5_SRGB:
+    case PixelFormat::ASTC_2D_10X8:
+    case PixelFormat::ASTC_2D_10X8_SRGB:
        return true;
    default:
        return false;
diff --git a/src/video_core/surface.h b/src/video_core/surface.h
index dfdb8d122..0dd3eb2e4 100644
--- a/src/video_core/surface.h
+++ b/src/video_core/surface.h
@@ -74,19 +74,21 @@ enum class PixelFormat {
    ASTC_2D_5X4_SRGB = 56,
    ASTC_2D_5X5 = 57,
    ASTC_2D_5X5_SRGB = 58,
+    ASTC_2D_10X8 = 59,
+    ASTC_2D_10X8_SRGB = 60,
    MaxColorFormat,
    // Depth formats
-    Z32F = 59,
+    Z32F = 61,
-    Z16 = 60,
+    Z16 = 62,
    MaxDepthFormat,
    // DepthStencil formats
-    Z24S8 = 61,
+    Z24S8 = 63,
-    S8Z24 = 62,
+    S8Z24 = 64,
-    Z32FS8 = 63,
+    Z32FS8 = 65,
    MaxDepthStencilFormat,
@@ -193,6 +195,8 @@ static constexpr u32 GetCompressionFactor(PixelFormat format) {
        4, // ASTC_2D_5X4_SRGB
        4, // ASTC_2D_5X5
        4, // ASTC_2D_5X5_SRGB
+        4, // ASTC_2D_10X8
+        4, // ASTC_2D_10X8_SRGB
        1, // Z32F
        1, // Z16
        1, // Z24S8
@@ -208,70 +212,72 @@ static constexpr u32 GetDefaultBlockWidth(PixelFormat format) {
    if (format == PixelFormat::Invalid)
        return 0;
    constexpr std::array<u32, MaxPixelFormat> block_width_table = {{
-        1, // ABGR8U
+        1,  // ABGR8U
-        1, // ABGR8S
+        1,  // ABGR8S
-        1, // ABGR8UI
+        1,  // ABGR8UI
-        1, // B5G6R5U
+        1,  // B5G6R5U
-        1, // A2B10G10R10U
+        1,  // A2B10G10R10U
-        1, // A1B5G5R5U
+        1,  // A1B5G5R5U
-        1, // R8U
+        1,  // R8U
-        1, // R8UI
+        1,  // R8UI
-        1, // RGBA16F
+        1,  // RGBA16F
-        1, // RGBA16U
+        1,  // RGBA16U
-        1, // RGBA16UI
+        1,  // RGBA16UI
-        1, // R11FG11FB10F
+        1,  // R11FG11FB10F
-        1, // RGBA32UI
+        1,  // RGBA32UI
-        4, // DXT1
+        4,  // DXT1
-        4, // DXT23
+        4,  // DXT23
-        4, // DXT45
+        4,  // DXT45
-        4, // DXN1
+        4,  // DXN1
-        4, // DXN2UNORM
+        4,  // DXN2UNORM
-        4, // DXN2SNORM
+        4,  // DXN2SNORM
-        4, // BC7U
+        4,  // BC7U
-        4, // BC6H_UF16
+        4,  // BC6H_UF16
-        4, // BC6H_SF16
+        4,  // BC6H_SF16
-        4, // ASTC_2D_4X4
+        4,  // ASTC_2D_4X4
-        1, // G8R8U
+        1,  // G8R8U
-        1, // G8R8S
+        1,  // G8R8S
-        1, // BGRA8
+        1,  // BGRA8
-        1, // RGBA32F
+        1,  // RGBA32F
-        1, // RG32F
+        1,  // RG32F
-        1, // R32F
+        1,  // R32F
-        1, // R16F
+        1,  // R16F
-        1, // R16U
+        1,  // R16U
-        1, // R16S
+        1,  // R16S
-        1, // R16UI
+        1,  // R16UI
-        1, // R16I
+        1,  // R16I
-        1, // RG16
+        1,  // RG16
-        1, // RG16F
+        1,  // RG16F
-        1, // RG16UI
+        1,  // RG16UI
-        1, // RG16I
+        1,  // RG16I
-        1, // RG16S
+        1,  // RG16S
-        1, // RGB32F
+        1,  // RGB32F
-        1, // RGBA8_SRGB
+        1,  // RGBA8_SRGB
-        1, // RG8U
+        1,  // RG8U
-        1, // RG8S
+        1,  // RG8S
-        1, // RG32UI
+        1,  // RG32UI
-        1, // R32UI
+        1,  // R32UI
-        8, // ASTC_2D_8X8
+        8,  // ASTC_2D_8X8
-        8, // ASTC_2D_8X5
+        8,  // ASTC_2D_8X5
-        5, // ASTC_2D_5X4
+        5,  // ASTC_2D_5X4
-        1, // BGRA8_SRGB
+        1,  // BGRA8_SRGB
-        4, // DXT1_SRGB
+        4,  // DXT1_SRGB
-        4, // DXT23_SRGB
+        4,  // DXT23_SRGB
-        4, // DXT45_SRGB
+        4,  // DXT45_SRGB
-        4, // BC7U_SRGB
+        4,  // BC7U_SRGB
-        4, // ASTC_2D_4X4_SRGB
+        4,  // ASTC_2D_4X4_SRGB
-        8, // ASTC_2D_8X8_SRGB
+        8,  // ASTC_2D_8X8_SRGB
-        8, // ASTC_2D_8X5_SRGB
+        8,  // ASTC_2D_8X5_SRGB
-        5, // ASTC_2D_5X4_SRGB
+        5,  // ASTC_2D_5X4_SRGB
-        5, // ASTC_2D_5X5
+        5,  // ASTC_2D_5X5
-        5, // ASTC_2D_5X5_SRGB
+        5,  // ASTC_2D_5X5_SRGB
-        1, // Z32F
+        10, // ASTC_2D_10X8
-        1, // Z16
+        10, // ASTC_2D_10X8_SRGB
-        1, // Z24S8
+        1,  // Z32F
-        1, // S8Z24
+        1,  // Z16
-        1, // Z32FS8
+        1,  // Z24S8
+        1,  // S8Z24
+        1,  // Z32FS8
    }};
    ASSERT(static_cast<std::size_t>(format) < block_width_table.size());
    return block_width_table[static_cast<std::size_t>(format)];
@@ -341,6 +347,8 @@ static constexpr u32 GetDefaultBlockHeight(PixelFormat format) {
        4, // ASTC_2D_5X4_SRGB
        5, // ASTC_2D_5X5
        5, // ASTC_2D_5X5_SRGB
+        8, // ASTC_2D_10X8
+        8, // ASTC_2D_10X8_SRGB
        1, // Z32F
        1, // Z16
        1, // Z24S8
@@ -416,6 +424,8 @@ static constexpr u32 GetFormatBpp(PixelFormat format) {
        128, // ASTC_2D_5X4_SRGB
        128, // ASTC_2D_5X5
        128, // ASTC_2D_5X5_SRGB
+        128, // ASTC_2D_10X8
+        128, // ASTC_2D_10X8_SRGB
        32,  // Z32F
        16,  // Z16
        32,  // Z24S8
diff --git a/src/video_core/textures/decoders.cpp b/src/video_core/textures/decoders.cpp
index 3066abf61..19f30b1b5 100644
--- a/src/video_core/textures/decoders.cpp
+++ b/src/video_core/textures/decoders.cpp
@@ -45,7 +45,7 @@ constexpr auto fast_swizzle_table = SwizzleTable<8, 4, 16>();
 * Instead of going gob by gob, we map the coordinates inside a block and manage from
 * those. Block_Width is assumed to be 1.
 */
-void PreciseProcessBlock(u8* swizzled_data, u8* unswizzled_data, const bool unswizzle,
+void PreciseProcessBlock(u8* const swizzled_data, u8* const unswizzled_data, const bool unswizzle,
                         const u32 x_start, const u32 y_start, const u32 z_start, const u32 x_end,
                         const u32 y_end, const u32 z_end, const u32 tile_offset,
                         const u32 xy_block_size, const u32 layer_z, const u32 stride_x,
@@ -81,7 +81,7 @@ void PreciseProcessBlock(u8* swizzled_data, u8* unswizzled_data, const bool unsw
 * Instead of going gob by gob, we map the coordinates inside a block and manage from
 * those. Block_Width is assumed to be 1.
 */
-void FastProcessBlock(u8* swizzled_data, u8* unswizzled_data, const bool unswizzle,
+void FastProcessBlock(u8* const swizzled_data, u8* const unswizzled_data, const bool unswizzle,
                      const u32 x_start, const u32 y_start, const u32 z_start, const u32 x_end,
                      const u32 y_end, const u32 z_end, const u32 tile_offset,
                      const u32 xy_block_size, const u32 layer_z, const u32 stride_x,
@@ -90,10 +90,10 @@ void FastProcessBlock(u8* swizzled_data, u8* unswizzled_data, const bool unswizz
    u32 z_address = tile_offset;
    const u32 x_startb = x_start * bytes_per_pixel;
    const u32 x_endb = x_end * bytes_per_pixel;
-    const u32 copy_size = 16;
+    constexpr u32 copy_size = 16;
-    const u32 gob_size_x = 64;
+    constexpr u32 gob_size_x = 64;
-    const u32 gob_size_y = 8;
+    constexpr u32 gob_size_y = 8;
-    const u32 gob_size_z = 1;
+    constexpr u32 gob_size_z = 1;
    const u32 gob_size = gob_size_x * gob_size_y * gob_size_z;
    for (u32 z = z_start; z < z_end; z++) {
        u32 y_address = z_address;
@@ -126,23 +126,23 @@ void FastProcessBlock(u8* swizzled_data, u8* unswizzled_data, const bool unswizz
 *  https://envytools.readthedocs.io/en/latest/hw/memory/g80-surface.html#blocklinear-surfaces
 */
 template <bool fast>
-void SwizzledData(u8* swizzled_data, u8* unswizzled_data, const bool unswizzle, const u32 width,
+void SwizzledData(u8* const swizzled_data, u8* const unswizzled_data, const bool unswizzle,
-                  const u32 height, const u32 depth, const u32 bytes_per_pixel,
+                  const u32 width, const u32 height, const u32 depth, const u32 bytes_per_pixel,
                  const u32 out_bytes_per_pixel, const u32 block_height, const u32 block_depth) {
    auto div_ceil = [](const u32 x, const u32 y) { return ((x + y - 1) / y); };
    const u32 stride_x = width * out_bytes_per_pixel;
    const u32 layer_z = height * stride_x;
-    const u32 gob_x_bytes = 64;
+    constexpr u32 gob_x_bytes = 64;
    const u32 gob_elements_x = gob_x_bytes / bytes_per_pixel;
-    const u32 gob_elements_y = 8;
+    constexpr u32 gob_elements_y = 8;
-    const u32 gob_elements_z = 1;
+    constexpr u32 gob_elements_z = 1;
    const u32 block_x_elements = gob_elements_x;
    const u32 block_y_elements = gob_elements_y * block_height;
    const u32 block_z_elements = gob_elements_z * block_depth;
    const u32 blocks_on_x = div_ceil(width, block_x_elements);
    const u32 blocks_on_y = div_ceil(height, block_y_elements);
    const u32 blocks_on_z = div_ceil(depth, block_z_elements);
-    const u32 gob_size = gob_x_bytes * gob_elements_y * gob_elements_z;
+    constexpr u32 gob_size = gob_x_bytes * gob_elements_y * gob_elements_z;
    const u32 xy_block_size = gob_size * block_height;
    const u32 block_size = xy_block_size * block_depth;
    u32 tile_offset = 0;
@@ -171,7 +171,7 @@ void SwizzledData(u8* swizzled_data, u8* unswizzled_data, const bool unswizzle,
 }
 void CopySwizzledData(u32 width, u32 height, u32 depth, u32 bytes_per_pixel,
-                      u32 out_bytes_per_pixel, u8* swizzled_data, u8* unswizzled_data,
+                      u32 out_bytes_per_pixel, u8* const swizzled_data, u8* const unswizzled_data,
                      bool unswizzle, u32 block_height, u32 block_depth) {
    if (bytes_per_pixel % 3 != 0 && (width * bytes_per_pixel) % 16 == 0) {
        SwizzledData<true>(swizzled_data, unswizzled_data, unswizzle, width, height, depth,
@@ -202,6 +202,8 @@ u32 BytesPerPixel(TextureFormat format) {
    case TextureFormat::ASTC_2D_5X4:
    case TextureFormat::ASTC_2D_8X8:
    case TextureFormat::ASTC_2D_8X5:
+    case TextureFormat::ASTC_2D_10X8:
+    case TextureFormat::ASTC_2D_5X5:
    case TextureFormat::A8R8G8B8:
    case TextureFormat::A2B10G10R10:
    case TextureFormat::BF10GF11RF11:
@@ -294,6 +296,8 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
    case TextureFormat::BC6H_SF16:
    case TextureFormat::ASTC_2D_4X4:
    case TextureFormat::ASTC_2D_8X8:
+    case TextureFormat::ASTC_2D_5X5:
+    case TextureFormat::ASTC_2D_10X8:
    case TextureFormat::A8R8G8B8:
    case TextureFormat::A2B10G10R10:
    case TextureFormat::A1B5G5R5:
@@ -321,9 +325,9 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
 std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
                          u32 block_height, u32 block_depth) {
    if (tiled) {
-        const u32 gobs_in_x = 64;
+        constexpr u32 gobs_in_x = 64;
-        const u32 gobs_in_y = 8;
+        constexpr u32 gobs_in_y = 8;
-        const u32 gobs_in_z = 1;
+        constexpr u32 gobs_in_z = 1;
        const u32 aligned_width = Common::AlignUp(width * bytes_per_pixel, gobs_in_x);
        const u32 aligned_height = Common::AlignUp(height, gobs_in_y * block_height);
        const u32 aligned_depth = Common::AlignUp(depth, gobs_in_z * block_depth);
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index d4fd60a73..be69fb831 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -134,6 +134,14 @@ void Config::ReadValues() {
                                                    Service::Account::MAX_USERS - 1);
    Settings::values.language_index = qt_config->value("language_index", 1).toInt();
+    const auto enabled = qt_config->value("rng_seed_enabled", false).toBool();
+    if (enabled) {
+        Settings::values.rng_seed = qt_config->value("rng_seed", 0).toULongLong();
+    } else {
+        Settings::values.rng_seed = std::nullopt;
+    }
    qt_config->endGroup();
    qt_config->beginGroup("Miscellaneous");
@@ -145,6 +153,7 @@ void Config::ReadValues() {
    Settings::values.use_gdbstub = qt_config->value("use_gdbstub", false).toBool();
    Settings::values.gdbstub_port = qt_config->value("gdbstub_port", 24689).toInt();
    Settings::values.program_args = qt_config->value("program_args", "").toString().toStdString();
+    Settings::values.dump_nso = qt_config->value("dump_nso", false).toBool();
    qt_config->endGroup();
    qt_config->beginGroup("WebService");
@@ -162,6 +171,7 @@ void Config::ReadValues() {
    qt_config->beginGroup("UIGameList");
    UISettings::values.show_unknown = qt_config->value("show_unknown", true).toBool();
+    UISettings::values.show_add_ons = qt_config->value("show_add_ons", true).toBool();
    UISettings::values.icon_size = qt_config->value("icon_size", 64).toUInt();
    UISettings::values.row_1_text_id = qt_config->value("row_1_text_id", 3).toUInt();
    UISettings::values.row_2_text_id = qt_config->value("row_2_text_id", 2).toUInt();
@@ -272,6 +282,10 @@ void Config::SaveValues() {
    qt_config->setValue("current_user", Settings::values.current_user);
    qt_config->setValue("language_index", Settings::values.language_index);
+    qt_config->setValue("rng_seed_enabled", Settings::values.rng_seed.has_value());
+    qt_config->setValue("rng_seed", Settings::values.rng_seed.value_or(0));
    qt_config->endGroup();
    qt_config->beginGroup("Miscellaneous");
@@ -283,6 +297,7 @@ void Config::SaveValues() {
    qt_config->setValue("use_gdbstub", Settings::values.use_gdbstub);
    qt_config->setValue("gdbstub_port", Settings::values.gdbstub_port);
    qt_config->setValue("program_args", QString::fromStdString(Settings::values.program_args));
+    qt_config->setValue("dump_nso", Settings::values.dump_nso);
    qt_config->endGroup();
    qt_config->beginGroup("WebService");
@@ -298,6 +313,7 @@ void Config::SaveValues() {
    qt_config->beginGroup("UIGameList");
    qt_config->setValue("show_unknown", UISettings::values.show_unknown);
+    qt_config->setValue("show_add_ons", UISettings::values.show_add_ons);
    qt_config->setValue("icon_size", UISettings::values.icon_size);
    qt_config->setValue("row_1_text_id", UISettings::values.row_1_text_id);
    qt_config->setValue("row_2_text_id", UISettings::values.row_2_text_id);
diff --git a/src/yuzu/configuration/configure_debug.cpp b/src/yuzu/configuration/configure_debug.cpp
index 9e765fc93..fd5876b41 100644
--- a/src/yuzu/configuration/configure_debug.cpp
+++ b/src/yuzu/configuration/configure_debug.cpp
@@ -34,6 +34,7 @@ void ConfigureDebug::setConfiguration() {
    ui->toggle_console->setChecked(UISettings::values.show_console);
    ui->log_filter_edit->setText(QString::fromStdString(Settings::values.log_filter));
    ui->homebrew_args_edit->setText(QString::fromStdString(Settings::values.program_args));
+    ui->dump_decompressed_nso->setChecked(Settings::values.dump_nso);
 }
 void ConfigureDebug::applyConfiguration() {
@@ -42,6 +43,7 @@ void ConfigureDebug::applyConfiguration() {
    UISettings::values.show_console = ui->toggle_console->isChecked();
    Settings::values.log_filter = ui->log_filter_edit->text().toStdString();
    Settings::values.program_args = ui->homebrew_args_edit->text().toStdString();
+    Settings::values.dump_nso = ui->dump_decompressed_nso->isChecked();
    Debugger::ToggleConsole();
    Log::Filter filter;
    filter.ParseFilterString(Settings::values.log_filter);
diff --git a/src/yuzu/configuration/configure_debug.ui b/src/yuzu/configuration/configure_debug.ui
index ff4987604..9c5b702f8 100644
--- a/src/yuzu/configuration/configure_debug.ui
+++ b/src/yuzu/configuration/configure_debug.ui
@@ -7,7 +7,7 @@
    <x>0</x>
    <y>0</y>
    <width>400</width>
-    <height>300</height>
+    <height>357</height>
   </rect>
  </property>
  <property name="windowTitle">
@@ -130,6 +130,25 @@
    </widget>
   </item>
   <item>
+    <widget class="QGroupBox" name="groupBox_4">
+     <property name="title">
+      <string>Dump</string>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout_4">
+      <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>
+     </layout>
+    </widget>
+   </item>
+   <item>
    <spacer name="verticalSpacer">
     <property name="orientation">
      <enum>Qt::Vertical</enum>
diff --git a/src/yuzu/configuration/configure_gamelist.cpp b/src/yuzu/configuration/configure_gamelist.cpp
index 8743ce982..639d5df0f 100644
--- a/src/yuzu/configuration/configure_gamelist.cpp
+++ b/src/yuzu/configuration/configure_gamelist.cpp
@@ -42,6 +42,7 @@ ConfigureGameList::~ConfigureGameList() = default;
 void ConfigureGameList::applyConfiguration() {
    UISettings::values.show_unknown = ui->show_unknown->isChecked();
+    UISettings::values.show_add_ons = ui->show_add_ons->isChecked();
    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();
@@ -50,6 +51,7 @@ void ConfigureGameList::applyConfiguration() {
 void ConfigureGameList::setConfiguration() {
    ui->show_unknown->setChecked(UISettings::values.show_unknown);
+    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->row_1_text_combobox->setCurrentIndex(
diff --git a/src/yuzu/configuration/configure_gamelist.ui b/src/yuzu/configuration/configure_gamelist.ui
index 7471fdb60..7a69377e7 100644
--- a/src/yuzu/configuration/configure_gamelist.ui
+++ b/src/yuzu/configuration/configure_gamelist.ui
@@ -1,126 +1,133 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
 <class>ConfigureGameList</class>
-  <widget class="QWidget" name="ConfigureGeneral">
+ <widget class="QWidget" name="ConfigureGameList">
-    <property name="geometry">
+  <property name="geometry">
-      <rect>
+   <rect>
-        <x>0</x>
+    <x>0</x>
-        <y>0</y>
+    <y>0</y>
-        <width>300</width>
+    <width>300</width>
-        <height>377</height>
+    <height>377</height>
-      </rect>
+   </rect>
-    </property>
+  </property>
-    <property name="windowTitle">
+  <property name="windowTitle">
-      <string>Form</string>
+   <string>Form</string>
-    </property>
+  </property>
-    <layout class="QHBoxLayout" name="HorizontalLayout">
+  <layout class="QHBoxLayout" name="HorizontalLayout">
-      <item>
+   <item>
-        <layout class="QVBoxLayout" name="VerticalLayout">
+    <layout class="QVBoxLayout" name="VerticalLayout">
+     <item>
+      <widget class="QGroupBox" name="GeneralGroupBox">
+       <property name="title">
+        <string>General</string>
+       </property>
+       <layout class="QHBoxLayout" name="GeneralHorizontalLayout">
+        <item>
+         <layout class="QVBoxLayout" name="GeneralVerticalLayout">
          <item>
-            <widget class="QGroupBox" name="GeneralGroupBox">
+           <widget class="QCheckBox" name="show_unknown">
-              <property name="title">
+            <property name="text">
-                <string>General</string>
+             <string>Show files with type 'Unknown'</string>
-              </property>
+            </property>
-              <layout class="QHBoxLayout" name="GeneralHorizontalLayout">
+           </widget>
-                <item>
-                  <layout class="QVBoxLayout" name="GeneralVerticalLayout">
-                    <item>
-                      <widget class="QCheckBox" name="show_unknown">
-                        <property name="text">
-                          <string>Show files with type 'Unknown'</string>
-                        </property>
-                      </widget>
-                    </item>
-                  </layout>
-                </item>
-              </layout>
-            </widget>
          </item>
          <item>
-            <widget class="QGroupBox" name="IconSizeGroupBox">
+           <widget class="QCheckBox" name="show_add_ons">
-              <property name="title">
+            <property name="text">
-                <string>Icon Size</string>
+             <string>Show Add-Ons Column</string>
-              </property>
+            </property>
-              <layout class="QHBoxLayout" name="icon_size_qhbox_layout">
+           </widget>
-                <item>
-                  <layout class="QVBoxLayout" name="icon_size_qvbox_layout">
-                    <item>
-                      <layout class="QHBoxLayout" name="icon_size_qhbox_layout_2">
-                        <item>
-                          <widget class="QLabel" name="icon_size_label">
-                            <property name="text">
-                              <string>Icon Size:</string>
-                            </property>
-                          </widget>
-                        </item>
-                        <item>
-                          <widget class="QComboBox" name="icon_size_combobox"/>
-                        </item>
-                      </layout>
-                    </item>
-                  </layout>
-                </item>
-              </layout>
-            </widget>
          </item>
+         </layout>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="IconSizeGroupBox">
+       <property name="title">
+        <string>Icon Size</string>
+       </property>
+       <layout class="QHBoxLayout" name="icon_size_qhbox_layout">
+        <item>
+         <layout class="QVBoxLayout" name="icon_size_qvbox_layout">
          <item>
-            <widget class="QGroupBox" name="RowGroupBox">
+           <layout class="QHBoxLayout" name="icon_size_qhbox_layout_2">
-              <property name="title">
+            <item>
-                <string>Row Text</string>
+             <widget class="QLabel" name="icon_size_label">
+              <property name="text">
+               <string>Icon Size:</string>
              </property>
-              <layout class="QHBoxLayout" name="RowHorizontalLayout">
+             </widget>
-                <item>
+            </item>
-                  <layout class="QVBoxLayout" name="RowVerticalLayout">
+            <item>
-                    <item>
+             <widget class="QComboBox" name="icon_size_combobox"/>
-                      <layout class="QHBoxLayout" name="row_1_qhbox_layout">
+            </item>
-                        <item>
+           </layout>
-                          <widget class="QLabel" name="row_1_label">
-                            <property name="text">
-                              <string>Row 1 Text:</string>
-                            </property>
-                          </widget>
-                        </item>
-                        <item>
-                          <widget class="QComboBox" name="row_1_text_combobox"/>
-                        </item>
-                      </layout>
-                    </item>
-                    <item>
-                      <layout class="QHBoxLayout" name="row_2_qhbox_layout">
-                        <item>
-                          <widget class="QLabel" name="row_2_label">
-                            <property name="text">
-                              <string>Row 2 Text:</string>
-                            </property>
-                          </widget>
-                        </item>
-                        <item>
-                          <widget class="QComboBox" name="row_2_text_combobox"/>
-                        </item>
-                      </layout>
-                    </item>
-                  </layout>
-                </item>
-              </layout>
-            </widget>
          </item>
+         </layout>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="RowGroupBox">
+       <property name="title">
+        <string>Row Text</string>
+       </property>
+       <layout class="QHBoxLayout" name="RowHorizontalLayout">
+        <item>
+         <layout class="QVBoxLayout" name="RowVerticalLayout">
          <item>
-            <spacer name="verticalSpacer">
+           <layout class="QHBoxLayout" name="row_1_qhbox_layout">
-              <property name="orientation">
+            <item>
-                <enum>Qt::Vertical</enum>
+             <widget class="QLabel" name="row_1_label">
+              <property name="text">
+               <string>Row 1 Text:</string>
              </property>
-              <property name="sizeHint" stdset="0">
+             </widget>
-                <size>
+            </item>
-                  <width>20</width>
+            <item>
-                  <height>40</height>
+             <widget class="QComboBox" name="row_1_text_combobox"/>
-                </size>
+            </item>
+           </layout>
+          </item>
+          <item>
+           <layout class="QHBoxLayout" name="row_2_qhbox_layout">
+            <item>
+             <widget class="QLabel" name="row_2_label">
+              <property name="text">
+               <string>Row 2 Text:</string>
              </property>
-            </spacer>
+             </widget>
+            </item>
+            <item>
+             <widget class="QComboBox" name="row_2_text_combobox"/>
+            </item>
+           </layout>
          </item>
-        </layout>
+         </layout>
-      </item>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <spacer name="verticalSpacer">
+       <property name="orientation">
+        <enum>Qt::Vertical</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>20</width>
+         <height>40</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
    </layout>
-  </widget>
+   </item>
+  </layout>
+ </widget>
 <resources/>
 <connections/>
 </ui>
diff --git a/src/yuzu/configuration/configure_general.cpp b/src/yuzu/configuration/configure_general.cpp
index b322258a0..314f51203 100644
--- a/src/yuzu/configuration/configure_general.cpp
+++ b/src/yuzu/configuration/configure_general.cpp
@@ -47,6 +47,9 @@ void ConfigureGeneral::OnDockedModeChanged(bool last_state, bool new_state) {
    }
    Core::System& system{Core::System::GetInstance()};
+    if (!system.IsPoweredOn()) {
+        return;
+    }
    Service::SM::ServiceManager& sm = system.ServiceManager();
    // Message queue is shared between these services, we just need to signal an operation
diff --git a/src/yuzu/configuration/configure_system.cpp b/src/yuzu/configuration/configure_system.cpp
index 4803d43bb..ab5d46492 100644
--- a/src/yuzu/configuration/configure_system.cpp
+++ b/src/yuzu/configuration/configure_system.cpp
@@ -137,6 +137,12 @@ ConfigureSystem::ConfigureSystem(QWidget* parent)
    connect(ui->pm_remove, &QPushButton::pressed, this, &ConfigureSystem::DeleteUser);
    connect(ui->pm_set_image, &QPushButton::pressed, this, &ConfigureSystem::SetUserImage);
+    connect(ui->rng_seed_checkbox, &QCheckBox::stateChanged, this, [this](bool checked) {
+        ui->rng_seed_edit->setEnabled(checked);
+        if (!checked)
+            ui->rng_seed_edit->setText(QStringLiteral("00000000"));
+    });
    scene = new QGraphicsScene;
    ui->current_user_icon->setScene(scene);
@@ -155,6 +161,13 @@ void ConfigureSystem::setConfiguration() {
    PopulateUserList();
    UpdateCurrentUser();
+    ui->rng_seed_checkbox->setChecked(Settings::values.rng_seed.has_value());
+    ui->rng_seed_edit->setEnabled(Settings::values.rng_seed.has_value());
+    const auto rng_seed =
+        QString("%1").arg(Settings::values.rng_seed.value_or(0), 8, 16, QLatin1Char{'0'}).toUpper();
+    ui->rng_seed_edit->setText(rng_seed);
 }
 void ConfigureSystem::PopulateUserList() {
@@ -195,6 +208,12 @@ void ConfigureSystem::applyConfiguration() {
        return;
    Settings::values.language_index = ui->combo_language->currentIndex();
+    if (ui->rng_seed_checkbox->isChecked())
+        Settings::values.rng_seed = ui->rng_seed_edit->text().toULongLong(nullptr, 16);
+    else
+        Settings::values.rng_seed = std::nullopt;
    Settings::Apply();
 }
diff --git a/src/yuzu/configuration/configure_system.ui b/src/yuzu/configuration/configure_system.ui
index 020b32a37..a91580893 100644
--- a/src/yuzu/configuration/configure_system.ui
+++ b/src/yuzu/configuration/configure_system.ui
@@ -6,7 +6,7 @@
   <rect>
    <x>0</x>
    <y>0</y>
-    <width>360</width>
+    <width>366</width>
    <height>483</height>
   </rect>
  </property>
@@ -22,98 +22,6 @@
        <string>System Settings</string>
       </property>
       <layout class="QGridLayout" name="gridLayout">
-        <item row="1" column="0">
-         <widget class="QLabel" name="label_language">
-          <property name="text">
-           <string>Language</string>
-          </property>
-         </widget>
-        </item>
-        <item row="0" column="0">
-         <widget class="QLabel" name="label_birthday">
-          <property name="text">
-           <string>Birthday</string>
-          </property>
-         </widget>
-        </item>
-        <item row="3" column="0">
-         <widget class="QLabel" name="label_console_id">
-          <property name="text">
-           <string>Console ID:</string>
-          </property>
-         </widget>
-        </item>
-        <item row="0" column="1">
-         <layout class="QHBoxLayout" name="horizontalLayout_birthday2">
-          <item>
-           <widget class="QComboBox" name="combo_birthmonth">
-            <item>
-             <property name="text">
-              <string>January</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>February</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>March</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>April</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>May</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>June</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>July</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>August</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>September</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>October</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>November</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>December</string>
-             </property>
-            </item>
-           </widget>
-          </item>
-          <item>
-           <widget class="QComboBox" name="combo_birthday"/>
-          </item>
-         </layout>
-        </item>
        <item row="1" column="1">
         <widget class="QComboBox" name="combo_language">
          <property name="toolTip">
@@ -206,6 +114,13 @@
          </item>
         </widget>
        </item>
+        <item row="3" column="0">
+         <widget class="QLabel" name="label_console_id">
+          <property name="text">
+           <string>Console ID:</string>
+          </property>
+         </widget>
+        </item>
        <item row="2" column="0">
         <widget class="QLabel" name="label_sound">
          <property name="text">
@@ -213,6 +128,100 @@
          </property>
         </widget>
        </item>
+        <item row="0" column="0">
+         <widget class="QLabel" name="label_birthday">
+          <property name="text">
+           <string>Birthday</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="1">
+         <layout class="QHBoxLayout" name="horizontalLayout_birthday2">
+          <item>
+           <widget class="QComboBox" name="combo_birthmonth">
+            <item>
+             <property name="text">
+              <string>January</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>February</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>March</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>April</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>May</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>June</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>July</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>August</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>September</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>October</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>November</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>December</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+          <item>
+           <widget class="QComboBox" name="combo_birthday"/>
+          </item>
+         </layout>
+        </item>
+        <item row="3" column="1">
+         <widget class="QPushButton" name="button_regenerate_console_id">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="layoutDirection">
+           <enum>Qt::RightToLeft</enum>
+          </property>
+          <property name="text">
+           <string>Regenerate</string>
+          </property>
+         </widget>
+        </item>
        <item row="2" column="1">
         <widget class="QComboBox" name="combo_sound">
          <item>
@@ -232,19 +241,38 @@
          </item>
         </widget>
        </item>
-        <item row="3" column="1">
+        <item row="1" column="0">
-         <widget class="QPushButton" name="button_regenerate_console_id">
+         <widget class="QLabel" name="label_language">
+          <property name="text">
+           <string>Language</string>
+          </property>
+         </widget>
+        </item>
+        <item row="4" column="0">
+         <widget class="QCheckBox" name="rng_seed_checkbox">
+          <property name="text">
+           <string>RNG Seed</string>
+          </property>
+         </widget>
+        </item>
+        <item row="4" column="1">
+         <widget class="QLineEdit" name="rng_seed_edit">
          <property name="sizePolicy">
-           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
-          <property name="layoutDirection">
+          <property name="font">
-           <enum>Qt::RightToLeft</enum>
+           <font>
+            <family>Lucida Console</family>
+           </font>
          </property>
-          <property name="text">
+          <property name="inputMask">
-           <string>Regenerate</string>
+           <string notr="true">HHHHHHHH</string>
+          </property>
+          <property name="maxLength">
+           <number>8</number>
          </property>
         </widget>
        </item>
diff --git a/src/yuzu/game_list.cpp b/src/yuzu/game_list.cpp
index a5a4aa432..11a8c390b 100644
--- a/src/yuzu/game_list.cpp
+++ b/src/yuzu/game_list.cpp
@@ -215,12 +215,18 @@ GameList::GameList(FileSys::VirtualFilesystem vfs, GMainWindow* parent)
    tree_view->setUniformRowHeights(true);
    tree_view->setContextMenuPolicy(Qt::CustomContextMenu);
-    item_model->insertColumns(0, COLUMN_COUNT);
+    item_model->insertColumns(0, UISettings::values.show_add_ons ? COLUMN_COUNT : COLUMN_COUNT - 1);
    item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, tr("Name"));
    item_model->setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, tr("Compatibility"));
-    item_model->setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
-    item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
+    if (UISettings::values.show_add_ons) {
-    item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));
+        item_model->setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
+        item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
+        item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));
+    } else {
+        item_model->setHeaderData(COLUMN_FILE_TYPE - 1, Qt::Horizontal, tr("File type"));
+        item_model->setHeaderData(COLUMN_SIZE - 1, Qt::Horizontal, tr("Size"));
+    }
    connect(tree_view, &QTreeView::activated, this, &GameList::ValidateEntry);
    connect(tree_view, &QTreeView::customContextMenuRequested, this, &GameList::PopupContextMenu);
@@ -394,6 +400,25 @@ void GameList::PopulateAsync(const QString& dir_path, bool deep_scan) {
    }
    tree_view->setEnabled(false);
+    // Update the columns in case UISettings has changed
+    item_model->removeColumns(0, item_model->columnCount());
+    item_model->insertColumns(0, UISettings::values.show_add_ons ? COLUMN_COUNT : COLUMN_COUNT - 1);
+    item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, tr("Name"));
+    item_model->setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, tr("Compatibility"));
+    if (UISettings::values.show_add_ons) {
+        item_model->setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
+        item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
+        item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));
+    } else {
+        item_model->setHeaderData(COLUMN_FILE_TYPE - 1, Qt::Horizontal, tr("File type"));
+        item_model->setHeaderData(COLUMN_SIZE - 1, Qt::Horizontal, tr("Size"));
+        item_model->removeColumns(COLUMN_COUNT - 1, 1);
+    }
+    LoadInterfaceLayout();
    // Delete any rows that might already exist if we're repopulating
    item_model->removeRows(0, item_model->rowCount());
diff --git a/src/yuzu/game_list_worker.cpp b/src/yuzu/game_list_worker.cpp
index 3d865a12d..362902e46 100644
--- a/src/yuzu/game_list_worker.cpp
+++ b/src/yuzu/game_list_worker.cpp
@@ -123,17 +123,22 @@ void GameListWorker::AddInstalledTitlesToGameList() {
        if (it != compatibility_list.end())
            compatibility = it->second.first;
-        emit EntryReady({
+        QList<QStandardItem*> list{
            new GameListItemPath(
                FormatGameName(file->GetFullPath()), icon, QString::fromStdString(name),
                QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType())),
                program_id),
            new GameListItemCompat(compatibility),
-            new GameListItem(FormatPatchNameVersions(patch, *loader)),
            new GameListItem(
                QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType()))),
            new GameListItemSize(file->GetSize()),
-        });
+        };
+        if (UISettings::values.show_add_ons) {
+            list.insert(2, new GameListItem(FormatPatchNameVersions(patch, *loader)));
+        }
+        emit EntryReady(list);
    }
    const auto control_data = cache->ListEntriesFilter(FileSys::TitleType::Application,
@@ -216,18 +221,23 @@ void GameListWorker::AddFstEntriesToGameList(const std::string& dir_path, unsign
            if (it != compatibility_list.end())
                compatibility = it->second.first;
-            emit EntryReady({
+            QList<QStandardItem*> list{
                new GameListItemPath(
                    FormatGameName(physical_name), icon, QString::fromStdString(name),
                    QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType())),
                    program_id),
                new GameListItemCompat(compatibility),
                new GameListItem(
-                    FormatPatchNameVersions(patch, *loader, loader->IsRomFSUpdatable())),
-                new GameListItem(
                    QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType()))),
                new GameListItemSize(FileUtil::GetSize(physical_name)),
-            });
+            };
+            if (UISettings::values.show_add_ons) {
+                list.insert(2, new GameListItem(FormatPatchNameVersions(
+                                   patch, *loader, loader->IsRomFSUpdatable())));
+            }
+            emit EntryReady(std::move(list));
        } else if (is_dir && recursion > 0) {
            watch_list.append(QString::fromStdString(physical_name));
            AddFstEntriesToGameList(physical_name, recursion - 1);
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 221702dc3..999086e7f 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -941,7 +941,8 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
    const auto full = res == "Full";
    const auto entry_size = CalculateRomFSEntrySize(extracted, full);
-    QProgressDialog progress(tr("Extracting RomFS..."), tr("Cancel"), 0, entry_size, this);
+    QProgressDialog progress(tr("Extracting RomFS..."), tr("Cancel"), 0,
+                             static_cast<s32>(entry_size), this);
    progress.setWindowModality(Qt::WindowModal);
    progress.setMinimumDuration(100);
diff --git a/src/yuzu/main.ui b/src/yuzu/main.ui
index 28cf269e7..75e96387f 100644
--- a/src/yuzu/main.ui
+++ b/src/yuzu/main.ui
@@ -70,6 +70,8 @@
    <addaction name="separator"/>
    <addaction name="action_Load_Amiibo"/>
    <addaction name="separator"/>
+    <addaction name="action_Open_yuzu_Folder"/>
+    <addaction name="separator"/>
    <addaction name="action_Exit"/>
   </widget>
   <widget class="QMenu" name="menu_Emulation">
@@ -110,7 +112,6 @@
     <string>&amp;Help</string>
    </property>
    <addaction name="action_Report_Compatibility"/>
-    <addaction name="action_Open_yuzu_Folder" />
    <addaction name="separator"/>
    <addaction name="action_About"/>
   </widget>
diff --git a/src/yuzu/ui_settings.h b/src/yuzu/ui_settings.h
index 2e617d52a..32a0d813c 100644
--- a/src/yuzu/ui_settings.h
+++ b/src/yuzu/ui_settings.h
@@ -59,6 +59,7 @@ struct Values {
    // Game List
    bool show_unknown;
+    bool show_add_ons;
    uint32_t icon_size;
    uint8_t row_1_text_id;
    uint8_t row_2_text_id;
diff --git a/src/yuzu_cmd/config.cpp b/src/yuzu_cmd/config.cpp
index b456266a6..9cc409fd5 100644
--- a/src/yuzu_cmd/config.cpp
+++ b/src/yuzu_cmd/config.cpp
@@ -132,6 +132,13 @@ void Config::ReadValues() {
    Settings::values.current_user = std::clamp<int>(
        sdl2_config->GetInteger("System", "current_user", 0), 0, Service::Account::MAX_USERS - 1);
+    const auto enabled = sdl2_config->GetBoolean("System", "rng_seed_enabled", false);
+    if (enabled) {
+        Settings::values.rng_seed = sdl2_config->GetInteger("System", "rng_seed", 0);
+    } else {
+        Settings::values.rng_seed = std::nullopt;
+    }
    // Miscellaneous
    Settings::values.log_filter = sdl2_config->Get("Miscellaneous", "log_filter", "*:Trace");
    Settings::values.use_dev_keys = sdl2_config->GetBoolean("Miscellaneous", "use_dev_keys", false);
@@ -141,6 +148,7 @@ void Config::ReadValues() {
    Settings::values.gdbstub_port =
        static_cast<u16>(sdl2_config->GetInteger("Debugging", "gdbstub_port", 24689));
    Settings::values.program_args = sdl2_config->Get("Debugging", "program_args", "");
+    Settings::values.dump_nso = sdl2_config->GetBoolean("Debugging", "dump_nso", false);
    // Web Service
    Settings::values.enable_telemetry =
diff --git a/src/yuzu_cmd/default_ini.h b/src/yuzu_cmd/default_ini.h
index e0b223cd6..ecf625e7b 100644
--- a/src/yuzu_cmd/default_ini.h
+++ b/src/yuzu_cmd/default_ini.h
@@ -178,6 +178,11 @@ use_docked_mode =
 # 1 (default): Yes, 0 : No
 enable_nfc =
+# Sets the seed for the RNG generator built into the switch
+# rng_seed will be ignored and randomly generated if rng_seed_enabled is false
+rng_seed_enabled =
+rng_seed =
 # Sets the account username, max length is 32 characters
 # yuzu (default)
 username = yuzu
@@ -201,6 +206,8 @@ log_filter = *:Trace
 # Port for listening to GDB connections.
 use_gdbstub=false
 gdbstub_port=24689
+# Determines whether or not yuzu will dump all NSOs it attempts to load while loading them
+dump_nso=false
 [WebService]
 # Whether or not to enable telemetry