39 files changed, 815 insertions, 225 deletions
diff --git a/dist/72-yuzu-input.rules b/dist/72-yuzu-input.rules
new file mode 100644
index 000000000..d64f8b28d
--- /dev/null
+++ b/dist/72-yuzu-input.rules
@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+# SPDX-License-Identifier: GPL-2.0-or-later
+# Allow systemd-logind to manage user access to hidraw with this file
+# On most systems, this file should be installed to /etc/udev/rules.d/72-yuzu-input.rules
+# Consult your distro if this is not the case
+# Switch Pro Controller (USB/Bluetooth)
+KERNEL=="hidraw*", ATTRS{idVendor}=="057e", ATTRS{idProduct}=="2009", MODE="0660", TAG+="uaccess"
+KERNEL=="hidraw*", KERNELS=="*057e:2009*", MODE="0660", TAG+="uaccess"
+# Joy-Con L (Bluetooth)
+KERNEL=="hidraw*", KERNELS=="*057e:2006*", MODE="0660", TAG+="uaccess"
+# Joy-Con R (Bluetooth)
+KERNEL=="hidraw*", KERNELS=="*057e:2007*", MODE="0660", TAG+="uaccess"
+# Joy-Con Charging Grip (USB)
+KERNEL=="hidraw*", ATTRS{idVendor}=="057e", ATTRS{idProduct}=="200e", MODE="0660", TAG+="uaccess"
diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/AddGameFolderDialogFragment.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/AddGameFolderDialogFragment.kt
index dec2b7cf1..9fab88248 100644
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/AddGameFolderDialogFragment.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/AddGameFolderDialogFragment.kt
@@ -14,8 +14,10 @@ import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.databinding.DialogAddFolderBinding
 import org.yuzu.yuzu_emu.model.GameDir
 import org.yuzu.yuzu_emu.model.GamesViewModel
+import org.yuzu.yuzu_emu.model.HomeViewModel
 class AddGameFolderDialogFragment : DialogFragment() {
+    private val homeViewModel: HomeViewModel by activityViewModels()
    private val gamesViewModel: GamesViewModel by activityViewModels()
    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
@@ -30,6 +32,7 @@ class AddGameFolderDialogFragment : DialogFragment() {
            .setTitle(R.string.add_game_folder)
            .setPositiveButton(android.R.string.ok) { _: DialogInterface, _: Int ->
                val newGameDir = GameDir(folderUriString!!, binding.deepScanSwitch.isChecked)
+                homeViewModel.setGamesDirSelected(true)
                gamesViewModel.addFolder(newGameDir)
            }
            .setNegativeButton(android.R.string.cancel, null)
diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SetupFragment.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SetupFragment.kt
index c4277735d..eb5edaa10 100644
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SetupFragment.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SetupFragment.kt
@@ -4,6 +4,7 @@
 package org.yuzu.yuzu_emu.fragments
 import android.Manifest
+import android.annotation.SuppressLint
 import android.content.Intent
 import android.os.Build
 import android.os.Bundle
@@ -75,6 +76,8 @@ class SetupFragment : Fragment() {
        return binding.root
    }
+    // This is using the correct scope, lint is just acting up
+    @SuppressLint("UnsafeRepeatOnLifecycleDetector")
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        mainActivity = requireActivity() as MainActivity
@@ -206,12 +209,24 @@ class SetupFragment : Fragment() {
            )
        }
-        viewLifecycleOwner.lifecycleScope.launch {
+        viewLifecycleOwner.lifecycleScope.apply {
-            repeatOnLifecycle(Lifecycle.State.CREATED) {
+            launch {
-                homeViewModel.shouldPageForward.collect {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
-                    if (it) {
+                    homeViewModel.shouldPageForward.collect {
-                        pageForward()
+                        if (it) {
-                        homeViewModel.setShouldPageForward(false)
+                            pageForward()
+                            homeViewModel.setShouldPageForward(false)
+                        }
+                    }
+                }
+            }
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    homeViewModel.gamesDirSelected.collect {
+                        if (it) {
+                            gamesDirCallback.onStepCompleted()
+                            homeViewModel.setGamesDirSelected(false)
+                        }
                    }
                }
            }
@@ -339,7 +354,6 @@ class SetupFragment : Fragment() {
        registerForActivityResult(ActivityResultContracts.OpenDocumentTree()) { result ->
            if (result != null) {
                mainActivity.processGamesDir(result)
-                gamesDirCallback.onStepCompleted()
            }
        }
diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/GamesViewModel.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/GamesViewModel.kt
index 752d98c10..fd925235b 100644
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/GamesViewModel.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/GamesViewModel.kt
@@ -133,7 +133,7 @@ class GamesViewModel : ViewModel() {
        viewModelScope.launch {
            withContext(Dispatchers.IO) {
                NativeConfig.addGameDir(gameDir)
-                getGameDirs()
+                getGameDirs(true)
            }
        }
diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/HomeViewModel.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/HomeViewModel.kt
index 251b5a667..07e65b028 100644
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/HomeViewModel.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/HomeViewModel.kt
@@ -6,6 +6,7 @@ package org.yuzu.yuzu_emu.model
 import androidx.lifecycle.ViewModel
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 class HomeViewModel : ViewModel() {
    val navigationVisible: StateFlow<Pair<Boolean, Boolean>> get() = _navigationVisible
@@ -17,6 +18,9 @@ class HomeViewModel : ViewModel() {
    val shouldPageForward: StateFlow<Boolean> get() = _shouldPageForward
    private val _shouldPageForward = MutableStateFlow(false)
+    private val _gamesDirSelected = MutableStateFlow(false)
+    val gamesDirSelected get() = _gamesDirSelected.asStateFlow()
    var navigatedToSetup = false
    fun setNavigationVisibility(visible: Boolean, animated: Boolean) {
@@ -36,4 +40,8 @@ class HomeViewModel : ViewModel() {
    fun setShouldPageForward(pageForward: Boolean) {
        _shouldPageForward.value = pageForward
    }
+    fun setGamesDirSelected(selected: Boolean) {
+        _gamesDirSelected.value = selected
+    }
 }
diff --git a/src/common/settings.cpp b/src/common/settings.cpp
index 4666bd0a0..88f509ba7 100644
--- a/src/common/settings.cpp
+++ b/src/common/settings.cpp
@@ -160,12 +160,16 @@ static bool is_nce_enabled = false;
 void SetNceEnabled(bool is_39bit) {
    const bool is_nce_selected = values.cpu_backend.GetValue() == CpuBackend::Nce;
-    is_nce_enabled = IsFastmemEnabled() && is_nce_selected && is_39bit;
+    if (is_nce_selected && !IsFastmemEnabled()) {
-    if (is_nce_selected && !is_nce_enabled) {
+        LOG_WARNING(Common, "Fastmem is required to natively execute code in a performant manner, "
+                            "falling back to Dynarmic");
+    }
+    if (is_nce_selected && !is_39bit) {
        LOG_WARNING(
            Common,
            "Program does not utilize 39-bit address space, unable to natively execute code");
    }
+    is_nce_enabled = IsFastmemEnabled() && is_nce_selected && is_39bit;
 }
 bool IsNceEnabled() {
diff --git a/src/common/settings.h b/src/common/settings.h
index 98341ad96..7dc18fffe 100644
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -180,14 +180,20 @@ struct Values {
                                             &use_speed_limit};
    // Cpu
-    SwitchableSetting<CpuBackend, true> cpu_backend{
+    SwitchableSetting<CpuBackend, true> cpu_backend{linkage,
-        linkage,         CpuBackend::Dynarmic, CpuBackend::Dynarmic,
 #ifdef HAS_NCE
-        CpuBackend::Nce,
+                                                    CpuBackend::Nce,
 #else
                                                    CpuBackend::Dynarmic,
 #endif
-        "cpu_backend",   Category::Cpu};
+                                                    CpuBackend::Dynarmic,
+#ifdef HAS_NCE
+                                                    CpuBackend::Nce,
+#else
+                                                    CpuBackend::Dynarmic,
+#endif
+                                                    "cpu_backend",
+                                                    Category::Cpu};
    SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage,           CpuAccuracy::Auto,
                                                      CpuAccuracy::Auto, CpuAccuracy::Paranoid,
                                                      "cpu_accuracy",    Category::Cpu};
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 05c103f51..27d636ed4 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -549,6 +549,8 @@ add_library(core STATIC
    hle/service/hid/xcd.cpp
    hle/service/hid/xcd.h
    hle/service/hid/errors.h
+    hle/service/hid/controllers/applet_resource.cpp
+    hle/service/hid/controllers/applet_resource.h
    hle/service/hid/controllers/console_six_axis.cpp
    hle/service/hid/controllers/console_six_axis.h
    hle/service/hid/controllers/controller_base.cpp
diff --git a/src/core/arm/debug.cpp b/src/core/arm/debug.cpp
index 1fe37b8ee..af1c34bc3 100644
--- a/src/core/arm/debug.cpp
+++ b/src/core/arm/debug.cpp
@@ -282,6 +282,8 @@ Loader::AppLoader::Modules FindModules(const Kernel::KProcess* process) {
                    // Ignore leading directories.
                    char* path_pointer = module_path.path.data();
+                    char* path_end =
+                        path_pointer + std::min(PathLengthMax, module_path.path_length);
                    for (s32 i = 0; i < std::min(PathLengthMax, module_path.path_length) &&
                                    module_path.path[i] != '\0';
@@ -292,7 +294,8 @@ Loader::AppLoader::Modules FindModules(const Kernel::KProcess* process) {
                    }
                    // Insert output.
-                    modules.emplace(svc_mem_info.base_address, path_pointer);
+                    modules.emplace(svc_mem_info.base_address,
+                                    std::string_view(path_pointer, path_end));
                }
            }
        }
diff --git a/src/core/file_sys/fsmitm_romfsbuild.cpp b/src/core/file_sys/fsmitm_romfsbuild.cpp
index f1d3e4129..dd9cca103 100644
--- a/src/core/file_sys/fsmitm_romfsbuild.cpp
+++ b/src/core/file_sys/fsmitm_romfsbuild.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 #include <cstring>
+#include <span>
 #include <string_view>
 #include "common/alignment.h"
 #include "common/assert.h"
@@ -134,7 +135,7 @@ void RomFSBuildContext::VisitDirectory(VirtualDir romfs_dir, VirtualDir ext_dir,
        child->size = child->source->GetSize();
-        AddFile(parent, child);
+        AddFile(parent, std::move(child));
    }
    for (auto& child_romfs_dir : romfs_dir->GetSubdirectories()) {
@@ -163,36 +164,24 @@ void RomFSBuildContext::VisitDirectory(VirtualDir romfs_dir, VirtualDir ext_dir,
 bool RomFSBuildContext::AddDirectory(std::shared_ptr<RomFSBuildDirectoryContext> parent_dir_ctx,
                                     std::shared_ptr<RomFSBuildDirectoryContext> dir_ctx) {
-    // Check whether it's already in the known directories.
-    const auto [it, is_new] = directories.emplace(dir_ctx->path, nullptr);
-    if (!is_new) {
-        return false;
-    }
    // Add a new directory.
    num_dirs++;
    dir_table_size +=
        sizeof(RomFSDirectoryEntry) + Common::AlignUp(dir_ctx->path_len - dir_ctx->cur_path_ofs, 4);
-    dir_ctx->parent = parent_dir_ctx;
+    dir_ctx->parent = std::move(parent_dir_ctx);
-    it->second = dir_ctx;
+    directories.emplace_back(std::move(dir_ctx));
    return true;
 }
 bool RomFSBuildContext::AddFile(std::shared_ptr<RomFSBuildDirectoryContext> parent_dir_ctx,
                                std::shared_ptr<RomFSBuildFileContext> file_ctx) {
-    // Check whether it's already in the known files.
-    const auto [it, is_new] = files.emplace(file_ctx->path, nullptr);
-    if (!is_new) {
-        return false;
-    }
    // Add a new file.
    num_files++;
    file_table_size +=
        sizeof(RomFSFileEntry) + Common::AlignUp(file_ctx->path_len - file_ctx->cur_path_ofs, 4);
-    file_ctx->parent = parent_dir_ctx;
+    file_ctx->parent = std::move(parent_dir_ctx);
-    it->second = file_ctx;
+    files.emplace_back(std::move(file_ctx));
    return true;
 }
@@ -201,7 +190,7 @@ RomFSBuildContext::RomFSBuildContext(VirtualDir base_, VirtualDir ext_)
    : base(std::move(base_)), ext(std::move(ext_)) {
    root = std::make_shared<RomFSBuildDirectoryContext>();
    root->path = "\0";
-    directories.emplace(root->path, root);
+    directories.emplace_back(root);
    num_dirs = 1;
    dir_table_size = 0x18;
@@ -210,28 +199,43 @@ RomFSBuildContext::RomFSBuildContext(VirtualDir base_, VirtualDir ext_)
 RomFSBuildContext::~RomFSBuildContext() = default;
-std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
+std::vector<std::pair<u64, VirtualFile>> RomFSBuildContext::Build() {
    const u64 dir_hash_table_entry_count = romfs_get_hash_table_count(num_dirs);
    const u64 file_hash_table_entry_count = romfs_get_hash_table_count(num_files);
    dir_hash_table_size = 4 * dir_hash_table_entry_count;
    file_hash_table_size = 4 * file_hash_table_entry_count;
-    // Assign metadata pointers
+    // Assign metadata pointers.
    RomFSHeader header{};
-    std::vector<u32> dir_hash_table(dir_hash_table_entry_count, ROMFS_ENTRY_EMPTY);
+    std::vector<u8> metadata(file_hash_table_size + file_table_size + dir_hash_table_size +
-    std::vector<u32> file_hash_table(file_hash_table_entry_count, ROMFS_ENTRY_EMPTY);
+                             dir_table_size);
+    u32* const dir_hash_table_pointer = reinterpret_cast<u32*>(metadata.data());
-    std::vector<u8> dir_table(dir_table_size);
+    u8* const dir_table_pointer = metadata.data() + dir_hash_table_size;
-    std::vector<u8> file_table(file_table_size);
+    u32* const file_hash_table_pointer =
+        reinterpret_cast<u32*>(metadata.data() + dir_hash_table_size + dir_table_size);
-    std::shared_ptr<RomFSBuildFileContext> cur_file;
+    u8* const file_table_pointer =
+        metadata.data() + dir_hash_table_size + dir_table_size + file_hash_table_size;
+    std::span<u32> dir_hash_table(dir_hash_table_pointer, dir_hash_table_entry_count);
+    std::span<u32> file_hash_table(file_hash_table_pointer, file_hash_table_entry_count);
+    std::span<u8> dir_table(dir_table_pointer, dir_table_size);
+    std::span<u8> file_table(file_table_pointer, file_table_size);
+    // Initialize hash tables.
+    std::memset(dir_hash_table.data(), 0xFF, dir_hash_table.size_bytes());
+    std::memset(file_hash_table.data(), 0xFF, file_hash_table.size_bytes());
+    // Sort tables by name.
+    std::sort(files.begin(), files.end(),
+              [](const auto& a, const auto& b) { return a->path < b->path; });
+    std::sort(directories.begin(), directories.end(),
+              [](const auto& a, const auto& b) { return a->path < b->path; });
    // Determine file offsets.
    u32 entry_offset = 0;
    std::shared_ptr<RomFSBuildFileContext> prev_file = nullptr;
-    for (const auto& it : files) {
+    for (const auto& cur_file : files) {
-        cur_file = it.second;
        file_partition_size = Common::AlignUp(file_partition_size, 16);
        cur_file->offset = file_partition_size;
        file_partition_size += cur_file->size;
@@ -243,34 +247,48 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
    }
    // Assign deferred parent/sibling ownership.
    for (auto it = files.rbegin(); it != files.rend(); ++it) {
-        cur_file = it->second;
+        auto& cur_file = *it;
        cur_file->sibling = cur_file->parent->file;
        cur_file->parent->file = cur_file;
    }
-    std::shared_ptr<RomFSBuildDirectoryContext> cur_dir;
    // Determine directory offsets.
    entry_offset = 0;
-    for (const auto& it : directories) {
+    for (const auto& cur_dir : directories) {
-        cur_dir = it.second;
        cur_dir->entry_offset = entry_offset;
        entry_offset +=
            static_cast<u32>(sizeof(RomFSDirectoryEntry) +
                             Common::AlignUp(cur_dir->path_len - cur_dir->cur_path_ofs, 4));
    }
    // Assign deferred parent/sibling ownership.
-    for (auto it = directories.rbegin(); it->second != root; ++it) {
+    for (auto it = directories.rbegin(); (*it) != root; ++it) {
-        cur_dir = it->second;
+        auto& cur_dir = *it;
        cur_dir->sibling = cur_dir->parent->child;
        cur_dir->parent->child = cur_dir;
    }
-    std::multimap<u64, VirtualFile> out;
+    // Create output map.
+    std::vector<std::pair<u64, VirtualFile>> out;
+    out.reserve(num_files + 2);
+    // Set header fields.
+    header.header_size = sizeof(RomFSHeader);
+    header.file_hash_table_size = file_hash_table_size;
+    header.file_table_size = file_table_size;
+    header.dir_hash_table_size = dir_hash_table_size;
+    header.dir_table_size = dir_table_size;
+    header.file_partition_ofs = ROMFS_FILEPARTITION_OFS;
+    header.dir_hash_table_ofs = Common::AlignUp(header.file_partition_ofs + file_partition_size, 4);
+    header.dir_table_ofs = header.dir_hash_table_ofs + header.dir_hash_table_size;
+    header.file_hash_table_ofs = header.dir_table_ofs + header.dir_table_size;
+    header.file_table_ofs = header.file_hash_table_ofs + header.file_hash_table_size;
+    std::vector<u8> header_data(sizeof(RomFSHeader));
+    std::memcpy(header_data.data(), &header, header_data.size());
+    out.emplace_back(0, std::make_shared<VectorVfsFile>(std::move(header_data)));
    // Populate file tables.
-    for (const auto& it : files) {
+    for (const auto& cur_file : files) {
-        cur_file = it.second;
        RomFSFileEntry cur_entry{};
        cur_entry.parent = cur_file->parent->entry_offset;
@@ -287,7 +305,7 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
        cur_entry.name_size = name_size;
-        out.emplace(cur_file->offset + ROMFS_FILEPARTITION_OFS, std::move(cur_file->source));
+        out.emplace_back(cur_file->offset + ROMFS_FILEPARTITION_OFS, std::move(cur_file->source));
        std::memcpy(file_table.data() + cur_file->entry_offset, &cur_entry, sizeof(RomFSFileEntry));
        std::memset(file_table.data() + cur_file->entry_offset + sizeof(RomFSFileEntry), 0,
                    Common::AlignUp(cur_entry.name_size, 4));
@@ -296,8 +314,7 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
    }
    // Populate dir tables.
-    for (const auto& it : directories) {
+    for (const auto& cur_dir : directories) {
-        cur_dir = it.second;
        RomFSDirectoryEntry cur_entry{};
        cur_entry.parent = cur_dir == root ? 0 : cur_dir->parent->entry_offset;
@@ -323,34 +340,13 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
                    cur_dir->path.data() + cur_dir->cur_path_ofs, name_size);
    }
-    // Set header fields.
+    // Write metadata.
-    header.header_size = sizeof(RomFSHeader);
+    out.emplace_back(header.dir_hash_table_ofs,
-    header.file_hash_table_size = file_hash_table_size;
+                     std::make_shared<VectorVfsFile>(std::move(metadata)));
-    header.file_table_size = file_table_size;
-    header.dir_hash_table_size = dir_hash_table_size;
-    header.dir_table_size = dir_table_size;
-    header.file_partition_ofs = ROMFS_FILEPARTITION_OFS;
-    header.dir_hash_table_ofs = Common::AlignUp(header.file_partition_ofs + file_partition_size, 4);
-    header.dir_table_ofs = header.dir_hash_table_ofs + header.dir_hash_table_size;
-    header.file_hash_table_ofs = header.dir_table_ofs + header.dir_table_size;
-    header.file_table_ofs = header.file_hash_table_ofs + header.file_hash_table_size;
-    std::vector<u8> header_data(sizeof(RomFSHeader));
-    std::memcpy(header_data.data(), &header, header_data.size());
-    out.emplace(0, std::make_shared<VectorVfsFile>(std::move(header_data)));
-    std::vector<u8> metadata(file_hash_table_size + file_table_size + dir_hash_table_size +
+    // Sort the output.
-                             dir_table_size);
+    std::sort(out.begin(), out.end(),
-    std::size_t index = 0;
+              [](const auto& a, const auto& b) { return a.first < b.first; });
-    std::memcpy(metadata.data(), dir_hash_table.data(), dir_hash_table.size() * sizeof(u32));
-    index += dir_hash_table.size() * sizeof(u32);
-    std::memcpy(metadata.data() + index, dir_table.data(), dir_table.size());
-    index += dir_table.size();
-    std::memcpy(metadata.data() + index, file_hash_table.data(),
-                file_hash_table.size() * sizeof(u32));
-    index += file_hash_table.size() * sizeof(u32);
-    std::memcpy(metadata.data() + index, file_table.data(), file_table.size());
-    out.emplace(header.dir_hash_table_ofs, std::make_shared<VectorVfsFile>(std::move(metadata)));
    return out;
 }
diff --git a/src/core/file_sys/fsmitm_romfsbuild.h b/src/core/file_sys/fsmitm_romfsbuild.h
index 06e5d5a47..f387c79f1 100644
--- a/src/core/file_sys/fsmitm_romfsbuild.h
+++ b/src/core/file_sys/fsmitm_romfsbuild.h
@@ -22,14 +22,14 @@ public:
    ~RomFSBuildContext();
    // This finalizes the context.
-    std::multimap<u64, VirtualFile> Build();
+    std::vector<std::pair<u64, VirtualFile>> Build();
 private:
    VirtualDir base;
    VirtualDir ext;
    std::shared_ptr<RomFSBuildDirectoryContext> root;
-    std::map<std::string, std::shared_ptr<RomFSBuildDirectoryContext>, std::less<>> directories;
+    std::vector<std::shared_ptr<RomFSBuildDirectoryContext>> directories;
-    std::map<std::string, std::shared_ptr<RomFSBuildFileContext>, std::less<>> files;
+    std::vector<std::shared_ptr<RomFSBuildFileContext>> files;
    u64 num_dirs = 0;
    u64 num_files = 0;
    u64 dir_table_size = 0;
diff --git a/src/core/file_sys/romfs.cpp b/src/core/file_sys/romfs.cpp
index 6de2103a0..6182598ae 100644
--- a/src/core/file_sys/romfs.cpp
+++ b/src/core/file_sys/romfs.cpp
@@ -55,44 +55,68 @@ struct FileEntry {
 };
 static_assert(sizeof(FileEntry) == 0x20, "FileEntry has incorrect size.");
-template <typename Entry>
+struct RomFSTraversalContext {
-std::pair<Entry, std::string> GetEntry(const VirtualFile& file, std::size_t offset) {
+    RomFSHeader header;
-    Entry entry{};
+    VirtualFile file;
-    if (file->ReadObject(&entry, offset) != sizeof(Entry))
+    std::vector<u8> directory_meta;
-        return {};
+    std::vector<u8> file_meta;
-    std::string string(entry.name_length, '\0');
+};
-    if (file->ReadArray(&string[0], string.size(), offset + sizeof(Entry)) != string.size())
+template <typename EntryType, auto Member>
+std::pair<EntryType, std::string> GetEntry(const RomFSTraversalContext& ctx, size_t offset) {
+    const size_t entry_end = offset + sizeof(EntryType);
+    const std::vector<u8>& vec = ctx.*Member;
+    const size_t size = vec.size();
+    const u8* data = vec.data();
+    EntryType entry{};
+    if (entry_end > size) {
        return {};
-    return {entry, string};
+    }
+    std::memcpy(&entry, data + offset, sizeof(EntryType));
+    const size_t name_length = std::min(entry_end + entry.name_length, size) - entry_end;
+    std::string name(reinterpret_cast<const char*>(data + entry_end), name_length);
+    return {entry, std::move(name)};
+}
+std::pair<DirectoryEntry, std::string> GetDirectoryEntry(const RomFSTraversalContext& ctx,
+                                                         size_t directory_offset) {
+    return GetEntry<DirectoryEntry, &RomFSTraversalContext::directory_meta>(ctx, directory_offset);
+}
+std::pair<FileEntry, std::string> GetFileEntry(const RomFSTraversalContext& ctx,
+                                               size_t file_offset) {
+    return GetEntry<FileEntry, &RomFSTraversalContext::file_meta>(ctx, file_offset);
 }
-void ProcessFile(const VirtualFile& file, std::size_t file_offset, std::size_t data_offset,
+void ProcessFile(const RomFSTraversalContext& ctx, u32 this_file_offset,
-                 u32 this_file_offset, std::shared_ptr<VectorVfsDirectory>& parent) {
+                 std::shared_ptr<VectorVfsDirectory>& parent) {
    while (this_file_offset != ROMFS_ENTRY_EMPTY) {
-        auto entry = GetEntry<FileEntry>(file, file_offset + this_file_offset);
+        auto entry = GetFileEntry(ctx, this_file_offset);
-        parent->AddFile(std::make_shared<OffsetVfsFile>(
+        parent->AddFile(std::make_shared<OffsetVfsFile>(ctx.file, entry.first.size,
-            file, entry.first.size, entry.first.offset + data_offset, entry.second));
+                                                        entry.first.offset + ctx.header.data_offset,
+                                                        std::move(entry.second)));
        this_file_offset = entry.first.sibling;
    }
 }
-void ProcessDirectory(const VirtualFile& file, std::size_t dir_offset, std::size_t file_offset,
+void ProcessDirectory(const RomFSTraversalContext& ctx, u32 this_dir_offset,
-                      std::size_t data_offset, u32 this_dir_offset,
                      std::shared_ptr<VectorVfsDirectory>& parent) {
    while (this_dir_offset != ROMFS_ENTRY_EMPTY) {
-        auto entry = GetEntry<DirectoryEntry>(file, dir_offset + this_dir_offset);
+        auto entry = GetDirectoryEntry(ctx, this_dir_offset);
        auto current = std::make_shared<VectorVfsDirectory>(
            std::vector<VirtualFile>{}, std::vector<VirtualDir>{}, entry.second);
        if (entry.first.child_file != ROMFS_ENTRY_EMPTY) {
-            ProcessFile(file, file_offset, data_offset, entry.first.child_file, current);
+            ProcessFile(ctx, entry.first.child_file, current);
        }
        if (entry.first.child_dir != ROMFS_ENTRY_EMPTY) {
-            ProcessDirectory(file, dir_offset, file_offset, data_offset, entry.first.child_dir,
+            ProcessDirectory(ctx, entry.first.child_dir, current);
-                             current);
        }
        parent->AddDirectory(current);
@@ -107,22 +131,25 @@ VirtualDir ExtractRomFS(VirtualFile file) {
        return root_container;
    }
-    RomFSHeader header{};
+    RomFSTraversalContext ctx{};
-    if (file->ReadObject(&header) != sizeof(RomFSHeader)) {
-        return root_container;
+    if (file->ReadObject(&ctx.header) != sizeof(RomFSHeader)) {
+        return nullptr;
    }
-    if (header.header_size != sizeof(RomFSHeader)) {
+    if (ctx.header.header_size != sizeof(RomFSHeader)) {
-        return root_container;
+        return nullptr;
    }
-    const u64 file_offset = header.file_meta.offset;
+    ctx.file = file;
-    const u64 dir_offset = header.directory_meta.offset;
+    ctx.directory_meta =
+        file->ReadBytes(ctx.header.directory_meta.size, ctx.header.directory_meta.offset);
+    ctx.file_meta = file->ReadBytes(ctx.header.file_meta.size, ctx.header.file_meta.offset);
-    ProcessDirectory(file, dir_offset, file_offset, header.data_offset, 0, root_container);
+    ProcessDirectory(ctx, 0, root_container);
    if (auto root = root_container->GetSubdirectory(""); root) {
-        return std::make_shared<CachedVfsDirectory>(std::move(root));
+        return root;
    }
    ASSERT(false);
diff --git a/src/core/file_sys/vfs_concat.cpp b/src/core/file_sys/vfs_concat.cpp
index 168b9cbec..7c7298527 100644
--- a/src/core/file_sys/vfs_concat.cpp
+++ b/src/core/file_sys/vfs_concat.cpp
@@ -59,8 +59,8 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(std::string&& name,
    return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map)));
 }
-VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte, std::string&& name,
+VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(
-                                                      std::multimap<u64, VirtualFile>&& files) {
+    u8 filler_byte, std::string&& name, std::vector<std::pair<u64, VirtualFile>>&& files) {
    // Fold trivial cases.
    if (files.empty()) {
        return nullptr;
diff --git a/src/core/file_sys/vfs_concat.h b/src/core/file_sys/vfs_concat.h
index cbddd12bd..b5f3d72e3 100644
--- a/src/core/file_sys/vfs_concat.h
+++ b/src/core/file_sys/vfs_concat.h
@@ -37,7 +37,7 @@ public:
    /// Convenience function that turns a map of offsets to files into a concatenated file, filling
    /// gaps with a given filler byte.
    static VirtualFile MakeConcatenatedFile(u8 filler_byte, std::string&& name,
-                                            std::multimap<u64, VirtualFile>&& files);
+                                            std::vector<std::pair<u64, VirtualFile>>&& files);
    std::string GetName() const override;
    std::size_t GetSize() const override;
diff --git a/src/core/file_sys/vfs_layered.cpp b/src/core/file_sys/vfs_layered.cpp
index 08daca397..5551743fb 100644
--- a/src/core/file_sys/vfs_layered.cpp
+++ b/src/core/file_sys/vfs_layered.cpp
@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <set>
+#include <unordered_set>
 #include <utility>
 #include "core/file_sys/vfs_layered.h"
@@ -59,13 +60,12 @@ std::string LayeredVfsDirectory::GetFullPath() const {
 std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {
    std::vector<VirtualFile> out;
-    std::set<std::string, std::less<>> out_names;
+    std::unordered_set<std::string> out_names;
    for (const auto& layer : dirs) {
        for (auto& file : layer->GetFiles()) {
-            auto file_name = file->GetName();
+            const auto [it, is_new] = out_names.emplace(file->GetName());
-            if (!out_names.contains(file_name)) {
+            if (is_new) {
-                out_names.emplace(std::move(file_name));
                out.emplace_back(std::move(file));
            }
        }
@@ -75,18 +75,19 @@ std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {
 }
 std::vector<VirtualDir> LayeredVfsDirectory::GetSubdirectories() const {
-    std::vector<std::string> names;
+    std::vector<VirtualDir> out;
+    std::unordered_set<std::string> out_names;
    for (const auto& layer : dirs) {
        for (const auto& sd : layer->GetSubdirectories()) {
-            if (std::find(names.begin(), names.end(), sd->GetName()) == names.end())
+            out_names.emplace(sd->GetName());
-                names.push_back(sd->GetName());
        }
    }
-    std::vector<VirtualDir> out;
+    out.reserve(out_names.size());
-    out.reserve(names.size());
+    for (const auto& subdir : out_names) {
-    for (const auto& subdir : names)
        out.emplace_back(GetSubdirectory(subdir));
+    }
    return out;
 }
diff --git a/src/core/hle/service/hid/controllers/applet_resource.cpp b/src/core/hle/service/hid/controllers/applet_resource.cpp
new file mode 100644
index 000000000..ee60d8b44
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/applet_resource.cpp
@@ -0,0 +1,199 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "core/core.h"
+#include "core/hle/kernel/k_shared_memory.h"
+#include "core/hle/service/hid/controllers/applet_resource.h"
+#include "core/hle/service/hid/errors.h"
+namespace Service::HID {
+AppletResource::AppletResource(Core::System& system_) : system{system_} {}
+AppletResource::~AppletResource() = default;
+Result AppletResource::CreateAppletResource(u64 aruid) {
+    const u64 index = GetIndexFromAruid(aruid);
+    if (index >= AruidIndexMax) {
+        return ResultAruidNotRegistered;
+    }
+    if (data[index].flag.is_assigned) {
+        return ResultAruidAlreadyRegistered;
+    }
+    // TODO: Here shared memory is created for the process we don't quite emulate this part so
+    // obtain this pointer from system
+    auto& shared_memory = system.Kernel().GetHidSharedMem();
+    data[index].shared_memory_handle = &shared_memory;
+    data[index].flag.is_assigned.Assign(true);
+    // TODO: InitializeSixAxisControllerConfig(false);
+    active_aruid = aruid;
+    return ResultSuccess;
+}
+Result AppletResource::RegisterAppletResourceUserId(u64 aruid, bool enable_input) {
+    const u64 index = GetIndexFromAruid(aruid);
+    if (index < AruidIndexMax) {
+        return ResultAruidAlreadyRegistered;
+    }
+    std::size_t data_index = AruidIndexMax;
+    for (std::size_t i = 0; i < AruidIndexMax; i++) {
+        if (!data[i].flag.is_initialized) {
+            data_index = i;
+            break;
+        }
+    }
+    if (data_index == AruidIndexMax) {
+        return ResultAruidNoAvailableEntries;
+    }
+    AruidData& aruid_data = data[data_index];
+    aruid_data.aruid = aruid;
+    aruid_data.flag.is_initialized.Assign(true);
+    if (enable_input) {
+        aruid_data.flag.enable_pad_input.Assign(true);
+        aruid_data.flag.enable_six_axis_sensor.Assign(true);
+        aruid_data.flag.bit_18.Assign(true);
+        aruid_data.flag.enable_touchscreen.Assign(true);
+    }
+    data_index = AruidIndexMax;
+    for (std::size_t i = 0; i < AruidIndexMax; i++) {
+        if (registration_list.flag[i] == RegistrationStatus::Initialized) {
+            if (registration_list.aruid[i] != aruid) {
+                continue;
+            }
+            data_index = i;
+            break;
+        }
+        if (registration_list.flag[i] == RegistrationStatus::None) {
+            data_index = i;
+            break;
+        }
+    }
+    if (data_index == AruidIndexMax) {
+        return ResultSuccess;
+    }
+    registration_list.flag[data_index] = RegistrationStatus::Initialized;
+    registration_list.aruid[data_index] = aruid;
+    return ResultSuccess;
+}
+void AppletResource::UnregisterAppletResourceUserId(u64 aruid) {
+    u64 index = GetIndexFromAruid(aruid);
+    if (index < AruidIndexMax) {
+        if (data[index].flag.is_assigned) {
+            data[index].shared_memory_handle = nullptr;
+            data[index].flag.is_assigned.Assign(false);
+        }
+    }
+    index = GetIndexFromAruid(aruid);
+    if (index < AruidIndexMax) {
+        DestroySevenSixAxisTransferMemory();
+        data[index].flag.raw = 0;
+        data[index].aruid = 0;
+        index = GetIndexFromAruid(aruid);
+        if (index < AruidIndexMax) {
+            registration_list.flag[index] = RegistrationStatus::PendingDelete;
+        }
+    }
+}
+u64 AppletResource::GetActiveAruid() {
+    return active_aruid;
+}
+Result AppletResource::GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid) {
+    u64 index = GetIndexFromAruid(aruid);
+    if (index >= AruidIndexMax) {
+        return ResultAruidNotRegistered;
+    }
+    *out_handle = data[index].shared_memory_handle;
+    return ResultSuccess;
+}
+u64 AppletResource::GetIndexFromAruid(u64 aruid) {
+    for (std::size_t i = 0; i < AruidIndexMax; i++) {
+        if (registration_list.flag[i] == RegistrationStatus::Initialized &&
+            registration_list.aruid[i] == aruid) {
+            return i;
+        }
+    }
+    return AruidIndexMax;
+}
+Result AppletResource::DestroySevenSixAxisTransferMemory() {
+    // TODO
+    return ResultSuccess;
+}
+void AppletResource::EnableInput(u64 aruid, bool is_enabled) {
+    const u64 index = GetIndexFromAruid(aruid);
+    if (index >= AruidIndexMax) {
+        return;
+    }
+    data[index].flag.enable_pad_input.Assign(is_enabled);
+    data[index].flag.enable_touchscreen.Assign(is_enabled);
+}
+void AppletResource::EnableSixAxisSensor(u64 aruid, bool is_enabled) {
+    const u64 index = GetIndexFromAruid(aruid);
+    if (index >= AruidIndexMax) {
+        return;
+    }
+    data[index].flag.enable_six_axis_sensor.Assign(is_enabled);
+}
+void AppletResource::EnablePadInput(u64 aruid, bool is_enabled) {
+    const u64 index = GetIndexFromAruid(aruid);
+    if (index >= AruidIndexMax) {
+        return;
+    }
+    data[index].flag.enable_pad_input.Assign(is_enabled);
+}
+void AppletResource::EnableTouchScreen(u64 aruid, bool is_enabled) {
+    const u64 index = GetIndexFromAruid(aruid);
+    if (index >= AruidIndexMax) {
+        return;
+    }
+    data[index].flag.enable_touchscreen.Assign(is_enabled);
+}
+void AppletResource::SetIsPalmaConnectable(u64 aruid, bool is_connectable) {
+    const u64 index = GetIndexFromAruid(aruid);
+    if (index >= AruidIndexMax) {
+        return;
+    }
+    data[index].flag.is_palma_connectable.Assign(is_connectable);
+}
+void AppletResource::EnablePalmaBoostMode(u64 aruid, bool is_enabled) {
+    const u64 index = GetIndexFromAruid(aruid);
+    if (index >= AruidIndexMax) {
+        return;
+    }
+    data[index].flag.enable_palma_boost_mode.Assign(is_enabled);
+}
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/applet_resource.h b/src/core/hle/service/hid/controllers/applet_resource.h
new file mode 100644
index 000000000..3dcec2898
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/applet_resource.h
@@ -0,0 +1,87 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+#include <array>
+#include "common/bit_field.h"
+#include "common/common_types.h"
+#include "core/hle/result.h"
+namespace Core {
+class System;
+}
+namespace Kernel {
+class KSharedMemory;
+}
+namespace Service::HID {
+class AppletResource {
+public:
+    explicit AppletResource(Core::System& system_);
+    ~AppletResource();
+    Result CreateAppletResource(u64 aruid);
+    Result RegisterAppletResourceUserId(u64 aruid, bool enable_input);
+    void UnregisterAppletResourceUserId(u64 aruid);
+    u64 GetActiveAruid();
+    Result GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid);
+    u64 GetIndexFromAruid(u64 aruid);
+    Result DestroySevenSixAxisTransferMemory();
+    void EnableInput(u64 aruid, bool is_enabled);
+    void EnableSixAxisSensor(u64 aruid, bool is_enabled);
+    void EnablePadInput(u64 aruid, bool is_enabled);
+    void EnableTouchScreen(u64 aruid, bool is_enabled);
+    void SetIsPalmaConnectable(u64 aruid, bool is_connectable);
+    void EnablePalmaBoostMode(u64 aruid, bool is_enabled);
+private:
+    static constexpr std::size_t AruidIndexMax = 0x20;
+    enum RegistrationStatus : u32 {
+        None,
+        Initialized,
+        PendingDelete,
+    };
+    struct DataStatusFlag {
+        union {
+            u32 raw{};
+            BitField<0, 1, u32> is_initialized;
+            BitField<1, 1, u32> is_assigned;
+            BitField<16, 1, u32> enable_pad_input;
+            BitField<17, 1, u32> enable_six_axis_sensor;
+            BitField<18, 1, u32> bit_18;
+            BitField<19, 1, u32> is_palma_connectable;
+            BitField<20, 1, u32> enable_palma_boost_mode;
+            BitField<21, 1, u32> enable_touchscreen;
+        };
+    };
+    struct AruidRegisterList {
+        std::array<RegistrationStatus, AruidIndexMax> flag{};
+        std::array<u64, AruidIndexMax> aruid{};
+    };
+    static_assert(sizeof(AruidRegisterList) == 0x180, "AruidRegisterList is an invalid size");
+    struct AruidData {
+        DataStatusFlag flag{};
+        u64 aruid{};
+        Kernel::KSharedMemory* shared_memory_handle{nullptr};
+    };
+    u64 active_aruid{};
+    AruidRegisterList registration_list{};
+    std::array<AruidData, AruidIndexMax> data{};
+    Core::System& system;
+};
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/errors.h b/src/core/hle/service/hid/errors.h
index 9585bdaf0..f00cb831f 100644
--- a/src/core/hle/service/hid/errors.h
+++ b/src/core/hle/service/hid/errors.h
@@ -19,6 +19,11 @@ constexpr Result NpadIsSameType{ErrorModule::HID, 602};
 constexpr Result InvalidNpadId{ErrorModule::HID, 709};
 constexpr Result NpadNotConnected{ErrorModule::HID, 710};
 constexpr Result InvalidArraySize{ErrorModule::HID, 715};
+constexpr Result ResultAruidNoAvailableEntries{ErrorModule::HID, 1044};
+constexpr Result ResultAruidAlreadyRegistered{ErrorModule::HID, 1046};
+constexpr Result ResultAruidNotRegistered{ErrorModule::HID, 1047};
 constexpr Result InvalidPalmaHandle{ErrorModule::HID, 3302};
 } // namespace Service::HID
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 1b7381d8d..afbcb019f 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
+#include "core/hle/kernel/k_process.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/hid/hid_debug_server.h"
 #include "core/hle/service/hid/hid_firmware_settings.h"
@@ -20,6 +22,12 @@ void LoopProcess(Core::System& system) {
    std::shared_ptr<HidFirmwareSettings> firmware_settings =
        std::make_shared<HidFirmwareSettings>();
+    // TODO: Remove this hack until this service is emulated properly.
+    const auto process_list = system.Kernel().GetProcessList();
+    if (!process_list.empty()) {
+        resouce_manager->RegisterAppletResourceUserId(process_list[0]->GetId(), true);
+    }
    server_manager->RegisterNamedService(
        "hid", std::make_shared<IHidServer>(system, resouce_manager, firmware_settings));
    server_manager->RegisterNamedService(
diff --git a/src/core/hle/service/hid/hid_server.cpp b/src/core/hle/service/hid/hid_server.cpp
index a7d1578d9..e0f4051aa 100644
--- a/src/core/hle/service/hid/hid_server.cpp
+++ b/src/core/hle/service/hid/hid_server.cpp
@@ -224,8 +224,13 @@ void IHidServer::CreateAppletResource(HLERequestContext& ctx) {
    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+    Result result = GetResourceManager()->CreateAppletResource(applet_resource_user_id);
+    if (result.IsSuccess()) {
+        result = GetResourceManager()->GetNpad()->Activate(applet_resource_user_id);
+    }
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
+    rb.Push(result);
    rb.PushIpcInterface<IAppletResource>(system, resource_manager);
 }
diff --git a/src/core/hle/service/hid/hid_system_server.cpp b/src/core/hle/service/hid/hid_system_server.cpp
index b56d0347a..4d33456a3 100644
--- a/src/core/hle/service/hid/hid_system_server.cpp
+++ b/src/core/hle/service/hid/hid_system_server.cpp
@@ -3,6 +3,7 @@
 #include "core/hid/hid_core.h"
 #include "core/hle/service/hid/controllers/npad.h"
+#include "core/hle/service/hid/controllers/palma.h"
 #include "core/hle/service/hid/controllers/touchscreen.h"
 #include "core/hle/service/hid/errors.h"
 #include "core/hle/service/hid/hid_system_server.h"
@@ -63,13 +64,13 @@ IHidSystemServer::IHidSystemServer(Core::System& system_, std::shared_ptr<Resour
        {329, nullptr, "DetachAbstractedPadAll"},
        {330, nullptr, "CheckAbstractedPadConnection"},
        {500, nullptr, "SetAppletResourceUserId"},
-        {501, nullptr, "RegisterAppletResourceUserId"},
+        {501, &IHidSystemServer::RegisterAppletResourceUserId, "RegisterAppletResourceUserId"},
-        {502, nullptr, "UnregisterAppletResourceUserId"},
+        {502, &IHidSystemServer::UnregisterAppletResourceUserId, "UnregisterAppletResourceUserId"},
-        {503, nullptr, "EnableAppletToGetInput"},
+        {503, &IHidSystemServer::EnableAppletToGetInput, "EnableAppletToGetInput"},
        {504, nullptr, "SetAruidValidForVibration"},
-        {505, nullptr, "EnableAppletToGetSixAxisSensor"},
+        {505, &IHidSystemServer::EnableAppletToGetSixAxisSensor, "EnableAppletToGetSixAxisSensor"},
-        {506, nullptr, "EnableAppletToGetPadInput"},
+        {506, &IHidSystemServer::EnableAppletToGetPadInput, "EnableAppletToGetPadInput"},
-        {507, nullptr, "EnableAppletToGetTouchScreen"},
+        {507, &IHidSystemServer::EnableAppletToGetTouchScreen, "EnableAppletToGetTouchScreen"},
        {510, nullptr, "SetVibrationMasterVolume"},
        {511, nullptr, "GetVibrationMasterVolume"},
        {512, nullptr, "BeginPermitVibrationSession"},
@@ -420,6 +421,129 @@ void IHidSystemServer::GetIrSensorState(HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(ResultSuccess);
 }
+void IHidSystemServer::RegisterAppletResourceUserId(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        bool enable_input;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+    const auto parameters{rp.PopRaw<Parameters>()};
+    LOG_INFO(Service_HID, "called, enable_input={}, applet_resource_user_id={}",
+             parameters.enable_input, parameters.applet_resource_user_id);
+    Result result = GetResourceManager()->RegisterAppletResourceUserId(
+        parameters.applet_resource_user_id, parameters.enable_input);
+    if (result.IsSuccess()) {
+        // result = GetResourceManager()->GetNpad()->RegisterAppletResourceUserId(
+        //     parameters.applet_resource_user_id);
+    }
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void IHidSystemServer::UnregisterAppletResourceUserId(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    u64 applet_resource_user_id{rp.Pop<u64>()};
+    LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+    GetResourceManager()->UnregisterAppletResourceUserId(applet_resource_user_id);
+    // GetResourceManager()->GetNpad()->UnregisterAppletResourceUserId(applet_resource_user_id);
+    // GetResourceManager()->GetPalma()->UnregisterAppletResourceUserId(applet_resource_user_id);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void IHidSystemServer::EnableAppletToGetInput(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        bool is_enabled;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+    const auto parameters{rp.PopRaw<Parameters>()};
+    LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}",
+             parameters.is_enabled, parameters.applet_resource_user_id);
+    GetResourceManager()->EnableInput(parameters.applet_resource_user_id, parameters.is_enabled);
+    // GetResourceManager()->GetNpad()->EnableInput(parameters.applet_resource_user_id);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void IHidSystemServer::EnableAppletToGetSixAxisSensor(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        bool is_enabled;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+    const auto parameters{rp.PopRaw<Parameters>()};
+    LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}",
+             parameters.is_enabled, parameters.applet_resource_user_id);
+    GetResourceManager()->EnableTouchScreen(parameters.applet_resource_user_id,
+                                            parameters.is_enabled);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void IHidSystemServer::EnableAppletToGetPadInput(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        bool is_enabled;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+    const auto parameters{rp.PopRaw<Parameters>()};
+    LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}",
+             parameters.is_enabled, parameters.applet_resource_user_id);
+    GetResourceManager()->EnablePadInput(parameters.applet_resource_user_id, parameters.is_enabled);
+    // GetResourceManager()->GetNpad()->EnableInput(parameters.applet_resource_user_id);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void IHidSystemServer::EnableAppletToGetTouchScreen(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        bool is_enabled;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+    const auto parameters{rp.PopRaw<Parameters>()};
+    LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}",
+             parameters.is_enabled, parameters.applet_resource_user_id);
+    GetResourceManager()->EnableTouchScreen(parameters.applet_resource_user_id,
+                                            parameters.is_enabled);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
 void IHidSystemServer::AcquireConnectionTriggerTimeoutEvent(HLERequestContext& ctx) {
    LOG_INFO(Service_AM, "(STUBBED) called");
diff --git a/src/core/hle/service/hid/hid_system_server.h b/src/core/hle/service/hid/hid_system_server.h
index 822d5e5b9..1e623dfc2 100644
--- a/src/core/hle/service/hid/hid_system_server.h
+++ b/src/core/hle/service/hid/hid_system_server.h
@@ -38,6 +38,12 @@ private:
    void HasLeftRightBattery(HLERequestContext& ctx);
    void GetUniquePadsFromNpad(HLERequestContext& ctx);
    void GetIrSensorState(HLERequestContext& ctx);
+    void RegisterAppletResourceUserId(HLERequestContext& ctx);
+    void UnregisterAppletResourceUserId(HLERequestContext& ctx);
+    void EnableAppletToGetInput(HLERequestContext& ctx);
+    void EnableAppletToGetSixAxisSensor(HLERequestContext& ctx);
+    void EnableAppletToGetPadInput(HLERequestContext& ctx);
+    void EnableAppletToGetTouchScreen(HLERequestContext& ctx);
    void AcquireConnectionTriggerTimeoutEvent(HLERequestContext& ctx);
    void AcquireDeviceRegisteredEventForControllerSupport(HLERequestContext& ctx);
    void GetRegisteredDevices(HLERequestContext& ctx);
diff --git a/src/core/hle/service/hid/resource_manager.cpp b/src/core/hle/service/hid/resource_manager.cpp
index e76d4eea9..60d4ef71f 100644
--- a/src/core/hle/service/hid/resource_manager.cpp
+++ b/src/core/hle/service/hid/resource_manager.cpp
@@ -9,6 +9,7 @@
 #include "core/hle/service/hid/resource_manager.h"
 #include "core/hle/service/ipc_helpers.h"
+#include "core/hle/service/hid/controllers/applet_resource.h"
 #include "core/hle/service/hid/controllers/console_six_axis.h"
 #include "core/hle/service/hid/controllers/debug_pad.h"
 #include "core/hle/service/hid/controllers/gesture.h"
@@ -33,7 +34,9 @@ constexpr auto mouse_keyboard_update_ns = std::chrono::nanoseconds{8 * 1000 * 10
 constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000};         // (5ms, 200Hz)
 ResourceManager::ResourceManager(Core::System& system_)
-    : system{system_}, service_context{system_, "hid"} {}
+    : system{system_}, service_context{system_, "hid"} {
+    applet_resource = std::make_shared<AppletResource>(system);
+}
 ResourceManager::~ResourceManager() = default;
@@ -77,6 +80,11 @@ void ResourceManager::Initialize() {
    system.HIDCore().ReloadInputDevices();
    is_initialized = true;
 }
+std::shared_ptr<AppletResource> ResourceManager::GetAppletResource() const {
+    return applet_resource;
+}
 std::shared_ptr<CaptureButton> ResourceManager::GetCaptureButton() const {
    return capture_button;
 }
@@ -137,6 +145,46 @@ std::shared_ptr<UniquePad> ResourceManager::GetUniquePad() const {
    return unique_pad;
 }
+Result ResourceManager::CreateAppletResource(u64 aruid) {
+    std::scoped_lock lock{shared_mutex};
+    return applet_resource->CreateAppletResource(aruid);
+}
+Result ResourceManager::RegisterAppletResourceUserId(u64 aruid, bool bool_value) {
+    std::scoped_lock lock{shared_mutex};
+    return applet_resource->RegisterAppletResourceUserId(aruid, bool_value);
+}
+void ResourceManager::UnregisterAppletResourceUserId(u64 aruid) {
+    std::scoped_lock lock{shared_mutex};
+    applet_resource->UnregisterAppletResourceUserId(aruid);
+}
+Result ResourceManager::GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid) {
+    std::scoped_lock lock{shared_mutex};
+    return applet_resource->GetSharedMemoryHandle(out_handle, aruid);
+}
+void ResourceManager::EnableInput(u64 aruid, bool is_enabled) {
+    std::scoped_lock lock{shared_mutex};
+    applet_resource->EnableInput(aruid, is_enabled);
+}
+void ResourceManager::EnableSixAxisSensor(u64 aruid, bool is_enabled) {
+    std::scoped_lock lock{shared_mutex};
+    applet_resource->EnableSixAxisSensor(aruid, is_enabled);
+}
+void ResourceManager::EnablePadInput(u64 aruid, bool is_enabled) {
+    std::scoped_lock lock{shared_mutex};
+    applet_resource->EnablePadInput(aruid, is_enabled);
+}
+void ResourceManager::EnableTouchScreen(u64 aruid, bool is_enabled) {
+    std::scoped_lock lock{shared_mutex};
+    applet_resource->EnableTouchScreen(aruid, is_enabled);
+}
 void ResourceManager::UpdateControllers(std::uintptr_t user_data,
                                        std::chrono::nanoseconds ns_late) {
    auto& core_timing = system.CoreTiming();
@@ -172,14 +220,12 @@ void ResourceManager::UpdateMotion(std::uintptr_t user_data, std::chrono::nanose
 }
 IAppletResource::IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource)
-    : ServiceFramework{system_, "IAppletResource"} {
+    : ServiceFramework{system_, "IAppletResource"}, resource_manager{resource} {
    static const FunctionInfo functions[] = {
        {0, &IAppletResource::GetSharedMemoryHandle, "GetSharedMemoryHandle"},
    };
    RegisterHandlers(functions);
-    resource->Initialize();
    // Register update callbacks
    npad_update_event = Core::Timing::CreateEvent(
        "HID::UpdatePadCallback",
@@ -233,9 +279,13 @@ IAppletResource::~IAppletResource() {
 void IAppletResource::GetSharedMemoryHandle(HLERequestContext& ctx) {
    LOG_DEBUG(Service_HID, "called");
+    Kernel::KSharedMemory* handle;
+    const u64 applet_resource_user_id = resource_manager->GetAppletResource()->GetActiveAruid();
+    const auto result = resource_manager->GetSharedMemoryHandle(&handle, applet_resource_user_id);
    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(ResultSuccess);
+    rb.Push(result);
-    rb.PushCopyObjects(&system.Kernel().GetHidSharedMem());
+    rb.PushCopyObjects(handle);
 }
 } // namespace Service::HID
diff --git a/src/core/hle/service/hid/resource_manager.h b/src/core/hle/service/hid/resource_manager.h
index 2b6a9b5e6..a78e2b729 100644
--- a/src/core/hle/service/hid/resource_manager.h
+++ b/src/core/hle/service/hid/resource_manager.h
@@ -6,11 +6,20 @@
 #include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/service.h"
+namespace Core {
+class System;
+}
 namespace Core::Timing {
 struct EventType;
 }
+namespace Kernel {
+class KSharedMemory;
+}
 namespace Service::HID {
+class AppletResource;
 class Controller_Stubbed;
 class ConsoleSixAxis;
 class DebugPad;
@@ -38,6 +47,7 @@ public:
    void Initialize();
+    std::shared_ptr<AppletResource> GetAppletResource() const;
    std::shared_ptr<CaptureButton> GetCaptureButton() const;
    std::shared_ptr<ConsoleSixAxis> GetConsoleSixAxis() const;
    std::shared_ptr<DebugMouse> GetDebugMouse() const;
@@ -54,6 +64,18 @@ public:
    std::shared_ptr<TouchScreen> GetTouchScreen() const;
    std::shared_ptr<UniquePad> GetUniquePad() const;
+    Result CreateAppletResource(u64 aruid);
+    Result RegisterAppletResourceUserId(u64 aruid, bool bool_value);
+    void UnregisterAppletResourceUserId(u64 aruid);
+    Result GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid);
+    void EnableInput(u64 aruid, bool is_enabled);
+    void EnableSixAxisSensor(u64 aruid, bool is_enabled);
+    void EnablePadInput(u64 aruid, bool is_enabled);
+    void EnableTouchScreen(u64 aruid, bool is_enabled);
    void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
    void UpdateNpad(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
    void UpdateMouseKeyboard(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
@@ -62,6 +84,9 @@ public:
 private:
    bool is_initialized{false};
+    mutable std::mutex shared_mutex;
+    std::shared_ptr<AppletResource> applet_resource = nullptr;
    std::shared_ptr<CaptureButton> capture_button = nullptr;
    std::shared_ptr<ConsoleSixAxis> console_six_axis = nullptr;
    std::shared_ptr<DebugMouse> debug_mouse = nullptr;
@@ -106,6 +131,8 @@ private:
    std::shared_ptr<Core::Timing::EventType> default_update_event;
    std::shared_ptr<Core::Timing::EventType> mouse_keyboard_update_event;
    std::shared_ptr<Core::Timing::EventType> motion_update_event;
+    std::shared_ptr<ResourceManager> resource_manager;
 };
 } // namespace Service::HID
diff --git a/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp b/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp
index d7db24f42..75bf31e32 100644
--- a/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp
+++ b/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp
@@ -171,6 +171,7 @@ void MakeGraphicBuffer(android::BufferQueueProducer& producer, u32 slot, u32 han
    buffer->height = SharedBufferHeight;
    buffer->stride = SharedBufferBlockLinearStride;
    buffer->format = SharedBufferBlockLinearFormat;
+    buffer->external_format = SharedBufferBlockLinearFormat;
    buffer->buffer_id = handle;
    buffer->offset = slot * SharedBufferSlotSize;
    ASSERT(producer.SetPreallocatedBuffer(slot, buffer) == android::Status::NoError);
diff --git a/src/video_core/host1x/ffmpeg/ffmpeg.cpp b/src/video_core/host1x/ffmpeg/ffmpeg.cpp
index dcd07e6d2..96686da59 100644
--- a/src/video_core/host1x/ffmpeg/ffmpeg.cpp
+++ b/src/video_core/host1x/ffmpeg/ffmpeg.cpp
@@ -233,7 +233,12 @@ std::unique_ptr<Frame> DecoderContext::ReceiveFrame(bool* out_is_interlaced) {
            return false;
        }
-        *out_is_interlaced = frame->interlaced_frame != 0;
+        *out_is_interlaced =
+#if defined(FF_API_INTERLACED_FRAME) || LIBAVUTIL_VERSION_MAJOR >= 59
+            (frame->flags & AV_FRAME_FLAG_INTERLACED) != 0;
+#else
+            frame->interlaced_frame != 0;
+#endif
        return true;
    };
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp
index 9995b6dd4..279e5a4e0 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp
@@ -714,7 +714,8 @@ bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& config,
    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
    std::scoped_lock lock{texture_cache.mutex};
-    ImageView* const image_view{texture_cache.TryFindFramebufferImageView(framebuffer_addr)};
+    ImageView* const image_view{
+        texture_cache.TryFindFramebufferImageView(config, framebuffer_addr)};
    if (!image_view) {
        return false;
    }
@@ -725,7 +726,6 @@ bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& config,
    screen_info.texture.width = image_view->size.width;
    screen_info.texture.height = image_view->size.height;
    screen_info.display_texture = image_view->Handle(Shader::TextureType::Color2D);
-    screen_info.display_srgb = VideoCore::Surface::IsPixelFormatSRGB(image_view->format);
    return true;
 }
diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp
index 6bfed08a1..7a4f0c5c1 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.cpp
+++ b/src/video_core/renderer_opengl/renderer_opengl.cpp
@@ -653,11 +653,7 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
    };
    glNamedBufferSubData(vertex_buffer.handle, 0, sizeof(vertices), std::data(vertices));
-    if (screen_info.display_srgb) {
+    glDisable(GL_FRAMEBUFFER_SRGB);
-        glEnable(GL_FRAMEBUFFER_SRGB);
-    } else {
-        glDisable(GL_FRAMEBUFFER_SRGB);
-    }
    glViewportIndexedf(0, 0.0f, 0.0f, static_cast<GLfloat>(layout.width),
                       static_cast<GLfloat>(layout.height));
@@ -710,8 +706,7 @@ void RendererOpenGL::RenderScreenshot() {
    GLuint renderbuffer;
    glGenRenderbuffers(1, &renderbuffer);
    glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, screen_info.display_srgb ? GL_SRGB8 : GL_RGB8,
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_SRGB8, layout.width, layout.height);
-                          layout.width, layout.height);
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer);
    DrawScreen(layout);
diff --git a/src/video_core/renderer_opengl/renderer_opengl.h b/src/video_core/renderer_opengl/renderer_opengl.h
index f1d5fd954..b70607635 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.h
+++ b/src/video_core/renderer_opengl/renderer_opengl.h
@@ -53,7 +53,6 @@ struct TextureInfo {
 struct ScreenInfo {
    GLuint display_texture{};
    bool was_accelerated = false;
-    bool display_srgb{};
    const Common::Rectangle<float> display_texcoords{0.0f, 0.0f, 1.0f, 1.0f};
    TextureInfo texture;
 };
diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
index c4c30d807..100b70918 100644
--- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp
+++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
@@ -94,7 +94,7 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
      device(CreateDevice(instance, dld, *surface)), memory_allocator(device), state_tracker(),
      scheduler(device, state_tracker),
      swapchain(*surface, device, scheduler, render_window.GetFramebufferLayout().width,
-                render_window.GetFramebufferLayout().height, false),
+                render_window.GetFramebufferLayout().height),
      present_manager(instance, render_window, device, memory_allocator, scheduler, swapchain,
                      surface),
      blit_screen(cpu_memory, render_window, device, memory_allocator, swapchain, present_manager,
@@ -131,11 +131,10 @@ void RendererVulkan::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
    const VAddr framebuffer_addr = framebuffer->address + framebuffer->offset;
    const bool use_accelerated =
        rasterizer.AccelerateDisplay(*framebuffer, framebuffer_addr, framebuffer->stride);
-    const bool is_srgb = use_accelerated && screen_info.is_srgb;
    RenderScreenshot(*framebuffer, use_accelerated);
    Frame* frame = present_manager.GetRenderFrame();
-    blit_screen.DrawToSwapchain(frame, *framebuffer, use_accelerated, is_srgb);
+    blit_screen.DrawToSwapchain(frame, *framebuffer, use_accelerated);
    scheduler.Flush(*frame->render_ready);
    present_manager.Present(frame);
@@ -205,7 +204,7 @@ void Vulkan::RendererVulkan::RenderScreenshot(const Tegra::FramebufferConfig& fr
        .flags = 0,
        .image = *staging_image,
        .viewType = VK_IMAGE_VIEW_TYPE_2D,
-        .format = screen_info.is_srgb ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_B8G8R8A8_UNORM,
+        .format = VK_FORMAT_B8G8R8A8_UNORM,
        .components{
            .r = VK_COMPONENT_SWIZZLE_IDENTITY,
            .g = VK_COMPONENT_SWIZZLE_IDENTITY,
diff --git a/src/video_core/renderer_vulkan/vk_blit_screen.cpp b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
index 5e461fbd0..60432f5ad 100644
--- a/src/video_core/renderer_vulkan/vk_blit_screen.cpp
+++ b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
@@ -127,9 +127,9 @@ BlitScreen::BlitScreen(Core::Memory::Memory& cpu_memory_, Core::Frontend::EmuWin
                       Scheduler& scheduler_, const ScreenInfo& screen_info_)
    : cpu_memory{cpu_memory_}, render_window{render_window_}, device{device_},
      memory_allocator{memory_allocator_}, swapchain{swapchain_}, present_manager{present_manager_},
-      scheduler{scheduler_}, image_count{swapchain.GetImageCount()}, screen_info{screen_info_},
+      scheduler{scheduler_}, image_count{swapchain.GetImageCount()}, screen_info{screen_info_} {
-      current_srgb{swapchain.IsSrgb()}, image_view_format{swapchain.GetImageViewFormat()} {
    resource_ticks.resize(image_count);
+    swapchain_view_format = swapchain.GetImageViewFormat();
    CreateStaticResources();
    CreateDynamicResources();
@@ -480,28 +480,22 @@ void BlitScreen::Draw(const Tegra::FramebufferConfig& framebuffer,
 }
 void BlitScreen::DrawToSwapchain(Frame* frame, const Tegra::FramebufferConfig& framebuffer,
-                                 bool use_accelerated, bool is_srgb) {
+                                 bool use_accelerated) {
-    // Recreate dynamic resources if the the image count or colorspace changed
+    // Recreate dynamic resources if the the image count or input format changed
+    const VkFormat current_framebuffer_format =
+        std::exchange(framebuffer_view_format, GetFormat(framebuffer));
    if (const std::size_t swapchain_images = swapchain.GetImageCount();
-        swapchain_images != image_count || current_srgb != is_srgb) {
+        swapchain_images != image_count || current_framebuffer_format != framebuffer_view_format) {
-        current_srgb = is_srgb;
-#ifdef ANDROID
-        // Android is already ordered the same as Switch.
-        image_view_format = current_srgb ? VK_FORMAT_R8G8B8A8_SRGB : VK_FORMAT_R8G8B8A8_UNORM;
-#else
-        image_view_format = current_srgb ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_B8G8R8A8_UNORM;
-#endif
        image_count = swapchain_images;
        Recreate();
    }
    // Recreate the presentation frame if the dimensions of the window changed
    const Layout::FramebufferLayout layout = render_window.GetFramebufferLayout();
-    if (layout.width != frame->width || layout.height != frame->height ||
+    if (layout.width != frame->width || layout.height != frame->height) {
-        is_srgb != frame->is_srgb) {
        Recreate();
-        present_manager.RecreateFrame(frame, layout.width, layout.height, is_srgb,
+        present_manager.RecreateFrame(frame, layout.width, layout.height, swapchain_view_format,
-                                      image_view_format, *renderpass);
+                                      *renderpass);
    }
    const VkExtent2D render_area{frame->width, frame->height};
@@ -629,7 +623,7 @@ void BlitScreen::CreateDescriptorPool() {
 }
 void BlitScreen::CreateRenderPass() {
-    renderpass = CreateRenderPassImpl(image_view_format);
+    renderpass = CreateRenderPassImpl(swapchain_view_format);
 }
 vk::RenderPass BlitScreen::CreateRenderPassImpl(VkFormat format) {
@@ -1149,7 +1143,7 @@ void BlitScreen::CreateRawImages(const Tegra::FramebufferConfig& framebuffer) {
            .pNext = nullptr,
            .flags = 0,
            .imageType = VK_IMAGE_TYPE_2D,
-            .format = used_on_framebuffer ? VK_FORMAT_R16G16B16A16_SFLOAT : GetFormat(framebuffer),
+            .format = used_on_framebuffer ? VK_FORMAT_R16G16B16A16_SFLOAT : framebuffer_view_format,
            .extent =
                {
                    .width = (up_scale * framebuffer.width) >> down_shift,
@@ -1174,7 +1168,7 @@ void BlitScreen::CreateRawImages(const Tegra::FramebufferConfig& framebuffer) {
            .flags = 0,
            .image = *image,
            .viewType = VK_IMAGE_VIEW_TYPE_2D,
-            .format = used_on_framebuffer ? VK_FORMAT_R16G16B16A16_SFLOAT : GetFormat(framebuffer),
+            .format = used_on_framebuffer ? VK_FORMAT_R16G16B16A16_SFLOAT : framebuffer_view_format,
            .components =
                {
                    .r = VK_COMPONENT_SWIZZLE_IDENTITY,
diff --git a/src/video_core/renderer_vulkan/vk_blit_screen.h b/src/video_core/renderer_vulkan/vk_blit_screen.h
index 8365b5668..16b882b6d 100644
--- a/src/video_core/renderer_vulkan/vk_blit_screen.h
+++ b/src/video_core/renderer_vulkan/vk_blit_screen.h
@@ -52,7 +52,6 @@ struct ScreenInfo {
    VkImageView image_view{};
    u32 width{};
    u32 height{};
-    bool is_srgb{};
 };
 class BlitScreen {
@@ -69,7 +68,7 @@ public:
              const Layout::FramebufferLayout layout, VkExtent2D render_area, bool use_accelerated);
    void DrawToSwapchain(Frame* frame, const Tegra::FramebufferConfig& framebuffer,
-                         bool use_accelerated, bool is_srgb);
+                         bool use_accelerated);
    [[nodiscard]] vk::Framebuffer CreateFramebuffer(const VkImageView& image_view,
                                                    VkExtent2D extent);
@@ -161,8 +160,8 @@ private:
    u32 raw_width = 0;
    u32 raw_height = 0;
    Service::android::PixelFormat pixel_format{};
-    bool current_srgb;
+    VkFormat framebuffer_view_format;
-    VkFormat image_view_format;
+    VkFormat swapchain_view_format;
    std::unique_ptr<FSR> fsr;
    std::unique_ptr<SMAA> smaa;
diff --git a/src/video_core/renderer_vulkan/vk_present_manager.cpp b/src/video_core/renderer_vulkan/vk_present_manager.cpp
index 2ef36583b..8e4c74b5c 100644
--- a/src/video_core/renderer_vulkan/vk_present_manager.cpp
+++ b/src/video_core/renderer_vulkan/vk_present_manager.cpp
@@ -172,13 +172,12 @@ void PresentManager::Present(Frame* frame) {
    });
 }
-void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, bool is_srgb,
+void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, VkFormat image_view_format,
-                                   VkFormat image_view_format, VkRenderPass rd) {
+                                   VkRenderPass rd) {
    auto& dld = device.GetLogical();
    frame->width = width;
    frame->height = height;
-    frame->is_srgb = is_srgb;
    frame->image = memory_allocator.CreateImage({
        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
@@ -289,7 +288,7 @@ void PresentManager::PresentThread(std::stop_token token) {
 }
 void PresentManager::RecreateSwapchain(Frame* frame) {
-    swapchain.Create(*surface, frame->width, frame->height, frame->is_srgb);
+    swapchain.Create(*surface, frame->width, frame->height);
    image_count = swapchain.GetImageCount();
 }
@@ -319,12 +318,12 @@ void PresentManager::CopyToSwapchain(Frame* frame) {
 void PresentManager::CopyToSwapchainImpl(Frame* frame) {
    MICROPROFILE_SCOPE(Vulkan_CopyToSwapchain);
-    // If the size or colorspace of the incoming frames has changed, recreate the swapchain
+    // If the size of the incoming frames has changed, recreate the swapchain
    // to account for that.
-    const bool srgb_changed = swapchain.NeedsRecreation(frame->is_srgb);
+    const bool is_suboptimal = swapchain.NeedsRecreation();
    const bool size_changed =
        swapchain.GetWidth() != frame->width || swapchain.GetHeight() != frame->height;
-    if (srgb_changed || size_changed) {
+    if (is_suboptimal || size_changed) {
        RecreateSwapchain(frame);
    }
diff --git a/src/video_core/renderer_vulkan/vk_present_manager.h b/src/video_core/renderer_vulkan/vk_present_manager.h
index a3d825fe6..337171a09 100644
--- a/src/video_core/renderer_vulkan/vk_present_manager.h
+++ b/src/video_core/renderer_vulkan/vk_present_manager.h
@@ -25,7 +25,6 @@ class Swapchain;
 struct Frame {
    u32 width;
    u32 height;
-    bool is_srgb;
    vk::Image image;
    vk::ImageView image_view;
    vk::Framebuffer framebuffer;
@@ -48,8 +47,8 @@ public:
    void Present(Frame* frame);
    /// Recreates the present frame to match the provided parameters
-    void RecreateFrame(Frame* frame, u32 width, u32 height, bool is_srgb,
+    void RecreateFrame(Frame* frame, u32 width, u32 height, VkFormat image_view_format,
-                       VkFormat image_view_format, VkRenderPass rd);
+                       VkRenderPass rd);
    /// Waits for the present thread to finish presenting all queued frames.
    void WaitPresent();
diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.cpp b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
index b6f52e017..59829c88b 100644
--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -783,7 +783,8 @@ bool RasterizerVulkan::AccelerateDisplay(const Tegra::FramebufferConfig& config,
        return false;
    }
    std::scoped_lock lock{texture_cache.mutex};
-    ImageView* const image_view = texture_cache.TryFindFramebufferImageView(framebuffer_addr);
+    ImageView* const image_view =
+        texture_cache.TryFindFramebufferImageView(config, framebuffer_addr);
    if (!image_view) {
        return false;
    }
@@ -792,7 +793,6 @@ bool RasterizerVulkan::AccelerateDisplay(const Tegra::FramebufferConfig& config,
    screen_info.image_view = image_view->Handle(Shader::TextureType::Color2D);
    screen_info.width = image_view->size.width;
    screen_info.height = image_view->size.height;
-    screen_info.is_srgb = VideoCore::Surface::IsPixelFormatSRGB(image_view->format);
    return true;
 }
diff --git a/src/video_core/renderer_vulkan/vk_swapchain.cpp b/src/video_core/renderer_vulkan/vk_swapchain.cpp
index 821f44f1a..86a30dcd1 100644
--- a/src/video_core/renderer_vulkan/vk_swapchain.cpp
+++ b/src/video_core/renderer_vulkan/vk_swapchain.cpp
@@ -105,14 +105,14 @@ VkCompositeAlphaFlagBitsKHR ChooseAlphaFlags(const VkSurfaceCapabilitiesKHR& cap
 } // Anonymous namespace
 Swapchain::Swapchain(VkSurfaceKHR surface_, const Device& device_, Scheduler& scheduler_,
-                     u32 width_, u32 height_, bool srgb)
+                     u32 width_, u32 height_)
    : surface{surface_}, device{device_}, scheduler{scheduler_} {
-    Create(surface_, width_, height_, srgb);
+    Create(surface_, width_, height_);
 }
 Swapchain::~Swapchain() = default;
-void Swapchain::Create(VkSurfaceKHR surface_, u32 width_, u32 height_, bool srgb) {
+void Swapchain::Create(VkSurfaceKHR surface_, u32 width_, u32 height_) {
    is_outdated = false;
    is_suboptimal = false;
    width = width_;
@@ -127,7 +127,7 @@ void Swapchain::Create(VkSurfaceKHR surface_, u32 width_, u32 height_, bool srgb
    Destroy();
-    CreateSwapchain(capabilities, srgb);
+    CreateSwapchain(capabilities);
    CreateSemaphores();
    resource_ticks.clear();
@@ -196,7 +196,7 @@ void Swapchain::Present(VkSemaphore render_semaphore) {
    }
 }
-void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities, bool srgb) {
+void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities) {
    const auto physical_device{device.GetPhysical()};
    const auto formats{physical_device.GetSurfaceFormatsKHR(surface)};
    const auto present_modes = physical_device.GetSurfacePresentModesKHR(surface);
@@ -274,15 +274,14 @@ void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities, bo
    swapchain = device.GetLogical().CreateSwapchainKHR(swapchain_ci);
    extent = swapchain_ci.imageExtent;
-    current_srgb = srgb;
    images = swapchain.GetImages();
    image_count = static_cast<u32>(images.size());
 #ifdef ANDROID
    // Android is already ordered the same as Switch.
-    image_view_format = srgb ? VK_FORMAT_R8G8B8A8_SRGB : VK_FORMAT_R8G8B8A8_UNORM;
+    image_view_format = VK_FORMAT_R8G8B8A8_UNORM;
 #else
-    image_view_format = srgb ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_B8G8R8A8_UNORM;
+    image_view_format = VK_FORMAT_B8G8R8A8_UNORM;
 #endif
 }
diff --git a/src/video_core/renderer_vulkan/vk_swapchain.h b/src/video_core/renderer_vulkan/vk_swapchain.h
index b8a1465a6..d264f06e4 100644
--- a/src/video_core/renderer_vulkan/vk_swapchain.h
+++ b/src/video_core/renderer_vulkan/vk_swapchain.h
@@ -20,11 +20,11 @@ class Scheduler;
 class Swapchain {
 public:
    explicit Swapchain(VkSurfaceKHR surface, const Device& device, Scheduler& scheduler, u32 width,
-                       u32 height, bool srgb);
+                       u32 height);
    ~Swapchain();
    /// Creates (or recreates) the swapchain with a given size.
-    void Create(VkSurfaceKHR surface, u32 width, u32 height, bool srgb);
+    void Create(VkSurfaceKHR surface, u32 width, u32 height);
    /// Acquires the next image in the swapchain, waits as needed.
    bool AcquireNextImage();
@@ -33,13 +33,8 @@ public:
    void Present(VkSemaphore render_semaphore);
    /// Returns true when the swapchain needs to be recreated.
-    bool NeedsRecreation(bool is_srgb) const {
+    bool NeedsRecreation() const {
-        return HasColorSpaceChanged(is_srgb) || IsSubOptimal() || NeedsPresentModeUpdate();
+        return IsSubOptimal() || NeedsPresentModeUpdate();
-    }
-    /// Returns true when the color space has changed.
-    bool HasColorSpaceChanged(bool is_srgb) const {
-        return current_srgb != is_srgb;
    }
    /// Returns true when the swapchain is outdated.
@@ -52,11 +47,6 @@ public:
        return is_suboptimal;
    }
-    /// Returns true when the swapchain format is in the srgb color space
-    bool IsSrgb() const {
-        return current_srgb;
-    }
    VkExtent2D GetSize() const {
        return extent;
    }
@@ -110,7 +100,7 @@ public:
    }
 private:
-    void CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities, bool srgb);
+    void CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities);
    void CreateSemaphores();
    void CreateImageViews();
@@ -144,7 +134,6 @@ private:
    bool has_mailbox{false};
    bool has_fifo_relaxed{false};
-    bool current_srgb{};
    bool is_outdated{};
    bool is_suboptimal{};
 };
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index dade38b18..0d5a1709f 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -712,14 +712,15 @@ bool TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
 }
 template <class P>
-typename P::ImageView* TextureCache<P>::TryFindFramebufferImageView(VAddr cpu_addr) {
+typename P::ImageView* TextureCache<P>::TryFindFramebufferImageView(
+    const Tegra::FramebufferConfig& config, VAddr cpu_addr) {
    // TODO: Properly implement this
    const auto it = page_table.find(cpu_addr >> YUZU_PAGEBITS);
    if (it == page_table.end()) {
        return nullptr;
    }
    const auto& image_map_ids = it->second;
-    boost::container::small_vector<const ImageBase*, 4> valid_images;
+    boost::container::small_vector<ImageId, 4> valid_image_ids;
    for (const ImageMapId map_id : image_map_ids) {
        const ImageMapView& map = slot_map_views[map_id];
        const ImageBase& image = slot_images[map.image_id];
@@ -729,18 +730,34 @@ typename P::ImageView* TextureCache<P>::TryFindFramebufferImageView(VAddr cpu_ad
        if (image.image_view_ids.empty()) {
            continue;
        }
-        valid_images.push_back(&image);
+        valid_image_ids.push_back(map.image_id);
    }
-    if (valid_images.size() == 1) [[likely]] {
+    const auto view_format = [&]() {
-        return &slot_image_views[valid_images[0]->image_view_ids.at(0)];
+        switch (config.pixel_format) {
+        case Service::android::PixelFormat::Rgb565:
+            return PixelFormat::R5G6B5_UNORM;
+        case Service::android::PixelFormat::Bgra8888:
+            return PixelFormat::B8G8R8A8_UNORM;
+        default:
+            return PixelFormat::A8B8G8R8_UNORM;
+        }
+    }();
+    const auto GetImageViewForFramebuffer = [&](ImageId image_id) {
+        const ImageViewInfo info{ImageViewType::e2D, view_format};
+        return &slot_image_views[FindOrEmplaceImageView(image_id, info)];
+    };
+    if (valid_image_ids.size() == 1) [[likely]] {
+        return GetImageViewForFramebuffer(valid_image_ids.front());
    }
-    if (valid_images.size() > 0) [[unlikely]] {
+    if (valid_image_ids.size() > 0) [[unlikely]] {
-        std::ranges::sort(valid_images, [](const auto* a, const auto* b) {
+        auto most_recent = std::ranges::max_element(valid_image_ids, [&](auto a, auto b) {
-            return a->modification_tick > b->modification_tick;
+            return slot_images[a].modification_tick < slot_images[b].modification_tick;
        });
-        return &slot_image_views[valid_images[0]->image_view_ids.at(0)];
+        return GetImageViewForFramebuffer(*most_recent);
    }
    return nullptr;
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index a40825c9f..cbe56e166 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -209,7 +209,8 @@ public:
                   const Tegra::Engines::Fermi2D::Config& copy);
    /// Try to find a cached image view in the given CPU address
-    [[nodiscard]] ImageView* TryFindFramebufferImageView(VAddr cpu_addr);
+    [[nodiscard]] ImageView* TryFindFramebufferImageView(const Tegra::FramebufferConfig& config,
+                                                         VAddr cpu_addr);
    /// Return true when there are uncommitted images to be downloaded
    [[nodiscard]] bool HasUncommittedFlushes() const noexcept;