[qt, input_common] allow to invert gyro controls on all 3 dimensions

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt

@@ -607,6 +607,12 @@ object NativeLibrary {
      */
     external fun addFileToFilesystemProvider(path: String)
 
+    /**
+     * Adds a game-folder file to the manual filesystem provider, respecting the internal gate for
+     * game-folder external-content mounting.
+     */
+    external fun addGameFolderFileToFilesystemProvider(path: String)
+
     /**
      * Clears all files added to the manual filesystem provider in our EmulationSession instance
      */

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/fetcher/SpacingItemDecoration.kt

@@ -1,10 +1,11 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 package org.yuzu.yuzu_emu.features.fetcher
 
 import android.graphics.Rect
 import android.view.View
+import androidx.recyclerview.widget.GridLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 
 class SpacingItemDecoration(private val spacing: Int) : RecyclerView.ItemDecoration() {
@@ -15,8 +16,20 @@ class SpacingItemDecoration(private val spacing: Int) : RecyclerView.ItemDecorat
         state: RecyclerView.State
     ) {
         outRect.bottom = spacing
-        if (parent.getChildAdapterPosition(view) == 0) {
+
+        val position = parent.getChildAdapterPosition(view)
+        if (position == RecyclerView.NO_POSITION) return
+
+        if (position == 0) {
             outRect.top = spacing
+            return
+        }
+
+        // If the item is in the first row, but NOT in first column add top spacing as well
+        val layoutManager = parent.layoutManager
+        if (layoutManager is GridLayoutManager && layoutManager.spanSizeLookup.getSpanGroupIndex(position, layoutManager.spanCount) == 0) {
+            outRect.top = spacing
+            return
         }
     }
 }

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

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: 2023 yuzu Emulator Project
@@ -68,7 +68,9 @@ class SettingsDialogFragment : DialogFragment(), DialogInterface.OnClickListener
                 MaterialAlertDialogBuilder(requireContext())
                     .setMessage(R.string.reset_setting_confirmation)
                     .setPositiveButton(android.R.string.ok) { _: DialogInterface, _: Int ->
-                        when (val item = settingsViewModel.clickedItem) {
+                        val item = settingsViewModel.clickedItem ?: return@setPositiveButton
+                        clearDialogState()
+                        when (item) {
                             is AnalogInputSetting -> {
                                 val stickParam = NativeInput.getStickParam(
                                     item.playerIndex,
@@ -107,12 +109,17 @@ class SettingsDialogFragment : DialogFragment(), DialogInterface.OnClickListener
                             }
 
                             else -> {
-                                settingsViewModel.clickedItem!!.setting.reset()
+                                item.setting.reset()
                                 settingsViewModel.setAdapterItemChanged(position)
                             }
                         }
                     }
-                    .setNegativeButton(android.R.string.cancel, null)
+                    .setNegativeButton(android.R.string.cancel) { _: DialogInterface, _: Int ->
+                        clearDialogState()
+                    }
+                    .setOnCancelListener {
+                        clearDialogState()
+                    }
                     .create()
             }
 
@@ -186,27 +193,6 @@ class SettingsDialogFragment : DialogFragment(), DialogInterface.OnClickListener
                     updateButtonState(isValid)
                 }
 
-                /*
-                 * xbzk: these two events, along with attachRepeat feature,
-                 * were causing spinbox buttons to respond twice per press
-                 * cutting these out to retain accelerated press functionality
-                 * TODO: clean this out later if no issues arise
-                 *
-                spinboxBinding.buttonDecrement.setOnClickListener {
-                    val current = spinboxBinding.editValue.text.toString().toIntOrNull() ?: currentValue
-                    val newValue = current - 1
-                    spinboxBinding.editValue.setText(newValue.toString())
-                    updateValidity(newValue)
-                }
-
-                spinboxBinding.buttonIncrement.setOnClickListener {
-                    val current = spinboxBinding.editValue.text.toString().toIntOrNull() ?: currentValue
-                    val newValue = current + 1
-                    spinboxBinding.editValue.setText(newValue.toString())
-                    updateValidity(newValue)
-                }
-                */
-
                 fun attachRepeat(button: View, delta: Int) {
                     val handler = Handler(Looper.getMainLooper())
                     var runnable: Runnable? = null
@@ -439,9 +425,13 @@ class SettingsDialogFragment : DialogFragment(), DialogInterface.OnClickListener
 
     private fun closeDialog() {
         settingsViewModel.setAdapterItemChanged(position)
+        clearDialogState()
+        dismiss()
+    }
+
+    private fun clearDialogState() {
         settingsViewModel.clickedItem = null
         settingsViewModel.setSliderProgress(-1f)
-        dismiss()
     }
 
     private fun getValueForSingleChoiceSelection(item: SingleChoiceSetting, which: Int): Int {

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

@@ -1066,7 +1066,10 @@ class SettingsFragmentPresenter(
                     IntSetting.THEME.getValueAsString()
 
                 override val defaultValue: Int = IntSetting.THEME.defaultValue
-                override fun reset() = IntSetting.THEME.setInt(defaultValue)
+                override fun reset() {
+                    IntSetting.THEME.setInt(defaultValue)
+                    settingsViewModel.setShouldRecreate(true)
+                }
             }
 
             add(HeaderSetting(R.string.app_settings))

src/android/app/src/main/java/org/yuzu/yuzu_emu/model/AddonViewModel.kt

@@ -127,10 +127,6 @@ class AddonViewModel : ViewModel() {
             return
         }
 
-        // Check if there are multiple update versions
-        val updates = _patchList.value.filter { PatchType.from(it.type) == PatchType.Update }
-        val hasMultipleUpdates = updates.size > 1
-
         NativeConfig.setDisabledAddons(
             game!!.programId,
             _patchList.value.mapNotNull {
@@ -140,7 +136,7 @@ class AddonViewModel : ViewModel() {
                     if (PatchType.from(it.type) == PatchType.Update) {
                         if (it.name.contains("(NAND)") || it.name.contains("(SDMC)")) {
                             it.name
-                        } else if (hasMultipleUpdates) {
+                        } else if (it.numericVersion != 0L) {
                             "Update@${it.numericVersion}"
                         } else {
                             it.name

src/android/app/src/main/java/org/yuzu/yuzu_emu/ui/main/MainActivity.kt

@@ -424,7 +424,9 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
         )
 
         val uriString = result.toString()
-        val folder = gamesViewModel.folders.value.firstOrNull { it.uriString == uriString }
+        val folder = gamesViewModel.folders.value.firstOrNull {
+            it.uriString == uriString && it.type == org.yuzu.yuzu_emu.model.DirectoryType.EXTERNAL_CONTENT
+        }
         if (folder != null) {
             Toast.makeText(
                 applicationContext,

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameHelper.kt

@@ -51,11 +51,24 @@ object GameHelper {
 
         // Scan External Content directories and register all NSP/XCI files
         val externalContentDirs = NativeConfig.getExternalContentDirs()
-        for (externalDir in externalContentDirs) {
+        val uniqueExternalContentDirs = linkedSetOf<String>()
+        externalContentDirs.forEach { externalDir ->
+            if (externalDir.isNotEmpty()) {
+                uniqueExternalContentDirs.add(externalDir)
+            }
+        }
+
+        val mountedContainerUris = mutableSetOf<String>()
+        for (externalDir in uniqueExternalContentDirs) {
             if (externalDir.isNotEmpty()) {
                 val externalDirUri = externalDir.toUri()
                 if (FileUtil.isTreeUriValid(externalDirUri)) {
-                    scanExternalContentRecursive(FileUtil.listFiles(externalDirUri), 3)
+                    scanContentContainersRecursive(FileUtil.listFiles(externalDirUri), 3) {
+                        val containerUri = it.uri.toString()
+                        if (mountedContainerUris.add(containerUri)) {
+                            NativeLibrary.addFileToFilesystemProvider(containerUri)
+                        }
+                    }
                 }
             }
         }
@@ -65,10 +78,13 @@ object GameHelper {
             val gameDirUri = gameDir.uriString.toUri()
             val isValid = FileUtil.isTreeUriValid(gameDirUri)
             if (isValid) {
+                val scanDepth = if (gameDir.deepScan) 3 else 1
+
                 addGamesRecursive(
                     games,
                     FileUtil.listFiles(gameDirUri),
-                    if (gameDir.deepScan) 3 else 1
+                    scanDepth,
+                    mountedContainerUris
                 )
             } else {
                 badDirs.add(index)
@@ -103,9 +119,10 @@ object GameHelper {
     // be done better imo.
     private val externalContentExtensions = setOf("nsp", "xci")
 
-    private fun scanExternalContentRecursive(
+    private fun scanContentContainersRecursive(
         files: Array<MinimalDocumentFile>,
-        depth: Int
+        depth: Int,
+        onContainerFound: (MinimalDocumentFile) -> Unit
     ) {
         if (depth <= 0) {
             return
@@ -113,14 +130,15 @@ object GameHelper {
 
         files.forEach {
             if (it.isDirectory) {
-                scanExternalContentRecursive(
+                scanContentContainersRecursive(
                     FileUtil.listFiles(it.uri),
-                    depth - 1
+                    depth - 1,
+                    onContainerFound
                 )
             } else {
                 val extension = FileUtil.getExtension(it.uri).lowercase()
                 if (externalContentExtensions.contains(extension)) {
-                    NativeLibrary.addFileToFilesystemProvider(it.uri.toString())
+                    onContainerFound(it)
                 }
             }
         }
@@ -129,7 +147,8 @@ object GameHelper {
     private fun addGamesRecursive(
         games: MutableList<Game>,
         files: Array<MinimalDocumentFile>,
-        depth: Int
+        depth: Int,
+        mountedContainerUris: MutableSet<String>
     ) {
         if (depth <= 0) {
             return
@@ -140,11 +159,20 @@ object GameHelper {
                 addGamesRecursive(
                     games,
                     FileUtil.listFiles(it.uri),
-                    depth - 1
+                    depth - 1,
+                    mountedContainerUris
                 )
             } else {
-                if (Game.extensions.contains(FileUtil.getExtension(it.uri))) {
-                    val game = getGame(it.uri, true)
+                val extension = FileUtil.getExtension(it.uri).lowercase()
+                val filePath = it.uri.toString()
+
+                if (externalContentExtensions.contains(extension) &&
+                    mountedContainerUris.add(filePath)) {
+                    NativeLibrary.addGameFolderFileToFilesystemProvider(filePath)
+                }
+
+                if (Game.extensions.contains(extension)) {
+                    val game = getGame(it.uri, true, false)
                     if (game != null) {
                         games.add(game)
                     }
@@ -153,14 +181,20 @@ object GameHelper {
         }
     }
 
-    fun getGame(uri: Uri, addedToLibrary: Boolean): Game? {
+    fun getGame(
+        uri: Uri,
+        addedToLibrary: Boolean,
+        registerFilesystemProvider: Boolean = true
+    ): Game? {
         val filePath = uri.toString()
         if (!GameMetadata.getIsValid(filePath)) {
             return null
         }
 
-        // Needed to update installed content information
-        NativeLibrary.addFileToFilesystemProvider(filePath)
+        if (registerFilesystemProvider) {
+            // Needed to update installed content information
+            NativeLibrary.addFileToFilesystemProvider(filePath)
+        }
 
         var name = GameMetadata.getTitle(filePath)
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/PathUtil.kt

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 package org.yuzu.yuzu_emu.utils
@@ -80,16 +80,14 @@ object PathUtil {
         }
     }
 
-    // This really shouldn't be necessary, but the Android API seemingly
-    // doesn't have a way of doing this?
-    // Apparently, on certain devices the mount location can vary, so add
-    // extra cases here if we discover any new ones.
     fun getRemovableStoragePath(idString: String): String? {
-        var pathFile: File
+        val possibleMountPaths = listOf("/mnt/media_rw/$idString", "/storage/$idString")
 
-        pathFile = File("/mnt/media_rw/$idString");
-        if (pathFile.exists()) {
-            return pathFile.absolutePath
+        for (mountPath in possibleMountPaths) {
+            val pathFile = File(mountPath);
+            if (pathFile.exists()) {
+                return pathFile.absolutePath
+            }
         }
 
         return null

src/android/app/src/main/jni/android_config.cpp

@@ -33,6 +33,12 @@ void AndroidConfig::ReadAndroidValues() {
     if (global) {
         ReadAndroidUIValues();
         ReadUIValues();
+        BeginGroup(Settings::TranslateCategory(Settings::Category::DataStorage));
+        Settings::values.ext_content_from_game_dirs = ReadBooleanSetting(
+            std::string("ext_content_from_game_dirs"),
+            std::make_optional(
+                Settings::values.ext_content_from_game_dirs.GetDefault()));
+        EndGroup();
         ReadOverlayValues();
     }
     ReadDriverValues();

src/android/app/src/main/jni/game_metadata.cpp

@@ -96,6 +96,11 @@ jboolean Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getIsValid(JNIEnv* env, jobj
         return false;
     }
 
+    if ((file_type == Loader::FileType::NSP || file_type == Loader::FileType::XCI) &&
+        !Loader::IsBootableGameContainer(file, file_type)) {
+        return false;
+    }
+
     u64 program_id = 0;
     Loader::ResultStatus res = loader->ReadProgramId(program_id);
     if (res != Loader::ResultStatus::Success) {

src/android/app/src/main/jni/native.cpp

@@ -217,107 +217,8 @@ void EmulationSession::ConfigureFilesystemProvider(const std::string& filepath)
         return;
     }
 
-    const auto extension = Common::ToLower(filepath.substr(filepath.find_last_of('.') + 1));
-
-    if (extension == "nsp") {
-        auto nsp = std::make_shared<FileSys::NSP>(file);
-        if (nsp->GetStatus() == Loader::ResultStatus::Success) {
-            std::map<u64, u32> nsp_versions;
-            std::map<u64, std::string> nsp_version_strings;
-
-            for (const auto& [title_id, nca_map] : nsp->GetNCAs()) {
-                for (const auto& [type_pair, nca] : nca_map) {
-                    const auto& [title_type, content_type] = type_pair;
-
-                    if (content_type == FileSys::ContentRecordType::Meta) {
-                        const auto meta_nca = std::make_shared<FileSys::NCA>(nca->GetBaseFile());
-                        if (meta_nca->GetStatus() == Loader::ResultStatus::Success) {
-                            const auto section0 = meta_nca->GetSubdirectories();
-                            if (!section0.empty()) {
-                                for (const auto& meta_file : section0[0]->GetFiles()) {
-                                    if (meta_file->GetExtension() == "cnmt") {
-                                        FileSys::CNMT cnmt(meta_file);
-                                        nsp_versions[cnmt.GetTitleID()] = cnmt.GetTitleVersion();
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    if (content_type == FileSys::ContentRecordType::Control &&
-                        title_type == FileSys::TitleType::Update) {
-                        auto romfs = nca->GetRomFS();
-                        if (romfs) {
-                            auto extracted = FileSys::ExtractRomFS(romfs);
-                            if (extracted) {
-                                auto nacp_file = extracted->GetFile("control.nacp");
-                                if (!nacp_file) {
-                                    nacp_file = extracted->GetFile("Control.nacp");
-                                }
-                                if (nacp_file) {
-                                    FileSys::NACP nacp(nacp_file);
-                                    auto ver_str = nacp.GetVersionString();
-                                    if (!ver_str.empty()) {
-                                        nsp_version_strings[title_id] = ver_str;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            for (const auto& [title_id, nca_map] : nsp->GetNCAs()) {
-                for (const auto& [type_pair, nca] : nca_map) {
-                    const auto& [title_type, content_type] = type_pair;
-
-                    if (title_type == FileSys::TitleType::Update) {
-                        u32 version = 0;
-                        auto ver_it = nsp_versions.find(title_id);
-                        if (ver_it != nsp_versions.end()) {
-                            version = ver_it->second;
-                        }
-
-                        std::string version_string;
-                        auto str_it = nsp_version_strings.find(title_id);
-                        if (str_it != nsp_version_strings.end()) {
-                            version_string = str_it->second;
-                        }
-
-                        m_manual_provider->AddEntryWithVersion(
-                            title_type, content_type, title_id, version, version_string,
-                            nca->GetBaseFile());
-
-                        LOG_DEBUG(Frontend, "Added NSP update entry - TitleID: {:016X}, Version: {}, VersionStr: {}",
-                                  title_id, version, version_string);
-                    } else {
-                        // Use regular AddEntry for non-updates
-                        m_manual_provider->AddEntry(title_type, content_type, title_id,
-                                                    nca->GetBaseFile());
-                        LOG_DEBUG(Frontend, "Added NSP entry - TitleID: {:016X}, TitleType: {}, ContentType: {}",
-                                  title_id, static_cast<int>(title_type), static_cast<int>(content_type));
-                    }
-                }
-            }
-            return;
-        }
-    }
-
-    // Handle XCI files
-    if (extension == "xci") {
-        FileSys::XCI xci{file};
-        if (xci.GetStatus() == Loader::ResultStatus::Success) {
-            const auto nsp = xci.GetSecurePartitionNSP();
-            if (nsp) {
-                for (const auto& title : nsp->GetNCAs()) {
-                    for (const auto& entry : title.second) {
-                        m_manual_provider->AddEntry(entry.first.first, entry.first.second, title.first,
-                                                    entry.second->GetBaseFile());
-                    }
-                }
-            }
-            return;
-        }
+    if (m_manual_provider->AddEntriesFromContainer(file)) {
+        return;
     }
 
     auto loader = Loader::GetLoader(m_system, file);
@@ -339,6 +240,13 @@ void EmulationSession::ConfigureFilesystemProvider(const std::string& filepath)
     }
 }
 
+void EmulationSession::ConfigureFilesystemProviderFromGameFolder(const std::string& filepath) {
+    if (!Settings::values.ext_content_from_game_dirs.GetValue()) {
+        return;
+    }
+    ConfigureFilesystemProvider(filepath);
+}
+
 void EmulationSession::InitializeSystem(bool reload) {
     if (!reload) {
         // Initialize logging system
@@ -1609,6 +1517,12 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_addFileToFilesystemProvider(JNIEnv* e
         Common::Android::GetJString(env, jpath));
 }
 
+void Java_org_yuzu_yuzu_1emu_NativeLibrary_addGameFolderFileToFilesystemProvider(
+    JNIEnv* env, jobject jobj, jstring jpath) {
+    EmulationSession::GetInstance().ConfigureFilesystemProviderFromGameFolder(
+        Common::Android::GetJString(env, jpath));
+}
+
 void Java_org_yuzu_yuzu_1emu_NativeLibrary_clearFilesystemProvider(JNIEnv* env, jobject jobj) {
     EmulationSession::GetInstance().GetContentProvider()->ClearAllEntries();
 }

src/android/app/src/main/jni/native.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -46,6 +49,7 @@ public:
     const Core::PerfStatsResults& PerfStats();
     int ShadersBuilding();
     void ConfigureFilesystemProvider(const std::string& filepath);
+    void ConfigureFilesystemProviderFromGameFolder(const std::string& filepath);
     void InitializeSystem(bool reload);
     void SetAppletId(int applet_id);
     Core::SystemResultStatus InitializeEmulation(const std::string& filepath,

src/common/settings.h

@@ -756,6 +756,8 @@ struct Values {
                                         Category::DataStorage};
     Setting<std::string> gamecard_path{linkage, std::string(), "gamecard_path",
                                        Category::DataStorage};
+    Setting<bool> ext_content_from_game_dirs{linkage, true, "ext_content_from_game_dirs",
+                                             Category::DataStorage};
     std::vector<std::string> external_content_dirs;
 
     // Debugging

src/core/file_sys/patch_manager.cpp

@@ -117,6 +117,12 @@ void AppendCommaIfNotEmpty(std::string& to, std::string_view with) {
 bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
     return dir != nullptr && (!dir->GetFiles().empty() || !dir->GetSubdirectories().empty());
 }
+
+bool IsVersionedExternalUpdateDisabled(const std::vector<std::string>& disabled, u32 version) {
+    const std::string disabled_key = fmt::format("Update@{}", version);
+    return std::find(disabled.cbegin(), disabled.cend(), disabled_key) != disabled.cend() ||
+           std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
+}
 } // Anonymous namespace
 
 PatchManager::PatchManager(u64 title_id_,
@@ -155,8 +161,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
             if (!update_versions.empty()) {
                 checked_external = true;
                 for (const auto& update_entry : update_versions) {
-                    std::string disabled_key = fmt::format("Update@{}", update_entry.version);
-                    if (std::find(disabled.cbegin(), disabled.cend(), disabled_key) == disabled.cend()) {
+                    if (!IsVersionedExternalUpdateDisabled(disabled, update_entry.version)) {
                         update_disabled = false;
                         enabled_version = update_entry.version;
                         break;
@@ -175,8 +180,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
                 if (!manual_update_versions.empty()) {
                     checked_manual = true;
                     for (const auto& update_entry : manual_update_versions) {
-                        std::string disabled_key = fmt::format("Update@{}", update_entry.version);
-                        if (std::find(disabled.cbegin(), disabled.cend(), disabled_key) == disabled.cend()) {
+                        if (!IsVersionedExternalUpdateDisabled(disabled, update_entry.version)) {
                             update_disabled = false;
                             enabled_version = update_entry.version;
                             break;
@@ -580,8 +584,7 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs
             if (!update_versions.empty()) {
                 checked_external = true;
                 for (const auto& update_entry : update_versions) {
-                    std::string disabled_key = fmt::format("Update@{}", update_entry.version);
-                    if (std::find(disabled.cbegin(), disabled.cend(), disabled_key) == disabled.cend()) {
+                    if (!IsVersionedExternalUpdateDisabled(disabled, update_entry.version)) {
                         update_disabled = false;
                         enabled_version = update_entry.version;
                         update_raw = external_provider->GetEntryForVersion(update_tid, type, update_entry.version);
@@ -600,8 +603,7 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs
                 if (!manual_update_versions.empty()) {
                     checked_manual = true;
                     for (const auto& update_entry : manual_update_versions) {
-                        std::string disabled_key = fmt::format("Update@{}", update_entry.version);
-                        if (std::find(disabled.cbegin(), disabled.cend(), disabled_key) == disabled.cend()) {
+                        if (!IsVersionedExternalUpdateDisabled(disabled, update_entry.version)) {
                             update_disabled = false;
                             enabled_version = update_entry.version;
                             update_raw = manual_provider->GetEntryForVersion(update_tid, type, update_entry.version);
@@ -704,9 +706,8 @@ std::vector<Patch> PatchManager::GetPatches(VirtualFile update_raw) const {
                     version_str = FormatTitleVersion(update_entry.version);
                 }
 
-                std::string disabled_key = fmt::format("Update@{}", update_entry.version);
                 const auto update_disabled =
-                    std::find(disabled.cbegin(), disabled.cend(), disabled_key) != disabled.cend();
+                    IsVersionedExternalUpdateDisabled(disabled, update_entry.version);
 
                 Patch update_patch = {.enabled = !update_disabled,
                                       .name = "Update",
@@ -732,9 +733,8 @@ std::vector<Patch> PatchManager::GetPatches(VirtualFile update_raw) const {
                     version_str = FormatTitleVersion(update_entry.version);
                 }
 
-                std::string disabled_key = fmt::format("Update@{}", update_entry.version);
                 const auto update_disabled =
-                    std::find(disabled.cbegin(), disabled.cend(), disabled_key) != disabled.cend();
+                    IsVersionedExternalUpdateDisabled(disabled, update_entry.version);
 
 
                 Patch update_patch = {.enabled = !update_disabled,
@@ -771,7 +771,8 @@ std::vector<Patch> PatchManager::GetPatches(VirtualFile update_raw) const {
             std::nullopt, std::nullopt, ContentRecordType::Program, update_tid);
 
         for (const auto& [slot, entry] : all_updates) {
-            if (slot == ContentProviderUnionSlot::External) {
+            if (slot == ContentProviderUnionSlot::External ||
+                slot == ContentProviderUnionSlot::FrontendManual) {
                 continue;
             }
 

src/core/file_sys/registered_cache.cpp

@@ -104,6 +104,206 @@ static std::string GetCNMTName(TitleType type, u64 title_id) {
     return fmt::format("{}_{:016x}.cnmt", TITLE_TYPE_NAMES[index], title_id);
 }
 
+static std::shared_ptr<NSP> OpenContainerAsNsp(const VirtualFile& file, Loader::FileType type) {
+    if (!file) {
+        return nullptr;
+    }
+
+    if (type == Loader::FileType::Unknown || type == Loader::FileType::Error) {
+        type = Loader::IdentifyFile(file);
+        if (type == Loader::FileType::Unknown) {
+            type = Loader::GuessFromFilename(file->GetName());
+        }
+    }
+
+    if (type == Loader::FileType::NSP) {
+        auto nsp = std::make_shared<NSP>(file);
+        return nsp->GetStatus() == Loader::ResultStatus::Success ? nsp : nullptr;
+    }
+
+    if (type == Loader::FileType::XCI) {
+        XCI xci(file);
+        if (xci.GetStatus() != Loader::ResultStatus::Success) {
+            return nullptr;
+        }
+
+        auto secure_partition = xci.GetSecurePartitionNSP();
+        if (secure_partition == nullptr) {
+            return nullptr;
+        }
+
+        return secure_partition;
+    }
+
+    // SAF-backed files can occasionally fail type-guessing despite being valid NSP/XCI.
+    // As a last resort, probe both container parsers directly.
+    {
+        auto nsp = std::make_shared<NSP>(file);
+        if (nsp->GetStatus() == Loader::ResultStatus::Success) {
+            return nsp;
+        }
+    }
+    {
+        XCI xci(file);
+        if (xci.GetStatus() == Loader::ResultStatus::Success) {
+            auto secure_partition = xci.GetSecurePartitionNSP();
+            if (secure_partition != nullptr) {
+                return secure_partition;
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+template <typename Callback>
+bool ForEachContainerEntry(const std::shared_ptr<NSP>& nsp, bool only_content,
+                           std::optional<u64> base_program_id, Callback&& on_entry) {
+    if (!nsp) {
+        return false;
+    }
+
+    const auto& ncas = nsp->GetNCAs();
+    if (ncas.empty()) {
+        return false;
+    }
+
+    std::map<u64, u32> versions;
+    std::map<u64, std::string> version_strings;
+
+    for (const auto& [title_id, nca_map] : ncas) {
+        for (const auto& [type_pair, nca] : nca_map) {
+            if (!nca) {
+                continue;
+            }
+
+            const auto& [title_type, content_type] = type_pair;
+
+            if (content_type == ContentRecordType::Meta) {
+                const auto subdirs = nca->GetSubdirectories();
+                if (!subdirs.empty()) {
+                    for (const auto& inner_file : subdirs[0]->GetFiles()) {
+                        if (inner_file->GetExtension() == "cnmt") {
+                            const CNMT cnmt(inner_file);
+                            versions[cnmt.GetTitleID()] = cnmt.GetTitleVersion();
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if (title_type == TitleType::Update && content_type == ContentRecordType::Control) {
+                const auto romfs = nca->GetRomFS();
+                if (!romfs) {
+                    continue;
+                }
+
+                const auto extracted = ExtractRomFS(romfs);
+                if (!extracted) {
+                    continue;
+                }
+
+                auto nacp_file = extracted->GetFile("control.nacp");
+                if (!nacp_file) {
+                    nacp_file = extracted->GetFile("Control.nacp");
+                }
+                if (!nacp_file) {
+                    continue;
+                }
+
+                const NACP nacp(nacp_file);
+                auto version_string = nacp.GetVersionString();
+                if (!version_string.empty()) {
+                    version_strings[title_id] = std::move(version_string);
+                }
+            }
+        }
+    }
+
+    bool added_entries = false;
+    for (const auto& [title_id, nca_map] : ncas) {
+        if (base_program_id.has_value() && GetBaseTitleID(title_id) != *base_program_id) {
+            continue;
+        }
+
+        for (const auto& [type_pair, nca] : nca_map) {
+            const auto& [title_type, content_type] = type_pair;
+            if (only_content && title_type != TitleType::Update && title_type != TitleType::AOC) {
+                continue;
+            }
+
+            auto entry_file = nca ? nca->GetBaseFile() : nullptr;
+            if (!entry_file) {
+                continue;
+            }
+
+            u32 version = 0;
+            std::string version_string;
+
+            if (title_type == TitleType::Update) {
+                if (const auto version_it = versions.find(title_id); version_it != versions.end()) {
+                    version = version_it->second;
+                }
+
+                if (const auto version_str_it = version_strings.find(title_id);
+                    version_str_it != version_strings.end()) {
+                    version_string = version_str_it->second;
+                }
+            }
+
+            on_entry(title_type, content_type, title_id, entry_file, version, version_string);
+            added_entries = true;
+        }
+    }
+
+    return added_entries;
+}
+
+static void UpsertExternalVersionEntry(std::vector<ExternalUpdateEntry>& multi_version_entries,
+                                       u64 title_id, u32 version,
+                                       const std::string& version_string,
+                                       ContentRecordType content_type, const VirtualFile& file) {
+    auto it = std::find_if(multi_version_entries.begin(), multi_version_entries.end(),
+                           [title_id, version](const ExternalUpdateEntry& entry) {
+                               return entry.title_id == title_id && entry.version == version;
+                           });
+
+    if (it == multi_version_entries.end()) {
+        ExternalUpdateEntry update_entry;
+        update_entry.title_id = title_id;
+        update_entry.version = version;
+        update_entry.version_string = version_string;
+        update_entry.files[static_cast<std::size_t>(content_type)] = file;
+        multi_version_entries.push_back(std::move(update_entry));
+        return;
+    }
+
+    it->files[static_cast<std::size_t>(content_type)] = file;
+    if (it->version_string.empty() && !version_string.empty()) {
+        it->version_string = version_string;
+    }
+}
+
+template <typename EntryMap, typename VersionMap>
+static bool AddExternalEntriesFromContainer(const std::shared_ptr<NSP>& nsp, EntryMap& entries,
+                                            VersionMap& versions,
+                                            std::vector<ExternalUpdateEntry>& multi_version_entries) {
+    return ForEachContainerEntry(
+        nsp, true, std::nullopt,
+        [&entries, &versions,
+         &multi_version_entries](TitleType title_type, ContentRecordType content_type, u64 title_id,
+                                 const VirtualFile& file, u32 version,
+                                 const std::string& version_string) {
+            entries[{title_id, content_type, title_type}] = file;
+
+            if (title_type == TitleType::Update) {
+                versions[title_id] = version;
+                UpsertExternalVersionEntry(multi_version_entries, title_id, version, version_string,
+                                           content_type, file);
+            }
+        });
+}
+
 ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
     switch (type) {
     case NCAContentType::Program:
@@ -1008,6 +1208,26 @@ void ManualContentProvider::AddEntryWithVersion(TitleType title_type, ContentRec
     }
 }
 
+bool ManualContentProvider::AddEntriesFromContainer(VirtualFile file, bool only_content,
+                                                    std::optional<u64> base_program_id) {
+    const auto nsp = OpenContainerAsNsp(file, Loader::FileType::Unknown);
+    if (!nsp) {
+        return false;
+    }
+
+    return ForEachContainerEntry(
+        nsp, only_content, base_program_id,
+        [this](TitleType title_type, ContentRecordType content_type, u64 title_id,
+               const VirtualFile& entry_file, u32 version, const std::string& version_string) {
+            if (title_type == TitleType::Update) {
+                AddEntryWithVersion(title_type, content_type, title_id, version, version_string,
+                                    entry_file);
+            } else {
+                AddEntry(title_type, content_type, title_id, entry_file);
+            }
+        });
+}
+
 void ManualContentProvider::ClearAllEntries() {
     entries.clear();
     multi_version_entries.clear();
@@ -1091,14 +1311,6 @@ VirtualFile ManualContentProvider::GetEntryForVersion(u64 title_id, ContentRecor
     return nullptr;
 }
 
-bool ManualContentProvider::HasMultipleVersions(u64 title_id, ContentRecordType type) const {
-    size_t count = 0;
-    for (const auto& entry : multi_version_entries)
-        if (entry.title_id == title_id && entry.files[size_t(type)])
-            ++count;
-    return count > 0;
-}
-
 ExternalContentProvider::ExternalContentProvider(std::vector<VirtualDir> load_directories)
     : load_dirs(std::move(load_directories)) {
     ExternalContentProvider::Refresh();
@@ -1159,247 +1371,22 @@ void ExternalContentProvider::ScanDirectory(const VirtualDir& dir) {
 }
 
 void ExternalContentProvider::ProcessNSP(const VirtualFile& file) {
-    auto nsp = NSP(file);
-    if (nsp.GetStatus() != Loader::ResultStatus::Success) {
+    const auto nsp = OpenContainerAsNsp(file, Loader::FileType::NSP);
+    if (!nsp) {
         return;
     }
 
     LOG_DEBUG(Service_FS, "Processing NSP file: {}", file->GetName());
-
-    const auto ncas = nsp.GetNCAs();
-
-    std::map<u64, u32> nsp_versions;
-    std::map<u64, std::string> nsp_version_strings;  // title_id -> NACP version string
-
-    for (const auto& [title_id, nca_map] : ncas) {
-        for (const auto& [type_pair, nca] : nca_map) {
-            const auto& [title_type, content_type] = type_pair;
-
-            if (content_type == ContentRecordType::Meta) {
-                const auto subdirs = nca->GetSubdirectories();
-                if (!subdirs.empty()) {
-                    const auto section0 = subdirs[0];
-                    const auto files = section0->GetFiles();
-                    for (const auto& inner_file : files) {
-                        if (inner_file->GetExtension() == "cnmt") {
-                            const CNMT cnmt(inner_file);
-                            const auto cnmt_title_id = cnmt.GetTitleID();
-                            const auto version = cnmt.GetTitleVersion();
-                            nsp_versions[cnmt_title_id] = version;
-                            versions[cnmt_title_id] = version;
-                            break;
-                        }
-                    }
-                }
-            }
-
-            if (content_type == ContentRecordType::Control && title_type == TitleType::Update) {
-                auto romfs = nca->GetRomFS();
-                if (romfs) {
-                    auto extracted = ExtractRomFS(romfs);
-                    if (extracted) {
-                        auto nacp_file = extracted->GetFile("control.nacp");
-                        if (!nacp_file) {
-                            nacp_file = extracted->GetFile("Control.nacp");
-                        }
-                        if (nacp_file) {
-                            NACP nacp(nacp_file);
-                            auto ver_str = nacp.GetVersionString();
-                            if (!ver_str.empty()) {
-                                nsp_version_strings[title_id] = ver_str;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    std::map<std::pair<u64, u32>, std::array<VirtualFile, size_t(ContentRecordType::Count)>> version_files;
-
-    for (const auto& [title_id, nca_map] : ncas) {
-        for (const auto& [type_pair, nca] : nca_map) {
-            const auto& [title_type, content_type] = type_pair;
-
-            if (title_type != TitleType::AOC && title_type != TitleType::Update) {
-                continue;
-            }
-
-            auto nca_file = nsp.GetNCAFile(title_id, content_type, title_type);
-            if (nca_file != nullptr) {
-                entries[{title_id, content_type, title_type}] = nca_file;
-
-                if (title_type == TitleType::Update) {
-                    u32 version = 0;
-                    auto ver_it = nsp_versions.find(title_id);
-                    if (ver_it != nsp_versions.end()) {
-                        version = ver_it->second;
-                    }
-
-                    version_files[{title_id, version}][size_t(content_type)] = nca_file;
-                }
-
-                LOG_DEBUG(Service_FS, "Added entry - Title ID: {:016X}, Type: {}, Content: {}",
-                          title_id, static_cast<int>(title_type), static_cast<int>(content_type));
-            }
-        }
-    }
-
-    for (const auto& [key, files_map] : version_files) {
-        const auto& [title_id, version] = key;
-
-        std::string ver_str;
-        auto str_it = nsp_version_strings.find(title_id);
-        if (str_it != nsp_version_strings.end()) {
-            ver_str = str_it->second;
-        }
-
-        bool version_exists = false;
-        for (auto& existing : multi_version_entries) {
-            if (existing.title_id == title_id && existing.version == version) {
-                existing.files = files_map;
-                if (existing.version_string.empty() && !ver_str.empty()) {
-                    existing.version_string = ver_str;
-                }
-                version_exists = true;
-                break;
-            }
-        }
-
-        if (!version_exists && !files_map.empty()) {
-            ExternalUpdateEntry update_entry{
-                .title_id = title_id,
-                .version = version,
-                .version_string = ver_str,
-                .files = files_map
-            };
-            multi_version_entries.push_back(update_entry);
-            LOG_DEBUG(Service_FS, "Added multi-version update - Title ID: {:016X}, Version: {}, VersionStr: {}, Content types: {}",
-                      title_id, version, ver_str, files_map.size());
-        }
-    }
+    AddExternalEntriesFromContainer(nsp, entries, versions, multi_version_entries);
 }
 
 void ExternalContentProvider::ProcessXCI(const VirtualFile& file) {
-    auto xci = XCI(file);
-    if (xci.GetStatus() != Loader::ResultStatus::Success) {
+    const auto nsp = OpenContainerAsNsp(file, Loader::FileType::XCI);
+    if (!nsp) {
         return;
     }
 
-    auto nsp = xci.GetSecurePartitionNSP();
-    if (nsp == nullptr) {
-        return;
-    }
-
-    const auto ncas = nsp->GetNCAs();
-
-    std::map<u64, u32> xci_versions;
-    std::map<u64, std::string> xci_version_strings;
-
-    for (const auto& [title_id, nca_map] : ncas) {
-        for (const auto& [type_pair, nca] : nca_map) {
-            const auto& [title_type, content_type] = type_pair;
-
-            if (content_type == ContentRecordType::Meta) {
-                const auto subdirs = nca->GetSubdirectories();
-                if (!subdirs.empty()) {
-                    const auto section0 = subdirs[0];
-                    const auto files = section0->GetFiles();
-                    for (const auto& inner_file : files) {
-                        if (inner_file->GetExtension() == "cnmt") {
-                            const CNMT cnmt(inner_file);
-                            const auto cnmt_title_id = cnmt.GetTitleID();
-                            const auto version = cnmt.GetTitleVersion();
-                            xci_versions[cnmt_title_id] = version;
-                            versions[cnmt_title_id] = version;
-                            break;
-                        }
-                    }
-                }
-            }
-
-            if (content_type == ContentRecordType::Control && title_type == TitleType::Update) {
-                auto romfs = nca->GetRomFS();
-                if (romfs) {
-                    auto extracted = ExtractRomFS(romfs);
-                    if (extracted) {
-                        auto nacp_file = extracted->GetFile("control.nacp");
-                        if (!nacp_file) {
-                            nacp_file = extracted->GetFile("Control.nacp");
-                        }
-                        if (nacp_file) {
-                            NACP nacp(nacp_file);
-                            auto ver_str = nacp.GetVersionString();
-                            if (!ver_str.empty()) {
-                                xci_version_strings[title_id] = ver_str;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    std::map<std::pair<u64, u32>, std::array<VirtualFile, size_t(ContentRecordType::Count)>> version_files;
-
-    for (const auto& [title_id, nca_map] : ncas) {
-        for (const auto& [type_pair, nca] : nca_map) {
-            const auto& [title_type, content_type] = type_pair;
-
-            if (title_type != TitleType::AOC && title_type != TitleType::Update) {
-                continue;
-            }
-
-            auto nca_file = nsp->GetNCAFile(title_id, content_type, title_type);
-            if (nca_file != nullptr) {
-                entries[{title_id, content_type, title_type}] = nca_file;
-
-                if (title_type == TitleType::Update) {
-                    u32 version = 0;
-                    auto ver_it = xci_versions.find(title_id);
-                    if (ver_it != xci_versions.end()) {
-                        version = ver_it->second;
-                    }
-
-                    version_files[{title_id, version}][size_t(content_type)] = nca_file;
-                }
-            }
-        }
-    }
-
-    for (const auto& [key, files_map] : version_files) {
-        const auto& [title_id, version] = key;
-
-        std::string ver_str;
-        auto str_it = xci_version_strings.find(title_id);
-        if (str_it != xci_version_strings.end()) {
-            ver_str = str_it->second;
-        }
-
-        bool version_exists = false;
-        for (auto& existing : multi_version_entries) {
-            if (existing.title_id == title_id && existing.version == version) {
-                existing.files = files_map;
-                if (existing.version_string.empty() && !ver_str.empty()) {
-                    existing.version_string = ver_str;
-                }
-                version_exists = true;
-                break;
-            }
-        }
-
-        if (!version_exists && !files_map.empty()) {
-            ExternalUpdateEntry update_entry{
-                .title_id = title_id,
-                .version = version,
-                .version_string = ver_str,
-                .files = files_map
-            };
-            multi_version_entries.push_back(update_entry);
-            LOG_DEBUG(Service_FS, "Added multi-version update from XCI - Title ID: {:016X}, Version: {}, VersionStr: {}, Content types: {}",
-                      title_id, version, ver_str, files_map.size());
-        }
-    }
+    AddExternalEntriesFromContainer(nsp, entries, versions, multi_version_entries);
 }
 
 bool ExternalContentProvider::HasEntry(u64 title_id, ContentRecordType type) const {
@@ -1491,12 +1478,4 @@ VirtualFile ExternalContentProvider::GetEntryForVersion(u64 title_id, ContentRec
     return nullptr;
 }
 
-bool ExternalContentProvider::HasMultipleVersions(u64 title_id, ContentRecordType type) const {
-    size_t count = 0;
-    for (const auto& entry : multi_version_entries)
-        if (entry.title_id == title_id && entry.files[size_t(type)])
-            ++count;
-    return count > 1;
-}
-
 } // namespace FileSys

src/core/file_sys/registered_cache.h

@@ -9,6 +9,7 @@
 #include <array>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 #include <ankerl/unordered_dense.h>
@@ -262,6 +263,8 @@ public:
                   VirtualFile file);
     void AddEntryWithVersion(TitleType title_type, ContentRecordType content_type, u64 title_id,
                              u32 version, const std::string& version_string, VirtualFile file);
+    bool AddEntriesFromContainer(VirtualFile file, bool only_content = false,
+                                 std::optional<u64> base_program_id = std::nullopt);
     void ClearAllEntries();
 
     void Refresh() override;
@@ -276,7 +279,6 @@ public:
 
     std::vector<ExternalUpdateEntry> ListUpdateVersions(u64 title_id) const;
     VirtualFile GetEntryForVersion(u64 title_id, ContentRecordType type, u32 version) const;
-    bool HasMultipleVersions(u64 title_id, ContentRecordType type) const;
 
 private:
     std::map<std::tuple<TitleType, ContentRecordType, u64>, VirtualFile> entries;
@@ -303,7 +305,6 @@ public:
 
     std::vector<ExternalUpdateEntry> ListUpdateVersions(u64 title_id) const;
     VirtualFile GetEntryForVersion(u64 title_id, ContentRecordType type, u32 version) const;
-    bool HasMultipleVersions(u64 title_id, ContentRecordType type) const;
 
 private:
     void ScanDirectory(const VirtualDir& dir);

src/core/loader/loader.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -9,11 +9,15 @@
 #include <ostream>
 #include <string>
 #include <concepts>
+#include <algorithm>
 #include "common/concepts.h"
 #include "common/fs/path_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "core/core.h"
+#include "core/file_sys/card_image.h"
+#include "core/file_sys/common_funcs.h"
+#include "core/file_sys/submission_package.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/loader/deconstructed_rom_directory.h"
 #include "core/loader/kip.h"
@@ -37,6 +41,49 @@ std::optional<FileType> IdentifyFileLoader(FileSys::VirtualFile file) {
     return std::nullopt;
 }
 
+std::shared_ptr<FileSys::NSP> OpenContainerAsNsp(FileSys::VirtualFile file, FileType type,
+                                                 u64 program_id = 0,
+                                                 std::size_t program_index = 0) {
+    if (!file) {
+        return nullptr;
+    }
+
+    if (type == FileType::NSP) {
+        auto nsp = std::make_shared<FileSys::NSP>(file, program_id, program_index);
+        return nsp->GetStatus() == ResultStatus::Success ? nsp : nullptr;
+    }
+
+    if (type == FileType::XCI) {
+        FileSys::XCI xci{file, program_id, program_index};
+        if (xci.GetStatus() != ResultStatus::Success) {
+            return nullptr;
+        }
+
+        auto secure_nsp = xci.GetSecurePartitionNSP();
+        if (secure_nsp == nullptr || secure_nsp->GetStatus() != ResultStatus::Success) {
+            return nullptr;
+        }
+
+        return secure_nsp;
+    }
+
+    return nullptr;
+}
+
+bool HasApplicationProgramContent(const std::shared_ptr<FileSys::NSP>& nsp) {
+    if (!nsp) {
+        return false;
+    }
+
+    const auto& ncas = nsp->GetNCAs();
+    return std::any_of(ncas.cbegin(), ncas.cend(), [](const auto& title_entry) {
+        const auto& nca_map = title_entry.second;
+        return nca_map.find(
+                   {FileSys::TitleType::Application, FileSys::ContentRecordType::Program}) !=
+               nca_map.end();
+    });
+}
+
 } // namespace
 
 FileType IdentifyFile(FileSys::VirtualFile file) {
@@ -62,6 +109,27 @@ FileType IdentifyFile(FileSys::VirtualFile file) {
     }
 }
 
+bool IsContainerType(FileType type) {
+    return type == FileType::NSP || type == FileType::XCI;
+}
+
+bool IsBootableGameContainer(FileSys::VirtualFile file, FileType type, u64 program_id,
+                             std::size_t program_index) {
+    if (!file) {
+        return false;
+    }
+
+    if (type == FileType::Unknown) {
+        type = IdentifyFile(file);
+    }
+
+    if (!IsContainerType(type)) {
+        return false;
+    }
+
+    return HasApplicationProgramContent(OpenContainerAsNsp(file, type, program_id, program_index));
+}
+
 FileType GuessFromFilename(const std::string& name) {
     if (name == "main")
         return FileType::DeconstructedRomDirectory;

src/core/loader/loader.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -46,12 +49,29 @@ enum class FileType {
 };
 
 /**
- * Identifies the type of a bootable file based on the magic value in its header.
+ * Identifies the type of a supported file/container based on its structure.
  * @param file open file
  * @return FileType of file
  */
 FileType IdentifyFile(FileSys::VirtualFile file);
 
+/**
+ * Returns whether the file type represents a container format that can bundle multiple titles
+ * (currently NSP/XCI).
+ */
+bool IsContainerType(FileType type);
+
+/**
+ * Returns whether a container file is bootable as a game (has Application/Program content).
+ *
+ * @param file open file
+ * @param type optional file type; if Unknown it is auto-detected.
+ * @param program_id optional program id hint for multi-program containers.
+ * @param program_index optional program index hint for multi-program containers.
+ */
+bool IsBootableGameContainer(FileSys::VirtualFile file, FileType type = FileType::Unknown,
+                             u64 program_id = 0, std::size_t program_index = 0);
+
 /**
  * Guess the type of a bootable file from its name
  * @param name String name of bootable file

src/core/loader/nsp.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -55,19 +58,30 @@ AppLoader_NSP::~AppLoader_NSP() = default;
 FileType AppLoader_NSP::IdentifyType(const FileSys::VirtualFile& nsp_file) {
     const FileSys::NSP nsp(nsp_file);
 
-    if (nsp.GetStatus() == ResultStatus::Success) {
-        // Extracted Type case
-        if (nsp.IsExtractedType() && nsp.GetExeFS() != nullptr &&
-            FileSys::IsDirectoryExeFS(nsp.GetExeFS())) {
-            return FileType::NSP;
+    if (nsp.GetStatus() != ResultStatus::Success) {
+        return FileType::Error;
+    }
+
+    // Extracted Type case
+    if (nsp.IsExtractedType() && nsp.GetExeFS() != nullptr &&
+        FileSys::IsDirectoryExeFS(nsp.GetExeFS())) {
+        return FileType::NSP;
+    }
+
+    // Non-extracted NSPs can legitimately contain only update/DLC content.
+    // Identify the container format itself; bootability is validated by Load().
+    if (!nsp.GetNCAs().empty()) {
+        return FileType::NSP;
+    }
+
+    // Fallback when NCAs couldn't be parsed (e.g. missing keys) but the PFS still contains NCAs.
+    for (const auto& entry : nsp.GetFiles()) {
+        if (entry == nullptr) {
+            continue;
         }
 
-        // Non-Extracted Type case
-        const auto program_id = nsp.GetProgramTitleID();
-        if (!nsp.IsExtractedType() &&
-            nsp.GetNCA(program_id, FileSys::ContentRecordType::Program) != nullptr &&
-            AppLoader_NCA::IdentifyType(
-                nsp.GetNCAFile(program_id, FileSys::ContentRecordType::Program)) == FileType::NCA) {
+        const auto& name = entry->GetName();
+        if (name.size() >= 4 && name.substr(name.size() - 4) == ".nca") {
             return FileType::NSP;
         }
     }

src/core/loader/xci.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -44,10 +47,13 @@ AppLoader_XCI::~AppLoader_XCI() = default;
 FileType AppLoader_XCI::IdentifyType(const FileSys::VirtualFile& xci_file) {
     const FileSys::XCI xci(xci_file);
 
-    if (xci.GetStatus() == ResultStatus::Success &&
-        xci.GetNCAByType(FileSys::NCAContentType::Program) != nullptr &&
-        AppLoader_NCA::IdentifyType(xci.GetNCAFileByType(FileSys::NCAContentType::Program)) ==
-            FileType::NCA) {
+    if (xci.GetStatus() != ResultStatus::Success) {
+        return FileType::Error;
+    }
+
+    // Identify XCI as a valid container even when it does not include a bootable Program NCA.
+    // Bootability is handled by AppLoader_XCI::Load().
+    if (xci.GetSecurePartitionNSP() != nullptr) {
         return FileType::XCI;
     }
 

src/input_common/input_poller.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -556,10 +559,15 @@ private:
 
 class InputFromMotion final : public Common::Input::InputDevice {
 public:
-    explicit InputFromMotion(PadIdentifier identifier_, int motion_sensor_, float gyro_threshold_,
-                             InputEngine* input_engine_)
-        : identifier(identifier_), motion_sensor(motion_sensor_), gyro_threshold(gyro_threshold_),
-          input_engine(input_engine_) {
+    explicit InputFromMotion(PadIdentifier identifier_, int motion_sensor_, float gyro_threshold_, bool invert_x_, bool invert_y_, bool invert_z_, InputEngine* input_engine_)
+        : identifier(identifier_)
+        , motion_sensor(motion_sensor_)
+        , gyro_threshold(gyro_threshold_)
+        , input_engine(input_engine_)
+        , invert_x{invert_x_}
+        , invert_y{invert_y_}
+        , invert_z{invert_z_}
+    {
         UpdateCallback engine_callback{[this]() { OnChange(); }};
         const InputIdentifier input_identifier{
             .identifier = identifier,
@@ -575,7 +583,19 @@ public:
     }
 
     Common::Input::MotionStatus GetStatus() const {
-        const auto basic_motion = input_engine->GetMotion(identifier, motion_sensor);
+        auto basic_motion = input_engine->GetMotion(identifier, motion_sensor);
+        if (invert_x) {
+            basic_motion.accel_x = -basic_motion.accel_x;
+            basic_motion.gyro_x = -basic_motion.gyro_x;
+        }
+        if (invert_y) {
+            basic_motion.accel_y = -basic_motion.accel_y;
+            basic_motion.gyro_y = -basic_motion.gyro_y;
+        }
+        if (invert_z) {
+            basic_motion.accel_z = -basic_motion.accel_z;
+            basic_motion.gyro_z = -basic_motion.gyro_z;
+        }
         Common::Input::MotionStatus status{};
         const Common::Input::AnalogProperties properties = {
             .deadzone = 0.0f,
@@ -608,6 +628,9 @@ private:
     const float gyro_threshold;
     int callback_key;
     InputEngine* input_engine;
+    bool invert_x : 1;
+    bool invert_y : 1;
+    bool invert_z : 1;
 };
 
 class InputFromAxisMotion final : public Common::Input::InputDevice {
@@ -1066,13 +1089,15 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateMotionDevice(
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
 
+    auto const invert_x = params.Get("invert_x", "+") == "-";
+    auto const invert_y = params.Get("invert_y", "+") != "+";
+    auto const invert_z = params.Get("invert_z", "+") != "+";
     if (params.Has("motion")) {
         const auto motion_sensor = params.Get("motion", 0);
         const auto gyro_threshold = params.Get("threshold", 0.007f);
         input_engine->PreSetController(identifier);
         input_engine->PreSetMotion(identifier, motion_sensor);
-        return std::make_unique<InputFromMotion>(identifier, motion_sensor, gyro_threshold,
-                                                 input_engine.get());
+        return std::make_unique<InputFromMotion>(identifier, motion_sensor, gyro_threshold, invert_x, invert_y, invert_z, input_engine.get());
     }
 
     const auto deadzone = std::clamp(params.Get("deadzone", 0.15f), 0.0f, 1.0f);
@@ -1085,7 +1110,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateMotionDevice(
         .range = range,
         .threshold = threshold,
         .offset = std::clamp(params.Get("offset_x", 0.0f), -1.0f, 1.0f),
-        .inverted = params.Get("invert_x", "+") == "-",
+        .inverted = invert_x,
     };
 
     const auto axis_y = params.Get("axis_y", 1);
@@ -1094,7 +1119,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateMotionDevice(
         .range = range,
         .threshold = threshold,
         .offset = std::clamp(params.Get("offset_y", 0.0f), -1.0f, 1.0f),
-        .inverted = params.Get("invert_y", "+") != "+",
+        .inverted = invert_y,
     };
 
     const auto axis_z = params.Get("axis_z", 1);
@@ -1103,14 +1128,13 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateMotionDevice(
         .range = range,
         .threshold = threshold,
         .offset = std::clamp(params.Get("offset_z", 0.0f), -1.0f, 1.0f),
-        .inverted = params.Get("invert_z", "+") != "+",
+        .inverted = invert_z,
     };
     input_engine->PreSetController(identifier);
     input_engine->PreSetAxis(identifier, axis_x);
     input_engine->PreSetAxis(identifier, axis_y);
     input_engine->PreSetAxis(identifier, axis_z);
-    return std::make_unique<InputFromAxisMotion>(identifier, axis_x, axis_y, axis_z, properties_x,
-                                                 properties_y, properties_z, input_engine.get());
+    return std::make_unique<InputFromAxisMotion>(identifier, axis_x, axis_y, axis_z, properties_x, properties_y, properties_z, input_engine.get());
 }
 
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateCameraDevice(

src/shader_recompiler/backend/spirv/emit_spirv_special.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -91,6 +94,17 @@ void AlphaTest(EmitContext& ctx) {
 } // Anonymous namespace
 
 void EmitPrologue(EmitContext& ctx) {
+    if (ctx.stage == Stage::Fragment && ctx.runtime_info.dual_source_blend) {
+        // Initialize dual-source blending outputs - prevents MoltenVK crash.
+        const Id zero{ctx.Const(0.0f)};
+        const Id one{ctx.Const(1.0f)};
+        const Id default_color{ctx.ConstantComposite(ctx.F32[4], zero, zero, zero, one)};
+        for (u32 i = 0; i < 2; ++i) {
+            if (Sirit::ValidId(ctx.frag_color[i])) {
+                ctx.OpStore(ctx.frag_color[i], default_color);
+            }
+        }
+    }
     if (ctx.stage == Stage::VertexB) {
         const Id zero{ctx.Const(0.0f)};
         const Id one{ctx.Const(1.0f)};

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -1670,13 +1670,22 @@ void EmitContext::DefineOutputs(const IR::Program& program) {
         break;
     case Stage::Fragment:
         for (u32 index = 0; index < 8; ++index) {
-            if (!info.stores_frag_color[index] && !profile.need_declared_frag_colors) {
+            const bool need_dual_source = runtime_info.dual_source_blend && index <= 1;
+            if (!need_dual_source && !info.stores_frag_color[index] &&
+                !profile.need_declared_frag_colors) {
                 continue;
             }
             const Id type{GetAttributeType(*this, runtime_info.color_output_types[index])};
             frag_color[index] = DefineOutput(*this, type, std::nullopt);
-            Decorate(frag_color[index], spv::Decoration::Location, index);
-            Name(frag_color[index], fmt::format("frag_color{}", index));
+            // Correct mapping for dual-source blending
+            if (runtime_info.dual_source_blend && index <= 1) {
+                Decorate(frag_color[index], spv::Decoration::Location, 0u);
+                Decorate(frag_color[index], spv::Decoration::Index, index);
+                Name(frag_color[index], index == 0 ? "frag_color0" : "frag_color0_secondary");
+            } else {
+                Decorate(frag_color[index], spv::Decoration::Location, index);
+                Name(frag_color[index], fmt::format("frag_color{}", index));
+            }
         }
         if (info.stores_frag_depth) {
             frag_depth = DefineOutput(*this, F32[1], std::nullopt);

src/shader_recompiler/runtime_info.h

@@ -110,6 +110,9 @@ struct RuntimeInfo {
 
     /// Output types for each color attachment
     std::array<AttributeType, 8> color_output_types{};
+
+    /// Dual source blending
+    bool dual_source_blend{};
 };
 
 } // namespace Shader

src/video_core/renderer_vulkan/blit_image.cpp

@@ -1032,7 +1032,7 @@ void BlitImageHelper::ConvertDepthToColorPipeline(vk::Pipeline& pipeline, VkRend
     VkShaderModule frag_shader = *convert_float_to_depth_frag;
     const std::array stages = MakeStages(*full_screen_vert, frag_shader);
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
-    pipeline = device.GetLogical().CreateGraphicsPipeline({
+    pipeline = device.GetLogical().CreateGraphicsPipeline(VkGraphicsPipelineCreateInfo{
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
         .flags = 0,
@@ -1062,7 +1062,7 @@ void BlitImageHelper::ConvertColorToDepthPipeline(vk::Pipeline& pipeline, VkRend
     VkShaderModule frag_shader = *convert_depth_to_float_frag;
     const std::array stages = MakeStages(*full_screen_vert, frag_shader);
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
-    pipeline = device.GetLogical().CreateGraphicsPipeline({
+    pipeline = device.GetLogical().CreateGraphicsPipeline(VkGraphicsPipelineCreateInfo{
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
         .flags = 0,
@@ -1093,7 +1093,7 @@ void BlitImageHelper::ConvertPipelineEx(vk::Pipeline& pipeline, VkRenderPass ren
     }
     const std::array stages = MakeStages(*full_screen_vert, *module);
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
-    pipeline = device.GetLogical().CreateGraphicsPipeline({
+    pipeline = device.GetLogical().CreateGraphicsPipeline(VkGraphicsPipelineCreateInfo{
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
         .flags = 0,
@@ -1135,7 +1135,7 @@ void BlitImageHelper::ConvertPipeline(vk::Pipeline& pipeline, VkRenderPass rende
         is_target_depth ? *convert_float_to_depth_frag : *convert_depth_to_float_frag;
     const std::array stages = MakeStages(*full_screen_vert, frag_shader);
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
-    pipeline = device.GetLogical().CreateGraphicsPipeline({
+    pipeline = device.GetLogical().CreateGraphicsPipeline(VkGraphicsPipelineCreateInfo{
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
         .flags = 0,

src/video_core/renderer_vulkan/pipeline_helper.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -61,7 +64,8 @@ public:
             .pDescriptorUpdateEntries = entries.data(),
             .templateType = type,
             .descriptorSetLayout = descriptor_set_layout,
-            .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
+            .pipelineBindPoint =
+                is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS,
             .pipelineLayout = pipeline_layout,
             .set = 0,
         });
@@ -122,7 +126,7 @@ private:
             });
             ++binding;
             num_descriptors += descriptors[i].count;
-            offset += sizeof(DescriptorUpdateEntry);
+            offset += sizeof(DescriptorUpdateEntry) * descriptors[i].count;
         }
     }
 

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -137,14 +137,8 @@ try
                       memory_allocator,
                       scheduler,
                       swapchain,
-#ifdef ANDROID
-                      surface)
-    ,
-#else
                       *surface)
-    ,
-#endif
-    blit_swapchain(device_memory,
+    , blit_swapchain(device_memory,
                    device,
                    memory_allocator,
                    present_manager,

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -108,6 +108,14 @@ VkBufferView Buffer::View(u32 offset, u32 size, VideoCore::Surface::PixelFormat
         // Null buffer not supported, adjust offset and size
         offset = 0;
         size = 0;
+    } else {
+        // Align offset down to minTexelBufferOffsetAlignment
+        const u32 alignment = static_cast<u32>(device->GetMinTexelBufferOffsetAlignment());
+        if (alignment > 1) {
+            const u32 aligned_offset = offset & ~(alignment - 1);
+            size += offset - aligned_offset;
+            offset = aligned_offset;
+        }
     }
     const auto it{std::ranges::find_if(views, [offset, size, format](const BufferView& view) {
         return offset == view.offset && size == view.size && format == view.format;

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -285,7 +285,7 @@ ComputePass::ComputePass(const Device& device_, DescriptorPool& descriptor_pool,
         .requiredSubgroupSize = optional_subgroup_size ? *optional_subgroup_size : 32U,
     };
     bool use_setup_size = device.IsExtSubgroupSizeControlSupported() && optional_subgroup_size;
-    pipeline = device.GetLogical().CreateComputePipeline({
+    pipeline = device.GetLogical().CreateComputePipeline(VkComputePipelineCreateInfo{
         .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
         .pNext = nullptr,
         .flags = 0,
@@ -299,7 +299,7 @@ ComputePass::ComputePass(const Device& device_, DescriptorPool& descriptor_pool,
             .pSpecializationInfo = nullptr,
         },
         .layout = *layout,
-        .basePipelineHandle = nullptr,
+        .basePipelineHandle = {},
         .basePipelineIndex = 0,
     });
 }
@@ -944,7 +944,7 @@ MSAACopyPass::MSAACopyPass(const Device& device_, Scheduler& scheduler_,
             .codeSize = static_cast<u32>(code.size_bytes()),
             .pCode = code.data(),
         });
-        pipelines[i] = device.GetLogical().CreateComputePipeline({
+        pipelines[i] = device.GetLogical().CreateComputePipeline(VkComputePipelineCreateInfo{
             .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
             .pNext = nullptr,
             .flags = 0,
@@ -958,7 +958,7 @@ MSAACopyPass::MSAACopyPass(const Device& device_, Scheduler& scheduler_,
                 .pSpecializationInfo = nullptr,
             },
             .layout = *layout,
-            .basePipelineHandle = nullptr,
+            .basePipelineHandle = {},
             .basePipelineIndex = 0,
         });
     };

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -50,11 +50,14 @@ ComputePipeline::ComputePipeline(const Device& device_, vk::PipelineCache& pipel
         DescriptorLayoutBuilder builder{device};
         builder.Add(info, VK_SHADER_STAGE_COMPUTE_BIT);
 
-        descriptor_set_layout = builder.CreateDescriptorSetLayout(false);
+        uses_push_descriptor = builder.CanUsePushDescriptor();
+        descriptor_set_layout = builder.CreateDescriptorSetLayout(uses_push_descriptor);
         pipeline_layout = builder.CreatePipelineLayout(*descriptor_set_layout);
         descriptor_update_template =
-            builder.CreateTemplate(*descriptor_set_layout, *pipeline_layout, false);
-        descriptor_allocator = descriptor_pool.Allocator(*descriptor_set_layout, info);
+            builder.CreateTemplate(*descriptor_set_layout, *pipeline_layout, uses_push_descriptor);
+        if (!uses_push_descriptor) {
+            descriptor_allocator = descriptor_pool.Allocator(*descriptor_set_layout, info);
+        }
         const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT subgroup_size_ci{
             .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT,
             .pNext = nullptr,
@@ -64,26 +67,24 @@ ComputePipeline::ComputePipeline(const Device& device_, vk::PipelineCache& pipel
         if (device.IsKhrPipelineExecutablePropertiesEnabled() && Settings::values.renderer_debug.GetValue()) {
             flags |= VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR;
         }
-        pipeline = device.GetLogical().CreateComputePipeline(
-            {
-                .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
-                .pNext = nullptr,
-                .flags = flags,
-                .stage{
-                    .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
-                    .pNext =
-                        device.IsExtSubgroupSizeControlSupported() ? &subgroup_size_ci : nullptr,
-                    .flags = 0,
-                    .stage = VK_SHADER_STAGE_COMPUTE_BIT,
-                    .module = *spv_module,
-                    .pName = "main",
-                    .pSpecializationInfo = nullptr,
-                },
-                .layout = *pipeline_layout,
-                .basePipelineHandle = 0,
-                .basePipelineIndex = 0,
+        pipeline = device.GetLogical().CreateComputePipeline(VkComputePipelineCreateInfo{
+            .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = flags,
+            .stage{
+                .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+                .pNext =
+                    device.IsExtSubgroupSizeControlSupported() ? &subgroup_size_ci : nullptr,
+                .flags = 0,
+                .stage = VK_SHADER_STAGE_COMPUTE_BIT,
+                .module = *spv_module,
+                .pName = "main",
+                .pSpecializationInfo = nullptr,
             },
-            *pipeline_cache);
+            .layout = *pipeline_layout,
+            .basePipelineHandle = 0,
+            .basePipelineIndex = 0,
+        }, *pipeline_cache);
 
         // Log compute pipeline creation
         if (Settings::values.gpu_logging_enabled.GetValue()) {
@@ -241,11 +242,16 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
                                  RESCALING_LAYOUT_WORDS_OFFSET, sizeof(rescaling_data),
                                  rescaling_data.data());
         }
-        const VkDescriptorSet descriptor_set{descriptor_allocator.Commit()};
-        const vk::Device& dev{device.GetLogical()};
-        dev.UpdateDescriptorSet(descriptor_set, *descriptor_update_template, descriptor_data);
-        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline_layout, 0,
-                                  descriptor_set, nullptr);
+        if (uses_push_descriptor) {
+            cmdbuf.PushDescriptorSetWithTemplateKHR(*descriptor_update_template, *pipeline_layout,
+                                                    0, descriptor_data);
+        } else {
+            const VkDescriptorSet descriptor_set{descriptor_allocator.Commit()};
+            const vk::Device& dev{device.GetLogical()};
+            dev.UpdateDescriptorSet(descriptor_set, *descriptor_update_template, descriptor_data);
+            cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline_layout, 0,
+                                      descriptor_set, nullptr);
+        }
     });
 }
 

src/video_core/renderer_vulkan/vk_compute_pipeline.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -55,6 +58,7 @@ private:
 
     vk::ShaderModule spv_module;
     vk::DescriptorSetLayout descriptor_set_layout;
+    bool uses_push_descriptor{false};
     DescriptorAllocator descriptor_allocator;
     vk::PipelineLayout pipeline_layout;
     vk::DescriptorUpdateTemplate descriptor_update_template;

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -474,7 +474,7 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
         buffer_cache.BindHostStageBuffers(stage);
         PushImageDescriptors(texture_cache, guest_descriptor_queue, stage_infos[stage], rescaling,
                              samplers_it, views_it);
-        const auto& info{stage_infos[0]};
+        const auto& info{stage_infos[stage]};
         if (info.uses_render_area) {
             render_area.uses_render_area = true;
             render_area.words = {static_cast<float>(regs.surface_clip.width),
@@ -946,29 +946,27 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         flags |= VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR;
     }
 
-    pipeline = device.GetLogical().CreateGraphicsPipeline(
-        {
-            .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = flags,
-            .stageCount = static_cast<u32>(shader_stages.size()),
-            .pStages = shader_stages.data(),
-            .pVertexInputState = &vertex_input_ci,
-            .pInputAssemblyState = &input_assembly_ci,
-            .pTessellationState = &tessellation_ci,
-            .pViewportState = &viewport_ci,
-            .pRasterizationState = &rasterization_ci,
-            .pMultisampleState = &multisample_ci,
-            .pDepthStencilState = &depth_stencil_ci,
-            .pColorBlendState = &color_blend_ci,
-            .pDynamicState = &dynamic_state_ci,
-            .layout = *pipeline_layout,
-            .renderPass = render_pass,
-            .subpass = 0,
-            .basePipelineHandle = nullptr,
-            .basePipelineIndex = 0,
-        },
-        *pipeline_cache);
+    pipeline = device.GetLogical().CreateGraphicsPipeline({
+        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = flags,
+        .stageCount = static_cast<u32>(shader_stages.size()),
+        .pStages = shader_stages.data(),
+        .pVertexInputState = &vertex_input_ci,
+        .pInputAssemblyState = &input_assembly_ci,
+        .pTessellationState = &tessellation_ci,
+        .pViewportState = &viewport_ci,
+        .pRasterizationState = &rasterization_ci,
+        .pMultisampleState = &multisample_ci,
+        .pDepthStencilState = &depth_stencil_ci,
+        .pColorBlendState = &color_blend_ci,
+        .pDynamicState = &dynamic_state_ci,
+        .layout = *pipeline_layout,
+        .renderPass = render_pass,
+        .subpass = 0,
+        .basePipelineHandle = nullptr,
+        .basePipelineIndex = 0,
+    }, *pipeline_cache);
 
     // Log graphics pipeline creation
     if (Settings::values.gpu_logging_enabled.GetValue()) {

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -237,11 +237,38 @@ Shader::RuntimeInfo MakeRuntimeInfo(std::span<const Shader::IR::Program> program
         }
         info.convert_depth_mode = gl_ndc;
         break;
-    case Shader::Stage::Fragment:
+    case Shader::Stage::Fragment: {
         info.alpha_test_func = MaxwellToCompareFunction(
             key.state.UnpackComparisonOp(key.state.alpha_test_func.Value()));
         info.alpha_test_reference = std::bit_cast<float>(key.state.alpha_test_ref);
 
+        // Check for dual source blending
+        const auto& blend0 = key.state.attachments[0];
+        if (blend0.enable != 0) {
+            using F = Maxwell::Blend::Factor;
+            const auto src_rgb = blend0.SourceRGBFactor();
+            const auto dst_rgb = blend0.DestRGBFactor();
+            const auto src_a = blend0.SourceAlphaFactor();
+            const auto dst_a = blend0.DestAlphaFactor();
+            info.dual_source_blend =
+                src_rgb == F::Source1Color_D3D || src_rgb == F::OneMinusSource1Color_D3D ||
+                src_rgb == F::Source1Alpha_D3D || src_rgb == F::OneMinusSource1Alpha_D3D ||
+                src_rgb == F::Source1Color_GL || src_rgb == F::OneMinusSource1Color_GL ||
+                src_rgb == F::Source1Alpha_GL || src_rgb == F::OneMinusSource1Alpha_GL ||
+                dst_rgb == F::Source1Color_D3D || dst_rgb == F::OneMinusSource1Color_D3D ||
+                dst_rgb == F::Source1Alpha_D3D || dst_rgb == F::OneMinusSource1Alpha_D3D ||
+                dst_rgb == F::Source1Color_GL || dst_rgb == F::OneMinusSource1Color_GL ||
+                dst_rgb == F::Source1Alpha_GL || dst_rgb == F::OneMinusSource1Alpha_GL ||
+                src_a == F::Source1Color_D3D || src_a == F::OneMinusSource1Color_D3D ||
+                src_a == F::Source1Alpha_D3D || src_a == F::OneMinusSource1Alpha_D3D ||
+                src_a == F::Source1Color_GL || src_a == F::OneMinusSource1Color_GL ||
+                src_a == F::Source1Alpha_GL || src_a == F::OneMinusSource1Alpha_GL ||
+                dst_a == F::Source1Color_D3D || dst_a == F::OneMinusSource1Color_D3D ||
+                dst_a == F::Source1Alpha_D3D || dst_a == F::OneMinusSource1Alpha_D3D ||
+                dst_a == F::Source1Color_GL || dst_a == F::OneMinusSource1Color_GL ||
+                dst_a == F::Source1Alpha_GL || dst_a == F::OneMinusSource1Alpha_GL;
+        }
+
         if (device.IsMoltenVK()) {
             for (size_t i = 0; i < 8; ++i) {
                 const auto format = static_cast<Tegra::RenderTargetFormat>(key.state.color_formats[i]);
@@ -258,6 +285,7 @@ Shader::RuntimeInfo MakeRuntimeInfo(std::span<const Shader::IR::Program> program
             }
         }
         break;
+    }
     default:
         break;
     }

src/video_core/renderer_vulkan/vk_present_manager.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -101,22 +101,14 @@ PresentManager::PresentManager(const vk::Instance& instance_,
                                MemoryAllocator& memory_allocator_,
                                Scheduler& scheduler_,
                                Swapchain& swapchain_,
-#ifdef ANDROID
-                               vk::SurfaceKHR& surface_)
-#else
-                               VkSurfaceKHR_T* surface_handle_)
-#endif
+                               VkSurfaceKHR_T* surface_)
     : instance{instance_}
     , render_window{render_window_}
     , device{device_}
     , memory_allocator{memory_allocator_}
     , scheduler{scheduler_}
     , swapchain{swapchain_}
-#ifdef ANDROID
     , surface{surface_}
-#else
-    , surface_handle{surface_handle_}
-#endif
     , blit_supported{CanBlitToSwapchain(device.GetPhysical(), swapchain.GetImageViewFormat())}
     , use_present_thread{Settings::values.async_presentation.GetValue()}
 {
@@ -299,11 +291,7 @@ void PresentManager::PresentThread(std::stop_token token) {
 }
 
 void PresentManager::RecreateSwapchain(Frame* frame) {
-#ifndef ANDROID
-    swapchain.Create(surface_handle, frame->width, frame->height); // Pass raw pointer
-#else
-    swapchain.Create(*surface, frame->width, frame->height); // Pass raw pointer
-#endif
+    swapchain.Create(surface, frame->width, frame->height); // Pass raw pointer
     SetImageCount();
 }
 
@@ -322,7 +310,7 @@ void PresentManager::CopyToSwapchain(Frame* frame) {
             // Recreate surface and swapchain if needed.
             if (requires_recreation) {
 #ifdef ANDROID
-                surface = CreateSurface(instance, render_window.GetWindowInfo());
+                surface = *CreateSurface(instance, render_window.GetWindowInfo()).address();
 #endif
                 RecreateSwapchain(frame);
             }

src/video_core/renderer_vulkan/vk_present_manager.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -15,8 +15,6 @@
 #include "video_core/vulkan_common/vulkan_memory_allocator.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
-struct VkSurfaceKHR_T;
-
 namespace Core::Frontend {
 class EmuWindow;
 } // namespace Core::Frontend
@@ -46,11 +44,7 @@ public:
                    MemoryAllocator& memory_allocator,
                    Scheduler& scheduler,
                    Swapchain& swapchain,
-#ifdef ANDROID
-                   vk::SurfaceKHR& surface);
-#else
-                   VkSurfaceKHR_T* surface_handle);
-#endif
+                   VkSurfaceKHR_T* surface);
     ~PresentManager();
 
     /// Returns the last used presentation frame
@@ -84,11 +78,7 @@ private:
     MemoryAllocator& memory_allocator;
     Scheduler& scheduler;
     Swapchain& swapchain;
-#ifdef ANDROID
-    vk::SurfaceKHR& surface;
-#else
-    VkSurfaceKHR_T* surface_handle;
-#endif
+    VkSurfaceKHR_T* surface;
     vk::CommandPool cmdpool;
     std::vector<Frame> frames;
     boost::container::deque<Frame*> present_queue;

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -1280,7 +1280,7 @@ void QueryCacheRuntime::EndHostConditionalRendering() {
     PauseHostConditionalRendering();
     impl->hcr_is_set = false;
     impl->is_hcr_running = false;
-    impl->hcr_buffer = nullptr;
+    impl->hcr_buffer = VkBuffer{};
     impl->hcr_offset = 0;
 }
 

src/video_core/renderer_vulkan/vk_query_cache.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -35,7 +38,7 @@ public:
     ~QueryCacheRuntime();
 
     template <typename SyncValuesType>
-    void SyncValues(std::span<SyncValuesType> values, VkBuffer base_src_buffer = nullptr);
+    void SyncValues(std::span<SyncValuesType> values, VkBuffer base_src_buffer = VkBuffer{});
 
     void Barriers(bool is_prebarrier);
 

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -377,7 +377,7 @@ void Scheduler::EndRenderPass()
                                    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, nullptr, nullptr, vk::Span(barriers.data(), num_images));
         });
 
-        state.renderpass = nullptr;
+        state.renderpass = VkRenderPass{};
         num_renderpass_images = 0;
     }
 

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -44,10 +44,10 @@ public:
     ~Scheduler();
 
     /// Sends the current execution context to the GPU.
-    u64 Flush(VkSemaphore signal_semaphore = nullptr, VkSemaphore wait_semaphore = nullptr);
+    u64 Flush(VkSemaphore signal_semaphore = {}, VkSemaphore wait_semaphore = {});
 
     /// Sends the current execution context to the GPU and waits for it to complete.
-    void Finish(VkSemaphore signal_semaphore = nullptr, VkSemaphore wait_semaphore = nullptr);
+    void Finish(VkSemaphore signal_semaphore = {}, VkSemaphore wait_semaphore = {});
 
     /// Waits for the worker thread to finish executing everything. After this function returns it's
     /// safe to touch worker resources.
@@ -237,8 +237,8 @@ private:
     };
 
     struct State {
-        VkRenderPass renderpass = nullptr;
-        VkFramebuffer framebuffer = nullptr;
+        VkRenderPass renderpass{};
+        VkFramebuffer framebuffer{};
         VkExtent2D render_area = {0, 0};
         GraphicsPipeline* graphics_pipeline = nullptr;
         bool is_rescaling = false;

src/video_core/renderer_vulkan/vk_swapchain.cpp

@@ -109,38 +109,22 @@ VkCompositeAlphaFlagBitsKHR ChooseAlphaFlags(const VkSurfaceCapabilitiesKHR& cap
 } // Anonymous namespace
 
 Swapchain::Swapchain(
-#ifdef ANDROID
-    VkSurfaceKHR surface_,
-#else
-    VkSurfaceKHR_T* surface_handle_,
-#endif
+    VkSurfaceKHR_T* surface_,
     const Device& device_,
     Scheduler& scheduler_,
     u32 width_,
     u32 height_)
-#ifdef ANDROID
     : surface(surface_)
-#else
-    : surface_handle{surface_handle_}
-#endif
     , device{device_}
     , scheduler{scheduler_}
 {
-#ifdef ANDROID
     Create(surface, width_, height_);
-#else
-    Create(surface_handle, width_, height_);
-#endif
 }
 
 Swapchain::~Swapchain() = default;
 
 void Swapchain::Create(
-#ifdef ANDROID
-    VkSurfaceKHR surface_,
-#else
-    VkSurfaceKHR_T* surface_handle_,
-#endif
+    VkSurfaceKHR_T* surface_,
     u32 width_,
     u32 height_)
 {
@@ -148,18 +132,10 @@ void Swapchain::Create(
     is_suboptimal = false;
     width = width_;
     height = height_;
-#ifdef ANDROID
     surface = surface_;
-#else
-    surface_handle = surface_handle_;
-#endif
 
     const auto physical_device = device.GetPhysical();
-#ifdef ANDROID
-    const auto capabilities{physical_device.GetSurfaceCapabilitiesKHR(surface)};
-#else
-    const auto capabilities{physical_device.GetSurfaceCapabilitiesKHR(surface_handle)};
-#endif
+    const auto capabilities{physical_device.GetSurfaceCapabilitiesKHR(VkSurfaceKHR(surface))};
     if (capabilities.maxImageExtent.width == 0 || capabilities.maxImageExtent.height == 0) {
         return;
     }
@@ -254,14 +230,8 @@ void Swapchain::Present(VkSemaphore render_semaphore) {
 
 void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities) {
     const auto physical_device{device.GetPhysical()};
-
-#ifdef ANDROID
-    const auto formats{physical_device.GetSurfaceFormatsKHR(surface)};
-    const auto present_modes = physical_device.GetSurfacePresentModesKHR(surface);
-#else
-    const auto formats{physical_device.GetSurfaceFormatsKHR(surface_handle)};
-    const auto present_modes = physical_device.GetSurfacePresentModesKHR(surface_handle);
-#endif
+    const auto formats{physical_device.GetSurfaceFormatsKHR(VkSurfaceKHR(surface))};
+    const auto present_modes = physical_device.GetSurfacePresentModesKHR(VkSurfaceKHR(surface));
 
     has_mailbox = std::find(present_modes.begin(), present_modes.end(), VK_PRESENT_MODE_MAILBOX_KHR)
                   != present_modes.end();
@@ -290,11 +260,7 @@ void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities) {
         .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
         .pNext = nullptr,
         .flags = 0,
-#ifdef ANDROID
-        .surface = surface,
-#else
-        .surface = surface_handle,
-#endif
+        .surface = VkSurfaceKHR(surface),
         .minImageCount = requested_image_count,
         .imageFormat = surface_format.format,
         .imageColorSpace = surface_format.colorSpace,
@@ -313,7 +279,7 @@ void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities) {
         .compositeAlpha = alpha_flags,
         .presentMode = present_mode,
         .clipped = VK_FALSE,
-        .oldSwapchain = nullptr,
+        .oldSwapchain = VkSwapchainKHR{},
     };
     const u32 graphics_family{device.GetGraphicsFamily()};
     const u32 present_family{device.GetPresentFamily()};
@@ -345,11 +311,7 @@ void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities) {
         swapchain_ci.flags |= VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR;
     }
     // Request the size again to reduce the possibility of a TOCTOU race condition.
-#ifdef ANDROID
-    const auto updated_capabilities = physical_device.GetSurfaceCapabilitiesKHR(surface);
-#else
-    const auto updated_capabilities = physical_device.GetSurfaceCapabilitiesKHR(surface_handle);
-#endif
+    const auto updated_capabilities = physical_device.GetSurfaceCapabilitiesKHR(VkSurfaceKHR(surface));
     swapchain_ci.imageExtent = ChooseSwapExtent(updated_capabilities, width, height);
     // Don't add code within this and the swapchain creation.
     swapchain = device.GetLogical().CreateSwapchainKHR(swapchain_ci);

src/video_core/renderer_vulkan/vk_swapchain.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -11,8 +11,6 @@
 #include "common/common_types.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
-struct VkSurfaceKHR_T;
-
 namespace Layout {
 struct FramebufferLayout;
 }
@@ -25,11 +23,7 @@ class Scheduler;
 class Swapchain {
 public:
     explicit Swapchain(
-#ifdef ANDROID
-        VkSurfaceKHR surface,
-#else
-        VkSurfaceKHR_T* surface_handle,
-#endif
+        VkSurfaceKHR_T* surface,
         const Device& device,
         Scheduler& scheduler,
         u32 width,
@@ -38,11 +32,7 @@ public:
 
     /// Creates (or recreates) the swapchain with a given size.
     void Create(
-#ifdef ANDROID
-        VkSurfaceKHR surface,
-#else
-        VkSurfaceKHR_T* surface_handle,
-#endif
+        VkSurfaceKHR_T* surface,
         u32 width,
         u32 height);
 
@@ -128,11 +118,7 @@ private:
 
     bool NeedsPresentModeUpdate() const;
 
-#ifdef ANDROID
-    VkSurfaceKHR surface;
-#else
-    VkSurfaceKHR_T* surface_handle;
-#endif
+    VkSurfaceKHR_T* surface;
 
     const Device& device;
     Scheduler& scheduler;

src/video_core/vulkan_common/vulkan.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -40,3 +40,6 @@
 #undef False
 #undef None
 #undef True
+
+// "Catch-all" handle for both Android and.. the rest of platforms
+struct VkSurfaceKHR_T;

src/video_core/vulkan_common/vulkan_device.cpp

@@ -419,7 +419,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     : instance{instance_}, dld{dld_}, physical{physical_},
     format_properties(GetFormatProperties(physical)) {
     // Get suitability and device properties.
-    const bool is_suitable = GetSuitability(surface != nullptr);
+    const bool is_suitable = GetSuitability(surface != VkSurfaceKHR{});
 
     const VkDriverId driver_id = properties.driver.driverID;
 
@@ -586,12 +586,20 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     if (is_amd_driver) {
         // AMD drivers need a higher amount of Sets per Pool in certain circumstances like in XC2.
         sets_per_pool = 96;
+
         // Disable VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT on AMD GCN4 and lower as it is broken.
         if (!features.shader_float16_int8.shaderFloat16) {
             LOG_WARNING(Render_Vulkan,
                         "AMD GCN4 and earlier have broken VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT");
             has_broken_cube_compatibility = true;
         }
+
+        // AMD drivers (2026+) have broken float16 math on DKCR
+        if (features.shader_float16_int8.shaderFloat16) {
+            LOG_WARNING(Render_Vulkan,
+                        "AMD drivers (2026+) have broken float16 math");
+            features.shader_float16_int8.shaderFloat16 = false;
+        }
     }
 
     if (is_qualcomm) {

src/video_core/vulkan_common/vulkan_device.h

@@ -318,6 +318,11 @@ public:
         return properties.properties.limits.minStorageBufferOffsetAlignment;
     }
 
+    /// Returns texel buffer offset alignment requirement.
+    VkDeviceSize GetMinTexelBufferOffsetAlignment() const {
+        return properties.properties.limits.minTexelBufferOffsetAlignment;
+    }
+
     /// Returns the maximum range for storage buffers.
     VkDeviceSize GetMaxStorageBufferRange() const {
         return properties.properties.limits.maxStorageBufferRange;

src/video_core/vulkan_common/vulkan_surface.cpp

@@ -15,7 +15,7 @@ vk::SurfaceKHR CreateSurface(
     const vk::Instance& instance,
     [[maybe_unused]] const Core::Frontend::EmuWindow::WindowSystemInfo& window_info) {
     [[maybe_unused]] const vk::InstanceDispatch& dld = instance.Dispatch();
-    VkSurfaceKHR unsafe_surface = nullptr;
+    VkSurfaceKHR unsafe_surface = VkSurfaceKHR{};
 
 #ifdef _WIN32
     if (window_info.type == Core::Frontend::WindowSystemType::Windows) {

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -404,13 +404,13 @@ public:
 
     /// Construct a handle transferring the ownership from another handle.
     Handle(Handle&& rhs) noexcept
-        : handle{std::exchange(rhs.handle, nullptr)}, owner{rhs.owner}, dld{rhs.dld} {}
+        : handle{std::exchange(rhs.handle, Type{})}, owner{rhs.owner}, dld{rhs.dld} {}
 
     /// Assign the current handle transferring the ownership from another handle.
     /// Destroys any previously held object.
     Handle& operator=(Handle&& rhs) noexcept {
         Release();
-        handle = std::exchange(rhs.handle, nullptr);
+        handle = std::exchange(rhs.handle, Type{});
         owner = rhs.owner;
         dld = rhs.dld;
         return *this;
@@ -424,7 +424,7 @@ public:
     /// Destroys any held object.
     void reset() noexcept {
         Release();
-        handle = nullptr;
+        handle = Type{};
     }
 
     /// Returns the address of the held object.
@@ -440,7 +440,7 @@ public:
 
     /// Returns true when there's a held object.
     explicit operator bool() const noexcept {
-        return handle != nullptr;
+        return handle != Type{};
     }
 
 #ifndef ANDROID
@@ -455,7 +455,7 @@ public:
 #endif
 
 protected:
-    Type handle = nullptr;
+    Type handle{};
     OwnerType owner = nullptr;
     const Dispatch* dld = nullptr;
 
@@ -463,7 +463,7 @@ private:
     /// Destroys the held object if it exists.
     void Release() noexcept {
         if (handle) {
-            Destroy(owner, handle, *dld);
+            Destroy(OwnerType(owner), Type(handle), *dld);
         }
     }
 };
@@ -506,7 +506,7 @@ public:
     /// Destroys any held object.
     void reset() noexcept {
         Release();
-        handle = nullptr;
+        handle = {};
     }
 
     /// Returns the address of the held object.
@@ -522,7 +522,7 @@ public:
 
     /// Returns true when there's a held object.
     explicit operator bool() const noexcept {
-        return handle != nullptr;
+        return handle != Type{};
     }
 
 #ifndef ANDROID
@@ -537,7 +537,7 @@ public:
 #endif
 
 protected:
-    Type handle = nullptr;
+    Type handle{};
     const Dispatch* dld = nullptr;
 
 private:
@@ -607,7 +607,7 @@ private:
     std::unique_ptr<AllocationType[]> allocations;
     std::size_t num = 0;
     VkDevice device = nullptr;
-    PoolType pool = nullptr;
+    PoolType pool{};
     const DeviceDispatch* dld = nullptr;
 };
 
@@ -669,12 +669,12 @@ public:
     Image& operator=(const Image&) = delete;
 
     Image(Image&& rhs) noexcept
-        : handle{std::exchange(rhs.handle, nullptr)}, usage{rhs.usage}, owner{rhs.owner},
+        : handle{std::exchange(rhs.handle, VkImage{})}, usage{rhs.usage}, owner{rhs.owner},
           allocator{rhs.allocator}, allocation{rhs.allocation}, dld{rhs.dld} {}
 
     Image& operator=(Image&& rhs) noexcept {
         Release();
-        handle = std::exchange(rhs.handle, nullptr);
+        handle = std::exchange(rhs.handle, VkImage{});
         usage = rhs.usage;
         owner = rhs.owner;
         allocator = rhs.allocator;
@@ -693,11 +693,11 @@ public:
 
     void reset() noexcept {
         Release();
-        handle = nullptr;
+        handle = VkImage{};
     }
 
     explicit operator bool() const noexcept {
-        return handle != nullptr;
+        return handle != VkImage{};
     }
 
     void SetObjectNameEXT(const char* name) const;
@@ -709,7 +709,7 @@ public:
 private:
     void Release() const noexcept;
 
-    VkImage handle = nullptr;
+    VkImage handle{};
     VkImageUsageFlags usage{};
     VkDevice owner = nullptr;
     VmaAllocator allocator = nullptr;
@@ -730,13 +730,13 @@ public:
     Buffer& operator=(const Buffer&) = delete;
 
     Buffer(Buffer&& rhs) noexcept
-        : handle{std::exchange(rhs.handle, nullptr)}, owner{rhs.owner}, allocator{rhs.allocator},
+        : handle{std::exchange(rhs.handle, VkBuffer{})}, owner{rhs.owner}, allocator{rhs.allocator},
           allocation{rhs.allocation}, mapped{rhs.mapped},
           is_coherent{rhs.is_coherent}, dld{rhs.dld} {}
 
     Buffer& operator=(Buffer&& rhs) noexcept {
         Release();
-        handle = std::exchange(rhs.handle, nullptr);
+        handle = std::exchange(rhs.handle, VkBuffer{});
         owner = rhs.owner;
         allocator = rhs.allocator;
         allocation = rhs.allocation;
@@ -756,11 +756,11 @@ public:
 
     void reset() noexcept {
         Release();
-        handle = nullptr;
+        handle = VkBuffer{};
     }
 
     explicit operator bool() const noexcept {
-        return handle != nullptr;
+        return handle != VkBuffer{};
     }
 
     /// Returns the host mapped memory, an empty span otherwise.
@@ -786,7 +786,7 @@ public:
 private:
     void Release() const noexcept;
 
-    VkBuffer handle = nullptr;
+    VkBuffer handle{};
     VkDevice owner = nullptr;
     VmaAllocator allocator = nullptr;
     VmaAllocation allocation = nullptr;
@@ -1020,10 +1020,10 @@ public:
     [[nodiscard]] PipelineLayout CreatePipelineLayout(const VkPipelineLayoutCreateInfo& ci) const;
 
     [[nodiscard]] Pipeline CreateGraphicsPipeline(const VkGraphicsPipelineCreateInfo& ci,
-                                                  VkPipelineCache cache = nullptr) const;
+                                                  VkPipelineCache cache = {}) const;
 
     [[nodiscard]] Pipeline CreateComputePipeline(const VkComputePipelineCreateInfo& ci,
-                                                 VkPipelineCache cache = nullptr) const;
+                                                 VkPipelineCache cache = {}) const;
 
     [[nodiscard]] Sampler CreateSampler(const VkSamplerCreateInfo& ci) const;
 

src/yuzu/configuration/configure_input_player.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: 2016 Citra Emulator Project
@@ -465,30 +465,40 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
 
         button->setContextMenuPolicy(Qt::CustomContextMenu);
 
-        connect(button, &QPushButton::customContextMenuRequested,
-                [=, this](const QPoint& menu_location) {
-                    QMenu context_menu;
-                    Common::ParamPackage param = emulated_controller->GetMotionParam(motion_id);
-                    context_menu.addAction(tr("Clear"), [&] {
-                        emulated_controller->SetMotionParam(motion_id, {});
-                        motion_map[motion_id]->setText(tr("[not set]"));
-                    });
-                    if (param.Has("motion")) {
-                        context_menu.addAction(tr("Set gyro threshold"), [&] {
-                            const int gyro_threshold =
-                                static_cast<int>(param.Get("threshold", 0.007f) * 1000.0f);
-                            const int new_threshold = QInputDialog::getInt(
-                                this, tr("Set threshold"), tr("Choose a value between 0% and 100%"),
-                                gyro_threshold, 0, 100);
-                            param.Set("threshold", new_threshold / 1000.0f);
-                            emulated_controller->SetMotionParam(motion_id, param);
-                        });
-                        context_menu.addAction(tr("Calibrate sensor"), [&] {
-                            emulated_controller->StartMotionCalibration();
-                        });
-                    }
-                    context_menu.exec(motion_map[motion_id]->mapToGlobal(menu_location));
+        connect(button, &QPushButton::customContextMenuRequested, [=, this](const QPoint& menu_location) {
+            QMenu context_menu;
+            Common::ParamPackage param = emulated_controller->GetMotionParam(motion_id);
+            context_menu.addAction(tr("Clear"), [&] {
+                emulated_controller->SetMotionParam(motion_id, {});
+                motion_map[motion_id]->setText(tr("[not set]"));
+            });
+            if (param.Has("motion")) {
+                context_menu.addAction(tr("Set gyro threshold"), [&] {
+                    const int gyro_threshold = int(param.Get("threshold", 0.007f) * 1000.0f);
+                    const int new_threshold = QInputDialog::getInt(
+                        this, tr("Set threshold"), tr("Choose a value between 0% and 100%"),
+                        gyro_threshold, 0, 100);
+                    param.Set("threshold", new_threshold / 1000.0f);
+                    emulated_controller->SetMotionParam(motion_id, param);
                 });
+                context_menu.addAction(tr("Invert X"), [&] {
+                    param.Set("invert_x", param.Get("invert_x", "+") == "-" ? "+" : "-");
+                    emulated_controller->SetMotionParam(motion_id, param);
+                });
+                context_menu.addAction(tr("Invert Y"), [&] {
+                    param.Set("invert_y", param.Get("invert_y", "+") == "-" ? "+" : "-");
+                    emulated_controller->SetMotionParam(motion_id, param);
+                });
+                context_menu.addAction(tr("Invert Z"), [&] {
+                    param.Set("invert_z", param.Get("invert_z", "+") == "-" ? "+" : "-");
+                    emulated_controller->SetMotionParam(motion_id, param);
+                });
+                context_menu.addAction(tr("Calibrate sensor"), [&] {
+                    emulated_controller->StartMotionCalibration();
+                });
+            }
+            context_menu.exec(motion_map[motion_id]->mapToGlobal(menu_location));
+        });
     }
 
     connect(ui->sliderZLThreshold, &QSlider::valueChanged, [=, this] {

src/yuzu/game/game_list_worker.cpp

@@ -4,6 +4,7 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <filesystem>
 #include <memory>
 #include <string>
 #include <utility>
@@ -16,14 +17,17 @@
 
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
+#include "common/settings.h"
 #include "core/core.h"
 #include "core/file_sys/card_image.h"
+#include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/fs_filesystem.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
+#include "core/file_sys/romfs.h"
 #include "core/file_sys/submission_package.h"
 #include "core/loader/loader.h"
 #include "yuzu/compatibility_list.h"
@@ -375,6 +379,12 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
                 return true;
             }
 
+            if (target == ScanTarget::PopulateGameList &&
+                (file_type == Loader::FileType::XCI || file_type == Loader::FileType::NSP) &&
+                !Loader::IsBootableGameContainer(file, file_type)) {
+                return true;
+            }
+
             u64 program_id = 0;
             const auto res2 = loader->ReadProgramId(program_id);
 
@@ -383,18 +393,10 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
                     provider->AddEntry(FileSys::TitleType::Application,
                                        FileSys::GetCRTypeFromNCAType(FileSys::NCA{file}.GetType()),
                                        program_id, file);
-                } else if (res2 == Loader::ResultStatus::Success &&
+                } else if (Settings::values.ext_content_from_game_dirs.GetValue() &&
                            (file_type == Loader::FileType::XCI ||
                             file_type == Loader::FileType::NSP)) {
-                    const auto nsp = file_type == Loader::FileType::NSP
-                                         ? std::make_shared<FileSys::NSP>(file)
-                                         : FileSys::XCI{file}.GetSecurePartitionNSP();
-                    for (const auto& title : nsp->GetNCAs()) {
-                        for (const auto& entry : title.second) {
-                            provider->AddEntry(entry.first.first, entry.first.second, title.first,
-                                               entry.second->GetBaseFile());
-                        }
-                    }
+                    void(provider->AddEntriesFromContainer(file));
                 }
             } else {
                 std::vector<u64> program_ids;

src/yuzu/main_window.cpp

@@ -2019,6 +2019,10 @@ void MainWindow::ConfigureFilesystemProvider(const std::string& filepath) {
         return;
     }
 
+    if (QtCommon::provider->AddEntriesFromContainer(file)) {
+        return;
+    }
+
     auto loader = Loader::GetLoader(*QtCommon::system, file);
     if (!loader) {
         return;
@@ -2033,19 +2037,8 @@ void MainWindow::ConfigureFilesystemProvider(const std::string& filepath) {
     const auto res2 = loader->ReadProgramId(program_id);
     if (res2 == Loader::ResultStatus::Success && file_type == Loader::FileType::NCA) {
         QtCommon::provider->AddEntry(FileSys::TitleType::Application,
-                                     FileSys::GetCRTypeFromNCAType(FileSys::NCA{file}.GetType()), program_id,
-                                     file);
-    } else if (res2 == Loader::ResultStatus::Success &&
-               (file_type == Loader::FileType::XCI || file_type == Loader::FileType::NSP)) {
-        const auto nsp = file_type == Loader::FileType::NSP
-                             ? std::make_shared<FileSys::NSP>(file)
-                             : FileSys::XCI{file}.GetSecurePartitionNSP();
-        for (const auto& title : nsp->GetNCAs()) {
-            for (const auto& entry : title.second) {
-                QtCommon::provider->AddEntry(entry.first.first, entry.first.second, title.first,
-                                             entry.second->GetBaseFile());
-            }
-        }
+                                     FileSys::GetCRTypeFromNCAType(FileSys::NCA{file}.GetType()),
+                                     program_id, file);
     }
 }