71 files changed, 2019 insertions, 948 deletions
diff --git a/README.md b/README.md
index 1d5b4626f..d258584bf 100644
--- a/README.md
+++ b/README.md
@@ -40,7 +40,7 @@ It is written in C++ with portability in mind, and we actively maintain builds f
 The emulator is capable of running most commercial games at full speed, provided you meet the [necessary hardware requirements](https://yuzu-emu.org/help/quickstart/#hardware-requirements).
-For a full list of games yuzu support, please visit our [Compatibility page](https://yuzu-emu.org/game/)
+For a full list of games yuzu supports, please visit our [Compatibility page](https://yuzu-emu.org/game/).
 Check out our [website](https://yuzu-emu.org/) for the latest news on exciting features, monthly progress reports, and more!
diff --git a/src/common/settings_common.cpp b/src/common/settings_common.cpp
index dedf5ef90..137b65d5f 100644
--- a/src/common/settings_common.cpp
+++ b/src/common/settings_common.cpp
@@ -1,7 +1,9 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
+#include <functional>
 #include <string>
+#include <vector>
 #include "common/settings_common.h"
 namespace Settings {
diff --git a/src/common/settings_enums.h b/src/common/settings_enums.h
index a1a29ebf6..e7cb59ea5 100644
--- a/src/common/settings_enums.h
+++ b/src/common/settings_enums.h
@@ -12,8 +12,8 @@ namespace Settings {
 template <typename T>
 struct EnumMetadata {
-    static constexpr std::vector<std::pair<std::string, T>> Canonicalizations();
+    static std::vector<std::pair<std::string, T>> Canonicalizations();
-    static constexpr u32 Index();
+    static u32 Index();
 };
 #define PAIR_45(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_46(N, __VA_ARGS__))
@@ -66,11 +66,11 @@ struct EnumMetadata {
 #define ENUM(NAME, ...)                                                                            \
    enum class NAME : u32 { __VA_ARGS__ };                                                         \
    template <>                                                                                    \
-    constexpr std::vector<std::pair<std::string, NAME>> EnumMetadata<NAME>::Canonicalizations() {  \
+    inline std::vector<std::pair<std::string, NAME>> EnumMetadata<NAME>::Canonicalizations() {     \
        return {PAIR(NAME, __VA_ARGS__)};                                                          \
    }                                                                                              \
    template <>                                                                                    \
-    constexpr u32 EnumMetadata<NAME>::Index() {                                                    \
+    inline u32 EnumMetadata<NAME>::Index() {                                                       \
        return __COUNTER__;                                                                        \
    }
@@ -85,7 +85,7 @@ enum class AudioEngine : u32 {
 };
 template <>
-constexpr std::vector<std::pair<std::string, AudioEngine>>
+inline std::vector<std::pair<std::string, AudioEngine>>
 EnumMetadata<AudioEngine>::Canonicalizations() {
    return {
        {"auto", AudioEngine::Auto},
@@ -96,7 +96,7 @@ EnumMetadata<AudioEngine>::Canonicalizations() {
 }
 template <>
-constexpr u32 EnumMetadata<AudioEngine>::Index() {
+inline u32 EnumMetadata<AudioEngine>::Index() {
    // This is just a sufficiently large number that is more than the number of other enums declared
    // here
    return 100;
@@ -147,7 +147,7 @@ ENUM(AntiAliasing, None, Fxaa, Smaa, MaxEnum);
 ENUM(AspectRatio, R16_9, R4_3, R21_9, R16_10, Stretch);
 template <typename Type>
-constexpr std::string CanonicalizeEnum(Type id) {
+inline std::string CanonicalizeEnum(Type id) {
    const auto group = EnumMetadata<Type>::Canonicalizations();
    for (auto& [name, value] : group) {
        if (value == id) {
@@ -158,7 +158,7 @@ constexpr std::string CanonicalizeEnum(Type id) {
 }
 template <typename Type>
-constexpr Type ToEnum(const std::string& canonicalization) {
+inline Type ToEnum(const std::string& canonicalization) {
    const auto group = EnumMetadata<Type>::Canonicalizations();
    for (auto& [name, value] : group) {
        if (name == canonicalization) {
diff --git a/src/common/settings_setting.h b/src/common/settings_setting.h
index a8beb06e9..e10843c73 100644
--- a/src/common/settings_setting.h
+++ b/src/common/settings_setting.h
@@ -190,7 +190,7 @@ public:
        }
    }
-    [[nodiscard]] std::string constexpr Canonicalize() const override final {
+    [[nodiscard]] std::string Canonicalize() const override final {
        if constexpr (std::is_enum_v<Type>) {
            return CanonicalizeEnum(this->GetValue());
        } else {
@@ -256,11 +256,11 @@ public:
     * @param runtime_modifiable_ Suggests whether this is modifiable while a guest is loaded
     * @param other_setting_ A second Setting to associate to this one in metadata
     */
+    template <typename T = BasicSetting>
    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name,
                               Category category_, u32 specialization_ = Specialization::Default,
                               bool save_ = true, bool runtime_modifiable_ = false,
-                               BasicSetting* other_setting_ = nullptr)
+                               typename std::enable_if<!ranged, T*>::type other_setting_ = nullptr)
-        requires(!ranged)
        : Setting<Type, false>{
              linkage, default_val,         name,          category_, specialization_,
              save_,   runtime_modifiable_, other_setting_} {
@@ -282,12 +282,12 @@ public:
     * @param runtime_modifiable_ Suggests whether this is modifiable while a guest is loaded
     * @param other_setting_ A second Setting to associate to this one in metadata
     */
+    template <typename T = BasicSetting>
    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const Type& min_val,
                               const Type& max_val, const std::string& name, Category category_,
                               u32 specialization_ = Specialization::Default, bool save_ = true,
                               bool runtime_modifiable_ = false,
-                               BasicSetting* other_setting_ = nullptr)
+                               typename std::enable_if<ranged, T*>::type other_setting_ = nullptr)
-        requires(ranged)
        : Setting<Type, true>{linkage,         default_val, min_val,
                              max_val,         name,        category_,
                              specialization_, save_,       runtime_modifiable_,
diff --git a/src/core/file_sys/romfs_factory.cpp b/src/core/file_sys/romfs_factory.cpp
index ae7a3511b..aa4726cfa 100644
--- a/src/core/file_sys/romfs_factory.cpp
+++ b/src/core/file_sys/romfs_factory.cpp
@@ -35,7 +35,7 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw_file) {
    update_raw = std::move(update_raw_file);
 }
-ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
+VirtualFile RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
    if (!updatable) {
        return file;
    }
@@ -45,12 +45,11 @@ ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_titl
    return patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw);
 }
-ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const {
+VirtualFile RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const {
    auto nca = content_provider.GetEntry(title_id, type);
    if (nca == nullptr) {
-        // TODO: Find the right error code to use here
+        return nullptr;
-        return ResultUnknown;
    }
    const PatchManager patch_manager{title_id, filesystem_controller, content_provider};
@@ -58,28 +57,20 @@ ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecor
    return patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type);
 }
-ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFSWithProgramIndex(
+VirtualFile RomFSFactory::OpenPatchedRomFSWithProgramIndex(u64 title_id, u8 program_index,
-    u64 title_id, u8 program_index, ContentRecordType type) const {
+                                                           ContentRecordType type) const {
    const auto res_title_id = GetBaseTitleIDWithProgramIndex(title_id, program_index);
    return OpenPatchedRomFS(res_title_id, type);
 }
-ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
+VirtualFile RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) const {
-                                          ContentRecordType type) const {
    const std::shared_ptr<NCA> res = GetEntry(title_id, storage, type);
    if (res == nullptr) {
-        // TODO(DarkLordZach): Find the right error code to use here
+        return nullptr;
-        return ResultUnknown;
-    }
-    const auto romfs = res->GetRomFS();
-    if (romfs == nullptr) {
-        // TODO(DarkLordZach): Find the right error code to use here
-        return ResultUnknown;
    }
-    return romfs;
+    return res->GetRomFS();
 }
 std::shared_ptr<NCA> RomFSFactory::GetEntry(u64 title_id, StorageId storage,
diff --git a/src/core/file_sys/romfs_factory.h b/src/core/file_sys/romfs_factory.h
index 14936031f..7ec40d19d 100644
--- a/src/core/file_sys/romfs_factory.h
+++ b/src/core/file_sys/romfs_factory.h
@@ -41,13 +41,11 @@ public:
    ~RomFSFactory();
    void SetPackedUpdate(VirtualFile update_raw_file);
-    [[nodiscard]] ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
+    [[nodiscard]] VirtualFile OpenCurrentProcess(u64 current_process_title_id) const;
-    [[nodiscard]] ResultVal<VirtualFile> OpenPatchedRomFS(u64 title_id,
+    [[nodiscard]] VirtualFile OpenPatchedRomFS(u64 title_id, ContentRecordType type) const;
-                                                          ContentRecordType type) const;
+    [[nodiscard]] VirtualFile OpenPatchedRomFSWithProgramIndex(u64 title_id, u8 program_index,
-    [[nodiscard]] ResultVal<VirtualFile> OpenPatchedRomFSWithProgramIndex(
+                                                               ContentRecordType type) const;
-        u64 title_id, u8 program_index, ContentRecordType type) const;
+    [[nodiscard]] VirtualFile Open(u64 title_id, StorageId storage, ContentRecordType type) const;
-    [[nodiscard]] ResultVal<VirtualFile> Open(u64 title_id, StorageId storage,
-                                              ContentRecordType type) const;
 private:
    [[nodiscard]] std::shared_ptr<NCA> GetEntry(u64 title_id, StorageId storage,
diff --git a/src/core/file_sys/savedata_factory.cpp b/src/core/file_sys/savedata_factory.cpp
index 70b36f170..a4d060007 100644
--- a/src/core/file_sys/savedata_factory.cpp
+++ b/src/core/file_sys/savedata_factory.cpp
@@ -108,26 +108,16 @@ SaveDataFactory::SaveDataFactory(Core::System& system_, VirtualDir save_director
 SaveDataFactory::~SaveDataFactory() = default;
-ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
+VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
-                                              const SaveDataAttribute& meta) const {
    PrintSaveDataAttributeWarnings(meta);
    const auto save_directory =
        GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
-    auto out = dir->CreateDirectoryRelative(save_directory);
+    return dir->CreateDirectoryRelative(save_directory);
-    // Return an error if the save data doesn't actually exist.
-    if (out == nullptr) {
-        // TODO(DarkLordZach): Find out correct error code.
-        return ResultUnknown;
-    }
-    return out;
 }
-ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
+VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
-                                            const SaveDataAttribute& meta) const {
    const auto save_directory =
        GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
@@ -138,12 +128,6 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
        return Create(space, meta);
    }
-    // Return an error if the save data doesn't actually exist.
-    if (out == nullptr) {
-        // TODO(Subv): Find out correct error code.
-        return ResultUnknown;
-    }
    return out;
 }
diff --git a/src/core/file_sys/savedata_factory.h b/src/core/file_sys/savedata_factory.h
index d3633ef03..45c7c81fb 100644
--- a/src/core/file_sys/savedata_factory.h
+++ b/src/core/file_sys/savedata_factory.h
@@ -89,8 +89,8 @@ public:
    explicit SaveDataFactory(Core::System& system_, VirtualDir save_directory_);
    ~SaveDataFactory();
-    ResultVal<VirtualDir> Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const;
+    VirtualDir Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const;
-    ResultVal<VirtualDir> Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const;
+    VirtualDir Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const;
    VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const;
diff --git a/src/core/file_sys/sdmc_factory.cpp b/src/core/file_sys/sdmc_factory.cpp
index 1df022c9e..d5158cd64 100644
--- a/src/core/file_sys/sdmc_factory.cpp
+++ b/src/core/file_sys/sdmc_factory.cpp
@@ -23,7 +23,7 @@ SDMCFactory::SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_)
 SDMCFactory::~SDMCFactory() = default;
-ResultVal<VirtualDir> SDMCFactory::Open() const {
+VirtualDir SDMCFactory::Open() const {
    return sd_dir;
 }
diff --git a/src/core/file_sys/sdmc_factory.h b/src/core/file_sys/sdmc_factory.h
index 3aebfb25e..a445fdb16 100644
--- a/src/core/file_sys/sdmc_factory.h
+++ b/src/core/file_sys/sdmc_factory.h
@@ -18,7 +18,7 @@ public:
    explicit SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_);
    ~SDMCFactory();
-    ResultVal<VirtualDir> Open() const;
+    VirtualDir Open() const;
    VirtualDir GetSDMCModificationLoadRoot(u64 title_id) const;
    VirtualDir GetSDMCContentDirectory() const;
diff --git a/src/core/hid/hid_types.h b/src/core/hid/hid_types.h
index 6b35f448c..00beb40dd 100644
--- a/src/core/hid/hid_types.h
+++ b/src/core/hid/hid_types.h
@@ -289,6 +289,19 @@ enum class GyroscopeZeroDriftMode : u32 {
    Tight = 2,
 };
+// This is nn::settings::system::TouchScreenMode
+enum class TouchScreenMode : u32 {
+    Stylus = 0,
+    Standard = 1,
+};
+// This is nn::hid::TouchScreenModeForNx
+enum class TouchScreenModeForNx : u8 {
+    UseSystemSetting,
+    Finger,
+    Heat2,
+};
 // This is nn::hid::NpadStyleTag
 struct NpadStyleTag {
    union {
@@ -334,6 +347,14 @@ struct TouchState {
 };
 static_assert(sizeof(TouchState) == 0x28, "Touchstate is an invalid size");
+// This is nn::hid::TouchScreenConfigurationForNx
+struct TouchScreenConfigurationForNx {
+    TouchScreenModeForNx mode{TouchScreenModeForNx::UseSystemSetting};
+    INSERT_PADDING_BYTES(0xF);
+};
+static_assert(sizeof(TouchScreenConfigurationForNx) == 0x10,
+              "TouchScreenConfigurationForNx is an invalid size");
 struct NpadColor {
    u8 r{};
    u8 g{};
@@ -662,6 +683,11 @@ struct MouseState {
 };
 static_assert(sizeof(MouseState) == 0x28, "MouseState is an invalid size");
+struct UniquePadId {
+    u64 id;
+};
+static_assert(sizeof(UniquePadId) == 0x8, "UniquePadId is an invalid size");
 /// Converts a NpadIdType to an array index.
 constexpr size_t NpadIdTypeToIndex(NpadIdType npad_id_type) {
    switch (npad_id_type) {
diff --git a/src/core/hle/kernel/k_page_table.cpp b/src/core/hle/kernel/k_page_table.cpp
index 02b5cada4..9bfc85b34 100644
--- a/src/core/hle/kernel/k_page_table.cpp
+++ b/src/core/hle/kernel/k_page_table.cpp
@@ -768,7 +768,7 @@ Result KPageTable::UnmapProcessMemory(KProcessAddress dst_addr, size_t size,
                                                 m_memory_block_slab_manager, num_allocator_blocks);
    R_TRY(allocator_result);
-    CASCADE_CODE(Operate(dst_addr, num_pages, KMemoryPermission::None, OperationType::Unmap));
+    R_TRY(Operate(dst_addr, num_pages, KMemoryPermission::None, OperationType::Unmap));
    // Apply the memory block update.
    m_memory_block_manager.Update(std::addressof(allocator), dst_addr, num_pages,
diff --git a/src/core/hle/result.h b/src/core/hle/result.h
index 240f06689..92a1439eb 100644
--- a/src/core/hle/result.h
+++ b/src/core/hle/result.h
@@ -283,159 +283,6 @@ private:
    u32 description_end;
 };
-/**
- * This is an optional value type. It holds a `Result` and, if that code is ResultSuccess, it
- * also holds a result of type `T`. If the code is an error code (not ResultSuccess), then trying
- * to access the inner value with operator* is undefined behavior and will assert with Unwrap().
- * Users of this class must be cognizant to check the status of the ResultVal with operator bool(),
- * Code(), Succeeded() or Failed() prior to accessing the inner value.
- *
- * An example of how it could be used:
- * \code
- * ResultVal<int> Frobnicate(float strength) {
- *     if (strength < 0.f || strength > 1.0f) {
- *         // Can't frobnicate too weakly or too strongly
- *         return Result{ErrorModule::Common, 1};
- *     } else {
- *         // Frobnicated! Give caller a cookie
- *         return 42;
- *     }
- * }
- * \endcode
- *
- * \code
- * auto frob_result = Frobnicate(0.75f);
- * if (frob_result) {
- *     // Frobbed ok
- *     printf("My cookie is %d\n", *frob_result);
- * } else {
- *     printf("Guess I overdid it. :( Error code: %ux\n", frob_result.Code().raw);
- * }
- * \endcode
- */
-template <typename T>
-class ResultVal {
-public:
-    constexpr ResultVal() : expected{} {}
-    constexpr ResultVal(Result code) : expected{Common::Unexpected(code)} {}
-    constexpr ResultVal(ResultRange range) : expected{Common::Unexpected(range)} {}
-    template <typename U>
-    constexpr ResultVal(U&& val) : expected{std::forward<U>(val)} {}
-    template <typename... Args>
-    constexpr ResultVal(Args&&... args) : expected{std::in_place, std::forward<Args>(args)...} {}
-    ~ResultVal() = default;
-    constexpr ResultVal(const ResultVal&) = default;
-    constexpr ResultVal(ResultVal&&) = default;
-    ResultVal& operator=(const ResultVal&) = default;
-    ResultVal& operator=(ResultVal&&) = default;
-    [[nodiscard]] constexpr explicit operator bool() const noexcept {
-        return expected.has_value();
-    }
-    [[nodiscard]] constexpr Result Code() const {
-        return expected.has_value() ? ResultSuccess : expected.error();
-    }
-    [[nodiscard]] constexpr bool Succeeded() const {
-        return expected.has_value();
-    }
-    [[nodiscard]] constexpr bool Failed() const {
-        return !expected.has_value();
-    }
-    [[nodiscard]] constexpr T* operator->() {
-        return std::addressof(expected.value());
-    }
-    [[nodiscard]] constexpr const T* operator->() const {
-        return std::addressof(expected.value());
-    }
-    [[nodiscard]] constexpr T& operator*() & {
-        return *expected;
-    }
-    [[nodiscard]] constexpr const T& operator*() const& {
-        return *expected;
-    }
-    [[nodiscard]] constexpr T&& operator*() && {
-        return *expected;
-    }
-    [[nodiscard]] constexpr const T&& operator*() const&& {
-        return *expected;
-    }
-    [[nodiscard]] constexpr T& Unwrap() & {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return expected.value();
-    }
-    [[nodiscard]] constexpr const T& Unwrap() const& {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return expected.value();
-    }
-    [[nodiscard]] constexpr T&& Unwrap() && {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return std::move(expected.value());
-    }
-    [[nodiscard]] constexpr const T&& Unwrap() const&& {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return std::move(expected.value());
-    }
-    template <typename U>
-    [[nodiscard]] constexpr T ValueOr(U&& v) const& {
-        return expected.value_or(v);
-    }
-    template <typename U>
-    [[nodiscard]] constexpr T ValueOr(U&& v) && {
-        return expected.value_or(v);
-    }
-private:
-    // TODO (Morph): Replace this with C++23 std::expected.
-    Common::Expected<T, Result> expected;
-};
-/**
- * Check for the success of `source` (which must evaluate to a ResultVal). If it succeeds, unwraps
- * the contained value and assigns it to `target`, which can be either an l-value expression or a
- * variable declaration. If it fails the return code is returned from the current function. Thus it
- * can be used to cascade errors out, achieving something akin to exception handling.
- */
-#define CASCADE_RESULT(target, source)                                                             \
-    auto CONCAT2(check_result_L, __LINE__) = source;                                               \
-    if (CONCAT2(check_result_L, __LINE__).Failed()) {                                              \
-        return CONCAT2(check_result_L, __LINE__).Code();                                           \
-    }                                                                                              \
-    target = std::move(*CONCAT2(check_result_L, __LINE__))
-/**
- * Analogous to CASCADE_RESULT, but for a bare Result. The code will be propagated if
- * non-success, or discarded otherwise.
- */
-#define CASCADE_CODE(source)                                                                       \
-    do {                                                                                           \
-        auto CONCAT2(check_result_L, __LINE__) = source;                                           \
-        if (CONCAT2(check_result_L, __LINE__).IsError()) {                                         \
-            return CONCAT2(check_result_L, __LINE__);                                              \
-        }                                                                                          \
-    } while (false)
 #define R_SUCCEEDED(res) (static_cast<Result>(res).IsSuccess())
 #define R_FAILED(res) (static_cast<Result>(res).IsFailure())
diff --git a/src/core/hle/service/acc/acc.cpp b/src/core/hle/service/acc/acc.cpp
index 2632cd3ef..b971401e6 100644
--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -765,15 +765,16 @@ Result Module::Interface::InitializeApplicationInfoBase() {
    // TODO(ogniK): This should be changed to reflect the target process for when we have multiple
    // processes emulated. As we don't actually have pid support we should assume we're just using
    // our own process
-    const auto launch_property =
+    Glue::ApplicationLaunchProperty launch_property{};
-        system.GetARPManager().GetLaunchProperty(system.GetApplicationProcessProgramID());
+    const auto result = system.GetARPManager().GetLaunchProperty(
+        &launch_property, system.GetApplicationProcessProgramID());
-    if (launch_property.Failed()) {
+    if (result != ResultSuccess) {
        LOG_ERROR(Service_ACC, "Failed to get launch property");
        return Account::ResultInvalidApplication;
    }
-    switch (launch_property->base_game_storage_id) {
+    switch (launch_property.base_game_storage_id) {
    case FileSys::StorageId::GameCard:
        application_info.application_type = ApplicationType::GameCard;
        break;
@@ -785,7 +786,7 @@ Result Module::Interface::InitializeApplicationInfoBase() {
        break;
    default:
        LOG_ERROR(Service_ACC, "Invalid game storage ID! storage_id={}",
-                  launch_property->base_game_storage_id);
+                  launch_property.base_game_storage_id);
        return Account::ResultInvalidApplication;
    }
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index 4f400d341..8d057b3a8 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -1317,6 +1317,50 @@ void ILibraryAppletCreator::CreateHandleStorage(HLERequestContext& ctx) {
    rb.PushIpcInterface<IStorage>(system, std::move(memory));
 }
+ILibraryAppletSelfAccessor::ILibraryAppletSelfAccessor(Core::System& system_)
+    : ServiceFramework{system_, "ILibraryAppletSelfAccessor"} {
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "PopInData"},
+        {1, nullptr, "PushOutData"},
+        {2, nullptr, "PopInteractiveInData"},
+        {3, nullptr, "PushInteractiveOutData"},
+        {5, nullptr, "GetPopInDataEvent"},
+        {6, nullptr, "GetPopInteractiveInDataEvent"},
+        {10, nullptr, "ExitProcessAndReturn"},
+        {11, nullptr, "GetLibraryAppletInfo"},
+        {12, nullptr, "GetMainAppletIdentityInfo"},
+        {13, nullptr, "CanUseApplicationCore"},
+        {14, nullptr, "GetCallerAppletIdentityInfo"},
+        {15, nullptr, "GetMainAppletApplicationControlProperty"},
+        {16, nullptr, "GetMainAppletStorageId"},
+        {17, nullptr, "GetCallerAppletIdentityInfoStack"},
+        {18, nullptr, "GetNextReturnDestinationAppletIdentityInfo"},
+        {19, nullptr, "GetDesirableKeyboardLayout"},
+        {20, nullptr, "PopExtraStorage"},
+        {25, nullptr, "GetPopExtraStorageEvent"},
+        {30, nullptr, "UnpopInData"},
+        {31, nullptr, "UnpopExtraStorage"},
+        {40, nullptr, "GetIndirectLayerProducerHandle"},
+        {50, nullptr, "ReportVisibleError"},
+        {51, nullptr, "ReportVisibleErrorWithErrorContext"},
+        {60, nullptr, "GetMainAppletApplicationDesiredLanguage"},
+        {70, nullptr, "GetCurrentApplicationId"},
+        {80, nullptr, "RequestExitToSelf"},
+        {90, nullptr, "CreateApplicationAndPushAndRequestToLaunch"},
+        {100, nullptr, "CreateGameMovieTrimmer"},
+        {101, nullptr, "ReserveResourceForMovieOperation"},
+        {102, nullptr, "UnreserveResourceForMovieOperation"},
+        {110, nullptr, "GetMainAppletAvailableUsers"},
+        {120, nullptr, "GetLaunchStorageInfoForDebug"},
+        {130, nullptr, "GetGpuErrorDetectedSystemEvent"},
+        {140, nullptr, "SetApplicationMemoryReservation"},
+        {150, nullptr, "ShouldSetGpuTimeSliceManually"},
+    };
+    RegisterHandlers(functions);
+}
+ILibraryAppletSelfAccessor::~ILibraryAppletSelfAccessor() = default;
 IApplicationFunctions::IApplicationFunctions(Core::System& system_)
    : ServiceFramework{system_, "IApplicationFunctions"}, service_context{system,
                                                                          "IApplicationFunctions"} {
@@ -1534,11 +1578,13 @@ void IApplicationFunctions::EnsureSaveData(HLERequestContext& ctx) {
    attribute.title_id = system.GetApplicationProcessProgramID();
    attribute.user_id = user_id;
    attribute.type = FileSys::SaveDataType::SaveData;
+    FileSys::VirtualDir save_data{};
    const auto res = system.GetFileSystemController().CreateSaveData(
-        FileSys::SaveDataSpaceId::NandUser, attribute);
+        &save_data, FileSys::SaveDataSpaceId::NandUser, attribute);
    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(res.Code());
+    rb.Push(res);
    rb.Push<u64>(0);
 }
@@ -1623,26 +1669,30 @@ void IApplicationFunctions::GetDesiredLanguage(HLERequestContext& ctx) {
    auto app_man = ns_am2->GetApplicationManagerInterface();
    // Get desired application language
-    const auto res_lang = app_man->GetApplicationDesiredLanguage(supported_languages);
+    u8 desired_language{};
-    if (res_lang.Failed()) {
+    const auto res_lang =
+        app_man->GetApplicationDesiredLanguage(&desired_language, supported_languages);
+    if (res_lang != ResultSuccess) {
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res_lang.Code());
+        rb.Push(res_lang);
        return;
    }
    // Convert to settings language code.
-    const auto res_code = app_man->ConvertApplicationLanguageToLanguageCode(*res_lang);
+    u64 language_code{};
-    if (res_code.Failed()) {
+    const auto res_code =
+        app_man->ConvertApplicationLanguageToLanguageCode(&language_code, desired_language);
+    if (res_code != ResultSuccess) {
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res_code.Code());
+        rb.Push(res_code);
        return;
    }
-    LOG_DEBUG(Service_AM, "got desired_language={:016X}", *res_code);
+    LOG_DEBUG(Service_AM, "got desired_language={:016X}", language_code);
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(ResultSuccess);
-    rb.Push(*res_code);
+    rb.Push(language_code);
 }
 void IApplicationFunctions::IsGamePlayRecordingSupported(HLERequestContext& ctx) {
diff --git a/src/core/hle/service/am/am.h b/src/core/hle/service/am/am.h
index d4fd163da..d68998f04 100644
--- a/src/core/hle/service/am/am.h
+++ b/src/core/hle/service/am/am.h
@@ -22,30 +22,6 @@ class Nvnflinger;
 namespace Service::AM {
-// This is nn::settings::Language
-enum SystemLanguage {
-    Japanese = 0,
-    English = 1, // en-US
-    French = 2,
-    German = 3,
-    Italian = 4,
-    Spanish = 5,
-    Chinese = 6,
-    Korean = 7,
-    Dutch = 8,
-    Portuguese = 9,
-    Russian = 10,
-    Taiwanese = 11,
-    BritishEnglish = 12, // en-GB
-    CanadianFrench = 13,
-    LatinAmericanSpanish = 14, // es-419
-    // 4.0.0+
-    SimplifiedChinese = 15,
-    TraditionalChinese = 16,
-    // 10.1.0+
-    BrazilianPortuguese = 17,
-};
 class AppletMessageQueue {
 public:
    // This is nn::am::AppletMessage
@@ -314,6 +290,12 @@ private:
    void CreateHandleStorage(HLERequestContext& ctx);
 };
+class ILibraryAppletSelfAccessor final : public ServiceFramework<ILibraryAppletSelfAccessor> {
+public:
+    explicit ILibraryAppletSelfAccessor(Core::System& system_);
+    ~ILibraryAppletSelfAccessor() override;
+};
 class IApplicationFunctions final : public ServiceFramework<IApplicationFunctions> {
 public:
    explicit IApplicationFunctions(Core::System& system_);
diff --git a/src/core/hle/service/am/applet_ae.cpp b/src/core/hle/service/am/applet_ae.cpp
index 2764f7ceb..ee9d99a54 100644
--- a/src/core/hle/service/am/applet_ae.cpp
+++ b/src/core/hle/service/am/applet_ae.cpp
@@ -26,8 +26,10 @@ public:
            {4, &ILibraryAppletProxy::GetDisplayController, "GetDisplayController"},
            {10, &ILibraryAppletProxy::GetProcessWindingController, "GetProcessWindingController"},
            {11, &ILibraryAppletProxy::GetLibraryAppletCreator, "GetLibraryAppletCreator"},
-            {20, &ILibraryAppletProxy::GetApplicationFunctions, "GetApplicationFunctions"},
+            {20, &ILibraryAppletProxy::OpenLibraryAppletSelfAccessor, "OpenLibraryAppletSelfAccessor"},
            {21, nullptr, "GetAppletCommonFunctions"},
+            {22, nullptr, "GetHomeMenuFunctions"},
+            {23, nullptr, "GetGlobalStateController"},
            {1000, &ILibraryAppletProxy::GetDebugFunctions, "GetDebugFunctions"},
        };
        // clang-format on
@@ -100,12 +102,12 @@ private:
        rb.PushIpcInterface<ILibraryAppletCreator>(system);
    }
-    void GetApplicationFunctions(HLERequestContext& ctx) {
+    void OpenLibraryAppletSelfAccessor(HLERequestContext& ctx) {
        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IApplicationFunctions>(system);
+        rb.PushIpcInterface<ILibraryAppletSelfAccessor>(system);
    }
    Nvnflinger::Nvnflinger& nvnflinger;
diff --git a/src/core/hle/service/audio/audctl.cpp b/src/core/hle/service/audio/audctl.cpp
index 7ad93be6b..66dd64fd1 100644
--- a/src/core/hle/service/audio/audctl.cpp
+++ b/src/core/hle/service/audio/audctl.cpp
@@ -22,13 +22,13 @@ AudCtl::AudCtl(Core::System& system_) : ServiceFramework{system_, "audctl"} {
        {9, nullptr, "GetAudioOutputMode"},
        {10, nullptr, "SetAudioOutputMode"},
        {11, nullptr, "SetForceMutePolicy"},
-        {12, nullptr, "GetForceMutePolicy"},
+        {12, &AudCtl::GetForceMutePolicy, "GetForceMutePolicy"},
-        {13, nullptr, "GetOutputModeSetting"},
+        {13, &AudCtl::GetOutputModeSetting, "GetOutputModeSetting"},
        {14, nullptr, "SetOutputModeSetting"},
        {15, nullptr, "SetOutputTarget"},
        {16, nullptr, "SetInputTargetForceEnabled"},
        {17, nullptr, "SetHeadphoneOutputLevelMode"},
-        {18, nullptr, "GetHeadphoneOutputLevelMode"},
+        {18, &AudCtl::GetHeadphoneOutputLevelMode, "GetHeadphoneOutputLevelMode"},
        {19, nullptr, "AcquireAudioVolumeUpdateEventForPlayReport"},
        {20, nullptr, "AcquireAudioOutputDeviceUpdateEventForPlayReport"},
        {21, nullptr, "GetAudioOutputTargetForPlayReport"},
@@ -41,7 +41,7 @@ AudCtl::AudCtl(Core::System& system_) : ServiceFramework{system_, "audctl"} {
        {28, nullptr, "GetAudioOutputChannelCountForPlayReport"},
        {29, nullptr, "BindAudioOutputChannelCountUpdateEventForPlayReport"},
        {30, nullptr, "SetSpeakerAutoMuteEnabled"},
-        {31, nullptr, "IsSpeakerAutoMuteEnabled"},
+        {31, &AudCtl::IsSpeakerAutoMuteEnabled, "IsSpeakerAutoMuteEnabled"},
        {32, nullptr, "GetActiveOutputTarget"},
        {33, nullptr, "GetTargetDeviceInfo"},
        {34, nullptr, "AcquireTargetNotification"},
@@ -96,4 +96,42 @@ void AudCtl::GetTargetVolumeMax(HLERequestContext& ctx) {
    rb.Push(target_max_volume);
 }
+void AudCtl::GetForceMutePolicy(HLERequestContext& ctx) {
+    LOG_WARNING(Audio, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(ForceMutePolicy::Disable);
+}
+void AudCtl::GetOutputModeSetting(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto value = rp.Pop<u32>();
+    LOG_WARNING(Audio, "(STUBBED) called, value={}", value);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(AudioOutputMode::PcmAuto);
+}
+void AudCtl::GetHeadphoneOutputLevelMode(HLERequestContext& ctx) {
+    LOG_WARNING(Audio, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(HeadphoneOutputLevelMode::Normal);
+}
+void AudCtl::IsSpeakerAutoMuteEnabled(HLERequestContext& ctx) {
+    const bool is_speaker_auto_mute_enabled = false;
+    LOG_WARNING(Audio, "(STUBBED) called, is_speaker_auto_mute_enabled={}",
+                is_speaker_auto_mute_enabled);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push<u8>(is_speaker_auto_mute_enabled);
+}
 } // namespace Service::Audio
diff --git a/src/core/hle/service/audio/audctl.h b/src/core/hle/service/audio/audctl.h
index 8e31ac237..d57abb383 100644
--- a/src/core/hle/service/audio/audctl.h
+++ b/src/core/hle/service/audio/audctl.h
@@ -17,8 +17,30 @@ public:
    ~AudCtl() override;
 private:
+    enum class AudioOutputMode {
+        Invalid,
+        Pcm1ch,
+        Pcm2ch,
+        Pcm6ch,
+        PcmAuto,
+    };
+    enum class ForceMutePolicy {
+        Disable,
+        SpeakerMuteOnHeadphoneUnplugged,
+    };
+    enum class HeadphoneOutputLevelMode {
+        Normal,
+        HighPower,
+    };
    void GetTargetVolumeMin(HLERequestContext& ctx);
    void GetTargetVolumeMax(HLERequestContext& ctx);
+    void GetForceMutePolicy(HLERequestContext& ctx);
+    void GetOutputModeSetting(HLERequestContext& ctx);
+    void GetHeadphoneOutputLevelMode(HLERequestContext& ctx);
+    void IsSpeakerAutoMuteEnabled(HLERequestContext& ctx);
 };
 } // namespace Service::Audio
diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp
index dfcdd3ada..ac465d5a9 100644
--- a/src/core/hle/service/filesystem/filesystem.cpp
+++ b/src/core/hle/service/filesystem/filesystem.cpp
@@ -57,8 +57,8 @@ Result VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64 size
        return FileSys::ERROR_PATH_NOT_FOUND;
    }
-    const auto entry_type = GetEntryType(path);
+    FileSys::EntryType entry_type{};
-    if (entry_type.Code() == ResultSuccess) {
+    if (GetEntryType(&entry_type, path) == ResultSuccess) {
        return FileSys::ERROR_PATH_ALREADY_EXISTS;
    }
@@ -210,8 +210,8 @@ Result VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_path_,
    return ResultUnknown;
 }
-ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::string& path_,
+Result VfsDirectoryServiceWrapper::OpenFile(FileSys::VirtualFile* out_file,
-                                                                     FileSys::Mode mode) const {
+                                            const std::string& path_, FileSys::Mode mode) const {
    const std::string path(Common::FS::SanitizePath(path_));
    std::string_view npath = path;
    while (!npath.empty() && (npath[0] == '/' || npath[0] == '\\')) {
@@ -224,50 +224,68 @@ ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::
    }
    if (mode == FileSys::Mode::Append) {
-        return std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize());
+        *out_file = std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize());
+    } else {
+        *out_file = file;
    }
-    return file;
+    return ResultSuccess;
 }
-ResultVal<FileSys::VirtualDir> VfsDirectoryServiceWrapper::OpenDirectory(const std::string& path_) {
+Result VfsDirectoryServiceWrapper::OpenDirectory(FileSys::VirtualDir* out_directory,
+                                                 const std::string& path_) {
    std::string path(Common::FS::SanitizePath(path_));
    auto dir = GetDirectoryRelativeWrapped(backing, path);
    if (dir == nullptr) {
        // TODO(DarkLordZach): Find a better error code for this
        return FileSys::ERROR_PATH_NOT_FOUND;
    }
-    return dir;
+    *out_directory = dir;
+    return ResultSuccess;
 }
-ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
+Result VfsDirectoryServiceWrapper::GetEntryType(FileSys::EntryType* out_entry_type,
-    const std::string& path_) const {
+                                                const std::string& path_) const {
    std::string path(Common::FS::SanitizePath(path_));
    auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
-    if (dir == nullptr)
+    if (dir == nullptr) {
        return FileSys::ERROR_PATH_NOT_FOUND;
+    }
    auto filename = Common::FS::GetFilename(path);
    // TODO(Subv): Some games use the '/' path, find out what this means.
-    if (filename.empty())
+    if (filename.empty()) {
-        return FileSys::EntryType::Directory;
+        *out_entry_type = FileSys::EntryType::Directory;
+        return ResultSuccess;
+    }
+    if (dir->GetFile(filename) != nullptr) {
+        *out_entry_type = FileSys::EntryType::File;
+        return ResultSuccess;
+    }
+    if (dir->GetSubdirectory(filename) != nullptr) {
+        *out_entry_type = FileSys::EntryType::Directory;
+        return ResultSuccess;
+    }
-    if (dir->GetFile(filename) != nullptr)
-        return FileSys::EntryType::File;
-    if (dir->GetSubdirectory(filename) != nullptr)
-        return FileSys::EntryType::Directory;
    return FileSys::ERROR_PATH_NOT_FOUND;
 }
-ResultVal<FileSys::FileTimeStampRaw> VfsDirectoryServiceWrapper::GetFileTimeStampRaw(
+Result VfsDirectoryServiceWrapper::GetFileTimeStampRaw(
-    const std::string& path) const {
+    FileSys::FileTimeStampRaw* out_file_time_stamp_raw, const std::string& path) const {
    auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
    if (dir == nullptr) {
        return FileSys::ERROR_PATH_NOT_FOUND;
    }
-    if (GetEntryType(path).Failed()) {
+    FileSys::EntryType entry_type;
+    if (GetEntryType(&entry_type, path) != ResultSuccess) {
        return FileSys::ERROR_PATH_NOT_FOUND;
    }
-    return dir->GetFileTimeStamp(Common::FS::GetFilename(path));
+    *out_file_time_stamp_raw = dir->GetFileTimeStamp(Common::FS::GetFilename(path));
+    return ResultSuccess;
 }
 FileSystemController::FileSystemController(Core::System& system_) : system{system_} {}
@@ -310,57 +328,54 @@ void FileSystemController::SetPackedUpdate(FileSys::VirtualFile update_raw) {
    romfs_factory->SetPackedUpdate(std::move(update_raw));
 }
-ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFSCurrentProcess() const {
+FileSys::VirtualFile FileSystemController::OpenRomFSCurrentProcess() const {
    LOG_TRACE(Service_FS, "Opening RomFS for current process");
    if (romfs_factory == nullptr) {
-        // TODO(bunnei): Find a better error code for this
+        return nullptr;
-        return ResultUnknown;
    }
    return romfs_factory->OpenCurrentProcess(system.GetApplicationProcessProgramID());
 }
-ResultVal<FileSys::VirtualFile> FileSystemController::OpenPatchedRomFS(
+FileSys::VirtualFile FileSystemController::OpenPatchedRomFS(u64 title_id,
-    u64 title_id, FileSys::ContentRecordType type) const {
+                                                            FileSys::ContentRecordType type) const {
    LOG_TRACE(Service_FS, "Opening patched RomFS for title_id={:016X}", title_id);
    if (romfs_factory == nullptr) {
-        // TODO: Find a better error code for this
+        return nullptr;
-        return ResultUnknown;
    }
    return romfs_factory->OpenPatchedRomFS(title_id, type);
 }
-ResultVal<FileSys::VirtualFile> FileSystemController::OpenPatchedRomFSWithProgramIndex(
+FileSys::VirtualFile FileSystemController::OpenPatchedRomFSWithProgramIndex(
    u64 title_id, u8 program_index, FileSys::ContentRecordType type) const {
    LOG_TRACE(Service_FS, "Opening patched RomFS for title_id={:016X}, program_index={}", title_id,
              program_index);
    if (romfs_factory == nullptr) {
-        // TODO: Find a better error code for this
+        return nullptr;
-        return ResultUnknown;
    }
    return romfs_factory->OpenPatchedRomFSWithProgramIndex(title_id, program_index, type);
 }
-ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFS(
+FileSys::VirtualFile FileSystemController::OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
-    u64 title_id, FileSys::StorageId storage_id, FileSys::ContentRecordType type) const {
+                                                     FileSys::ContentRecordType type) const {
    LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}, storage_id={:02X}, type={:02X}",
              title_id, storage_id, type);
    if (romfs_factory == nullptr) {
-        // TODO(bunnei): Find a better error code for this
+        return nullptr;
-        return ResultUnknown;
    }
    return romfs_factory->Open(title_id, storage_id, type);
 }
-ResultVal<FileSys::VirtualDir> FileSystemController::CreateSaveData(
+Result FileSystemController::CreateSaveData(FileSys::VirtualDir* out_save_data,
-    FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const {
+                                            FileSys::SaveDataSpaceId space,
+                                            const FileSys::SaveDataAttribute& save_struct) const {
    LOG_TRACE(Service_FS, "Creating Save Data for space_id={:01X}, save_struct={}", space,
              save_struct.DebugInfo());
@@ -368,11 +383,18 @@ ResultVal<FileSys::VirtualDir> FileSystemController::CreateSaveData(
        return FileSys::ERROR_ENTITY_NOT_FOUND;
    }
-    return save_data_factory->Create(space, save_struct);
+    auto save_data = save_data_factory->Create(space, save_struct);
+    if (save_data == nullptr) {
+        return FileSys::ERROR_ENTITY_NOT_FOUND;
+    }
+    *out_save_data = save_data;
+    return ResultSuccess;
 }
-ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveData(
+Result FileSystemController::OpenSaveData(FileSys::VirtualDir* out_save_data,
-    FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& attribute) const {
+                                          FileSys::SaveDataSpaceId space,
+                                          const FileSys::SaveDataAttribute& attribute) const {
    LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}", space,
              attribute.DebugInfo());
@@ -380,32 +402,50 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveData(
        return FileSys::ERROR_ENTITY_NOT_FOUND;
    }
-    return save_data_factory->Open(space, attribute);
+    auto save_data = save_data_factory->Open(space, attribute);
+    if (save_data == nullptr) {
+        return FileSys::ERROR_ENTITY_NOT_FOUND;
+    }
+    *out_save_data = save_data;
+    return ResultSuccess;
 }
-ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveDataSpace(
+Result FileSystemController::OpenSaveDataSpace(FileSys::VirtualDir* out_save_data_space,
-    FileSys::SaveDataSpaceId space) const {
+                                               FileSys::SaveDataSpaceId space) const {
    LOG_TRACE(Service_FS, "Opening Save Data Space for space_id={:01X}", space);
    if (save_data_factory == nullptr) {
        return FileSys::ERROR_ENTITY_NOT_FOUND;
    }
-    return save_data_factory->GetSaveDataSpaceDirectory(space);
+    auto save_data_space = save_data_factory->GetSaveDataSpaceDirectory(space);
+    if (save_data_space == nullptr) {
+        return FileSys::ERROR_ENTITY_NOT_FOUND;
+    }
+    *out_save_data_space = save_data_space;
+    return ResultSuccess;
 }
-ResultVal<FileSys::VirtualDir> FileSystemController::OpenSDMC() const {
+Result FileSystemController::OpenSDMC(FileSys::VirtualDir* out_sdmc) const {
    LOG_TRACE(Service_FS, "Opening SDMC");
    if (sdmc_factory == nullptr) {
        return FileSys::ERROR_SD_CARD_NOT_FOUND;
    }
-    return sdmc_factory->Open();
+    auto sdmc = sdmc_factory->Open();
+    if (sdmc == nullptr) {
+        return FileSys::ERROR_SD_CARD_NOT_FOUND;
+    }
+    *out_sdmc = sdmc;
+    return ResultSuccess;
 }
-ResultVal<FileSys::VirtualDir> FileSystemController::OpenBISPartition(
+Result FileSystemController::OpenBISPartition(FileSys::VirtualDir* out_bis_partition,
-    FileSys::BisPartitionId id) const {
+                                              FileSys::BisPartitionId id) const {
    LOG_TRACE(Service_FS, "Opening BIS Partition with id={:08X}", id);
    if (bis_factory == nullptr) {
@@ -417,11 +457,12 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenBISPartition(
        return FileSys::ERROR_INVALID_ARGUMENT;
    }
-    return part;
+    *out_bis_partition = part;
+    return ResultSuccess;
 }
-ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
+Result FileSystemController::OpenBISPartitionStorage(
-    FileSys::BisPartitionId id) const {
+    FileSys::VirtualFile* out_bis_partition_storage, FileSys::BisPartitionId id) const {
    LOG_TRACE(Service_FS, "Opening BIS Partition Storage with id={:08X}", id);
    if (bis_factory == nullptr) {
@@ -433,7 +474,8 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
        return FileSys::ERROR_INVALID_ARGUMENT;
    }
-    return part;
+    *out_bis_partition_storage = part;
+    return ResultSuccess;
 }
 u64 FileSystemController::GetFreeSpaceSize(FileSys::StorageId id) const {
diff --git a/src/core/hle/service/filesystem/filesystem.h b/src/core/hle/service/filesystem/filesystem.h
index a5c1c9d3e..fd991f976 100644
--- a/src/core/hle/service/filesystem/filesystem.h
+++ b/src/core/hle/service/filesystem/filesystem.h
@@ -64,21 +64,24 @@ public:
    Result RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
    void SetPackedUpdate(FileSys::VirtualFile update_raw);
-    ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess() const;
+    FileSys::VirtualFile OpenRomFSCurrentProcess() const;
-    ResultVal<FileSys::VirtualFile> OpenPatchedRomFS(u64 title_id,
+    FileSys::VirtualFile OpenPatchedRomFS(u64 title_id, FileSys::ContentRecordType type) const;
-                                                     FileSys::ContentRecordType type) const;
+    FileSys::VirtualFile OpenPatchedRomFSWithProgramIndex(u64 title_id, u8 program_index,
-    ResultVal<FileSys::VirtualFile> OpenPatchedRomFSWithProgramIndex(
+                                                          FileSys::ContentRecordType type) const;
-        u64 title_id, u8 program_index, FileSys::ContentRecordType type) const;
+    FileSys::VirtualFile OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
-    ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
+                                   FileSys::ContentRecordType type) const;
-                                              FileSys::ContentRecordType type) const;
-    ResultVal<FileSys::VirtualDir> CreateSaveData(
+    Result CreateSaveData(FileSys::VirtualDir* out_save_data, FileSys::SaveDataSpaceId space,
-        FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const;
+                          const FileSys::SaveDataAttribute& save_struct) const;
-    ResultVal<FileSys::VirtualDir> OpenSaveData(
+    Result OpenSaveData(FileSys::VirtualDir* out_save_data, FileSys::SaveDataSpaceId space,
-        FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const;
+                        const FileSys::SaveDataAttribute& save_struct) const;
-    ResultVal<FileSys::VirtualDir> OpenSaveDataSpace(FileSys::SaveDataSpaceId space) const;
+    Result OpenSaveDataSpace(FileSys::VirtualDir* out_save_data_space,
-    ResultVal<FileSys::VirtualDir> OpenSDMC() const;
+                             FileSys::SaveDataSpaceId space) const;
-    ResultVal<FileSys::VirtualDir> OpenBISPartition(FileSys::BisPartitionId id) const;
+    Result OpenSDMC(FileSys::VirtualDir* out_sdmc) const;
-    ResultVal<FileSys::VirtualFile> OpenBISPartitionStorage(FileSys::BisPartitionId id) const;
+    Result OpenBISPartition(FileSys::VirtualDir* out_bis_partition,
+                            FileSys::BisPartitionId id) const;
+    Result OpenBISPartitionStorage(FileSys::VirtualFile* out_bis_partition_storage,
+                                   FileSys::BisPartitionId id) const;
    u64 GetFreeSpaceSize(FileSys::StorageId id) const;
    u64 GetTotalSpaceSize(FileSys::StorageId id) const;
@@ -224,26 +227,28 @@ public:
     * @param mode Mode to open the file with
     * @return Opened file, or error code
     */
-    ResultVal<FileSys::VirtualFile> OpenFile(const std::string& path, FileSys::Mode mode) const;
+    Result OpenFile(FileSys::VirtualFile* out_file, const std::string& path,
+                    FileSys::Mode mode) const;
    /**
     * Open a directory specified by its path
     * @param path Path relative to the archive
     * @return Opened directory, or error code
     */
-    ResultVal<FileSys::VirtualDir> OpenDirectory(const std::string& path);
+    Result OpenDirectory(FileSys::VirtualDir* out_directory, const std::string& path);
    /**
     * Get the type of the specified path
     * @return The type of the specified path or error code
     */
-    ResultVal<FileSys::EntryType> GetEntryType(const std::string& path) const;
+    Result GetEntryType(FileSys::EntryType* out_entry_type, const std::string& path) const;
    /**
     * Get the timestamp of the specified path
     * @return The timestamp of the specified path or error code
     */
-    ResultVal<FileSys::FileTimeStampRaw> GetFileTimeStampRaw(const std::string& path) const;
+    Result GetFileTimeStampRaw(FileSys::FileTimeStampRaw* out_time_stamp_raw,
+                               const std::string& path) const;
 private:
    FileSys::VirtualDir backing;
diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp
index 427dbc8b3..423a814cb 100644
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -419,14 +419,15 @@ public:
        LOG_DEBUG(Service_FS, "called. file={}, mode={}", name, mode);
-        auto result = backend.OpenFile(name, mode);
+        FileSys::VirtualFile vfs_file{};
-        if (result.Failed()) {
+        auto result = backend.OpenFile(&vfs_file, name, mode);
+        if (result != ResultSuccess) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
+            rb.Push(result);
            return;
        }
-        auto file = std::make_shared<IFile>(system, result.Unwrap());
+        auto file = std::make_shared<IFile>(system, vfs_file);
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
@@ -444,14 +445,15 @@ public:
        LOG_DEBUG(Service_FS, "called. directory={}, filter={}", name, filter_flags);
-        auto result = backend.OpenDirectory(name);
+        FileSys::VirtualDir vfs_dir{};
-        if (result.Failed()) {
+        auto result = backend.OpenDirectory(&vfs_dir, name);
+        if (result != ResultSuccess) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
+            rb.Push(result);
            return;
        }
-        auto directory = std::make_shared<IDirectory>(system, result.Unwrap());
+        auto directory = std::make_shared<IDirectory>(system, vfs_dir);
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
@@ -464,16 +466,17 @@ public:
        LOG_DEBUG(Service_FS, "called. file={}", name);
-        auto result = backend.GetEntryType(name);
+        FileSys::EntryType vfs_entry_type{};
-        if (result.Failed()) {
+        auto result = backend.GetEntryType(&vfs_entry_type, name);
+        if (result != ResultSuccess) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
+            rb.Push(result);
            return;
        }
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);
-        rb.Push<u32>(static_cast<u32>(*result));
+        rb.Push<u32>(static_cast<u32>(vfs_entry_type));
    }
    void Commit(HLERequestContext& ctx) {
@@ -505,16 +508,17 @@ public:
        LOG_WARNING(Service_FS, "(Partial Implementation) called. file={}", name);
-        auto result = backend.GetFileTimeStampRaw(name);
+        FileSys::FileTimeStampRaw vfs_timestamp{};
-        if (result.Failed()) {
+        auto result = backend.GetFileTimeStampRaw(&vfs_timestamp, name);
+        if (result != ResultSuccess) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
+            rb.Push(result);
            return;
        }
        IPC::ResponseBuilder rb{ctx, 10};
        rb.Push(ResultSuccess);
-        rb.PushRaw(*result);
+        rb.PushRaw(vfs_timestamp);
    }
 private:
@@ -572,14 +576,15 @@ private:
    }
    void FindAllSaves(FileSys::SaveDataSpaceId space) {
-        const auto save_root = fsc.OpenSaveDataSpace(space);
+        FileSys::VirtualDir save_root{};
+        const auto result = fsc.OpenSaveDataSpace(&save_root, space);
-        if (save_root.Failed() || *save_root == nullptr) {
+        if (result != ResultSuccess || save_root == nullptr) {
            LOG_ERROR(Service_FS, "The save root for the space_id={:02X} was invalid!", space);
            return;
        }
-        for (const auto& type : (*save_root)->GetSubdirectories()) {
+        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()) {
@@ -837,9 +842,11 @@ void FSP_SRV::OpenFileSystemWithPatch(HLERequestContext& ctx) {
 void FSP_SRV::OpenSdCardFileSystem(HLERequestContext& ctx) {
    LOG_DEBUG(Service_FS, "called");
-    auto filesystem =
+    FileSys::VirtualDir sdmc_dir{};
-        std::make_shared<IFileSystem>(system, fsc.OpenSDMC().Unwrap(),
+    fsc.OpenSDMC(&sdmc_dir);
-                                      SizeGetter::FromStorageId(fsc, FileSys::StorageId::SdCard));
+    auto filesystem = std::make_shared<IFileSystem>(
+        system, sdmc_dir, SizeGetter::FromStorageId(fsc, FileSys::StorageId::SdCard));
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
@@ -856,7 +863,8 @@ void FSP_SRV::CreateSaveDataFileSystem(HLERequestContext& ctx) {
    LOG_DEBUG(Service_FS, "called save_struct = {}, uid = {:016X}{:016X}", save_struct.DebugInfo(),
              uid[1], uid[0]);
-    fsc.CreateSaveData(FileSys::SaveDataSpaceId::NandUser, save_struct);
+    FileSys::VirtualDir save_data_dir{};
+    fsc.CreateSaveData(&save_data_dir, FileSys::SaveDataSpaceId::NandUser, save_struct);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(ResultSuccess);
@@ -874,8 +882,9 @@ void FSP_SRV::OpenSaveDataFileSystem(HLERequestContext& ctx) {
    LOG_INFO(Service_FS, "called.");
-    auto dir = fsc.OpenSaveData(parameters.space_id, parameters.attribute);
+    FileSys::VirtualDir dir{};
-    if (dir.Failed()) {
+    auto result = fsc.OpenSaveData(&dir, parameters.space_id, parameters.attribute);
+    if (result != ResultSuccess) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 0};
        rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
        return;
@@ -899,8 +908,8 @@ void FSP_SRV::OpenSaveDataFileSystem(HLERequestContext& ctx) {
        ASSERT(false);
    }
-    auto filesystem = std::make_shared<IFileSystem>(system, std::move(dir.Unwrap()),
+    auto filesystem =
-                                                    SizeGetter::FromStorageId(fsc, id));
+        std::make_shared<IFileSystem>(system, std::move(dir), SizeGetter::FromStorageId(fsc, id));
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
@@ -970,7 +979,7 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(HLERequestContext& ctx) {
    if (!romfs) {
        auto current_romfs = fsc.OpenRomFSCurrentProcess();
-        if (current_romfs.Failed()) {
+        if (!current_romfs) {
            // TODO (bunnei): Find the right error code to use here
            LOG_CRITICAL(Service_FS, "no file system interface available!");
            IPC::ResponseBuilder rb{ctx, 2};
@@ -978,7 +987,7 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(HLERequestContext& ctx) {
            return;
        }
-        romfs = current_romfs.Unwrap();
+        romfs = current_romfs;
    }
    auto storage = std::make_shared<IStorage>(system, romfs);
@@ -999,7 +1008,7 @@ void FSP_SRV::OpenDataStorageByDataId(HLERequestContext& ctx) {
    auto data = fsc.OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data);
-    if (data.Failed()) {
+    if (!data) {
        const auto archive = FileSys::SystemArchive::SynthesizeSystemArchive(title_id);
        if (archive != nullptr) {
@@ -1021,7 +1030,7 @@ void FSP_SRV::OpenDataStorageByDataId(HLERequestContext& ctx) {
    const FileSys::PatchManager pm{title_id, fsc, content_provider};
    auto storage = std::make_shared<IStorage>(
-        system, pm.PatchRomFS(std::move(data.Unwrap()), 0, FileSys::ContentRecordType::Data));
+        system, pm.PatchRomFS(std::move(data), 0, FileSys::ContentRecordType::Data));
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
@@ -1051,7 +1060,7 @@ void FSP_SRV::OpenDataStorageWithProgramIndex(HLERequestContext& ctx) {
        fsc.OpenPatchedRomFSWithProgramIndex(system.GetApplicationProcessProgramID(), program_index,
                                             FileSys::ContentRecordType::Program);
-    if (patched_romfs.Failed()) {
+    if (!patched_romfs) {
        // TODO: Find the right error code to use here
        LOG_ERROR(Service_FS, "could not open storage with program_index={}", program_index);
@@ -1060,7 +1069,7 @@ void FSP_SRV::OpenDataStorageWithProgramIndex(HLERequestContext& ctx) {
        return;
    }
-    auto storage = std::make_shared<IStorage>(system, std::move(patched_romfs.Unwrap()));
+    auto storage = std::make_shared<IStorage>(system, std::move(patched_romfs));
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
diff --git a/src/core/hle/service/glue/arp.cpp b/src/core/hle/service/glue/arp.cpp
index ed6fcb5f6..6f1151b03 100644
--- a/src/core/hle/service/glue/arp.cpp
+++ b/src/core/hle/service/glue/arp.cpp
@@ -65,18 +65,19 @@ void ARP_R::GetApplicationLaunchProperty(HLERequestContext& ctx) {
        return;
    }
-    const auto res = manager.GetLaunchProperty(*title_id);
+    ApplicationLaunchProperty launch_property{};
+    const auto res = manager.GetLaunchProperty(&launch_property, *title_id);
-    if (res.Failed()) {
+    if (res != ResultSuccess) {
        LOG_ERROR(Service_ARP, "Failed to get launch property!");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push(res);
        return;
    }
    IPC::ResponseBuilder rb{ctx, 6};
    rb.Push(ResultSuccess);
-    rb.PushRaw(*res);
+    rb.PushRaw(launch_property);
 }
 void ARP_R::GetApplicationLaunchPropertyWithApplicationId(HLERequestContext& ctx) {
@@ -85,18 +86,19 @@ void ARP_R::GetApplicationLaunchPropertyWithApplicationId(HLERequestContext& ctx
    LOG_DEBUG(Service_ARP, "called, title_id={:016X}", title_id);
-    const auto res = manager.GetLaunchProperty(title_id);
+    ApplicationLaunchProperty launch_property{};
+    const auto res = manager.GetLaunchProperty(&launch_property, title_id);
-    if (res.Failed()) {
+    if (res != ResultSuccess) {
        LOG_ERROR(Service_ARP, "Failed to get launch property!");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push(res);
        return;
    }
    IPC::ResponseBuilder rb{ctx, 6};
    rb.Push(ResultSuccess);
-    rb.PushRaw(*res);
+    rb.PushRaw(launch_property);
 }
 void ARP_R::GetApplicationControlProperty(HLERequestContext& ctx) {
@@ -113,16 +115,17 @@ void ARP_R::GetApplicationControlProperty(HLERequestContext& ctx) {
        return;
    }
-    const auto res = manager.GetControlProperty(*title_id);
+    std::vector<u8> nacp_data;
+    const auto res = manager.GetControlProperty(&nacp_data, *title_id);
-    if (res.Failed()) {
+    if (res != ResultSuccess) {
        LOG_ERROR(Service_ARP, "Failed to get control property!");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push(res);
        return;
    }
-    ctx.WriteBuffer(*res);
+    ctx.WriteBuffer(nacp_data);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(ResultSuccess);
@@ -134,16 +137,17 @@ void ARP_R::GetApplicationControlPropertyWithApplicationId(HLERequestContext& ct
    LOG_DEBUG(Service_ARP, "called, title_id={:016X}", title_id);
-    const auto res = manager.GetControlProperty(title_id);
+    std::vector<u8> nacp_data;
+    const auto res = manager.GetControlProperty(&nacp_data, title_id);
-    if (res.Failed()) {
+    if (res != ResultSuccess) {
        LOG_ERROR(Service_ARP, "Failed to get control property!");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push(res);
        return;
    }
-    ctx.WriteBuffer(*res);
+    ctx.WriteBuffer(nacp_data);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(ResultSuccess);
diff --git a/src/core/hle/service/glue/glue_manager.cpp b/src/core/hle/service/glue/glue_manager.cpp
index 4bf67921b..22f001704 100644
--- a/src/core/hle/service/glue/glue_manager.cpp
+++ b/src/core/hle/service/glue/glue_manager.cpp
@@ -15,7 +15,8 @@ ARPManager::ARPManager() = default;
 ARPManager::~ARPManager() = default;
-ResultVal<ApplicationLaunchProperty> ARPManager::GetLaunchProperty(u64 title_id) const {
+Result ARPManager::GetLaunchProperty(ApplicationLaunchProperty* out_launch_property,
+                                     u64 title_id) const {
    if (title_id == 0) {
        return Glue::ResultInvalidProcessId;
    }
@@ -25,10 +26,11 @@ ResultVal<ApplicationLaunchProperty> ARPManager::GetLaunchProperty(u64 title_id)
        return Glue::ResultProcessIdNotRegistered;
    }
-    return iter->second.launch;
+    *out_launch_property = iter->second.launch;
+    return ResultSuccess;
 }
-ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const {
+Result ARPManager::GetControlProperty(std::vector<u8>* out_control_property, u64 title_id) const {
    if (title_id == 0) {
        return Glue::ResultInvalidProcessId;
    }
@@ -38,7 +40,8 @@ ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const {
        return Glue::ResultProcessIdNotRegistered;
    }
-    return iter->second.control;
+    *out_control_property = iter->second.control;
+    return ResultSuccess;
 }
 Result ARPManager::Register(u64 title_id, ApplicationLaunchProperty launch,
diff --git a/src/core/hle/service/glue/glue_manager.h b/src/core/hle/service/glue/glue_manager.h
index 1cf53d9d9..216aa34c1 100644
--- a/src/core/hle/service/glue/glue_manager.h
+++ b/src/core/hle/service/glue/glue_manager.h
@@ -32,12 +32,12 @@ public:
    // Returns the ApplicationLaunchProperty corresponding to the provided title ID if it was
    // previously registered, otherwise ResultProcessIdNotRegistered if it was never registered or
    // ResultInvalidProcessId if the title ID is 0.
-    ResultVal<ApplicationLaunchProperty> GetLaunchProperty(u64 title_id) const;
+    Result GetLaunchProperty(ApplicationLaunchProperty* out_launch_property, u64 title_id) const;
    // Returns a vector of the raw bytes of NACP data (necessarily 0x4000 in size) corresponding to
    // the provided title ID if it was previously registered, otherwise ResultProcessIdNotRegistered
    // if it was never registered or ResultInvalidProcessId if the title ID is 0.
-    ResultVal<std::vector<u8>> GetControlProperty(u64 title_id) const;
+    Result GetControlProperty(std::vector<u8>* out_control_property, u64 title_id) const;
    // Adds a new entry to the internal database with the provided parameters, returning
    // ResultProcessIdNotRegistered if attempting to re-register a title ID without an intermediate
diff --git a/src/core/hle/service/hid/controllers/touchscreen.h b/src/core/hle/service/hid/controllers/touchscreen.h
index e57a3a80e..dd00921fd 100644
--- a/src/core/hle/service/hid/controllers/touchscreen.h
+++ b/src/core/hle/service/hid/controllers/touchscreen.h
@@ -16,22 +16,6 @@ class EmulatedConsole;
 namespace Service::HID {
 class Controller_Touchscreen final : public ControllerBase {
 public:
-    // This is nn::hid::TouchScreenModeForNx
-    enum class TouchScreenModeForNx : u8 {
-        UseSystemSetting,
-        Finger,
-        Heat2,
-    };
-    // This is nn::hid::TouchScreenConfigurationForNx
-    struct TouchScreenConfigurationForNx {
-        TouchScreenModeForNx mode{TouchScreenModeForNx::UseSystemSetting};
-        INSERT_PADDING_BYTES_NOINIT(0x7);
-        INSERT_PADDING_BYTES_NOINIT(0xF); // Reserved
-    };
-    static_assert(sizeof(TouchScreenConfigurationForNx) == 0x17,
-                  "TouchScreenConfigurationForNx is an invalid size");
    explicit Controller_Touchscreen(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
    ~Controller_Touchscreen() override;
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 2bf1d8a27..fd466db7b 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -2368,7 +2368,7 @@ void Hid::GetNpadCommunicationMode(HLERequestContext& ctx) {
 void Hid::SetTouchScreenConfiguration(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    const auto touchscreen_mode{rp.PopRaw<Controller_Touchscreen::TouchScreenConfigurationForNx>()};
+    const auto touchscreen_mode{rp.PopRaw<Core::HID::TouchScreenConfigurationForNx>()};
    const auto applet_resource_user_id{rp.Pop<u64>()};
    LOG_WARNING(Service_HID, "(STUBBED) called, touchscreen_mode={}, applet_resource_user_id={}",
@@ -2543,7 +2543,8 @@ public:
 class HidSys final : public ServiceFramework<HidSys> {
 public:
-    explicit HidSys(Core::System& system_) : ServiceFramework{system_, "hid:sys"} {
+    explicit HidSys(Core::System& system_)
+        : ServiceFramework{system_, "hid:sys"}, service_context{system_, "hid:sys"} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {31, nullptr, "SendKeyboardLockKeyEvent"},
@@ -2568,7 +2569,7 @@ public:
            {303, &HidSys::ApplyNpadSystemCommonPolicy, "ApplyNpadSystemCommonPolicy"},
            {304, nullptr, "EnableAssigningSingleOnSlSrPress"},
            {305, nullptr, "DisableAssigningSingleOnSlSrPress"},
-            {306, nullptr, "GetLastActiveNpad"},
+            {306, &HidSys::GetLastActiveNpad, "GetLastActiveNpad"},
            {307, nullptr, "GetNpadSystemExtStyle"},
            {308, nullptr, "ApplyNpadSystemCommonPolicyFull"},
            {309, nullptr, "GetNpadFullKeyGripColor"},
@@ -2624,7 +2625,7 @@ public:
            {700, nullptr, "ActivateUniquePad"},
            {702, nullptr, "AcquireUniquePadConnectionEventHandle"},
            {703, nullptr, "GetUniquePadIds"},
-            {751, nullptr, "AcquireJoyDetachOnBluetoothOffEventHandle"},
+            {751, &HidSys::AcquireJoyDetachOnBluetoothOffEventHandle, "AcquireJoyDetachOnBluetoothOffEventHandle"},
            {800, nullptr, "ListSixAxisSensorHandles"},
            {801, nullptr, "IsSixAxisSensorUserCalibrationSupported"},
            {802, nullptr, "ResetSixAxisSensorCalibrationValues"},
@@ -2650,7 +2651,7 @@ public:
            {830, nullptr, "SetNotificationLedPattern"},
            {831, nullptr, "SetNotificationLedPatternWithTimeout"},
            {832, nullptr, "PrepareHidsForNotificationWake"},
-            {850, nullptr, "IsUsbFullKeyControllerEnabled"},
+            {850, &HidSys::IsUsbFullKeyControllerEnabled, "IsUsbFullKeyControllerEnabled"},
            {851, nullptr, "EnableUsbFullKeyController"},
            {852, nullptr, "IsUsbConnected"},
            {870, nullptr, "IsHandheldButtonPressedOnConsoleMode"},
@@ -2682,7 +2683,7 @@ public:
            {1150, nullptr, "SetTouchScreenMagnification"},
            {1151, nullptr, "GetTouchScreenFirmwareVersion"},
            {1152, nullptr, "SetTouchScreenDefaultConfiguration"},
-            {1153, nullptr, "GetTouchScreenDefaultConfiguration"},
+            {1153, &HidSys::GetTouchScreenDefaultConfiguration, "GetTouchScreenDefaultConfiguration"},
            {1154, nullptr, "IsFirmwareAvailableForNotification"},
            {1155, nullptr, "SetForceHandheldStyleVibration"},
            {1156, nullptr, "SendConnectionTriggerWithoutTimeoutEvent"},
@@ -2749,6 +2750,8 @@ public:
        // clang-format on
        RegisterHandlers(functions);
+        joy_detach_event = service_context.CreateEvent("HidSys::JoyDetachEvent");
    }
 private:
@@ -2760,17 +2763,66 @@ private:
        rb.Push(ResultSuccess);
    }
+    void GetLastActiveNpad(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.PushEnum(Core::HID::NpadIdType::Handheld);
+    }
    void GetUniquePadsFromNpad(HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const auto npad_id_type{rp.PopEnum<Core::HID::NpadIdType>()};
-        const s64 total_entries = 0;
        LOG_WARNING(Service_HID, "(STUBBED) called, npad_id_type={}", npad_id_type);
+        const std::vector<Core::HID::UniquePadId> unique_pads{};
+        ctx.WriteBuffer(unique_pads);
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);
-        rb.Push(total_entries);
+        rb.Push(static_cast<u32>(unique_pads.size()));
    }
+    void AcquireJoyDetachOnBluetoothOffEventHandle(HLERequestContext& ctx) {
+        LOG_INFO(Service_AM, "called");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(ResultSuccess);
+        rb.PushCopyObjects(joy_detach_event->GetReadableEvent());
+    }
+    void IsUsbFullKeyControllerEnabled(HLERequestContext& ctx) {
+        const bool is_enabled = false;
+        LOG_WARNING(Service_HID, "(STUBBED) called, is_enabled={}", is_enabled);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push(is_enabled);
+    }
+    void GetTouchScreenDefaultConfiguration(HLERequestContext& ctx) {
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+        Core::HID::TouchScreenConfigurationForNx touchscreen_config{
+            .mode = Core::HID::TouchScreenModeForNx::Finger,
+        };
+        if (touchscreen_config.mode != Core::HID::TouchScreenModeForNx::Heat2 &&
+            touchscreen_config.mode != Core::HID::TouchScreenModeForNx::Finger) {
+            touchscreen_config.mode = Core::HID::TouchScreenModeForNx::UseSystemSetting;
+        }
+        IPC::ResponseBuilder rb{ctx, 6};
+        rb.Push(ResultSuccess);
+        rb.PushRaw(touchscreen_config);
+    }
+    Kernel::KEvent* joy_detach_event;
+    KernelHelpers::ServiceContext service_context;
 };
 void LoopProcess(Core::System& system) {
diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp
index 055c0a2db..c73035c77 100644
--- a/src/core/hle/service/ldr/ldr.cpp
+++ b/src/core/hle/service/ldr/ldr.cpp
@@ -357,7 +357,8 @@ public:
        return ResultSuccess;
    }
-    ResultVal<VAddr> MapProcessCodeMemory(Kernel::KProcess* process, VAddr base_addr, u64 size) {
+    Result MapProcessCodeMemory(VAddr* out_map_location, Kernel::KProcess* process, VAddr base_addr,
+                                u64 size) {
        auto& page_table{process->GetPageTable()};
        VAddr addr{};
@@ -372,20 +373,21 @@ public:
            R_TRY(result);
            if (ValidateRegionForMap(page_table, addr, size)) {
-                return addr;
+                *out_map_location = addr;
+                return ResultSuccess;
            }
        }
        return ERROR_INSUFFICIENT_ADDRESS_SPACE;
    }
-    ResultVal<VAddr> MapNro(Kernel::KProcess* process, VAddr nro_addr, std::size_t nro_size,
+    Result MapNro(VAddr* out_map_location, Kernel::KProcess* process, VAddr nro_addr,
-                            VAddr bss_addr, std::size_t bss_size, std::size_t size) {
+                  std::size_t nro_size, VAddr bss_addr, std::size_t bss_size, std::size_t size) {
        for (std::size_t retry = 0; retry < MAXIMUM_MAP_RETRIES; retry++) {
            auto& page_table{process->GetPageTable()};
            VAddr addr{};
-            CASCADE_RESULT(addr, MapProcessCodeMemory(process, nro_addr, nro_size));
+            R_TRY(MapProcessCodeMemory(&addr, process, nro_addr, nro_size));
            if (bss_size) {
                auto block_guard = detail::ScopeExit([&] {
@@ -411,7 +413,8 @@ public:
            }
            if (ValidateRegionForMap(page_table, addr, size)) {
-                return addr;
+                *out_map_location = addr;
+                return ResultSuccess;
            }
        }
@@ -437,9 +440,9 @@ public:
        CopyCode(nro_addr + nro_header.segment_headers[DATA_INDEX].memory_offset, data_start,
                 nro_header.segment_headers[DATA_INDEX].memory_size);
-        CASCADE_CODE(process->GetPageTable().SetProcessMemoryPermission(
+        R_TRY(process->GetPageTable().SetProcessMemoryPermission(
            text_start, ro_start - text_start, Kernel::Svc::MemoryPermission::ReadExecute));
-        CASCADE_CODE(process->GetPageTable().SetProcessMemoryPermission(
+        R_TRY(process->GetPageTable().SetProcessMemoryPermission(
            ro_start, data_start - ro_start, Kernel::Svc::MemoryPermission::Read));
        return process->GetPageTable().SetProcessMemoryPermission(
@@ -542,31 +545,32 @@ public:
        }
        // Map memory for the NRO
-        const auto map_result{MapNro(system.ApplicationProcess(), nro_address, nro_size,
+        VAddr map_location{};
-                                     bss_address, bss_size, nro_size + bss_size)};
+        const auto map_result{MapNro(&map_location, system.ApplicationProcess(), nro_address,
-        if (map_result.Failed()) {
+                                     nro_size, bss_address, bss_size, nro_size + bss_size)};
+        if (map_result != ResultSuccess) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(map_result.Code());
+            rb.Push(map_result);
        }
        // Load the NRO into the mapped memory
        if (const auto result{
-                LoadNro(system.ApplicationProcess(), header, nro_address, *map_result)};
+                LoadNro(system.ApplicationProcess(), header, nro_address, map_location)};
            result.IsError()) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(map_result.Code());
+            rb.Push(result);
        }
        // Track the loaded NRO
-        nro.insert_or_assign(*map_result,
+        nro.insert_or_assign(map_location,
-                             NROInfo{hash, *map_result, nro_size, bss_address, bss_size,
+                             NROInfo{hash, map_location, nro_size, bss_address, bss_size,
                                     header.segment_headers[TEXT_INDEX].memory_size,
                                     header.segment_headers[RO_INDEX].memory_size,
                                     header.segment_headers[DATA_INDEX].memory_size, nro_address});
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(ResultSuccess);
-        rb.Push(*map_result);
+        rb.Push(map_location);
    }
    Result UnmapNro(const NROInfo& info) {
@@ -574,19 +578,19 @@ public:
        auto& page_table{system.ApplicationProcess()->GetPageTable()};
        if (info.bss_size != 0) {
-            CASCADE_CODE(page_table.UnmapCodeMemory(
+            R_TRY(page_table.UnmapCodeMemory(
                info.nro_address + info.text_size + info.ro_size + info.data_size, info.bss_address,
                info.bss_size, Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
        }
-        CASCADE_CODE(page_table.UnmapCodeMemory(
+        R_TRY(page_table.UnmapCodeMemory(
            info.nro_address + info.text_size + info.ro_size,
            info.src_addr + info.text_size + info.ro_size, info.data_size,
            Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
-        CASCADE_CODE(page_table.UnmapCodeMemory(
+        R_TRY(page_table.UnmapCodeMemory(
            info.nro_address + info.text_size, info.src_addr + info.text_size, info.ro_size,
            Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
-        CASCADE_CODE(page_table.UnmapCodeMemory(
+        R_TRY(page_table.UnmapCodeMemory(
            info.nro_address, info.src_addr, info.text_size,
            Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
        return ResultSuccess;
diff --git a/src/core/hle/service/mii/mii.cpp b/src/core/hle/service/mii/mii.cpp
index 5c7adf97d..65c11a2f3 100644
--- a/src/core/hle/service/mii/mii.cpp
+++ b/src/core/hle/service/mii/mii.cpp
@@ -101,20 +101,14 @@ private:
        LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
-        const auto result{manager.GetDefault(source_flag)};
+        const auto default_miis{manager.GetDefault(source_flag)};
-        if (result.Failed()) {
+        if (default_miis.size() > 0) {
-            IPC::ResponseBuilder rb{ctx, 2};
+            ctx.WriteBuffer(SerializeArray(default_miis));
-            rb.Push(result.Code());
-            return;
-        }
-        if (result->size() > 0) {
-            ctx.WriteBuffer(SerializeArray(*result));
        }
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);
-        rb.Push<u32>(static_cast<u32>(result->size()));
+        rb.Push<u32>(static_cast<u32>(default_miis.size()));
    }
    void Get1(HLERequestContext& ctx) {
@@ -123,15 +117,10 @@ private:
        LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
-        const auto result{manager.GetDefault(source_flag)};
+        const auto default_miis{manager.GetDefault(source_flag)};
-        if (result.Failed()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
-            return;
-        }
        std::vector<CharInfo> values;
-        for (const auto& element : *result) {
+        for (const auto& element : default_miis) {
            values.emplace_back(element.info);
        }
@@ -139,7 +128,7 @@ private:
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);
-        rb.Push<u32>(static_cast<u32>(result->size()));
+        rb.Push<u32>(static_cast<u32>(default_miis.size()));
    }
    void UpdateLatest(HLERequestContext& ctx) {
@@ -149,16 +138,17 @@ private:
        LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
-        const auto result{manager.UpdateLatest(info, source_flag)};
+        CharInfo new_char_info{};
-        if (result.Failed()) {
+        const auto result{manager.UpdateLatest(&new_char_info, info, source_flag)};
+        if (result != ResultSuccess) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
+            rb.Push(result);
            return;
        }
        IPC::ResponseBuilder rb{ctx, 2 + sizeof(CharInfo) / sizeof(u32)};
        rb.Push(ResultSuccess);
-        rb.PushRaw<CharInfo>(*result);
+        rb.PushRaw<CharInfo>(new_char_info);
    }
    void BuildRandom(HLERequestContext& ctx) {
diff --git a/src/core/hle/service/mii/mii_manager.cpp b/src/core/hle/service/mii/mii_manager.cpp
index c920650f5..46125d473 100644
--- a/src/core/hle/service/mii/mii_manager.cpp
+++ b/src/core/hle/service/mii/mii_manager.cpp
@@ -409,8 +409,7 @@ u32 MiiManager::GetCount(SourceFlag source_flag) const {
    return static_cast<u32>(count);
 }
-ResultVal<CharInfo> MiiManager::UpdateLatest([[maybe_unused]] const CharInfo& info,
+Result MiiManager::UpdateLatest(CharInfo* out_info, const CharInfo& info, SourceFlag source_flag) {
-                                             SourceFlag source_flag) {
    if ((source_flag & SourceFlag::Database) == SourceFlag::None) {
        return ERROR_CANNOT_FIND_ENTRY;
    }
@@ -672,7 +671,7 @@ bool MiiManager::ValidateV3Info(const Ver3StoreData& mii_v3) const {
    return is_valid;
 }
-ResultVal<std::vector<MiiInfoElement>> MiiManager::GetDefault(SourceFlag source_flag) {
+std::vector<MiiInfoElement> MiiManager::GetDefault(SourceFlag source_flag) {
    std::vector<MiiInfoElement> result;
    if ((source_flag & SourceFlag::Default) == SourceFlag::None) {
diff --git a/src/core/hle/service/mii/mii_manager.h b/src/core/hle/service/mii/mii_manager.h
index 5525fcd1c..45c2be3c8 100644
--- a/src/core/hle/service/mii/mii_manager.h
+++ b/src/core/hle/service/mii/mii_manager.h
@@ -19,12 +19,12 @@ public:
    bool CheckAndResetUpdateCounter(SourceFlag source_flag, u64& current_update_counter);
    bool IsFullDatabase() const;
    u32 GetCount(SourceFlag source_flag) const;
-    ResultVal<CharInfo> UpdateLatest(const CharInfo& info, SourceFlag source_flag);
+    Result UpdateLatest(CharInfo* out_info, const CharInfo& info, SourceFlag source_flag);
    CharInfo BuildRandom(Age age, Gender gender, Race race);
    CharInfo BuildDefault(std::size_t index);
    CharInfo ConvertV3ToCharInfo(const Ver3StoreData& mii_v3) const;
    bool ValidateV3Info(const Ver3StoreData& mii_v3) const;
-    ResultVal<std::vector<MiiInfoElement>> GetDefault(SourceFlag source_flag);
+    std::vector<MiiInfoElement> GetDefault(SourceFlag source_flag);
    Result GetIndex(const CharInfo& info, u32& index);
    // This is nn::mii::detail::Ver::StoreDataRaw::BuildFromStoreData
diff --git a/src/core/hle/service/ns/ns.cpp b/src/core/hle/service/ns/ns.cpp
index 91c5a2182..6e0baf0be 100644
--- a/src/core/hle/service/ns/ns.cpp
+++ b/src/core/hle/service/ns/ns.cpp
@@ -392,19 +392,20 @@ void IApplicationManagerInterface::GetApplicationDesiredLanguage(HLERequestConte
    IPC::RequestParser rp{ctx};
    const auto supported_languages = rp.Pop<u32>();
-    const auto res = GetApplicationDesiredLanguage(supported_languages);
+    u8 desired_language{};
-    if (res.Succeeded()) {
+    const auto res = GetApplicationDesiredLanguage(&desired_language, supported_languages);
+    if (res == ResultSuccess) {
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);
-        rb.Push<u32>(*res);
+        rb.Push<u32>(desired_language);
    } else {
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push(res);
    }
 }
-ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
+Result IApplicationManagerInterface::GetApplicationDesiredLanguage(u8* out_desired_language,
-    const u32 supported_languages) {
+                                                                   const u32 supported_languages) {
    LOG_DEBUG(Service_NS, "called with supported_languages={:08X}", supported_languages);
    // Get language code from settings
@@ -430,7 +431,8 @@ ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
    for (const auto lang : *priority_list) {
        const auto supported_flag = GetSupportedLanguageFlag(lang);
        if (supported_languages == 0 || (supported_languages & supported_flag) == supported_flag) {
-            return static_cast<u8>(lang);
+            *out_desired_language = static_cast<u8>(lang);
+            return ResultSuccess;
        }
    }
@@ -444,19 +446,20 @@ void IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
    IPC::RequestParser rp{ctx};
    const auto application_language = rp.Pop<u8>();
-    const auto res = ConvertApplicationLanguageToLanguageCode(application_language);
+    u64 language_code{};
-    if (res.Succeeded()) {
+    const auto res = ConvertApplicationLanguageToLanguageCode(&language_code, application_language);
+    if (res == ResultSuccess) {
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(ResultSuccess);
-        rb.Push(*res);
+        rb.Push(language_code);
    } else {
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push(res);
    }
 }
-ResultVal<u64> IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
+Result IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
-    u8 application_language) {
+    u64* out_language_code, u8 application_language) {
    const auto language_code =
        ConvertToLanguageCode(static_cast<ApplicationLanguage>(application_language));
    if (language_code == std::nullopt) {
@@ -464,7 +467,8 @@ ResultVal<u64> IApplicationManagerInterface::ConvertApplicationLanguageToLanguag
        return Service::NS::ResultApplicationLanguageNotFound;
    }
-    return static_cast<u64>(*language_code);
+    *out_language_code = static_cast<u64>(*language_code);
+    return ResultSuccess;
 }
 IApplicationVersionInterface::IApplicationVersionInterface(Core::System& system_)
@@ -618,12 +622,13 @@ void IReadOnlyApplicationControlDataInterface::GetApplicationControlData(HLERequ
    static_assert(sizeof(RequestParameters) == 0x10, "RequestParameters has incorrect size.");
    IPC::RequestParser rp{ctx};
+    std::vector<u8> nacp_data{};
    const auto parameters{rp.PopRaw<RequestParameters>()};
-    const auto nacp_data{system.GetARPManager().GetControlProperty(parameters.application_id)};
+    const auto result =
-    const auto result = nacp_data ? ResultSuccess : ResultUnknown;
+        system.GetARPManager().GetControlProperty(&nacp_data, parameters.application_id);
-    if (nacp_data) {
+    if (result == ResultSuccess) {
-        ctx.WriteBuffer(nacp_data->data(), nacp_data->size());
+        ctx.WriteBuffer(nacp_data.data(), nacp_data.size());
    }
    IPC::ResponseBuilder rb{ctx, 2};
diff --git a/src/core/hle/service/ns/ns.h b/src/core/hle/service/ns/ns.h
index 203388e1f..175dad780 100644
--- a/src/core/hle/service/ns/ns.h
+++ b/src/core/hle/service/ns/ns.h
@@ -28,8 +28,9 @@ public:
    explicit IApplicationManagerInterface(Core::System& system_);
    ~IApplicationManagerInterface() override;
-    ResultVal<u8> GetApplicationDesiredLanguage(u32 supported_languages);
+    Result GetApplicationDesiredLanguage(u8* out_desired_language, u32 supported_languages);
-    ResultVal<u64> ConvertApplicationLanguageToLanguageCode(u8 application_language);
+    Result ConvertApplicationLanguageToLanguageCode(u64* out_language_code,
+                                                    u8 application_language);
 private:
    void GetApplicationControlData(HLERequestContext& ctx);
diff --git a/src/core/hle/service/nvnflinger/buffer_queue_producer.cpp b/src/core/hle/service/nvnflinger/buffer_queue_producer.cpp
index b16f9933f..dc6917d5d 100644
--- a/src/core/hle/service/nvnflinger/buffer_queue_producer.cpp
+++ b/src/core/hle/service/nvnflinger/buffer_queue_producer.cpp
@@ -449,6 +449,7 @@ Status BufferQueueProducer::QueueBuffer(s32 slot, const QueueBufferInput& input,
    case NativeWindowScalingMode::ScaleToWindow:
    case NativeWindowScalingMode::ScaleCrop:
    case NativeWindowScalingMode::NoScaleCrop:
+    case NativeWindowScalingMode::PreserveAspectRatio:
        break;
    default:
        LOG_ERROR(Service_Nvnflinger, "unknown scaling mode {}", scaling_mode);
diff --git a/src/core/hle/service/nvnflinger/nvnflinger.cpp b/src/core/hle/service/nvnflinger/nvnflinger.cpp
index 5f55cd31e..21f31f7a0 100644
--- a/src/core/hle/service/nvnflinger/nvnflinger.cpp
+++ b/src/core/hle/service/nvnflinger/nvnflinger.cpp
@@ -183,7 +183,7 @@ std::optional<u32> Nvnflinger::FindBufferQueueId(u64 display_id, u64 layer_id) {
    return layer->GetBinderId();
 }
-ResultVal<Kernel::KReadableEvent*> Nvnflinger::FindVsyncEvent(u64 display_id) {
+Result Nvnflinger::FindVsyncEvent(Kernel::KReadableEvent** out_vsync_event, u64 display_id) {
    const auto lock_guard = Lock();
    auto* const display = FindDisplay(display_id);
@@ -191,7 +191,7 @@ ResultVal<Kernel::KReadableEvent*> Nvnflinger::FindVsyncEvent(u64 display_id) {
        return VI::ResultNotFound;
    }
-    return display->GetVSyncEvent();
+    return display->GetVSyncEvent(out_vsync_event);
 }
 VI::Display* Nvnflinger::FindDisplay(u64 display_id) {
diff --git a/src/core/hle/service/nvnflinger/nvnflinger.h b/src/core/hle/service/nvnflinger/nvnflinger.h
index ef236303a..f478c2bc6 100644
--- a/src/core/hle/service/nvnflinger/nvnflinger.h
+++ b/src/core/hle/service/nvnflinger/nvnflinger.h
@@ -82,7 +82,7 @@ public:
    ///
    /// If an invalid display ID is provided, then VI::ResultNotFound is returned.
    /// If the vsync event has already been retrieved, then VI::ResultPermissionDenied is returned.
-    [[nodiscard]] ResultVal<Kernel::KReadableEvent*> FindVsyncEvent(u64 display_id);
+    [[nodiscard]] Result FindVsyncEvent(Kernel::KReadableEvent** out_vsync_event, u64 display_id);
    /// Performs a composition request to the emulated nvidia GPU and triggers the vsync events when
    /// finished.
diff --git a/src/core/hle/service/nvnflinger/window.h b/src/core/hle/service/nvnflinger/window.h
index 61cca5b01..36d6cde3d 100644
--- a/src/core/hle/service/nvnflinger/window.h
+++ b/src/core/hle/service/nvnflinger/window.h
@@ -41,6 +41,7 @@ enum class NativeWindowScalingMode : s32 {
    ScaleToWindow = 1,
    ScaleCrop = 2,
    NoScaleCrop = 3,
+    PreserveAspectRatio = 4,
 };
 /// Transform parameter for QueueBuffer
diff --git a/src/core/hle/service/olsc/olsc.cpp b/src/core/hle/service/olsc/olsc.cpp
index 14ba67b4c..889f27c31 100644
--- a/src/core/hle/service/olsc/olsc.cpp
+++ b/src/core/hle/service/olsc/olsc.cpp
@@ -8,15 +8,16 @@
 namespace Service::OLSC {
-class OLSC final : public ServiceFramework<OLSC> {
+class IOlscServiceForApplication final : public ServiceFramework<IOlscServiceForApplication> {
 public:
-    explicit OLSC(Core::System& system_) : ServiceFramework{system_, "olsc:u"} {
+    explicit IOlscServiceForApplication(Core::System& system_)
+        : ServiceFramework{system_, "olsc:u"} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, &OLSC::Initialize, "Initialize"},
+            {0, &IOlscServiceForApplication::Initialize, "Initialize"},
            {10, nullptr, "VerifySaveDataBackupLicenseAsync"},
-            {13, &OLSC::GetSaveDataBackupSetting, "GetSaveDataBackupSetting"},
+            {13, &IOlscServiceForApplication::GetSaveDataBackupSetting, "GetSaveDataBackupSetting"},
-            {14, &OLSC::SetSaveDataBackupSettingEnabled, "SetSaveDataBackupSettingEnabled"},
+            {14, &IOlscServiceForApplication::SetSaveDataBackupSettingEnabled, "SetSaveDataBackupSettingEnabled"},
            {15, nullptr, "SetCustomData"},
            {16, nullptr, "DeleteSaveDataBackupSetting"},
            {18, nullptr, "GetSaveDataBackupInfoCache"},
@@ -72,10 +73,155 @@ private:
    bool initialized{};
 };
+class INativeHandleHolder final : public ServiceFramework<INativeHandleHolder> {
+public:
+    explicit INativeHandleHolder(Core::System& system_)
+        : ServiceFramework{system_, "INativeHandleHolder"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetNativeHandle"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+};
+class ITransferTaskListController final : public ServiceFramework<ITransferTaskListController> {
+public:
+    explicit ITransferTaskListController(Core::System& system_)
+        : ServiceFramework{system_, "ITransferTaskListController"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Unknown0"},
+            {1, nullptr, "Unknown1"},
+            {2, nullptr, "Unknown2"},
+            {3, nullptr, "Unknown3"},
+            {4, nullptr, "Unknown4"},
+            {5, &ITransferTaskListController::GetNativeHandleHolder , "GetNativeHandleHolder"},
+            {6, nullptr, "Unknown6"},
+            {7, nullptr, "Unknown7"},
+            {8, nullptr, "GetRemoteStorageController"},
+            {9, &ITransferTaskListController::GetNativeHandleHolder, "GetNativeHandleHolder2"},
+            {10, nullptr, "Unknown10"},
+            {11, nullptr, "Unknown11"},
+            {12, nullptr, "Unknown12"},
+            {13, nullptr, "Unknown13"},
+            {14, nullptr, "Unknown14"},
+            {15, nullptr, "Unknown15"},
+            {16, nullptr, "Unknown16"},
+            {17, nullptr, "Unknown17"},
+            {18, nullptr, "Unknown18"},
+            {19, nullptr, "Unknown19"},
+            {20, nullptr, "Unknown20"},
+            {21, nullptr, "Unknown21"},
+            {22, nullptr, "Unknown22"},
+            {23, nullptr, "Unknown23"},
+            {24, nullptr, "Unknown24"},
+            {25, nullptr, "Unknown25"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+private:
+    void GetNativeHandleHolder(HLERequestContext& ctx) {
+        LOG_INFO(Service_OLSC, "called");
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(ResultSuccess);
+        rb.PushIpcInterface<INativeHandleHolder>(system);
+    }
+};
+class IOlscServiceForSystemService final : public ServiceFramework<IOlscServiceForSystemService> {
+public:
+    explicit IOlscServiceForSystemService(Core::System& system_)
+        : ServiceFramework{system_, "olsc:s"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IOlscServiceForSystemService::OpenTransferTaskListController, "OpenTransferTaskListController"},
+            {1, nullptr, "OpenRemoteStorageController"},
+            {2, nullptr, "OpenDaemonController"},
+            {10, nullptr, "Unknown10"},
+            {11, nullptr, "Unknown11"},
+            {12, nullptr, "Unknown12"},
+            {13, nullptr, "Unknown13"},
+            {100, nullptr, "ListLastTransferTaskErrorInfo"},
+            {101, nullptr, "GetLastErrorInfoCount"},
+            {102, nullptr, "RemoveLastErrorInfoOld"},
+            {103, nullptr, "GetLastErrorInfo"},
+            {104, nullptr, "GetLastErrorEventHolder"},
+            {105, nullptr, "GetLastTransferTaskErrorInfo"},
+            {200, nullptr, "GetDataTransferPolicyInfo"},
+            {201, nullptr, "RemoveDataTransferPolicyInfo"},
+            {202, nullptr, "UpdateDataTransferPolicyOld"},
+            {203, nullptr, "UpdateDataTransferPolicy"},
+            {204, nullptr, "CleanupDataTransferPolicyInfo"},
+            {205, nullptr, "RequestDataTransferPolicy"},
+            {300, nullptr, "GetAutoTransferSeriesInfo"},
+            {301, nullptr, "UpdateAutoTransferSeriesInfo"},
+            {400, nullptr, "CleanupSaveDataArchiveInfoType1"},
+            {900, nullptr, "CleanupTransferTask"},
+            {902, nullptr, "CleanupSeriesInfoType0"},
+            {903, nullptr, "CleanupSaveDataArchiveInfoType0"},
+            {904, nullptr, "CleanupApplicationAutoTransferSetting"},
+            {905, nullptr, "CleanupErrorHistory"},
+            {906, nullptr, "SetLastError"},
+            {907, nullptr, "AddSaveDataArchiveInfoType0"},
+            {908, nullptr, "RemoveSeriesInfoType0"},
+            {909, nullptr, "GetSeriesInfoType0"},
+            {910, nullptr, "RemoveLastErrorInfo"},
+            {911, nullptr, "CleanupSeriesInfoType1"},
+            {912, nullptr, "RemoveSeriesInfoType1"},
+            {913, nullptr, "GetSeriesInfoType1"},
+            {1000, nullptr, "UpdateIssueOld"},
+            {1010, nullptr, "Unknown1010"},
+            {1011, nullptr, "ListIssueInfoOld"},
+            {1012, nullptr, "GetIssueOld"},
+            {1013, nullptr, "GetIssue2Old"},
+            {1014, nullptr, "GetIssue3Old"},
+            {1020, nullptr, "RepairIssueOld"},
+            {1021, nullptr, "RepairIssueWithUserIdOld"},
+            {1022, nullptr, "RepairIssue2Old"},
+            {1023, nullptr, "RepairIssue3Old"},
+            {1024, nullptr, "Unknown1024"},
+            {1100, nullptr, "UpdateIssue"},
+            {1110, nullptr, "Unknown1110"},
+            {1111, nullptr, "ListIssueInfo"},
+            {1112, nullptr, "GetIssue"},
+            {1113, nullptr, "GetIssue2"},
+            {1114, nullptr, "GetIssue3"},
+            {1120, nullptr, "RepairIssue"},
+            {1121, nullptr, "RepairIssueWithUserId"},
+            {1122, nullptr, "RepairIssue2"},
+            {1123, nullptr, "RepairIssue3"},
+            {1124, nullptr, "Unknown1124"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+private:
+    void OpenTransferTaskListController(HLERequestContext& ctx) {
+        LOG_INFO(Service_OLSC, "called");
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(ResultSuccess);
+        rb.PushIpcInterface<ITransferTaskListController>(system);
+    }
+};
 void LoopProcess(Core::System& system) {
    auto server_manager = std::make_unique<ServerManager>(system);
-    server_manager->RegisterNamedService("olsc:u", std::make_shared<OLSC>(system));
+    server_manager->RegisterNamedService("olsc:u",
+                                         std::make_shared<IOlscServiceForApplication>(system));
+    server_manager->RegisterNamedService("olsc:s",
+                                         std::make_shared<IOlscServiceForSystemService>(system));
    ServerManager::RunServer(std::move(server_manager));
 }
diff --git a/src/core/hle/service/pctl/pctl_module.cpp b/src/core/hle/service/pctl/pctl_module.cpp
index f966c5c8b..5db1703d1 100644
--- a/src/core/hle/service/pctl/pctl_module.cpp
+++ b/src/core/hle/service/pctl/pctl_module.cpp
@@ -6,6 +6,7 @@
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/hle/service/ipc_helpers.h"
+#include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/pctl/pctl.h"
 #include "core/hle/service/pctl/pctl_module.h"
 #include "core/hle/service/server_manager.h"
@@ -24,7 +25,8 @@ constexpr Result ResultNoRestrictionEnabled{ErrorModule::PCTL, 181};
 class IParentalControlService final : public ServiceFramework<IParentalControlService> {
 public:
    explicit IParentalControlService(Core::System& system_, Capability capability_)
-        : ServiceFramework{system_, "IParentalControlService"}, capability{capability_} {
+        : ServiceFramework{system_, "IParentalControlService"}, capability{capability_},
+          service_context{system_, "IParentalControlService"} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {1, &IParentalControlService::Initialize, "Initialize"},
@@ -33,7 +35,7 @@ public:
            {1003, nullptr, "ConfirmResumeApplicationPermission"},
            {1004, nullptr, "ConfirmSnsPostPermission"},
            {1005, nullptr, "ConfirmSystemSettingsPermission"},
-            {1006, nullptr, "IsRestrictionTemporaryUnlocked"},
+            {1006, &IParentalControlService::IsRestrictionTemporaryUnlocked, "IsRestrictionTemporaryUnlocked"},
            {1007, nullptr, "RevertRestrictionTemporaryUnlocked"},
            {1008, nullptr, "EnterRestrictedSystemSettings"},
            {1009, nullptr, "LeaveRestrictedSystemSettings"},
@@ -47,14 +49,14 @@ public:
            {1017, &IParentalControlService::EndFreeCommunication, "EndFreeCommunication"},
            {1018, &IParentalControlService::IsFreeCommunicationAvailable, "IsFreeCommunicationAvailable"},
            {1031, &IParentalControlService::IsRestrictionEnabled, "IsRestrictionEnabled"},
-            {1032, nullptr, "GetSafetyLevel"},
+            {1032, &IParentalControlService::GetSafetyLevel, "GetSafetyLevel"},
            {1033, nullptr, "SetSafetyLevel"},
            {1034, nullptr, "GetSafetyLevelSettings"},
-            {1035, nullptr, "GetCurrentSettings"},
+            {1035, &IParentalControlService::GetCurrentSettings, "GetCurrentSettings"},
            {1036, nullptr, "SetCustomSafetyLevelSettings"},
            {1037, nullptr, "GetDefaultRatingOrganization"},
            {1038, nullptr, "SetDefaultRatingOrganization"},
-            {1039, nullptr, "GetFreeCommunicationApplicationListCount"},
+            {1039, &IParentalControlService::GetFreeCommunicationApplicationListCount, "GetFreeCommunicationApplicationListCount"},
            {1042, nullptr, "AddToFreeCommunicationApplicationList"},
            {1043, nullptr, "DeleteSettings"},
            {1044, nullptr, "GetFreeCommunicationApplicationList"},
@@ -76,7 +78,7 @@ public:
            {1206, nullptr, "GetPinCodeLength"},
            {1207, nullptr, "GetPinCodeChangedEvent"},
            {1208, nullptr, "GetPinCode"},
-            {1403, nullptr, "IsPairingActive"},
+            {1403, &IParentalControlService::IsPairingActive, "IsPairingActive"},
            {1406, nullptr, "GetSettingsLastUpdated"},
            {1411, nullptr, "GetPairingAccountInfo"},
            {1421, nullptr, "GetAccountNickname"},
@@ -84,18 +86,18 @@ public:
            {1425, nullptr, "RequestPostEvents"},
            {1426, nullptr, "GetPostEventInterval"},
            {1427, nullptr, "SetPostEventInterval"},
-            {1432, nullptr, "GetSynchronizationEvent"},
+            {1432, &IParentalControlService::GetSynchronizationEvent, "GetSynchronizationEvent"},
            {1451, nullptr, "StartPlayTimer"},
            {1452, nullptr, "StopPlayTimer"},
            {1453, nullptr, "IsPlayTimerEnabled"},
            {1454, nullptr, "GetPlayTimerRemainingTime"},
            {1455, nullptr, "IsRestrictedByPlayTimer"},
-            {1456, nullptr, "GetPlayTimerSettings"},
+            {1456, &IParentalControlService::GetPlayTimerSettings, "GetPlayTimerSettings"},
-            {1457, nullptr, "GetPlayTimerEventToRequestSuspension"},
+            {1457, &IParentalControlService::GetPlayTimerEventToRequestSuspension, "GetPlayTimerEventToRequestSuspension"},
-            {1458, nullptr, "IsPlayTimerAlarmDisabled"},
+            {1458, &IParentalControlService::IsPlayTimerAlarmDisabled, "IsPlayTimerAlarmDisabled"},
            {1471, nullptr, "NotifyWrongPinCodeInputManyTimes"},
            {1472, nullptr, "CancelNetworkRequest"},
-            {1473, nullptr, "GetUnlinkedEvent"},
+            {1473, &IParentalControlService::GetUnlinkedEvent, "GetUnlinkedEvent"},
            {1474, nullptr, "ClearUnlinkedEvent"},
            {1601, nullptr, "DisableAllFeatures"},
            {1602, nullptr, "PostEnableAllFeatures"},
@@ -131,6 +133,12 @@ public:
        };
        // clang-format on
        RegisterHandlers(functions);
+        synchronization_event =
+            service_context.CreateEvent("IParentalControlService::SynchronizationEvent");
+        unlinked_event = service_context.CreateEvent("IParentalControlService::UnlinkedEvent");
+        request_suspension_event =
+            service_context.CreateEvent("IParentalControlService::RequestSuspensionEvent");
    }
 private:
@@ -228,6 +236,17 @@ private:
        states.free_communication = true;
    }
+    void IsRestrictionTemporaryUnlocked(HLERequestContext& ctx) {
+        const bool is_temporary_unlocked = false;
+        LOG_WARNING(Service_PCTL, "(STUBBED) called, is_temporary_unlocked={}",
+                    is_temporary_unlocked);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push<u8>(is_temporary_unlocked);
+    }
    void ConfirmStereoVisionPermission(HLERequestContext& ctx) {
        LOG_DEBUG(Service_PCTL, "called");
        states.stereo_vision = true;
@@ -268,6 +287,34 @@ private:
        rb.Push(pin_code[0] != '\0');
    }
+    void GetSafetyLevel(HLERequestContext& ctx) {
+        const u32 safety_level = 0;
+        LOG_WARNING(Service_PCTL, "(STUBBED) called, safety_level={}", safety_level);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push(safety_level);
+    }
+    void GetCurrentSettings(HLERequestContext& ctx) {
+        LOG_INFO(Service_PCTL, "called");
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.PushRaw(restriction_settings);
+    }
+    void GetFreeCommunicationApplicationListCount(HLERequestContext& ctx) {
+        const u32 count = 4;
+        LOG_WARNING(Service_PCTL, "(STUBBED) called, count={}", count);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push(count);
+    }
    void ConfirmStereoVisionRestrictionConfigurable(HLERequestContext& ctx) {
        LOG_DEBUG(Service_PCTL, "called");
@@ -300,6 +347,61 @@ private:
        }
    }
+    void IsPairingActive(HLERequestContext& ctx) {
+        const bool is_pairing_active = false;
+        LOG_WARNING(Service_PCTL, "(STUBBED) called, is_pairing_active={}", is_pairing_active);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push<u8>(is_pairing_active);
+    }
+    void GetSynchronizationEvent(HLERequestContext& ctx) {
+        LOG_INFO(Service_PCTL, "called");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(ResultSuccess);
+        rb.PushCopyObjects(synchronization_event->GetReadableEvent());
+    }
+    void GetPlayTimerSettings(HLERequestContext& ctx) {
+        LOG_WARNING(Service_PCTL, "(STUBBED) called");
+        const PlayTimerSettings timer_settings{};
+        IPC::ResponseBuilder rb{ctx, 15};
+        rb.Push(ResultSuccess);
+        rb.PushRaw(timer_settings);
+    }
+    void GetPlayTimerEventToRequestSuspension(HLERequestContext& ctx) {
+        LOG_INFO(Service_PCTL, "called");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(ResultSuccess);
+        rb.PushCopyObjects(request_suspension_event->GetReadableEvent());
+    }
+    void IsPlayTimerAlarmDisabled(HLERequestContext& ctx) {
+        const bool is_play_timer_alarm_disabled = false;
+        LOG_INFO(Service_PCTL, "called, is_play_timer_alarm_disabled={}",
+                 is_play_timer_alarm_disabled);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push<u8>(is_play_timer_alarm_disabled);
+    }
+    void GetUnlinkedEvent(HLERequestContext& ctx) {
+        LOG_INFO(Service_PCTL, "called");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(ResultSuccess);
+        rb.PushCopyObjects(unlinked_event->GetReadableEvent());
+    }
    void SetStereoVisionRestriction(HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const auto can_use = rp.Pop<bool>();
@@ -364,10 +466,30 @@ private:
        bool disabled{};
    };
+    // This is nn::pctl::RestrictionSettings
+    struct RestrictionSettings {
+        u8 rating_age;
+        bool sns_post_restriction;
+        bool free_communication_restriction;
+    };
+    static_assert(sizeof(RestrictionSettings) == 0x3, "RestrictionSettings has incorrect size.");
+    // This is nn::pctl::PlayTimerSettings
+    struct PlayTimerSettings {
+        std::array<u32, 13> settings;
+    };
+    static_assert(sizeof(PlayTimerSettings) == 0x34, "PlayTimerSettings has incorrect size.");
    States states{};
    ParentalControlSettings settings{};
+    RestrictionSettings restriction_settings{};
    std::array<char, 8> pin_code{};
    Capability capability{};
+    Kernel::KEvent* synchronization_event;
+    Kernel::KEvent* unlinked_event;
+    Kernel::KEvent* request_suspension_event;
+    KernelHelpers::ServiceContext service_context;
 };
 void Module::Interface::CreateService(HLERequestContext& ctx) {
diff --git a/src/core/hle/service/server_manager.cpp b/src/core/hle/service/server_manager.cpp
index d1e99b184..e2e399534 100644
--- a/src/core/hle/service/server_manager.cpp
+++ b/src/core/hle/service/server_manager.cpp
@@ -102,16 +102,17 @@ Result ServerManager::RegisterNamedService(const std::string& service_name,
        m_system.ServiceManager().RegisterService(service_name, max_sessions, handler)));
    // Get the registered port.
-    auto port = m_system.ServiceManager().GetServicePort(service_name);
+    Kernel::KPort* port{};
-    ASSERT(port.Succeeded());
+    ASSERT(
+        R_SUCCEEDED(m_system.ServiceManager().GetServicePort(std::addressof(port), service_name)));
    // Open a new reference to the server port.
-    (*port)->GetServerPort().Open();
+    port->GetServerPort().Open();
    // Begin tracking the server port.
    {
        std::scoped_lock ll{m_list_mutex};
-        m_ports.emplace(std::addressof((*port)->GetServerPort()), std::move(handler));
+        m_ports.emplace(std::addressof(port->GetServerPort()), std::move(handler));
    }
    // Signal the wakeup event.
diff --git a/src/core/hle/service/set/set.cpp b/src/core/hle/service/set/set.cpp
index 83f888c54..2082b8ef7 100644
--- a/src/core/hle/service/set/set.cpp
+++ b/src/core/hle/service/set/set.cpp
@@ -11,66 +11,6 @@
 namespace Service::Set {
 namespace {
-constexpr std::array<LanguageCode, 18> available_language_codes = {{
-    LanguageCode::JA,
-    LanguageCode::EN_US,
-    LanguageCode::FR,
-    LanguageCode::DE,
-    LanguageCode::IT,
-    LanguageCode::ES,
-    LanguageCode::ZH_CN,
-    LanguageCode::KO,
-    LanguageCode::NL,
-    LanguageCode::PT,
-    LanguageCode::RU,
-    LanguageCode::ZH_TW,
-    LanguageCode::EN_GB,
-    LanguageCode::FR_CA,
-    LanguageCode::ES_419,
-    LanguageCode::ZH_HANS,
-    LanguageCode::ZH_HANT,
-    LanguageCode::PT_BR,
-}};
-enum class KeyboardLayout : u64 {
-    Japanese = 0,
-    EnglishUs = 1,
-    EnglishUsInternational = 2,
-    EnglishUk = 3,
-    French = 4,
-    FrenchCa = 5,
-    Spanish = 6,
-    SpanishLatin = 7,
-    German = 8,
-    Italian = 9,
-    Portuguese = 10,
-    Russian = 11,
-    Korean = 12,
-    ChineseSimplified = 13,
-    ChineseTraditional = 14,
-};
-constexpr std::array<std::pair<LanguageCode, KeyboardLayout>, 18> language_to_layout{{
-    {LanguageCode::JA, KeyboardLayout::Japanese},
-    {LanguageCode::EN_US, KeyboardLayout::EnglishUs},
-    {LanguageCode::FR, KeyboardLayout::French},
-    {LanguageCode::DE, KeyboardLayout::German},
-    {LanguageCode::IT, KeyboardLayout::Italian},
-    {LanguageCode::ES, KeyboardLayout::Spanish},
-    {LanguageCode::ZH_CN, KeyboardLayout::ChineseSimplified},
-    {LanguageCode::KO, KeyboardLayout::Korean},
-    {LanguageCode::NL, KeyboardLayout::EnglishUsInternational},
-    {LanguageCode::PT, KeyboardLayout::Portuguese},
-    {LanguageCode::RU, KeyboardLayout::Russian},
-    {LanguageCode::ZH_TW, KeyboardLayout::ChineseTraditional},
-    {LanguageCode::EN_GB, KeyboardLayout::EnglishUk},
-    {LanguageCode::FR_CA, KeyboardLayout::FrenchCa},
-    {LanguageCode::ES_419, KeyboardLayout::SpanishLatin},
-    {LanguageCode::ZH_HANS, KeyboardLayout::ChineseSimplified},
-    {LanguageCode::ZH_HANT, KeyboardLayout::ChineseTraditional},
-    {LanguageCode::PT_BR, KeyboardLayout::Portuguese},
-}};
 constexpr std::size_t PRE_4_0_0_MAX_ENTRIES = 0xF;
 constexpr std::size_t POST_4_0_0_MAX_ENTRIES = 0x40;
diff --git a/src/core/hle/service/set/set.h b/src/core/hle/service/set/set.h
index 7fd3a7654..b61a3560d 100644
--- a/src/core/hle/service/set/set.h
+++ b/src/core/hle/service/set/set.h
@@ -32,6 +32,67 @@ enum class LanguageCode : u64 {
    ZH_HANT = 0x00746E61482D687A,
    PT_BR = 0x00000052422D7470,
 };
+enum class KeyboardLayout : u64 {
+    Japanese = 0,
+    EnglishUs = 1,
+    EnglishUsInternational = 2,
+    EnglishUk = 3,
+    French = 4,
+    FrenchCa = 5,
+    Spanish = 6,
+    SpanishLatin = 7,
+    German = 8,
+    Italian = 9,
+    Portuguese = 10,
+    Russian = 11,
+    Korean = 12,
+    ChineseSimplified = 13,
+    ChineseTraditional = 14,
+};
+constexpr std::array<LanguageCode, 18> available_language_codes = {{
+    LanguageCode::JA,
+    LanguageCode::EN_US,
+    LanguageCode::FR,
+    LanguageCode::DE,
+    LanguageCode::IT,
+    LanguageCode::ES,
+    LanguageCode::ZH_CN,
+    LanguageCode::KO,
+    LanguageCode::NL,
+    LanguageCode::PT,
+    LanguageCode::RU,
+    LanguageCode::ZH_TW,
+    LanguageCode::EN_GB,
+    LanguageCode::FR_CA,
+    LanguageCode::ES_419,
+    LanguageCode::ZH_HANS,
+    LanguageCode::ZH_HANT,
+    LanguageCode::PT_BR,
+}};
+static constexpr std::array<std::pair<LanguageCode, KeyboardLayout>, 18> language_to_layout{{
+    {LanguageCode::JA, KeyboardLayout::Japanese},
+    {LanguageCode::EN_US, KeyboardLayout::EnglishUs},
+    {LanguageCode::FR, KeyboardLayout::French},
+    {LanguageCode::DE, KeyboardLayout::German},
+    {LanguageCode::IT, KeyboardLayout::Italian},
+    {LanguageCode::ES, KeyboardLayout::Spanish},
+    {LanguageCode::ZH_CN, KeyboardLayout::ChineseSimplified},
+    {LanguageCode::KO, KeyboardLayout::Korean},
+    {LanguageCode::NL, KeyboardLayout::EnglishUsInternational},
+    {LanguageCode::PT, KeyboardLayout::Portuguese},
+    {LanguageCode::RU, KeyboardLayout::Russian},
+    {LanguageCode::ZH_TW, KeyboardLayout::ChineseTraditional},
+    {LanguageCode::EN_GB, KeyboardLayout::EnglishUk},
+    {LanguageCode::FR_CA, KeyboardLayout::FrenchCa},
+    {LanguageCode::ES_419, KeyboardLayout::SpanishLatin},
+    {LanguageCode::ZH_HANS, KeyboardLayout::ChineseSimplified},
+    {LanguageCode::ZH_HANT, KeyboardLayout::ChineseTraditional},
+    {LanguageCode::PT_BR, KeyboardLayout::Portuguese},
+}};
 LanguageCode GetLanguageCodeFromIndex(std::size_t idx);
 class SET final : public ServiceFramework<SET> {
diff --git a/src/core/hle/service/set/set_sys.cpp b/src/core/hle/service/set/set_sys.cpp
index 2e38d1cfc..165b97dad 100644
--- a/src/core/hle/service/set/set_sys.cpp
+++ b/src/core/hle/service/set/set_sys.cpp
@@ -4,10 +4,12 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
+#include "common/string_util.h"
 #include "core/file_sys/errors.h"
 #include "core/file_sys/system_archive/system_version.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/ipc_helpers.h"
+#include "core/hle/service/set/set.h"
 #include "core/hle/service/set/set_sys.h"
 namespace Service::Set {
@@ -73,6 +75,16 @@ void GetFirmwareVersionImpl(HLERequestContext& ctx, GetFirmwareVersionType type)
 }
 } // Anonymous namespace
+void SET_SYS::SetLanguageCode(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    language_code_setting = rp.PopEnum<LanguageCode>();
+    LOG_INFO(Service_SET, "called, language_code={}", language_code_setting);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
 void SET_SYS::GetFirmwareVersion(HLERequestContext& ctx) {
    LOG_DEBUG(Service_SET, "called");
    GetFirmwareVersionImpl(ctx, GetFirmwareVersionType::Version1);
@@ -83,21 +95,113 @@ void SET_SYS::GetFirmwareVersion2(HLERequestContext& ctx) {
    GetFirmwareVersionImpl(ctx, GetFirmwareVersionType::Version2);
 }
+void SET_SYS::GetAccountSettings(HLERequestContext& ctx) {
+    LOG_INFO(Service_SET, "called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(account_settings);
+}
+void SET_SYS::SetAccountSettings(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    account_settings = rp.PopRaw<AccountSettings>();
+    LOG_INFO(Service_SET, "called, account_settings_flags={}", account_settings.flags);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void SET_SYS::GetEulaVersions(HLERequestContext& ctx) {
+    LOG_INFO(Service_SET, "called");
+    ctx.WriteBuffer(eula_versions);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(static_cast<u32>(eula_versions.size()));
+}
+void SET_SYS::SetEulaVersions(HLERequestContext& ctx) {
+    const auto elements = ctx.GetReadBufferNumElements<EulaVersion>();
+    const auto buffer_data = ctx.ReadBuffer();
+    LOG_INFO(Service_SET, "called, elements={}", elements);
+    eula_versions.resize(elements);
+    for (std::size_t index = 0; index < elements; index++) {
+        const std::size_t start_index = index * sizeof(EulaVersion);
+        memcpy(eula_versions.data() + start_index, buffer_data.data() + start_index,
+               sizeof(EulaVersion));
+    }
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
 void SET_SYS::GetColorSetId(HLERequestContext& ctx) {
    LOG_DEBUG(Service_SET, "called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(ResultSuccess);
    rb.PushEnum(color_set);
 }
 void SET_SYS::SetColorSetId(HLERequestContext& ctx) {
-    LOG_DEBUG(Service_SET, "called");
    IPC::RequestParser rp{ctx};
    color_set = rp.PopEnum<ColorSet>();
+    LOG_DEBUG(Service_SET, "called, color_set={}", color_set);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void SET_SYS::GetNotificationSettings(HLERequestContext& ctx) {
+    LOG_INFO(Service_SET, "called");
+    IPC::ResponseBuilder rb{ctx, 8};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(notification_settings);
+}
+void SET_SYS::SetNotificationSettings(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    notification_settings = rp.PopRaw<NotificationSettings>();
+    LOG_INFO(Service_SET, "called, flags={}, volume={}, head_time={}:{}, tailt_time={}:{}",
+             notification_settings.flags.raw, notification_settings.volume,
+             notification_settings.start_time.hour, notification_settings.start_time.minute,
+             notification_settings.stop_time.hour, notification_settings.stop_time.minute);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void SET_SYS::GetAccountNotificationSettings(HLERequestContext& ctx) {
+    LOG_INFO(Service_SET, "called");
+    ctx.WriteBuffer(account_notifications);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(static_cast<u32>(account_notifications.size()));
+}
+void SET_SYS::SetAccountNotificationSettings(HLERequestContext& ctx) {
+    const auto elements = ctx.GetReadBufferNumElements<AccountNotificationSettings>();
+    const auto buffer_data = ctx.ReadBuffer();
+    LOG_INFO(Service_SET, "called, elements={}", elements);
+    account_notifications.resize(elements);
+    for (std::size_t index = 0; index < elements; index++) {
+        const std::size_t start_index = index * sizeof(AccountNotificationSettings);
+        memcpy(account_notifications.data() + start_index, buffer_data.data() + start_index,
+               sizeof(AccountNotificationSettings));
+    }
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(ResultSuccess);
 }
@@ -177,17 +281,218 @@ void SET_SYS::GetSettingsItemValue(HLERequestContext& ctx) {
    rb.Push(response);
 }
+void SET_SYS::GetTvSettings(HLERequestContext& ctx) {
+    LOG_INFO(Service_SET, "called");
+    IPC::ResponseBuilder rb{ctx, 10};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(tv_settings);
+}
+void SET_SYS::SetTvSettings(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    tv_settings = rp.PopRaw<TvSettings>();
+    LOG_INFO(Service_SET,
+             "called, flags={}, cmu_mode={}, constrast_ratio={}, hdmi_content_type={}, "
+             "rgb_range={}, tv_gama={}, tv_resolution={}, tv_underscan={}",
+             tv_settings.flags.raw, tv_settings.cmu_mode, tv_settings.constrast_ratio,
+             tv_settings.hdmi_content_type, tv_settings.rgb_range, tv_settings.tv_gama,
+             tv_settings.tv_resolution, tv_settings.tv_underscan);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void SET_SYS::GetQuestFlag(HLERequestContext& ctx) {
+    LOG_WARNING(Service_SET, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(QuestFlag::Retail);
+}
+void SET_SYS::SetRegionCode(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    region_code = rp.PopEnum<RegionCode>();
+    LOG_INFO(Service_SET, "called, region_code={}", region_code);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void SET_SYS::GetPrimaryAlbumStorage(HLERequestContext& ctx) {
+    LOG_WARNING(Service_SET, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(PrimaryAlbumStorage::SdCard);
+}
+void SET_SYS::GetSleepSettings(HLERequestContext& ctx) {
+    LOG_INFO(Service_SET, "called");
+    IPC::ResponseBuilder rb{ctx, 5};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(sleep_settings);
+}
+void SET_SYS::SetSleepSettings(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    sleep_settings = rp.PopRaw<SleepSettings>();
+    LOG_INFO(Service_SET, "called, flags={}, handheld_sleep_plan={}, console_sleep_plan={}",
+             sleep_settings.flags.raw, sleep_settings.handheld_sleep_plan,
+             sleep_settings.console_sleep_plan);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void SET_SYS::GetInitialLaunchSettings(HLERequestContext& ctx) {
+    LOG_INFO(Service_SET, "called");
+    IPC::ResponseBuilder rb{ctx, 10};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(launch_settings);
+}
+void SET_SYS::SetInitialLaunchSettings(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    launch_settings = rp.PopRaw<InitialLaunchSettings>();
+    LOG_INFO(Service_SET, "called, flags={}, timestamp={}", launch_settings.flags.raw,
+             launch_settings.timestamp.time_point);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
 void SET_SYS::GetDeviceNickName(HLERequestContext& ctx) {
    LOG_DEBUG(Service_SET, "called");
+    ctx.WriteBuffer(::Settings::values.device_name.GetValue());
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(ResultSuccess);
-    ctx.WriteBuffer(::Settings::values.device_name.GetValue());
+}
+void SET_SYS::SetDeviceNickName(HLERequestContext& ctx) {
+    const std::string device_name = Common::StringFromBuffer(ctx.ReadBuffer());
+    LOG_INFO(Service_SET, "called, device_name={}", device_name);
+    ::Settings::values.device_name = device_name;
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void SET_SYS::GetProductModel(HLERequestContext& ctx) {
+    const u32 product_model = 1;
+    LOG_WARNING(Service_SET, "(STUBBED) called, product_model={}", product_model);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(product_model);
+}
+void SET_SYS::GetMiiAuthorId(HLERequestContext& ctx) {
+    const auto author_id = Common::UUID::MakeDefault();
+    LOG_WARNING(Service_SET, "(STUBBED) called, author_id={}", author_id.FormattedString());
+    IPC::ResponseBuilder rb{ctx, 6};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(author_id);
+}
+void SET_SYS::GetAutoUpdateEnableFlag(HLERequestContext& ctx) {
+    u8 auto_update_flag{};
+    LOG_WARNING(Service_SET, "(STUBBED) called, auto_update_flag={}", auto_update_flag);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(auto_update_flag);
+}
+void SET_SYS::GetBatteryPercentageFlag(HLERequestContext& ctx) {
+    u8 battery_percentage_flag{1};
+    LOG_WARNING(Service_SET, "(STUBBED) called, battery_percentage_flag={}",
+                battery_percentage_flag);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(battery_percentage_flag);
+}
+void SET_SYS::GetErrorReportSharePermission(HLERequestContext& ctx) {
+    LOG_WARNING(Service_SET, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(ErrorReportSharePermission::Denied);
+}
+void SET_SYS::GetAppletLaunchFlags(HLERequestContext& ctx) {
+    LOG_INFO(Service_SET, "called, applet_launch_flag={}", applet_launch_flag);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(applet_launch_flag);
+}
+void SET_SYS::SetAppletLaunchFlags(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    applet_launch_flag = rp.Pop<u32>();
+    LOG_INFO(Service_SET, "called, applet_launch_flag={}", applet_launch_flag);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void SET_SYS::GetKeyboardLayout(HLERequestContext& ctx) {
+    const auto language_code =
+        available_language_codes[static_cast<s32>(::Settings::values.language_index.GetValue())];
+    const auto key_code =
+        std::find_if(language_to_layout.cbegin(), language_to_layout.cend(),
+                     [=](const auto& element) { return element.first == language_code; });
+    KeyboardLayout selected_keyboard_layout = KeyboardLayout::EnglishUs;
+    if (key_code != language_to_layout.end()) {
+        selected_keyboard_layout = key_code->second;
+    }
+    LOG_INFO(Service_SET, "called, selected_keyboard_layout={}", selected_keyboard_layout);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(static_cast<u32>(selected_keyboard_layout));
+}
+void SET_SYS::GetChineseTraditionalInputMethod(HLERequestContext& ctx) {
+    LOG_WARNING(Service_SET, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(ChineseTraditionalInputMethod::Unknown0);
+}
+void SET_SYS::GetFieldTestingFlag(HLERequestContext& ctx) {
+    LOG_WARNING(Service_SET, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push<u8>(false);
 }
 SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
    // clang-format off
    static const FunctionInfo functions[] = {
-        {0, nullptr, "SetLanguageCode"},
+        {0, &SET_SYS::SetLanguageCode, "SetLanguageCode"},
        {1, nullptr, "SetNetworkSettings"},
        {2, nullptr, "GetNetworkSettings"},
        {3, &SET_SYS::GetFirmwareVersion, "GetFirmwareVersion"},
@@ -203,35 +508,35 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
        {14, nullptr, "SetExternalSteadyClockSourceId"},
        {15, nullptr, "GetUserSystemClockContext"},
        {16, nullptr, "SetUserSystemClockContext"},
-        {17, nullptr, "GetAccountSettings"},
+        {17, &SET_SYS::GetAccountSettings, "GetAccountSettings"},
-        {18, nullptr, "SetAccountSettings"},
+        {18, &SET_SYS::SetAccountSettings, "SetAccountSettings"},
        {19, nullptr, "GetAudioVolume"},
        {20, nullptr, "SetAudioVolume"},
-        {21, nullptr, "GetEulaVersions"},
+        {21, &SET_SYS::GetEulaVersions, "GetEulaVersions"},
-        {22, nullptr, "SetEulaVersions"},
+        {22, &SET_SYS::SetEulaVersions, "SetEulaVersions"},
        {23, &SET_SYS::GetColorSetId, "GetColorSetId"},
        {24, &SET_SYS::SetColorSetId, "SetColorSetId"},
        {25, nullptr, "GetConsoleInformationUploadFlag"},
        {26, nullptr, "SetConsoleInformationUploadFlag"},
        {27, nullptr, "GetAutomaticApplicationDownloadFlag"},
        {28, nullptr, "SetAutomaticApplicationDownloadFlag"},
-        {29, nullptr, "GetNotificationSettings"},
+        {29, &SET_SYS::GetNotificationSettings, "GetNotificationSettings"},
-        {30, nullptr, "SetNotificationSettings"},
+        {30, &SET_SYS::SetNotificationSettings, "SetNotificationSettings"},
-        {31, nullptr, "GetAccountNotificationSettings"},
+        {31, &SET_SYS::GetAccountNotificationSettings, "GetAccountNotificationSettings"},
-        {32, nullptr, "SetAccountNotificationSettings"},
+        {32, &SET_SYS::SetAccountNotificationSettings, "SetAccountNotificationSettings"},
        {35, nullptr, "GetVibrationMasterVolume"},
        {36, nullptr, "SetVibrationMasterVolume"},
        {37, &SET_SYS::GetSettingsItemValueSize, "GetSettingsItemValueSize"},
        {38, &SET_SYS::GetSettingsItemValue, "GetSettingsItemValue"},
-        {39, nullptr, "GetTvSettings"},
+        {39, &SET_SYS::GetTvSettings, "GetTvSettings"},
-        {40, nullptr, "SetTvSettings"},
+        {40, &SET_SYS::SetTvSettings, "SetTvSettings"},
        {41, nullptr, "GetEdid"},
        {42, nullptr, "SetEdid"},
        {43, nullptr, "GetAudioOutputMode"},
        {44, nullptr, "SetAudioOutputMode"},
        {45, nullptr, "IsForceMuteOnHeadphoneRemoved"},
        {46, nullptr, "SetForceMuteOnHeadphoneRemoved"},
-        {47, nullptr, "GetQuestFlag"},
+        {47, &SET_SYS::GetQuestFlag, "GetQuestFlag"},
        {48, nullptr, "SetQuestFlag"},
        {49, nullptr, "GetDataDeletionSettings"},
        {50, nullptr, "SetDataDeletionSettings"},
@@ -241,13 +546,13 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
        {54, nullptr, "SetDeviceTimeZoneLocationName"},
        {55, nullptr, "GetWirelessCertificationFileSize"},
        {56, nullptr, "GetWirelessCertificationFile"},
-        {57, nullptr, "SetRegionCode"},
+        {57, &SET_SYS::SetRegionCode, "SetRegionCode"},
        {58, nullptr, "GetNetworkSystemClockContext"},
        {59, nullptr, "SetNetworkSystemClockContext"},
        {60, nullptr, "IsUserSystemClockAutomaticCorrectionEnabled"},
        {61, nullptr, "SetUserSystemClockAutomaticCorrectionEnabled"},
        {62, nullptr, "GetDebugModeFlag"},
-        {63, nullptr, "GetPrimaryAlbumStorage"},
+        {63, &SET_SYS::GetPrimaryAlbumStorage, "GetPrimaryAlbumStorage"},
        {64, nullptr, "SetPrimaryAlbumStorage"},
        {65, nullptr, "GetUsb30EnableFlag"},
        {66, nullptr, "SetUsb30EnableFlag"},
@@ -255,15 +560,15 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
        {68, nullptr, "GetSerialNumber"},
        {69, nullptr, "GetNfcEnableFlag"},
        {70, nullptr, "SetNfcEnableFlag"},
-        {71, nullptr, "GetSleepSettings"},
+        {71, &SET_SYS::GetSleepSettings, "GetSleepSettings"},
-        {72, nullptr, "SetSleepSettings"},
+        {72, &SET_SYS::SetSleepSettings, "SetSleepSettings"},
        {73, nullptr, "GetWirelessLanEnableFlag"},
        {74, nullptr, "SetWirelessLanEnableFlag"},
-        {75, nullptr, "GetInitialLaunchSettings"},
+        {75, &SET_SYS::GetInitialLaunchSettings, "GetInitialLaunchSettings"},
-        {76, nullptr, "SetInitialLaunchSettings"},
+        {76, &SET_SYS::SetInitialLaunchSettings, "SetInitialLaunchSettings"},
        {77, &SET_SYS::GetDeviceNickName, "GetDeviceNickName"},
-        {78, nullptr, "SetDeviceNickName"},
+        {78, &SET_SYS::SetDeviceNickName, "SetDeviceNickName"},
-        {79, nullptr, "GetProductModel"},
+        {79, &SET_SYS::GetProductModel, "GetProductModel"},
        {80, nullptr, "GetLdnChannel"},
        {81, nullptr, "SetLdnChannel"},
        {82, nullptr, "AcquireTelemetryDirtyFlagEventHandle"},
@@ -274,16 +579,16 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
        {87, nullptr, "SetPtmFuelGaugeParameter"},
        {88, nullptr, "GetBluetoothEnableFlag"},
        {89, nullptr, "SetBluetoothEnableFlag"},
-        {90, nullptr, "GetMiiAuthorId"},
+        {90, &SET_SYS::GetMiiAuthorId, "GetMiiAuthorId"},
        {91, nullptr, "SetShutdownRtcValue"},
        {92, nullptr, "GetShutdownRtcValue"},
        {93, nullptr, "AcquireFatalDirtyFlagEventHandle"},
        {94, nullptr, "GetFatalDirtyFlags"},
-        {95, nullptr, "GetAutoUpdateEnableFlag"},
+        {95, &SET_SYS::GetAutoUpdateEnableFlag, "GetAutoUpdateEnableFlag"},
        {96, nullptr, "SetAutoUpdateEnableFlag"},
        {97, nullptr, "GetNxControllerSettings"},
        {98, nullptr, "SetNxControllerSettings"},
-        {99, nullptr, "GetBatteryPercentageFlag"},
+        {99, &SET_SYS::GetBatteryPercentageFlag, "GetBatteryPercentageFlag"},
        {100, nullptr, "SetBatteryPercentageFlag"},
        {101, nullptr, "GetExternalRtcResetFlag"},
        {102, nullptr, "SetExternalRtcResetFlag"},
@@ -308,10 +613,10 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
        {121, nullptr, "SetPushNotificationActivityModeOnSleep"},
        {122, nullptr, "GetServiceDiscoveryControlSettings"},
        {123, nullptr, "SetServiceDiscoveryControlSettings"},
-        {124, nullptr, "GetErrorReportSharePermission"},
+        {124, &SET_SYS::GetErrorReportSharePermission, "GetErrorReportSharePermission"},
        {125, nullptr, "SetErrorReportSharePermission"},
-        {126, nullptr, "GetAppletLaunchFlags"},
+        {126, &SET_SYS::GetAppletLaunchFlags, "GetAppletLaunchFlags"},
-        {127, nullptr, "SetAppletLaunchFlags"},
+        {127, &SET_SYS::SetAppletLaunchFlags, "SetAppletLaunchFlags"},
        {128, nullptr, "GetConsoleSixAxisSensorAccelerationBias"},
        {129, nullptr, "SetConsoleSixAxisSensorAccelerationBias"},
        {130, nullptr, "GetConsoleSixAxisSensorAngularVelocityBias"},
@@ -320,7 +625,7 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
        {133, nullptr, "SetConsoleSixAxisSensorAccelerationGain"},
        {134, nullptr, "GetConsoleSixAxisSensorAngularVelocityGain"},
        {135, nullptr, "SetConsoleSixAxisSensorAngularVelocityGain"},
-        {136, nullptr, "GetKeyboardLayout"},
+        {136, &SET_SYS::GetKeyboardLayout, "GetKeyboardLayout"},
        {137, nullptr, "SetKeyboardLayout"},
        {138, nullptr, "GetWebInspectorFlag"},
        {139, nullptr, "GetAllowedSslHosts"},
@@ -354,7 +659,7 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
        {167, nullptr, "SetUsb30DeviceEnableFlag"},
        {168, nullptr, "GetThemeId"},
        {169, nullptr, "SetThemeId"},
-        {170, nullptr, "GetChineseTraditionalInputMethod"},
+        {170, &SET_SYS::GetChineseTraditionalInputMethod, "GetChineseTraditionalInputMethod"},
        {171, nullptr, "SetChineseTraditionalInputMethod"},
        {172, nullptr, "GetPtmCycleCountReliability"},
        {173, nullptr, "SetPtmCycleCountReliability"},
@@ -385,12 +690,16 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
        {198, nullptr, "SetButtonConfigRegisteredSettingsEmbedded"},
        {199, nullptr, "GetButtonConfigRegisteredSettings"},
        {200, nullptr, "SetButtonConfigRegisteredSettings"},
-        {201, nullptr, "GetFieldTestingFlag"},
+        {201, &SET_SYS::GetFieldTestingFlag, "GetFieldTestingFlag"},
        {202, nullptr, "SetFieldTestingFlag"},
        {203, nullptr, "GetPanelCrcMode"},
        {204, nullptr, "SetPanelCrcMode"},
        {205, nullptr, "GetNxControllerSettingsEx"},
        {206, nullptr, "SetNxControllerSettingsEx"},
+        {207, nullptr, "GetHearingProtectionSafeguardFlag"},
+        {208, nullptr, "SetHearingProtectionSafeguardFlag"},
+        {209, nullptr, "GetHearingProtectionSafeguardRemainingTime"},
+        {210, nullptr, "SetHearingProtectionSafeguardRemainingTime"},
    };
    // clang-format on
diff --git a/src/core/hle/service/set/set_sys.h b/src/core/hle/service/set/set_sys.h
index 1efbcc97a..c7dba2a9e 100644
--- a/src/core/hle/service/set/set_sys.h
+++ b/src/core/hle/service/set/set_sys.h
@@ -3,7 +3,9 @@
 #pragma once
+#include "common/uuid.h"
 #include "core/hle/service/service.h"
+#include "core/hle/service/time/clock_types.h"
 namespace Core {
 class System;
@@ -23,15 +25,331 @@ private:
        BasicBlack = 1,
    };
-    void GetSettingsItemValueSize(HLERequestContext& ctx);
+    /// Indicates the current console is a retail or kiosk unit
-    void GetSettingsItemValue(HLERequestContext& ctx);
+    enum class QuestFlag : u8 {
+        Retail = 0,
+        Kiosk = 1,
+    };
+    /// This is nn::settings::system::TvResolution
+    enum class TvResolution : u32 {
+        Auto,
+        Resolution1080p,
+        Resolution720p,
+        Resolution480p,
+    };
+    /// This is nn::settings::system::HdmiContentType
+    enum class HdmiContentType : u32 {
+        None,
+        Graphics,
+        Cinema,
+        Photo,
+        Game,
+    };
+    /// This is nn::settings::system::RgbRange
+    enum class RgbRange : u32 {
+        Auto,
+        Full,
+        Limited,
+    };
+    /// This is nn::settings::system::CmuMode
+    enum class CmuMode : u32 {
+        None,
+        ColorInvert,
+        HighContrast,
+        GrayScale,
+    };
+    /// This is nn::settings::system::PrimaryAlbumStorage
+    enum class PrimaryAlbumStorage : u32 {
+        Nand,
+        SdCard,
+    };
+    /// This is nn::settings::system::NotificationVolume
+    enum class NotificationVolume : u32 {
+        Mute,
+        Low,
+        High,
+    };
+    /// This is nn::settings::system::ChineseTraditionalInputMethod
+    enum class ChineseTraditionalInputMethod : u32 {
+        Unknown0 = 0,
+        Unknown1 = 1,
+        Unknown2 = 2,
+    };
+    /// This is nn::settings::system::ErrorReportSharePermission
+    enum class ErrorReportSharePermission : u32 {
+        NotConfirmed,
+        Granted,
+        Denied,
+    };
+    /// This is nn::settings::system::FriendPresenceOverlayPermission
+    enum class FriendPresenceOverlayPermission : u8 {
+        NotConfirmed,
+        NoDisplay,
+        FavoriteFriends,
+        Friends,
+    };
+    /// This is nn::settings::system::HandheldSleepPlan
+    enum class HandheldSleepPlan : u32 {
+        Sleep1Min,
+        Sleep3Min,
+        Sleep5Min,
+        Sleep10Min,
+        Sleep30Min,
+        Never,
+    };
+    /// This is nn::settings::system::ConsoleSleepPlan
+    enum class ConsoleSleepPlan : u32 {
+        Sleep1Hour,
+        Sleep2Hour,
+        Sleep3Hour,
+        Sleep6Hour,
+        Sleep12Hour,
+        Never,
+    };
+    /// This is nn::settings::system::RegionCode
+    enum class RegionCode : u32 {
+        Japan,
+        Usa,
+        Europe,
+        Australia,
+        HongKongTaiwanKorea,
+        China,
+    };
+    /// This is nn::settings::system::EulaVersionClockType
+    enum class EulaVersionClockType : u32 {
+        NetworkSystemClock,
+        SteadyClock,
+    };
+    /// This is nn::settings::system::SleepFlag
+    struct SleepFlag {
+        union {
+            u32 raw{};
+            BitField<0, 1, u32> SleepsWhilePlayingMedia;
+            BitField<1, 1, u32> WakesAtPowerStateChange;
+        };
+    };
+    static_assert(sizeof(SleepFlag) == 4, "TvFlag is an invalid size");
+    /// This is nn::settings::system::TvFlag
+    struct TvFlag {
+        union {
+            u32 raw{};
+            BitField<0, 1, u32> Allows4k;
+            BitField<1, 1, u32> Allows3d;
+            BitField<2, 1, u32> AllowsCec;
+            BitField<3, 1, u32> PreventsScreenBurnIn;
+        };
+    };
+    static_assert(sizeof(TvFlag) == 4, "TvFlag is an invalid size");
+    /// This is nn::settings::system::InitialLaunchFlag
+    struct InitialLaunchFlag {
+        union {
+            u32 raw{};
+            BitField<0, 1, u32> InitialLaunchCompletionFlag;
+            BitField<8, 1, u32> InitialLaunchUserAdditionFlag;
+            BitField<16, 1, u32> InitialLaunchTimestampFlag;
+        };
+    };
+    static_assert(sizeof(InitialLaunchFlag) == 4, "InitialLaunchFlag is an invalid size");
+    /// This is nn::settings::system::NotificationFlag
+    struct NotificationFlag {
+        union {
+            u32 raw{};
+            BitField<0, 1, u32> RingtoneFlag;
+            BitField<1, 1, u32> DownloadCompletionFlag;
+            BitField<8, 1, u32> EnablesNews;
+            BitField<9, 1, u32> IncomingLampFlag;
+        };
+    };
+    static_assert(sizeof(NotificationFlag) == 4, "NotificationFlag is an invalid size");
+    /// This is nn::settings::system::AccountNotificationFlag
+    struct AccountNotificationFlag {
+        union {
+            u32 raw{};
+            BitField<0, 1, u32> FriendOnlineFlag;
+            BitField<1, 1, u32> FriendRequestFlag;
+            BitField<8, 1, u32> CoralInvitationFlag;
+        };
+    };
+    static_assert(sizeof(AccountNotificationFlag) == 4,
+                  "AccountNotificationFlag is an invalid size");
+    /// This is nn::settings::system::TvSettings
+    struct TvSettings {
+        TvFlag flags;
+        TvResolution tv_resolution;
+        HdmiContentType hdmi_content_type;
+        RgbRange rgb_range;
+        CmuMode cmu_mode;
+        u32 tv_underscan;
+        f32 tv_gama;
+        f32 constrast_ratio;
+    };
+    static_assert(sizeof(TvSettings) == 0x20, "TvSettings is an invalid size");
+    /// This is nn::settings::system::NotificationTime
+    struct NotificationTime {
+        u32 hour;
+        u32 minute;
+    };
+    static_assert(sizeof(NotificationTime) == 0x8, "NotificationTime is an invalid size");
+    /// This is nn::settings::system::NotificationSettings
+    struct NotificationSettings {
+        NotificationFlag flags;
+        NotificationVolume volume;
+        NotificationTime start_time;
+        NotificationTime stop_time;
+    };
+    static_assert(sizeof(NotificationSettings) == 0x18, "NotificationSettings is an invalid size");
+    /// This is nn::settings::system::AccountSettings
+    struct AccountSettings {
+        u32 flags;
+    };
+    static_assert(sizeof(AccountSettings) == 0x4, "AccountSettings is an invalid size");
+    /// This is nn::settings::system::AccountNotificationSettings
+    struct AccountNotificationSettings {
+        Common::UUID uid;
+        AccountNotificationFlag flags;
+        FriendPresenceOverlayPermission friend_presence_permission;
+        FriendPresenceOverlayPermission friend_invitation_permission;
+        INSERT_PADDING_BYTES(0x2);
+    };
+    static_assert(sizeof(AccountNotificationSettings) == 0x18,
+                  "AccountNotificationSettings is an invalid size");
+    /// This is nn::settings::system::InitialLaunchSettings
+    struct SleepSettings {
+        SleepFlag flags;
+        HandheldSleepPlan handheld_sleep_plan;
+        ConsoleSleepPlan console_sleep_plan;
+    };
+    static_assert(sizeof(SleepSettings) == 0xc, "SleepSettings is incorrect size");
+    /// This is nn::settings::system::InitialLaunchSettings
+    struct InitialLaunchSettings {
+        InitialLaunchFlag flags;
+        INSERT_PADDING_BYTES(0x4);
+        Time::Clock::SteadyClockTimePoint timestamp;
+    };
+    static_assert(sizeof(InitialLaunchSettings) == 0x20, "InitialLaunchSettings is incorrect size");
+    /// This is nn::settings::system::InitialLaunchSettings
+    struct EulaVersion {
+        u32 version;
+        RegionCode region_code;
+        EulaVersionClockType clock_type;
+        INSERT_PADDING_BYTES(0x4);
+        s64 posix_time;
+        Time::Clock::SteadyClockTimePoint timestamp;
+    };
+    static_assert(sizeof(EulaVersion) == 0x30, "EulaVersion is incorrect size");
+    void SetLanguageCode(HLERequestContext& ctx);
    void GetFirmwareVersion(HLERequestContext& ctx);
    void GetFirmwareVersion2(HLERequestContext& ctx);
+    void GetAccountSettings(HLERequestContext& ctx);
+    void SetAccountSettings(HLERequestContext& ctx);
+    void GetEulaVersions(HLERequestContext& ctx);
+    void SetEulaVersions(HLERequestContext& ctx);
    void GetColorSetId(HLERequestContext& ctx);
    void SetColorSetId(HLERequestContext& ctx);
+    void GetNotificationSettings(HLERequestContext& ctx);
+    void SetNotificationSettings(HLERequestContext& ctx);
+    void GetAccountNotificationSettings(HLERequestContext& ctx);
+    void SetAccountNotificationSettings(HLERequestContext& ctx);
+    void GetSettingsItemValueSize(HLERequestContext& ctx);
+    void GetSettingsItemValue(HLERequestContext& ctx);
+    void GetTvSettings(HLERequestContext& ctx);
+    void SetTvSettings(HLERequestContext& ctx);
+    void GetQuestFlag(HLERequestContext& ctx);
+    void SetRegionCode(HLERequestContext& ctx);
+    void GetPrimaryAlbumStorage(HLERequestContext& ctx);
+    void GetSleepSettings(HLERequestContext& ctx);
+    void SetSleepSettings(HLERequestContext& ctx);
+    void GetInitialLaunchSettings(HLERequestContext& ctx);
+    void SetInitialLaunchSettings(HLERequestContext& ctx);
    void GetDeviceNickName(HLERequestContext& ctx);
+    void SetDeviceNickName(HLERequestContext& ctx);
+    void GetProductModel(HLERequestContext& ctx);
+    void GetMiiAuthorId(HLERequestContext& ctx);
+    void GetAutoUpdateEnableFlag(HLERequestContext& ctx);
+    void GetBatteryPercentageFlag(HLERequestContext& ctx);
+    void GetErrorReportSharePermission(HLERequestContext& ctx);
+    void GetAppletLaunchFlags(HLERequestContext& ctx);
+    void SetAppletLaunchFlags(HLERequestContext& ctx);
+    void GetKeyboardLayout(HLERequestContext& ctx);
+    void GetChineseTraditionalInputMethod(HLERequestContext& ctx);
+    void GetFieldTestingFlag(HLERequestContext& ctx);
+    AccountSettings account_settings{
+        .flags = {},
+    };
    ColorSet color_set = ColorSet::BasicWhite;
+    NotificationSettings notification_settings{
+        .flags = {0x300},
+        .volume = NotificationVolume::High,
+        .start_time = {.hour = 9, .minute = 0},
+        .stop_time = {.hour = 21, .minute = 0},
+    };
+    std::vector<AccountNotificationSettings> account_notifications{};
+    TvSettings tv_settings{
+        .flags = {0xc},
+        .tv_resolution = TvResolution::Auto,
+        .hdmi_content_type = HdmiContentType::Game,
+        .rgb_range = RgbRange::Auto,
+        .cmu_mode = CmuMode::None,
+        .tv_underscan = {},
+        .tv_gama = 1.0f,
+        .constrast_ratio = 0.5f,
+    };
+    InitialLaunchSettings launch_settings{
+        .flags = {0x10001},
+        .timestamp = {},
+    };
+    SleepSettings sleep_settings{
+        .flags = {0x3},
+        .handheld_sleep_plan = HandheldSleepPlan::Sleep10Min,
+        .console_sleep_plan = ConsoleSleepPlan::Sleep1Hour,
+    };
+    u32 applet_launch_flag{};
+    std::vector<EulaVersion> eula_versions{};
+    RegionCode region_code;
+    LanguageCode language_code_setting;
 };
 } // namespace Service::Set
diff --git a/src/core/hle/service/sm/sm.cpp b/src/core/hle/service/sm/sm.cpp
index 1608fa24c..9ab718e0a 100644
--- a/src/core/hle/service/sm/sm.cpp
+++ b/src/core/hle/service/sm/sm.cpp
@@ -52,8 +52,7 @@ static Result ValidateServiceName(const std::string& name) {
 Result ServiceManager::RegisterService(std::string name, u32 max_sessions,
                                       SessionRequestHandlerPtr handler) {
+    R_TRY(ValidateServiceName(name));
-    CASCADE_CODE(ValidateServiceName(name));
    std::scoped_lock lk{lock};
    if (registered_services.find(name) != registered_services.end()) {
@@ -77,7 +76,7 @@ Result ServiceManager::RegisterService(std::string name, u32 max_sessions,
 }
 Result ServiceManager::UnregisterService(const std::string& name) {
-    CASCADE_CODE(ValidateServiceName(name));
+    R_TRY(ValidateServiceName(name));
    std::scoped_lock lk{lock};
    const auto iter = registered_services.find(name);
@@ -92,8 +91,8 @@ Result ServiceManager::UnregisterService(const std::string& name) {
    return ResultSuccess;
 }
-ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name) {
+Result ServiceManager::GetServicePort(Kernel::KPort** out_port, const std::string& name) {
-    CASCADE_CODE(ValidateServiceName(name));
+    R_TRY(ValidateServiceName(name));
    std::scoped_lock lk{lock};
    auto it = service_ports.find(name);
@@ -102,7 +101,8 @@ ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name
        return Service::SM::ResultNotRegistered;
    }
-    return it->second;
+    *out_port = it->second;
+    return ResultSuccess;
 }
 /**
@@ -122,32 +122,34 @@ void SM::Initialize(HLERequestContext& ctx) {
 }
 void SM::GetService(HLERequestContext& ctx) {
-    auto result = GetServiceImpl(ctx);
+    Kernel::KClientSession* client_session{};
+    auto result = GetServiceImpl(&client_session, ctx);
    if (ctx.GetIsDeferred()) {
        // Don't overwrite the command buffer.
        return;
    }
-    if (result.Succeeded()) {
+    if (result == ResultSuccess) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
-        rb.Push(result.Code());
+        rb.Push(result);
-        rb.PushMoveObjects(result.Unwrap());
+        rb.PushMoveObjects(client_session);
    } else {
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result.Code());
+        rb.Push(result);
    }
 }
 void SM::GetServiceTipc(HLERequestContext& ctx) {
-    auto result = GetServiceImpl(ctx);
+    Kernel::KClientSession* client_session{};
+    auto result = GetServiceImpl(&client_session, ctx);
    if (ctx.GetIsDeferred()) {
        // Don't overwrite the command buffer.
        return;
    }
    IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
-    rb.Push(result.Code());
+    rb.Push(result);
-    rb.PushMoveObjects(result.Succeeded() ? result.Unwrap() : nullptr);
+    rb.PushMoveObjects(result == ResultSuccess ? client_session : nullptr);
 }
 static std::string PopServiceName(IPC::RequestParser& rp) {
@@ -161,7 +163,7 @@ static std::string PopServiceName(IPC::RequestParser& rp) {
    return result;
 }
-ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(HLERequestContext& ctx) {
+Result SM::GetServiceImpl(Kernel::KClientSession** out_client_session, HLERequestContext& ctx) {
    if (!ctx.GetManager()->GetIsInitializedForSm()) {
        return Service::SM::ResultInvalidClient;
    }
@@ -170,18 +172,18 @@ ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(HLERequestContext& ctx) {
    std::string name(PopServiceName(rp));
    // Find the named port.
-    auto port_result = service_manager.GetServicePort(name);
+    Kernel::KPort* port{};
-    if (port_result.Code() == Service::SM::ResultInvalidServiceName) {
+    auto port_result = service_manager.GetServicePort(&port, name);
+    if (port_result == Service::SM::ResultInvalidServiceName) {
        LOG_ERROR(Service_SM, "Invalid service name '{}'", name);
        return Service::SM::ResultInvalidServiceName;
    }
-    if (port_result.Failed()) {
+    if (port_result != ResultSuccess) {
        LOG_INFO(Service_SM, "Waiting for service {} to become available", name);
        ctx.SetIsDeferred();
        return Service::SM::ResultNotRegistered;
    }
-    auto& port = port_result.Unwrap();
    // Create a new session.
    Kernel::KClientSession* session{};
@@ -192,7 +194,8 @@ ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(HLERequestContext& ctx) {
    LOG_DEBUG(Service_SM, "called service={} -> session={}", name, session->GetId());
-    return session;
+    *out_client_session = session;
+    return ResultSuccess;
 }
 void SM::RegisterService(HLERequestContext& ctx) {
diff --git a/src/core/hle/service/sm/sm.h b/src/core/hle/service/sm/sm.h
index 6697f4007..14bfaf8c2 100644
--- a/src/core/hle/service/sm/sm.h
+++ b/src/core/hle/service/sm/sm.h
@@ -42,7 +42,7 @@ private:
    void RegisterService(HLERequestContext& ctx);
    void UnregisterService(HLERequestContext& ctx);
-    ResultVal<Kernel::KClientSession*> GetServiceImpl(HLERequestContext& ctx);
+    Result GetServiceImpl(Kernel::KClientSession** out_client_session, HLERequestContext& ctx);
    ServiceManager& service_manager;
    Kernel::KernelCore& kernel;
@@ -55,7 +55,7 @@ public:
    Result RegisterService(std::string name, u32 max_sessions, SessionRequestHandlerPtr handler);
    Result UnregisterService(const std::string& name);
-    ResultVal<Kernel::KPort*> GetServicePort(const std::string& name);
+    Result GetServicePort(Kernel::KPort** out_port, const std::string& name);
    template <Common::DerivedFrom<SessionRequestHandler> T>
    std::shared_ptr<T> GetService(const std::string& service_name) const {
diff --git a/src/core/hle/service/sockets/nsd.cpp b/src/core/hle/service/sockets/nsd.cpp
index 5dfcaabb1..bac21752a 100644
--- a/src/core/hle/service/sockets/nsd.cpp
+++ b/src/core/hle/service/sockets/nsd.cpp
@@ -54,7 +54,7 @@ NSD::NSD(Core::System& system_, const char* name) : ServiceFramework{system_, na
    RegisterHandlers(functions);
 }
-static ResultVal<std::string> ResolveImpl(const std::string& fqdn_in) {
+static std::string ResolveImpl(const std::string& fqdn_in) {
    // The real implementation makes various substitutions.
    // For now we just return the string as-is, which is good enough when not
    // connecting to real Nintendo servers.
@@ -64,13 +64,10 @@ static ResultVal<std::string> ResolveImpl(const std::string& fqdn_in) {
 static Result ResolveCommon(const std::string& fqdn_in, std::array<char, 0x100>& fqdn_out) {
    const auto res = ResolveImpl(fqdn_in);
-    if (res.Failed()) {
+    if (res.size() >= fqdn_out.size()) {
-        return res.Code();
-    }
-    if (res->size() >= fqdn_out.size()) {
        return ResultOverflow;
    }
-    std::memcpy(fqdn_out.data(), res->c_str(), res->size() + 1);
+    std::memcpy(fqdn_out.data(), res.c_str(), res.size() + 1);
    return ResultSuccess;
 }
diff --git a/src/core/hle/service/spl/spl_module.cpp b/src/core/hle/service/spl/spl_module.cpp
index cd631b2ea..549e6f4fa 100644
--- a/src/core/hle/service/spl/spl_module.cpp
+++ b/src/core/hle/service/spl/spl_module.cpp
@@ -30,10 +30,10 @@ void Module::Interface::GetConfig(HLERequestContext& ctx) {
    // This should call svcCallSecureMonitor with the appropriate args.
    // Since we do not have it implemented yet, we will use this for now.
-    const auto smc_result = GetConfigImpl(config_item);
+    u64 smc_result{};
-    const auto result_code = smc_result.Code();
+    const auto result_code = GetConfigImpl(&smc_result, config_item);
-    if (smc_result.Failed()) {
+    if (result_code != ResultSuccess) {
        LOG_ERROR(Service_SPL, "called, config_item={}, result_code={}", config_item,
                  result_code.raw);
@@ -42,11 +42,11 @@ void Module::Interface::GetConfig(HLERequestContext& ctx) {
    }
    LOG_DEBUG(Service_SPL, "called, config_item={}, result_code={}, smc_result={}", config_item,
-              result_code.raw, *smc_result);
+              result_code.raw, smc_result);
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(result_code);
-    rb.Push(*smc_result);
+    rb.Push(smc_result);
 }
 void Module::Interface::ModularExponentiate(HLERequestContext& ctx) {
@@ -99,7 +99,7 @@ void Module::Interface::GetBootReason(HLERequestContext& ctx) {
    rb.Push(ResultSecureMonitorNotImplemented);
 }
-ResultVal<u64> Module::Interface::GetConfigImpl(ConfigItem config_item) const {
+Result Module::Interface::GetConfigImpl(u64* out_config, ConfigItem config_item) const {
    switch (config_item) {
    case ConfigItem::DisableProgramVerification:
    case ConfigItem::DramId:
@@ -121,40 +121,50 @@ ResultVal<u64> Module::Interface::GetConfigImpl(ConfigItem config_item) const {
        return ResultSecureMonitorNotImplemented;
    case ConfigItem::ExosphereApiVersion:
        // Get information about the current exosphere version.
-        return (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) |
+        *out_config = (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) |
-               (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MINOR} << 48) |
+                      (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MINOR} << 48) |
-               (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MICRO} << 40) |
+                      (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MICRO} << 40) |
-               (static_cast<u64>(HLE::ApiVersion::GetTargetFirmware()));
+                      (static_cast<u64>(HLE::ApiVersion::GetTargetFirmware()));
+        return ResultSuccess;
    case ConfigItem::ExosphereNeedsReboot:
        // We are executing, so we aren't in the process of rebooting.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
    case ConfigItem::ExosphereNeedsShutdown:
        // We are executing, so we aren't in the process of shutting down.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
    case ConfigItem::ExosphereGitCommitHash:
        // Get information about the current exosphere git commit hash.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
    case ConfigItem::ExosphereHasRcmBugPatch:
        // Get information about whether this unit has the RCM bug patched.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
    case ConfigItem::ExosphereBlankProdInfo:
        // Get whether this unit should simulate a "blanked" PRODINFO.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
    case ConfigItem::ExosphereAllowCalWrites:
        // Get whether this unit should allow writing to the calibration partition.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
    case ConfigItem::ExosphereEmummcType:
        // Get what kind of emummc this unit has active.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
    case ConfigItem::ExospherePayloadAddress:
        // Gets the physical address of the reboot payload buffer, if one exists.
        return ResultSecureMonitorNotInitialized;
    case ConfigItem::ExosphereLogConfiguration:
        // Get the log configuration.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
    case ConfigItem::ExosphereForceEnableUsb30:
        // Get whether usb 3.0 should be force-enabled.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
    default:
        return ResultSecureMonitorInvalidArgument;
    }
diff --git a/src/core/hle/service/spl/spl_module.h b/src/core/hle/service/spl/spl_module.h
index e074e115d..06dcffa6c 100644
--- a/src/core/hle/service/spl/spl_module.h
+++ b/src/core/hle/service/spl/spl_module.h
@@ -35,7 +35,7 @@ public:
        std::shared_ptr<Module> module;
    private:
-        ResultVal<u64> GetConfigImpl(ConfigItem config_item) const;
+        Result GetConfigImpl(u64* out_config, ConfigItem config_item) const;
        std::mt19937 rng;
    };
diff --git a/src/core/hle/service/ssl/ssl.cpp b/src/core/hle/service/ssl/ssl.cpp
index 9c96f9763..2cba9e5c9 100644
--- a/src/core/hle/service/ssl/ssl.cpp
+++ b/src/core/hle/service/ssl/ssl.cpp
@@ -4,6 +4,7 @@
 #include "common/string_util.h"
 #include "core/core.h"
+#include "core/hle/result.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
@@ -141,12 +142,12 @@ private:
    bool did_set_host_name = false;
    bool did_handshake = false;
-    ResultVal<s32> SetSocketDescriptorImpl(s32 fd) {
+    Result SetSocketDescriptorImpl(s32* out_fd, s32 fd) {
        LOG_DEBUG(Service_SSL, "called, fd={}", fd);
        ASSERT(!did_handshake);
        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD>("bsd:u");
        ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
-        s32 ret_fd;
        // Based on https://switchbrew.org/wiki/SSL_services#SetSocketDescriptor
        if (do_not_close_socket) {
            auto res = bsd->DuplicateSocketImpl(fd);
@@ -156,9 +157,9 @@ private:
            }
            fd = *res;
            fd_to_close = fd;
-            ret_fd = fd;
+            *out_fd = fd;
        } else {
-            ret_fd = -1;
+            *out_fd = -1;
        }
        std::optional<std::shared_ptr<Network::SocketBase>> sock = bsd->GetSocket(fd);
        if (!sock.has_value()) {
@@ -167,7 +168,7 @@ private:
        }
        socket = std::move(*sock);
        backend->SetSocket(socket);
-        return ret_fd;
+        return ResultSuccess;
    }
    Result SetHostNameImpl(const std::string& hostname) {
@@ -247,34 +248,36 @@ private:
        return ret;
    }
-    ResultVal<std::vector<u8>> ReadImpl(size_t size) {
+    Result ReadImpl(std::vector<u8>* out_data, size_t size) {
        ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
-        std::vector<u8> res(size);
+        size_t actual_size{};
-        ResultVal<size_t> actual = backend->Read(res);
+        Result res = backend->Read(&actual_size, *out_data);
-        if (actual.Failed()) {
+        if (res != ResultSuccess) {
-            return actual.Code();
+            return res;
        }
-        res.resize(*actual);
+        out_data->resize(actual_size);
        return res;
    }
-    ResultVal<size_t> WriteImpl(std::span<const u8> data) {
+    Result WriteImpl(size_t* out_size, std::span<const u8> data) {
        ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
-        return backend->Write(data);
+        return backend->Write(out_size, data);
    }
-    ResultVal<s32> PendingImpl() {
+    Result PendingImpl(s32* out_pending) {
        LOG_WARNING(Service_SSL, "(STUBBED) called.");
-        return 0;
+        *out_pending = 0;
+        return ResultSuccess;
    }
    void SetSocketDescriptor(HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
-        const s32 fd = rp.Pop<s32>();
+        const s32 in_fd = rp.Pop<s32>();
-        const ResultVal<s32> res = SetSocketDescriptorImpl(fd);
+        s32 out_fd{-1};
+        const Result res = SetSocketDescriptorImpl(&out_fd, in_fd);
        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(res.Code());
+        rb.Push(res);
-        rb.Push<s32>(res.ValueOr(-1));
+        rb.Push<s32>(out_fd);
    }
    void SetHostName(HLERequestContext& ctx) {
@@ -313,14 +316,15 @@ private:
        };
        static_assert(sizeof(OutputParameters) == 0x8);
-        const Result res = DoHandshakeImpl();
+        Result res = DoHandshakeImpl();
        OutputParameters out{};
        if (res == ResultSuccess) {
-            auto certs = backend->GetServerCerts();
+            std::vector<std::vector<u8>> certs;
-            if (certs.Succeeded()) {
+            res = backend->GetServerCerts(&certs);
-                const std::vector<u8> certs_buf = SerializeServerCerts(*certs);
+            if (res == ResultSuccess) {
+                const std::vector<u8> certs_buf = SerializeServerCerts(certs);
                ctx.WriteBuffer(certs_buf);
-                out.certs_count = static_cast<u32>(certs->size());
+                out.certs_count = static_cast<u32>(certs.size());
                out.certs_size = static_cast<u32>(certs_buf.size());
            }
        }
@@ -330,29 +334,32 @@ private:
    }
    void Read(HLERequestContext& ctx) {
-        const ResultVal<std::vector<u8>> res = ReadImpl(ctx.GetWriteBufferSize());
+        std::vector<u8> output_bytes;
+        const Result res = ReadImpl(&output_bytes, ctx.GetWriteBufferSize());
        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(res.Code());
+        rb.Push(res);
-        if (res.Succeeded()) {
+        if (res == ResultSuccess) {
-            rb.Push(static_cast<u32>(res->size()));
+            rb.Push(static_cast<u32>(output_bytes.size()));
-            ctx.WriteBuffer(*res);
+            ctx.WriteBuffer(output_bytes);
        } else {
            rb.Push(static_cast<u32>(0));
        }
    }
    void Write(HLERequestContext& ctx) {
-        const ResultVal<size_t> res = WriteImpl(ctx.ReadBuffer());
+        size_t write_size{0};
+        const Result res = WriteImpl(&write_size, ctx.ReadBuffer());
        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(res.Code());
+        rb.Push(res);
-        rb.Push(static_cast<u32>(res.ValueOr(0)));
+        rb.Push(static_cast<u32>(write_size));
    }
    void Pending(HLERequestContext& ctx) {
-        const ResultVal<s32> res = PendingImpl();
+        s32 pending_size{0};
+        const Result res = PendingImpl(&pending_size);
        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(res.Code());
+        rb.Push(res);
-        rb.Push<s32>(res.ValueOr(0));
+        rb.Push<s32>(pending_size);
    }
    void SetSessionCacheMode(HLERequestContext& ctx) {
@@ -438,13 +445,14 @@ private:
    void CreateConnection(HLERequestContext& ctx) {
        LOG_WARNING(Service_SSL, "called");
-        auto backend_res = CreateSSLConnectionBackend();
+        std::unique_ptr<SSLConnectionBackend> backend;
+        const Result res = CreateSSLConnectionBackend(&backend);
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(backend_res.Code());
+        rb.Push(res);
-        if (backend_res.Succeeded()) {
+        if (res == ResultSuccess) {
            rb.PushIpcInterface<ISslConnection>(system, ssl_version, shared_data,
-                                                std::move(*backend_res));
+                                                std::move(backend));
        }
    }
diff --git a/src/core/hle/service/ssl/ssl_backend.h b/src/core/hle/service/ssl/ssl_backend.h
index 409f4367c..a2ec8e694 100644
--- a/src/core/hle/service/ssl/ssl_backend.h
+++ b/src/core/hle/service/ssl/ssl_backend.h
@@ -35,11 +35,11 @@ public:
    virtual void SetSocket(std::shared_ptr<Network::SocketBase> socket) = 0;
    virtual Result SetHostName(const std::string& hostname) = 0;
    virtual Result DoHandshake() = 0;
-    virtual ResultVal<size_t> Read(std::span<u8> data) = 0;
+    virtual Result Read(size_t* out_size, std::span<u8> data) = 0;
-    virtual ResultVal<size_t> Write(std::span<const u8> data) = 0;
+    virtual Result Write(size_t* out_size, std::span<const u8> data) = 0;
-    virtual ResultVal<std::vector<std::vector<u8>>> GetServerCerts() = 0;
+    virtual Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) = 0;
 };
-ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend();
+Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend);
 } // namespace Service::SSL
diff --git a/src/core/hle/service/ssl/ssl_backend_none.cpp b/src/core/hle/service/ssl/ssl_backend_none.cpp
index 2f4f23c42..a7fafd0a3 100644
--- a/src/core/hle/service/ssl/ssl_backend_none.cpp
+++ b/src/core/hle/service/ssl/ssl_backend_none.cpp
@@ -7,7 +7,7 @@
 namespace Service::SSL {
-ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() {
+Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend) {
    LOG_ERROR(Service_SSL,
              "Can't create SSL connection because no SSL backend is available on this platform");
    return ResultInternalError;
diff --git a/src/core/hle/service/ssl/ssl_backend_openssl.cpp b/src/core/hle/service/ssl/ssl_backend_openssl.cpp
index 6ca869dbf..b2dd37cd4 100644
--- a/src/core/hle/service/ssl/ssl_backend_openssl.cpp
+++ b/src/core/hle/service/ssl/ssl_backend_openssl.cpp
@@ -105,31 +105,30 @@ public:
                return ResultInternalError;
            }
        }
-        return HandleReturn("SSL_do_handshake", 0, ret).Code();
+        return HandleReturn("SSL_do_handshake", 0, ret);
    }
-    ResultVal<size_t> Read(std::span<u8> data) override {
+    Result Read(size_t* out_size, std::span<u8> data) override {
-        size_t actual;
+        const int ret = SSL_read_ex(ssl, data.data(), data.size(), out_size);
-        const int ret = SSL_read_ex(ssl, data.data(), data.size(), &actual);
+        return HandleReturn("SSL_read_ex", out_size, ret);
-        return HandleReturn("SSL_read_ex", actual, ret);
    }
-    ResultVal<size_t> Write(std::span<const u8> data) override {
+    Result Write(size_t* out_size, std::span<const u8> data) override {
-        size_t actual;
+        const int ret = SSL_write_ex(ssl, data.data(), data.size(), out_size);
-        const int ret = SSL_write_ex(ssl, data.data(), data.size(), &actual);
+        return HandleReturn("SSL_write_ex", out_size, ret);
-        return HandleReturn("SSL_write_ex", actual, ret);
    }
-    ResultVal<size_t> HandleReturn(const char* what, size_t actual, int ret) {
+    Result HandleReturn(const char* what, size_t* actual, int ret) {
        const int ssl_err = SSL_get_error(ssl, ret);
        CheckOpenSSLErrors();
        switch (ssl_err) {
        case SSL_ERROR_NONE:
-            return actual;
+            return ResultSuccess;
        case SSL_ERROR_ZERO_RETURN:
            LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_ZERO_RETURN", what);
            // DoHandshake special-cases this, but for Read and Write:
-            return size_t(0);
+            *actual = 0;
+            return ResultSuccess;
        case SSL_ERROR_WANT_READ:
            LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_WANT_READ", what);
            return ResultWouldBlock;
@@ -139,20 +138,20 @@ public:
        default:
            if (ssl_err == SSL_ERROR_SYSCALL && got_read_eof) {
                LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_SYSCALL because server hung up", what);
-                return size_t(0);
+                *actual = 0;
+                return ResultSuccess;
            }
            LOG_ERROR(Service_SSL, "{} => other SSL_get_error return value {}", what, ssl_err);
            return ResultInternalError;
        }
    }
-    ResultVal<std::vector<std::vector<u8>>> GetServerCerts() override {
+    Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) override {
        STACK_OF(X509)* chain = SSL_get_peer_cert_chain(ssl);
        if (!chain) {
            LOG_ERROR(Service_SSL, "SSL_get_peer_cert_chain returned nullptr");
            return ResultInternalError;
        }
-        std::vector<std::vector<u8>> ret;
        int count = sk_X509_num(chain);
        ASSERT(count >= 0);
        for (int i = 0; i < count; i++) {
@@ -161,10 +160,10 @@ public:
            unsigned char* buf = nullptr;
            int len = i2d_X509(x509, &buf);
            ASSERT_OR_EXECUTE(len >= 0 && buf, { continue; });
-            ret.emplace_back(buf, buf + len);
+            out_certs->emplace_back(buf, buf + len);
            OPENSSL_free(buf);
        }
-        return ret;
+        return ResultSuccess;
    }
    ~SSLConnectionBackendOpenSSL() {
@@ -253,13 +252,13 @@ public:
    std::shared_ptr<Network::SocketBase> socket;
 };
-ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() {
+Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend) {
    auto conn = std::make_unique<SSLConnectionBackendOpenSSL>();
-    const Result res = conn->Init();
-    if (res.IsFailure()) {
+    R_TRY(conn->Init());
-        return res;
-    }
+    *out_backend = std::move(conn);
-    return conn;
+    return ResultSuccess;
 }
 namespace {
diff --git a/src/core/hle/service/ssl/ssl_backend_schannel.cpp b/src/core/hle/service/ssl/ssl_backend_schannel.cpp
index d8074339a..bda12b761 100644
--- a/src/core/hle/service/ssl/ssl_backend_schannel.cpp
+++ b/src/core/hle/service/ssl/ssl_backend_schannel.cpp
@@ -299,21 +299,22 @@ public:
        return ResultSuccess;
    }
-    ResultVal<size_t> Read(std::span<u8> data) override {
+    Result Read(size_t* out_size, std::span<u8> data) override {
+        *out_size = 0;
        if (handshake_state != HandshakeState::Connected) {
            LOG_ERROR(Service_SSL, "Called Read but we did not successfully handshake");
            return ResultInternalError;
        }
        if (data.size() == 0 || got_read_eof) {
-            return size_t(0);
+            return ResultSuccess;
        }
        while (1) {
            if (!cleartext_read_buf.empty()) {
-                const size_t read_size = std::min(cleartext_read_buf.size(), data.size());
+                *out_size = std::min(cleartext_read_buf.size(), data.size());
-                std::memcpy(data.data(), cleartext_read_buf.data(), read_size);
+                std::memcpy(data.data(), cleartext_read_buf.data(), *out_size);
                cleartext_read_buf.erase(cleartext_read_buf.begin(),
-                                         cleartext_read_buf.begin() + read_size);
+                                         cleartext_read_buf.begin() + *out_size);
-                return read_size;
+                return ResultSuccess;
            }
            if (!ciphertext_read_buf.empty()) {
                SecBuffer empty{
@@ -366,7 +367,8 @@ public:
                case SEC_I_CONTEXT_EXPIRED:
                    // Server hung up by sending close_notify.
                    got_read_eof = true;
-                    return size_t(0);
+                    *out_size = 0;
+                    return ResultSuccess;
                default:
                    LOG_ERROR(Service_SSL, "DecryptMessage failed: {}",
                              Common::NativeErrorToString(ret));
@@ -379,18 +381,21 @@ public:
            }
            if (ciphertext_read_buf.empty()) {
                got_read_eof = true;
-                return size_t(0);
+                *out_size = 0;
+                return ResultSuccess;
            }
        }
    }
-    ResultVal<size_t> Write(std::span<const u8> data) override {
+    Result Write(size_t* out_size, std::span<const u8> data) override {
+        *out_size = 0;
        if (handshake_state != HandshakeState::Connected) {
            LOG_ERROR(Service_SSL, "Called Write but we did not successfully handshake");
            return ResultInternalError;
        }
        if (data.size() == 0) {
-            return size_t(0);
+            return ResultSuccess;
        }
        data = data.subspan(0, std::min<size_t>(data.size(), stream_sizes.cbMaximumMessage));
        if (!cleartext_write_buf.empty()) {
@@ -402,7 +407,7 @@ public:
                LOG_ERROR(Service_SSL, "Called Write but buffer does not match previous buffer");
                return ResultInternalError;
            }
-            return WriteAlreadyEncryptedData();
+            return WriteAlreadyEncryptedData(out_size);
        } else {
            cleartext_write_buf.assign(data.begin(), data.end());
        }
@@ -448,21 +453,21 @@ public:
                                    tmp_data_buf.end());
        ciphertext_write_buf.insert(ciphertext_write_buf.end(), trailer_buf.begin(),
                                    trailer_buf.end());
-        return WriteAlreadyEncryptedData();
+        return WriteAlreadyEncryptedData(out_size);
    }
-    ResultVal<size_t> WriteAlreadyEncryptedData() {
+    Result WriteAlreadyEncryptedData(size_t* out_size) {
        const Result r = FlushCiphertextWriteBuf();
        if (r != ResultSuccess) {
            return r;
        }
        // write buf is empty
-        const size_t cleartext_bytes_written = cleartext_write_buf.size();
+        *out_size = cleartext_write_buf.size();
        cleartext_write_buf.clear();
-        return cleartext_bytes_written;
+        return ResultSuccess;
    }
-    ResultVal<std::vector<std::vector<u8>>> GetServerCerts() override {
+    Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) override {
        PCCERT_CONTEXT returned_cert = nullptr;
        const SECURITY_STATUS ret =
            QueryContextAttributes(&ctxt, SECPKG_ATTR_REMOTE_CERT_CONTEXT, &returned_cert);
@@ -473,16 +478,15 @@ public:
            return ResultInternalError;
        }
        PCCERT_CONTEXT some_cert = nullptr;
-        std::vector<std::vector<u8>> certs;
        while ((some_cert = CertEnumCertificatesInStore(returned_cert->hCertStore, some_cert))) {
-            certs.emplace_back(static_cast<u8*>(some_cert->pbCertEncoded),
+            out_certs->emplace_back(static_cast<u8*>(some_cert->pbCertEncoded),
-                               static_cast<u8*>(some_cert->pbCertEncoded) +
+                                    static_cast<u8*>(some_cert->pbCertEncoded) +
-                                   some_cert->cbCertEncoded);
+                                        some_cert->cbCertEncoded);
        }
-        std::reverse(certs.begin(),
+        std::reverse(out_certs->begin(),
-                     certs.end()); // Windows returns certs in reverse order from what we want
+                     out_certs->end()); // Windows returns certs in reverse order from what we want
        CertFreeCertificateContext(returned_cert);
-        return certs;
+        return ResultSuccess;
    }
    ~SSLConnectionBackendSchannel() {
@@ -532,13 +536,13 @@ public:
    size_t read_buf_fill_size = 0;
 };
-ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() {
+Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend) {
    auto conn = std::make_unique<SSLConnectionBackendSchannel>();
-    const Result res = conn->Init();
-    if (res.IsFailure()) {
+    R_TRY(conn->Init());
-        return res;
-    }
+    *out_backend = std::move(conn);
-    return conn;
+    return ResultSuccess;
 }
 } // namespace Service::SSL
diff --git a/src/core/hle/service/ssl/ssl_backend_securetransport.cpp b/src/core/hle/service/ssl/ssl_backend_securetransport.cpp
index b3083cbad..c48914f64 100644
--- a/src/core/hle/service/ssl/ssl_backend_securetransport.cpp
+++ b/src/core/hle/service/ssl/ssl_backend_securetransport.cpp
@@ -100,27 +100,23 @@ public:
    Result DoHandshake() override {
        OSStatus status = SSLHandshake(context);
-        return HandleReturn("SSLHandshake", 0, status).Code();
+        return HandleReturn("SSLHandshake", 0, status);
    }
-    ResultVal<size_t> Read(std::span<u8> data) override {
+    Result Read(size_t* out_size, std::span<u8> data) override {
-        size_t actual;
+        OSStatus status = SSLRead(context, data.data(), data.size(), out_size);
-        OSStatus status = SSLRead(context, data.data(), data.size(), &actual);
+        return HandleReturn("SSLRead", out_size, status);
-        ;
-        return HandleReturn("SSLRead", actual, status);
    }
-    ResultVal<size_t> Write(std::span<const u8> data) override {
+    Result Write(size_t* out_size, std::span<const u8> data) override {
-        size_t actual;
+        OSStatus status = SSLWrite(context, data.data(), data.size(), out_size);
-        OSStatus status = SSLWrite(context, data.data(), data.size(), &actual);
+        return HandleReturn("SSLWrite", out_size, status);
-        ;
-        return HandleReturn("SSLWrite", actual, status);
    }
-    ResultVal<size_t> HandleReturn(const char* what, size_t actual, OSStatus status) {
+    Result HandleReturn(const char* what, size_t* actual, OSStatus status) {
        switch (status) {
        case 0:
-            return actual;
+            return ResultSuccess;
        case errSSLWouldBlock:
            return ResultWouldBlock;
        default: {
@@ -136,22 +132,21 @@ public:
        }
    }
-    ResultVal<std::vector<std::vector<u8>>> GetServerCerts() override {
+    Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) override {
        CFReleaser<SecTrustRef> trust;
        OSStatus status = SSLCopyPeerTrust(context, &trust.ptr);
        if (status) {
            LOG_ERROR(Service_SSL, "SSLCopyPeerTrust failed: {}", OSStatusToString(status));
            return ResultInternalError;
        }
-        std::vector<std::vector<u8>> ret;
        for (CFIndex i = 0, count = SecTrustGetCertificateCount(trust); i < count; i++) {
            SecCertificateRef cert = SecTrustGetCertificateAtIndex(trust, i);
            CFReleaser<CFDataRef> data(SecCertificateCopyData(cert));
            ASSERT_OR_EXECUTE(data, { return ResultInternalError; });
            const u8* ptr = CFDataGetBytePtr(data);
-            ret.emplace_back(ptr, ptr + CFDataGetLength(data));
+            out_certs->emplace_back(ptr, ptr + CFDataGetLength(data));
        }
-        return ret;
+        return ResultSuccess;
    }
    static OSStatus ReadCallback(SSLConnectionRef connection, void* data, size_t* dataLength) {
@@ -210,13 +205,13 @@ private:
    std::shared_ptr<Network::SocketBase> socket;
 };
-ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() {
+Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend) {
    auto conn = std::make_unique<SSLConnectionBackendSecureTransport>();
-    const Result res = conn->Init();
-    if (res.IsFailure()) {
+    R_TRY(conn->Init());
-        return res;
-    }
+    *out_backend = std::move(conn);
-    return conn;
+    return ResultSuccess;
 }
 } // namespace Service::SSL
diff --git a/src/core/hle/service/vi/display/vi_display.cpp b/src/core/hle/service/vi/display/vi_display.cpp
index 69af2868a..f0b5eff8a 100644
--- a/src/core/hle/service/vi/display/vi_display.cpp
+++ b/src/core/hle/service/vi/display/vi_display.cpp
@@ -58,14 +58,15 @@ const Layer& Display::GetLayer(std::size_t index) const {
    return *layers.at(index);
 }
-ResultVal<Kernel::KReadableEvent*> Display::GetVSyncEvent() {
+Result Display::GetVSyncEvent(Kernel::KReadableEvent** out_vsync_event) {
    if (got_vsync_event) {
        return ResultPermissionDenied;
    }
    got_vsync_event = true;
-    return GetVSyncEventUnchecked();
+    *out_vsync_event = GetVSyncEventUnchecked();
+    return ResultSuccess;
 }
 Kernel::KReadableEvent* Display::GetVSyncEventUnchecked() {
diff --git a/src/core/hle/service/vi/display/vi_display.h b/src/core/hle/service/vi/display/vi_display.h
index 3f31d1f32..101cbce20 100644
--- a/src/core/hle/service/vi/display/vi_display.h
+++ b/src/core/hle/service/vi/display/vi_display.h
@@ -85,7 +85,7 @@ public:
     * @returns The internal Vsync event if it has not yet been retrieved,
     *          VI::ResultPermissionDenied otherwise.
     */
-    [[nodiscard]] ResultVal<Kernel::KReadableEvent*> GetVSyncEvent();
+    [[nodiscard]] Result GetVSyncEvent(Kernel::KReadableEvent** out_vsync_event);
    /// Gets the internal vsync event.
    Kernel::KReadableEvent* GetVSyncEventUnchecked();
diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp
index 1b193f00c..6bb02393c 100644
--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -683,9 +683,9 @@ private:
        LOG_DEBUG(Service_VI, "called. display_id={}", display_id);
-        const auto vsync_event = nv_flinger.FindVsyncEvent(display_id);
+        Kernel::KReadableEvent* vsync_event{};
-        if (vsync_event.Failed()) {
+        const auto result = nv_flinger.FindVsyncEvent(&vsync_event, display_id);
-            const auto result = vsync_event.Code();
+        if (result != ResultSuccess) {
            if (result == ResultNotFound) {
                LOG_ERROR(Service_VI, "Vsync event was not found for display_id={}", display_id);
            }
@@ -697,7 +697,7 @@ private:
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(*vsync_event);
+        rb.PushCopyObjects(vsync_event);
    }
    void ConvertScalingMode(HLERequestContext& ctx) {
@@ -705,15 +705,16 @@ private:
        const auto mode = rp.PopEnum<NintendoScaleMode>();
        LOG_DEBUG(Service_VI, "called mode={}", mode);
-        const auto converted_mode = ConvertScalingModeImpl(mode);
+        ConvertedScaleMode converted_mode{};
+        const auto result = ConvertScalingModeImpl(&converted_mode, mode);
-        if (converted_mode.Succeeded()) {
+        if (result == ResultSuccess) {
            IPC::ResponseBuilder rb{ctx, 4};
            rb.Push(ResultSuccess);
-            rb.PushEnum(*converted_mode);
+            rb.PushEnum(converted_mode);
        } else {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(converted_mode.Code());
+            rb.Push(result);
        }
    }
@@ -760,18 +761,24 @@ private:
        rb.Push(alignment);
    }
-    static ResultVal<ConvertedScaleMode> ConvertScalingModeImpl(NintendoScaleMode mode) {
+    static Result ConvertScalingModeImpl(ConvertedScaleMode* out_scaling_mode,
+                                         NintendoScaleMode mode) {
        switch (mode) {
        case NintendoScaleMode::None:
-            return ConvertedScaleMode::None;
+            *out_scaling_mode = ConvertedScaleMode::None;
+            return ResultSuccess;
        case NintendoScaleMode::Freeze:
-            return ConvertedScaleMode::Freeze;
+            *out_scaling_mode = ConvertedScaleMode::Freeze;
+            return ResultSuccess;
        case NintendoScaleMode::ScaleToWindow:
-            return ConvertedScaleMode::ScaleToWindow;
+            *out_scaling_mode = ConvertedScaleMode::ScaleToWindow;
+            return ResultSuccess;
        case NintendoScaleMode::ScaleAndCrop:
-            return ConvertedScaleMode::ScaleAndCrop;
+            *out_scaling_mode = ConvertedScaleMode::ScaleAndCrop;
+            return ResultSuccess;
        case NintendoScaleMode::PreserveAspectRatio:
-            return ConvertedScaleMode::PreserveAspectRatio;
+            *out_scaling_mode = ConvertedScaleMode::PreserveAspectRatio;
+            return ResultSuccess;
        default:
            LOG_ERROR(Service_VI, "Invalid scaling mode specified, mode={}", mode);
            return ResultOperationFailed;
diff --git a/src/core/memory.h b/src/core/memory.h
index 2eb61ffd3..13047a545 100644
--- a/src/core/memory.h
+++ b/src/core/memory.h
@@ -509,9 +509,9 @@ class GuestMemory {
 public:
    GuestMemory() = delete;
-    explicit GuestMemory(M& memory_, u64 addr_, std::size_t size_,
+    explicit GuestMemory(M& memory, u64 addr, std::size_t size,
                         Common::ScratchBuffer<T>* backup = nullptr)
-        : memory{memory_}, addr{addr_}, size{size_} {
+        : m_memory{memory}, m_addr{addr}, m_size{size} {
        static_assert(FLAGS & GuestMemoryFlags::Read || FLAGS & GuestMemoryFlags::Write);
        if constexpr (FLAGS & GuestMemoryFlags::Read) {
            Read(addr, size, backup);
@@ -521,89 +521,97 @@ public:
    ~GuestMemory() = default;
    T* data() noexcept {
-        return data_span.data();
+        return m_data_span.data();
    }
    const T* data() const noexcept {
-        return data_span.data();
+        return m_data_span.data();
+    }
+    size_t size() const noexcept {
+        return m_size;
+    }
+    size_t size_bytes() const noexcept {
+        return this->size() * sizeof(T);
    }
    [[nodiscard]] T* begin() noexcept {
-        return data();
+        return this->data();
    }
    [[nodiscard]] const T* begin() const noexcept {
-        return data();
+        return this->data();
    }
    [[nodiscard]] T* end() noexcept {
-        return data() + size;
+        return this->data() + this->size();
    }
    [[nodiscard]] const T* end() const noexcept {
-        return data() + size;
+        return this->data() + this->size();
    }
    T& operator[](size_t index) noexcept {
-        return data_span[index];
+        return m_data_span[index];
    }
    const T& operator[](size_t index) const noexcept {
-        return data_span[index];
+        return m_data_span[index];
    }
-    void SetAddressAndSize(u64 addr_, std::size_t size_) noexcept {
+    void SetAddressAndSize(u64 addr, std::size_t size) noexcept {
-        addr = addr_;
+        m_addr = addr;
-        size = size_;
+        m_size = size;
-        addr_changed = true;
+        m_addr_changed = true;
    }
-    std::span<T> Read(u64 addr_, std::size_t size_,
+    std::span<T> Read(u64 addr, std::size_t size,
                      Common::ScratchBuffer<T>* backup = nullptr) noexcept {
-        addr = addr_;
+        m_addr = addr;
-        size = size_;
+        m_size = size;
-        if (size == 0) {
+        if (m_size == 0) {
-            is_data_copy = true;
+            m_is_data_copy = true;
            return {};
        }
-        if (TrySetSpan()) {
+        if (this->TrySetSpan()) {
            if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                memory.FlushRegion(addr, size * sizeof(T));
+                m_memory.FlushRegion(m_addr, this->size_bytes());
            }
        } else {
            if (backup) {
-                backup->resize_destructive(size);
+                backup->resize_destructive(this->size());
-                data_span = *backup;
+                m_data_span = *backup;
            } else {
-                data_copy.resize(size);
+                m_data_copy.resize(this->size());
-                data_span = std::span(data_copy);
+                m_data_span = std::span(m_data_copy);
            }
-            is_data_copy = true;
+            m_is_data_copy = true;
-            span_valid = true;
+            m_span_valid = true;
            if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                memory.ReadBlock(addr, data_span.data(), size * sizeof(T));
+                m_memory.ReadBlock(m_addr, this->data(), this->size_bytes());
            } else {
-                memory.ReadBlockUnsafe(addr, data_span.data(), size * sizeof(T));
+                m_memory.ReadBlockUnsafe(m_addr, this->data(), this->size_bytes());
            }
        }
-        return data_span;
+        return m_data_span;
    }
    void Write(std::span<T> write_data) noexcept {
        if constexpr (FLAGS & GuestMemoryFlags::Cached) {
-            memory.WriteBlockCached(addr, write_data.data(), size * sizeof(T));
+            m_memory.WriteBlockCached(m_addr, write_data.data(), this->size_bytes());
        } else if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-            memory.WriteBlock(addr, write_data.data(), size * sizeof(T));
+            m_memory.WriteBlock(m_addr, write_data.data(), this->size_bytes());
        } else {
-            memory.WriteBlockUnsafe(addr, write_data.data(), size * sizeof(T));
+            m_memory.WriteBlockUnsafe(m_addr, write_data.data(), this->size_bytes());
        }
    }
    bool TrySetSpan() noexcept {
-        if (u8* ptr = memory.GetSpan(addr, size * sizeof(T)); ptr) {
+        if (u8* ptr = m_memory.GetSpan(m_addr, this->size_bytes()); ptr) {
-            data_span = {reinterpret_cast<T*>(ptr), size};
+            m_data_span = {reinterpret_cast<T*>(ptr), this->size()};
-            span_valid = true;
+            m_span_valid = true;
            return true;
        }
        return false;
@@ -611,36 +619,36 @@ public:
 protected:
    bool IsDataCopy() const noexcept {
-        return is_data_copy;
+        return m_is_data_copy;
    }
    bool AddressChanged() const noexcept {
-        return addr_changed;
+        return m_addr_changed;
    }
-    M& memory;
+    M& m_memory;
-    u64 addr;
+    u64 m_addr{};
-    size_t size;
+    size_t m_size{};
-    std::span<T> data_span{};
+    std::span<T> m_data_span{};
-    std::vector<T> data_copy;
+    std::vector<T> m_data_copy{};
-    bool span_valid{false};
+    bool m_span_valid{false};
-    bool is_data_copy{false};
+    bool m_is_data_copy{false};
-    bool addr_changed{false};
+    bool m_addr_changed{false};
 };
 template <typename M, typename T, GuestMemoryFlags FLAGS>
 class GuestMemoryScoped : public GuestMemory<M, T, FLAGS> {
 public:
    GuestMemoryScoped() = delete;
-    explicit GuestMemoryScoped(M& memory_, u64 addr_, std::size_t size_,
+    explicit GuestMemoryScoped(M& memory, u64 addr, std::size_t size,
                               Common::ScratchBuffer<T>* backup = nullptr)
-        : GuestMemory<M, T, FLAGS>(memory_, addr_, size_, backup) {
+        : GuestMemory<M, T, FLAGS>(memory, addr, size, backup) {
        if constexpr (!(FLAGS & GuestMemoryFlags::Read)) {
            if (!this->TrySetSpan()) {
                if (backup) {
-                    this->data_span = *backup;
+                    this->m_data_span = *backup;
-                    this->span_valid = true;
+                    this->m_span_valid = true;
-                    this->is_data_copy = true;
+                    this->m_is_data_copy = true;
                }
            }
        }
@@ -648,24 +656,21 @@ public:
    ~GuestMemoryScoped() {
        if constexpr (FLAGS & GuestMemoryFlags::Write) {
-            if (this->size == 0) [[unlikely]] {
+            if (this->size() == 0) [[unlikely]] {
                return;
            }
            if (this->AddressChanged() || this->IsDataCopy()) {
-                ASSERT(this->span_valid);
+                ASSERT(this->m_span_valid);
                if constexpr (FLAGS & GuestMemoryFlags::Cached) {
-                    this->memory.WriteBlockCached(this->addr, this->data_span.data(),
+                    this->m_memory.WriteBlockCached(this->m_addr, this->data(), this->size_bytes());
-                                                  this->size * sizeof(T));
                } else if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                    this->memory.WriteBlock(this->addr, this->data_span.data(),
+                    this->m_memory.WriteBlock(this->m_addr, this->data(), this->size_bytes());
-                                            this->size * sizeof(T));
                } else {
-                    this->memory.WriteBlockUnsafe(this->addr, this->data_span.data(),
+                    this->m_memory.WriteBlockUnsafe(this->m_addr, this->data(), this->size_bytes());
-                                                  this->size * sizeof(T));
                }
            } else if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                this->memory.InvalidateRegion(this->addr, this->size * sizeof(T));
+                this->m_memory.InvalidateRegion(this->m_addr, this->size_bytes());
            }
        }
    }
diff --git a/src/shader_recompiler/environment.h b/src/shader_recompiler/environment.h
index 26e8307c1..15285ab0a 100644
--- a/src/shader_recompiler/environment.h
+++ b/src/shader_recompiler/environment.h
@@ -39,7 +39,7 @@ public:
    [[nodiscard]] virtual std::optional<ReplaceConstant> GetReplaceConstBuffer(u32 bank,
                                                                               u32 offset) = 0;
-    virtual void Dump(u64 hash) = 0;
+    virtual void Dump(u64 pipeline_hash, u64 shader_hash) = 0;
    [[nodiscard]] const ProgramHeader& SPH() const noexcept {
        return sph;
diff --git a/src/video_core/engines/maxwell_dma.cpp b/src/video_core/engines/maxwell_dma.cpp
index cd8e24b0b..da8eab7ee 100644
--- a/src/video_core/engines/maxwell_dma.cpp
+++ b/src/video_core/engines/maxwell_dma.cpp
@@ -5,6 +5,7 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/microprofile.h"
+#include "common/polyfill_ranges.h"
 #include "common/settings.h"
 #include "core/core.h"
 #include "core/memory.h"
diff --git a/src/video_core/renderer_opengl/gl_device.cpp b/src/video_core/renderer_opengl/gl_device.cpp
index ee140c9c2..94258ccd0 100644
--- a/src/video_core/renderer_opengl/gl_device.cpp
+++ b/src/video_core/renderer_opengl/gl_device.cpp
@@ -106,6 +106,43 @@ bool IsASTCSupported() {
    return true;
 }
+static bool HasSlowSoftwareAstc(std::string_view vendor_name, std::string_view renderer) {
+// ifdef for Unix reduces string comparisons for non-Windows drivers, and Intel
+#ifdef YUZU_UNIX
+    // Sorted vaguely by how likely a vendor is to appear
+    if (vendor_name == "AMD") {
+        // RadeonSI
+        return true;
+    }
+    if (vendor_name == "Intel") {
+        // Must be inside YUZU_UNIX ifdef as the Windows driver uses the same vendor string
+        // iris, crocus
+        const bool is_intel_dg = (renderer.find("DG") != std::string_view::npos);
+        return is_intel_dg;
+    }
+    if (vendor_name == "nouveau") {
+        return true;
+    }
+    if (vendor_name == "X.Org") {
+        // R600
+        return true;
+    }
+#endif
+    if (vendor_name == "Collabora Ltd") {
+        // Zink
+        return true;
+    }
+    if (vendor_name == "Microsoft Corporation") {
+        // d3d12
+        return true;
+    }
+    if (vendor_name == "Mesa/X.org") {
+        // llvmpipe, softpipe, virgl
+        return true;
+    }
+    return false;
+}
 [[nodiscard]] bool IsDebugToolAttached(std::span<const std::string_view> extensions) {
    const bool nsight = std::getenv("NVTX_INJECTION64_PATH") || std::getenv("NSIGHT_LAUNCHED");
    return nsight || HasExtension(extensions, "GL_EXT_debug_tool") ||
@@ -120,12 +157,16 @@ Device::Device(Core::Frontend::EmuWindow& emu_window) {
    }
    vendor_name = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
    const std::string_view version = reinterpret_cast<const char*>(glGetString(GL_VERSION));
+    const std::string_view renderer = reinterpret_cast<const char*>(glGetString(GL_RENDERER));
    const std::vector extensions = GetExtensions();
    const bool is_nvidia = vendor_name == "NVIDIA Corporation";
    const bool is_amd = vendor_name == "ATI Technologies Inc.";
    const bool is_intel = vendor_name == "Intel";
+    const bool has_slow_software_astc =
+        !is_nvidia && !is_amd && HasSlowSoftwareAstc(vendor_name, renderer);
 #ifdef __unix__
    constexpr bool is_linux = true;
 #else
@@ -152,7 +193,7 @@ Device::Device(Core::Frontend::EmuWindow& emu_window) {
    has_vertex_viewport_layer = GLAD_GL_ARB_shader_viewport_layer_array;
    has_image_load_formatted = HasExtension(extensions, "GL_EXT_shader_image_load_formatted");
    has_texture_shadow_lod = HasExtension(extensions, "GL_EXT_texture_shadow_lod");
-    has_astc = IsASTCSupported();
+    has_astc = !has_slow_software_astc && IsASTCSupported();
    has_variable_aoffi = TestVariableAoffi();
    has_component_indexing_bug = is_amd;
    has_precise_bug = TestPreciseBug();
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.cpp b/src/video_core/renderer_opengl/gl_shader_cache.cpp
index 618cb6354..2888e0238 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -445,7 +445,8 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
    ShaderContext::ShaderPools& pools, const GraphicsPipelineKey& key,
    std::span<Shader::Environment* const> envs, bool use_shader_workers,
    bool force_context_flush) try {
-    LOG_INFO(Render_OpenGL, "0x{:016x}", key.Hash());
+    auto hash = key.Hash();
+    LOG_INFO(Render_OpenGL, "0x{:016x}", hash);
    size_t env_index{};
    u32 total_storage_buffers{};
    std::array<Shader::IR::Program, Maxwell::MaxShaderProgram> programs;
@@ -474,7 +475,7 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
        Shader::Maxwell::Flow::CFG cfg(env, pools.flow_block, cfg_offset, index == 0);
        if (Settings::values.dump_shaders) {
-            env.Dump(key.unique_hashes[index]);
+            env.Dump(hash, key.unique_hashes[index]);
        }
        if (!uses_vertex_a || index != 1) {
@@ -566,12 +567,13 @@ std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
 std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
    ShaderContext::ShaderPools& pools, const ComputePipelineKey& key, Shader::Environment& env,
    bool force_context_flush) try {
-    LOG_INFO(Render_OpenGL, "0x{:016x}", key.Hash());
+    auto hash = key.Hash();
+    LOG_INFO(Render_OpenGL, "0x{:016x}", hash);
    Shader::Maxwell::Flow::CFG cfg{env, pools.flow_block, env.StartAddress()};
    if (Settings::values.dump_shaders) {
-        env.Dump(key.Hash());
+        env.Dump(hash, key.unique_hash);
    }
    auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
index 4f84d8497..c1314ca99 100644
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -584,7 +584,8 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
    ShaderPools& pools, const GraphicsPipelineCacheKey& key,
    std::span<Shader::Environment* const> envs, PipelineStatistics* statistics,
    bool build_in_parallel) try {
-    LOG_INFO(Render_Vulkan, "0x{:016x}", key.Hash());
+    auto hash = key.Hash();
+    LOG_INFO(Render_Vulkan, "0x{:016x}", hash);
    size_t env_index{0};
    std::array<Shader::IR::Program, Maxwell::MaxShaderProgram> programs;
    const bool uses_vertex_a{key.unique_hashes[0] != 0};
@@ -611,7 +612,7 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
        const u32 cfg_offset{static_cast<u32>(env.StartAddress() + sizeof(Shader::ProgramHeader))};
        Shader::Maxwell::Flow::CFG cfg(env, pools.flow_block, cfg_offset, index == 0);
        if (Settings::values.dump_shaders) {
-            env.Dump(key.unique_hashes[index]);
+            env.Dump(hash, key.unique_hashes[index]);
        }
        if (!uses_vertex_a || index != 1) {
            // Normal path
@@ -712,18 +713,19 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
 std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
    ShaderPools& pools, const ComputePipelineCacheKey& key, Shader::Environment& env,
    PipelineStatistics* statistics, bool build_in_parallel) try {
+    auto hash = key.Hash();
    if (device.HasBrokenCompute()) {
-        LOG_ERROR(Render_Vulkan, "Skipping 0x{:016x}", key.Hash());
+        LOG_ERROR(Render_Vulkan, "Skipping 0x{:016x}", hash);
        return nullptr;
    }
-    LOG_INFO(Render_Vulkan, "0x{:016x}", key.Hash());
+    LOG_INFO(Render_Vulkan, "0x{:016x}", hash);
    Shader::Maxwell::Flow::CFG cfg{env, pools.flow_block, env.StartAddress()};
    // Dump it before error.
    if (Settings::values.dump_shaders) {
-        env.Dump(key.Hash());
+        env.Dump(hash, key.unique_hash);
    }
    auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
diff --git a/src/video_core/shader_cache.cpp b/src/video_core/shader_cache.cpp
index 01701201d..e81cd031b 100644
--- a/src/video_core/shader_cache.cpp
+++ b/src/video_core/shader_cache.cpp
@@ -51,6 +51,11 @@ bool ShaderCache::RefreshStages(std::array<u64, 6>& unique_hashes) {
        }
        const auto& shader_config{maxwell3d->regs.pipelines[index]};
        const auto program{static_cast<Tegra::Engines::Maxwell3D::Regs::ShaderType>(index)};
+        if (program == Tegra::Engines::Maxwell3D::Regs::ShaderType::Pixel &&
+            !maxwell3d->regs.rasterize_enable) {
+            unique_hashes[index] = 0;
+            continue;
+        }
        const GPUVAddr shader_addr{base_addr + shader_config.offset};
        const std::optional<VAddr> cpu_shader_addr{gpu_memory->GpuToCpuAddress(shader_addr)};
        if (!cpu_shader_addr) {
diff --git a/src/video_core/shader_cache.h b/src/video_core/shader_cache.h
index de8e08002..a76896620 100644
--- a/src/video_core/shader_cache.h
+++ b/src/video_core/shader_cache.h
@@ -70,7 +70,7 @@ public:
 protected:
    struct GraphicsEnvironments {
        std::array<GraphicsEnvironment, NUM_PROGRAMS> envs;
-        std::array<Shader::Environment*, NUM_PROGRAMS> env_ptrs;
+        std::array<Shader::Environment*, NUM_PROGRAMS> env_ptrs{};
        std::span<Shader::Environment* const> Span() const noexcept {
            return std::span(env_ptrs.begin(), std::ranges::find(env_ptrs, nullptr));
diff --git a/src/video_core/shader_environment.cpp b/src/video_core/shader_environment.cpp
index c7cb56243..4edbe5700 100644
--- a/src/video_core/shader_environment.cpp
+++ b/src/video_core/shader_environment.cpp
@@ -102,7 +102,8 @@ static std::string_view StageToPrefix(Shader::Stage stage) {
    }
 }
-static void DumpImpl(u64 hash, const u64* code, u32 read_highest, u32 read_lowest,
+static void DumpImpl(u64 pipeline_hash, u64 shader_hash, std::span<const u64> code,
+                     [[maybe_unused]] u32 read_highest, [[maybe_unused]] u32 read_lowest,
                     u32 initial_offset, Shader::Stage stage) {
    const auto shader_dir{Common::FS::GetYuzuPath(Common::FS::YuzuPath::DumpDir)};
    const auto base_dir{shader_dir / "shaders"};
@@ -111,13 +112,18 @@ static void DumpImpl(u64 hash, const u64* code, u32 read_highest, u32 read_lowes
        return;
    }
    const auto prefix = StageToPrefix(stage);
-    const auto name{base_dir / fmt::format("{}{:016x}.ash", prefix, hash)};
+    const auto name{base_dir /
-    const size_t real_size = read_highest - read_lowest + initial_offset;
+                    fmt::format("{:016x}_{}_{:016x}.ash", pipeline_hash, prefix, shader_hash)};
-    const size_t padding_needed = ((32 - (real_size % 32)) % 32);
    std::fstream shader_file(name, std::ios::out | std::ios::binary);
+    ASSERT(initial_offset % sizeof(u64) == 0);
    const size_t jump_index = initial_offset / sizeof(u64);
-    shader_file.write(reinterpret_cast<const char*>(code + jump_index), real_size);
+    const size_t code_size = code.size_bytes() - initial_offset;
-    for (size_t i = 0; i < padding_needed; i++) {
+    shader_file.write(reinterpret_cast<const char*>(&code[jump_index]), code_size);
+    // + 1 instruction, due to the fact that we skip the final self branch instruction in the code,
+    // but we need to consider it for padding, otherwise nvdisasm rages.
+    const size_t padding_needed = (32 - ((code_size + INST_SIZE) % 32)) % 32;
+    for (size_t i = 0; i < INST_SIZE + padding_needed; i++) {
        shader_file.put(0);
    }
 }
@@ -197,8 +203,8 @@ u64 GenericEnvironment::CalculateHash() const {
    return Common::CityHash64(data.get(), size);
 }
-void GenericEnvironment::Dump(u64 hash) {
+void GenericEnvironment::Dump(u64 pipeline_hash, u64 shader_hash) {
-    DumpImpl(hash, code.data(), read_highest, read_lowest, initial_offset, stage);
+    DumpImpl(pipeline_hash, shader_hash, code, read_highest, read_lowest, initial_offset, stage);
 }
 void GenericEnvironment::Serialize(std::ofstream& file) const {
@@ -282,6 +288,7 @@ std::optional<u64> GenericEnvironment::TryFindSize() {
 Tegra::Texture::TICEntry GenericEnvironment::ReadTextureInfo(GPUVAddr tic_addr, u32 tic_limit,
                                                             bool via_header_index, u32 raw) {
    const auto handle{Tegra::Texture::TexturePair(raw, via_header_index)};
+    ASSERT(handle.first <= tic_limit);
    const GPUVAddr descriptor_addr{tic_addr + handle.first * sizeof(Tegra::Texture::TICEntry)};
    Tegra::Texture::TICEntry entry;
    gpu_memory->ReadBlock(descriptor_addr, &entry, sizeof(entry));
@@ -465,8 +472,8 @@ void FileEnvironment::Deserialize(std::ifstream& file) {
        .read(reinterpret_cast<char*>(&read_highest), sizeof(read_highest))
        .read(reinterpret_cast<char*>(&viewport_transform_state), sizeof(viewport_transform_state))
        .read(reinterpret_cast<char*>(&stage), sizeof(stage));
-    code = std::make_unique<u64[]>(Common::DivCeil(code_size, sizeof(u64)));
+    code.resize(Common::DivCeil(code_size, sizeof(u64)));
-    file.read(reinterpret_cast<char*>(code.get()), code_size);
+    file.read(reinterpret_cast<char*>(code.data()), code_size);
    for (size_t i = 0; i < num_texture_types; ++i) {
        u32 key;
        Shader::TextureType type;
@@ -509,8 +516,8 @@ void FileEnvironment::Deserialize(std::ifstream& file) {
    is_propietary_driver = texture_bound == 2;
 }
-void FileEnvironment::Dump(u64 hash) {
+void FileEnvironment::Dump(u64 pipeline_hash, u64 shader_hash) {
-    DumpImpl(hash, code.get(), read_highest, read_lowest, initial_offset, stage);
+    DumpImpl(pipeline_hash, shader_hash, code, read_highest, read_lowest, initial_offset, stage);
 }
 u64 FileEnvironment::ReadInstruction(u32 address) {
diff --git a/src/video_core/shader_environment.h b/src/video_core/shader_environment.h
index a0f61cbda..b90f3d44e 100644
--- a/src/video_core/shader_environment.h
+++ b/src/video_core/shader_environment.h
@@ -58,7 +58,7 @@ public:
    [[nodiscard]] u64 CalculateHash() const;
-    void Dump(u64 hash) override;
+    void Dump(u64 pipeline_hash, u64 shader_hash) override;
    void Serialize(std::ofstream& file) const;
@@ -188,10 +188,10 @@ public:
        return cbuf_replacements.size() != 0;
    }
-    void Dump(u64 hash) override;
+    void Dump(u64 pipeline_hash, u64 shader_hash) override;
 private:
-    std::unique_ptr<u64[]> code;
+    std::vector<u64> code;
    std::unordered_map<u32, Shader::TextureType> texture_types;
    std::unordered_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
    std::unordered_map<u64, u32> cbuf_values;
diff --git a/src/video_core/vulkan_common/vulkan_device.cpp b/src/video_core/vulkan_common/vulkan_device.cpp
index bd67e27ed..adde96aa5 100644
--- a/src/video_core/vulkan_common/vulkan_device.cpp
+++ b/src/video_core/vulkan_common/vulkan_device.cpp
@@ -326,6 +326,43 @@ std::vector<const char*> ExtensionListForVulkan(
 } // Anonymous namespace
+void Device::RemoveExtension(bool& extension, const std::string& extension_name) {
+    extension = false;
+    loaded_extensions.erase(extension_name);
+}
+void Device::RemoveExtensionIfUnsuitable(bool is_suitable, const std::string& extension_name) {
+    if (loaded_extensions.contains(extension_name) && !is_suitable) {
+        LOG_WARNING(Render_Vulkan, "Removing unsuitable extension {}", extension_name);
+        this->RemoveExtension(is_suitable, extension_name);
+    }
+}
+template <typename Feature>
+void Device::RemoveExtensionFeature(bool& extension, Feature& feature,
+                                    const std::string& extension_name) {
+    // Unload extension.
+    this->RemoveExtension(extension, extension_name);
+    // Save sType and pNext for chain.
+    VkStructureType sType = feature.sType;
+    void* pNext = feature.pNext;
+    // Clear feature struct and restore chain.
+    feature = {};
+    feature.sType = sType;
+    feature.pNext = pNext;
+}
+template <typename Feature>
+void Device::RemoveExtensionFeatureIfUnsuitable(bool is_suitable, Feature& feature,
+                                                const std::string& extension_name) {
+    if (loaded_extensions.contains(extension_name) && !is_suitable) {
+        LOG_WARNING(Render_Vulkan, "Removing features for unsuitable extension {}", extension_name);
+        this->RemoveExtensionFeature(is_suitable, feature, extension_name);
+    }
+}
 Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR surface,
               const vk::InstanceDispatch& dld_)
    : instance{instance_}, dld{dld_}, physical{physical_},
@@ -397,21 +434,20 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
    if (is_qualcomm || is_turnip) {
        LOG_WARNING(Render_Vulkan,
                    "Qualcomm and Turnip drivers have broken VK_EXT_custom_border_color");
-        extensions.custom_border_color = false;
+        RemoveExtensionFeature(extensions.custom_border_color, features.custom_border_color,
-        loaded_extensions.erase(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
+                               VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
    }
    if (is_qualcomm) {
        must_emulate_scaled_formats = true;
        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken VK_EXT_extended_dynamic_state");
-        extensions.extended_dynamic_state = false;
+        RemoveExtensionFeature(extensions.extended_dynamic_state, features.extended_dynamic_state,
-        loaded_extensions.erase(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+                               VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
        LOG_WARNING(Render_Vulkan,
                    "Qualcomm drivers have a slow VK_KHR_push_descriptor implementation");
-        extensions.push_descriptor = false;
+        RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
-        loaded_extensions.erase(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
 #if defined(ANDROID) && defined(ARCHITECTURE_arm64)
        // Patch the driver to enable BCn textures.
@@ -440,15 +476,12 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
        must_emulate_scaled_formats = true;
        LOG_WARNING(Render_Vulkan, "ARM drivers have broken VK_EXT_extended_dynamic_state");
-        extensions.extended_dynamic_state = false;
+        RemoveExtensionFeature(extensions.extended_dynamic_state, features.extended_dynamic_state,
-        loaded_extensions.erase(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+                               VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
        LOG_WARNING(Render_Vulkan, "ARM drivers have broken VK_EXT_extended_dynamic_state2");
-        features.extended_dynamic_state2.extendedDynamicState2 = false;
+        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2,
-        features.extended_dynamic_state2.extendedDynamicState2LogicOp = false;
+                               VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-        features.extended_dynamic_state2.extendedDynamicState2PatchControlPoints = false;
-        extensions.extended_dynamic_state2 = false;
-        loaded_extensions.erase(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
    }
    if (is_nvidia) {
@@ -464,8 +497,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
        case NvidiaArchitecture::VoltaOrOlder:
            if (nv_major_version < 527) {
                LOG_WARNING(Render_Vulkan, "Volta and older have broken VK_KHR_push_descriptor");
-                extensions.push_descriptor = false;
+                RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
-                loaded_extensions.erase(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
            }
            break;
        }
@@ -480,8 +512,9 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
        if (version < VK_MAKE_API_VERSION(0, 21, 2, 0)) {
            LOG_WARNING(Render_Vulkan,
                        "RADV versions older than 21.2 have broken VK_EXT_extended_dynamic_state");
-            extensions.extended_dynamic_state = false;
+            RemoveExtensionFeature(extensions.extended_dynamic_state,
-            loaded_extensions.erase(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+                                   features.extended_dynamic_state,
+                                   VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
        }
    }
    if (extensions.extended_dynamic_state2 && is_radv) {
@@ -490,11 +523,9 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
            LOG_WARNING(
                Render_Vulkan,
                "RADV versions older than 22.3.1 have broken VK_EXT_extended_dynamic_state2");
-            features.extended_dynamic_state2.extendedDynamicState2 = false;
+            RemoveExtensionFeature(extensions.extended_dynamic_state2,
-            features.extended_dynamic_state2.extendedDynamicState2LogicOp = false;
+                                   features.extended_dynamic_state2,
-            features.extended_dynamic_state2.extendedDynamicState2PatchControlPoints = false;
+                                   VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-            extensions.extended_dynamic_state2 = false;
-            loaded_extensions.erase(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
        }
    }
    if (extensions.extended_dynamic_state2 && is_qualcomm) {
@@ -504,11 +535,9 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
            // Qualcomm Adreno 7xx drivers do not properly support extended_dynamic_state2.
            LOG_WARNING(Render_Vulkan,
                        "Qualcomm Adreno 7xx drivers have broken VK_EXT_extended_dynamic_state2");
-            features.extended_dynamic_state2.extendedDynamicState2 = false;
+            RemoveExtensionFeature(extensions.extended_dynamic_state2,
-            features.extended_dynamic_state2.extendedDynamicState2LogicOp = false;
+                                   features.extended_dynamic_state2,
-            features.extended_dynamic_state2.extendedDynamicState2PatchControlPoints = false;
+                                   VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-            extensions.extended_dynamic_state2 = false;
-            loaded_extensions.erase(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
        }
    }
    if (extensions.extended_dynamic_state3 && is_radv) {
@@ -540,9 +569,9 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
        if (is_rdna2) {
            LOG_WARNING(Render_Vulkan,
                        "RADV has broken VK_EXT_vertex_input_dynamic_state on RDNA2 hardware");
-            features.vertex_input_dynamic_state.vertexInputDynamicState = false;
+            RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
-            extensions.vertex_input_dynamic_state = false;
+                                   features.vertex_input_dynamic_state,
-            loaded_extensions.erase(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+                                   VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
        }
    }
    if (extensions.vertex_input_dynamic_state && is_qualcomm) {
@@ -553,9 +582,9 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
            LOG_WARNING(
                Render_Vulkan,
                "Qualcomm Adreno 7xx drivers have broken VK_EXT_vertex_input_dynamic_state");
-            features.vertex_input_dynamic_state.vertexInputDynamicState = false;
+            RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
-            extensions.vertex_input_dynamic_state = false;
+                                   features.vertex_input_dynamic_state,
-            loaded_extensions.erase(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+                                   VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
        }
    }
@@ -575,8 +604,8 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
        if (!features.shader_float16_int8.shaderFloat16) {
            LOG_WARNING(Render_Vulkan,
                        "AMD GCN4 and earlier have broken VK_EXT_sampler_filter_minmax");
-            extensions.sampler_filter_minmax = false;
+            RemoveExtension(extensions.sampler_filter_minmax,
-            loaded_extensions.erase(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME);
+                            VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME);
        }
    }
@@ -584,8 +613,9 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
        const u32 version = (properties.properties.driverVersion << 3) >> 3;
        if (version < VK_MAKE_API_VERSION(27, 20, 100, 0)) {
            LOG_WARNING(Render_Vulkan, "Intel has broken VK_EXT_vertex_input_dynamic_state");
-            extensions.vertex_input_dynamic_state = false;
+            RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
-            loaded_extensions.erase(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+                                   features.vertex_input_dynamic_state,
+                                   VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
        }
    }
    if (features.shader_float16_int8.shaderFloat16 && is_intel_windows) {
@@ -612,8 +642,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
            // mesa/mesa/-/commit/ff91c5ca42bc80aa411cb3fd8f550aa6fdd16bdc
            LOG_WARNING(Render_Vulkan,
                        "ANV drivers 22.3.0 to 23.1.0 have broken VK_KHR_push_descriptor");
-            extensions.push_descriptor = false;
+            RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
-            loaded_extensions.erase(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
        }
    }
    if (is_mvk) {
@@ -963,7 +992,7 @@ bool Device::GetSuitability(bool requires_swapchain) {
            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
        SetNext(next, properties.push_descriptor);
    }
-    if (extensions.subgroup_size_control) {
+    if (extensions.subgroup_size_control || features.subgroup_size_control.subgroupSizeControl) {
        properties.subgroup_size_control.sType =
            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
        SetNext(next, properties.subgroup_size_control);
@@ -1007,34 +1036,29 @@ bool Device::GetSuitability(bool requires_swapchain) {
    return suitable;
 }
-void Device::RemoveExtensionIfUnsuitable(bool is_suitable, const std::string& extension_name) {
-    if (loaded_extensions.contains(extension_name) && !is_suitable) {
-        LOG_WARNING(Render_Vulkan, "Removing unsuitable extension {}", extension_name);
-        loaded_extensions.erase(extension_name);
-    }
-}
 void Device::RemoveUnsuitableExtensions() {
    // VK_EXT_custom_border_color
    extensions.custom_border_color = features.custom_border_color.customBorderColors &&
                                     features.custom_border_color.customBorderColorWithoutFormat;
-    RemoveExtensionIfUnsuitable(extensions.custom_border_color,
+    RemoveExtensionFeatureIfUnsuitable(extensions.custom_border_color, features.custom_border_color,
-                                VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
+                                       VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
    // VK_EXT_depth_clip_control
    extensions.depth_clip_control = features.depth_clip_control.depthClipControl;
-    RemoveExtensionIfUnsuitable(extensions.depth_clip_control,
+    RemoveExtensionFeatureIfUnsuitable(extensions.depth_clip_control, features.depth_clip_control,
-                                VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME);
+                                       VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME);
    // VK_EXT_extended_dynamic_state
    extensions.extended_dynamic_state = features.extended_dynamic_state.extendedDynamicState;
-    RemoveExtensionIfUnsuitable(extensions.extended_dynamic_state,
+    RemoveExtensionFeatureIfUnsuitable(extensions.extended_dynamic_state,
-                                VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+                                       features.extended_dynamic_state,
+                                       VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
    // VK_EXT_extended_dynamic_state2
    extensions.extended_dynamic_state2 = features.extended_dynamic_state2.extendedDynamicState2;
-    RemoveExtensionIfUnsuitable(extensions.extended_dynamic_state2,
+    RemoveExtensionFeatureIfUnsuitable(extensions.extended_dynamic_state2,
-                                VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
+                                       features.extended_dynamic_state2,
+                                       VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
    // VK_EXT_extended_dynamic_state3
    dynamic_state3_blending =
@@ -1048,35 +1072,38 @@ void Device::RemoveUnsuitableExtensions() {
    extensions.extended_dynamic_state3 = dynamic_state3_blending || dynamic_state3_enables;
    dynamic_state3_blending = dynamic_state3_blending && extensions.extended_dynamic_state3;
    dynamic_state3_enables = dynamic_state3_enables && extensions.extended_dynamic_state3;
-    RemoveExtensionIfUnsuitable(extensions.extended_dynamic_state3,
+    RemoveExtensionFeatureIfUnsuitable(extensions.extended_dynamic_state3,
-                                VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
+                                       features.extended_dynamic_state3,
+                                       VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
    // VK_EXT_provoking_vertex
    extensions.provoking_vertex =
        features.provoking_vertex.provokingVertexLast &&
        features.provoking_vertex.transformFeedbackPreservesProvokingVertex;
-    RemoveExtensionIfUnsuitable(extensions.provoking_vertex,
+    RemoveExtensionFeatureIfUnsuitable(extensions.provoking_vertex, features.provoking_vertex,
-                                VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME);
+                                       VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME);
    // VK_KHR_shader_atomic_int64
    extensions.shader_atomic_int64 = features.shader_atomic_int64.shaderBufferInt64Atomics &&
                                     features.shader_atomic_int64.shaderSharedInt64Atomics;
-    RemoveExtensionIfUnsuitable(extensions.shader_atomic_int64,
+    RemoveExtensionFeatureIfUnsuitable(extensions.shader_atomic_int64, features.shader_atomic_int64,
-                                VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME);
+                                       VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME);
    // VK_EXT_shader_demote_to_helper_invocation
    extensions.shader_demote_to_helper_invocation =
        features.shader_demote_to_helper_invocation.shaderDemoteToHelperInvocation;
-    RemoveExtensionIfUnsuitable(extensions.shader_demote_to_helper_invocation,
+    RemoveExtensionFeatureIfUnsuitable(extensions.shader_demote_to_helper_invocation,
-                                VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME);
+                                       features.shader_demote_to_helper_invocation,
+                                       VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME);
    // VK_EXT_subgroup_size_control
    extensions.subgroup_size_control =
        features.subgroup_size_control.subgroupSizeControl &&
        properties.subgroup_size_control.minSubgroupSize <= GuestWarpSize &&
        properties.subgroup_size_control.maxSubgroupSize >= GuestWarpSize;
-    RemoveExtensionIfUnsuitable(extensions.subgroup_size_control,
+    RemoveExtensionFeatureIfUnsuitable(extensions.subgroup_size_control,
-                                VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME);
+                                       features.subgroup_size_control,
+                                       VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME);
    // VK_EXT_transform_feedback
    extensions.transform_feedback =
@@ -1086,24 +1113,27 @@ void Device::RemoveUnsuitableExtensions() {
        properties.transform_feedback.maxTransformFeedbackBuffers > 0 &&
        properties.transform_feedback.transformFeedbackQueries &&
        properties.transform_feedback.transformFeedbackDraw;
-    RemoveExtensionIfUnsuitable(extensions.transform_feedback,
+    RemoveExtensionFeatureIfUnsuitable(extensions.transform_feedback, features.transform_feedback,
-                                VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
+                                       VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
    // VK_EXT_vertex_input_dynamic_state
    extensions.vertex_input_dynamic_state =
        features.vertex_input_dynamic_state.vertexInputDynamicState;
-    RemoveExtensionIfUnsuitable(extensions.vertex_input_dynamic_state,
+    RemoveExtensionFeatureIfUnsuitable(extensions.vertex_input_dynamic_state,
-                                VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+                                       features.vertex_input_dynamic_state,
+                                       VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
    // VK_KHR_pipeline_executable_properties
    if (Settings::values.renderer_shader_feedback.GetValue()) {
        extensions.pipeline_executable_properties =
            features.pipeline_executable_properties.pipelineExecutableInfo;
-        RemoveExtensionIfUnsuitable(extensions.pipeline_executable_properties,
+        RemoveExtensionFeatureIfUnsuitable(extensions.pipeline_executable_properties,
-                                    VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
+                                           features.pipeline_executable_properties,
+                                           VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
    } else {
-        extensions.pipeline_executable_properties = false;
+        RemoveExtensionFeature(extensions.pipeline_executable_properties,
-        loaded_extensions.erase(VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
+                               features.pipeline_executable_properties,
+                               VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
    }
    // VK_KHR_workgroup_memory_explicit_layout
@@ -1113,8 +1143,9 @@ void Device::RemoveUnsuitableExtensions() {
        features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout8BitAccess &&
        features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout16BitAccess &&
        features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayoutScalarBlockLayout;
-    RemoveExtensionIfUnsuitable(extensions.workgroup_memory_explicit_layout,
+    RemoveExtensionFeatureIfUnsuitable(extensions.workgroup_memory_explicit_layout,
-                                VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME);
+                                       features.workgroup_memory_explicit_layout,
+                                       VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME);
 }
 void Device::SetupFamilies(VkSurfaceKHR surface) {
diff --git a/src/video_core/vulkan_common/vulkan_device.h b/src/video_core/vulkan_common/vulkan_device.h
index be3ed45ff..488fdd313 100644
--- a/src/video_core/vulkan_common/vulkan_device.h
+++ b/src/video_core/vulkan_common/vulkan_device.h
@@ -20,7 +20,6 @@ VK_DEFINE_HANDLE(VmaAllocator)
 // Vulkan version in the macro describes the minimum version required for feature availability.
 // If the Vulkan version is lower than the required version, the named extension is required.
 #define FOR_EACH_VK_FEATURE_1_1(FEATURE)                                                           \
-    FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)                \
    FEATURE(KHR, 16BitStorage, 16BIT_STORAGE, bit16_storage)                                       \
    FEATURE(KHR, ShaderAtomicInt64, SHADER_ATOMIC_INT64, shader_atomic_int64)                      \
    FEATURE(KHR, ShaderDrawParameters, SHADER_DRAW_PARAMETERS, shader_draw_parameters)             \
@@ -36,7 +35,8 @@ VK_DEFINE_HANDLE(VmaAllocator)
 #define FOR_EACH_VK_FEATURE_1_3(FEATURE)                                                           \
    FEATURE(EXT, ShaderDemoteToHelperInvocation, SHADER_DEMOTE_TO_HELPER_INVOCATION,               \
-            shader_demote_to_helper_invocation)
+            shader_demote_to_helper_invocation)                                                    \
+    FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)
 // Define all features which may be used by the implementation and require an extension here.
 #define FOR_EACH_VK_FEATURE_EXT(FEATURE)                                                           \
@@ -639,8 +639,17 @@ private:
    // Remove extensions which have incomplete feature support.
    void RemoveUnsuitableExtensions();
+    void RemoveExtension(bool& extension, const std::string& extension_name);
    void RemoveExtensionIfUnsuitable(bool is_suitable, const std::string& extension_name);
+    template <typename Feature>
+    void RemoveExtensionFeature(bool& extension, Feature& feature,
+                                const std::string& extension_name);
+    template <typename Feature>
+    void RemoveExtensionFeatureIfUnsuitable(bool is_suitable, Feature& feature,
+                                            const std::string& extension_name);
    /// Sets up queue families.
    void SetupFamilies(VkSurfaceKHR surface);
diff --git a/src/yuzu/game_list.cpp b/src/yuzu/game_list.cpp
index 465084fea..b5a02700d 100644
--- a/src/yuzu/game_list.cpp
+++ b/src/yuzu/game_list.cpp
@@ -214,13 +214,17 @@ void GameList::OnTextChanged(const QString& new_text) {
            const int children_count = folder->rowCount();
            for (int j = 0; j < children_count; ++j) {
                ++children_total;
                const QStandardItem* child = folder->child(j, 0);
+                const auto program_id = child->data(GameListItemPath::ProgramIdRole).toULongLong();
                const QString file_path =
                    child->data(GameListItemPath::FullPathRole).toString().toLower();
                const QString file_title =
                    child->data(GameListItemPath::TitleRole).toString().toLower();
                const QString file_program_id =
-                    child->data(GameListItemPath::ProgramIdRole).toString().toLower();
+                    QStringLiteral("%1").arg(program_id, 16, 16, QLatin1Char{'0'});
                // Only items which filename in combination with its title contains all words
                // that are in the searchfield will be visible in the gamelist
@@ -231,7 +235,7 @@ void GameList::OnTextChanged(const QString& new_text) {
                    file_path.mid(file_path.lastIndexOf(QLatin1Char{'/'}) + 1) + QLatin1Char{' '} +
                    file_title;
                if (ContainsAllWords(file_name, edit_filter_text) ||
-                    (file_program_id.count() == 16 && edit_filter_text.contains(file_program_id))) {
+                    (file_program_id.count() == 16 && file_program_id.contains(edit_filter_text))) {
                    tree_view->setRowHidden(j, folder_index, false);
                    ++result_count;
                } else {