Merge branch 'feat_autoloader_wip' into 'main'

feat(fs): Implement Autoloader for game updates

See merge request citron/emulator!108

src/citron/configuration/configure_per_game_addons.h

@@ -1,4 +1,5 @@
 // SPDX-FileCopyrightText: 2016 Citra Emulator Project
+// SPDX-FileCopyrightText: 2025 citron Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
@@ -7,6 +8,7 @@
 #include <vector>
 
 #include <QList>
+#include <QWidget>
 
 #include "core/file_sys/vfs/vfs_types.h"
 
@@ -14,7 +16,6 @@ namespace Core {
 class System;
 }
 
-class QGraphicsScene;
 class QStandardItem;
 class QStandardItemModel;
 class QTreeView;

src/citron/main.cpp

@@ -37,6 +37,7 @@
 #include "applets/qt_profile_select.h"
 #include "applets/qt_software_keyboard.h"
 #include "applets/qt_web_browser.h"
+#include "common/hex_util.h"
 #include "common/nvidia_flags.h"
 #include "common/settings_enums.h"
 #include "configuration/configure_input.h"
@@ -45,6 +46,7 @@
 #include "core/file_sys/romfs_factory.h"
 #include "core/file_sys/vfs/vfs.h"
 #include "core/file_sys/vfs/vfs_real.h"
+#include "core/file_sys/nca_metadata.h"
 #include "core/frontend/applets/cabinet.h"
 #include "core/frontend/applets/controller.h"
 #include "core/frontend/applets/general.h"
@@ -433,10 +435,13 @@ GMainWindow::GMainWindow(std::unique_ptr<QtConfig> config_, bool has_broken_vulk
     show();
 
     system->SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
-    system->RegisterContentProvider(FileSys::ContentProviderUnionSlot::FrontendManual,
+    system->RegisterContentProvider(FileSys::ContentProviderUnionSlot::FrontendManual, provider.get());
-                                    provider.get());
     system->GetFileSystemController().CreateFactories(*vfs);
 
+    autoloader_provider = std::make_unique<FileSys::ManualContentProvider>();
+    system->RegisterContentProvider(FileSys::ContentProviderUnionSlot::Autoloader,
+    autoloader_provider.get());
+
     // Remove cached contents generated during the previous session
     RemoveCachedContents();
 
@@ -1582,6 +1587,7 @@ void GMainWindow::ConnectMenuEvents() {
     connect_menu(ui->action_Load_File, &GMainWindow::OnMenuLoadFile);
     connect_menu(ui->action_Load_Folder, &GMainWindow::OnMenuLoadFolder);
     connect_menu(ui->action_Install_File_NAND, &GMainWindow::OnMenuInstallToNAND);
+    connect_menu(ui->action_Install_With_Autoloader, &GMainWindow::OnMenuInstallWithAutoloader);
     connect_menu(ui->action_Trim_XCI_File, &GMainWindow::OnMenuTrimXCI);
     connect_menu(ui->action_Exit, &QMainWindow::close);
     connect_menu(ui->action_Load_Amiibo, &GMainWindow::OnLoadAmiibo);
@@ -1971,6 +1977,8 @@ void GMainWindow::BootGame(const QString& filename, Service::AM::FrontendAppletP
                            StartGameType type) {
     LOG_INFO(Frontend, "citron starting...");
 
+    RegisterAutoloaderContents();
+
     if (params.program_id == 0 ||
         params.program_id > static_cast<u64>(Service::AM::AppletProgramId::MaxProgramId)) {
         StoreRecentFile(filename); // Put the filename on top of the list
@@ -6129,6 +6137,260 @@ void GMainWindow::CheckForUpdatesAutomatically() {
     #endif
 }
 
+void GMainWindow::RegisterAutoloaderContents() {
+    autoloader_provider->ClearAllEntries();
+    const auto& disabled_addons = Settings::values.disabled_addons;
+
+    const auto sdmc_path = Common::FS::GetCitronPath(Common::FS::CitronPath::SDMCDir);
+    const auto autoloader_root = sdmc_path / "autoloader";
+    if (!Common::FS::IsDir(autoloader_root)) {
+        return;
+    }
+
+    LOG_INFO(Frontend, "Scanning for Autoloader contents...");
+
+    for (const auto& title_dir_entry : std::filesystem::directory_iterator(autoloader_root)) {
+        if (!title_dir_entry.is_directory()) continue;
+
+        u64 title_id_val = 0;
+        try {
+            title_id_val = std::stoull(title_dir_entry.path().filename().string(), nullptr, 16);
+        } catch (const std::invalid_argument&) {
+            continue;
+        }
+
+        const auto it = disabled_addons.find(title_id_val);
+        const auto& disabled_for_game = (it != disabled_addons.end()) ? it->second : std::vector<std::string>{};
+
+        const auto process_content_type = [&](const std::filesystem::path& content_path) {
+            if (!Common::FS::IsDir(content_path)) return;
+
+            for (const auto& mod_dir_entry : std::filesystem::directory_iterator(content_path)) {
+                if (!mod_dir_entry.is_directory()) continue;
+
+                const std::string mod_name = mod_dir_entry.path().filename().string();
+                if (std::find(disabled_for_game.begin(), disabled_for_game.end(), mod_name) != disabled_for_game.end()) {
+                    LOG_INFO(Frontend, "Skipping disabled Autoloader content: {}", mod_name);
+                    continue;
+                }
+
+                std::optional<FileSys::CNMT> cnmt;
+                for (const auto& file_entry : std::filesystem::directory_iterator(mod_dir_entry.path())) {
+                    if (file_entry.path().string().ends_with(".cnmt.nca")) {
+                        auto vfs_file = vfs->OpenFile(file_entry.path().string(), FileSys::OpenMode::Read);
+                        if (vfs_file) {
+                            FileSys::NCA meta_nca(vfs_file);
+                            if (meta_nca.GetStatus() == Loader::ResultStatus::Success && !meta_nca.GetSubdirectories().empty()) {
+                                auto section0 = meta_nca.GetSubdirectories()[0];
+                                if (!section0->GetFiles().empty()) {
+                                    cnmt.emplace(section0->GetFiles()[0]);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if (!cnmt) continue;
+
+                for (const auto& record : cnmt->GetContentRecords()) {
+                    std::string nca_filename = Common::HexToString(record.nca_id) + ".nca";
+                    std::filesystem::path nca_path = mod_dir_entry.path() / nca_filename;
+                    auto nca_vfs_file = vfs->OpenFile(nca_path.string(), FileSys::OpenMode::Read);
+                    if (nca_vfs_file) {
+                        autoloader_provider->AddEntry(cnmt->GetType(), record.type, cnmt->GetTitleID(), nca_vfs_file);
+                    }
+                }
+            }
+        };
+
+        process_content_type(title_dir_entry.path() / "Updates");
+        process_content_type(title_dir_entry.path() / "DLC");
+    }
+}
+
+void GMainWindow::OnMenuInstallWithAutoloader() {
+    LOG_INFO(Loader, "AUTOLOADER: Starting Autoloader installation process.");
+
+    const QString file_filter = tr("Nintendo Submission Package (*.nsp)");
+    QStringList filenames = QFileDialog::getOpenFileNames(
+        this, tr("Select Update/DLC Files for Autoloader"),
+        QString::fromStdString(UISettings::values.roms_path), file_filter);
+
+    if (filenames.isEmpty()) {
+        return;
+    }
+
+    UISettings::values.roms_path = QFileInfo(filenames[0]).path().toStdString();
+
+    // Calculate the total size of all files to be installed for the progress dialog.
+    qint64 total_size_bytes = 0;
+    for (const QString& file : filenames) {
+        QString sanitized_path = file;
+        if (sanitized_path.contains(QLatin1String(".nsp/"))) {
+            sanitized_path = sanitized_path.left(sanitized_path.indexOf(QLatin1String(".nsp/")) + 4);
+        }
+        auto vfs_file = vfs->OpenFile(sanitized_path.toStdString(), FileSys::OpenMode::Read);
+        if (vfs_file) {
+            FileSys::NSP nsp(vfs_file);
+            if (nsp.GetStatus() == Loader::ResultStatus::Success) {
+                for (const auto& title_pair : nsp.GetNCAs()) {
+                    for (const auto& nca_pair : title_pair.second) {
+                        total_size_bytes += nca_pair.second->GetBaseFile()->GetSize();
+                    }
+                }
+            }
+        }
+    }
+
+    if (total_size_bytes == 0) {
+        QMessageBox::warning(this, tr("No files to install"), tr("Could not find any valid files to install in the selected NSPs."));
+        return;
+    }
+
+    QProgressDialog progress(tr("Installing to Autoloader..."), tr("Cancel"), 0, 100, this);
+    progress.setWindowModality(Qt::WindowModal);
+    progress.setMinimumDuration(0);
+    progress.setValue(0);
+    progress.show();
+
+    qint64 total_copied_bytes = 0;
+    int success_count = 0;
+    QStringList failed_files;
+
+    for (const QString& file : filenames) {
+        progress.setLabelText(tr("Installing %1...").arg(QFileInfo(file).fileName()));
+        QCoreApplication::processEvents();
+
+        if (progress.wasCanceled()) {
+            break;
+        }
+
+        QString sanitized_path = file;
+        if (sanitized_path.contains(QLatin1String(".nsp/"))) {
+            sanitized_path = sanitized_path.left(sanitized_path.indexOf(QLatin1String(".nsp/")) + 4);
+        }
+        const std::string file_path = sanitized_path.toStdString();
+        LOG_INFO(Loader, "AUTOLOADER: Processing sanitized file path: {}", file_path);
+
+        auto vfs_file = vfs->OpenFile(file_path, FileSys::OpenMode::Read);
+        if (!vfs_file) {
+            LOG_ERROR(Loader, "AUTOLOADER: FAILED at VFS Open. Could not open file: {}", file_path);
+            failed_files.append(QFileInfo(file).fileName() + tr(" (File Open Error)"));
+            continue;
+        }
+
+        FileSys::NSP nsp(vfs_file);
+        if (nsp.GetStatus() != Loader::ResultStatus::Success) {
+            LOG_ERROR(Loader, "AUTOLOADER: FAILED at NSP Parse for file: {}", file_path);
+            failed_files.append(QFileInfo(file).fileName() + tr(" (NSP Parse Error)"));
+            continue;
+        }
+
+        const auto title_map = nsp.GetNCAs();
+        if (title_map.empty()) {
+            LOG_ERROR(Loader, "AUTOLOADER: FAILED, NSP contains no titles: {}", file_path);
+            failed_files.append(QFileInfo(file).fileName() + tr(" (Empty NSP)"));
+            continue;
+        }
+
+        const auto& [title_id, nca_map] = *title_map.begin();
+        const auto& [type_pair, meta_nca] = *std::find_if(nca_map.begin(), nca_map.end(), [](const auto& pair){
+            return pair.first.second == FileSys::ContentRecordType::Meta;
+        });
+
+        if (!meta_nca || meta_nca->GetSubdirectories().empty() || meta_nca->GetSubdirectories()[0]->GetFiles().empty()) {
+            LOG_ERROR(Loader, "AUTOLOADER: FAILED at Metadata search for title {}: malformed.", title_id);
+            failed_files.append(QFileInfo(file).fileName() + tr(" (Malformed Metadata)"));
+            continue;
+        }
+
+        const auto cnmt_file = meta_nca->GetSubdirectories()[0]->GetFiles()[0];
+        const FileSys::CNMT cnmt(cnmt_file);
+
+        std::string type_folder = (cnmt.GetType() == FileSys::TitleType::Update) ? "Updates" : "DLC";
+        u64 program_id = FileSys::GetBaseTitleID(title_id);
+        QString nsp_name = QFileInfo(sanitized_path).completeBaseName();
+        std::string sdmc_path = Common::FS::GetCitronPathString(Common::FS::CitronPath::SDMCDir);
+        std::string dest_path_str = fmt::format("{}/autoloader/{:016X}/{}/{}", sdmc_path, program_id, type_folder, nsp_name.toStdString());
+
+        auto dest_dir = vfs->CreateDirectory(dest_path_str, FileSys::OpenMode::ReadWrite);
+        if (!dest_dir) {
+            LOG_ERROR(Loader, "AUTOLOADER: FAILED to create destination directory: {}", dest_path_str);
+            failed_files.append(QFileInfo(file).fileName() + tr(" (Directory Creation Error)"));
+            continue;
+        }
+
+        bool copy_failed = false;
+        for (const auto& [key, nca] : nca_map) {
+            auto source_file = nca->GetBaseFile();
+            auto dest_file = dest_dir->CreateFileRelative(source_file->GetName());
+
+            if (!dest_file->Resize(source_file->GetSize())) {
+                LOG_ERROR(Loader, "AUTOLOADER: FAILED to resize destination file for {}.", source_file->GetName());
+                copy_failed = true;
+                break;
+            }
+
+            std::vector<u8> buffer(CopyBufferSize);
+            for (std::size_t i = 0; i < source_file->GetSize(); i += buffer.size()) {
+                if (progress.wasCanceled()) {
+                    dest_file->Resize(0);
+                    copy_failed = true;
+                    break;
+                }
+
+                const auto bytes_to_read = std::min(buffer.size(), source_file->GetSize() - i);
+                const auto bytes_read = source_file->Read(buffer.data(), bytes_to_read, i);
+
+                if (bytes_read == 0 && i < source_file->GetSize()) {
+                    LOG_ERROR(Loader, "AUTOLOADER: FAILED to read from source file {}.", source_file->GetName());
+                    copy_failed = true;
+                    break;
+                }
+
+                dest_file->Write(buffer.data(), bytes_read, i);
+
+                total_copied_bytes += bytes_read;
+                progress.setValue((total_copied_bytes * 100) / total_size_bytes);
+                QCoreApplication::processEvents();
+            }
+
+            if (copy_failed) {
+                break;
+            }
+        }
+
+        if (progress.wasCanceled()) {
+            failed_files.append(QFileInfo(file).fileName() + tr(" (Cancelled)"));
+            vfs->DeleteDirectory(dest_path_str);
+            break;
+        }
+
+        if (copy_failed) {
+            failed_files.append(QFileInfo(file).fileName());
+            vfs->DeleteDirectory(dest_path_str);
+        } else {
+            success_count++;
+        }
+    }
+
+    progress.close();
+
+    QString message = tr("Autoloader install finished.");
+    if (success_count > 0) {
+        message += tr("\n%n file(s) successfully installed.", "", success_count);
+    }
+    if (!failed_files.isEmpty()) {
+        message += tr("\n%n file(s) failed to install:", "", failed_files.size());
+        message += QStringLiteral("\n- ") + failed_files.join(QStringLiteral("\n- "));
+    }
+    QMessageBox::information(this, tr("Install Complete"), message);
+
+    RegisterAutoloaderContents();
+    game_list->PopulateAsync(UISettings::values.game_dirs);
+}
+
 void GMainWindow::OnToggleGridView() {
     game_list->ToggleViewMode();
 }

src/citron/main.h

@@ -268,6 +268,7 @@ private:
                             const bool tas_allowed = false);
 
     void RegisterMetaTypes();
+    void RegisterAutoloaderContents();
 
     void InitializeWidgets();
     void InitializeDebugWidgets();
@@ -344,6 +345,9 @@ private:
         Service::AM::FrontendAppletParameters LibraryAppletParameters(u64 program_id,
                                                                       Service::AM::AppletId applet_id);
 
+        // This will hold and provide all discovered Autoloader content.
+        std::unique_ptr<FileSys::ManualContentProvider> autoloader_provider;
+
 private slots:
     void OnStartGame();
     void OnRestartGame();
@@ -378,6 +382,7 @@ private slots:
     void IncrementInstallProgress();
     void OnMenuInstallToNAND();
     void OnMenuTrimXCI();
+    void OnMenuInstallWithAutoloader();
     void OnMenuRecentFile();
     void OnConfigure();
     void OnConfigureTas();

src/citron/main.ui

@@ -59,6 +59,7 @@
     </widget>
     <addaction name="action_Install_File_NAND"/>
     <addaction name="action_Trim_XCI_File"/>
+    <addaction name="action_Install_With_Autoloader"/>
     <addaction name="separator"/>
     <addaction name="action_Load_File"/>
     <addaction name="action_Load_Folder"/>
@@ -207,6 +208,14 @@
     <string>&amp;Install Files to NAND...</string>
    </property>
   </action>
+  <action name="action_Install_With_Autoloader">
+   <property name="enabled">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Install Files with &amp;Autoloader...</string>
+   </property>
+  </action>
   <action name="action_Trim_XCI_File">
    <property name="enabled">
     <bool>true</bool>

src/core/file_sys/patch_manager.cpp

@@ -1,10 +1,12 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 citron Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
 #include <array>
 #include <cstddef>
 #include <cstring>
+#include <map>
 
 #include "common/hex_util.h"
 #include "common/logging/log.h"
@@ -61,8 +63,6 @@ std::string FormatTitleVersion(u32 version,
     return fmt::format("v{}.{}.{}", bytes[3], bytes[2], bytes[1]);
 }
 
-// Returns a directory with name matching name case-insensitive. Returns nullptr if directory
-// doesn't have a directory with name.
 VirtualDir FindSubdirectoryCaseless(const VirtualDir dir, std::string_view name) {
 #ifdef _WIN32
     return dir->GetSubdirectory(name);
@@ -74,7 +74,6 @@ VirtualDir FindSubdirectoryCaseless(const VirtualDir dir, std::string_view name)
             return subdir;
         }
     }
-
     return nullptr;
 #endif
 }
@@ -84,20 +83,17 @@ std::optional<std::vector<Core::Memory::CheatEntry>> ReadCheatFileFromFolder(
     const auto build_id_raw = Common::HexToString(build_id_, upper);
     const auto build_id = build_id_raw.substr(0, sizeof(u64) * 2);
     const auto file = base_path->GetFile(fmt::format("{}.txt", build_id));
-
     if (file == nullptr) {
         LOG_INFO(Common_Filesystem, "No cheats file found for title_id={:016X}, build_id={}",
                  title_id, build_id);
         return std::nullopt;
     }
-
     std::vector<u8> data(file->GetSize());
     if (file->Read(data.data(), data.size()) != data.size()) {
         LOG_INFO(Common_Filesystem, "Failed to read cheats file for title_id={:016X}, build_id={}",
                  title_id, build_id);
         return std::nullopt;
     }
-
     const Core::Memory::TextCheatParser parser;
     return parser.Parse(std::string_view(reinterpret_cast<const char*>(data.data()), data.size()));
 }
@@ -120,64 +116,89 @@ PatchManager::PatchManager(u64 title_id_,
                            const Service::FileSystem::FileSystemController& fs_controller_,
                            const ContentProvider& content_provider_)
     : title_id{title_id_}, fs_controller{fs_controller_}, content_provider{content_provider_} {}
-
 PatchManager::~PatchManager() = default;
-
 u64 PatchManager::GetTitleID() const {
     return title_id;
 }
 
 VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     LOG_INFO(Loader, "Patching ExeFS for title_id={:016X}", title_id);
-
     if (exefs == nullptr)
         return exefs;
 
     const auto& disabled = Settings::values.disabled_addons[title_id];
-    const auto update_disabled =
+    bool autoloader_update_applied = false;
-        std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
 
-    // Game Updates
+    // --- AUTOLOADER UPDATE (PRIORITY) ---
-    const auto update_tid = GetUpdateTitleID(title_id);
+    VirtualDir sdmc_root = nullptr;
-    const auto update = content_provider.GetEntry(update_tid, ContentRecordType::Program);
+    if (fs_controller.OpenSDMC(&sdmc_root).IsSuccess() && sdmc_root) {
+        const auto autoloader_updates_path = fmt::format("autoloader/{:016X}/Updates", title_id);
+        const auto updates_dir = sdmc_root->GetSubdirectory(autoloader_updates_path);
+        if (updates_dir) {
+            const auto base_program_nca = content_provider.GetEntry(title_id, ContentRecordType::Program);
+            if(base_program_nca){
+                for (const auto& mod : updates_dir->GetSubdirectories()) {
+                    if (mod && std::find(disabled.cbegin(), disabled.cend(), mod->GetName()) == disabled.cend()) {
+                        for (const auto& file : mod->GetFiles()) {
+                            if (file->GetExtension() == "nca") {
+                                NCA nca(file, base_program_nca.get());
+                                if (nca.GetStatus() == Loader::ResultStatus::Success && nca.GetType() == NCAContentType::Program) {
+                                    LOG_INFO(Loader, "    ExeFS: Autoloader Update ({}) applied successfully", mod->GetName());
+                                    exefs = nca.GetExeFS();
+                                    autoloader_update_applied = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (autoloader_update_applied) break;
+                }
+            }
+        }
+    }
 
-    if (!update_disabled && update != nullptr && update->GetExeFS() != nullptr) {
+    // --- NAND UPDATE (FALLBACK) ---
-        LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
+    if (!autoloader_update_applied) {
-                 FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0)));
+        const auto update_disabled = std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
-        exefs = update->GetExeFS();
+        const auto update_tid = GetUpdateTitleID(title_id);
+        const auto update = content_provider.GetEntry(update_tid, ContentRecordType::Program);
+        if (!update_disabled && update != nullptr && update->GetExeFS() != nullptr) {
+            LOG_INFO(Loader, "    ExeFS: NAND Update ({}) applied successfully",
+                     FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0)));
+            exefs = update->GetExeFS();
+        }
     }
 
     // LayeredExeFS
     const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     const auto sdmc_load_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);
-
     std::vector<VirtualDir> patch_dirs = {sdmc_load_dir};
     if (load_dir != nullptr) {
         const auto load_patch_dirs = load_dir->GetSubdirectories();
         patch_dirs.insert(patch_dirs.end(), load_patch_dirs.begin(), load_patch_dirs.end());
     }
-
     std::sort(patch_dirs.begin(), patch_dirs.end(),
-              [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
+              [](const VirtualDir& l, const VirtualDir& r) {
+                  if(!l) return true; if(!r) return false; return l->GetName() < r->GetName();
+              });
 
     std::vector<VirtualDir> layers;
     layers.reserve(patch_dirs.size() + 1);
     for (const auto& subdir : patch_dirs) {
-        if (std::find(disabled.begin(), disabled.end(), subdir->GetName()) != disabled.end())
+        if (!subdir || std::find(disabled.begin(), disabled.end(), subdir->GetName()) != disabled.end())
             continue;
-
         auto exefs_dir = FindSubdirectoryCaseless(subdir, "exefs");
         if (exefs_dir != nullptr)
             layers.push_back(std::move(exefs_dir));
     }
-    layers.push_back(exefs);
+    if(exefs) {
-
+        layers.push_back(exefs);
+    }
     auto layered = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
     if (layered != nullptr) {
         LOG_INFO(Loader, "    ExeFS: LayeredExeFS patches applied successfully");
         exefs = std::move(layered);
     }
-
     if (Settings::values.dump_exefs) {
         LOG_INFO(Loader, "Dumping ExeFS for title_id={:016X}", title_id);
         const auto dump_dir = fs_controller.GetModificationDumpRoot(title_id);
@@ -186,7 +207,6 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
             VfsRawCopyD(exefs, exefs_dir);
         }
     }
-
     return exefs;
 }
 
@@ -194,19 +214,16 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
                                                       const std::string& build_id) const {
     const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto nso_build_id = fmt::format("{:0<64}", build_id);
-
     std::vector<VirtualFile> out;
     out.reserve(patch_dirs.size());
     for (const auto& subdir : patch_dirs) {
-        if (std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend())
+        if (!subdir || std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend())
             continue;
-
         auto exefs_dir = FindSubdirectoryCaseless(subdir, "exefs");
         if (exefs_dir != nullptr) {
             for (const auto& file : exefs_dir->GetFiles()) {
                 if (file->GetExtension() == "ips") {
                     auto name = file->GetName();
-
                     const auto this_build_id =
                         fmt::format("{:0<64}", name.substr(0, name.find('.')));
                     if (nso_build_id == this_build_id)
@@ -215,7 +232,6 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
                     IPSwitchCompiler compiler{file};
                     if (!compiler.IsValid())
                         continue;
-
                     const auto this_build_id = Common::HexToString(compiler.GetBuildID());
                     if (nso_build_id == this_build_id)
                         out.push_back(file);
@@ -223,7 +239,6 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
             }
         }
     }
-
     return out;
 }
 
@@ -231,17 +246,13 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
     if (nso.size() < sizeof(Loader::NSOHeader)) {
         return nso;
     }
-
     Loader::NSOHeader header;
     std::memcpy(&header, nso.data(), sizeof(header));
-
     if (header.magic != Common::MakeMagic('N', 'S', 'O', '0')) {
         return nso;
     }
-
     const auto build_id_raw = Common::HexToString(header.build_id);
     const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
-
     if (Settings::values.dump_nso) {
         LOG_INFO(Loader, "Dumping NSO for name={}, build_id={}, title_id={:016X}", name, build_id,
                  title_id);
@@ -249,25 +260,20 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
         if (dump_dir != nullptr) {
             const auto nso_dir = GetOrCreateDirectoryRelative(dump_dir, "/nso");
             const auto file = nso_dir->CreateFile(fmt::format("{}-{}.nso", name, build_id));
-
             file->Resize(nso.size());
             file->WriteBytes(nso);
         }
     }
-
     LOG_INFO(Loader, "Patching NSO for name={}, build_id={}", name, build_id);
-
     const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return nso;
     }
-
     auto patch_dirs = load_dir->GetSubdirectories();
     std::sort(patch_dirs.begin(), patch_dirs.end(),
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
     const auto patches = CollectPatches(patch_dirs, build_id);
-
     auto out = nso;
     for (const auto& patch_file : patches) {
         if (patch_file->GetExtension() == "ips") {
@@ -285,11 +291,9 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
                 out = patched->ReadAllBytes();
         }
     }
-
     if (out.size() < sizeof(Loader::NSOHeader)) {
         return nso;
     }
-
     std::memcpy(out.data(), &header, sizeof(header));
     return out;
 }
@@ -297,19 +301,15 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
 bool PatchManager::HasNSOPatch(const BuildID& build_id_, std::string_view name) const {
     const auto build_id_raw = Common::HexToString(build_id_);
     const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
-
     LOG_INFO(Loader, "Querying NSO patch existence for build_id={}, name={}", build_id, name);
-
     const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return false;
     }
-
     auto patch_dirs = load_dir->GetSubdirectories();
     std::sort(patch_dirs.begin(), patch_dirs.end(),
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
-
     return !CollectPatches(patch_dirs, build_id).empty();
 }
 
@@ -320,31 +320,26 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return {};
     }
-
     const auto& disabled = Settings::values.disabled_addons[title_id];
     auto patch_dirs = load_dir->GetSubdirectories();
     std::sort(patch_dirs.begin(), patch_dirs.end(),
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
-
     std::vector<Core::Memory::CheatEntry> out;
     for (const auto& subdir : patch_dirs) {
-        if (std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend()) {
+        if (!subdir || std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend()) {
             continue;
         }
-
         auto cheats_dir = FindSubdirectoryCaseless(subdir, "cheats");
         if (cheats_dir != nullptr) {
             if (const auto res = ReadCheatFileFromFolder(title_id, build_id_, cheats_dir, true)) {
                 std::copy(res->begin(), res->end(), std::back_inserter(out));
                 continue;
             }
-
             if (const auto res = ReadCheatFileFromFolder(title_id, build_id_, cheats_dir, false)) {
                 std::copy(res->begin(), res->end(), std::back_inserter(out));
             }
         }
     }
-
     return out;
 }
 
@@ -357,40 +352,39 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
         (load_dir == nullptr && sdmc_load_dir == nullptr)) {
         return;
     }
-
     const auto& disabled = Settings::values.disabled_addons[title_id];
     std::vector<VirtualDir> patch_dirs;
     if (load_dir) {
-    patch_dirs = load_dir->GetSubdirectories();
+        patch_dirs = load_dir->GetSubdirectories();
-}
+    }
     if (std::find(disabled.cbegin(), disabled.cend(), "SDMC") == disabled.cend()) {
         patch_dirs.push_back(sdmc_load_dir);
     }
+
     std::sort(patch_dirs.begin(), patch_dirs.end(),
-              [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
+              [](const VirtualDir& l, const VirtualDir& r) {
+                  if (!l) return true;
+                  if (!r) return false;
+                  return l->GetName() < r->GetName();
+              });
 
     std::vector<VirtualDir> layers;
     std::vector<VirtualDir> layers_ext;
     layers.reserve(patch_dirs.size() + 1);
     layers_ext.reserve(patch_dirs.size() + 1);
     for (const auto& subdir : patch_dirs) {
-        if (std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend()) {
+        if (!subdir || std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend()) {
             continue;
         }
-
         auto romfs_dir = FindSubdirectoryCaseless(subdir, "romfs");
         if (romfs_dir != nullptr)
             layers.emplace_back(std::make_shared<CachedVfsDirectory>(std::move(romfs_dir)));
-
-        // Support for romfslite introduced in Atmosphere 1.9.5
         auto romfslite_dir = FindSubdirectoryCaseless(subdir, "romfslite");
         if (romfslite_dir != nullptr)
             layers.emplace_back(std::make_shared<CachedVfsDirectory>(std::move(romfslite_dir)));
-
         auto ext_dir = FindSubdirectoryCaseless(subdir, "romfs_ext");
         if (ext_dir != nullptr)
             layers_ext.emplace_back(std::make_shared<CachedVfsDirectory>(std::move(ext_dir)));
-
         if (type == ContentRecordType::HtmlDocument) {
             auto manual_dir = FindSubdirectoryCaseless(subdir, "manual_html");
             if (manual_dir != nullptr)
@@ -398,30 +392,23 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
         }
     }
 
-    // When there are no layers to apply, return early as there is no need to rebuild the RomFS
     if (layers.empty() && layers_ext.empty()) {
         return;
     }
-
     auto extracted = ExtractRomFS(romfs);
     if (extracted == nullptr) {
         return;
     }
-
     layers.emplace_back(std::move(extracted));
-
     auto layered = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
     if (layered == nullptr) {
         return;
     }
-
     auto layered_ext = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers_ext));
-
     auto packed = CreateRomFS(std::move(layered), std::move(layered_ext));
     if (packed == nullptr) {
         return;
     }
-
     LOG_INFO(Loader, "    RomFS: LayeredFS patches applied successfully");
     romfs = std::move(packed);
 }
@@ -436,41 +423,134 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs
     } else {
         LOG_DEBUG(Loader, "{}", log_string);
     }
-
     auto romfs = base_romfs;
-
-    // Game Updates
-    const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update_raw = content_provider.GetEntryRaw(update_tid, type);
-
     const auto& disabled = Settings::values.disabled_addons[title_id];
-    const auto update_disabled =
+    bool autoloader_update_applied = false;
-        std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
 
-    if (!update_disabled && update_raw != nullptr && base_nca != nullptr) {
+    // --- AUTOLOADER UPDATE (PRIORITY) ---
-        const auto new_nca = std::make_shared<NCA>(update_raw, base_nca);
+    if (type == ContentRecordType::Program) {
-        if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
+        VirtualDir sdmc_root = nullptr;
-            new_nca->GetRomFS() != nullptr) {
+        if (fs_controller.OpenSDMC(&sdmc_root).IsSuccess() && sdmc_root) {
-            LOG_INFO(Loader, "    RomFS: Update ({}) applied successfully",
+            const auto autoloader_updates_path = fmt::format("autoloader/{:016X}/Updates", title_id);
-                     FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0)));
+            const auto updates_dir = sdmc_root->GetSubdirectory(autoloader_updates_path);
-            romfs = new_nca->GetRomFS();
+            if (updates_dir) {
-            const auto version =
+                for (const auto& mod : updates_dir->GetSubdirectories()) {
-                FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0));
+                    if (mod && std::find(disabled.cbegin(), disabled.cend(), mod->GetName()) == disabled.cend()) {
-        }
+                        for (const auto& file : mod->GetFiles()) {
-    } else if (!update_disabled && packed_update_raw != nullptr && base_nca != nullptr) {
+                            if (file->GetExtension() == "nca") {
-        const auto new_nca = std::make_shared<NCA>(packed_update_raw, base_nca);
+                                const auto new_nca = std::make_shared<NCA>(file, base_nca);
-        if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
+                                if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
-            new_nca->GetRomFS() != nullptr) {
+                                    new_nca->GetType() == NCAContentType::Program &&
-            LOG_INFO(Loader, "    RomFS: Update (PACKED) applied successfully");
+                                    new_nca->GetRomFS() != nullptr) {
-            romfs = new_nca->GetRomFS();
+                                    LOG_INFO(Loader, "    RomFS: Autoloader Update ({}) applied successfully", mod->GetName());
+                                    romfs = new_nca->GetRomFS();
+                                    autoloader_update_applied = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (autoloader_update_applied) break;
+                }
+            }
+        }
+    }
+
+    // --- NAND UPDATE (FALLBACK) ---
+    if (!autoloader_update_applied) {
+        const auto update_disabled = std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
+        const auto update_tid = GetUpdateTitleID(title_id);
+        const auto update_raw = content_provider.GetEntryRaw(update_tid, type);
+        if (!update_disabled && update_raw != nullptr && base_nca != nullptr) {
+            const auto new_nca = std::make_shared<NCA>(update_raw, base_nca);
+            if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
+                new_nca->GetRomFS() != nullptr) {
+                LOG_INFO(Loader, "    RomFS: NAND Update ({}) applied successfully",
+                         FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0)));
+                romfs = new_nca->GetRomFS();
+            }
+        } else if (!update_disabled && packed_update_raw != nullptr && base_nca != nullptr) {
+            const auto new_nca = std::make_shared<NCA>(packed_update_raw, base_nca);
+            if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
+                new_nca->GetRomFS() != nullptr) {
+                LOG_INFO(Loader, "    RomFS: Update (PACKED) applied successfully");
+                romfs = new_nca->GetRomFS();
+            }
+        }
+    }
+
+    // --- AUTOLOADER DLC (Layering) ---
+    if (type == ContentRecordType::Program) {
+        VirtualDir sdmc_root = nullptr;
+        if (fs_controller.OpenSDMC(&sdmc_root).IsSuccess() && sdmc_root) {
+            const auto autoloader_dlc_path = fmt::format("autoloader/{:016X}/DLC", title_id);
+            const auto dlc_dir = sdmc_root->GetSubdirectory(autoloader_dlc_path);
+            if (dlc_dir) {
+                std::map<u64, VirtualFile> dlc_ncas;
+                for (const auto& mod : dlc_dir->GetSubdirectories()) {
+                    if (mod && std::find(disabled.cbegin(), disabled.cend(), mod->GetName()) == disabled.cend()) {
+                        u64 dlc_title_id = 0;
+                        VirtualFile data_nca_file = nullptr;
+
+                        for (const auto& file : mod->GetFiles()) {
+                            if (file->GetName().ends_with(".cnmt.nca")) {
+                                NCA meta_nca(file);
+                                if (meta_nca.GetStatus() == Loader::ResultStatus::Success && !meta_nca.GetSubdirectories().empty()) {
+                                    auto section0 = meta_nca.GetSubdirectories()[0];
+                                    if (!section0->GetFiles().empty()) {
+                                        CNMT cnmt(section0->GetFiles()[0]);
+                                        dlc_title_id = cnmt.GetTitleID();
+                                    }
+                                }
+                            } else if (file->GetExtension() == "nca") {
+                                // Tentatively assume this is the data NCA
+                                data_nca_file = file;
+                            }
+                        }
+
+                        if (dlc_title_id != 0 && data_nca_file != nullptr) {
+                            dlc_ncas[dlc_title_id] = data_nca_file;
+                        }
+                    }
+                }
+
+                if (!dlc_ncas.empty()) {
+                    std::vector<VirtualDir> layers;
+                    auto base_layer = ExtractRomFS(romfs);
+                    if (base_layer) {
+                        layers.push_back(std::move(base_layer));
+
+                        for (const auto& [tid, nca_file] : dlc_ncas) {
+                            const auto dlc_nca = std::make_shared<NCA>(nca_file, base_nca);
+                            if (dlc_nca->GetStatus() == Loader::ResultStatus::Success &&
+                                dlc_nca->GetType() == NCAContentType::Data &&
+                                dlc_nca->GetRomFS() != nullptr) {
+
+                                auto extracted_dlc_romfs = ExtractRomFS(dlc_nca->GetRomFS());
+                                if (extracted_dlc_romfs) {
+                                    layers.push_back(std::move(extracted_dlc_romfs));
+                                    LOG_INFO(Loader, "    RomFS: Staging Autoloader DLC TID {:016X}", tid);
+                                }
+                            }
+                        }
+
+                        if (layers.size() > 1) {
+                            auto layered_dir = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
+                            auto packed = CreateRomFS(std::move(layered_dir), nullptr);
+                            if (packed) {
+                                romfs = std::move(packed);
+                                LOG_INFO(Loader, "    RomFS: Autoloader DLCs layered successfully.");
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
 
-    // LayeredFS
     if (apply_layeredfs) {
         ApplyLayeredFS(romfs, title_id, type, fs_controller);
     }
-
     return romfs;
 }
 
@@ -478,16 +558,14 @@ std::vector<Patch> PatchManager::GetPatches(VirtualFile update_raw) const {
     if (title_id == 0) {
         return {};
     }
-
     std::vector<Patch> out;
     const auto& disabled = Settings::values.disabled_addons[title_id];
 
-    // Game Updates
+    // --- 1. NAND Update (from original code) ---
     const auto update_tid = GetUpdateTitleID(title_id);
     PatchManager update{update_tid, fs_controller, content_provider};
     const auto metadata = update.GetControlMetadata();
     const auto& nacp = metadata.first;
-
     const auto update_disabled =
         std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
     Patch update_patch = {.enabled = !update_disabled,
@@ -496,134 +574,209 @@ std::vector<Patch> PatchManager::GetPatches(VirtualFile update_raw) const {
                           .type = PatchType::Update,
                           .program_id = title_id,
                           .title_id = title_id};
-
     if (nacp != nullptr) {
         update_patch.version = nacp->GetVersionString();
         out.push_back(update_patch);
-    } else {
+    } else if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
-        if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
+        const auto meta_ver = content_provider.GetEntryVersion(update_tid);
-            const auto meta_ver = content_provider.GetEntryVersion(update_tid);
+        if (meta_ver.value_or(0) != 0) {
-            if (meta_ver.value_or(0) == 0) {
+            update_patch.version = FormatTitleVersion(*meta_ver);
-                out.push_back(update_patch);
-            } else {
-                update_patch.version = FormatTitleVersion(*meta_ver);
-                out.push_back(update_patch);
-            }
-        } else if (update_raw != nullptr) {
-            update_patch.version = "PACKED";
             out.push_back(update_patch);
         }
+    } else if (update_raw != nullptr) {
+        update_patch.version = "PACKED";
+        out.push_back(update_patch);
     }
 
-    // General Mods (LayeredFS and IPS)
+    // --- 2. Autoloader Content (Updates and DLC) ---
+    VirtualDir sdmc_root = nullptr;
+    if (fs_controller.OpenSDMC(&sdmc_root).IsSuccess() && sdmc_root) {
+        const auto scan_autoloader_content =
+            [&](const std::string& content_type_folder, PatchType patch_type) {
+            const auto autoloader_path = fmt::format("autoloader/{:016X}/{}", title_id, content_type_folder);
+            const auto content_dir = sdmc_root->GetSubdirectory(autoloader_path);
+            if (!content_dir) return;
+
+            for (const auto& mod : content_dir->GetSubdirectories()) {
+                if (!mod) continue;
+
+                std::string mod_name_str = mod->GetName();
+                std::string version_str = "Unknown";
+
+                if (patch_type == PatchType::DLC) {
+                    u64 dlc_title_id = 0;
+                    for (const auto& file : mod->GetFiles()) {
+                        if (file->GetName().ends_with(".cnmt.nca")) {
+                            NCA meta_nca(file);
+                            if (meta_nca.GetStatus() == Loader::ResultStatus::Success && !meta_nca.GetSubdirectories().empty()) {
+                                auto section0 = meta_nca.GetSubdirectories()[0];
+                                if (!section0->GetFiles().empty()) {
+                                    CNMT cnmt(section0->GetFiles()[0]);
+                                    dlc_title_id = cnmt.GetTitleID();
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (dlc_title_id != 0) {
+                        version_str = fmt::format("{}", (dlc_title_id - GetBaseTitleID(dlc_title_id)) / 0x1000);
+                    } else {
+                        version_str = "DLC";
+                    }
+                    for (const auto& file : mod->GetFiles()) {
+                        if (file->GetExtension() == "nca") {
+                            NCA nca_check(file);
+                            if (nca_check.GetStatus() == Loader::ResultStatus::Success && nca_check.GetType() == NCAContentType::Control) {
+                                if (auto romfs = nca_check.GetRomFS()) {
+                                    if (auto extracted = ExtractRomFS(romfs)) {
+                                        if (auto nacp_file = extracted->GetFile("control.nacp")) {
+                                            NACP dlc_nacp(nacp_file);
+                                            std::string nacp_name = dlc_nacp.GetApplicationName();
+                                            if (!nacp_name.empty()) {
+                                                mod_name_str = nacp_name;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else { // Handle Updates
+                    for (const auto& file : mod->GetFiles()) {
+                        if (file->GetExtension() == "nca") {
+                            NCA nca_check(file);
+                            if (nca_check.GetStatus() == Loader::ResultStatus::Success && nca_check.GetType() == NCAContentType::Control) {
+                                if (auto romfs = nca_check.GetRomFS()) {
+                                    if (auto extracted = ExtractRomFS(romfs)) {
+                                        if (auto nacp_file = extracted->GetFile("control.nacp")) {
+                                            NACP autoloader_nacp(nacp_file);
+                                            std::string nacp_version = autoloader_nacp.GetVersionString();
+                                            if (!nacp_version.empty()) {
+                                                version_str = nacp_version;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (version_str == "Unknown") {
+                         for (const auto& file : mod->GetFiles()) {
+                            if (file->GetName().ends_with(".cnmt.nca")) {
+                                NCA meta_nca(file);
+                                if (meta_nca.GetStatus() == Loader::ResultStatus::Success && !meta_nca.GetSubdirectories().empty()) {
+                                    auto section0 = meta_nca.GetSubdirectories()[0];
+                                    if (!section0->GetFiles().empty()) {
+                                        CNMT cnmt(section0->GetFiles()[0]);
+                                        version_str = FormatTitleVersion(cnmt.GetTitleVersion(), TitleVersionFormat::FourElements);
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                const auto mod_disabled = std::find(disabled.begin(), disabled.end(), mod->GetName()) != disabled.end();
+                out.push_back({.enabled = !mod_disabled, .name = mod_name_str, .version = version_str, .type = patch_type, .program_id = title_id, .title_id = title_id});
+            }
+        };
+
+        scan_autoloader_content("Updates", PatchType::Update);
+        scan_autoloader_content("DLC", PatchType::DLC);
+    }
+
+    // --- 3. General Mods (from original code) ---
     const auto mod_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (mod_dir != nullptr) {
         for (const auto& mod : mod_dir->GetSubdirectories()) {
             std::string types;
-
             const auto exefs_dir = FindSubdirectoryCaseless(mod, "exefs");
             if (IsDirValidAndNonEmpty(exefs_dir)) {
-                bool ips = false;
+                bool ips = false, ipswitch = false, layeredfs = false;
-                bool ipswitch = false;
-                bool layeredfs = false;
-
                 for (const auto& file : exefs_dir->GetFiles()) {
-                    if (file->GetExtension() == "ips") {
+                    if (file->GetExtension() == "ips") ips = true;
-                        ips = true;
+                    else if (file->GetExtension() == "pchtxt") ipswitch = true;
-                    } else if (file->GetExtension() == "pchtxt") {
+                    else if (std::find(EXEFS_FILE_NAMES.begin(), EXEFS_FILE_NAMES.end(), file->GetName()) != EXEFS_FILE_NAMES.end()) layeredfs = true;
-                        ipswitch = true;
-                    } else if (std::find(EXEFS_FILE_NAMES.begin(), EXEFS_FILE_NAMES.end(),
-                                         file->GetName()) != EXEFS_FILE_NAMES.end()) {
-                        layeredfs = true;
-                    }
                 }
-
+                if (ips) AppendCommaIfNotEmpty(types, "IPS");
-                if (ips)
+                if (ipswitch) AppendCommaIfNotEmpty(types, "IPSwitch");
-                    AppendCommaIfNotEmpty(types, "IPS");
+                if (layeredfs) AppendCommaIfNotEmpty(types, "LayeredExeFS");
-                if (ipswitch)
-                    AppendCommaIfNotEmpty(types, "IPSwitch");
-                if (layeredfs)
-                    AppendCommaIfNotEmpty(types, "LayeredExeFS");
             }
-            if (IsDirValidAndNonEmpty(FindSubdirectoryCaseless(mod, "romfs")) ||
+            if (IsDirValidAndNonEmpty(FindSubdirectoryCaseless(mod, "romfs")) || IsDirValidAndNonEmpty(FindSubdirectoryCaseless(mod, "romfslite"))) AppendCommaIfNotEmpty(types, "LayeredFS");
-                IsDirValidAndNonEmpty(FindSubdirectoryCaseless(mod, "romfslite")))
+            if (IsDirValidAndNonEmpty(FindSubdirectoryCaseless(mod, "cheats"))) AppendCommaIfNotEmpty(types, "Cheats");
-                AppendCommaIfNotEmpty(types, "LayeredFS");
+            if (types.empty()) continue;
-            if (IsDirValidAndNonEmpty(FindSubdirectoryCaseless(mod, "cheats")))
+            const auto mod_disabled = std::find(disabled.begin(), disabled.end(), mod->GetName()) != disabled.end();
-                AppendCommaIfNotEmpty(types, "Cheats");
+            out.push_back({.enabled = !mod_disabled, .name = mod->GetName(), .version = types, .type = PatchType::Mod, .program_id = title_id, .title_id = title_id});
-
-            if (types.empty())
-                continue;
-
-            const auto mod_disabled =
-                std::find(disabled.begin(), disabled.end(), mod->GetName()) != disabled.end();
-            out.push_back({.enabled = !mod_disabled,
-                           .name = mod->GetName(),
-                           .version = types,
-                           .type = PatchType::Mod,
-                           .program_id = title_id,
-                           .title_id = title_id});
         }
     }
-
-    // SDMC mod directory (RomFS LayeredFS)
     const auto sdmc_mod_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);
     if (sdmc_mod_dir != nullptr) {
         std::string types;
-        if (IsDirValidAndNonEmpty(FindSubdirectoryCaseless(sdmc_mod_dir, "exefs"))) {
+        if (IsDirValidAndNonEmpty(FindSubdirectoryCaseless(sdmc_mod_dir, "exefs"))) AppendCommaIfNotEmpty(types, "LayeredExeFS");
-            AppendCommaIfNotEmpty(types, "LayeredExeFS");
+        if (IsDirValidAndNonEmpty(FindSubdirectoryCaseless(sdmc_mod_dir, "romfs")) || IsDirValidAndNonEmpty(FindSubdirectoryCaseless(sdmc_mod_dir, "romfslite"))) AppendCommaIfNotEmpty(types, "LayeredFS");
-        }
-        if (IsDirValidAndNonEmpty(FindSubdirectoryCaseless(sdmc_mod_dir, "romfs")) ||
-            IsDirValidAndNonEmpty(FindSubdirectoryCaseless(sdmc_mod_dir, "romfslite"))) {
-            AppendCommaIfNotEmpty(types, "LayeredFS");
-        }
-
         if (!types.empty()) {
-            const auto mod_disabled =
+            const auto mod_disabled = std::find(disabled.begin(), disabled.end(), "SDMC") != disabled.end();
-                std::find(disabled.begin(), disabled.end(), "SDMC") != disabled.end();
+            out.push_back({.enabled = !mod_disabled, .name = "SDMC", .version = types, .type = PatchType::Mod, .program_id = title_id, .title_id = title_id});
-            out.push_back({.enabled = !mod_disabled,
-                           .name = "SDMC",
-                           .version = types,
-                           .type = PatchType::Mod,
-                           .program_id = title_id,
-                           .title_id = title_id});
         }
     }
 
-    // DLC
+    // --- 4. NAND DLC (from original code) ---
-    const auto dlc_entries =
+    const auto dlc_entries = content_provider.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
-        content_provider.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
     std::vector<ContentProviderEntry> dlc_match;
     dlc_match.reserve(dlc_entries.size());
     std::copy_if(dlc_entries.begin(), dlc_entries.end(), std::back_inserter(dlc_match),
                  [this](const ContentProviderEntry& entry) {
                      return GetBaseTitleID(entry.title_id) == title_id &&
-                            content_provider.GetEntry(entry)->GetStatus() ==
+                            content_provider.GetEntry(entry)->GetStatus() == Loader::ResultStatus::Success;
-                                Loader::ResultStatus::Success;
                  });
     if (!dlc_match.empty()) {
-        // Ensure sorted so DLC IDs show in order.
         std::sort(dlc_match.begin(), dlc_match.end());
-
         std::string list;
         for (size_t i = 0; i < dlc_match.size() - 1; ++i)
             list += fmt::format("{}, ", dlc_match[i].title_id & 0x7FF);
-
         list += fmt::format("{}", dlc_match.back().title_id & 0x7FF);
-
+        const auto dlc_disabled = std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end();
-        const auto dlc_disabled =
+        out.push_back({.enabled = !dlc_disabled, .name = "DLC", .version = std::move(list), .type = PatchType::DLC, .program_id = title_id, .title_id = dlc_match.back().title_id});
-            std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end();
-        out.push_back({.enabled = !dlc_disabled,
-                       .name = "DLC",
-                       .version = std::move(list),
-                       .type = PatchType::DLC,
-                       .program_id = title_id,
-                       .title_id = dlc_match.back().title_id});
     }
 
     return out;
 }
 
 std::optional<u32> PatchManager::GetGameVersion() const {
+    const auto& disabled = Settings::values.disabled_addons[title_id];
+
+    // --- Autoloader Check (PRIORITY) ---
+    VirtualDir sdmc_root = nullptr;
+    if (fs_controller.OpenSDMC(&sdmc_root).IsSuccess() && sdmc_root) {
+        const auto autoloader_updates_path = fmt::format("autoloader/{:016X}/Updates", title_id);
+        const auto autoloader_updates_dir = sdmc_root->GetSubdirectory(autoloader_updates_path);
+        if (autoloader_updates_dir) {
+            for (const auto& update_mod : autoloader_updates_dir->GetSubdirectories()) {
+                if (!update_mod) continue;
+
+                if (std::find(disabled.cbegin(), disabled.cend(), update_mod->GetName()) == disabled.cend()) {
+                    for (const auto& file : update_mod->GetFiles()) {
+                        if (file->GetName().ends_with(".cnmt.nca")) {
+                            NCA meta_nca(file);
+                            if (meta_nca.GetStatus() == Loader::ResultStatus::Success && !meta_nca.GetSubdirectories().empty()) {
+                                auto section0 = meta_nca.GetSubdirectories()[0];
+                                for (const auto& cnmt_file_entry : section0->GetFiles()) {
+                                    if (cnmt_file_entry->GetExtension() == "cnmt") {
+                                        CNMT cnmt(cnmt_file_entry);
+                                        return cnmt.GetTitleVersion();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // --- NAND Check (FALLBACK) ---
     const auto update_tid = GetUpdateTitleID(title_id);
     if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
         return content_provider.GetEntryVersion(update_tid);
@@ -633,12 +786,49 @@ std::optional<u32> PatchManager::GetGameVersion() const {
 }
 
 PatchManager::Metadata PatchManager::GetControlMetadata() const {
-    const auto base_control_nca = content_provider.GetEntry(title_id, ContentRecordType::Control);
+    std::unique_ptr<NCA> control_nca = nullptr;
-    if (base_control_nca == nullptr) {
+    const auto& disabled_map = Settings::values.disabled_addons;
+    const auto it = disabled_map.find(title_id);
+    const auto& disabled_for_game = (it != disabled_map.end()) ? it->second : std::vector<std::string>{};
+
+    VirtualDir sdmc_root = nullptr;
+    if (fs_controller.OpenSDMC(&sdmc_root).IsSuccess() && sdmc_root) {
+        const auto autoloader_updates_path = fmt::format("autoloader/{:016X}/Updates", title_id);
+        if (const auto autoloader_updates_dir = sdmc_root->GetSubdirectory(autoloader_updates_path)) {
+            for (const auto& update_mod : autoloader_updates_dir->GetSubdirectories()) {
+                if (!update_mod) continue;
+
+                const std::string mod_name = update_mod->GetName();
+                if (std::find(disabled_for_game.begin(), disabled_for_game.end(), mod_name) == disabled_for_game.end()) {
+                    for (const auto& file : update_mod->GetFiles()) {
+                        if (file->GetExtension() == "nca") {
+                            NCA nca_check(file);
+                            if (nca_check.GetStatus() == Loader::ResultStatus::Success && nca_check.GetType() == NCAContentType::Control) {
+                                LOG_INFO(Loader, "Found active Autoloader Control NCA in '{}'", mod_name);
+                                control_nca = std::make_unique<NCA>(file);
+                                // Found the highest priority enabled control, we are done.
+                                return ParseControlNCA(*control_nca);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Fallback to NAND if no enabled Autoloader update was found
+    const auto update_tid = GetUpdateTitleID(title_id);
+    control_nca = content_provider.GetEntry(update_tid, ContentRecordType::Control);
+
+    if (control_nca == nullptr) {
+        control_nca = content_provider.GetEntry(title_id, ContentRecordType::Control);
+    }
+
+    if (control_nca == nullptr) {
         return {};
     }
 
-    return ParseControlNCA(*base_control_nca);
+    return ParseControlNCA(*control_nca);
 }
 
 PatchManager::Metadata PatchManager::ParseControlNCA(const NCA& nca) const {
@@ -664,35 +854,28 @@ PatchManager::Metadata PatchManager::ParseControlNCA(const NCA& nca) const {
 
     auto nacp = nacp_file == nullptr ? nullptr : std::make_unique<NACP>(nacp_file);
 
-    // Get language code from settings
     const auto language_code = Service::Set::GetLanguageCodeFromIndex(
         static_cast<u32>(Settings::values.language_index.GetValue()));
 
-    // Convert to application language and get priority list
     const auto application_language =
         Service::NS::ConvertToApplicationLanguage(language_code)
             .value_or(Service::NS::ApplicationLanguage::AmericanEnglish);
     const auto language_priority_list =
         Service::NS::GetApplicationLanguagePriorityList(application_language);
 
-    // Convert to language names
+    auto priority_language_names = FileSys::LANGUAGE_NAMES;
-    auto priority_language_names = FileSys::LANGUAGE_NAMES; // Copy
     if (language_priority_list) {
         for (size_t i = 0; i < priority_language_names.size(); ++i) {
-            // Relies on FileSys::LANGUAGE_NAMES being in the same order as
-            // Service::NS::ApplicationLanguage
             const auto language_index = static_cast<u8>(language_priority_list->at(i));
 
             if (language_index < FileSys::LANGUAGE_NAMES.size()) {
                 priority_language_names[i] = FileSys::LANGUAGE_NAMES[language_index];
             } else {
-                // Not a catastrophe, unlikely to happen
                 LOG_WARNING(Loader, "Invalid language index {}", language_index);
             }
         }
     }
 
-    // Get first matching icon
     VirtualFile icon_file;
     for (const auto& language : priority_language_names) {
         icon_file = extracted->GetFile(std::string("icon_").append(language).append(".dat"));

src/core/file_sys/patch_manager.h

@@ -1,4 +1,5 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 citron Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
@@ -92,6 +93,7 @@ public:
     [[nodiscard]] Metadata ParseControlNCA(const NCA& nca) const;
 
 private:
+    [[nodiscard]] VirtualFile FindAutoloaderNCA(ContentRecordType type) const;
     [[nodiscard]] std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
                                                           const std::string& build_id) const;
 

src/core/file_sys/registered_cache.h

@@ -1,4 +1,5 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 citron Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
@@ -208,6 +209,7 @@ enum class ContentProviderUnionSlot {
     UserNAND,       ///< User NAND
     SDMC,           ///< SD Card
     FrontendManual, ///< Frontend-defined game list or similar
+    Autoloader,     ///< Separate functionality for multiple Updates/DLCs without being overwritten by NAND.
 };
 
 // Combines multiple ContentProvider(s) (i.e. SysNAND, UserNAND, SDMC) into one interface.