When auth is down, launch into offline mode (#5647)

Signed-off-by: DioEgizio <dioegizio@protonmail.com>

.clang-tidy

@@ -1,32 +1,32 @@
 FormatStyle: file
 
 Checks:
-  'bugprone-*,clang-analyzer-*,cppcoreguidelines-*,hicpp-*,misc-*,modernize-*,performance-*,portability-*,readability-*,
+    "bugprone-*,clang-analyzer-*,cppcoreguidelines-*,hicpp-*,misc-*,modernize-*,performance-*,portability-*,readability-*,
-  -*-magic-numbers,
+    -*-magic-numbers,
-  -*-non-private-member-variables-in-classes,
+    -*-non-private-member-variables-in-classes,
-  -*-special-member-functions,
+    -*-special-member-functions,
-  -bugprone-easily-swappable-parameters,
+    -bugprone-easily-swappable-parameters,
-  -cppcoreguidelines-owning-memory,
+    -cppcoreguidelines-owning-memory,
-  -cppcoreguidelines-pro-type-static-cast-downcast,
+    -cppcoreguidelines-pro-type-static-cast-downcast,
-  -modernize-use-nodiscard,
+    -modernize-use-nodiscard,
-  -modernize-use-trailing-return-type,
+    -modernize-use-trailing-return-type,
-  -portability-avoid-pragma-once,
+    -portability-avoid-pragma-once,
-  -readability-avoid-unconditional-preprocessor-if,
+    -readability-avoid-unconditional-preprocessor-if,
-  -readability-function-cognitive-complexity,
+    -readability-function-cognitive-complexity,
-  -readability-identifier-length,
+    -readability-identifier-length,
-  -readability-redundant-access-specifiers'
+    -readability-redundant-access-specifiers"
 
 CheckOptions:
-  - { key: misc-include-cleaner.MissingIncludes,                        value: false }
+    misc-include-cleaner.MissingIncludes: false
-  - { key: readability-identifier-naming.DefaultCase,                   value: camelBack }
+    readability-identifier-naming.DefaultCase: "camelBack"
-  - { key: readability-identifier-naming.NamespaceCase,                 value: CamelCase }
+    readability-identifier-naming.NamespaceCase: "CamelCase"
-  - { key: readability-identifier-naming.ClassCase,                     value: CamelCase }
+    readability-identifier-naming.ClassCase: "CamelCase"
-  - { key: readability-identifier-naming.ClassConstantCase,             value: CamelCase }
+    readability-identifier-naming.ClassConstantCase: "CamelCase"
-  - { key: readability-identifier-naming.EnumCase,                      value: CamelCase }
+    readability-identifier-naming.EnumCase: "CamelCase"
-  - { key: readability-identifier-naming.EnumConstantCase,              value: CamelCase }
+    readability-identifier-naming.EnumConstantCase: "CamelCase"
-  - { key: readability-identifier-naming.MacroDefinitionCase,           value: UPPER_CASE }
+    readability-identifier-naming.MacroDefinitionCase: "UPPER_CASE"
-  - { key: readability-identifier-naming.ClassMemberPrefix,             value: m_ }
+    readability-identifier-naming.ClassMemberPrefix: "m_"
-  - { key: readability-identifier-naming.StaticConstantPrefix,          value: s_ }
+    readability-identifier-naming.StaticConstantPrefix: "s_"
-  - { key: readability-identifier-naming.StaticVariablePrefix,          value: s_ }
+    readability-identifier-naming.StaticVariablePrefix: "s_"
-  - { key: readability-identifier-naming.GlobalConstantPrefix,          value: g_ }
+    readability-identifier-naming.GlobalConstantPrefix: "g_"
-  - { key: readability-implicit-bool-conversion.AllowPointerConditions, value: true }
+    readability-implicit-bool-conversion.AllowPointerConditions: true

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -23,14 +23,14 @@ body:
     - macOS
     - Linux
     - Other
-- type: textarea
+- type: input
   attributes:
     label: Version of Prism Launcher
     description: The version of Prism Launcher used in the bug report.
     placeholder: Prism Launcher 5.0
   validations:
     required: true
-- type: textarea
+- type: input
   attributes:
     label: Version of Qt
     description: The version of Qt used in the bug report. You can find it in Help -> About Prism Launcher -> About Qt.

.github/actions/package/linux/action.yml

@@ -91,9 +91,9 @@ runs:
         find "$INSTALL_APPIMAGE_DIR" -name '*gamemode*' -exec rm {} +
 
         #disable OpenGL and Vulkan launcher features until https://github.com/VHSgunzo/sharun/issues/35
-        echo "LAUNCHER_DISABLE_GLVULKAN=1" > "$INSTALL_APPIMAGE_DIR"/.env
+        echo "PRISMLAUNCHER_DISABLE_GLVULKAN=1" >> "$INSTALL_APPIMAGE_DIR"/.env
         #makes the launcher use portals for file picking
-        echo "QT_QPA_PLATFORMTHEME=xdgdesktopportal" > "$INSTALL_APPIMAGE_DIR"/.env
+        echo "QT_QPA_PLATFORMTHEME=xdgdesktopportal" >> "$INSTALL_APPIMAGE_DIR"/.env
         ln -s org.prismlauncher.PrismLauncher.metainfo.xml "$INSTALL_APPIMAGE_DIR"/share/metainfo/org.prismlauncher.PrismLauncher.appdata.xml
         ln -s share/applications/org.prismlauncher.PrismLauncher.desktop "$INSTALL_APPIMAGE_DIR"
         ln -s share/icons/hicolor/256x256/apps/org.prismlauncher.PrismLauncher.png "$INSTALL_APPIMAGE_DIR"

.github/actions/package/windows/action.yml

@@ -69,7 +69,7 @@ runs:
 
     - name: Sign executables
       if: ${{ env.CI_HAS_ACCESS_TO_AZURE != '' && inputs.azure-client-id != '' }}
-      uses: azure/artifact-signing-action@v1
+      uses: azure/artifact-signing-action@v2
       with:
         endpoint: https://eus.codesigning.azure.net/
         trusted-signing-account-name: PrismLauncher
@@ -142,7 +142,7 @@ runs:
 
     - name: Sign installer
       if: ${{ env.CI_HAS_ACCESS_TO_AZURE != '' && inputs.azure-client-id != '' }}
-      uses: azure/artifact-signing-action@v1
+      uses: azure/artifact-signing-action@v2
       with:
         endpoint: https://eus.codesigning.azure.net/
         trusted-signing-account-name: PrismLauncher

.github/actions/setup-dependencies/action.yml

@@ -55,7 +55,7 @@ runs:
     # TODO(@getchoo): Get this working on MSYS2!
     - name: Setup ccache
       if: ${{ (runner.os != 'Windows' || inputs.msystem == '') && inputs.build-type == 'Debug' }}
-      uses: hendrikmuhs/ccache-action@v1.2.21
+      uses: hendrikmuhs/ccache-action@v1.2.23
       with:
         variant: sccache
         create-symlink: ${{ runner.os != 'Windows' }}

.github/actions/setup-dependencies/linux/action.yml

@@ -13,7 +13,7 @@ runs:
           dpkg-dev \
           ninja-build extra-cmake-modules pkg-config scdoc \
           cmark gamemode-dev libarchive-dev libcmark-dev libqrencode-dev zlib1g-dev \
-          libxcb-cursor-dev libtomlplusplus-dev libvulkan-dev
+          libxcb-cursor-dev libtomlplusplus-dev
 
     - name: Setup AppImage tooling
       shell: bash

.github/actions/setup-dependencies/windows/action.yml

@@ -91,7 +91,7 @@ runs:
 
     - name: Retrieve ccache cache (MinGW)
       if: ${{ inputs.msystem != '' && inputs.build-type == 'Debug' }}
-      uses: actions/cache@v5.0.4
+      uses: actions/cache@v5.0.5
       with:
         path: '${{ github.workspace }}\.ccache'
         key: ${{ runner.os }}-mingw-w64-ccache-${{ github.run_id }}

.github/workflows/backport.yml

@@ -24,7 +24,7 @@ jobs:
         with:
           ref: ${{ github.event.pull_request.head.sha }}
       - name: Create backport PRs
-        uses: korthout/backport-action@v4.2.0
+        uses: korthout/backport-action@v4.5
         with:
           # Config README: https://github.com/korthout/backport-action#backport-action
           pull_description: |-

.github/workflows/clang-tidy.yml

@@ -28,19 +28,14 @@ jobs:
           fetch-depth: 0 # Required for diffing later on
           submodules: "true"
 
-      - name: Setup sccache
-        uses: hendrikmuhs/ccache-action@v1.2.21
-        with:
-          variant: sccache
-
       - name: Install Nix
         uses: cachix/install-nix-action@v31
 
-      - name: Run build
+      - name: Run source generators
         # TODO(@getchoo): Figure out how to make this work with PCH
         run: |
           nix develop --command bash -c '
-            cmake -B build -D Launcher_USE_PCH=OFF -D CMAKE_CXX_COMPILER_LAUNCHER=sccache && cmake --build build
+            cmake -B build -D Launcher_USE_PCH=OFF && cmake --build build --target autogen autorcc
           '
 
       # TODO: Use SARIF after https://github.com/psastras/sarif-rs/issues/638 is fixed
@@ -49,5 +44,5 @@ jobs:
           BASE_REF: ${{ github.event.pull_request.base.sha || github.event.merge_group.base_sha }}
         run: |
           nix develop --command bash -c '
-            git diff -U0 --no-color "$BASE_REF" | clang-tidy-diff.py -p1
+            clang-tidy -verify-config && git diff -U0 --no-color "$BASE_REF" | clang-tidy-diff.py -p1 -quiet -only-check-in-db
           '

.github/workflows/container.yml

@@ -33,7 +33,7 @@ jobs:
           - arch: arm64
             os: ubuntu-24.04-arm
           - arch: amd64
-            os: ubuntu-24.04-arm
+            os: ubuntu-24.04
 
     runs-on: ${{ matrix.os }}
 

.github/workflows/nix.yml

@@ -88,7 +88,7 @@ jobs:
           - os: ubuntu-22.04-arm
             system: aarch64-linux
 
-          - os: macos-14
+          - os: macos-26
             system: aarch64-darwin
 
     runs-on: ${{ matrix.os }}
@@ -103,7 +103,7 @@ jobs:
         # For PRs
       - name: Setup Nix Magic Cache
         if: ${{ github.event_name == 'pull_request' }}
-        uses: DeterminateSystems/magic-nix-cache-action@v13
+        uses: DeterminateSystems/magic-nix-cache-action@v14
         with:
           diagnostic-endpoint: ""
           use-flakehub: false

.github/workflows/release.yml

@@ -94,7 +94,7 @@ jobs:
 
       - name: Create release
         id: create_release
-        uses: softprops/action-gh-release@v2
+        uses: softprops/action-gh-release@v3
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           tag_name: ${{ github.ref }}

.github/workflows/update-flake.yml

@@ -20,14 +20,16 @@ jobs:
 
     steps:
       - uses: actions/checkout@v6
-      - uses: cachix/install-nix-action@1ca7d21a94afc7c957383a2d217460d980de4934 # v31
+      - uses: cachix/install-nix-action@8aa03977d8d733052d78f4e008a241fd1dbf36b3 # v31
 
       - uses: DeterminateSystems/update-flake-lock@v28
         with:
           commit-msg: "chore(nix): update lockfile"
           pr-title: "chore(nix): update lockfile"
           pr-labels: |
-            Linux
+            platform: Linux
-            packaging
+            area: packaging
-            simple change
+            complexity: low
+            priority: low
+            type: robot
             changelog:omit

CMakeLists.txt

@@ -13,6 +13,10 @@ endif()
 ##################################### Set CMake options #####################################
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
+set(CMAKE_AUTOUIC ON)
+set(CMAKE_AUTOGEN_ORIGIN_DEPENDS OFF)
+set(CMAKE_GLOBAL_AUTOGEN_TARGET ON)
+set(CMAKE_GLOBAL_AUTORCC_TARGET ON)
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/")
@@ -179,7 +183,7 @@ set(Launcher_LOGIN_CALLBACK_URL "https://prismlauncher.org/successful-login" CAC
 set(Launcher_LEGACY_FMLLIBS_BASE_URL "https://files.prismlauncher.org/fmllibs/" CACHE STRING "URL for legacy (<=1.5.2) FML Libraries.")
 
 ######## Set version numbers ########
-set(Launcher_VERSION_MAJOR 11)
+set(Launcher_VERSION_MAJOR 12)
 set(Launcher_VERSION_MINOR 0)
 set(Launcher_VERSION_PATCH 0)
 

buildconfig/BuildConfig.cpp.in

@@ -50,6 +50,7 @@ Config::Config()
     LAUNCHER_GIT = "@Launcher_Git@";
     LAUNCHER_APPID = "@Launcher_AppID@";
     LAUNCHER_SVGFILENAME = "@Launcher_SVGFileName@";
+    LAUNCHER_ENVNAME = "@Launcher_ENVName@";
 
     USER_AGENT = "@Launcher_UserAgent@";
 

buildconfig/BuildConfig.h

@@ -54,6 +54,7 @@ class Config {
     QString LAUNCHER_GIT;
     QString LAUNCHER_APPID;
     QString LAUNCHER_SVGFILENAME;
+    QString LAUNCHER_ENVNAME;
 
     /// The major version number.
     int VERSION_MAJOR;
@@ -193,8 +194,10 @@ class Config {
     QString MODRINTH_STAGING_URL = "https://staging-api.modrinth.com/v2";
     QString MODRINTH_PROD_URL = "https://api.modrinth.com/v2";
     QStringList MODRINTH_MRPACK_HOSTS{ "cdn.modrinth.com", "github.com", "raw.githubusercontent.com", "gitlab.com" };
+    QString MODRINTH_DOWNLOAD_HOST = "cdn.modrinth.com";
 
     QString FLAME_BASE_URL = "https://api.curseforge.com/v1";
+    QString FLAME_DOWNLOAD_HOST = "edge.forgecdn.net";
 
     QString versionString() const;
     /**

flake.lock

@@ -18,15 +18,15 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1773964973,
+        "lastModified": 1778443072,
-        "narHash": "sha256-d2Q5VNbc91GloTZNByC4u3JS8Tj5BjfuOF19/vuJ/iM=",
+        "narHash": "sha256-rNDJzV2JTV5SUTwv1cgKZYMdyoUYU9/YfegSaUf3QfY=",
-        "rev": "812b3986fd1568f7a858f97fcf425ad996ba7d25",
+        "rev": "da5ad661ba4e5ef59ba743f0d112cbc30e474f32",
         "type": "tarball",
-        "url": "https://releases.nixos.org/nixos/25.11/nixos-25.11.7849.812b3986fd15/nixexprs.tar.xz"
+        "url": "https://releases.nixos.org/nixos/unstable/nixos-26.05pre995699.da5ad661ba4e/nixexprs.tar.xz"
       },
       "original": {
         "type": "tarball",
-        "url": "https://channels.nixos.org/nixos-25.11/nixexprs.tar.xz"
+        "url": "https://channels.nixos.org/nixos-unstable/nixexprs.tar.xz"
       }
     },
     "root": {

flake.nix

@@ -9,7 +9,7 @@
   };
 
   inputs = {
-    nixpkgs.url = "https://channels.nixos.org/nixos-25.11/nixexprs.tar.xz";
+    nixpkgs.url = "https://channels.nixos.org/nixos-unstable/nixexprs.tar.xz";
 
     libnbtplusplus = {
       url = "github:PrismLauncher/libnbtplusplus";
@@ -42,7 +42,7 @@
 
         let
           pkgs = nixpkgsFor.${system};
-          llvm = pkgs.llvmPackages_19;
+          llvm = pkgs.llvmPackages_22;
         in
 
         {
@@ -85,7 +85,7 @@
 
         let
           pkgs = nixpkgsFor.${system};
-          llvm = pkgs.llvmPackages_19;
+          llvm = pkgs.llvmPackages_22;
           python = pkgs.python3;
           mkShell = pkgs.mkShell.override { inherit (llvm) stdenv; };
 
@@ -189,7 +189,7 @@
         final: prev:
 
         let
-          llvm = final.llvmPackages_19 or prev.llvmPackages_19;
+          llvm = final.llvmPackages_22 or prev.llvmPackages_22;
         in
 
         {

launcher/Application.cpp

@@ -514,12 +514,13 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
         logFile = std::unique_ptr<QFile>(new QFile(logBase.arg(0)));
         if (!logFile->open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) {
             showFatalErrorMessage("The launcher data folder is not writable!",
-                                  QString("The launcher couldn't create a log file - the data folder is not writable.\n"
+                                  QString("The launcher couldn't create a log file - %1.\n"
                                           "\n"
                                           "Make sure you have write permissions to the data folder.\n"
-                                          "(%1)\n"
+                                          "(%2)\n"
                                           "\n"
                                           "The launcher cannot continue until you fix this problem.")
+                                      .arg(logFile->errorString())
                                       .arg(dataPath));
             return;
         }
@@ -577,16 +578,14 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
     }
 
     {
-        bool migrated = false;
+        auto migrated = handleDataMigration(
-
+            dataPath, FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "../../PolyMC"), "PolyMC",
-        if (!migrated)
+            "polymc.cfg");
-            migrated = handleDataMigration(
+        if (!migrated) {
-                dataPath, FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "../../PolyMC"), "PolyMC",
+            handleDataMigration(dataPath,
-                "polymc.cfg");
+                                FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "../../multimc"),
-        if (!migrated)
+                                "MultiMC", "multimc.cfg");
-            migrated = handleDataMigration(
+        }
-                dataPath, FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "../../multimc"), "MultiMC",
-                "multimc.cfg");
     }
 
     {
@@ -626,11 +625,11 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
             if (check.write(payload) == payload.size()) {
                 check.close();
             } else {
-                qWarning() << "Could not write into" << liveCheckFile << "!";
+                qWarning() << "Could not write into" << liveCheckFile << "error:" << check.errorString();
                 check.remove();  // also closes file!
             }
         } else {
-            qWarning() << "Could not open" << liveCheckFile << "for writing!";
+            qWarning() << "Could not open" << liveCheckFile << "for writing:" << check.errorString();
         }
     }
 
@@ -734,6 +733,7 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
         m_settings->registerSetting({ "MinMemAlloc", "MinMemoryAlloc" }, 512);
         m_settings->registerSetting({ "MaxMemAlloc", "MaxMemoryAlloc" }, SysInfo::defaultMaxJvmMem());
         m_settings->registerSetting("PermGen", 128);
+        m_settings->registerSetting("LowMemWarning", true);
 
         // Java Settings
         m_settings->registerSetting("JavaPath", "");
@@ -777,6 +777,7 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
         m_settings->registerSetting("ModDependenciesDisabled", false);
         m_settings->registerSetting("SkipModpackUpdatePrompt", false);
         m_settings->registerSetting("ShowModIncompat", false);
+        m_settings->registerSetting("DownloadGameFilesDuringInstanceCreation", true);
 
         // Minecraft offline player name
         m_settings->registerSetting("LastOfflinePlayerName", "");
@@ -869,6 +870,7 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
             resetIfInvalid(m_settings->registerSetting("LegacyFMLLibsURLOverride", "").get());
         }
 
+        m_settings->registerSetting("MetaRefreshOnLaunch", true);
         m_settings->registerSetting("CloseAfterLaunch", false);
         m_settings->registerSetting("QuitAfterGameStop", false);
 
@@ -933,15 +935,6 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
         qInfo() << "<> Network done.";
     }
 
-    // load translations
-    {
-        m_translations.reset(new TranslationsModel("translations"));
-        auto bcp47Name = m_settings->get("Language").toString();
-        m_translations->selectLanguage(bcp47Name);
-        qInfo() << "Your language is" << bcp47Name;
-        qInfo() << "<> Translations loaded.";
-    }
-
     // Instance icons
     {
         auto setting = APPLICATION->settings()->getSetting("IconsDir");
@@ -1020,8 +1013,13 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
         qInfo() << "<> Cache initialized.";
     }
 
-    // now we have network, download translation updates
+    // load translations
-    m_translations->downloadIndex();
+    {
+        m_translations.reset(new TranslationsModel("translations"));
+        m_translations->downloadIndex();
+        qInfo() << "Your language is" << m_translations->selectedLanguage();
+        qInfo() << "<> Translations loaded.";
+    }
 
     // FIXME: what to do with these?
     m_profilers.insert("jprofiler", std::shared_ptr<BaseProfilerFactory>(new JProfilerFactory()));
@@ -1955,7 +1953,7 @@ bool Application::handleDataMigration(const QString& currentData,
     auto setDoNotMigrate = [&nomigratePath] {
         QFile file(nomigratePath);
         if (!file.open(QIODevice::WriteOnly)) {
-            qWarning() << "setDoNotMigrate failed; Failed to open file '" << file.fileName() << "' for writing!";
+            qWarning() << "setDoNotMigrate failed; Failed to open file" << file.fileName() << "for writing:" << file.errorString();
         }
     };
 

launcher/BaseVersionList.h

@@ -63,7 +63,7 @@ class BaseVersionList : public QAbstractListModel {
      * The task returned by this function should reset the model when it's done.
      * \return A pointer to a task that reloads the version list.
      */
-    virtual Task::Ptr getLoadTask() = 0;
+    virtual Task::Ptr getLoadTask(bool forceReload = false) = 0;
 
     //! Checks whether or not the list is loaded. If this returns false, the list should be
     // loaded.

launcher/CMakeLists.txt

@@ -260,6 +260,8 @@ set(MINECRAFT_SOURCES
     minecraft/launch/ClaimAccount.h
     minecraft/launch/CreateGameFolders.cpp
     minecraft/launch/CreateGameFolders.h
+    minecraft/launch/EnsureAvailableMemory.cpp
+    minecraft/launch/EnsureAvailableMemory.h
     minecraft/launch/EnsureOfflineLibraries.cpp
     minecraft/launch/EnsureOfflineLibraries.h
     minecraft/launch/ModMinecraftJar.cpp
@@ -1065,6 +1067,8 @@ SET(LAUNCHER_SOURCES
     ui/dialogs/ImportResourceDialog.h
     ui/dialogs/MSALoginDialog.cpp
     ui/dialogs/MSALoginDialog.h
+    ui/dialogs/NetworkJobFailedDialog.cpp
+    ui/dialogs/NetworkJobFailedDialog.h
     ui/dialogs/NewComponentDialog.cpp
     ui/dialogs/NewComponentDialog.h
     ui/dialogs/NewInstanceDialog.cpp
@@ -1202,77 +1206,6 @@ if(WIN32)
     )
 endif()
 
-qt_wrap_ui(LAUNCHER_UI
-    ui/MainWindow.ui
-    ui/setupwizard/PasteWizardPage.ui
-    ui/setupwizard/AutoJavaWizardPage.ui
-    ui/setupwizard/LoginWizardPage.ui
-    ui/pages/global/AccountListPage.ui
-    ui/pages/global/JavaPage.ui
-    ui/pages/global/LauncherPage.ui
-    ui/pages/global/APIPage.ui
-    ui/pages/global/ProxyPage.ui
-    ui/pages/global/ExternalToolsPage.ui
-    ui/pages/instance/ExternalResourcesPage.ui
-    ui/pages/instance/NotesPage.ui
-    ui/pages/instance/LogPage.ui
-    ui/pages/instance/ServersPage.ui
-    ui/pages/instance/OtherLogsPage.ui
-    ui/pages/instance/VersionPage.ui
-    ui/pages/instance/ManagedPackPage.ui
-    ui/pages/instance/WorldListPage.ui
-    ui/pages/instance/ScreenshotsPage.ui
-    ui/pages/modplatform/atlauncher/AtlOptionalModDialog.ui
-    ui/pages/modplatform/atlauncher/AtlPage.ui
-    ui/pages/modplatform/CustomPage.ui
-    ui/pages/modplatform/ResourcePage.ui
-    ui/pages/modplatform/flame/FlamePage.ui
-    ui/pages/modplatform/legacy_ftb/Page.ui
-    ui/pages/modplatform/import_ftb/ImportFTBPage.ui
-    ui/pages/modplatform/ImportPage.ui
-    ui/pages/modplatform/OptionalModDialog.ui
-    ui/pages/modplatform/ftb/FtbPage.ui
-    ui/pages/modplatform/modrinth/ModrinthPage.ui
-    ui/pages/modplatform/technic/TechnicPage.ui
-    ui/widgets/CustomCommands.ui
-    ui/widgets/EnvironmentVariables.ui
-    ui/widgets/InfoFrame.ui
-    ui/widgets/ModFilterWidget.ui
-    ui/widgets/SubTaskProgressBar.ui
-    ui/widgets/AppearanceWidget.ui
-    ui/widgets/MinecraftSettingsWidget.ui
-    ui/widgets/JavaSettingsWidget.ui
-    ui/dialogs/CopyInstanceDialog.ui
-    ui/dialogs/CreateShortcutDialog.ui
-    ui/dialogs/ProfileSetupDialog.ui
-    ui/dialogs/ProgressDialog.ui
-    ui/dialogs/NewInstanceDialog.ui
-    ui/dialogs/NewComponentDialog.ui
-    ui/dialogs/NewsDialog.ui
-    ui/dialogs/ProfileSelectDialog.ui
-    ui/dialogs/ExportInstanceDialog.ui
-    ui/dialogs/ExportPackDialog.ui
-    ui/dialogs/ExportToModListDialog.ui
-    ui/dialogs/IconPickerDialog.ui
-    ui/dialogs/ImportResourceDialog.ui
-    ui/dialogs/MSALoginDialog.ui
-    ui/dialogs/AboutDialog.ui
-    ui/dialogs/ReviewMessageBox.ui
-    ui/dialogs/ScrollMessageBox.ui
-    ui/dialogs/BlockedModsDialog.ui
-    ui/dialogs/ChooseProviderDialog.ui
-    ui/dialogs/skins/SkinManageDialog.ui
-    ui/dialogs/ChooseOfflineNameDialog.ui
-)
-
-qt_wrap_ui(PRISM_UPDATE_UI
-    ui/dialogs/UpdateAvailableDialog.ui
-)
-
-if (NOT Apple)
-    set (LAUNCHER_UI ${LAUNCHER_UI} ${PRISM_UPDATE_UI})
-endif()
-
 qt_add_resources(LAUNCHER_RESOURCES
     resources/backgrounds/backgrounds.qrc
     resources/multimc/multimc.qrc
@@ -1291,12 +1224,6 @@ qt_add_resources(LAUNCHER_RESOURCES
     "${CMAKE_CURRENT_BINARY_DIR}/../${Launcher_Branding_LogoQRC}"
 )
 
-qt_wrap_ui(PRISMUPDATER_UI
-    updater/prismupdater/SelectReleaseDialog.ui
-    ui/widgets/SubTaskProgressBar.ui
-    ui/dialogs/ProgressDialog.ui
-)
-
 ######## Windows resource files ########
 if(WIN32)
     set(LAUNCHER_RCS ${CMAKE_CURRENT_BINARY_DIR}/../${Launcher_Branding_WindowsRC})
@@ -1316,7 +1243,7 @@ endif()
 ####### Targets ########
 
 # Add executable
-add_library(Launcher_logic STATIC ${LOGIC_SOURCES} ${LAUNCHER_SOURCES} ${LAUNCHER_UI} ${LAUNCHER_RESOURCES})
+add_library(Launcher_logic STATIC ${LOGIC_SOURCES} ${LAUNCHER_SOURCES} ${LAUNCHER_RESOURCES})
 target_include_directories(Launcher_logic PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 target_compile_definitions(Launcher_logic PUBLIC LAUNCHER_APPLICATION)
 
@@ -1436,7 +1363,7 @@ endif()
 
 if(Launcher_BUILD_UPDATER)
     # Updater
-    add_library(prism_updater_logic STATIC ${PRISMUPDATER_SOURCES} ${TASKS_SOURCES} ${PRISMUPDATER_UI})
+    add_library(prism_updater_logic STATIC ${PRISMUPDATER_SOURCES} ${TASKS_SOURCES})
     target_include_directories(prism_updater_logic PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 
     if(${Launcher_USE_PCH})
@@ -1564,8 +1491,10 @@ if (CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
     target_compile_options(Launcher_logic PRIVATE /wd4100) # C4100 - unused parameter
     target_compile_options(${Launcher_Name} PRIVATE /wd4100) # C4100 - unused parameter
 else()
-    target_compile_options(Launcher_logic PRIVATE -Wno-unused-parameter -Wno-missing-field-initializers)
+    # sfinae-incomplete is a new GCC warning and triggers in Qt headers
-    target_compile_options(${Launcher_Name} PRIVATE -Wno-unused-parameter -Wno-missing-field-initializers)
+    # no-unknown-warning-option so that compilers that don't have sfinae-incomplete don't error
+    target_compile_options(Launcher_logic PRIVATE -Wno-unused-parameter -Wno-missing-field-initializers -Wno-unknown-warning-option -Wno-sfinae-incomplete)
+    target_compile_options(${Launcher_Name} PRIVATE -Wno-unused-parameter -Wno-missing-field-initializers -Wno-unknown-warning-option -Wno-sfinae-incomplete)
 endif()
 
 #### The bundle mess! ####

launcher/FileSystem.cpp

@@ -36,6 +36,7 @@
  */
 
 #include "FileSystem.h"
+#include <qcontainerfwd.h>
 #include <QPair>
 
 #include "BuildConfig.h"
@@ -683,6 +684,32 @@ bool deletePath(QString path)
     return err.value() == 0;
 }
 
+bool deleteContents(const QString& path)
+{
+    const QFileInfo info(path);
+    if (!info.exists()) {
+        return true;
+    }
+    if (!info.isDir()) {
+        qWarning() << "Attempted to delete contents of non-directory path:" << path;
+        return false;
+    }
+
+    bool ret = true;
+
+    for (const auto& entry : fs::directory_iterator(StringUtils::toStdString(path))) {
+        std::error_code err;
+
+        fs::remove_all(entry.path(), err);
+        if (err.value() != 0) {
+            qWarning().nospace() << "Could not delete directory entry " << entry.path() << ": " << QString::fromStdString(err.message());
+            ret = false;
+        }
+    }
+
+    return ret;
+}
+
 bool trash(QString path, QString* pathInTrash)
 {
     // FIXME: Figure out trash in Flatpak. Qt seemingly doesn't use the Trash portal
@@ -796,68 +823,33 @@ QString NormalizePath(QString path)
     }
 }
 
-static const QString BAD_WIN_CHARS = "<>:\"|?*\r\n";
+namespace {
-static const QString BAD_NTFS_CHARS = "<>:\"|?*";
+const QString g_badChars = "<>:\"|?*\r\n!";
-static const QString BAD_HFS_CHARS = ":";
+QString removeChars(QString source, QChar replace, const QString& extraChars = "")
-
-static const QString BAD_FILENAME_CHARS = BAD_WIN_CHARS + "\\/";
-
-QString RemoveInvalidFilenameChars(QString string, QChar replaceWith)
 {
-    for (int i = 0; i < string.length(); i++)
+    auto badChars = g_badChars;
-        if (string.at(i) < ' ' || BAD_FILENAME_CHARS.contains(string.at(i)))
+    if (!extraChars.isEmpty()) {
-            string[i] = replaceWith;
+        badChars += extraChars;
-    return string;
-}
-
-QString RemoveInvalidPathChars(QString path, QChar replaceWith)
-{
-    QString invalidChars;
-#ifdef Q_OS_WIN
-    invalidChars = BAD_WIN_CHARS;
-#endif
-
-    // the null character is ignored in this check as it was not a problem until now
-    switch (statFS(path).fsType) {
-        case FilesystemType::FAT:  // similar to NTFS
-        /* fallthrough */
-        case FilesystemType::NTFS:
-        /* fallthrough */
-        case FilesystemType::REFS:  // similar to NTFS(should be available only on windows)
-            invalidChars += BAD_NTFS_CHARS;
-            break;
-        // case FilesystemType::EXT:
-        // case FilesystemType::EXT_2_OLD:
-        // case FilesystemType::EXT_2_3_4:
-        // case FilesystemType::XFS:
-        // case FilesystemType::BTRFS:
-        // case FilesystemType::NFS:
-        // case FilesystemType::ZFS:
-        case FilesystemType::APFS:
-        /* fallthrough */
-        case FilesystemType::HFS:
-        /* fallthrough */
-        case FilesystemType::HFSPLUS:
-        /* fallthrough */
-        case FilesystemType::HFSX:
-            invalidChars += BAD_HFS_CHARS;
-            break;
-        // case FilesystemType::FUSEBLK:
-        // case FilesystemType::F2FS:
-        // case FilesystemType::UNKNOWN:
-        default:
-            break;
     }
 
-    if (invalidChars.size() != 0) {
+    for (auto& c : source) {
-        for (int i = 0; i < path.length(); i++) {
+        if (c.unicode() < 0x20 || !c.isPrint() || badChars.contains(c)) {
-            if (path.at(i) < ' ' || invalidChars.contains(path.at(i))) {
+            c = replace;
-                path[i] = replaceWith;
-            }
         }
     }
 
-    return path;
+    return source;
+}
+}  // namespace
+
+QString RemoveInvalidFilenameChars(QString string, QChar replaceWith)
+{
+    return removeChars(std::move(string), replaceWith, "\\/");
+}
+
+QString RemoveInvalidPathChars(QString string, QChar replaceWith)
+{
+    return removeChars(std::move(string), replaceWith);
 }
 
 QString DirNameFromString(QString string, QString inDir)
@@ -954,7 +946,7 @@ QString createShortcut(QString destination, QString target, QStringList args, QS
         return QString();
     }
     if (!info.open(QIODevice::WriteOnly | QIODevice::Text)) {
-        qWarning() << "Failed to open file" << info.fileName() << "for writing!";
+        qWarning() << "Failed to open file" << info.fileName() << "for writing:" << info.errorString();
         return QString();
     }
 
@@ -965,7 +957,7 @@ QString createShortcut(QString destination, QString target, QStringList args, QS
 
     QFile f(exec);
     if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
-        qWarning() << "Failed to open file" << f.fileName() << "for writing!";
+        qWarning() << "Failed to open file" << f.fileName() << "for writing:" << f.errorString();
         return QString();
     }
     QTextStream stream(&f);
@@ -1010,7 +1002,7 @@ QString createShortcut(QString destination, QString target, QStringList args, QS
         destination += ".desktop";
     QFile f(destination);
     if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
-        qWarning() << "Failed to open file '" << f.fileName() << "' for writing!";
+        qWarning() << "Failed to open file" << f.fileName() << "for writing:" << f.errorString();
         return QString();
     }
     QTextStream stream(&f);

launcher/FileSystem.h

@@ -291,6 +291,13 @@ bool move(const QString& source, const QString& dest);
  */
 bool deletePath(QString path);
 
+/**
+ * Delete a folder's contents recursively but not the folder itself.
+ * @param path The path to the folder.
+ * @return Whether the deletion was completely successful.
+ */
+bool deleteContents(const QString& path);
+
 bool removeFiles(QStringList listFile);
 
 /**

launcher/HardwareInfo.cpp

@@ -18,79 +18,45 @@
 
 #include "HardwareInfo.h"
 
-#include <QCoreApplication>
+#include <QDebug>
-#include <QOffscreenSurface>
+#include <QStringList>
-#include <QOpenGLFunctions>
-#include <QProcessEnvironment>
-
-#ifndef Q_OS_MACOS
-#include <QVulkanInstance>
-#include <QVulkanWindow>
-#endif
 
+#if defined(Q_OS_MACOS) || defined(Q_OS_LINUX)
 namespace {
-bool vulkanInfo(QStringList& out)
+QString afterColon(QString str)
 {
-    if (!QProcessEnvironment::systemEnvironment().value(QStringLiteral("LAUNCHER_DISABLE_GLVULKAN")).isEmpty()) {
+    return str.remove(0, str.indexOf(':') + 2).trimmed();
-        return false;
-    }
-#ifndef Q_OS_MACOS
-    QVulkanInstance inst;
-    if (!inst.create()) {
-        qWarning() << "Vulkan instance creation failed, VkResult:" << inst.errorCode();
-        out << "Couldn't get Vulkan device information";
-        return false;
-    }
-
-    QVulkanWindow window;
-    window.setVulkanInstance(&inst);
-
-    for (auto device : window.availablePhysicalDevices()) {
-        const auto supportedVulkanVersion = QVersionNumber(VK_API_VERSION_MAJOR(device.apiVersion), VK_API_VERSION_MINOR(device.apiVersion),
-                                                           VK_API_VERSION_PATCH(device.apiVersion));
-        out << QString("Found Vulkan device: %1 (API version %2)").arg(device.deviceName).arg(supportedVulkanVersion.toString());
-    }
-#endif
-
-    return true;
 }
 
-bool openGlInfo(QStringList& out)
+template <typename F>
+bool readFromOutput(const char* command, F function)
 {
-    if (!QProcessEnvironment::systemEnvironment().value(QStringLiteral("LAUNCHER_DISABLE_GLVULKAN")).isEmpty()) {
+    FILE* file = popen(command, "r");  // NOLINT(*-command-processor)
-        return false;
+    if (!file) {
-    }
+        qWarning().nospace() << "Could not execute command '" << command << "': " << strerror(errno);
-    QOpenGLContext ctx;
-    if (!ctx.create()) {
-        qWarning() << "OpenGL context creation failed";
-        out << "Couldn't get OpenGL device information";
         return false;
     }
 
-    QOffscreenSurface surface;
+    constexpr size_t bufferSize = 512;
-    surface.create();
+    std::array<char, bufferSize> buffer{};
-    ctx.makeCurrent(&surface);
+    while (fgets(buffer.data(), bufferSize, file) != nullptr) {
+        function(buffer.data());
+    }
 
-    auto* f = ctx.functions();
+    const int exitCode = pclose(file);
-    f->initializeOpenGLFunctions();
+    if (exitCode != 0) {
+        if (exitCode == -1) {
+            qWarning().nospace() << "Could not close stream for command '" << command << "': " << strerror(errno);
+        } else {
+            qWarning().nospace() << "Command '" << command << "' exited with code " << exitCode;
+        }
 
-    auto toQString = [](const GLubyte* str) { return QString(reinterpret_cast<const char*>(str)); };
+        return false;
-    out << "OpenGL driver vendor: " + toQString(f->glGetString(GL_VENDOR));
+    }
-    out << "OpenGL renderer: " + toQString(f->glGetString(GL_RENDERER));
-    out << "OpenGL driver version: " + toQString(f->glGetString(GL_VERSION));
 
     return true;
 }
 }  // namespace
-
-#ifndef Q_OS_LINUX
-QStringList HardwareInfo::gpuInfo()
-{
-    QStringList info;
-    vulkanInfo(info);
-    openGlInfo(info);
-    return info;
-}
 #endif
 
 #ifdef Q_OS_WINDOWS
@@ -99,7 +65,11 @@ QStringList HardwareInfo::gpuInfo()
 #endif
 #include <QSettings>
 
-#include "windows.h"
+#include <dxgi1_6.h>
+#include <windows.h>
+
+#include <wrl/client.h>
+using Microsoft::WRL::ComPtr;
 
 QString HardwareInfo::cpuInfo()
 {
@@ -135,16 +105,42 @@ uint64_t HardwareInfo::availableRamMiB()
     return 0;
 }
 
+QStringList HardwareInfo::gpuInfo()
+{
+    ComPtr<IDXGIFactory6> factory;
+    HRESULT hr = CreateDXGIFactory1(IID_PPV_ARGS(&factory));
+    if (FAILED(hr)) {
+        qWarning() << "Could not create DXGI factory:" << Qt::hex << hr;
+        return { "GPU discovery failed: could not create DXGI factory" };
+    }
+
+    UINT i = 0;
+    ComPtr<IDXGIAdapter> adapter;
+    QStringList out;
+    while (factory->EnumAdapterByGpuPreference(i, DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE, IID_PPV_ARGS(&adapter)) != DXGI_ERROR_NOT_FOUND) {
+        DXGI_ADAPTER_DESC desc;
+        hr = adapter->GetDesc(&desc);
+        if (SUCCEEDED(hr)) {
+            out << "GPU: " + QString::fromWCharArray(desc.Description);  // NOLINT(*-pro-bounds-array-to-pointer-decay, *-no-array-decay)
+        } else {
+            qWarning() << "Could not get DXGI adapter description:" << Qt::hex << hr;
+        }
+
+        ++i;
+    }
+
+    return out;
+}
+
 #elif defined(Q_OS_MACOS)
-#include "mach/mach.h"
 #include "sys/sysctl.h"
 
 QString HardwareInfo::cpuInfo()
 {
-    std::array<char, 512> buffer;
+    std::array<char, 512> buffer{};
     size_t bufferSize = buffer.size();
     if (sysctlbyname("machdep.cpu.brand_string", &buffer, &bufferSize, nullptr, 0) == 0) {
-        return QString(buffer.data());
+        return { buffer.data() };
     }
 
     qWarning() << "Could not get CPU model: sysctlbyname";
@@ -153,7 +149,7 @@ QString HardwareInfo::cpuInfo()
 
 uint64_t HardwareInfo::totalRamMiB()
 {
-    uint64_t memsize;
+    uint64_t memsize = 0;
     size_t memsizeSize = sizeof memsize;
     if (sysctlbyname("hw.memsize", &memsize, &memsizeSize, nullptr, 0) == 0) {
         // transforming bytes -> mib
@@ -166,36 +162,62 @@ uint64_t HardwareInfo::totalRamMiB()
 
 uint64_t HardwareInfo::availableRamMiB()
 {
-    mach_port_t host_port = mach_host_self();
+    return 0;
-    mach_msg_type_number_t count = HOST_VM_INFO64_COUNT;
+}
 
-    vm_statistics64_data_t vm_stats;
+MacOSHardwareInfo::MemoryPressureLevel MacOSHardwareInfo::memoryPressureLevel()
-
+{
-    if (host_statistics64(host_port, HOST_VM_INFO64, reinterpret_cast<host_info64_t>(&vm_stats), &count) == KERN_SUCCESS) {
+    uint32_t level = 0;
-        // transforming bytes -> mib
+    size_t levelSize = sizeof level;
-        return (vm_stats.free_count + vm_stats.inactive_count) * vm_page_size / 1024 / 1024;
+    if (sysctlbyname("kern.memorystatus_vm_pressure_level", &level, &levelSize, nullptr, 0) == 0) {
+        return static_cast<MemoryPressureLevel>(level);
     }
 
-    qWarning() << "Could not get available RAM: host_statistics64";
+    qWarning() << "Could not get memory pressure level: sysctlbyname";
-    return 0;
+    return MemoryPressureLevel::Normal;
+}
+
+QString MacOSHardwareInfo::memoryPressureLevelName()
+{
+    // The names are internal, users refer to levels by their graph colors in Activity Monitor
+    switch (memoryPressureLevel()) {
+        case MemoryPressureLevel::Normal:
+            return "Green";
+        case MemoryPressureLevel::Warning:
+            return "Yellow";
+        case MemoryPressureLevel::Critical:
+            return "Red";
+        default:
+            Q_ASSERT(false);
+            return "";
+    }
+}
+
+QStringList HardwareInfo::gpuInfo()
+{
+    QStringList out;
+    const bool success = readFromOutput("system_profiler SPDisplaysDataType", [&](const QString& str) {
+        // Chipset Model: Intel HD Graphics 620
+        if (str.contains("Chipset Model")) {
+            out << "GPU: " + afterColon(str);
+        }
+    });
+    if (!success) {
+        return { "GPU discovery failed: could not read from system_profiler" };
+    }
+
+    return out;
 }
 
 #elif defined(Q_OS_LINUX)
 #include <fstream>
 
-namespace {
-QString afterColon(QString& str)
-{
-    return str.remove(0, str.indexOf(':') + 2).trimmed();
-}
-}  // namespace
-
 QString HardwareInfo::cpuInfo()
 {
     std::ifstream cpuin("/proc/cpuinfo");
     for (std::string line; std::getline(cpuin, line);) {
         // model name      : AMD Ryzen 7 5800X 8-Core Processor
-        if (QString str = QString::fromStdString(line); str.startsWith("model name")) {
+        if (const QString str = QString::fromStdString(line); str.startsWith("model name")) {
             return afterColon(str);
         }
     }
@@ -204,12 +226,13 @@ QString HardwareInfo::cpuInfo()
     return "unknown";
 }
 
-uint64_t readMemInfo(QString searchTarget)
+namespace {
+uint64_t readMemInfo(const QString& searchTarget)
 {
     std::ifstream memin("/proc/meminfo");
     for (std::string line; std::getline(memin, line);) {
         // MemTotal:       16287480 kB
-        if (QString str = QString::fromStdString(line); str.startsWith(searchTarget)) {
+        if (const QString str = QString::fromStdString(line); str.startsWith(searchTarget)) {
             bool ok = false;
             const uint total = str.simplified().section(' ', 1, 1).toUInt(&ok);
             if (!ok) {
@@ -225,6 +248,7 @@ uint64_t readMemInfo(QString searchTarget)
     qWarning() << "Could not read /proc/meminfo: search target not found:" << searchTarget;
     return 0;
 }
+}  // namespace
 
 uint64_t HardwareInfo::totalRamMiB()
 {
@@ -238,52 +262,50 @@ uint64_t HardwareInfo::availableRamMiB()
 
 QStringList HardwareInfo::gpuInfo()
 {
-    QStringList list;
-    const bool vulkanSuccess = vulkanInfo(list);
-    const bool openGlSuccess = openGlInfo(list);
-    if (vulkanSuccess || openGlSuccess) {
-        return list;
-    }
-
-    std::array<char, 512> buffer;
-    FILE* lspci = popen("lspci -k", "r");
-
-    if (!lspci) {
-        return { "Could not detect GPUs: lspci is not present" };
-    }
-
     bool readingGpuInfo = false;
-    QString currentModel = "";
+    QString gpu;
-    while (fgets(buffer.data(), 512, lspci) != nullptr) {
+    QString driverInUse = "NONE";
-        QString str(buffer.data());
+    QString driversAvailable = "NONE";
+    QStringList out;
+
+    const bool success = readFromOutput("lspci -k", [&](const QString& str) {
         // clang-format off
         // 04:00.0 VGA compatible controller: Advanced Micro Devices, Inc. [AMD/ATI] Ellesmere [Radeon RX 470/480/570/570X/580/580X/590] (rev e7)
         // Subsystem: Sapphire Technology Limited Radeon RX 580 Pulse 4GB
         // Kernel driver in use: amdgpu
         // Kernel modules: amdgpu
         // clang-format on
-        if (str.contains("VGA compatible controller")) {
+        if (str.contains("VGA compatible controller") || str.contains("3D controller")) {
             readingGpuInfo = true;
         } else if (!str.startsWith('\t')) {
+            if (readingGpuInfo) {
+                out << QString("GPU: %1 (driver in use: %2; drivers available: %3)").arg(gpu, driverInUse, driversAvailable);
+                driverInUse = "NONE";
+                driversAvailable = "NONE";
+            }
             readingGpuInfo = false;
         }
+
         if (!readingGpuInfo) {
-            continue;
+            return;
         }
 
+        const QString value = afterColon(str);
         if (str.contains("Subsystem")) {
-            currentModel = "Found GPU: " + afterColon(str);
+            gpu = value;
         }
         if (str.contains("Kernel driver in use")) {
-            currentModel += " (using driver " + afterColon(str);
+            driverInUse = value;
         }
         if (str.contains("Kernel modules")) {
-            currentModel += ", available drivers: " + afterColon(str) + ")";
+            driversAvailable = value;
-            list.append(currentModel);
         }
+    });
+    if (!success) {
+        return { "GPU discovery failed: could not read from lspci" };
     }
-    pclose(lspci);
+
-    return list;
+    return out;
 }
 
 #else
@@ -298,19 +320,20 @@ QString HardwareInfo::cpuInfo()
 
 uint64_t HardwareInfo::totalRamMiB()
 {
-    char buff[512];
+    uint64_t out = 0;
-    FILE* fp = popen("sysctl hw.physmem", "r");
-    if (fp != nullptr) {
-        if (fgets(buff, 512, fp) != nullptr) {
-            std::string str(buff);
-            uint64_t mem = std::stoull(str.substr(12, std::string::npos));
 
-            // transforming kib -> mib
+    const bool success = readFromOutput("sysctl hw.physmem", [&](const QString& str) {
-            return mem / 1024;
+        const uint64_t mem = str.mid(12).toULong();
-        }
+
+        // transforming kib -> mib
+        out = mem / 1024;
+    });
+    if (!success) {
+        qWarning() << "Could not get total RAM: could not read from sysctl";
+        return 0;
     }
 
-    return 0;
+    return out;
 }
 
 #else
@@ -325,4 +348,8 @@ uint64_t HardwareInfo::availableRamMiB()
     return 0;
 }
 
+QStringList HardwareInfo::gpuInfo()
+{
+    return { "GPU discovery failed: not implemented for this OS" };
+}
 #endif

launcher/HardwareInfo.h

@@ -27,3 +27,16 @@ uint64_t totalRamMiB();
 uint64_t availableRamMiB();
 QStringList gpuInfo();
 }  // namespace HardwareInfo
+
+#ifdef Q_OS_MACOS
+namespace MacOSHardwareInfo {
+enum class MemoryPressureLevel : uint8_t {
+    Normal = 1,
+    Warning = 2,
+    Critical = 4,
+};
+
+MemoryPressureLevel memoryPressureLevel();
+QString memoryPressureLevelName();
+}  // namespace MacOSHardwareInfo
+#endif

launcher/InstanceCreationTask.cpp

@@ -3,6 +3,7 @@
 #include <QDebug>
 #include <QFile>
 
+#include "Application.h"
 #include "InstanceTask.h"
 #include "minecraft/MinecraftLoadAndCheck.h"
 #include "tasks/SequentialTask.h"
@@ -18,7 +19,7 @@ bool InstanceCreationTask::abort()
         return m_gameFilesTask->abort();
     }
 
-    return true;
+    return InstanceTask::abort();
 }
 
 void InstanceCreationTask::executeTask()
@@ -38,8 +39,9 @@ void InstanceCreationTask::executeTask()
 
     m_instance = createInstance();
     if (!m_instance) {
-        if (m_abort)
+        if (m_abort) {
             return;
+        }
 
         qWarning() << "Instance creation failed!";
         if (!m_error_message.isEmpty()) {
@@ -63,8 +65,9 @@ void InstanceCreationTask::executeTask()
         qDebug() << "Removing old files";
 
         for (const QString& path : m_filesToRemove) {
-            if (!QFile::exists(path))
+            if (!QFile::exists(path)) {
                 continue;
+            }
 
             qDebug() << "Removing" << path;
 
@@ -81,6 +84,10 @@ void InstanceCreationTask::executeTask()
     }
 
     if (!m_abort) {
+        if (!APPLICATION->settings()->get("DownloadGameFilesDuringInstanceCreation").toBool()) {
+            emitSucceeded();
+            return;
+        }
         setAbortable(true);
         setAbortButtonText(tr("Skip"));
         qDebug() << "Downloading game files";
@@ -110,7 +117,7 @@ void InstanceCreationTask::executeTask()
     }
 }
 
-void InstanceCreationTask::scheduleToDelete(QWidget* parent, QDir dir, QString path, bool checkDisabled)
+void InstanceCreationTask::scheduleToDelete(QWidget* parent, const QDir& dir, const QString& path, bool checkDisabled)
 {
     if (path.isEmpty()) {
         return;

launcher/InstanceCreationTask.h

@@ -38,7 +38,7 @@ class InstanceCreationTask : public InstanceTask {
 
    protected:
     void setError(const QString& message) { m_error_message = message; };
-    void scheduleToDelete(QWidget* parent, QDir dir, QString path, bool checkDisabled = false);
+    void scheduleToDelete(QWidget* parent, const QDir& dir, const QString& path, bool checkDisabled = false);
 
    protected:
     bool m_abort = false;

launcher/InstanceList.cpp

@@ -924,23 +924,23 @@ class InstanceStaging : public Task {
         connect(child, &Task::progress, this, &InstanceStaging::setProgress);
         connect(child, &Task::stepProgress, this, &InstanceStaging::propagateStepProgress);
         connect(&m_backoffTimer, &QTimer::timeout, this, &InstanceStaging::childSucceeded);
-        m_backoffTimer.setSingleShot(true);
     }
 
-    virtual ~InstanceStaging() {}
+    ~InstanceStaging() override = default;
 
     // FIXME/TODO: add ability to abort during instance commit retries
     bool abort() override
     {
-        if (!canAbort())
+        if (!canAbort()) {
             return false;
+        }
 
         return m_child->abort();
     }
     bool canAbort() const override { return (m_child && m_child->canAbort()); }
 
    protected:
-    virtual void executeTask() override
+    void executeTask() override
     {
         if (m_stagingPath.isNull()) {
             emitFailed(tr("Could not create staging folder"));
@@ -954,10 +954,8 @@ class InstanceStaging : public Task {
    private slots:
     void childSucceeded()
     {
-        if (!isRunning())
-            return;
         unsigned sleepTime = backoff();
-        if (m_parent->commitStagedInstance(m_stagingPath, *m_child.get(), m_child->group(), *m_child.get())) {
+        if (m_parent->commitStagedInstance(m_stagingPath, *m_child, m_child->group(), *m_child)) {
             m_backoffTimer.stop();
             emitSucceeded();
             return;

launcher/LaunchController.cpp

@@ -40,6 +40,7 @@
 #include "minecraft/auth/AccountData.h"
 #include "minecraft/auth/AccountList.h"
 
+#include "net/NetUtils.h"
 #include "ui/InstanceWindow.h"
 #include "ui/dialogs/CustomMessageBox.h"
 #include "ui/dialogs/MSALoginDialog.h"
@@ -50,7 +51,7 @@
 #include <QInputDialog>
 #include <QList>
 #include <QPushButton>
-#include <QRegularExpression>
+#include <utility>
 
 #include "BuildConfig.h"
 #include "JavaCommon.h"
@@ -82,9 +83,9 @@ void LaunchController::decideAccount()
     }
 
     // Select the account to use. If the instance has a specific account set, that will be used. Otherwise, the default account will be used
-    auto accounts = APPLICATION->accounts();
+    auto* accounts = APPLICATION->accounts();
-    auto instanceAccountId = m_instance->settings()->get("InstanceAccountId").toString();
+    const auto instanceAccountId = m_instance->settings()->get("InstanceAccountId").toString();
-    auto instanceAccountIndex = accounts->findAccountByProfileId(instanceAccountId);
+    const auto instanceAccountIndex = accounts->findAccountByProfileId(instanceAccountId);
     if (instanceAccountIndex == -1 || instanceAccountId.isEmpty()) {
         m_accountToUse = accounts->defaultAccount();
     } else {
@@ -109,7 +110,7 @@ void LaunchController::decideAccount()
         }
     }
 
-    if (!m_accountToUse) {
+    if (!m_accountToUse && accounts->anyAccountIsValid()) {
         // If no default account is set, ask the user which one to use.
         ProfileSelectDialog selectDialog(tr("Which account would you like to use?"), ProfileSelectDialog::GlobalDefaultCheckbox,
                                          m_parentWidget);
@@ -133,15 +134,7 @@ LaunchDecision LaunchController::decideLaunchMode()
         return LaunchDecision::Continue;
     }
 
-    if (m_wantedLaunchMode == LaunchMode::Normal) {
+    const auto* accounts = APPLICATION->accounts();
-        if (m_accountToUse->shouldRefresh() || m_accountToUse->accountState() == AccountState::Offline) {
-            // Force account refresh on the account used to launch the instance updating the AccountState
-            // only on first try and if it is not meant to be offline
-            m_accountToUse->refresh();
-        }
-    }
-
-    const auto accounts = APPLICATION->accounts();
     MinecraftAccountPtr accountToCheck = nullptr;
 
     if (m_accountToUse->accountType() != AccountType::Offline) {
@@ -163,7 +156,9 @@ LaunchDecision LaunchController::decideLaunchMode()
     }
 
     auto state = accountToCheck->accountState();
-    if (state == AccountState::Unchecked || state == AccountState::Errored) {
+    const bool needsRefresh =
+        m_wantedLaunchMode == LaunchMode::Normal && (state == AccountState::Offline || accountToCheck->shouldRefresh());
+    if (state == AccountState::Unchecked || state == AccountState::Errored || needsRefresh) {
         accountToCheck->refresh();
         state = AccountState::Working;
     }
@@ -213,7 +208,7 @@ LaunchDecision LaunchController::decideLaunchMode()
     return LaunchDecision::Abort;
 }
 
-bool LaunchController::askPlayDemo()
+bool LaunchController::askPlayDemo() const
 {
     QMessageBox box(m_parentWidget);
     box.setWindowTitle(tr("Play demo?"));
@@ -223,21 +218,22 @@ bool LaunchController::askPlayDemo()
     text += tr("\n\nDo you want to play the demo?");
     box.setText(text);
     box.setIcon(QMessageBox::Warning);
-    auto demoButton = box.addButton(tr("Play Demo"), QMessageBox::ButtonRole::YesRole);
+    const auto* demoButton = box.addButton(tr("Play Demo"), QMessageBox::ButtonRole::YesRole);
-    auto cancelButton = box.addButton(tr("Cancel"), QMessageBox::ButtonRole::NoRole);
+    auto* cancelButton = box.addButton(tr("Cancel"), QMessageBox::ButtonRole::NoRole);
     box.setDefaultButton(cancelButton);
 
     box.exec();
     return box.clickedButton() == demoButton;
 }
 
-QString LaunchController::askOfflineName(QString playerName, bool* ok)
+QString LaunchController::askOfflineName(const QString& playerName, bool* ok)
 {
     if (ok != nullptr) {
         *ok = false;
     }
 
-    QString message;
+    QString title, message;
+    title = tr("Player name");
     switch (m_actualLaunchMode) {
         case LaunchMode::Normal:
             Q_ASSERT(false);
@@ -247,17 +243,24 @@ QString LaunchController::askOfflineName(QString playerName, bool* ok)
             break;
         case LaunchMode::Offline:
             if (m_wantedLaunchMode == LaunchMode::Normal) {
-                message = tr("You are not connected to the Internet, launching in offline mode\n\n");
+                auto netErr = m_accountToUse->accountData()->networkError;
+                if (Net::isServerError(netErr)) {
+                    title = tr("Auth servers offline");
+                    message = tr("The Minecraft authentication servers are currently unavailable, launching in offline mode.\n\n");
+                } else {
+                    title = tr("No internet connection");
+                    message = tr("You are not connected to the Internet, launching in offline mode.\n\n");
+                }
             }
             message += tr("Choose your offline mode player name");
             break;
     }
 
-    QString lastOfflinePlayerName = APPLICATION->settings()->get("LastOfflinePlayerName").toString();
+    const QString lastOfflinePlayerName = APPLICATION->settings()->get("LastOfflinePlayerName").toString();
     QString usedname = lastOfflinePlayerName.isEmpty() ? playerName : lastOfflinePlayerName;
 
     ChooseOfflineNameDialog dialog(message, m_parentWidget);
-    dialog.setWindowTitle(tr("Player name"));
+    dialog.setWindowTitle(title);
     dialog.setUsername(usedname);
     if (dialog.exec() != QDialog::Accepted) {
         return {};
@@ -331,23 +334,24 @@ void LaunchController::login()
     launchInstance();
 }
 
-bool LaunchController::reauthenticateAccount(MinecraftAccountPtr account, QString reason)
+bool LaunchController::reauthenticateAccount(const MinecraftAccountPtr& account, const QString& reason)
 {
     auto button = QMessageBox::warning(
         m_parentWidget, tr("Account refresh failed"), tr("%1. Do you want to reauthenticate this account?").arg(reason),
         QMessageBox::StandardButton::Yes | QMessageBox::StandardButton::No, QMessageBox::StandardButton::Yes);
     if (button == QMessageBox::StandardButton::Yes) {
-        auto accounts = APPLICATION->accounts();
+        auto* accounts = APPLICATION->accounts();
-        bool isDefault = accounts->defaultAccount() == account;
+        const bool isDefault = accounts->defaultAccount() == account;
-        accounts->removeAccount(accounts->index(accounts->findAccountByProfileId(account->profileId())));
         if (account->accountType() == AccountType::MSA) {
             auto newAccount = MSALoginDialog::newAccount(m_parentWidget);
 
             if (newAccount != nullptr) {
+                accounts->removeAccount(accounts->index(accounts->findAccountByProfileId(account->profileId())));
                 accounts->addAccount(newAccount);
 
-                if (isDefault)
+                if (isDefault) {
                     accounts->setDefaultAccount(newAccount);
+                }
 
                 if (m_accountToUse == account) {
                     m_accountToUse = nullptr;
@@ -358,14 +362,13 @@ bool LaunchController::reauthenticateAccount(MinecraftAccountPtr account, QStrin
         }
     }
 
-    emitFailed(reason);
     return false;
 }
 
 void LaunchController::launchInstance()
 {
-    Q_ASSERT_X(m_instance != NULL, "launchInstance", "instance is NULL");
+    Q_ASSERT(m_instance != nullptr);
-    Q_ASSERT_X(m_session.get() != nullptr, "launchInstance", "session is NULL");
+    Q_ASSERT(m_session.get() != nullptr);
 
     if (!m_instance->reloadSettings()) {
         QMessageBox::critical(m_parentWidget, tr("Error!"), tr("Couldn't load the instance profile."));
@@ -379,8 +382,8 @@ void LaunchController::launchInstance()
         return;
     }
 
-    auto console = qobject_cast<InstanceWindow*>(m_parentWidget);
+    const auto* console = qobject_cast<InstanceWindow*>(m_parentWidget);
-    auto showConsole = m_instance->settings()->get("ShowConsole").toBool();
+    const auto showConsole = m_instance->settings()->get("ShowConsole").toBool();
     if (!console && showConsole) {
         APPLICATION->showInstanceWindow(m_instance);
     }
@@ -395,7 +398,7 @@ void LaunchController::launchInstance()
         online_mode = "online";
 
         // Prepend Server Status
-        QStringList servers = { "login.microsoftonline.com", "session.minecraft.net", "textures.minecraft.net", "api.mojang.com" };
+        const QStringList servers = { "login.microsoftonline.com", "session.minecraft.net", "textures.minecraft.net", "api.mojang.com" };
 
         m_launcher->prependStep(makeShared<PrintServers>(m_launcher, servers));
     } else {
@@ -465,10 +468,10 @@ void LaunchController::onFailed(QString reason)
     if (m_instance->settings()->get("ShowConsoleOnError").toBool()) {
         APPLICATION->showInstanceWindow(m_instance, "console");
     }
-    emitFailed(reason);
+    emitFailed(std::move(reason));
 }
 
-void LaunchController::onProgressRequested(Task* task)
+void LaunchController::onProgressRequested(Task* task) const
 {
     ProgressDialog progDialog(m_parentWidget);
     progDialog.setSkipButton(true, tr("Abort"));

launcher/LaunchController.h

@@ -50,11 +50,11 @@ class LaunchController : public Task {
     void executeTask() override;
 
     LaunchController();
-    virtual ~LaunchController() = default;
+    ~LaunchController() override = default;
 
     void setInstance(BaseInstance* instance) { m_instance = instance; }
 
-    BaseInstance* instance() { return m_instance; }
+    BaseInstance* instance() const { return m_instance; }
 
     void setLaunchMode(const LaunchMode mode) { m_wantedLaunchMode = mode; }
 
@@ -68,7 +68,7 @@ class LaunchController : public Task {
 
     void setAccountToUse(MinecraftAccountPtr accountToUse) { m_accountToUse = std::move(accountToUse); }
 
-    QString id() { return m_instance->id(); }
+    QString id() const { return m_instance->id(); }
 
     bool abort() override;
 
@@ -77,27 +77,27 @@ class LaunchController : public Task {
     void launchInstance();
     void decideAccount();
     LaunchDecision decideLaunchMode();
-    bool askPlayDemo();
+    bool askPlayDemo() const;
-    QString askOfflineName(QString playerName, bool* ok = nullptr);
+    QString askOfflineName(const QString& playerName, bool* ok = nullptr);
-    bool reauthenticateAccount(MinecraftAccountPtr account, QString reason);
+    bool reauthenticateAccount(const MinecraftAccountPtr& account, const QString& reason);
 
    private slots:
     void readyForLaunch();
 
     void onSucceeded();
     void onFailed(QString reason);
-    void onProgressRequested(Task* task);
+    void onProgressRequested(Task* task) const;
 
    private:
     LaunchMode m_wantedLaunchMode = LaunchMode::Normal;
     LaunchMode m_actualLaunchMode = LaunchMode::Normal;
     BaseProfilerFactory* m_profiler = nullptr;
     QString m_offlineName;
-    BaseInstance* m_instance;
+    BaseInstance* m_instance = nullptr;
     QWidget* m_parentWidget = nullptr;
     InstanceWindow* m_console = nullptr;
     MinecraftAccountPtr m_accountToUse = nullptr;
-    AuthSessionPtr m_session;
+    AuthSessionPtr m_session = nullptr;
-    LaunchTask* m_launcher;
+    LaunchTask* m_launcher = nullptr;
-    MinecraftTarget::Ptr m_targetToJoin;
+    MinecraftTarget::Ptr m_targetToJoin = nullptr;
 };

launcher/Launcher.in

@@ -15,6 +15,7 @@ fi
 
 
 LAUNCHER_NAME=@Launcher_APP_BINARY_NAME@
+LAUNCHER_ENVNAME=@Launcher_ENVName@
 LAUNCHER_DIR="$(dirname "$(readlink -f "$0")")"
 echo "Launcher Dir: ${LAUNCHER_DIR}"
 
@@ -23,7 +24,7 @@ export QT_QPA_PLATFORMTHEME=xdgdesktopportal
 
 # disable OpenGL and Vulkan launcher features on sharun until https://github.com/VHSgunzo/sharun/issues/35
 if [[ -f "${LAUNCHER_DIR}/sharun" ]]; then
-    export LAUNCHER_DISABLE_GLVULKAN=1
+    export ${LAUNCHER_ENVNAME}_DISABLE_GLVULKAN=1
 fi
 
 # Just to be sure...

launcher/LoggedProcess.cpp

@@ -114,7 +114,7 @@ void LoggedProcess::on_error(QProcess::ProcessError error)
 {
     switch (error) {
         case QProcess::FailedToStart: {
-            emit log({ tr("The process failed to start.") }, MessageLevel::Fatal);
+            emit log({ tr("The process failed to start: %1").arg(errorString()) }, MessageLevel::Fatal);
             changeState(LoggedProcess::FailedToStart);
             break;
         }

launcher/MTPixmapCache.h

@@ -14,26 +14,26 @@
     else                                                                    \
         type = Qt::DirectConnection;
 
-#define DEFINE_FUNC_NO_PARAM(NAME, RET_TYPE)                                                 \
+#define DEFINE_FUNC_NO_PARAM(NAME, RET_TYPE, RET_DEF)                                        \
     static RET_TYPE NAME()                                                                   \
     {                                                                                        \
-        RET_TYPE ret;                                                                        \
+        RET_TYPE ret = RET_DEF;                                                              \
         GET_TYPE()                                                                           \
         QMetaObject::invokeMethod(s_instance, "_" #NAME, type, Q_RETURN_ARG(RET_TYPE, ret)); \
         return ret;                                                                          \
     }
-#define DEFINE_FUNC_ONE_PARAM(NAME, RET_TYPE, PARAM_1_TYPE)                                                           \
+#define DEFINE_FUNC_ONE_PARAM(NAME, RET_TYPE, RET_DEF, PARAM_1_TYPE)                                                  \
     static RET_TYPE NAME(PARAM_1_TYPE p1)                                                                             \
     {                                                                                                                 \
-        RET_TYPE ret;                                                                                                 \
+        RET_TYPE ret = RET_DEF;                                                                                       \
         GET_TYPE()                                                                                                    \
         QMetaObject::invokeMethod(s_instance, "_" #NAME, type, Q_RETURN_ARG(RET_TYPE, ret), Q_ARG(PARAM_1_TYPE, p1)); \
         return ret;                                                                                                   \
     }
-#define DEFINE_FUNC_TWO_PARAM(NAME, RET_TYPE, PARAM_1_TYPE, PARAM_2_TYPE)                                            \
+#define DEFINE_FUNC_TWO_PARAM(NAME, RET_TYPE, RET_DEF, PARAM_1_TYPE, PARAM_2_TYPE)                                   \
     static RET_TYPE NAME(PARAM_1_TYPE p1, PARAM_2_TYPE p2)                                                           \
     {                                                                                                                \
-        RET_TYPE ret;                                                                                                \
+        RET_TYPE ret = RET_DEF;                                                                                      \
         GET_TYPE()                                                                                                   \
         QMetaObject::invokeMethod(s_instance, "_" #NAME, type, Q_RETURN_ARG(RET_TYPE, ret), Q_ARG(PARAM_1_TYPE, p1), \
                                   Q_ARG(PARAM_2_TYPE, p2));                                                          \
@@ -53,18 +53,18 @@ class PixmapCache final : public QObject {
     static void setInstance(PixmapCache* i) { s_instance = i; }
 
    public:
-    DEFINE_FUNC_NO_PARAM(cacheLimit, int)
+    DEFINE_FUNC_NO_PARAM(cacheLimit, int, -1)
-    DEFINE_FUNC_NO_PARAM(clear, bool)
+    DEFINE_FUNC_NO_PARAM(clear, bool, false)
-    DEFINE_FUNC_TWO_PARAM(find, bool, const QString&, QPixmap*)
+    DEFINE_FUNC_TWO_PARAM(find, bool, false, const QString&, QPixmap*)
-    DEFINE_FUNC_TWO_PARAM(find, bool, const QPixmapCache::Key&, QPixmap*)
+    DEFINE_FUNC_TWO_PARAM(find, bool, false, const QPixmapCache::Key&, QPixmap*)
-    DEFINE_FUNC_TWO_PARAM(insert, bool, const QString&, const QPixmap&)
+    DEFINE_FUNC_TWO_PARAM(insert, bool, false, const QString&, const QPixmap&)
-    DEFINE_FUNC_ONE_PARAM(insert, QPixmapCache::Key, const QPixmap&)
+    DEFINE_FUNC_ONE_PARAM(insert, QPixmapCache::Key, {}, const QPixmap&)
-    DEFINE_FUNC_ONE_PARAM(remove, bool, const QString&)
+    DEFINE_FUNC_ONE_PARAM(remove, bool, false, const QString&)
-    DEFINE_FUNC_ONE_PARAM(remove, bool, const QPixmapCache::Key&)
+    DEFINE_FUNC_ONE_PARAM(remove, bool, false, const QPixmapCache::Key&)
-    DEFINE_FUNC_TWO_PARAM(replace, bool, const QPixmapCache::Key&, const QPixmap&)
+    DEFINE_FUNC_TWO_PARAM(replace, bool, false, const QPixmapCache::Key&, const QPixmap&)
-    DEFINE_FUNC_ONE_PARAM(setCacheLimit, bool, int)
+    DEFINE_FUNC_ONE_PARAM(setCacheLimit, bool, false, int)
-    DEFINE_FUNC_NO_PARAM(markCacheMissByEviciton, bool)
+    DEFINE_FUNC_NO_PARAM(markCacheMissByEviciton, bool, false)
-    DEFINE_FUNC_ONE_PARAM(setFastEvictionThreshold, bool, int)
+    DEFINE_FUNC_ONE_PARAM(setFastEvictionThreshold, bool, false, int)
 
     // NOTE: Every function returns something non-void to simplify the macros.
    private slots:

launcher/ResourceDownloadTask.cpp

@@ -19,23 +19,52 @@
 
 #include "ResourceDownloadTask.h"
 
+#include <utility>
+
 #include "Application.h"
 
 #include "FileSystem.h"
+#include "minecraft/MinecraftInstance.h"
+#include "minecraft/PackProfile.h"
 #include "minecraft/mod/ResourceFolderModel.h"
 
 #include "minecraft/mod/ShaderPackFolderModel.h"
+#include "modplatform/ModIndex.h"
 #include "modplatform/helpers/HashUtils.h"
 #include "net/ApiDownload.h"
 #include "net/ChecksumValidator.h"
 
+namespace {
+Net::ModrinthDownloadMeta createModrinthMeta(BaseInstance* instance, QString reason)
+{
+    auto* mcInstance = dynamic_cast<MinecraftInstance*>(instance);
+    if (!mcInstance) {
+        return {};
+    }
+
+    auto* profile = mcInstance->getPackProfile();
+    if (!profile) {
+        return {};
+    }
+
+    auto loaders = profile->getModLoadersList();
+
+    return {
+        .reason = std::move(reason),
+        .gameVersion = profile->getComponentVersion("net.minecraft"),
+        .loader = !loaders.isEmpty() ? ModPlatform::getModLoaderAsString(loaders.first()) : "",
+    };
+}
+}  // namespace
+
 ResourceDownloadTask::ResourceDownloadTask(ModPlatform::IndexedPack::Ptr pack,
                                            ModPlatform::IndexedVersion version,
                                            ResourceFolderModel* packs,
-                                           bool is_indexed)
+                                           bool isIndexed,
+                                           QString downloadReason)
     : m_pack(std::move(pack)), m_pack_version(std::move(version)), m_pack_model(packs)
 {
-    if (is_indexed) {
+    if (isIndexed) {
         m_update_task.reset(new LocalResourceUpdateTask(m_pack_model->indexDir(), *m_pack, m_pack_version));
         connect(m_update_task.get(), &LocalResourceUpdateTask::hasOldResource, this, &ResourceDownloadTask::hasOldResource);
 
@@ -45,7 +74,9 @@ ResourceDownloadTask::ResourceDownloadTask(ModPlatform::IndexedPack::Ptr pack,
     m_filesNetJob.reset(new NetJob(tr("Resource download"), APPLICATION->network()));
     m_filesNetJob->setStatus(tr("Downloading resource:\n%1").arg(m_pack_version.downloadUrl));
 
-    auto action = Net::ApiDownload::makeFile(m_pack_version.downloadUrl, m_pack_model->dir().absoluteFilePath(getFilename()));
+    auto action = Net::ApiDownload::makeFile(m_pack_version.downloadUrl, m_pack_model->dir().absoluteFilePath(getFilename()),
+                                             Net::Download::Option::NoOptions,
+                                             createModrinthMeta(m_pack_model->instance(), std::move(downloadReason)));
     if (!m_pack_version.hash_type.isEmpty() && !m_pack_version.hash.isEmpty()) {
         switch (Hashing::algorithmFromString(m_pack_version.hash_type)) {
             case Hashing::Algorithm::Md4:
@@ -82,8 +113,9 @@ void ResourceDownloadTask::downloadSucceeded()
     auto oldName = std::get<0>(to_delete);
     auto oldFilename = std::get<1>(to_delete);
 
-    if (oldName.isEmpty() || oldFilename == m_pack_version.fileName)
+    if (oldName.isEmpty() || oldFilename == m_pack_version.fileName) {
         return;
+    }
 
     m_pack_model->uninstallResource(oldFilename, true);
 
@@ -95,8 +127,9 @@ void ResourceDownloadTask::downloadSucceeded()
         if (oldConfig.exists() && !newConfig.exists()) {
             bool success = FS::move(oldConfig.filePath(), newConfig.filePath());
 
-            if (!success)
+            if (!success) {
                 emit logWarning(tr("Failed to rename shader config from '%1' to '%2'").arg(oldConfig.fileName(), newConfig.fileName()));
+            }
         }
     }
 }
@@ -104,7 +137,7 @@ void ResourceDownloadTask::downloadSucceeded()
 void ResourceDownloadTask::downloadFailed(QString reason)
 {
     m_filesNetJob.reset();
-    emitFailed(reason);
+    emitFailed(std::move(reason));
 }
 
 void ResourceDownloadTask::downloadProgressChanged(qint64 current, qint64 total)
@@ -114,7 +147,7 @@ void ResourceDownloadTask::downloadProgressChanged(qint64 current, qint64 total)
 
 // This indirection is done so that we don't delete a mod before being sure it was
 // downloaded successfully!
-void ResourceDownloadTask::hasOldResource(QString name, QString filename)
+void ResourceDownloadTask::hasOldResource(const QString& name, const QString& filename)
 {
     to_delete = { name, filename };
 }

launcher/ResourceDownloadTask.h

@@ -33,7 +33,8 @@ class ResourceDownloadTask : public SequentialTask {
     explicit ResourceDownloadTask(ModPlatform::IndexedPack::Ptr pack,
                                   ModPlatform::IndexedVersion version,
                                   ResourceFolderModel* packs,
-                                  bool is_indexed = true);
+                                  bool isIndexed = true,
+                                  QString downloadReason = "standalone");
     const QString& getFilename() const { return m_pack_version.fileName; }
     const QVariant& getVersionID() const { return m_pack_version.fileId; }
     const ModPlatform::IndexedVersion& getVersion() const { return m_pack_version; }
@@ -56,5 +57,5 @@ class ResourceDownloadTask : public SequentialTask {
     std::tuple<QString, QString> to_delete{ "", "" };
 
    private slots:
-    void hasOldResource(QString name, QString filename);
+    void hasOldResource(const QString& name, const QString& filename);
 };

launcher/Version.cpp

@@ -1,124 +1,42 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2023 flowln <flowlnlnln@gmail.com>
+ *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (c) 2026 Trial97 <alexandru.tripon97@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
 #include "Version.h"
 
 #include <QDebug>
 #include <QRegularExpressionMatch>
 #include <QUrl>
-
+#include <compare>
-Version::Version(QString str) : m_string(std::move(str))
-{
-    parse();
-}
-
-#define VERSION_OPERATOR(return_on_different)                                               \
-    bool exclude_our_sections = false;                                                      \
-    bool exclude_their_sections = false;                                                    \
-                                                                                            \
-    const auto size = qMax(m_sections.size(), other.m_sections.size());                     \
-    for (int i = 0; i < size; ++i) {                                                        \
-        Section sec1 = (i >= m_sections.size()) ? Section() : m_sections.at(i);             \
-        Section sec2 = (i >= other.m_sections.size()) ? Section() : other.m_sections.at(i); \
-                                                                                            \
-        { /* Don't include appendixes in the comparison */                                  \
-            if (sec1.isAppendix())                                                          \
-                exclude_our_sections = true;                                                \
-            if (sec2.isAppendix())                                                          \
-                exclude_their_sections = true;                                              \
-                                                                                            \
-            if (exclude_our_sections) {                                                     \
-                sec1 = Section();                                                           \
-                if (sec2.m_isNull)                                                          \
-                    break;                                                                  \
-            }                                                                               \
-                                                                                            \
-            if (exclude_their_sections) {                                                   \
-                sec2 = Section();                                                           \
-                if (sec1.m_isNull)                                                          \
-                    break;                                                                  \
-            }                                                                               \
-        }                                                                                   \
-                                                                                            \
-        if (sec1 != sec2)                                                                   \
-            return return_on_different;                                                     \
-    }
-
-bool Version::operator<(const Version& other) const
-{
-    VERSION_OPERATOR(sec1 < sec2)
-
-    return false;
-}
-bool Version::operator==(const Version& other) const
-{
-    VERSION_OPERATOR(false)
-
-    return true;
-}
-bool Version::operator!=(const Version& other) const
-{
-    return !operator==(other);
-}
-bool Version::operator<=(const Version& other) const
-{
-    return *this < other || *this == other;
-}
-bool Version::operator>(const Version& other) const
-{
-    return !(*this <= other);
-}
-bool Version::operator>=(const Version& other) const
-{
-    return !(*this < other);
-}
-
-void Version::parse()
-{
-    m_sections.clear();
-    QString currentSection;
-
-    if (m_string.isEmpty())
-        return;
-
-    auto classChange = [&currentSection](QChar lastChar, QChar currentChar) {
-        if (lastChar.isNull())
-            return false;
-        if (lastChar.isDigit() != currentChar.isDigit())
-            return true;
-
-        const QList<QChar> s_separators{ '.', '-', '+' };
-        if (s_separators.contains(currentChar) && currentSection.at(0) != currentChar)
-            return true;
-
-        return false;
-    };
-
-    currentSection += m_string.at(0);
-    for (int i = 1; i < m_string.size(); ++i) {
-        const auto& current_char = m_string.at(i);
-        if (classChange(m_string.at(i - 1), current_char)) {
-            if (!currentSection.isEmpty())
-                m_sections.append(Section(currentSection));
-            currentSection = "";
-        }
-
-        currentSection += current_char;
-    }
-
-    if (!currentSection.isEmpty())
-        m_sections.append(Section(currentSection));
-}
 
 /// qDebug print support for the Version class
 QDebug operator<<(QDebug debug, const Version& v)
 {
-    QDebugStateSaver saver(debug);
+    const QDebugStateSaver saver(debug);
 
     debug.nospace() << "Version{ string: " << v.toString() << ", sections: [ ";
 
     bool first = true;
-    for (auto s : v.m_sections) {
+    for (const auto& s : v.m_sections) {
-        if (!first)
+        if (!first) {
             debug.nospace() << ", ";
-        debug.nospace() << s.m_fullString;
+        }
+        debug.nospace() << s.value;
         first = false;
     }
 
@@ -126,3 +44,114 @@ QDebug operator<<(QDebug debug, const Version& v)
 
     return debug;
 }
+
+std::strong_ordering Version::Section::operator<=>(const Section& other) const
+{
+    // If both components are numeric, compare numerically (codepoint-wise)
+    if (this->t == Type::Numeric && other.t == Type::Numeric) {
+        auto aLen = this->value.size();
+        if (aLen != other.value.size()) {
+            // Lengths differ; compare by length
+            return aLen <=> other.value.size();
+        }
+        // Compare by digits
+        auto cmp = QString::compare(this->value, other.value);
+        if (cmp < 0) {
+            return std::strong_ordering::less;
+        }
+        if (cmp > 0) {
+            return std::strong_ordering::greater;
+        }
+        return std::strong_ordering::equal;
+    }
+    // One or both are null
+    if (this->t == Type::Null) {
+        if (other.t == Type::PreRelease) {
+            return std::strong_ordering::greater;
+        }
+        return std::strong_ordering::less;
+    }
+    if (other.t == Type::Null) {
+        if (this->t == Type::PreRelease) {
+            return std::strong_ordering::less;
+        }
+        return std::strong_ordering::greater;
+    }
+    // Textual comparison (differing type, or both textual/pre-release)
+    auto minLen = qMin(this->value.size(), other.value.size());
+    for (int i = 0; i < minLen; i++) {
+        auto a = this->value.at(i);
+        auto b = other.value.at(i);
+        if (a != b) {
+            // Compare by rune
+            return a.unicode() <=> b.unicode();
+        }
+    }
+    // Compare by length
+    return this->value.size() <=> other.value.size();
+}
+
+namespace {
+void removeLeadingZeros(QString& s)
+{
+    s.remove(0, std::distance(s.begin(), std::ranges::find_if_not(s, [](QChar c) { return c == '0'; })));
+}
+}  // namespace
+
+void Version::parse()
+{
+    auto len = m_string.size();
+    for (int i = 0; i < len;) {
+        Section cur(Section::Type::Textual);
+        auto c = m_string.at(i);
+        if (c == '+') {
+            break;  // Ignore appendices
+        }
+        // custom: the space is special to handle the strings like "1.20 Pre-Release 1"
+        // this is needed to support Modrinth versions
+        if (c == '-' || c == ' ') {
+            // Add dash to component
+            cur.value += c;
+            i++;
+            // If the next rune is non-digit, mark as pre-release (requires >= 1 non-digit after dash so the component has length > 1)
+            if (i < len && !m_string.at(i).isDigit()) {
+                cur.t = Section::Type::PreRelease;
+            }
+        } else if (c.isDigit()) {
+            // Mark as numeric
+            cur.t = Section::Type::Numeric;
+        }
+        for (; i < len; i++) {
+            auto r = m_string.at(i);
+            if ((r.isDigit() != (cur.t == Section::Type::Numeric))   // starts a new section
+                || (r == ' ' && cur.t == Section::Type::Numeric)     // custom: numeric section then a space is a pre-release
+                || (r == '-' && cur.t != Section::Type::PreRelease)  // "---" is a valid pre-release component
+                || r == '+') {
+                // Run completed (do not consume this rune)
+                break;
+            }
+            // Add rune to current run
+            cur.value += r;
+        }
+        if (!cur.value.isEmpty()) {
+            if (cur.t == Section::Type::Numeric) {
+                removeLeadingZeros(cur.value);
+            }
+            m_sections.append(cur);
+        }
+    }
+}
+
+std::strong_ordering Version::operator<=>(const Version& other) const
+{
+    const auto size = qMax(m_sections.size(), other.m_sections.size());
+    for (int i = 0; i < size; ++i) {
+        auto sec1 = (i >= m_sections.size()) ? Section() : m_sections.at(i);
+        auto sec2 = (i >= other.m_sections.size()) ? Section() : other.m_sections.at(i);
+
+        if (auto cmp = sec1 <=> sec2; cmp != std::strong_ordering::equal) {
+            return cmp;
+        }
+    }
+    return std::strong_ordering::equal;
+}

launcher/Version.h

@@ -3,6 +3,7 @@
  *  Prism Launcher - Minecraft Launcher
  *  Copyright (C) 2023 flowln <flowlnlnln@gmail.com>
  *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (c) 2026 Trial97 <alexandru.tripon97@gmail.com>
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -15,23 +16,6 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- * This file incorporates work covered by the following copyright and
- * permission notice:
- *
- *      Copyright 2013-2021 MultiMC Contributors
- *
- *      Licensed under the Apache License, Version 2.0 (the "License");
- *      you may not use this file except in compliance with the License.
- *      You may obtain a copy of the License at
- *
- *          http://www.apache.org/licenses/LICENSE-2.0
- *
- *      Unless required by applicable law or agreed to in writing, software
- *      distributed under the License is distributed on an "AS IS" BASIS,
- *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *      See the License for the specific language governing permissions and
- *      limitations under the License.
  */
 
 #pragma once
@@ -41,115 +25,36 @@
 #include <QString>
 #include <QStringView>
 
-class QUrl;
+// this implements the FlexVer
-
+// https://git.sleeping.town/exa/FlexVer
 class Version {
    public:
-    Version(QString str);
+    Version(QString str) : m_string(std::move(str)) { parse(); }  // NOLINT(hicpp-explicit-conversions)
     Version() = default;
 
-    bool operator<(const Version& other) const;
+   private:
-    bool operator<=(const Version& other) const;
+    struct Section {
-    bool operator>(const Version& other) const;
+        enum class Type : std::uint8_t { Null, Textual, Numeric, PreRelease };
-    bool operator>=(const Version& other) const;
+        explicit Section(Type t = Type::Null, QString value = "") : t(t), value(std::move(value)) {}
-    bool operator==(const Version& other) const;
+        Type t;
-    bool operator!=(const Version& other) const;
+        QString value;
+        bool operator==(const Section& other) const = default;
+        std::strong_ordering operator<=>(const Section& other) const;
+    };
 
+   private:
+    void parse();
+
+   public:
     QString toString() const { return m_string; }
     bool isEmpty() const { return m_string.isEmpty(); }
 
     friend QDebug operator<<(QDebug debug, const Version& v);
 
-   private:
+    bool operator==(const Version& other) const { return (*this <=> other) == std::strong_ordering::equal; }
-    struct Section {
+    std::strong_ordering operator<=>(const Version& other) const;
-        explicit Section(QString fullString) : m_fullString(std::move(fullString))
-        {
-            qsizetype cutoff = m_fullString.size();
-            for (int i = 0; i < m_fullString.size(); i++) {
-                if (!m_fullString[i].isDigit()) {
-                    cutoff = i;
-                    break;
-                }
-            }
-
-            auto numPart = QStringView{ m_fullString }.left(cutoff);
-
-            if (!numPart.isEmpty()) {
-                m_isNull = false;
-                m_numPart = numPart.toInt();
-            }
-
-            auto stringPart = QStringView{ m_fullString }.mid(cutoff);
-
-            if (!stringPart.isEmpty()) {
-                m_isNull = false;
-                m_stringPart = stringPart.toString();
-            }
-        }
-
-        explicit Section() = default;
-
-        bool m_isNull = true;
-
-        int m_numPart = 0;
-        QString m_stringPart;
-
-        QString m_fullString;
-
-        inline bool isAppendix() const { return m_stringPart.startsWith('+'); }
-        inline bool isPreRelease() const { return m_stringPart.startsWith('-') && m_stringPart.length() > 1; }
-
-        inline bool operator==(const Section& other) const
-        {
-            if (m_isNull && !other.m_isNull)
-                return false;
-            if (!m_isNull && other.m_isNull)
-                return false;
-
-            if (!m_isNull && !other.m_isNull) {
-                return (m_numPart == other.m_numPart) && (m_stringPart == other.m_stringPart);
-            }
-
-            return true;
-        }
-
-        inline bool operator<(const Section& other) const
-        {
-            static auto unequal_is_less = [](const Section& non_null) -> bool {
-                if (non_null.m_stringPart.isEmpty())
-                    return non_null.m_numPart == 0;
-                return (non_null.m_stringPart != QLatin1Char('.')) && non_null.isPreRelease();
-            };
-
-            if (!m_isNull && other.m_isNull)
-                return unequal_is_less(*this);
-            if (m_isNull && !other.m_isNull)
-                return !unequal_is_less(other);
-
-            if (!m_isNull && !other.m_isNull) {
-                if (m_numPart < other.m_numPart)
-                    return true;
-                if (m_numPart == other.m_numPart && m_stringPart < other.m_stringPart)
-                    return true;
-
-                if (!m_stringPart.isEmpty() && other.m_stringPart.isEmpty())
-                    return false;
-                if (m_stringPart.isEmpty() && !other.m_stringPart.isEmpty())
-                    return true;
-
-                return false;
-            }
-
-            return m_fullString < other.m_fullString;
-        }
-
-        inline bool operator!=(const Section& other) const { return !(*this == other); }
-        inline bool operator>(const Section& other) const { return !(*this < other || *this == other); }
-    };
 
    private:
     QString m_string;
     QList<Section> m_sections;
-
-    void parse();
 };

launcher/archive/ArchiveReader.cpp

@@ -24,6 +24,7 @@
 #include <QDir>
 #include <QFileInfo>
 #include <QUrl>
+#include <functional>
 #include <memory>
 #include <optional>
 
@@ -36,25 +37,36 @@ QStringList ArchiveReader::getFiles()
 bool ArchiveReader::collectFiles(bool onlyFiles)
 {
     return parse([this, onlyFiles](File* f) {
-        if (!onlyFiles || f->isFile())
+        if (!onlyFiles || f->isFile()) {
             m_fileNames << f->filename();
+        }
         return f->skip();
     });
 }
 
+using getPathFunc = std::function<const char*(archive_entry*)>;
+static QString decodeLibArchivePath(archive_entry* entry, const getPathFunc& getUtf8Path, const getPathFunc& getPath)
+{
+    auto fileName = QString::fromUtf8(getUtf8Path(entry));
+    if (fileName.isEmpty()) {
+        fileName = QString::fromLocal8Bit(getPath(entry));
+    }
+    return fileName;
+}
+
 QString ArchiveReader::File::filename()
 {
-    return QString::fromUtf8(archive_entry_pathname_utf8(m_entry));
+    return decodeLibArchivePath(m_entry, archive_entry_pathname_utf8, archive_entry_pathname);
 }
 
 QByteArray ArchiveReader::File::readAll(int* outStatus)
 {
     QByteArray data;
-    const void* buff;
+    const void* buff = nullptr;
-    size_t size;
+    size_t size = 0;
-    la_int64_t offset;
+    la_int64_t offset = 0;
 
-    int status;
+    int status = 0;
     while ((status = archive_read_data_block(m_archive.get(), &buff, &size, &offset)) == ARCHIVE_OK) {
         data.append(static_cast<const char*>(buff), static_cast<qsizetype>(size));
     }
@@ -80,10 +92,10 @@ int ArchiveReader::File::readNextHeader()
     return archive_read_next_header(m_archive.get(), &m_entry);
 }
 
-auto ArchiveReader::goToFile(QString filename) -> std::unique_ptr<File>
+auto ArchiveReader::goToFile(const QString& filename) -> std::unique_ptr<File>
 {
     auto f = std::make_unique<File>();
-    auto a = f->m_archive.get();
+    auto* a = f->m_archive.get();
     archive_read_support_format_all(a);
     archive_read_support_filter_all(a);
     auto fileName = m_archivePath.toStdWString();
@@ -105,15 +117,16 @@ auto ArchiveReader::goToFile(QString filename) -> std::unique_ptr<File>
 
 static int copy_data(struct archive* ar, struct archive* aw, bool notBlock = false)
 {
-    int r;
+    int r = 0;
-    const void* buff;
+    const void* buff = nullptr;
-    size_t size;
+    size_t size = 0;
-    la_int64_t offset;
+    la_int64_t offset = 0;
 
     for (;;) {
         r = archive_read_data_block(ar, &buff, &size, &offset);
-        if (r == ARCHIVE_EOF)
+        if (r == ARCHIVE_EOF) {
-            return (ARCHIVE_OK);
+            return ARCHIVE_OK;
+        }
         if (r < ARCHIVE_OK) {
             qCritical() << "Failed reading data block:" << archive_error_string(ar);
             return (r);
@@ -130,39 +143,43 @@ static int copy_data(struct archive* ar, struct archive* aw, bool notBlock = fal
     }
 }
 
-bool willEscapeRoot(const QDir& root, archive_entry* entry)
+static bool willEscapeRoot(const QDir& root, archive_entry* entry)
 {
-    const char* entryPathC = archive_entry_pathname(entry);
+    auto entryPath = decodeLibArchivePath(entry, archive_entry_pathname_utf8, archive_entry_pathname);
-    const char* linkTargetC = archive_entry_symlink(entry);
+    auto linkTarget = decodeLibArchivePath(entry, archive_entry_symlink_utf8, archive_entry_symlink);
-    const char* hardlinkC = archive_entry_hardlink(entry);
+    auto hardLink = decodeLibArchivePath(entry, archive_entry_hardlink_utf8, archive_entry_hardlink);
 
-    if (!entryPathC || (!linkTargetC && !hardlinkC))
+    if (entryPath.isEmpty() || (linkTarget.isEmpty() && hardLink.isEmpty())) {
         return false;
+    }
 
-    QString entryPath = QString::fromUtf8(entryPathC);
+    bool isHardLink = false;
-    QString linkTarget = linkTargetC ? QString::fromUtf8(linkTargetC) : QString::fromUtf8(hardlinkC);
+    if (isHardLink = linkTarget.isEmpty(); isHardLink) {
+        linkTarget = hardLink;
+    }
 
     QString linkFullPath = root.filePath(entryPath);
     auto rootDir = QUrl::fromLocalFile(root.absolutePath());
 
-    if (!rootDir.isParentOf(QUrl::fromLocalFile(linkFullPath)))
+    if (!rootDir.isParentOf(QUrl::fromLocalFile(linkFullPath))) {
         return true;
+    }
 
     QDir linkDir = QFileInfo(linkFullPath).dir();
     if (!QDir::isAbsolutePath(linkTarget)) {
-        linkTarget = (linkTargetC ? linkDir : root).filePath(linkTarget);
+        linkTarget = (!isHardLink ? linkDir : root).filePath(linkTarget);
     }
     return !rootDir.isParentOf(QUrl::fromLocalFile(QDir::cleanPath(linkTarget)));
 }
 
-bool ArchiveReader::File::writeFile(archive* out, QString targetFileName, bool notBlock)
+bool ArchiveReader::File::writeFile(archive* out, const QString& targetFileName, bool notBlock)
 {
     return writeFile(out, targetFileName, {}, notBlock);
 };
 
-bool ArchiveReader::File::writeFile(archive* out, QString targetFileName, std::optional<QDir> root, bool notBlock)
+bool ArchiveReader::File::writeFile(archive* out, const QString& targetFileName, std::optional<QDir> root, bool notBlock)
 {
-    auto entry = m_entry;
+    auto* entry = m_entry;
     std::unique_ptr<archive_entry, decltype(&archive_entry_free)> entryClone(nullptr, &archive_entry_free);
     if (!targetFileName.isEmpty()) {
         entryClone.reset(archive_entry_clone(m_entry));
@@ -175,25 +192,29 @@ bool ArchiveReader::File::writeFile(archive* out, QString targetFileName, std::o
         return false;
     }
     if (archive_write_header(out, entry) < ARCHIVE_OK) {
-        qCritical() << "Failed to write header to entry:" << filename() << "-" << archive_error_string(out);
+        qCritical() << "Failed to write header to entry:" << filename() << "-" << archive_error_string(out) << targetFileName;
         return false;
-    } else if (archive_entry_size(m_entry) > 0) {
+    }
+    if (archive_entry_size(m_entry) > 0) {
         auto r = copy_data(m_archive.get(), out, notBlock);
-        if (r < ARCHIVE_OK)
+        if (r < ARCHIVE_OK) {
             qCritical() << "Failed reading data block:" << archive_error_string(out);
-        if (r < ARCHIVE_WARN)
+        }
+        if (r < ARCHIVE_WARN) {
             return false;
+        }
     }
     auto r = archive_write_finish_entry(out);
-    if (r < ARCHIVE_OK)
+    if (r < ARCHIVE_OK) {
         qCritical() << "Failed to finish writing entry:" << archive_error_string(out);
+    }
     return (r >= ARCHIVE_WARN);
 }
 
-bool ArchiveReader::parse(std::function<bool(File*, bool&)> doStuff)
+bool ArchiveReader::parse(const std::function<bool(File*, bool&)>& doStuff)
 {
     auto f = std::make_unique<File>();
-    auto a = f->m_archive.get();
+    auto* a = f->m_archive.get();
     archive_read_support_format_all(a);
     archive_read_support_filter_all(a);
     auto fileName = m_archivePath.toStdWString();
@@ -217,7 +238,7 @@ bool ArchiveReader::parse(std::function<bool(File*, bool&)> doStuff)
     return true;
 }
 
-bool ArchiveReader::parse(std::function<bool(File*)> doStuff)
+bool ArchiveReader::parse(const std::function<bool(File*)>& doStuff)
 {
     return parse([doStuff](File* f, bool&) { return doStuff(f); });
 }
@@ -241,26 +262,32 @@ QString ArchiveReader::getZipName()
 
 bool ArchiveReader::exists(const QString& filePath) const
 {
-    if (filePath == QLatin1String("/") || filePath.isEmpty())
+    if (filePath == QLatin1String("/") || filePath.isEmpty()) {
         return true;
+    }
     // Normalize input path (remove trailing slash, if any)
     QString normalizedPath = QDir::cleanPath(filePath);
-    if (normalizedPath.startsWith('/'))
+    if (normalizedPath.startsWith('/')) {
         normalizedPath.remove(0, 1);
-    if (normalizedPath == QLatin1String("."))
+    }
+    if (normalizedPath == QLatin1String(".")) {
         return true;
-    if (normalizedPath == QLatin1String(".."))
+    }
+    if (normalizedPath == QLatin1String("..")) {
         return false;  // root only
+    }
 
     // Check for exact file match
-    if (m_fileNames.contains(normalizedPath, Qt::CaseInsensitive))
+    if (m_fileNames.contains(normalizedPath, Qt::CaseInsensitive)) {
         return true;
+    }
 
     // Check for directory existence by seeing if any file starts with that path
     QString dirPath = normalizedPath + QLatin1Char('/');
     for (const QString& f : m_fileNames) {
-        if (f.startsWith(dirPath, Qt::CaseInsensitive))
+        if (f.startsWith(dirPath, Qt::CaseInsensitive)) {
             return true;
+        }
     }
 
     return false;

launcher/archive/ArchiveReader.h

@@ -23,6 +23,7 @@
 #include <QStringList>
 #include <memory>
 #include <optional>
+#include <utility>
 
 struct archive;
 struct archive_entry;
@@ -30,7 +31,7 @@ namespace MMCZip {
 class ArchiveReader {
    public:
     using ArchivePtr = std::unique_ptr<struct archive, int (*)(struct archive*)>;
-    ArchiveReader(QString fileName) : m_archivePath(fileName) {}
+    explicit ArchiveReader(QString fileName) : m_archivePath(std::move(fileName)) {}
     virtual ~ArchiveReader() = default;
 
     QStringList getFiles();
@@ -50,8 +51,8 @@ class ArchiveReader {
 
         QByteArray readAll(int* outStatus = nullptr);
         bool skip();
-        bool writeFile(archive* out, QString targetFileName = "", bool notBlock = false);
+        bool writeFile(archive* out, const QString& targetFileName = "", bool notBlock = false);
-        bool writeFile(archive* out, QString targetFileName, std::optional<QDir> root, bool notBlock = false);
+        bool writeFile(archive* out, const QString& targetFileName, std::optional<QDir> root, bool notBlock = false);
 
        private:
         int readNextHeader();
@@ -62,14 +63,14 @@ class ArchiveReader {
         archive_entry* m_entry;
     };
 
-    std::unique_ptr<File> goToFile(QString filename);
+    std::unique_ptr<File> goToFile(const QString& filename);
-    bool parse(std::function<bool(File*)>);
+    bool parse(const std::function<bool(File*)>&);
-    bool parse(std::function<bool(File*, bool&)>);
+    bool parse(const std::function<bool(File*, bool&)>&);
 
    private:
     QString m_archivePath;
     size_t m_blockSize = 10240;
 
-    QStringList m_fileNames = {};
+    QStringList m_fileNames;
 };
 }  // namespace MMCZip

launcher/archive/ArchiveWriter.cpp

@@ -174,7 +174,7 @@ bool ArchiveWriter::addFile(const QString& fileName, const QString& fileDest)
     if (fileInfo.isFile() && !fileInfo.isSymLink()) {
         QFile file(fileInfo.absoluteFilePath());
         if (!file.open(QIODevice::ReadOnly)) {
-            qCritical() << "Failed to open file:" << fileInfo.filePath();
+            qCritical() << "Failed to open file:" << fileInfo.filePath() << "error:" << file.errorString();
             return false;
         }
 

launcher/java/JavaChecker.cpp

@@ -179,13 +179,20 @@ void JavaChecker::finished(int exitcode, QProcess::ExitStatus status)
 void JavaChecker::error(QProcess::ProcessError err)
 {
     if (err == QProcess::FailedToStart) {
-        qDebug() << "Java checker has failed to start.";
+        qDebug() << "Java checker has failed to start:" << process->errorString();
         qDebug() << "Process environment:";
         qDebug() << process->environment();
         qDebug() << "Native environment:";
         qDebug() << QProcessEnvironment::systemEnvironment().toStringList();
         killTimer.stop();
-        emit checkFinished({ m_path, m_id });
+
+        Result result = {
+            m_path,
+            m_id,
+        };
+        result.errorLog = process->errorString();
+        result.validity = Result::Validity::Errored;
+        emit checkFinished(result);
     }
     emitSucceeded();
 }

launcher/java/JavaInstallList.cpp

@@ -51,8 +51,9 @@ JavaInstallList::JavaInstallList(QObject* parent, bool onlyManagedVersions)
     : BaseVersionList(parent), m_only_managed_versions(onlyManagedVersions)
 {}
 
-Task::Ptr JavaInstallList::getLoadTask()
+Task::Ptr JavaInstallList::getLoadTask(bool forceReload)
 {
+    Q_UNUSED(forceReload)
     load();
     return getCurrentTask();
 }

launcher/java/JavaInstallList.h

@@ -35,7 +35,7 @@ class JavaInstallList : public BaseVersionList {
    public:
     explicit JavaInstallList(QObject* parent = 0, bool onlyManagedVersions = false);
 
-    Task::Ptr getLoadTask() override;
+    Task::Ptr getLoadTask(bool forceReload = false) override;
     bool isLoaded() override;
     const BaseVersion::Ptr at(int i) const override;
     int count() const override;

launcher/java/JavaUtils.cpp

@@ -42,6 +42,7 @@
 
 #include <QDebug>
 #include "Application.h"
+#include "BuildConfig.h"
 #include "FileSystem.h"
 #include "java/JavaInstallList.h"
 #include "java/JavaUtils.h"
@@ -155,7 +156,7 @@ JavaInstallPtr JavaUtils::GetDefaultJava()
 
 QStringList addJavasFromEnv(QList<QString> javas)
 {
-    auto env = qEnvironmentVariable("PRISMLAUNCHER_JAVA_PATHS");  // FIXME: use launcher name from buildconfig
+    auto env = QProcessEnvironment::systemEnvironment().value(QStringLiteral("%1_JAVA_PATHS").arg(BuildConfig.LAUNCHER_ENVNAME));
 #if defined(Q_OS_WIN32)
     QList<QString> javaPaths = env.replace("\\", "/").split(QLatin1String(";"));
 

launcher/meta/BaseEntity.cpp

@@ -82,12 +82,12 @@ QUrl BaseEntity::url() const
     return QUrl(metaOverride).resolved(localFilename());
 }
 
-Task::Ptr BaseEntity::loadTask(Net::Mode mode)
+Task::Ptr BaseEntity::loadTask(Net::Mode mode, bool forceReload)
 {
     if (m_task && m_task->isRunning()) {
         return m_task;
     }
-    m_task.reset(new BaseEntityLoadTask(this, mode));
+    m_task.reset(new BaseEntityLoadTask(this, mode, forceReload));
     return m_task;
 }
 
@@ -107,7 +107,9 @@ BaseEntity::LoadStatus BaseEntity::status() const
     return m_load_status;
 }
 
-BaseEntityLoadTask::BaseEntityLoadTask(BaseEntity* parent, Net::Mode mode) : m_entity(parent), m_mode(mode) {}
+BaseEntityLoadTask::BaseEntityLoadTask(BaseEntity* parent, Net::Mode mode, bool forceReload)
+    : m_entity(parent), m_mode(mode), m_force_reload(forceReload)
+{}
 
 void BaseEntityLoadTask::executeTask()
 {
@@ -125,9 +127,11 @@ void BaseEntityLoadTask::executeTask()
             }
 
             // on online the hash needs to match
-            hashMatches = m_entity->m_sha256 == m_entity->m_file_sha256;
+            const auto& expected = m_entity->m_sha256;
+            const auto& actual = m_entity->m_file_sha256;
+            hashMatches = expected == actual;
             if (m_mode == Net::Mode::Online && !m_entity->m_sha256.isEmpty() && !hashMatches) {
-                throw Exception("mismatched checksum");
+                throw Exception(QString("Checksum mismatch, expected sha256: %1, got: %2").arg(expected, actual));
             }
 
             // load local file
@@ -149,13 +153,18 @@ void BaseEntityLoadTask::executeTask()
     auto wasLoadedOffline = m_entity->m_load_status != BaseEntity::LoadStatus::NotLoaded && m_mode == Net::Mode::Offline;
     // if has is not present allways fetch from remote(e.g. the main index file), else only fetch if hash doesn't match
     auto wasLoadedRemote = m_entity->m_sha256.isEmpty() ? m_entity->m_load_status == BaseEntity::LoadStatus::Remote : hashMatches;
-    if (wasLoadedOffline || wasLoadedRemote) {
+    if (wasLoadedOffline || (wasLoadedRemote && !m_force_reload)) {
         emitSucceeded();
         return;
     }
     m_task.reset(new NetJob(QObject::tr("Download of meta file %1").arg(m_entity->localFilename()), APPLICATION->network()));
     auto url = m_entity->url();
     auto entry = APPLICATION->metacache()->resolveEntry("meta", m_entity->localFilename());
+    if (m_force_reload) {
+        // clear validators so manual refreshes fetch a fresh body
+        entry->setETag({});
+        entry->setRemoteChangedTimestamp({});
+    }
     entry->setStale(true);
     auto dl = Net::ApiDownload::makeCached(url, entry);
     /*

launcher/meta/BaseEntity.h

@@ -43,7 +43,7 @@ class BaseEntity {
     void setSha256(QString sha256);
 
     virtual void parse(const QJsonObject& obj) = 0;
-    [[nodiscard]] Task::Ptr loadTask(Net::Mode loadType = Net::Mode::Online);
+    [[nodiscard]] Task::Ptr loadTask(Net::Mode loadType = Net::Mode::Online, bool forceReload = false);
 
    protected:
     QString m_sha256;       // the expected sha256
@@ -58,7 +58,7 @@ class BaseEntityLoadTask : public Task {
     Q_OBJECT
 
    public:
-    explicit BaseEntityLoadTask(BaseEntity* parent, Net::Mode mode);
+    explicit BaseEntityLoadTask(BaseEntity* parent, Net::Mode mode, bool forceReload);
     ~BaseEntityLoadTask() override = default;
 
     virtual void executeTask() override;
@@ -68,6 +68,7 @@ class BaseEntityLoadTask : public Task {
    private:
     BaseEntity* m_entity;
     Net::Mode m_mode;
+    bool m_force_reload = false;
     NetJob::Ptr m_task;
 };
 }  // namespace Meta

launcher/meta/Index.cpp

@@ -15,6 +15,7 @@
 
 #include "Index.h"
 
+#include "Application.h"
 #include "JsonFormat.h"
 #include "QObjectPtr.h"
 #include "VersionList.h"
@@ -135,7 +136,7 @@ void Index::connectVersionList(const int row, const VersionList::Ptr& list)
 
 Task::Ptr Index::loadVersion(const QString& uid, const QString& version, Net::Mode mode, bool force)
 {
-    if (mode == Net::Mode::Offline) {
+    if (mode == Net::Mode::Offline || !APPLICATION->settings()->get("MetaRefreshOnLaunch").toBool()) {
         return get(uid, version)->loadTask(mode);
     }
 

launcher/meta/VersionList.cpp

@@ -32,11 +32,11 @@ VersionList::VersionList(const QString& uid, QObject* parent) : BaseVersionList(
     setObjectName("Version list: " + uid);
 }
 
-Task::Ptr VersionList::getLoadTask()
+Task::Ptr VersionList::getLoadTask(bool forceReload)
 {
     auto loadTask = makeShared<SequentialTask>(tr("Load meta for %1", "This is for the task name that loads the meta index.").arg(m_uid));
-    loadTask->addTask(APPLICATION->metadataIndex()->loadTask(Net::Mode::Online));
+    loadTask->addTask(APPLICATION->metadataIndex()->loadTask(Net::Mode::Online, forceReload));
-    loadTask->addTask(this->loadTask(Net::Mode::Online));
+    loadTask->addTask(this->loadTask(Net::Mode::Online, forceReload));
     return loadTask;
 }
 

launcher/meta/VersionList.h

@@ -37,7 +37,7 @@ class VersionList : public BaseVersionList, public BaseEntity {
     enum Roles { UidRole = Qt::UserRole + 100, TimeRole, RequiresRole, VersionPtrRole };
 
     bool isLoaded() override;
-    Task::Ptr getLoadTask() override;
+    Task::Ptr getLoadTask(bool forceReload = false) override;
     const BaseVersion::Ptr at(int i) const override;
     int count() const override;
     void sortVersions() override;

launcher/minecraft/AssetsUtils.cpp

@@ -104,7 +104,7 @@ bool loadAssetsIndexJson(const QString& assetsId, const QString& path, AssetsInd
     // Try to open the file and fail if we can't.
     // TODO: We should probably report this error to the user.
     if (!file.open(QIODevice::ReadOnly)) {
-        qCritical() << "Failed to read assets index file" << path;
+        qCritical() << "Failed to read assets index file" << path << "error:" << file.errorString();
         return false;
     }
     index.id = assetsId;

launcher/minecraft/LaunchProfile.cpp

@@ -349,7 +349,8 @@ void LaunchProfile::getLibraryFiles(const RuntimeContext& runtimeContext,
                                     QStringList& jars,
                                     QStringList& nativeJars,
                                     const QString& overridePath,
-                                    const QString& tempPath) const
+                                    const QString& tempPath,
+                                    bool addJarMods) const
 {
     QStringList native32, native64;
     jars.clear();
@@ -360,7 +361,7 @@ void LaunchProfile::getLibraryFiles(const RuntimeContext& runtimeContext,
     // NOTE: order is important here, add main jar last to the lists
     if (m_mainJar) {
         // FIXME: HACK!! jar modding is weird and unsystematic!
-        if (m_jarMods.size()) {
+        if (m_jarMods.size() && addJarMods) {
             QDir tempDir(tempPath);
             jars.append(tempDir.absoluteFilePath("minecraft.jar"));
         } else {

launcher/minecraft/LaunchProfile.h

@@ -87,7 +87,8 @@ class LaunchProfile : public ProblemProvider {
                          QStringList& jars,
                          QStringList& nativeJars,
                          const QString& overridePath,
-                         const QString& tempPath) const;
+                         const QString& tempPath,
+                         bool addJarMods = true) const;
     bool hasTrait(const QString& trait) const;
     ProblemSeverity getProblemSeverity() const override;
     const QList<PatchProblem> getProblems() const override;

launcher/minecraft/Library.cpp

@@ -149,7 +149,7 @@ QList<Net::NetRequest::Ptr> Library::getDownloads(const RuntimeContext& runtimeC
         if (sha1.size()) {
             auto dl = Net::ApiDownload::makeCached(url, entry, options);
             dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Sha1, sha1));
-            qDebug() << "Checksummed Download for:" << rawName().serialize() << "storage:" << storage << "url:" << url;
+            qDebug() << "Checksummed Download for:" << rawName().serialize() << "storage:" << storage << "url:" << url << "expected sha1:" << sha1;
             out.append(dl);
         } else {
             out.append(Net::ApiDownload::makeCached(url, entry, options));

launcher/minecraft/MinecraftInstance.cpp

@@ -59,6 +59,7 @@
 #include "minecraft/launch/AutoInstallJava.h"
 #include "minecraft/launch/ClaimAccount.h"
 #include "minecraft/launch/CreateGameFolders.h"
+#include "minecraft/launch/EnsureAvailableMemory.h"
 #include "minecraft/launch/EnsureOfflineLibraries.h"
 #include "minecraft/launch/ExtractNatives.h"
 #include "minecraft/launch/LauncherPartLaunch.h"
@@ -130,7 +131,8 @@
     for (const auto& gpu : gpus) {
         QString name = qvariant_cast<QString>(gpu[QStringLiteral("Name")]);
         bool defaultGpu = qvariant_cast<bool>(gpu[QStringLiteral("Default")]);
-        if (!defaultGpu) {
+        bool discrete = qvariant_cast<bool>(gpu.value(QStringLiteral("Discrete"), !defaultGpu));
+        if (discrete) {
             QStringList envList = qvariant_cast<QStringList>(gpu[QStringLiteral("Environment")]);
             for (int i = 0; i + 1 < envList.size(); i += 2) {
                 env.insert(envList[i], envList[i + 1]);
@@ -208,6 +210,7 @@ void MinecraftInstance::loadSpecificSettings()
         m_settings->registerOverride(global_settings->getSetting("MinMemAlloc"), memorySetting);
         m_settings->registerOverride(global_settings->getSetting("MaxMemAlloc"), memorySetting);
         m_settings->registerOverride(global_settings->getSetting("PermGen"), memorySetting);
+        m_settings->registerOverride(global_settings->getSetting("LowMemWarning"), memorySetting);
 
         // Native library workarounds
         auto nativeLibraryWorkaroundsOverride = m_settings->registerSetting("OverrideNativeWorkarounds", false);
@@ -890,6 +893,14 @@ QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session, Minecr
 
     QStringList out;
 
+    out << "Components:";
+    for (int i = 0; i < m_components->rowCount(); ++i) {
+        const auto& component = m_components->getComponent(i);
+        out << indent +
+                   QString("%1) %2 (%3) %4").arg(QString::number(i + 1), component->getName(), component->getID(), component->getVersion());
+    }
+    out << emptyLine;
+
     out << "Launcher: " + getLauncher();
     out << "Main class: " + getMainClass() << emptyLine;
 
@@ -1191,6 +1202,11 @@ LaunchTask* MinecraftInstance::createLaunchTask(AuthSessionPtr session, Minecraf
         process->appendStep(makeShared<ScanModFolders>(pptr));
     }
 
+    // make sure we have enough RAM, warn the user if we don't
+    {
+        process->appendStep(makeShared<EnsureAvailableMemory>(pptr, this));
+    }
+
     // print some instance info here...
     {
         process->appendStep(makeShared<PrintInstanceInfo>(pptr, session, targetToJoin));

launcher/minecraft/ProfileUtils.cpp

@@ -144,13 +144,13 @@ bool saveJsonFile(const QJsonDocument& doc, const QString& filename)
     auto data = doc.toJson();
     QSaveFile jsonFile(filename);
     if (!jsonFile.open(QIODevice::WriteOnly)) {
+        qWarning() << "Couldn't open" << filename << "for writing:" << jsonFile.errorString();
         jsonFile.cancelWriting();
-        qWarning() << "Couldn't open" << filename << "for writing";
         return false;
     }
     jsonFile.write(data);
     if (!jsonFile.commit()) {
-        qWarning() << "Couldn't save" << filename;
+        qWarning() << "Couldn't save" << filename << "error:" << jsonFile.errorString();
         return false;
     }
     return true;

launcher/minecraft/ShortcutUtils.cpp

@@ -71,7 +71,7 @@ bool createInstanceShortcut(const Shortcut& shortcut, const QString& filePath)
 
     QFile iconFile(iconPath);
     if (!iconFile.open(QFile::WriteOnly)) {
-        QMessageBox::critical(shortcut.parent, QObject::tr("Create Shortcut"), QObject::tr("Failed to create icon for application."));
+        QMessageBox::critical(shortcut.parent, QObject::tr("Create Shortcut"), QObject::tr("Failed to create icon for application: %1").arg(iconFile.errorString()));
         return false;
     }
 
@@ -101,7 +101,7 @@ bool createInstanceShortcut(const Shortcut& shortcut, const QString& filePath)
 
     QFile iconFile(iconPath);
     if (!iconFile.open(QFile::WriteOnly)) {
-        QMessageBox::critical(shortcut.parent, QObject::tr("Create Shortcut"), QObject::tr("Failed to create icon for shortcut."));
+        QMessageBox::critical(shortcut.parent, QObject::tr("Create Shortcut"), QObject::tr("Failed to create icon for shortcut: %1").arg(iconFile.errorString()));
         return false;
     }
     bool success = icon->icon().pixmap(64, 64).save(&iconFile, "PNG");
@@ -127,7 +127,7 @@ bool createInstanceShortcut(const Shortcut& shortcut, const QString& filePath)
 
     QFile iconFile(iconPath);
     if (!iconFile.open(QFile::WriteOnly)) {
-        QMessageBox::critical(shortcut.parent, QObject::tr("Create Shortcut"), QObject::tr("Failed to create icon for shortcut."));
+        QMessageBox::critical(shortcut.parent, QObject::tr("Create Shortcut"), QObject::tr("Failed to create icon for shortcut: %1").arg(iconFile.errorString()));
         return false;
     }
     bool success = icon->icon().pixmap(64, 64).save(&iconFile, "ICO");

launcher/minecraft/VanillaInstanceCreationTask.cpp

@@ -7,30 +7,27 @@
 #include "minecraft/PackProfile.h"
 #include "settings/INISettingsObject.h"
 
-VanillaCreationTask::VanillaCreationTask(BaseVersion::Ptr version, QString loader, BaseVersion::Ptr loader_version)
+VanillaCreationTask::VanillaCreationTask(BaseVersion::Ptr version, QString loader, BaseVersion::Ptr loaderVersion)
-    : InstanceCreationTask()
+    : m_version(std::move(version)), m_using_loader(true), m_loader(std::move(loader)), m_loader_version(std::move(loaderVersion))
-    , m_version(std::move(version))
-    , m_using_loader(true)
-    , m_loader(std::move(loader))
-    , m_loader_version(std::move(loader_version))
 {}
 
 std::unique_ptr<MinecraftInstance> VanillaCreationTask::createInstance()
 {
     setStatus(tr("Creating instance from version %1").arg(m_version->name()));
 
-    auto inst = std::make_unique<MinecraftInstance>(m_globalSettings, std::make_unique<INISettingsObject>(FS::PathCombine(m_stagingPath, "instance.cfg")),
+    auto inst = std::make_unique<MinecraftInstance>(
-                           m_stagingPath);
+        m_globalSettings, std::make_unique<INISettingsObject>(FS::PathCombine(m_stagingPath, "instance.cfg")), m_stagingPath);
     SettingsObject::Lock lock(inst->settings());
 
-    auto components = inst->getPackProfile();
+    auto* components = inst->getPackProfile();
     components->buildingFromScratch();
     components->setComponentVersion("net.minecraft", m_version->descriptor(), true);
-    if (m_using_loader)
+    if (m_using_loader) {
         components->setComponentVersion(m_loader, m_loader_version->descriptor());
+    }
 
     inst->setName(name());
     inst->setIconKey(m_instIcon);
-
+    components->saveNow();
     return inst;
 }

launcher/minecraft/VanillaInstanceCreationTask.h

@@ -7,8 +7,8 @@
 class VanillaCreationTask final : public InstanceCreationTask {
     Q_OBJECT
    public:
-    VanillaCreationTask(BaseVersion::Ptr version) : InstanceCreationTask(), m_version(std::move(version)) {}
+    explicit VanillaCreationTask(BaseVersion::Ptr version) : m_version(std::move(version)) {}
-    VanillaCreationTask(BaseVersion::Ptr version, QString loader, BaseVersion::Ptr loader_version);
+    VanillaCreationTask(BaseVersion::Ptr version, QString loader, BaseVersion::Ptr loaderVersion);
 
     std::unique_ptr<MinecraftInstance> createInstance() override;
 

launcher/minecraft/World.cpp

@@ -274,9 +274,6 @@ void World::readFromZip(const QFileInfo& file)
         QFileInfo fi(filePath);
         if (fi.fileName().compare(levelDat, Qt::CaseInsensitive) == 0) {
             m_containerOffsetPath = filePath.chopped(levelDat.length());
-            if (!m_containerOffsetPath.isEmpty()) {
-                return false;
-            }
             m_levelDatTime = file->dateTime();
             loadFromLevelDat(file->readAll());
             m_isValid = true;

launcher/minecraft/WorldList.cpp

@@ -157,7 +157,8 @@ bool WorldList::resetIcon(int row)
         return false;
     World& m = m_worlds[row];
     if (m.resetIcon()) {
-        emit dataChanged(index(row), index(row), { WorldList::IconFileRole });
+        QModelIndex modelIndex = index(row, NameColumn);
+        emit dataChanged(modelIndex, modelIndex, { WorldList::IconFileRole });
         return true;
     }
     return false;
@@ -426,7 +427,7 @@ void WorldList::loadWorldsAsync()
                         m_worlds[row].setSize(size);
 
                         // Notify views
-                        QModelIndex modelIndex = index(row);
+                        QModelIndex modelIndex = index(row, SizeColumn);
                         emit dataChanged(modelIndex, modelIndex, { SizeRole });
                     }
                 },

launcher/minecraft/auth/AccountData.h

@@ -41,6 +41,7 @@
 
 #include <QDateTime>
 #include <QMap>
+#include <QNetworkReply>
 #include <QVariantMap>
 
 enum class Validity { None, Assumed, Certain };
@@ -118,5 +119,6 @@ struct AccountData {
     // runtime only information (not saved with the account)
     QString internalId;
     QString errorString;
+    QNetworkReply::NetworkError networkError = QNetworkReply::NoError;
     AccountState accountState = AccountState::Unchecked;
 };

launcher/minecraft/auth/AccountList.cpp

@@ -450,7 +450,7 @@ bool AccountList::loadList()
     // Try to open the file and fail if we can't.
     // TODO: We should probably report this error to the user.
     if (!file.open(QIODevice::ReadOnly)) {
-        qCritical() << QString("Failed to read the account list file (%1).").arg(m_listFilePath).toUtf8();
+        qCritical() << QString("Failed to read the account list file %1 (%2).").arg(m_listFilePath).arg(file.errorString()).toUtf8();
         return false;
     }
 
@@ -567,7 +567,7 @@ bool AccountList::saveList()
     // Try to open the file and fail if we can't.
     // TODO: We should probably report this error to the user.
     if (!file.open(QIODevice::WriteOnly)) {
-        qCritical() << QString("Failed to read the account list file (%1).").arg(m_listFilePath).toUtf8();
+        qCritical() << QString("Failed to save the account list file %1 (%2).").arg(m_listFilePath).arg(file.errorString()).toUtf8();
         return false;
     }
 
@@ -578,7 +578,7 @@ bool AccountList::saveList()
         qDebug() << "Saved account list to" << m_listFilePath;
         return true;
     } else {
-        qDebug() << "Failed to save accounts to" << m_listFilePath;
+        qDebug() << "Failed to save accounts to" << m_listFilePath << "error:" << file.errorString();
         return false;
     }
 }
@@ -648,9 +648,17 @@ void AccountList::tryNext()
     while (m_refreshQueue.length()) {
         auto accountId = m_refreshQueue.front();
         m_refreshQueue.pop_front();
+        bool found = false;
         for (int i = 0; i < count(); i++) {
             auto account = at(i);
             if (account->internalId() == accountId) {
+                found = true;
+                if (!account->shouldRefresh()) {
+                    // Account no longer needs refreshing, skip it.
+                    qDebug() << "RefreshSchedule: Skipping account" << account->profileName() << "with internal ID"
+                             << accountId << "(no longer needs refresh)";
+                    break;
+                }
                 m_currentTask = account->refresh();
                 if (m_currentTask) {
                     connect(m_currentTask.get(), &Task::succeeded, this, &AccountList::authSucceeded);
@@ -660,9 +668,12 @@ void AccountList::tryNext()
                              << accountId;
                     return;
                 }
+                break;
             }
         }
-        qDebug() << "RefreshSchedule: Account with internal ID" << accountId << "not found.";
+        if (!found) {
+            qDebug() << "RefreshSchedule: Account with internal ID" << accountId << "not found.";
+        }
     }
     // if we get here, no account needed refreshing. Schedule refresh in an hour.
     m_refreshTimer->start(1000 * 3600);

launcher/minecraft/auth/steps/LauncherLoginStep.cpp

@@ -56,10 +56,11 @@ void LauncherLoginStep::onRequestDone(QByteArray* response)
     qCDebug(authCredentials()) << *response;
     if (m_request->error() != QNetworkReply::NoError) {
         qWarning() << "Reply error:" << m_request->error();
-        if (Net::isApplicationError(m_request->error())) {
+        if (Net::isApplicationError(m_request->error()) && !Net::isServerError(m_request->error())) {
             emit finished(AccountTaskState::STATE_FAILED_SOFT,
                           tr("Failed to get Minecraft access token: %1").arg(m_request->errorString()));
         } else {
+            m_data->networkError = m_request->error();
             emit finished(AccountTaskState::STATE_OFFLINE, tr("Failed to get Minecraft access token: %1").arg(m_request->errorString()));
         }
         return;

launcher/minecraft/auth/steps/MSADeviceCodeStep.cpp

@@ -113,6 +113,12 @@ DeviceAuthorizationResponse parseDeviceAuthorizationResponse(const QByteArray& d
 
 void MSADeviceCodeStep::deviceAuthorizationFinished(QByteArray* response)
 {
+    if (!m_request->wasSuccessful() || m_request->error() != QNetworkReply::NoError) {
+        qWarning() << "Device authorization failed:" << m_request->error() << m_request->errorString();
+        emit finished(AccountTaskState::STATE_FAILED_HARD, tr("Device authorization failed: %1").arg(m_request->errorString()));
+        return;
+    }
+
     auto rsp = parseDeviceAuthorizationResponse(*response);
     if (!rsp.error.isEmpty() || !rsp.error_description.isEmpty()) {
         qWarning() << "Device authorization failed:" << rsp.error;
@@ -120,12 +126,6 @@ void MSADeviceCodeStep::deviceAuthorizationFinished(QByteArray* response)
                       tr("Device authorization failed: %1").arg(rsp.error_description.isEmpty() ? rsp.error : rsp.error_description));
         return;
     }
-    if (!m_request->wasSuccessful() || m_request->error() != QNetworkReply::NoError) {
-        qWarning() << "Device authorization failed:" << *response;
-        emit finished(AccountTaskState::STATE_FAILED_HARD, tr("Failed to retrieve device authorization"));
-        return;
-    }
-
     if (rsp.device_code.isEmpty() || rsp.user_code.isEmpty() || rsp.verification_uri.isEmpty() || rsp.expires_in == 0) {
         qWarning() << "Device authorization failed: required fields missing";
         emit finished(AccountTaskState::STATE_FAILED_HARD, tr("Device authorization failed: required fields missing"));

launcher/minecraft/auth/steps/MinecraftProfileStep.cpp

@@ -52,10 +52,11 @@ void MinecraftProfileStep::onRequestDone(QByteArray* response)
         qWarning() << " Response:";
         qWarning() << QString::fromUtf8(*response);
 
-        if (Net::isApplicationError(m_request->error())) {
+        if (Net::isApplicationError(m_request->error()) && !Net::isServerError(m_request->error())) {
             emit finished(AccountTaskState::STATE_FAILED_SOFT,
                           tr("Minecraft Java profile acquisition failed: %1").arg(m_request->errorString()));
         } else {
+            m_data->networkError = m_request->error();
             emit finished(AccountTaskState::STATE_OFFLINE,
                           tr("Minecraft Java profile acquisition failed: %1").arg(m_request->errorString()));
         }

launcher/minecraft/auth/steps/XboxAuthorizationStep.cpp

@@ -2,7 +2,7 @@
 
 #include <QJsonDocument>
 #include <QJsonParseError>
-#include <QNetworkRequest>
+#include <utility>
 
 #include "Application.h"
 #include "Logging.h"
@@ -12,7 +12,7 @@
 #include "net/Upload.h"
 
 XboxAuthorizationStep::XboxAuthorizationStep(AccountData* data, Token* token, QString relyingParty, QString authorizationKind)
-    : AuthStep(data), m_token(token), m_relyingParty(relyingParty), m_authorizationKind(authorizationKind)
+    : AuthStep(data), m_token(token), m_relyingParty(std::move(relyingParty)), m_authorizationKind(std::move(authorizationKind))
 {}
 
 QString XboxAuthorizationStep::describe()
@@ -22,7 +22,7 @@ QString XboxAuthorizationStep::describe()
 
 void XboxAuthorizationStep::perform()
 {
-    QString xbox_auth_template = R"XXX(
+    const QString xboxAuthTemplate = R"XXX(
 {
     "Properties": {
         "SandboxId": "RETAIL",
@@ -34,15 +34,13 @@ void XboxAuthorizationStep::perform()
     "TokenType": "JWT"
 }
 )XXX";
-    auto xbox_auth_data = xbox_auth_template.arg(m_data->userToken.token, m_relyingParty);
+    const auto xboxAuthData = xboxAuthTemplate.arg(m_data->userToken.token, m_relyingParty);
     // http://xboxlive.com
-    QUrl url("https://xsts.auth.xboxlive.com/xsts/authorize");
+    const QUrl url("https://xsts.auth.xboxlive.com/xsts/authorize");
-    auto headers = QList<Net::HeaderPair>{
+    auto headers = QList<Net::HeaderPair>{ { .headerName = "Content-Type", .headerValue = "application/json" },
-        { "Content-Type", "application/json" },
+                                           { .headerName = "Accept", .headerValue = "application/json" },
-        { "Accept", "application/json" },
+                                           { .headerName = "x-xbl-contract-version", .headerValue = "1" } };
-        { "x-xbl-contract-version", "1" }
+    auto [request, response] = Net::Upload::makeByteArray(url, xboxAuthData.toUtf8());
-    };
-    auto [request, response] = Net::Upload::makeByteArray(url, xbox_auth_data.toUtf8());
     m_request = request;
     m_request->addHeaderProxy(std::make_unique<Net::RawHeaderProxy>(headers));
     m_request->enableAutoRetry(true);
@@ -62,15 +60,14 @@ void XboxAuthorizationStep::onRequestDone(QByteArray* response)
     qCDebug(authCredentials()) << *response;
     if (m_request->error() != QNetworkReply::NoError) {
         qWarning() << "Reply error:" << m_request->error();
-        if (Net::isApplicationError(m_request->error())) {
+        if (Net::isApplicationError(m_request->error()) && !Net::isServerError(m_request->error())) {
-            if (!processSTSError(*response)) {
+            if (processSTSError(*response)) {
-                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                return;
-                              tr("Failed to get authorization for %1 services. Error %2.").arg(m_authorizationKind, m_request->error()));
-            } else {
-                emit finished(AccountTaskState::STATE_FAILED_SOFT,
-                              tr("Unknown STS error for %1 services: %2").arg(m_authorizationKind, m_request->errorString()));
             }
+            emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                          tr("Unknown STS error for %1 services: %2").arg(m_authorizationKind, m_request->errorString()));
         } else {
+            m_data->networkError = m_request->error();
             emit finished(AccountTaskState::STATE_OFFLINE,
                           tr("Failed to get authorization for %1 services: %2").arg(m_authorizationKind, m_request->errorString()));
         }
@@ -99,8 +96,8 @@ bool XboxAuthorizationStep::processSTSError(const QByteArray& response)
 {
     if (m_request->error() == QNetworkReply::AuthenticationRequiredError) {
         QJsonParseError jsonError;
-        QJsonDocument doc = QJsonDocument::fromJson(response, &jsonError);
+        const QJsonDocument doc = QJsonDocument::fromJson(response, &jsonError);
-        if (jsonError.error) {
+        if (jsonError.error != QJsonParseError::NoError) {
             qWarning() << "Cannot parse error XSTS response as JSON:" << jsonError.errorString();
             emit finished(AccountTaskState::STATE_FAILED_SOFT,
                           tr("Cannot parse %1 authorization error response as JSON: %2").arg(m_authorizationKind, jsonError.errorString()));

launcher/minecraft/auth/steps/XboxUserStep.cpp

@@ -56,9 +56,10 @@ void XboxUserStep::onRequestDone(QByteArray* response)
 {
     if (m_request->error() != QNetworkReply::NoError) {
         qWarning() << "Reply error:" << m_request->error();
-        if (Net::isApplicationError(m_request->error())) {
+        if (Net::isApplicationError(m_request->error()) && !Net::isServerError(m_request->error())) {
             emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Xbox user authentication failed: %1").arg(m_request->errorString()));
         } else {
+            m_data->networkError = m_request->error();
             emit finished(AccountTaskState::STATE_OFFLINE, tr("Xbox user authentication failed: %1").arg(m_request->errorString()));
         }
         return;

launcher/minecraft/launch/EnsureAvailableMemory.cpp

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Octol1ttle <l1ttleofficial@outlook.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "EnsureAvailableMemory.h"
+
+#include "HardwareInfo.h"
+#include "ui/dialogs/CustomMessageBox.h"
+
+EnsureAvailableMemory::EnsureAvailableMemory(LaunchTask* parent, MinecraftInstance* instance) : LaunchStep(parent), m_instance(instance) {}
+
+void EnsureAvailableMemory::executeTask()
+{
+#ifdef Q_OS_MACOS
+    QString text;
+    switch (MacOSHardwareInfo::memoryPressureLevel()) {
+        case MacOSHardwareInfo::MemoryPressureLevel::Normal:
+            emitSucceeded();
+            return;
+        case MacOSHardwareInfo::MemoryPressureLevel::Warning:
+            text =
+                tr("The system is under increased memory pressure.\n"
+                   "This may lead to lag or slowdowns.\n"
+                   "If possible, close other applications before continuing.\n\n"
+                   "Launch anyway?");
+            break;
+        case MacOSHardwareInfo::MemoryPressureLevel::Critical:
+            text =
+                tr("Your system is under critical memory pressure.\n"
+                   "This may lead to severe slowdowns, crashes or system instability.\n"
+                   "It is recommended to close other applications or restart your system.\n\n"
+                   "Launch anyway?");
+            break;
+    }
+
+    bool shouldAbort = false;
+
+    if (m_instance->settings()->get("LowMemWarning").toBool()) {
+        auto* dialog = CustomMessageBox::selectable(nullptr, tr("High memory pressure"), text, QMessageBox::Icon::Warning,
+                                                    QMessageBox::StandardButton::Yes | QMessageBox::StandardButton::No,
+                                                    QMessageBox::StandardButton::No);
+
+        shouldAbort = dialog->exec() == QMessageBox::No;
+        dialog->deleteLater();
+    }
+
+    const auto message = tr("The system is under high memory pressure");
+    if (shouldAbort) {
+        emit logLine(message, MessageLevel::Fatal);
+        emitFailed(message);
+        return;
+    }
+
+    emit logLine(message, MessageLevel::Warning);
+    emitSucceeded();
+#else
+    const uint64_t available = HardwareInfo::availableRamMiB();
+    if (available == 0) {
+        // could not read
+        emitSucceeded();
+        return;
+    }
+
+    const uint64_t settingMin = m_instance->settings()->get("MinMemAlloc").toUInt();
+    const uint64_t settingMax = m_instance->settings()->get("MaxMemAlloc").toUInt();
+    const uint64_t max = std::max(settingMin, settingMax);
+
+    if (static_cast<double>(max) * 0.9 > static_cast<double>(available)) {
+        bool shouldAbort = false;
+
+        if (m_instance->settings()->get("LowMemWarning").toBool()) {
+            auto* dialog = CustomMessageBox::selectable(
+                nullptr, tr("Low free memory"),
+                tr("There might not be enough free RAM to launch this instance with the current memory settings.\n\n"
+                   "Maximum allocated: %1 MiB\nFree: %2 MiB (out of %3 MiB total)\n\n"
+                   "Launch anyway? This may cause slowdowns in the game and your system.")
+                    .arg(max)
+                    .arg(available)
+                    .arg(HardwareInfo::totalRamMiB()),
+                QMessageBox::Icon::Warning, QMessageBox::StandardButton::Yes | QMessageBox::StandardButton::No,
+                QMessageBox::StandardButton::No);
+
+            shouldAbort = dialog->exec() == QMessageBox::No;
+            dialog->deleteLater();
+        }
+
+        const auto message = tr("Not enough RAM available to launch this instance");
+        if (shouldAbort) {
+            emit logLine(message, MessageLevel::Fatal);
+            emitFailed(message);
+            return;
+        }
+
+        emit logLine(message, MessageLevel::Warning);
+    }
+
+    emitSucceeded();
+#endif
+}

launcher/minecraft/launch/EnsureAvailableMemory.h

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Octol1ttle <l1ttleofficial@outlook.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "launch/LaunchStep.h"
+#include "minecraft/MinecraftInstance.h"
+
+class EnsureAvailableMemory : public LaunchStep {
+    Q_OBJECT
+
+   public:
+    explicit EnsureAvailableMemory(LaunchTask* parent, MinecraftInstance* instance);
+    ~EnsureAvailableMemory() override = default;
+
+    void executeTask() override;
+    bool canAbort() const override { return false; }
+
+   private:
+    MinecraftInstance* m_instance;
+};

launcher/minecraft/launch/EnsureOfflineLibraries.cpp

@@ -27,16 +27,27 @@ void EnsureOfflineLibraries::executeTask()
 {
     const auto profile = m_instance->getPackProfile()->getProfile();
     QStringList allJars;
-    profile->getLibraryFiles(m_instance->runtimeContext(), allJars, allJars, m_instance->getLocalLibraryPath(), m_instance->binRoot());
+    profile->getLibraryFiles(m_instance->runtimeContext(), allJars, allJars, m_instance->getLocalLibraryPath(), m_instance->binRoot(),
+                             false);
+
+    QStringList missing;
     for (const auto& jar : allJars) {
         if (!QFileInfo::exists(jar)) {
-            emit logLine(tr("This instance cannot be launched because some libraries are missing or have not been downloaded yet. Please "
+            missing.append(jar);
-                            "try again in online mode with a working Internet connection"),
-                         MessageLevel::Fatal);
-            emitFailed("Required libraries are missing");
-            return;
         }
     }
 
-    emitSucceeded();
+    if (missing.isEmpty()) {
+        emitSucceeded();
+        return;
+    }
+
+    emit logLine("Missing libraries:", MessageLevel::Error);
+    for (const auto& jar : missing) {
+        emit logLine("  " + jar, MessageLevel::Error);
+    }
+    emit logLine(tr("\nThis instance cannot be launched because some libraries are missing or have not been downloaded yet. Please "
+                    "try again in online mode with a working Internet connection"),
+                 MessageLevel::Fatal);
+    emitFailed("Required libraries are missing");
 }

launcher/minecraft/launch/LauncherPartLaunch.cpp

@@ -164,9 +164,9 @@ void LauncherPartLaunch::on_state(LoggedProcess::State state)
     switch (state) {
         case LoggedProcess::FailedToStart: {
             //: Error message displayed if instace can't start
-            const char* reason = QT_TR_NOOP("Could not launch Minecraft!");
+            const char* reason = QT_TR_NOOP("Could not launch Minecraft: %1");
-            emit logLine(reason, MessageLevel::Fatal);
+            emit logLine(QString(reason).arg(m_process.errorString()), MessageLevel::Fatal);
-            emitFailed(tr(reason));
+            emitFailed(tr(reason).arg(m_process.errorString()));
             return;
         }
         case LoggedProcess::Aborted:

launcher/minecraft/launch/PrintInstanceInfo.cpp

@@ -61,13 +61,19 @@ void PrintInstanceInfo::executeTask()
     auto instance = m_parent->instance();
     QStringList log;
 
+    log << "";
     log << "OS: " + QString("%1 | %2 | %3").arg(QSysInfo::prettyProductName(), QSysInfo::kernelType(), QSysInfo::kernelVersion());
 #ifdef Q_OS_FREEBSD
     ::runSysctlHwModel(log);
     ::runPciconf(log);
 #else
     log << "CPU: " + HardwareInfo::cpuInfo();
+#ifdef Q_OS_MACOS
+    log << "Memory pressure level: " + MacOSHardwareInfo::memoryPressureLevelName();
+#else
     log << QString("RAM: %1 MiB (available: %2 MiB)").arg(HardwareInfo::totalRamMiB()).arg(HardwareInfo::availableRamMiB());
+#endif
+
 #endif
     log.append(HardwareInfo::gpuInfo());
     log << "";

launcher/minecraft/mod/DataPack.cpp

@@ -216,7 +216,7 @@ static std::pair<Version, Version> map(int format, const QMap<std::pair<int, int
 int DataPack::compare(const Resource& other, SortType type) const
 {
     const auto& cast_other = static_cast<const DataPack&>(other);
-    if (type == SortType::PACK_FORMAT) {
+    if (type == SortType::PackFormat) {
         auto this_ver = packFormat();
         auto other_ver = cast_other.packFormat();
 

launcher/minecraft/mod/DataPackFolderModel.cpp

@@ -40,25 +40,26 @@
 #include <QIcon>
 #include <QStyle>
 
-#include "Version.h"
-
 #include "minecraft/mod/tasks/LocalDataPackParseTask.h"
 
-DataPackFolderModel::DataPackFolderModel(const QString& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent)
+DataPackFolderModel::DataPackFolderModel(const QString& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent)
-    : ResourceFolderModel(QDir(dir), instance, is_indexed, create_dir, parent)
+    : ResourceFolderModel(QDir(dir), instance, isIndexed, createDir, parent)
 {
-    m_column_names = QStringList({ "Enable", "Image", "Name", "Pack Format", "Last Modified" });
+    m_columnNames = QStringList({ "Enable", "Image", "Name", "Pack Format", "Last Modified", "Size", "File Name" });
-    m_column_names_translated = QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Pack Format"), tr("Last Modified") });
+    m_columnNamesTranslated =
-    m_column_sort_keys = { SortType::ENABLED, SortType::NAME, SortType::NAME, SortType::PACK_FORMAT, SortType::DATE };
+        QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Pack Format"), tr("Last Modified"), tr("Size"), tr("File Name") });
-    m_column_resize_modes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch, QHeaderView::Interactive,
+    m_columnSortKeys = { SortType::Enabled, SortType::Name, SortType::Name,    SortType::PackFormat,
-                              QHeaderView::Interactive };
+                         SortType::Date,    SortType::Size, SortType::Filename };
-    m_columnsHideable = { false, true, false, true, true };
+    m_columnResizeModes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,    QHeaderView::Interactive,
+                            QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
+    m_columnsHideable = { false, true, false, true, true, true, true };
 }
 
 QVariant DataPackFolderModel::data(const QModelIndex& index, int role) const
 {
-    if (!validateIndex(index))
+    if (!validateIndex(index)) {
         return {};
+    }
 
     int row = index.row();
     int column = index.column();
@@ -67,11 +68,13 @@ QVariant DataPackFolderModel::data(const QModelIndex& index, int role) const
         case Qt::BackgroundRole:
             return rowBackground(row);
         case Qt::DisplayRole:
-            switch (column) {
+            if (column == PackFormatColumn) {
-                case PackFormatColumn: {
+                const auto& resource = at(row);
-                    const auto& resource = at(row);
+                return resource.packFormatStr();
-                    return resource.packFormatStr();
+            }
-                }
+            if (column == SizeColumn) {
+                const auto& resource = at(row);
+                return resource.sizeStr();
             }
             break;
         case Qt::DecorationRole: {
@@ -92,6 +95,8 @@ QVariant DataPackFolderModel::data(const QModelIndex& index, int role) const
                 return QSize(32, 32);
             }
             break;
+        default:
+            break;
     }
 
     // map the columns to the base equivilents
@@ -109,7 +114,14 @@ QVariant DataPackFolderModel::data(const QModelIndex& index, int role) const
         case ProviderColumn:
             mappedIndex = index.siblingAtColumn(ResourceFolderModel::ProviderColumn);
             break;
-            // FIXME: there is no size column due to an oversight
+        case FileNameColumn:
+            mappedIndex = index.siblingAtColumn(ResourceFolderModel::FileNameColumn);
+            break;
+        case SizeColumn:
+            mappedIndex = index.siblingAtColumn(ResourceFolderModel::SizeColumn);
+            break;
+        default:
+            break;
     }
 
     if (mappedIndex.isValid()) {
@@ -129,6 +141,8 @@ QVariant DataPackFolderModel::headerData(int section, [[maybe_unused]] Qt::Orien
                 case PackFormatColumn:
                 case DateColumn:
                 case ImageColumn:
+                case SizeColumn:
+                case FileNameColumn:
                     return columnNames().at(section);
                 default:
                     return {};
@@ -145,6 +159,10 @@ QVariant DataPackFolderModel::headerData(int section, [[maybe_unused]] Qt::Orien
                     return tr("The data pack format ID, as well as the Minecraft versions it was designed for.");
                 case DateColumn:
                     return tr("The date and time this data pack was last changed (or added).");
+                case SizeColumn:
+                    return tr("The size of the data pack.");
+                case FileNameColumn:
+                    return tr("The file name of the data pack.");
                 default:
                     return {};
             }
@@ -160,7 +178,7 @@ QVariant DataPackFolderModel::headerData(int section, [[maybe_unused]] Qt::Orien
 
 int DataPackFolderModel::columnCount(const QModelIndex& parent) const
 {
-    return parent.isValid() ? 0 : NUM_COLUMNS;
+    return parent.isValid() ? 0 : NumColumns;
 }
 
 Resource* DataPackFolderModel::createResource(const QFileInfo& file)
@@ -170,5 +188,5 @@ Resource* DataPackFolderModel::createResource(const QFileInfo& file)
 
 Task* DataPackFolderModel::createParseTask(Resource& resource)
 {
-    return new LocalDataPackParseTask(m_next_resolution_ticket, static_cast<DataPack*>(&resource));
+    return new LocalDataPackParseTask(m_nextResolutionTicket, static_cast<DataPack*>(&resource));
 }

launcher/minecraft/mod/DataPackFolderModel.h

@@ -39,16 +39,24 @@
 #include "ResourceFolderModel.h"
 
 #include "DataPack.h"
-#include "ResourcePack.h"
 
 class DataPackFolderModel : public ResourceFolderModel {
     Q_OBJECT
    public:
-    enum Columns { ActiveColumn = 0, ImageColumn, NameColumn, PackFormatColumn, DateColumn, NUM_COLUMNS };
+    enum Columns : std::uint8_t {
+        ActiveColumn = 0,
+        ImageColumn,
+        NameColumn,
+        PackFormatColumn,
+        DateColumn,
+        SizeColumn,
+        FileNameColumn,
+        NumColumns
+    };
 
-    explicit DataPackFolderModel(const QString& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent = nullptr);
+    explicit DataPackFolderModel(const QString& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent = nullptr);
 
-    virtual QString id() const override { return "datapacks"; }
+    QString id() const override { return "datapacks"; }
 
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
 
@@ -56,7 +64,7 @@ class DataPackFolderModel : public ResourceFolderModel {
     int columnCount(const QModelIndex& parent) const override;
 
     [[nodiscard]] Resource* createResource(const QFileInfo& file) override;
-    [[nodiscard]] Task* createParseTask(Resource&) override;
+    [[nodiscard]] Task* createParseTask(Resource& /*unused*/) override;
 
     RESOURCE_HELPERS(DataPack)
 };

launcher/minecraft/mod/Mod.cpp

@@ -40,6 +40,7 @@
 #include <QDir>
 #include <QRegularExpression>
 #include <QString>
+#include <algorithm>
 
 #include "MTPixmapCache.h"
 #include "MetadataHandler.h"
@@ -49,6 +50,34 @@
 #include "minecraft/mod/tasks/LocalModParseTask.h"
 #include "modplatform/ModIndex.h"
 
+namespace {
+
+int compareVersionLists(const QStringList& leftVersions, const QStringList& rightVersions)
+{
+    const qsizetype commonSize = std::min(leftVersions.size(), rightVersions.size());
+
+    for (qsizetype i = 0; i < commonSize; i++) {
+        const auto leftVersion = Version(leftVersions.at(i).trimmed());
+        const auto rightVersion = Version(rightVersions.at(i).trimmed());
+
+        if (leftVersion > rightVersion)
+            return 1;
+
+        if (leftVersion < rightVersion)
+            return -1;
+    }
+
+    if (leftVersions.size() > rightVersions.size())
+        return 1;
+
+    if (leftVersions.size() < rightVersions.size())
+        return -1;
+
+    return 0;
+}
+
+}  // namespace
+
 Mod::Mod(const QFileInfo& file) : Resource(file), m_local_details()
 {
     m_enabled = (file.suffix() != "disabled");
@@ -61,18 +90,18 @@ void Mod::setDetails(const ModDetails& details)
 
 int Mod::compare(const Resource& other, SortType type) const
 {
-    auto cast_other = dynamic_cast<Mod const*>(&other);
+    auto cast_other = dynamic_cast<const Mod*>(&other);
     if (!cast_other)
         return Resource::compare(other, type);
 
     switch (type) {
         default:
-        case SortType::ENABLED:
+        case SortType::Enabled:
-        case SortType::NAME:
+        case SortType::Name:
-        case SortType::DATE:
+        case SortType::Date:
-        case SortType::SIZE:
+        case SortType::Size:
             return Resource::compare(other, type);
-        case SortType::VERSION: {
+        case SortType::Version: {
             auto this_ver = Version(version());
             auto other_ver = Version(cast_other->version());
             if (this_ver > other_ver)
@@ -81,38 +110,38 @@ int Mod::compare(const Resource& other, SortType type) const
                 return -1;
             break;
         }
-        case SortType::SIDE: {
+        case SortType::Side: {
             auto compare_result = QString::compare(side(), cast_other->side(), Qt::CaseInsensitive);
             if (compare_result != 0)
                 return compare_result;
             break;
         }
-        case SortType::MC_VERSIONS: {
+        case SortType::McVersions: {
-            auto compare_result = QString::compare(mcVersions(), cast_other->mcVersions(), Qt::CaseInsensitive);
+            auto compare_result = compareVersionLists(mcVersions(), cast_other->mcVersions());
             if (compare_result != 0)
                 return compare_result;
             break;
         }
-        case SortType::LOADERS: {
+        case SortType::Loaders: {
             auto compare_result = QString::compare(loaders(), cast_other->loaders(), Qt::CaseInsensitive);
             if (compare_result != 0)
                 return compare_result;
             break;
         }
-        case SortType::RELEASE_TYPE: {
+        case SortType::ReleaseType: {
             auto compare_result = QString::compare(releaseType(), cast_other->releaseType(), Qt::CaseInsensitive);
             if (compare_result != 0)
                 return compare_result;
             break;
         }
-        case SortType::REQUIRED_BY: {
+        case SortType::RequiredBy: {
             if (requiredByCount() > cast_other->requiredByCount())
                 return 1;
             if (requiredByCount() < cast_other->requiredByCount())
                 return -1;
             break;
         }
-        case SortType::REQUIRES: {
+        case SortType::Requires: {
             if (requiresCount() > cast_other->requiresCount())
                 return 1;
             if (requiresCount() < cast_other->requiresCount())
@@ -197,14 +226,19 @@ auto Mod::side() const -> QString
     return ModPlatform::SideUtils::toString(ModPlatform::Side::UniversalSide);
 }
 
-auto Mod::mcVersions() const -> QString
+auto Mod::mcVersions() const -> QStringList
 {
     if (metadata())
-        return metadata()->mcVersions.join(", ");
+        return metadata()->mcVersions;
 
     return {};
 }
 
+auto Mod::mcVersionsString() const -> QString
+{
+    return mcVersions().join(", ");
+}
+
 auto Mod::releaseType() const -> QString
 {
     if (metadata())

launcher/minecraft/mod/Mod.h

@@ -68,7 +68,8 @@ class Mod : public Resource {
     auto issueTracker() const -> QString;
     auto side() const -> QString;
     auto loaders() const -> QString;
-    auto mcVersions() const -> QString;
+    auto mcVersions() const -> QStringList;
+    auto mcVersionsString() const -> QString;
     auto releaseType() const -> QString;
     QStringList dependencies() const;
 

launcher/minecraft/mod/ModFolderModel.cpp

@@ -51,38 +51,39 @@
 #include <QUrl>
 #include <QUuid>
 #include <algorithm>
+#include <set>
 
-#include "minecraft/Component.h"
 #include "minecraft/mod/Resource.h"
 #include "minecraft/mod/ResourceFolderModel.h"
 #include "minecraft/mod/tasks/LocalModParseTask.h"
 #include "modplatform/ModIndex.h"
 #include "ui/dialogs/CustomMessageBox.h"
 
-ModFolderModel::ModFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent)
+ModFolderModel::ModFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent)
-    : ResourceFolderModel(QDir(dir), instance, is_indexed, create_dir, parent)
+    : ResourceFolderModel(QDir(dir), instance, isIndexed, createDir, parent)
 {
-    m_column_names = QStringList({ "Enable", "Image", "Name", "Version", "Last Modified", "Provider", "Size", "Side", "Loaders",
+    m_columnNames = QStringList({ "Enable", "Image", "Name", "Version", "Last Modified", "Provider", "Size", "Side", "Loaders",
-                                   "Minecraft Versions", "Release Type", "Requires", "Required By" });
+                                  "Minecraft Versions", "Release Type", "Requires", "Required By", "File Name" });
-    m_column_names_translated =
+    m_columnNamesTranslated =
         QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Version"), tr("Last Modified"), tr("Provider"), tr("Size"), tr("Side"),
-                      tr("Loaders"), tr("Minecraft Versions"), tr("Release Type"), tr("Requires"), tr("Required By") });
+                      tr("Loaders"), tr("Minecraft Versions"), tr("Release Type"), tr("Requires"), tr("Required By"), tr("File Name") });
-    m_column_sort_keys = { SortType::ENABLED,      SortType::NAME,     SortType::NAME,       SortType::VERSION, SortType::DATE,
+    m_columnSortKeys = { SortType::Enabled,     SortType::Name,     SortType::Name,       SortType::Version, SortType::Date,
-                           SortType::PROVIDER,     SortType::SIZE,     SortType::SIDE,       SortType::LOADERS, SortType::MC_VERSIONS,
+                         SortType::Provider,    SortType::Size,     SortType::Side,       SortType::Loaders, SortType::McVersions,
-                           SortType::RELEASE_TYPE, SortType::REQUIRES, SortType::REQUIRED_BY };
+                         SortType::ReleaseType, SortType::Requires, SortType::RequiredBy, SortType::Filename };
-    m_column_resize_modes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,     QHeaderView::Interactive,
+    m_columnResizeModes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,     QHeaderView::Interactive,
-                              QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive,
+                            QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive,
-                              QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive,
+                            QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive,
-                              QHeaderView::Interactive };
+                            QHeaderView::Interactive, QHeaderView::Interactive };
-    m_columnsHideable = { false, true, false, true, true, true, true, true, true, true, true, true, true };
+    m_columnsHideable = { false, true, false, true, true, true, true, true, true, true, true, true, true, true };
 
     connect(this, &ModFolderModel::parseFinished, this, &ModFolderModel::onParseFinished);
 }
 
 QVariant ModFolderModel::data(const QModelIndex& index, int role) const
 {
-    if (!validateIndex(index))
+    if (!validateIndex(index)) {
         return {};
+    }
 
     int row = index.row();
     int column = index.column();
@@ -109,7 +110,7 @@ QVariant ModFolderModel::data(const QModelIndex& index, int role) const
                     return at(row).loaders();
                 }
                 case McVersionsColumn: {
-                    return at(row).mcVersions();
+                    return at(row).mcVersionsString();
                 }
                 case ReleaseTypeColumn: {
                     return at(row).releaseType();
@@ -120,6 +121,8 @@ QVariant ModFolderModel::data(const QModelIndex& index, int role) const
                 case RequiresColumn: {
                     return at(row).requiresCount();
                 }
+                default:
+                    break;
             }
             break;
         case Qt::DecorationRole: {
@@ -155,6 +158,11 @@ QVariant ModFolderModel::data(const QModelIndex& index, int role) const
         case SizeColumn:
             mappedIndex = index.siblingAtColumn(ResourceFolderModel::SizeColumn);
             break;
+        case FileNameColumn:
+            mappedIndex = index.siblingAtColumn(ResourceFolderModel::FileNameColumn);
+            break;
+        default:
+            break;
     }
 
     if (mappedIndex.isValid()) {
@@ -182,6 +190,7 @@ QVariant ModFolderModel::headerData(int section, [[maybe_unused]] Qt::Orientatio
                 case SizeColumn:
                 case RequiredByColumn:
                 case RequiresColumn:
+                case FileNameColumn:
                     return columnNames().at(section);
                 default:
                     return QVariant();
@@ -213,6 +222,8 @@ QVariant ModFolderModel::headerData(int section, [[maybe_unused]] Qt::Orientatio
                     return tr("For each mod, the number of other mods which depend on it.");
                 case RequiresColumn:
                     return tr("For each mod, the number of other mods it depends on.");
+                case FileNameColumn:
+                    return tr("The file name of the mod.");
                 default:
                     return QVariant();
             }
@@ -223,12 +234,12 @@ QVariant ModFolderModel::headerData(int section, [[maybe_unused]] Qt::Orientatio
 
 int ModFolderModel::columnCount(const QModelIndex& parent) const
 {
-    return parent.isValid() ? 0 : NUM_COLUMNS;
+    return parent.isValid() ? 0 : NumColumns;
 }
 
 Task* ModFolderModel::createParseTask(Resource& resource)
 {
-    return new LocalModParseTask(m_next_resolution_ticket, resource.type(), resource.fileinfo());
+    return new LocalModParseTask(m_nextResolutionTicket, resource.type(), resource.fileinfo());
 }
 
 bool ModFolderModel::isValid()
@@ -236,35 +247,37 @@ bool ModFolderModel::isValid()
     return m_dir.exists() && m_dir.isReadable();
 }
 
-void ModFolderModel::onParseSucceeded(int ticket, QString mod_id)
+void ModFolderModel::onParseSucceeded(int ticket, const QString& resourceId)
 {
-    auto iter = m_active_parse_tasks.constFind(ticket);
+    auto iter = m_activeParseTasks.constFind(ticket);
-    if (iter == m_active_parse_tasks.constEnd())
+    if (iter == m_activeParseTasks.constEnd()) {
         return;
+    }
 
-    int row = m_resources_index[mod_id];
+    int row = m_resourcesIndex[resourceId];
 
-    auto parse_task = *iter;
+    const auto& parseTask = *iter;
-    auto cast_task = static_cast<LocalModParseTask*>(parse_task.get());
+    auto* castTask = static_cast<LocalModParseTask*>(parseTask.get());
 
-    Q_ASSERT(cast_task->token() == ticket);
+    Q_ASSERT(castTask->token() == ticket);
 
-    auto resource = find(mod_id);
+    auto resource = find(resourceId);
 
-    auto result = cast_task->result();
+    auto result = castTask->result();
     if (result && resource) {
         auto* mod = static_cast<Mod*>(resource.get());
         mod->finishResolvingWithDetails(std::move(result->details));
-
     }
     emit dataChanged(index(row, RequiresColumn), index(row, RequiredByColumn));
 }
 
-Mod* findById(QSet<Mod*> mods, QString modId)
+namespace {
+Mod* findById(QSet<Mod*> mods, const QString& resourceId)
 {
-    auto found = std::find_if(mods.begin(), mods.end(), [modId](Mod* m) { return m->mod_id() == modId; });
+    auto found = std::ranges::find_if(mods, [resourceId](Mod* m) { return m->mod_id() == resourceId; });
     return found != mods.end() ? *found : nullptr;
 }
+}  // namespace
 
 void ModFolderModel::onParseFinished()
 {
@@ -277,25 +290,25 @@ void ModFolderModel::onParseFinished()
     m_requires.clear();
     m_requiredBy.clear();
 
-    auto findByProjectID = [mods](QVariant modId, ModPlatform::ResourceProvider provider) -> Mod* {
+    auto findByProjectID = [mods](const QVariant& modId, ModPlatform::ResourceProvider provider) -> Mod* {
-        auto found = std::find_if(mods.begin(), mods.end(), [modId, provider](Mod* m) {
+        auto found = std::ranges::find_if(mods, [modId, provider](Mod* m) {
             return m->metadata() && m->metadata()->provider == provider && m->metadata()->project_id == modId;
         });
         return found != mods.end() ? *found : nullptr;
     };
-    for (auto mod : mods) {
+    for (auto* mod : mods) {
         auto id = mod->mod_id();
-        for (auto dep : mod->dependencies()) {
+        for (const auto& dep : mod->dependencies()) {
-            auto d = findById(mods, dep);
+            auto* d = findById(mods, dep);
             if (d) {
                 m_requires[id] << d;
                 m_requiredBy[d->mod_id()] << mod;
             }
         }
         if (mod->metadata()) {
-            for (auto dep : mod->metadata()->dependencies) {
+            for (const auto& dep : mod->metadata()->dependencies) {
                 if (dep.type == ModPlatform::DependencyType::REQUIRED) {
-                    auto d = findByProjectID(dep.addonId, mod->metadata()->provider);
+                    auto* d = findByProjectID(dep.addonId, mod->metadata()->provider);
                     if (d) {
                         m_requires[id] << d;
                         m_requiredBy[d->mod_id()] << mod;
@@ -304,30 +317,31 @@ void ModFolderModel::onParseFinished()
             }
         }
     }
-    for (auto mod : mods) {
+    for (auto* mod : mods) {
         auto id = mod->mod_id();
         if (mod->requiredByCount() != m_requiredBy[id].count() || mod->requiresCount() != m_requires[id].count()) {
             mod->setRequiredByCount(m_requiredBy[id].count());
             mod->setRequiresCount(m_requires[id].count());
-            int row = m_resources_index[mod->internal_id()];
+            int row = m_resourcesIndex[mod->internalId()];
             emit dataChanged(index(row), index(row, columnCount(QModelIndex()) - 1));
         }
     }
 }
 
-QSet<Mod*> collectMods(QSet<Mod*> mods, QHash<QString, QSet<Mod*>> relation, std::set<QString>& seen, bool shouldBeEnabled)
+namespace {
+
+QSet<Mod*> collectMods(const QSet<Mod*>& mods, QHash<QString, QSet<Mod*>> relation, std::set<QString>& seen, bool shouldBeEnabled)
 {
     QSet<Mod*> affectedList = {};
     QSet<Mod*> needToCheck = {};
-    for (auto mod : mods) {
+    for (auto* mod : mods) {
         auto id = mod->mod_id();
-        if (seen.count(id) == 0) {
+        if (!seen.contains(id)) {
             seen.insert(id);
-            for (auto affected : relation[id]) {
+            for (auto* affected : relation[id]) {
                 auto affectedId = affected->mod_id();
 
-                if (findById(mods, affectedId) == nullptr && seen.count(affectedId) == 0) {
+                if (findById(mods, affectedId) == nullptr && !seen.contains(affectedId)) {
-                    seen.insert(affectedId);
                     if (shouldBeEnabled != affected->enabled()) {
                         affectedList << affected;
                     }
@@ -342,11 +356,13 @@ QSet<Mod*> collectMods(QSet<Mod*> mods, QHash<QString, QSet<Mod*>> relation, std
     }
     return affectedList;
 }
+}  // namespace
 
 QModelIndexList ModFolderModel::getAffectedMods(const QModelIndexList& indexes, EnableAction action)
 {
-    if (indexes.isEmpty())
+    if (indexes.isEmpty()) {
         return {};
+    }
 
     QModelIndexList affectedList = {};
     auto affectedModsList = selectedMods(indexes);
@@ -366,9 +382,9 @@ QModelIndexList ModFolderModel::getAffectedMods(const QModelIndexList& indexes,
             return {};  // this function should not be called with TOGGLE
         }
     }
-    for (auto affected : affectedMods) {
+    for (auto* affected : affectedMods) {
         auto affectedId = affected->mod_id();
-        auto row = m_resources_index[affected->internal_id()];
+        auto row = m_resourcesIndex[affected->internalId()];
         affectedList << index(row, 0);
     }
     return affectedList;
@@ -376,8 +392,9 @@ QModelIndexList ModFolderModel::getAffectedMods(const QModelIndexList& indexes,
 
 bool ModFolderModel::setResourceEnabled(const QModelIndexList& indexes, EnableAction action)
 {
-    if (indexes.isEmpty())
+    if (indexes.isEmpty()) {
         return {};
+    }
 
     auto indexedModsList = selectedMods(indexes);
     auto indexedMods = QSet(indexedModsList.begin(), indexedModsList.end());
@@ -396,7 +413,7 @@ bool ModFolderModel::setResourceEnabled(const QModelIndexList& indexes, EnableAc
             break;
         }
         case EnableAction::TOGGLE: {
-            for (auto mod : indexedMods) {
+            for (auto* mod : indexedMods) {
                 if (mod->enabled()) {
                     toDisable << mod;
                 } else {
@@ -411,10 +428,10 @@ bool ModFolderModel::setResourceEnabled(const QModelIndexList& indexes, EnableAc
     auto requiredToDisable = collectMods(toDisable, m_requiredBy, seen, false);
 
     toDisable.removeIf([toEnable](Mod* m) { return toEnable.contains(m); });
-    auto toList = [this](QSet<Mod*> mods) {
+    auto toList = [this](const QSet<Mod*>& mods) {
         QModelIndexList list;
-        for (auto mod : mods) {
+        for (auto* mod : mods) {
-            auto row = m_resources_index[mod->internal_id()];
+            auto row = m_resourcesIndex[mod->internalId()];
             list << index(row, 0);
         }
         return list;
@@ -447,8 +464,8 @@ bool ModFolderModel::setResourceEnabled(const QModelIndexList& indexes, EnableAc
             yesButton = tr("Disable Required");
         }
 
-        auto box = CustomMessageBox::selectable(nullptr, title, message, QMessageBox::Warning,
+        auto* box = CustomMessageBox::selectable(nullptr, title, message, QMessageBox::Warning,
-                                                QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::No);
+                                                 QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::No);
         box->button(QMessageBox::No)->setText(noButton);
         box->button(QMessageBox::Yes)->setText(yesButton);
         auto response = box->exec();
@@ -466,21 +483,23 @@ bool ModFolderModel::setResourceEnabled(const QModelIndexList& indexes, EnableAc
     return disableStatus && enableStatus;
 }
 
-QStringList reqToList(QSet<Mod*> l)
+namespace {
+QStringList reqToList(const QSet<Mod*>& l)
 {
     QStringList req;
-    for (auto m : l) {
+    for (auto* m : l) {
         req << m->name();
     }
     return req;
 }
+}  // namespace
 
-QStringList ModFolderModel::requiresList(QString id)
+QStringList ModFolderModel::requiresList(const QString& id)
 {
     return reqToList(m_requires[id]);
 }
 
-QStringList ModFolderModel::requiredByList(QString id)
+QStringList ModFolderModel::requiredByList(const QString& id)
 {
     return reqToList(m_requiredBy[id]);
 }
@@ -489,7 +508,7 @@ bool ModFolderModel::deleteResources(const QModelIndexList& indexes)
 {
     auto deleteInvalid = [](QSet<Mod*>& mods) {
         for (auto it = mods.begin(); it != mods.end();) {
-            auto mod = *it;
+            auto* mod = *it;
             // the QFileInfo::exists is used instead of mod->fileinfo().exists
             // because the later somehow caches that the file exists
             if (!mod || !QFileInfo::exists(mod->fileinfo().absoluteFilePath())) {
@@ -500,14 +519,14 @@ bool ModFolderModel::deleteResources(const QModelIndexList& indexes)
         }
     };
     auto rsp = ResourceFolderModel::deleteResources(indexes);
-    for (auto mod : allMods()) {
+    for (auto* mod : allMods()) {
         auto id = mod->mod_id();
         deleteInvalid(m_requiredBy[id]);
         deleteInvalid(m_requires[id]);
         if (mod->requiredByCount() != m_requiredBy[id].count() || mod->requiresCount() != m_requires[id].count()) {
             mod->setRequiredByCount(m_requiredBy[id].count());
             mod->setRequiresCount(m_requires[id].count());
-            int row = m_resources_index[mod->internal_id()];
+            int row = m_resourcesIndex[mod->internalId()];
             emit dataChanged(index(row, RequiresColumn), index(row, RequiredByColumn));
         }
     }

launcher/minecraft/mod/ModFolderModel.h

@@ -46,7 +46,6 @@
 
 #include "Mod.h"
 #include "ResourceFolderModel.h"
-#include "minecraft/Component.h"
 #include "minecraft/mod/Resource.h"
 
 class BaseInstance;
@@ -59,7 +58,7 @@ class QFileSystemWatcher;
 class ModFolderModel : public ResourceFolderModel {
     Q_OBJECT
    public:
-    enum Columns {
+    enum Columns : std::uint8_t {
         ActiveColumn = 0,
         ImageColumn,
         NameColumn,
@@ -73,11 +72,12 @@ class ModFolderModel : public ResourceFolderModel {
         ReleaseTypeColumn,
         RequiresColumn,
         RequiredByColumn,
-        NUM_COLUMNS
+        FileNameColumn,
+        NumColumns
     };
-    ModFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent = nullptr);
+    ModFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent = nullptr);
 
-    virtual QString id() const override { return "mods"; }
+    QString id() const override { return "mods"; }
 
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
 
@@ -85,7 +85,7 @@ class ModFolderModel : public ResourceFolderModel {
     int columnCount(const QModelIndex& parent) const override;
 
     [[nodiscard]] Resource* createResource(const QFileInfo& file) override { return new Mod(file); }
-    [[nodiscard]] Task* createParseTask(Resource&) override;
+    [[nodiscard]] Task* createParseTask(Resource& /*unused*/) override;
 
     bool isValid();
 
@@ -97,11 +97,11 @@ class ModFolderModel : public ResourceFolderModel {
     RESOURCE_HELPERS(Mod)
 
    public:
-    QStringList requiresList(QString id);
+    QStringList requiresList(const QString& id);
-    QStringList requiredByList(QString id);
+    QStringList requiredByList(const QString& id);
 
    private slots:
-    void onParseSucceeded(int ticket, QString resource_id) override;
+    void onParseSucceeded(int ticket, const QString& resourceId) override;
     void onParseFinished();
 
    private:

launcher/minecraft/mod/Resource.cpp

@@ -4,71 +4,75 @@
 #include <QFileInfo>
 #include <QRegularExpression>
 #include <tuple>
+#include <utility>
 
 #include "FileSystem.h"
 #include "StringUtils.h"
 #include "minecraft/MinecraftInstance.h"
 #include "minecraft/PackProfile.h"
 
-Resource::Resource(QObject* parent) : QObject(parent) {}
+Resource::Resource(QObject* parent) : QObject(parent), m_size_info(0) {}
 
-Resource::Resource(QFileInfo file_info) : QObject()
+Resource::Resource(QFileInfo fileInfo) : m_size_info(0)
 {
-    setFile(file_info);
+    setFile(fileInfo);
 }
 
-void Resource::setFile(QFileInfo file_info)
+void Resource::setFile(QFileInfo fileInfo)
 {
-    m_file_info = file_info;
+    m_file_info = std::move(fileInfo);
     parseFile();
 }
 
-static std::tuple<QString, qint64> calculateFileSize(const QFileInfo& file)
+namespace {
+std::tuple<QString, qint64> calculateFileSize(const QFileInfo& file)
 {
     if (file.isDir()) {
         auto dir = QDir(file.absoluteFilePath());
         dir.setFilter(QDir::AllEntries | QDir::NoDotAndDotDot);
         auto count = dir.count();
         auto str = QObject::tr("item");
-        if (count != 1)
+        if (count != 1) {
             str = QObject::tr("items");
+        }
         return { QString("%1 %2").arg(QString::number(count), str), count };
     }
     return { StringUtils::humanReadableFileSize(file.size(), true), file.size() };
 }
+}  // namespace
 
 void Resource::parseFile()
 {
-    QString file_name{ m_file_info.fileName() };
+    QString fileName{ m_file_info.fileName() };
 
     m_type = ResourceType::UNKNOWN;
 
-    m_internal_id = file_name;
+    m_internal_id = fileName;
 
     std::tie(m_size_str, m_size_info) = calculateFileSize(m_file_info);
     if (m_file_info.isDir()) {
         m_type = ResourceType::FOLDER;
-        m_name = file_name;
+        m_name = fileName;
     } else if (m_file_info.isFile()) {
-        if (file_name.endsWith(".disabled")) {
+        if (fileName.endsWith(".disabled")) {
-            file_name.chop(9);
+            fileName.chop(9);
             m_enabled = false;
         }
 
-        if (file_name.endsWith(".zip") || file_name.endsWith(".jar")) {
+        if (fileName.endsWith(".zip") || fileName.endsWith(".jar")) {
             m_type = ResourceType::ZIPFILE;
-            file_name.chop(4);
+            fileName.chop(4);
-        } else if (file_name.endsWith(".nilmod")) {
+        } else if (fileName.endsWith(".nilmod")) {
             m_type = ResourceType::ZIPFILE;
-            file_name.chop(7);
+            fileName.chop(7);
-        } else if (file_name.endsWith(".litemod")) {
+        } else if (fileName.endsWith(".litemod")) {
             m_type = ResourceType::LITEMOD;
-            file_name.chop(8);
+            fileName.chop(8);
         } else {
             m_type = ResourceType::SINGLEFILE;
         }
 
-        m_name = file_name;
+        m_name = fileName;
     }
 
     m_changed_date_time = m_file_info.lastModified();
@@ -76,39 +80,45 @@ void Resource::parseFile()
 
 auto Resource::name() const -> QString
 {
-    if (metadata())
+    if (metadata()) {
         return metadata()->name;
+    }
 
     return m_name;
 }
 
-static void removeThePrefix(QString& string)
+namespace {
+void removeThePrefix(QString& string)
 {
     static const QRegularExpression s_regex(QStringLiteral("^(?:the|teh) +"), QRegularExpression::CaseInsensitiveOption);
     string.remove(s_regex);
     string = string.trimmed();
 }
+}  // namespace
 
 auto Resource::provider() const -> QString
 {
-    if (metadata())
+    if (metadata()) {
         return ModPlatform::ProviderCapabilities::readableName(metadata()->provider);
+    }
 
     return tr("Unknown");
 }
 
 auto Resource::homepage() const -> QString
 {
-    if (metadata())
+    if (metadata()) {
         return ModPlatform::getMetaURL(metadata()->provider, metadata()->project_id);
+    }
 
     return {};
 }
 
 void Resource::setMetadata(std::shared_ptr<Metadata::ModStruct>&& metadata)
 {
-    if (status() == ResourceStatus::NO_METADATA)
+    if (status() == ResourceStatus::NoMetadata) {
-        setStatus(ResourceStatus::INSTALLED);
+        setStatus(ResourceStatus::Installed);
+    }
 
     m_metadata = metadata;
 }
@@ -133,12 +143,12 @@ void Resource::updateIssues(const BaseInstance* inst)
         return;
     }
 
-    auto mcInst = dynamic_cast<const MinecraftInstance*>(inst);
+    const auto* mcInst = dynamic_cast<const MinecraftInstance*>(inst);
     if (mcInst == nullptr) {
         return;
     }
 
-    auto profile = mcInst->getPackProfile();
+    auto* profile = mcInst->getPackProfile();
     QString mcVersion = profile->getComponentVersion("net.minecraft");
 
     if (!m_metadata->mcVersions.empty() && !m_metadata->mcVersions.contains(mcVersion)) {
@@ -151,46 +161,59 @@ int Resource::compare(const Resource& other, SortType type) const
 {
     switch (type) {
         default:
-        case SortType::ENABLED:
+        case SortType::Enabled:
-            if (enabled() && !other.enabled())
+            if (enabled() && !other.enabled()) {
                 return 1;
-            if (!enabled() && other.enabled())
+            }
+            if (!enabled() && other.enabled()) {
                 return -1;
+            }
             break;
-        case SortType::NAME: {
+        case SortType::Name: {
-            QString this_name{ name() };
+            QString thisName{ name() };
-            QString other_name{ other.name() };
+            QString otherName{ other.name() };
 
             // TODO do we need this? it could result in 0 being returned
-            removeThePrefix(this_name);
+            removeThePrefix(thisName);
-            removeThePrefix(other_name);
+            removeThePrefix(otherName);
 
-            return QString::compare(this_name, other_name, Qt::CaseInsensitive);
+            return QString::compare(thisName, otherName, Qt::CaseInsensitive);
         }
-        case SortType::DATE:
+        case SortType::Date:
-            if (dateTimeChanged() > other.dateTimeChanged())
+            if (dateTimeChanged() > other.dateTimeChanged()) {
                 return 1;
-            if (dateTimeChanged() < other.dateTimeChanged())
+            }
+            if (dateTimeChanged() < other.dateTimeChanged()) {
                 return -1;
+            }
             break;
-        case SortType::SIZE: {
+        case SortType::Filename:
+            return fileinfo().fileName().localeAwareCompare(other.fileinfo().fileName());
+
+        case SortType::Size: {
             if (this->type() != other.type()) {
-                if (this->type() == ResourceType::FOLDER)
+                if (this->type() == ResourceType::FOLDER) {
                     return -1;
-                if (other.type() == ResourceType::FOLDER)
+                }
+                if (other.type() == ResourceType::FOLDER) {
                     return 1;
+                }
             }
 
-            if (sizeInfo() > other.sizeInfo())
+            if (sizeInfo() > other.sizeInfo()) {
                 return 1;
-            if (sizeInfo() < other.sizeInfo())
+            }
+            if (sizeInfo() < other.sizeInfo()) {
                 return -1;
+            }
             break;
         }
-        case SortType::PROVIDER: {
+
-            auto compare_result = QString::compare(provider(), other.provider(), Qt::CaseInsensitive);
+        case SortType::Provider: {
-            if (compare_result != 0)
+            auto compareResult = QString::compare(provider(), other.provider(), Qt::CaseInsensitive);
-                return compare_result;
+            if (compareResult != 0) {
+                return compareResult;
+            }
             break;
         }
     }
@@ -200,13 +223,20 @@ int Resource::compare(const Resource& other, SortType type) const
 
 bool Resource::applyFilter(QRegularExpression filter) const
 {
-    return filter.match(name()).hasMatch();
+    if (filter.match(name()).hasMatch()) {
+        return true;
+    }
+    if (filter.match(fileinfo().fileName()).hasMatch()) {
+        return true;
+    }
+    return false;
 }
 
 bool Resource::enable(EnableAction action)
 {
-    if (m_type == ResourceType::UNKNOWN || m_type == ResourceType::FOLDER)
+    if (m_type == ResourceType::UNKNOWN || m_type == ResourceType::FOLDER) {
         return false;
+    }
 
     QString path = m_file_info.absoluteFilePath();
     QFile file(path);
@@ -225,14 +255,16 @@ bool Resource::enable(EnableAction action)
             break;
     }
 
-    if (m_enabled == enable)
+    if (m_enabled == enable) {
         return false;
+    }
 
     if (enable) {
         // m_enabled is false, but there's no '.disabled' suffix.
         // TODO: Report error?
-        if (!path.endsWith(".disabled"))
+        if (!path.endsWith(".disabled")) {
             return false;
+        }
         path.chop(9);
     } else {
         path += ".disabled";
@@ -240,8 +272,9 @@ bool Resource::enable(EnableAction action)
             path = FS::getUniqueResourceName(path);
         }
     }
-    if (!file.rename(path))
+    if (!file.rename(path)) {
         return false;
+    }
 
     setFile(QFileInfo(path));
 
@@ -249,33 +282,34 @@ bool Resource::enable(EnableAction action)
     return true;
 }
 
-auto Resource::destroy(const QDir& index_dir, bool preserve_metadata, bool attempt_trash) -> bool
+auto Resource::destroy(const QDir& indexDir, bool preserveMetadata, bool attemptTrash) -> bool
 {
     m_type = ResourceType::UNKNOWN;
 
-    if (!preserve_metadata) {
+    if (!preserveMetadata) {
         qDebug() << QString("Destroying metadata for '%1' on purpose").arg(name());
-        destroyMetadata(index_dir);
+        destroyMetadata(indexDir);
     }
 
-    return (attempt_trash && FS::trash(m_file_info.filePath())) || FS::deletePath(m_file_info.filePath());
+    return (attemptTrash && FS::trash(m_file_info.filePath())) || FS::deletePath(m_file_info.filePath());
 }
 
-auto Resource::destroyMetadata(const QDir& index_dir) -> void
+auto Resource::destroyMetadata(const QDir& indexDir) -> void
 {
     if (metadata()) {
-        Metadata::remove(index_dir, metadata()->slug);
+        Metadata::remove(indexDir, metadata()->slug);
     } else {
         auto n = name();
-        Metadata::remove(index_dir, n);
+        Metadata::remove(indexDir, n);
     }
     m_metadata = nullptr;
 }
 
 bool Resource::isSymLinkUnder(const QString& instPath) const
 {
-    if (isSymLink())
+    if (isSymLink()) {
         return true;
+    }
 
     auto instDir = QDir(instPath);
 
@@ -293,8 +327,9 @@ bool Resource::isMoreThanOneHardLink() const
 auto Resource::getOriginalFileName() const -> QString
 {
     auto fileName = m_file_info.fileName();
-    if (!m_enabled)
+    if (!m_enabled) {
         fileName.chop(9);
+    }
     return fileName;
 }
 
@@ -324,16 +359,16 @@ QDebug operator<<(QDebug debug, ResourceType type)
 QDebug operator<<(QDebug debug, ResourceStatus status)
 {
     switch (status) {
-        case ResourceStatus::INSTALLED:
+        case ResourceStatus::Installed:
             debug << "INSTALLED";
             break;
-        case ResourceStatus::NOT_INSTALLED:
+        case ResourceStatus::NotInstalled:
             debug << "NOT_INSTALLED";
             break;
-        case ResourceStatus::NO_METADATA:
+        case ResourceStatus::NoMetadata:
             debug << "NO_METADATA";
             break;
-        case ResourceStatus::UNKNOWN:
+        case ResourceStatus::Unknown:
         default:
             debug << "UNKNOWN";
             break;

launcher/minecraft/mod/Resource.h

@@ -45,7 +45,7 @@
 
 class BaseInstance;
 
-enum class ResourceType {
+enum class ResourceType : std::uint8_t {
     UNKNOWN,     //!< Indicates an unspecified resource type.
     ZIPFILE,     //!< The resource is a zip file containing the resource's class files.
     SINGLEFILE,  //!< The resource is a single file (not a zip file).
@@ -55,32 +55,33 @@ enum class ResourceType {
 
 QDebug operator<<(QDebug debug, ResourceType type);
 
-enum class ResourceStatus {
+enum class ResourceStatus : std::uint8_t {
-    INSTALLED,      // Both JAR and Metadata are present
+    Installed,     // Both JAR and Metadata are present
-    NOT_INSTALLED,  // Only the Metadata is present
+    NotInstalled,  // Only the Metadata is present
-    NO_METADATA,    // Only the JAR is present
+    NoMetadata,    // Only the JAR is present
-    UNKNOWN,        // Default status
+    Unknown,       // Default status
 };
 
 QDebug operator<<(QDebug debug, ResourceStatus status);
 
-enum class SortType {
+enum class SortType : std::uint8_t {
-    NAME,
+    Name,
-    DATE,
+    Date,
-    VERSION,
+    Version,
-    ENABLED,
+    Enabled,
-    PACK_FORMAT,
+    PackFormat,
-    PROVIDER,
+    Provider,
-    SIZE,
+    Size,
-    SIDE,
+    Side,
-    MC_VERSIONS,
+    McVersions,
-    LOADERS,
+    Loaders,
-    RELEASE_TYPE,
+    ReleaseType,
-    REQUIRES,
+    Requires,
-    REQUIRED_BY,
+    RequiredBy,
+    Filename,
 };
 
-enum class EnableAction { ENABLE, DISABLE, TOGGLE };
+enum class EnableAction : std::uint8_t { ENABLE, DISABLE, TOGGLE };
 
 /** General class for managed resources. It mirrors a file in disk, with some more info
  *  for display and house-keeping purposes.
@@ -92,20 +93,19 @@ class Resource : public QObject {
     Q_DISABLE_COPY(Resource)
    public:
     using Ptr = shared_qobject_ptr<Resource>;
-    using WeakPtr = QPointer<Resource>;
 
     Resource(QObject* parent = nullptr);
-    Resource(QFileInfo file_info);
+    Resource(QFileInfo fileInfo);
-    Resource(QString file_path) : Resource(QFileInfo(file_path)) {}
+    Resource(const QString& filePath) : Resource(QFileInfo(filePath)) {}
 
     ~Resource() override = default;
 
-    void setFile(QFileInfo file_info);
+    void setFile(QFileInfo fileInfo);
     void parseFile();
 
     auto fileinfo() const -> QFileInfo { return m_file_info; }
     auto dateTimeChanged() const -> QDateTime { return m_changed_date_time; }
-    auto internal_id() const -> QString { return m_internal_id; }
+    auto internalId() const -> QString { return m_internal_id; }
     auto type() const -> ResourceType { return m_type; }
     bool enabled() const { return m_enabled; }
     auto getOriginalFileName() const -> QString;
@@ -138,7 +138,7 @@ class Resource : public QObject {
      *  = 0: 'this' is equal to 'other'
      *  < 0: 'this' comes before 'other'
      */
-    virtual int compare(const Resource& other, SortType type = SortType::NAME) const;
+    virtual int compare(const Resource& other, SortType type = SortType::Name) const;
 
     /** Returns whether the given filter should filter out 'this' (false),
      *  or if such filter includes the Resource (true).
@@ -163,9 +163,9 @@ class Resource : public QObject {
     }
 
     // Delete all files of this resource.
-    auto destroy(const QDir& index_dir, bool preserve_metadata = false, bool attempt_trash = true) -> bool;
+    auto destroy(const QDir& indexDir, bool preserveMetadata = false, bool attemptTrash = true) -> bool;
     // Delete the metadata only.
-    auto destroyMetadata(const QDir& index_dir) -> void;
+    auto destroyMetadata(const QDir& indexDir) -> void;
 
     auto isSymLink() const -> bool { return m_file_info.isSymLink(); }
 
@@ -195,7 +195,7 @@ class Resource : public QObject {
     ResourceType m_type = ResourceType::UNKNOWN;
 
     /* Installation status of the resource. */
-    ResourceStatus m_status = ResourceStatus::UNKNOWN;
+    ResourceStatus m_status = ResourceStatus::Unknown;
 
     std::shared_ptr<Metadata::ModStruct> m_metadata = nullptr;
 

launcher/minecraft/mod/ResourceFolderModel.cpp

@@ -11,6 +11,7 @@
 #include <QStyle>
 #include <QThreadPool>
 #include <QUrl>
+#include <algorithm>
 #include <utility>
 
 #include "Application.h"
@@ -27,10 +28,10 @@
 #include "tasks/Task.h"
 #include "ui/dialogs/CustomMessageBox.h"
 
-ResourceFolderModel::ResourceFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent)
+ResourceFolderModel::ResourceFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent)
-    : QAbstractListModel(parent), m_dir(dir), m_instance(instance), m_watcher(this), m_is_indexed(is_indexed)
+    : QAbstractListModel(parent), m_dir(dir), m_instance(instance), m_watcher(this), m_isIndexed(isIndexed)
 {
-    if (create_dir) {
+    if (createDir) {
         FS::ensureFolderPathExists(m_dir.absolutePath());
     }
 
@@ -49,70 +50,75 @@ ResourceFolderModel::ResourceFolderModel(const QDir& dir, BaseInstance* instance
 
 ResourceFolderModel::~ResourceFolderModel()
 {
-    while (!QThreadPool::globalInstance()->waitForDone(100))
+    while (!QThreadPool::globalInstance()->waitForDone(100)) {
         QCoreApplication::processEvents();
+    }
 }
 
 bool ResourceFolderModel::startWatching(const QStringList& paths)
 {
     // Remove orphaned metadata next time
-    m_first_folder_load = true;
+    m_firstFolderLoad = true;
 
-    if (m_is_watching)
+    if (m_isWatching) {
         return false;
+    }
 
-    auto couldnt_be_watched = m_watcher.addPaths(paths);
+    auto couldntBeWatched = m_watcher.addPaths(paths);
-    for (auto path : paths) {
+    for (const auto& path : paths) {
-        if (couldnt_be_watched.contains(path))
+        if (couldntBeWatched.contains(path)) {
             qDebug() << "Failed to start watching" << path;
-        else
+        } else {
             qDebug() << "Started watching" << path;
+        }
     }
 
     update();
 
-    m_is_watching = !m_is_watching;
+    m_isWatching = !m_isWatching;
-    return m_is_watching;
+    return m_isWatching;
 }
 
 bool ResourceFolderModel::stopWatching(const QStringList& paths)
 {
-    if (!m_is_watching)
+    if (!m_isWatching) {
         return false;
-
-    auto couldnt_be_stopped = m_watcher.removePaths(paths);
-    for (auto path : paths) {
-        if (couldnt_be_stopped.contains(path))
-            qDebug() << "Failed to stop watching" << path;
-        else
-            qDebug() << "Stopped watching" << path;
     }
 
-    m_is_watching = !m_is_watching;
+    auto couldntBeStopped = m_watcher.removePaths(paths);
-    return !m_is_watching;
+    for (const auto& path : paths) {
+        if (couldntBeStopped.contains(path)) {
+            qDebug() << "Failed to stop watching" << path;
+        } else {
+            qDebug() << "Stopped watching" << path;
+        }
+    }
+
+    m_isWatching = !m_isWatching;
+    return !m_isWatching;
 }
 
-bool ResourceFolderModel::installResource(QString original_path)
+bool ResourceFolderModel::installResource(QString originalPath)
 {
     // NOTE: fix for GH-1178: remove trailing slash to avoid issues with using the empty result of QFileInfo::fileName
-    original_path = FS::NormalizePath(original_path);
+    originalPath = FS::NormalizePath(originalPath);
-    QFileInfo file_info(original_path);
+    QFileInfo fileInfo(originalPath);
 
-    if (!file_info.exists() || !file_info.isReadable()) {
+    if (!fileInfo.exists() || !fileInfo.isReadable()) {
-        qWarning() << "Caught attempt to install non-existing file or file-like object:" << original_path;
+        qWarning() << "Caught attempt to install non-existing file or file-like object:" << originalPath;
         return false;
     }
-    qDebug() << "Installing:" << file_info.absoluteFilePath();
+    qDebug() << "Installing:" << fileInfo.absoluteFilePath();
 
-    Resource resource(file_info);
+    Resource resource(fileInfo);
     if (!resource.valid()) {
-        qWarning() << original_path << "is not a valid resource. Ignoring it.";
+        qWarning() << originalPath << "is not a valid resource. Ignoring it.";
         return false;
     }
 
-    auto new_path = FS::NormalizePath(m_dir.filePath(file_info.fileName()));
+    auto newPath = FS::NormalizePath(m_dir.filePath(fileInfo.fileName()));
-    if (original_path == new_path) {
+    if (originalPath == newPath) {
-        qWarning() << "Overwriting the mod (" << original_path << ") with itself makes no sense...";
+        qWarning() << "Overwriting the mod (" << originalPath << ") with itself makes no sense...";
         return false;
     }
 
@@ -120,45 +126,47 @@ bool ResourceFolderModel::installResource(QString original_path)
         case ResourceType::SINGLEFILE:
         case ResourceType::ZIPFILE:
         case ResourceType::LITEMOD: {
-            if (QFile::exists(new_path) || QFile::exists(new_path + QString(".disabled"))) {
+            if (QFile::exists(newPath) || QFile::exists(newPath + QString(".disabled"))) {
-                if (!FS::deletePath(new_path)) {
+                if (!FS::deletePath(newPath)) {
-                    qCritical() << "Cleaning up new location (" << new_path << ") was unsuccessful!";
+                    qCritical() << "Cleaning up new location (" << newPath << ") was unsuccessful!";
                     return false;
                 }
-                qDebug() << new_path << "has been deleted.";
+                qDebug() << newPath << "has been deleted.";
             }
 
-            if (!QFile::copy(original_path, new_path)) {
+            if (!QFile::copy(originalPath, newPath)) {
-                qCritical() << "Copy from" << original_path << "to" << new_path << "has failed.";
+                qCritical() << "Copy from" << originalPath << "to" << newPath << "has failed.";
                 return false;
             }
 
-            FS::updateTimestamp(new_path);
+            FS::updateTimestamp(newPath);
 
-            QFileInfo new_path_file_info(new_path);
+            QFileInfo newPathFileInfo(newPath);
-            resource.setFile(new_path_file_info);
+            resource.setFile(newPathFileInfo);
 
-            if (!m_is_watching)
+            if (!m_isWatching) {
                 return update();
+            }
 
             return true;
         }
         case ResourceType::FOLDER: {
-            if (QFile::exists(new_path)) {
+            if (QFile::exists(newPath)) {
-                qDebug() << "Ignoring folder '" << original_path << "', it would merge with" << new_path;
+                qDebug() << "Ignoring folder '" << originalPath << "', it would merge with" << newPath;
                 return false;
             }
 
-            if (!FS::copy(original_path, new_path)()) {
+            if (!FS::copy(originalPath, newPath)()) {
-                qWarning() << "Copy of folder from" << original_path << "to" << new_path << "has (potentially partially) failed.";
+                qWarning() << "Copy of folder from" << originalPath << "to" << newPath << "has (potentially partially) failed.";
                 return false;
             }
 
-            QFileInfo newpathInfo(new_path);
+            QFileInfo newpathInfo(newPath);
             resource.setFile(newpathInfo);
 
-            if (!m_is_watching)
+            if (!m_isWatching) {
                 return update();
+            }
 
             return true;
         }
@@ -168,24 +176,24 @@ bool ResourceFolderModel::installResource(QString original_path)
     return false;
 }
 
-void ResourceFolderModel::installResourceWithFlameMetadata(QString path, ModPlatform::IndexedVersion& vers)
+void ResourceFolderModel::installResourceWithFlameMetadata(const QString& path, ModPlatform::IndexedVersion& vers)
 {
-    auto install = [this, path] { installResource(std::move(path)); };
+    auto install = [this, path] { installResource(path); };
     if (vers.addonId.isValid()) {
         ModPlatform::IndexedPack pack{
-            vers.addonId,
+            .addonId = vers.addonId,
-            ModPlatform::ResourceProvider::FLAME,
+            .provider = ModPlatform::ResourceProvider::FLAME,
         };
 
         auto [job, response] = FlameAPI().getProject(vers.addonId.toString());
         connect(job.get(), &Task::failed, this, install);
         connect(job.get(), &Task::aborted, this, install);
         connect(job.get(), &Task::succeeded, [response, this, &vers, install, &pack] {
-            QJsonParseError parse_error{};
+            QJsonParseError parseError{};
-            QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
+            QJsonDocument doc = QJsonDocument::fromJson(*response, &parseError);
-            if (parse_error.error != QJsonParseError::NoError) {
+            if (parseError.error != QJsonParseError::NoError) {
-                qWarning() << "Error while parsing JSON response for mod info at" << parse_error.offset
+                qWarning() << "Error while parsing JSON response for mod info at" << parseError.offset
-                           << "reason:" << parse_error.errorString();
+                           << "reason:" << parseError.errorString();
                 qDebug() << *response;
                 return;
             }
@@ -196,9 +204,9 @@ void ResourceFolderModel::installResourceWithFlameMetadata(QString path, ModPlat
                 qDebug() << doc;
                 qWarning() << "Error while reading mod info:" << e.cause();
             }
-            LocalResourceUpdateTask update_metadata(indexDir(), pack, vers);
+            LocalResourceUpdateTask updateMetadata(indexDir(), pack, vers);
-            connect(&update_metadata, &Task::finished, this, install);
+            connect(&updateMetadata, &Task::finished, this, install);
-            update_metadata.start();
+            updateMetadata.start();
         });
 
         job->start();
@@ -207,7 +215,7 @@ void ResourceFolderModel::installResourceWithFlameMetadata(QString path, ModPlat
     }
 }
 
-bool ResourceFolderModel::uninstallResource(const QString& file_name, bool preserve_metadata)
+bool ResourceFolderModel::uninstallResource(const QString& fileName, bool preserveMetadata)
 {
     for (auto& resource : m_resources) {
         auto resourceFileInfo = resource->fileinfo();
@@ -216,8 +224,8 @@ bool ResourceFolderModel::uninstallResource(const QString& file_name, bool prese
             resourceFileName.chop(9);
         }
 
-        if (resourceFileName == file_name) {
+        if (resourceFileName == fileName) {
-            auto res = resource->destroy(indexDir(), preserve_metadata, false);
+            auto res = resource->destroy(indexDir(), preserveMetadata, false);
 
             update();
 
@@ -229,14 +237,16 @@ bool ResourceFolderModel::uninstallResource(const QString& file_name, bool prese
 
 bool ResourceFolderModel::deleteResources(const QModelIndexList& indexes)
 {
-    if (indexes.isEmpty())
+    if (indexes.isEmpty()) {
         return true;
+    }
 
     for (auto i : indexes) {
-        if (i.column() != 0)
+        if (i.column() != 0) {
             continue;
+        }
 
-        auto& resource = m_resources.at(i.row());
+        const auto& resource = m_resources.at(i.row());
         resource->destroy(indexDir());
     }
 
@@ -247,14 +257,16 @@ bool ResourceFolderModel::deleteResources(const QModelIndexList& indexes)
 
 void ResourceFolderModel::deleteMetadata(const QModelIndexList& indexes)
 {
-    if (indexes.isEmpty())
+    if (indexes.isEmpty()) {
         return;
+    }
 
     for (auto i : indexes) {
-        if (i.column() != 0)
+        if (i.column() != 0) {
             continue;
+        }
 
-        auto& resource = m_resources.at(i.row());
+        const auto& resource = m_resources.at(i.row());
         resource->destroyMetadata(indexDir());
     }
 
@@ -271,33 +283,36 @@ bool ResourceFolderModel::setResourceEnabled(const QModelIndexList& indexes, Ena
                                          QMessageBox::Warning, QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
                 ->exec();
 
-        if (response != QMessageBox::Yes)
+        if (response != QMessageBox::Yes) {
             return false;
+        }
     }
 
-    if (indexes.isEmpty())
+    if (indexes.isEmpty()) {
         return true;
+    }
 
     bool succeeded = true;
-    for (auto const& idx : indexes) {
+    for (const auto& idx : indexes) {
-        if (!validateIndex(idx) || idx.column() != 0)
+        if (!validateIndex(idx) || idx.column() != 0) {
             continue;
+        }
 
         int row = idx.row();
 
         auto& resource = m_resources[row];
 
         // Preserve the row, but change its ID
-        auto old_id = resource->internal_id();
+        auto oldId = resource->internalId();
         if (!resource->enable(action)) {
             succeeded = false;
             continue;
         }
 
-        auto new_id = resource->internal_id();
+        auto newId = resource->internalId();
 
-        m_resources_index.remove(old_id);
+        m_resourcesIndex.remove(oldId);
-        m_resources_index[new_id] = row;
+        m_resourcesIndex[newId] = row;
 
         emit dataChanged(index(row, 0), index(row, columnCount(QModelIndex()) - 1));
     }
@@ -312,24 +327,25 @@ bool ResourceFolderModel::update()
     QMutexLocker lock(&s_update_task_mutex);
 
     // Already updating, so we schedule a future update and return.
-    if (m_current_update_task) {
+    if (m_currentUpdateTask) {
-        m_scheduled_update = true;
+        m_scheduledUpdate = true;
         return false;
     }
 
-    m_current_update_task.reset(createUpdateTask());
+    m_currentUpdateTask.reset(createUpdateTask());
-    if (!m_current_update_task)
+    if (!m_currentUpdateTask) {
         return false;
+    }
 
-    connect(m_current_update_task.get(), &Task::succeeded, this, &ResourceFolderModel::onUpdateSucceeded,
+    connect(m_currentUpdateTask.get(), &Task::succeeded, this, &ResourceFolderModel::onUpdateSucceeded,
             Qt::ConnectionType::QueuedConnection);
-    connect(m_current_update_task.get(), &Task::failed, this, &ResourceFolderModel::onUpdateFailed, Qt::ConnectionType::QueuedConnection);
+    connect(m_currentUpdateTask.get(), &Task::failed, this, &ResourceFolderModel::onUpdateFailed, Qt::ConnectionType::QueuedConnection);
     connect(
-        m_current_update_task.get(), &Task::finished, this,
+        m_currentUpdateTask.get(), &Task::finished, this,
         [this] {
-            m_current_update_task.reset();
+            m_currentUpdateTask.reset();
-            if (m_scheduled_update) {
+            if (m_scheduledUpdate) {
-                m_scheduled_update = false;
+                m_scheduledUpdate = false;
                 update();
             } else {
                 emit updateFinished();
@@ -340,16 +356,16 @@ bool ResourceFolderModel::update()
     Task::Ptr preUpdate{ createPreUpdateTask() };
 
     if (preUpdate != nullptr) {
-        auto task = new SequentialTask("ResourceFolderModel::update");
+        auto* task = new SequentialTask("ResourceFolderModel::update");
 
         task->addTask(preUpdate);
-        task->addTask(m_current_update_task);
+        task->addTask(m_currentUpdateTask);
 
         connect(task, &Task::finished, [task] { task->deleteLater(); });
 
         QThreadPool::globalInstance()->start(task);
     } else {
-        QThreadPool::globalInstance()->start(m_current_update_task.get());
+        QThreadPool::globalInstance()->start(m_currentUpdateTask.get());
     }
 
     return true;
@@ -362,24 +378,25 @@ void ResourceFolderModel::resolveResource(Resource::Ptr res)
     }
 
     Task::Ptr task{ createParseTask(*res) };
-    if (!task)
+    if (!task) {
         return;
+    }
 
-    int ticket = m_next_resolution_ticket.fetch_add(1);
+    int ticket = m_nextResolutionTicket.fetch_add(1);
 
     res->setResolving(true, ticket);
-    m_active_parse_tasks.insert(ticket, task);
+    m_activeParseTasks.insert(ticket, task);
 
     connect(
-        task.get(), &Task::succeeded, this, [this, ticket, res] { onParseSucceeded(ticket, res->internal_id()); },
+        task.get(), &Task::succeeded, this, [this, ticket, res] { onParseSucceeded(ticket, res->internalId()); },
         Qt::ConnectionType::QueuedConnection);
     connect(
-        task.get(), &Task::failed, this, [this, ticket, res] { onParseFailed(ticket, res->internal_id()); },
+        task.get(), &Task::failed, this, [this, ticket, res] { onParseFailed(ticket, res->internalId()); },
         Qt::ConnectionType::QueuedConnection);
     connect(
         task.get(), &Task::finished, this,
         [this, ticket] {
-            m_active_parse_tasks.remove(ticket);
+            m_activeParseTasks.remove(ticket);
             emit parseFinished();
         },
         Qt::ConnectionType::QueuedConnection);
@@ -394,44 +411,45 @@ void ResourceFolderModel::resolveResource(Resource::Ptr res)
 
 void ResourceFolderModel::onUpdateSucceeded()
 {
-    auto update_results = static_cast<ResourceFolderLoadTask*>(m_current_update_task.get())->result();
+    auto updateResults = static_cast<ResourceFolderLoadTask*>(m_currentUpdateTask.get())->result();
 
-    auto& new_resources = update_results->resources;
+    auto& newResources = updateResults->resources;
 
-    auto current_list = m_resources_index.keys();
+    auto currentList = m_resourcesIndex.keys();
-    QSet<QString> current_set(current_list.begin(), current_list.end());
+    QSet<QString> currentSet(currentList.begin(), currentList.end());
 
-    auto new_list = new_resources.keys();
+    auto newList = newResources.keys();
-    QSet<QString> new_set(new_list.begin(), new_list.end());
+    QSet<QString> newSet(newList.begin(), newList.end());
 
-    applyUpdates(current_set, new_set, new_resources);
+    applyUpdates(currentSet, newSet, newResources);
 }
 
-void ResourceFolderModel::onParseSucceeded(int ticket, QString resource_id)
+void ResourceFolderModel::onParseSucceeded(int ticket, const QString& resourceId)
 {
-    auto iter = m_active_parse_tasks.constFind(ticket);
+    auto iter = m_activeParseTasks.constFind(ticket);
-    if (iter == m_active_parse_tasks.constEnd() || !m_resources_index.contains(resource_id))
+    if (iter == m_activeParseTasks.constEnd() || !m_resourcesIndex.contains(resourceId)) {
         return;
+    }
 
-    int row = m_resources_index[resource_id];
+    int row = m_resourcesIndex[resourceId];
     emit dataChanged(index(row), index(row, columnCount(QModelIndex()) - 1));
 }
 
 Task* ResourceFolderModel::createUpdateTask()
 {
-    auto index_dir = indexDir();
+    auto indexDir2 = indexDir();
-    auto task = new ResourceFolderLoadTask(dir(), index_dir, m_is_indexed, m_first_folder_load,
+    auto* task = new ResourceFolderLoadTask(dir(), indexDir2, m_isIndexed, m_firstFolderLoad,
-                                           [this](const QFileInfo& file) { return createResource(file); });
+                                            [this](const QFileInfo& file) { return createResource(file); });
-    m_first_folder_load = false;
+    m_firstFolderLoad = false;
     return task;
 }
 
 bool ResourceFolderModel::hasPendingParseTasks() const
 {
-    return !m_active_parse_tasks.isEmpty();
+    return !m_activeParseTasks.isEmpty();
 }
 
-void ResourceFolderModel::directoryChanged(QString path)
+void ResourceFolderModel::directoryChanged(const QString& /*path*/)
 {
     update();
 }
@@ -446,8 +464,9 @@ Qt::ItemFlags ResourceFolderModel::flags(const QModelIndex& index) const
 {
     Qt::ItemFlags defaultFlags = QAbstractListModel::flags(index);
     auto flags = defaultFlags | Qt::ItemIsDropEnabled;
-    if (index.isValid())
+    if (index.isValid()) {
         flags |= Qt::ItemIsUserCheckable;
+    }
     return flags;
 }
 
@@ -458,21 +477,25 @@ QStringList ResourceFolderModel::mimeTypes() const
     return types;
 }
 
-bool ResourceFolderModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int, int, const QModelIndex&)
+bool ResourceFolderModel::dropMimeData(const QMimeData* data,
+                                       Qt::DropAction action,
+                                       int /*row*/,
+                                       int /*column*/,
+                                       const QModelIndex& /*parent*/)
 {
     if (action == Qt::IgnoreAction) {
         return true;
     }
 
     // check if the action is supported
-    if (!data || !(action & supportedDropActions())) {
+    if ((data == nullptr) || !(action & supportedDropActions())) {
         return false;
     }
 
     // files dropped from outside?
     if (data->hasUrls()) {
         auto urls = data->urls();
-        for (auto url : urls) {
+        for (const auto& url : urls) {
             // only local files may be dropped...
             if (!url.isLocalFile()) {
                 continue;
@@ -488,14 +511,12 @@ bool ResourceFolderModel::dropMimeData(const QMimeData* data, Qt::DropAction act
 
 bool ResourceFolderModel::validateIndex(const QModelIndex& index) const
 {
-    if (!index.isValid())
+    if (!index.isValid()) {
         return false;
+    }
 
     int row = index.row();
-    if (row < 0 || row >= m_resources.size())
+    return row >= 0 && row < m_resources.size();
-        return false;
-
-    return true;
 }
 
 // HACK: all subclasses need to call this to have the whole row painted
@@ -504,15 +525,15 @@ QBrush ResourceFolderModel::rowBackground(int row) const
 {
     if (APPLICATION->settings()->get("ShowModIncompat").toBool() && m_resources[row]->hasIssues()) {
         return { QColor(255, 0, 0, 40) };
-    } else {
-        return {};
     }
+    return {};
 }
 
 QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
 {
-    if (!validateIndex(index))
+    if (!validateIndex(index)) {
         return {};
+    }
 
     int row = index.row();
     int column = index.column();
@@ -530,11 +551,13 @@ QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
                     return m_resources[row]->provider();
                 case SizeColumn:
                     return m_resources[row]->sizeStr();
+                case FileNameColumn:
+                    return m_resources[row]->fileinfo().fileName();
                 default:
                     return {};
             }
         case Qt::ToolTipRole: {
-            QString tooltip = m_resources[row]->internal_id();
+            QString tooltip = m_resources[row]->internalId();
 
             if (column == NameColumn) {
                 if (APPLICATION->settings()->get("ShowModIncompat").toBool()) {
@@ -545,7 +568,7 @@ QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
 
                 if (at(row).isSymLinkUnder(instDirPath())) {
                     tooltip +=
-                        m_resources[row]->internal_id() +
+                        m_resources[row]->internalId() +
                         tr("\nWarning: This resource is symbolically linked from elsewhere. Editing it will also change the original."
                            "\nCanonical Path: %1")
                             .arg(at(row).fileinfo().canonicalFilePath());
@@ -562,7 +585,8 @@ QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
             if (column == NameColumn) {
                 if (APPLICATION->settings()->get("ShowModIncompat").toBool() && at(row).hasIssues()) {
                     return QIcon::fromTheme("status-bad");
-                } else if (at(row).isSymLinkUnder(instDirPath()) || at(row).isMoreThanOneHardLink()) {
+                }
+                if (at(row).isSymLinkUnder(instDirPath()) || at(row).isMoreThanOneHardLink()) {
                     return QIcon::fromTheme("status-yellow");
                 }
             }
@@ -570,8 +594,9 @@ QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
             return {};
         }
         case Qt::CheckStateRole:
-            if (column == ActiveColumn)
+            if (column == ActiveColumn) {
                 return m_resources[row]->enabled() ? Qt::Checked : Qt::Unchecked;
+            }
             return {};
         default:
             return {};
@@ -581,8 +606,9 @@ QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
 bool ResourceFolderModel::setData(const QModelIndex& index, [[maybe_unused]] const QVariant& value, int role)
 {
     int row = index.row();
-    if (row < 0 || row >= rowCount(index.parent()) || !index.isValid())
+    if (row < 0 || row >= rowCount(index.parent()) || !index.isValid()) {
         return false;
+    }
 
     if (role == Qt::CheckStateRole) {
         return setResourceEnabled({ index }, EnableAction::TOGGLE);
@@ -601,6 +627,7 @@ QVariant ResourceFolderModel::headerData(int section, [[maybe_unused]] Qt::Orien
                 case DateColumn:
                 case ProviderColumn:
                 case SizeColumn:
+                case FileNameColumn:
                     return columnNames().at(section);
                 default:
                     return {};
@@ -618,6 +645,8 @@ QVariant ResourceFolderModel::headerData(int section, [[maybe_unused]] Qt::Orien
                     return tr("The source provider of the resource.");
                 case SizeColumn:
                     return tr("The size of the resource.");
+                case FileNameColumn:
+                    return tr("The file name of the resource.");
                 default:
                     return {};
             }
@@ -638,22 +667,22 @@ void ResourceFolderModel::setupHeaderAction(QAction* act, int column)
 
 void ResourceFolderModel::saveColumns(QTreeView* tree)
 {
-    auto const stateSettingName = QString("UI/%1_Page/Columns").arg(id());
+    const auto stateSettingName = QString("UI/%1_Page/Columns").arg(id());
-    auto const overrideSettingName = QString("UI/%1_Page/ColumnsOverride").arg(id());
+    const auto overrideSettingName = QString("UI/%1_Page/ColumnsOverride").arg(id());
-    auto const visibilitySettingName = QString("UI/%1_Page/ColumnsVisibility").arg(id());
+    const auto visibilitySettingName = QString("UI/%1_Page/ColumnsVisibility").arg(id());
 
     auto stateSetting = m_instance->settings()->getSetting(stateSettingName);
     stateSetting->set(QString::fromUtf8(tree->header()->saveState().toBase64()));
 
     // neither passthrough nor override settings works for this usecase as I need to only set the global when the gate is false
-    auto settings = m_instance->settings();
+    auto* settings = m_instance->settings();
     if (!settings->get(overrideSettingName).toBool()) {
         settings = APPLICATION->settings();
     }
     auto visibility = Json::toMap(settings->get(visibilitySettingName).toString());
-    for (auto i = 0; i < m_column_names.size(); ++i) {
+    for (auto i = 0; i < m_columnNames.size(); ++i) {
         if (m_columnsHideable[i]) {
-            auto name = m_column_names[i];
+            auto name = m_columnNames[i];
             visibility[name] = !tree->isColumnHidden(i);
         }
     }
@@ -662,24 +691,24 @@ void ResourceFolderModel::saveColumns(QTreeView* tree)
 
 void ResourceFolderModel::loadColumns(QTreeView* tree)
 {
-    auto const stateSettingName = QString("UI/%1_Page/Columns").arg(id());
+    const auto stateSettingName = QString("UI/%1_Page/Columns").arg(id());
-    auto const overrideSettingName = QString("UI/%1_Page/ColumnsOverride").arg(id());
+    const auto overrideSettingName = QString("UI/%1_Page/ColumnsOverride").arg(id());
-    auto const visibilitySettingName = QString("UI/%1_Page/ColumnsVisibility").arg(id());
+    const auto visibilitySettingName = QString("UI/%1_Page/ColumnsVisibility").arg(id());
 
     auto stateSetting = m_instance->settings()->getOrRegisterSetting(stateSettingName, "");
     tree->header()->restoreState(QByteArray::fromBase64(stateSetting->get().toString().toUtf8()));
 
-    auto setVisible = [this, tree](QVariant value) {
+    auto setVisible = [this, tree](const QVariant& value) {
         auto visibility = Json::toMap(value.toString());
-        for (auto i = 0; i < m_column_names.size(); ++i) {
+        for (auto i = 0; i < m_columnNames.size(); ++i) {
             if (m_columnsHideable[i]) {
-                auto name = m_column_names[i];
+                auto name = m_columnNames[i];
                 tree->setColumnHidden(i, !visibility.value(name, false).toBool());
             }
         }
     };
 
-    auto const defaultValue = Json::fromMap({
+    const auto defaultValue = Json::fromMap({
         { "Image", true },
         { "Version", true },
         { "Last Modified", true },
@@ -687,7 +716,7 @@ void ResourceFolderModel::loadColumns(QTreeView* tree)
         { "Pack Format", true },
     });
     // neither passthrough nor override settings works for this usecase as I need to only set the global when the gate is false
-    auto settings = m_instance->settings();
+    auto* settings = m_instance->settings();
     if (!settings->getOrRegisterSetting(overrideSettingName, false)->get().toBool()) {
         settings = APPLICATION->settings();
     }
@@ -696,7 +725,7 @@ void ResourceFolderModel::loadColumns(QTreeView* tree)
 
     // allways connect the signal in case the setting is toggled on and off
     auto gSetting = APPLICATION->settings()->getOrRegisterSetting(visibilitySettingName, defaultValue);
-    connect(gSetting.get(), &Setting::SettingChanged, tree, [this, setVisible, overrideSettingName](const Setting&, QVariant value) {
+    connect(gSetting.get(), &Setting::SettingChanged, tree, [this, setVisible, overrideSettingName](const Setting&, const QVariant& value) {
         if (!m_instance->settings()->get(overrideSettingName).toBool()) {
             setVisible(value);
         }
@@ -705,11 +734,11 @@ void ResourceFolderModel::loadColumns(QTreeView* tree)
 
 QMenu* ResourceFolderModel::createHeaderContextMenu(QTreeView* tree)
 {
-    auto menu = new QMenu(tree);
+    auto* menu = new QMenu(tree);
 
     {  // action to decide if the visibility is per instance or not
-        auto act = new QAction(tr("Override Columns Visibility"), menu);
+        auto* act = new QAction(tr("Override Columns Visibility"), menu);
-        auto const overrideSettingName = QString("UI/%1_Page/ColumnsOverride").arg(id());
+        const auto overrideSettingName = QString("UI/%1_Page/ColumnsOverride").arg(id());
 
         act->setCheckable(true);
         act->setChecked(m_instance->settings()->getOrRegisterSetting(overrideSettingName, false)->get().toBool());
@@ -725,9 +754,10 @@ QMenu* ResourceFolderModel::createHeaderContextMenu(QTreeView* tree)
 
     for (int col = 0; col < columnCount(); ++col) {
         // Skip creating actions for columns that should not be hidden
-        if (!m_columnsHideable.at(col))
+        if (!m_columnsHideable.at(col)) {
             continue;
-        auto act = new QAction(menu);
+        }
+        auto* act = new QAction(menu);
         setupHeaderAction(act, col);
 
         act->setCheckable(true);
@@ -736,8 +766,9 @@ QMenu* ResourceFolderModel::createHeaderContextMenu(QTreeView* tree)
         connect(act, &QAction::toggled, tree, [this, col, tree](bool toggled) {
             tree->setColumnHidden(col, !toggled);
             for (int c = 0; c < columnCount(); ++c) {
-                if (m_column_resize_modes.at(c) == QHeaderView::ResizeToContents)
+                if (m_columnResizeModes.at(c) == QHeaderView::ResizeToContents) {
                     tree->resizeColumnToContents(c);
+                }
             }
             saveColumns(tree);
         });
@@ -755,41 +786,43 @@ QSortFilterProxyModel* ResourceFolderModel::createFilterProxyModel(QObject* pare
 
 SortType ResourceFolderModel::columnToSortKey(size_t column) const
 {
-    Q_ASSERT(m_column_sort_keys.size() == columnCount());
+    Q_ASSERT(m_columnSortKeys.size() == columnCount());
-    return m_column_sort_keys.at(column);
+    return m_columnSortKeys.at(column);
 }
 
 /* Standard Proxy Model for createFilterProxyModel */
-bool ResourceFolderModel::ProxyModel::filterAcceptsRow(int source_row, [[maybe_unused]] const QModelIndex& source_parent) const
+bool ResourceFolderModel::ProxyModel::filterAcceptsRow(int sourceRow, [[maybe_unused]] const QModelIndex& sourceParent) const
 {
     auto* model = qobject_cast<ResourceFolderModel*>(sourceModel());
-    if (!model)
+    if (!model) {
         return true;
+    }
 
-    const auto& resource = model->at(source_row);
+    const auto& resource = model->at(sourceRow);
 
     return resource.applyFilter(filterRegularExpression());
 }
 
-bool ResourceFolderModel::ProxyModel::lessThan(const QModelIndex& source_left, const QModelIndex& source_right) const
+bool ResourceFolderModel::ProxyModel::lessThan(const QModelIndex& sourceLeft, const QModelIndex& sourceRight) const
 {
     auto* model = qobject_cast<ResourceFolderModel*>(sourceModel());
-    if (!model || !source_left.isValid() || !source_right.isValid() || source_left.column() != source_right.column()) {
+    if (!model || !sourceLeft.isValid() || !sourceRight.isValid() || sourceLeft.column() != sourceRight.column()) {
-        return QSortFilterProxyModel::lessThan(source_left, source_right);
+        return QSortFilterProxyModel::lessThan(sourceLeft, sourceRight);
     }
 
     // we are now guaranteed to have two valid indexes in the same column... we love the provided invariants unconditionally and
     // proceed.
 
-    auto column_sort_key = model->columnToSortKey(source_left.column());
+    auto columnSortKey = model->columnToSortKey(sourceLeft.column());
-    auto const& resource_left = model->at(source_left.row());
+    const auto& resourceLeft = model->at(sourceLeft.row());
-    auto const& resource_right = model->at(source_right.row());
+    const auto& resourceRight = model->at(sourceRight.row());
 
-    auto compare_result = resource_left.compare(resource_right, column_sort_key);
+    auto compareResult = resourceLeft.compare(resourceRight, columnSortKey);
-    if (compare_result == 0)
+    if (compareResult == 0) {
-        return QSortFilterProxyModel::lessThan(source_left, source_right);
+        return QSortFilterProxyModel::lessThan(sourceLeft, sourceRight);
+    }
 
-    return compare_result < 0;
+    return compareResult < 0;
 }
 
 QString ResourceFolderModel::instDirPath() const
@@ -797,50 +830,51 @@ QString ResourceFolderModel::instDirPath() const
     return QFileInfo(m_instance->instanceRoot()).absoluteFilePath();
 }
 
-void ResourceFolderModel::onParseFailed(int ticket, QString resource_id)
+void ResourceFolderModel::onParseFailed(int ticket, const QString& resourceId)
 {
-    auto iter = m_active_parse_tasks.constFind(ticket);
+    auto iter = m_activeParseTasks.constFind(ticket);
-    if (iter == m_active_parse_tasks.constEnd() || !m_resources_index.contains(resource_id))
+    if (iter == m_activeParseTasks.constEnd() || !m_resourcesIndex.contains(resourceId)) {
         return;
+    }
 
-    auto removed_index = m_resources_index[resource_id];
+    auto removedIndex = m_resourcesIndex[resourceId];
-    auto removed_it = m_resources.begin() + removed_index;
+    auto removedIt = m_resources.begin() + removedIndex;
-    Q_ASSERT(removed_it != m_resources.end());
+    Q_ASSERT(removedIt != m_resources.end());
 
-    beginRemoveRows(QModelIndex(), removed_index, removed_index);
+    beginRemoveRows(QModelIndex(), removedIndex, removedIndex);
-    m_resources.erase(removed_it);
+    m_resources.erase(removedIt);
 
     // update index
-    m_resources_index.clear();
+    m_resourcesIndex.clear();
     int idx = 0;
-    for (auto const& mod : qAsConst(m_resources)) {
+    for (const auto& mod : qAsConst(m_resources)) {
-        m_resources_index[mod->internal_id()] = idx;
+        m_resourcesIndex[mod->internalId()] = idx;
         idx++;
     }
     endRemoveRows();
 }
 
-void ResourceFolderModel::applyUpdates(QSet<QString>& current_set, QSet<QString>& new_set, QMap<QString, Resource::Ptr>& new_resources)
+void ResourceFolderModel::applyUpdates(QSet<QString>& currentSet, QSet<QString>& newSet, QMap<QString, Resource::Ptr>& newResources)
 {
     // see if the kept resources changed in some way
     {
-        QSet<QString> kept_set = current_set;
+        QSet<QString> keptSet = currentSet;
-        kept_set.intersect(new_set);
+        keptSet.intersect(newSet);
 
-        for (auto const& kept : kept_set) {
+        for (const auto& kept : keptSet) {
-            auto row_it = m_resources_index.constFind(kept);
+            auto rowIt = m_resourcesIndex.constFind(kept);
-            Q_ASSERT(row_it != m_resources_index.constEnd());
+            Q_ASSERT(rowIt != m_resourcesIndex.constEnd());
-            auto row = row_it.value();
+            auto row = rowIt.value();
 
-            auto& new_resource = new_resources[kept];
+            auto& newResource = newResources[kept];
-            auto const& current_resource = m_resources.at(row);
+            const auto& currentResource = m_resources.at(row);
 
-            if (new_resource->dateTimeChanged() == current_resource->dateTimeChanged()) {
+            if (newResource->dateTimeChanged() == currentResource->dateTimeChanged()) {
                 // no significant change
-                bool hadIssues = !current_resource->hasIssues();
+                bool hadIssues = !currentResource->hasIssues();
-                current_resource->updateIssues(m_instance);
+                currentResource->updateIssues(m_instance);
 
-                if (hadIssues != current_resource->hasIssues()) {
+                if (hadIssues != currentResource->hasIssues()) {
                     emit dataChanged(index(row, 0), index(row, columnCount({}) - 1));
                 }
                 continue;
@@ -848,16 +882,16 @@ void ResourceFolderModel::applyUpdates(QSet<QString>& current_set, QSet<QString>
 
             // If the resource is resolving, but something about it changed, we don't want to
             // continue the resolving.
-            if (current_resource->isResolving()) {
+            if (currentResource->isResolving()) {
-                auto ticket = current_resource->resolutionTicket();
+                auto ticket = currentResource->resolutionTicket();
-                if (m_active_parse_tasks.contains(ticket)) {
+                if (m_activeParseTasks.contains(ticket)) {
-                    auto task = (*m_active_parse_tasks.find(ticket)).get();
+                    auto* task = (*m_activeParseTasks.find(ticket)).get();
                     task->abort();
                 }
             }
 
-            m_resources[row].reset(new_resource);
+            m_resources[row].reset(newResource);
-            new_resource->updateIssues(m_instance);
+            newResource->updateIssues(m_instance);
 
             resolveResource(m_resources.at(row));
             emit dataChanged(index(row, 0), index(row, columnCount(QModelIndex()) - 1));
@@ -866,46 +900,47 @@ void ResourceFolderModel::applyUpdates(QSet<QString>& current_set, QSet<QString>
 
     // remove resources no longer present
     {
-        QSet<QString> removed_set = current_set;
+        QSet<QString> removedSet = currentSet;
-        removed_set.subtract(new_set);
+        removedSet.subtract(newSet);
 
-        QList<int> removed_rows;
+        QList<int> removedRows;
-        for (auto& removed : removed_set)
+        for (const auto& removed : removedSet) {
-            removed_rows.append(m_resources_index[removed]);
+            removedRows.append(m_resourcesIndex[removed]);
+        }
 
-        std::sort(removed_rows.begin(), removed_rows.end(), std::greater<int>());
+        std::ranges::sort(removedRows, std::greater());
 
-        for (auto& removed_index : removed_rows) {
+        for (auto& removedIndex : removedRows) {
-            auto removed_it = m_resources.begin() + removed_index;
+            auto removedIt = m_resources.begin() + removedIndex;
 
-            Q_ASSERT(removed_it != m_resources.end());
+            Q_ASSERT(removedIt != m_resources.end());
 
-            if ((*removed_it)->isResolving()) {
+            if ((*removedIt)->isResolving()) {
-                auto ticket = (*removed_it)->resolutionTicket();
+                auto ticket = (*removedIt)->resolutionTicket();
-                if (m_active_parse_tasks.contains(ticket)) {
+                if (m_activeParseTasks.contains(ticket)) {
-                    auto task = (*m_active_parse_tasks.find(ticket)).get();
+                    auto* task = (*m_activeParseTasks.find(ticket)).get();
                     task->abort();
                 }
             }
 
-            beginRemoveRows(QModelIndex(), removed_index, removed_index);
+            beginRemoveRows(QModelIndex(), removedIndex, removedIndex);
-            m_resources.erase(removed_it);
+            m_resources.erase(removedIt);
             endRemoveRows();
         }
     }
 
     // add new resources to the end
     {
-        QSet<QString> added_set = new_set;
+        QSet<QString> addedSet = newSet;
-        added_set.subtract(current_set);
+        addedSet.subtract(currentSet);
 
         // When you have a Qt build with assertions turned on, proceeding here will abort the application
-        if (added_set.size() > 0) {
+        if (addedSet.size() > 0) {
             beginInsertRows(QModelIndex(), static_cast<int>(m_resources.size()),
-                            static_cast<int>(m_resources.size() + added_set.size() - 1));
+                            static_cast<int>(m_resources.size() + addedSet.size() - 1));
 
-            for (auto& added : added_set) {
+            for (const auto& added : addedSet) {
-                auto res = new_resources[added];
+                auto res = newResources[added];
                 res->updateIssues(m_instance);
                 m_resources.append(res);
                 resolveResource(m_resources.last());
@@ -917,10 +952,10 @@ void ResourceFolderModel::applyUpdates(QSet<QString>& current_set, QSet<QString>
 
     // update index
     {
-        m_resources_index.clear();
+        m_resourcesIndex.clear();
         int idx = 0;
-        for (auto const& mod : qAsConst(m_resources)) {
+        for (const auto& mod : qAsConst(m_resources)) {
-            m_resources_index[mod->internal_id()] = idx;
+            m_resourcesIndex[mod->internalId()] = idx;
             idx++;
         }
     }
@@ -928,17 +963,19 @@ void ResourceFolderModel::applyUpdates(QSet<QString>& current_set, QSet<QString>
 Resource::Ptr ResourceFolderModel::find(QString id)
 {
     auto iter =
-        std::find_if(m_resources.constBegin(), m_resources.constEnd(), [&](Resource::Ptr const& r) { return r->internal_id() == id; });
+        std::find_if(m_resources.constBegin(), m_resources.constEnd(), [&](const Resource::Ptr& r) { return r->internalId() == id; });
-    if (iter == m_resources.constEnd())
+    if (iter == m_resources.constEnd()) {
         return nullptr;
+    }
     return *iter;
 }
 QList<Resource*> ResourceFolderModel::allResources()
 {
     QList<Resource*> result;
     result.reserve(m_resources.size());
-    for (const Resource ::Ptr& resource : m_resources)
+    for (const Resource ::Ptr& resource : m_resources) {
         result.append((resource.get()));
+    }
     return result;
 }
 
@@ -946,8 +983,9 @@ QList<Resource*> ResourceFolderModel::selectedResources(const QModelIndexList& i
 {
     QList<Resource*> result;
     for (const QModelIndex& index : indexes) {
-        if (index.column() != 0)
+        if (index.column() != 0) {
             continue;
+        }
         result.append(&at(index.row()));
     }
     return result;

launcher/minecraft/mod/ResourceFolderModel.h

@@ -61,7 +61,7 @@ class QSortFilterProxyModel;
 class ResourceFolderModel : public QAbstractListModel {
     Q_OBJECT
    public:
-    ResourceFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent = nullptr);
+    ResourceFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent = nullptr);
     ~ResourceFolderModel() override;
 
     virtual QString id() const { return "resource"; }
@@ -93,13 +93,13 @@ class ResourceFolderModel : public QAbstractListModel {
      */
     virtual bool installResource(QString path);
 
-    virtual void installResourceWithFlameMetadata(QString path, ModPlatform::IndexedVersion& vers);
+    virtual void installResourceWithFlameMetadata(const QString& path, ModPlatform::IndexedVersion& vers);
 
     /** Uninstall (i.e. remove all data about it) a resource, given its file name.
      *
      *  Returns whether the removal was successful.
      */
-    virtual bool uninstallResource(const QString& file_name, bool preserve_metadata = false);
+    virtual bool uninstallResource(const QString& fileName, bool preserveMetadata = false);
     virtual bool deleteResources(const QModelIndexList&);
     virtual void deleteMetadata(const QModelIndexList&);
 
@@ -125,7 +125,7 @@ class ResourceFolderModel : public QAbstractListModel {
 
     Resource::Ptr find(QString id);
 
-    QDir const& dir() const { return m_dir; }
+    const QDir& dir() const { return m_dir; }
 
     /** Checks whether there's any parse tasks being done.
      *
@@ -137,12 +137,12 @@ class ResourceFolderModel : public QAbstractListModel {
     /* Qt behavior */
 
     /* Basic columns */
-    enum Columns { ActiveColumn = 0, NameColumn, DateColumn, ProviderColumn, SizeColumn, NUM_COLUMNS };
+    enum Columns : std::uint8_t { ActiveColumn = 0, NameColumn, DateColumn, ProviderColumn, SizeColumn, FileNameColumn, NumColumns };
 
-    QStringList columnNames(bool translated = true) const { return translated ? m_column_names_translated : m_column_names; }
+    QStringList columnNames(bool translated = true) const { return translated ? m_columnNamesTranslated : m_columnNames; }
 
     int rowCount(const QModelIndex& parent = {}) const override { return parent.isValid() ? 0 : static_cast<int>(size()); }
-    int columnCount(const QModelIndex& parent = {}) const override { return parent.isValid() ? 0 : NUM_COLUMNS; }
+    int columnCount(const QModelIndex& parent = {}) const override { return parent.isValid() ? 0 : NumColumns; }
 
     Qt::DropActions supportedDropActions() const override;
 
@@ -171,18 +171,19 @@ class ResourceFolderModel : public QAbstractListModel {
     QSortFilterProxyModel* createFilterProxyModel(QObject* parent = nullptr);
 
     SortType columnToSortKey(size_t column) const;
-    QList<QHeaderView::ResizeMode> columnResizeModes() const { return m_column_resize_modes; }
+    QList<QHeaderView::ResizeMode> columnResizeModes() const { return m_columnResizeModes; }
 
     class ProxyModel : public QSortFilterProxyModel {
        public:
         explicit ProxyModel(QObject* parent = nullptr) : QSortFilterProxyModel(parent) {}
 
        protected:
-        bool filterAcceptsRow(int source_row, const QModelIndex& source_parent) const override;
+        bool filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const override;
-        bool lessThan(const QModelIndex& source_left, const QModelIndex& source_right) const override;
+        bool lessThan(const QModelIndex& sourceLeft, const QModelIndex& sourceRight) const override;
     };
 
     QString instDirPath() const;
+    BaseInstance* instance() const { return m_instance; }
 
    signals:
     void updateFinished();
@@ -206,7 +207,7 @@ class ResourceFolderModel : public QAbstractListModel {
      *  This task should load and parse all heavy info needed by a resource, such as parsing a manifest. It gets executed
      *  in the background, so it slowly updates the UI as tasks get done.
      */
-    [[nodiscard]] virtual Task* createParseTask(Resource&) { return nullptr; }
+    [[nodiscard]] virtual Task* createParseTask(Resource& /*unused*/) { return nullptr; }
 
     /** Standard implementation of the model update logic.
      *
@@ -214,10 +215,10 @@ class ResourceFolderModel : public QAbstractListModel {
      *  to act only on those disparities.
      *
      */
-    void applyUpdates(QSet<QString>& current_set, QSet<QString>& new_set, QMap<QString, Resource::Ptr>& new_resources);
+    void applyUpdates(QSet<QString>& currentSet, QSet<QString>& newSet, QMap<QString, Resource::Ptr>& newResources);
 
    protected slots:
-    void directoryChanged(QString);
+    void directoryChanged(const QString&);
 
     /** Called when the update task is successful.
      *
@@ -233,39 +234,40 @@ class ResourceFolderModel : public QAbstractListModel {
      *  This is just a simple reference implementation. You probably want to override it with your own logic in a subclass
      *  if the resource is complex and has more stuff to parse.
      */
-    virtual void onParseSucceeded(int ticket, QString resource_id);
+    virtual void onParseSucceeded(int ticket, const QString& resourceId);
-    virtual void onParseFailed(int ticket, QString resource_id);
+    virtual void onParseFailed(int ticket, const QString& resourceId);
 
    protected:
     // Represents the relationship between a column's index (represented by the list index), and it's sorting key.
     // As such, the order in with they appear is very important!
-    QList<SortType> m_column_sort_keys = { SortType::ENABLED, SortType::NAME, SortType::DATE, SortType::PROVIDER, SortType::SIZE };
+    QList<SortType> m_columnSortKeys = { SortType::Enabled,  SortType::Name, SortType::Date,
-    QStringList m_column_names = { "Enable", "Name", "Last Modified", "Provider", "Size" };
+                                         SortType::Provider, SortType::Size, SortType::Filename };
-    QStringList m_column_names_translated = { tr("Enable"), tr("Name"), tr("Last Modified"), tr("Provider"), tr("Size") };
+    QStringList m_columnNames = { "Enable", "Name", "Last Modified", "Provider", "Size", "File Name" };
-    QList<QHeaderView::ResizeMode> m_column_resize_modes = { QHeaderView::Interactive, QHeaderView::Stretch, QHeaderView::Interactive,
+    QStringList m_columnNamesTranslated = { tr("Enable"), tr("Name"), tr("Last Modified"), tr("Provider"), tr("Size"), tr("File Name") };
-                                                             QHeaderView::Interactive, QHeaderView::Interactive };
+    QList<QHeaderView::ResizeMode> m_columnResizeModes = { QHeaderView::Interactive, QHeaderView::Stretch,     QHeaderView::Interactive,
-    QList<bool> m_columnsHideable = { false, false, true, true, true };
+                                                           QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
+    QList<bool> m_columnsHideable = { false, false, true, true, true, true };
 
     QDir m_dir;
     BaseInstance* m_instance;
     QFileSystemWatcher m_watcher;
-    bool m_is_watching = false;
+    bool m_isWatching = false;
 
-    bool m_is_indexed;
+    bool m_isIndexed;
-    bool m_first_folder_load = true;
+    bool m_firstFolderLoad = true;
 
-    Task::Ptr m_current_update_task = nullptr;
+    Task::Ptr m_currentUpdateTask = nullptr;
-    bool m_scheduled_update = false;
+    bool m_scheduledUpdate = false;
 
     QList<Resource::Ptr> m_resources;
 
     // Represents the relationship between a resource's internal ID and it's row position on the model.
-    QMap<QString, int> m_resources_index;
+    QMap<QString, int> m_resourcesIndex;
 
     // Runs off-thread
     ConcurrentTask m_resourceResolver;
     bool m_resourceResolverRunning = false;
 
-    QMap<int, Task::Ptr> m_active_parse_tasks;
+    QMap<int, Task::Ptr> m_activeParseTasks;
-    std::atomic<int> m_next_resolution_ticket = 0;
+    std::atomic<int> m_nextResolutionTicket = 0;
 };

launcher/minecraft/mod/ResourcePackFolderModel.cpp

@@ -39,27 +39,26 @@
 #include <QIcon>
 #include <QStyle>
 
-#include "Version.h"
-
 #include "minecraft/mod/tasks/LocalDataPackParseTask.h"
 
-ResourcePackFolderModel::ResourcePackFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent)
+ResourcePackFolderModel::ResourcePackFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent)
-    : ResourceFolderModel(dir, instance, is_indexed, create_dir, parent)
+    : ResourceFolderModel(dir, instance, isIndexed, createDir, parent)
 {
-    m_column_names = QStringList({ "Enable", "Image", "Name", "Pack Format", "Last Modified", "Provider", "Size" });
+    m_columnNames = QStringList({ "Enable", "Image", "Name", "Pack Format", "Last Modified", "Provider", "Size", "File Name" });
-    m_column_names_translated =
+    m_columnNamesTranslated = QStringList(
-        QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Pack Format"), tr("Last Modified"), tr("Provider"), tr("Size") });
+        { tr("Enable"), tr("Image"), tr("Name"), tr("Pack Format"), tr("Last Modified"), tr("Provider"), tr("Size"), tr("File Name") });
-    m_column_sort_keys = { SortType::ENABLED, SortType::NAME,     SortType::NAME, SortType::PACK_FORMAT,
+    m_columnSortKeys = { SortType::Enabled, SortType::Name,     SortType::Name, SortType::PackFormat,
-                           SortType::DATE,    SortType::PROVIDER, SortType::SIZE };
+                         SortType::Date,    SortType::Provider, SortType::Size, SortType::Filename };
-    m_column_resize_modes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,    QHeaderView::Interactive,
+    m_columnResizeModes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,     QHeaderView::Interactive,
-                              QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
+                            QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
-    m_columnsHideable = { false, true, false, true, true, true, true };
+    m_columnsHideable = { false, true, false, true, true, true, true, true };
 }
 
 QVariant ResourcePackFolderModel::data(const QModelIndex& index, int role) const
 {
-    if (!validateIndex(index))
+    if (!validateIndex(index)) {
         return {};
+    }
 
     int row = index.row();
     int column = index.column();
@@ -92,6 +91,8 @@ QVariant ResourcePackFolderModel::data(const QModelIndex& index, int role) const
                 return QSize(32, 32);
             }
             break;
+        default:
+            break;
     }
 
     // map the columns to the base equivilents
@@ -112,6 +113,11 @@ QVariant ResourcePackFolderModel::data(const QModelIndex& index, int role) const
         case SizeColumn:
             mappedIndex = index.siblingAtColumn(ResourceFolderModel::SizeColumn);
             break;
+        case FileNameColumn:
+            mappedIndex = index.siblingAtColumn(ResourceFolderModel::FileNameColumn);
+            break;
+        default:
+            break;
     }
 
     if (mappedIndex.isValid()) {
@@ -133,6 +139,7 @@ QVariant ResourcePackFolderModel::headerData(int section, [[maybe_unused]] Qt::O
                 case ImageColumn:
                 case ProviderColumn:
                 case SizeColumn:
+                case FileNameColumn:
                     return columnNames().at(section);
                 default:
                     return {};
@@ -153,6 +160,8 @@ QVariant ResourcePackFolderModel::headerData(int section, [[maybe_unused]] Qt::O
                     return tr("The source provider of the resource pack.");
                 case SizeColumn:
                     return tr("The size of the resource pack.");
+                case FileNameColumn:
+                    return tr("The file name of the resource pack.");
                 default:
                     return {};
             }
@@ -168,10 +177,10 @@ QVariant ResourcePackFolderModel::headerData(int section, [[maybe_unused]] Qt::O
 
 int ResourcePackFolderModel::columnCount(const QModelIndex& parent) const
 {
-    return parent.isValid() ? 0 : NUM_COLUMNS;
+    return parent.isValid() ? 0 : NumColumns;
 }
 
 Task* ResourcePackFolderModel::createParseTask(Resource& resource)
 {
-    return new LocalDataPackParseTask(m_next_resolution_ticket, dynamic_cast<ResourcePack*>(&resource));
+    return new LocalDataPackParseTask(m_nextResolutionTicket, dynamic_cast<ResourcePack*>(&resource));
 }

launcher/minecraft/mod/ResourcePackFolderModel.h

@@ -7,9 +7,19 @@
 class ResourcePackFolderModel : public ResourceFolderModel {
     Q_OBJECT
    public:
-    enum Columns { ActiveColumn = 0, ImageColumn, NameColumn, PackFormatColumn, DateColumn, ProviderColumn, SizeColumn, NUM_COLUMNS };
+    enum Columns : std::uint8_t {
+        ActiveColumn = 0,
+        ImageColumn,
+        NameColumn,
+        PackFormatColumn,
+        DateColumn,
+        ProviderColumn,
+        SizeColumn,
+        FileNameColumn,
+        NumColumns
+    };
 
-    explicit ResourcePackFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent = nullptr);
+    explicit ResourcePackFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent = nullptr);
 
     QString id() const override { return "resourcepacks"; }
 
@@ -19,7 +29,7 @@ class ResourcePackFolderModel : public ResourceFolderModel {
     int columnCount(const QModelIndex& parent) const override;
 
     [[nodiscard]] Resource* createResource(const QFileInfo& file) override { return new ResourcePack(file); }
-    [[nodiscard]] Task* createParseTask(Resource&) override;
+    [[nodiscard]] Task* createParseTask(Resource& /*unused*/) override;
 
     RESOURCE_HELPERS(ResourcePack)
 };

launcher/minecraft/mod/ShaderPackFolderModel.h

@@ -18,7 +18,7 @@ class ShaderPackFolderModel : public ResourceFolderModel {
 
     [[nodiscard]] Task* createParseTask(Resource& resource) override
     {
-        return new LocalShaderPackParseTask(m_next_resolution_ticket, static_cast<ShaderPack&>(resource));
+        return new LocalShaderPackParseTask(m_nextResolutionTicket, static_cast<ShaderPack&>(resource));
     }
 
     QDir indexDir() const override { return m_dir; }

launcher/minecraft/mod/TexturePackFolderModel.cpp

@@ -36,28 +36,30 @@
 #include "TexturePackFolderModel.h"
 
 #include "minecraft/mod/tasks/LocalTexturePackParseTask.h"
-#include "minecraft/mod/tasks/ResourceFolderLoadTask.h"
 
-TexturePackFolderModel::TexturePackFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent)
+TexturePackFolderModel::TexturePackFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent)
-    : ResourceFolderModel(QDir(dir), instance, is_indexed, create_dir, parent)
+    : ResourceFolderModel(QDir(dir), instance, isIndexed, createDir, parent)
 {
-    m_column_names = QStringList({ "Enable", "Image", "Name", "Last Modified", "Provider", "Size" });
+    m_columnNames = QStringList({ "Enable", "Image", "Name", "Last Modified", "Provider", "Size", "File Name" });
-    m_column_names_translated = QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Last Modified"), tr("Provider"), tr("Size") });
+    m_columnNamesTranslated =
-    m_column_sort_keys = { SortType::ENABLED, SortType::NAME, SortType::NAME, SortType::DATE, SortType::PROVIDER, SortType::SIZE };
+        QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Last Modified"), tr("Provider"), tr("Size"), tr("File Name") });
-    m_column_resize_modes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,
+    m_columnSortKeys = { SortType::Enabled,  SortType::Name, SortType::Name,    SortType::Date,
-                              QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
+                         SortType::Provider, SortType::Size, SortType::Filename };
-    m_columnsHideable = { false, true, false, true, true, true };
+    m_columnResizeModes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,    QHeaderView::Interactive,
+                            QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
+    m_columnsHideable = { false, true, false, true, true, true, true };
 }
 
 Task* TexturePackFolderModel::createParseTask(Resource& resource)
 {
-    return new LocalTexturePackParseTask(m_next_resolution_ticket, static_cast<TexturePack&>(resource));
+    return new LocalTexturePackParseTask(m_nextResolutionTicket, static_cast<TexturePack&>(resource));
 }
 
 QVariant TexturePackFolderModel::data(const QModelIndex& index, int role) const
 {
-    if (!validateIndex(index))
+    if (!validateIndex(index)) {
         return {};
+    }
 
     int row = index.row();
     int column = index.column();
@@ -76,6 +78,8 @@ QVariant TexturePackFolderModel::data(const QModelIndex& index, int role) const
                 return QSize(32, 32);
             }
             break;
+        default:
+            break;
     }
 
     // map the columns to the base equivilents
@@ -96,6 +100,11 @@ QVariant TexturePackFolderModel::data(const QModelIndex& index, int role) const
         case SizeColumn:
             mappedIndex = index.siblingAtColumn(ResourceFolderModel::SizeColumn);
             break;
+        case FileNameColumn:
+            mappedIndex = index.siblingAtColumn(ResourceFolderModel::FileNameColumn);
+            break;
+        default:
+            break;
     }
 
     if (mappedIndex.isValid()) {
@@ -116,6 +125,7 @@ QVariant TexturePackFolderModel::headerData(int section, [[maybe_unused]] Qt::Or
                 case ImageColumn:
                 case ProviderColumn:
                 case SizeColumn:
+                case FileNameColumn:
                     return columnNames().at(section);
                 default:
                     return {};
@@ -132,6 +142,8 @@ QVariant TexturePackFolderModel::headerData(int section, [[maybe_unused]] Qt::Or
                     return tr("The source provider of the texture pack.");
                 case SizeColumn:
                     return tr("The size of the texture pack.");
+                case FileNameColumn:
+                    return tr("The file name of the texture pack.");
                 default:
                     return {};
             }
@@ -145,5 +157,5 @@ QVariant TexturePackFolderModel::headerData(int section, [[maybe_unused]] Qt::Or
 
 int TexturePackFolderModel::columnCount(const QModelIndex& parent) const
 {
-    return parent.isValid() ? 0 : NUM_COLUMNS;
+    return parent.isValid() ? 0 : NumColumns;
 }

launcher/minecraft/mod/TexturePackFolderModel.h

@@ -44,11 +44,20 @@ class TexturePackFolderModel : public ResourceFolderModel {
     Q_OBJECT
 
    public:
-    enum Columns { ActiveColumn = 0, ImageColumn, NameColumn, DateColumn, ProviderColumn, SizeColumn, NUM_COLUMNS };
+    enum Columns : std::uint8_t {
+        ActiveColumn = 0,
+        ImageColumn,
+        NameColumn,
+        DateColumn,
+        ProviderColumn,
+        SizeColumn,
+        FileNameColumn,
+        NumColumns
+    };
 
-    explicit TexturePackFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent = nullptr);
+    explicit TexturePackFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent = nullptr);
 
-    virtual QString id() const override { return "texturepacks"; }
+    QString id() const override { return "texturepacks"; }
 
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
 
@@ -56,7 +65,7 @@ class TexturePackFolderModel : public ResourceFolderModel {
     int columnCount(const QModelIndex& parent) const override;
 
     [[nodiscard]] Resource* createResource(const QFileInfo& file) override { return new TexturePack(file); }
-    [[nodiscard]] Task* createParseTask(Resource&) override;
+    [[nodiscard]] Task* createParseTask(Resource& /*unused*/) override;
 
     RESOURCE_HELPERS(TexturePack)
 };

launcher/minecraft/mod/tasks/LocalModParseTask.cpp

@@ -751,7 +751,7 @@ bool loadIconFile(const Mod& mod, QPixmap* pixmap)
             if (icon_info.exists() && icon_info.isFile()) {
                 QFile icon(icon_info.filePath());
                 if (!icon.open(QIODevice::ReadOnly)) {
-                    return png_invalid("failed  to open file " + icon_info.filePath());
+                    return png_invalid("failed to open file " + icon_info.filePath() + " " + icon.errorString());
                 }
                 auto data = icon.readAll();
 

launcher/minecraft/mod/tasks/ResourceFolderLoadTask.cpp

@@ -41,26 +41,28 @@
 #include "minecraft/mod/MetadataHandler.h"
 
 #include <QThread>
+#include <utility>
 
-ResourceFolderLoadTask::ResourceFolderLoadTask(const QDir& resource_dir,
+ResourceFolderLoadTask::ResourceFolderLoadTask(const QDir& resourceDir,
-                                               const QDir& index_dir,
+                                               const QDir& indexDir,
-                                               bool is_indexed,
+                                               bool isIndexed,
-                                               bool clean_orphan,
+                                               bool cleanOrphan,
-                                               std::function<Resource*(const QFileInfo&)> create_function)
+                                               std::function<Resource*(const QFileInfo&)> createFunction)
     : Task(false)
-    , m_resource_dir(resource_dir)
+    , m_resource_dir(resourceDir)
-    , m_index_dir(index_dir)
+    , m_index_dir(indexDir)
-    , m_is_indexed(is_indexed)
+    , m_is_indexed(isIndexed)
-    , m_clean_orphan(clean_orphan)
+    , m_clean_orphan(cleanOrphan)
-    , m_create_func(create_function)
+    , m_create_func(std::move(createFunction))
     , m_result(new Result())
     , m_thread_to_spawn_into(thread())
 {}
 
 void ResourceFolderLoadTask::executeTask()
 {
-    if (thread() != m_thread_to_spawn_into)
+    if (thread() != m_thread_to_spawn_into) {
         connect(this, &Task::finished, this->thread(), &QThread::quit);
+    }
 
     if (m_is_indexed) {
         // Read metadata first
@@ -71,7 +73,7 @@ void ResourceFolderLoadTask::executeTask()
     m_resource_dir.refresh();
     for (auto entry : m_resource_dir.entryInfoList()) {
         auto filePath = entry.absoluteFilePath();
-        if (auto app = APPLICATION_DYN; app && app->checkQSavePath(filePath)) {
+        if (auto* app = APPLICATION_DYN; (app != nullptr) && app->checkQSavePath(filePath)) {
             continue;
         }
         auto newFilePath = FS::getUniqueResourceName(filePath);
@@ -83,29 +85,29 @@ void ResourceFolderLoadTask::executeTask()
         Resource* resource = m_create_func(entry);
 
         if (resource->enabled()) {
-            if (m_result->resources.contains(resource->internal_id())) {
+            if (m_result->resources.contains(resource->internalId())) {
-                m_result->resources[resource->internal_id()]->setStatus(ResourceStatus::INSTALLED);
+                m_result->resources[resource->internalId()]->setStatus(ResourceStatus::Installed);
                 // Delete the object we just created, since a valid one is already in the mods list.
                 delete resource;
             } else {
-                m_result->resources[resource->internal_id()].reset(resource);
+                m_result->resources[resource->internalId()].reset(resource);
-                m_result->resources[resource->internal_id()]->setStatus(ResourceStatus::NO_METADATA);
+                m_result->resources[resource->internalId()]->setStatus(ResourceStatus::NoMetadata);
             }
         } else {
-            QString chopped_id = resource->internal_id().chopped(9);
+            QString choppedId = resource->internalId().chopped(9);
-            if (m_result->resources.contains(chopped_id)) {
+            if (m_result->resources.contains(choppedId)) {
-                m_result->resources[resource->internal_id()].reset(resource);
+                m_result->resources[resource->internalId()].reset(resource);
 
-                auto metadata = m_result->resources[chopped_id]->metadata();
+                auto metadata = m_result->resources[choppedId]->metadata();
                 if (metadata) {
                     resource->setMetadata(*metadata);
 
-                    m_result->resources[resource->internal_id()]->setStatus(ResourceStatus::INSTALLED);
+                    m_result->resources[resource->internalId()]->setStatus(ResourceStatus::Installed);
-                    m_result->resources.remove(chopped_id);
+                    m_result->resources.remove(choppedId);
                 }
             } else {
-                m_result->resources[resource->internal_id()].reset(resource);
+                m_result->resources[resource->internalId()].reset(resource);
-                m_result->resources[resource->internal_id()]->setStatus(ResourceStatus::NO_METADATA);
+                m_result->resources[resource->internalId()]->setStatus(ResourceStatus::NoMetadata);
             }
         }
     }
@@ -116,38 +118,41 @@ void ResourceFolderLoadTask::executeTask()
         QMutableMapIterator iter(m_result->resources);
         while (iter.hasNext()) {
             auto resource = iter.next().value();
-            if (resource->status() == ResourceStatus::NOT_INSTALLED) {
+            if (resource->status() == ResourceStatus::NotInstalled) {
                 resource->destroy(m_index_dir, false, false);
                 iter.remove();
             }
         }
     }
 
-    for (auto mod : m_result->resources)
+    for (const auto& mod : m_result->resources) {
         mod->moveToThread(m_thread_to_spawn_into);
+    }
 
-    if (m_aborted)
+    if (m_aborted) {
         emit finished();
-    else
+    } else {
         emitSucceeded();
+    }
 }
 
 void ResourceFolderLoadTask::getFromMetadata()
 {
     m_index_dir.refresh();
-    for (auto entry : m_index_dir.entryList(QDir::Files)) {
+    for (const auto& entry : m_index_dir.entryList(QDir::Files)) {
         if (!entry.endsWith(".pw.toml")) {
             continue;
         }
 
         auto metadata = Metadata::get(m_index_dir, entry);
 
-        if (!metadata.isValid())
+        if (!metadata.isValid()) {
             continue;
+        }
 
         auto* resource = m_create_func(QFileInfo(m_resource_dir.filePath(metadata.filename)));
         resource->setMetadata(metadata);
-        resource->setStatus(ResourceStatus::NOT_INSTALLED);
+        resource->setStatus(ResourceStatus::NotInstalled);
-        m_result->resources[resource->internal_id()].reset(resource);
+        m_result->resources[resource->internalId()].reset(resource);
     }
 }

launcher/minecraft/mod/tasks/ResourceFolderLoadTask.h

@@ -41,7 +41,7 @@
 #include <QObject>
 #include <QRunnable>
 #include <memory>
-#include "minecraft/mod/Mod.h"
+#include "minecraft/mod/Resource.h"
 #include "tasks/Task.h"
 
 class ResourceFolderLoadTask : public Task {
@@ -54,11 +54,11 @@ class ResourceFolderLoadTask : public Task {
     ResultPtr result() const { return m_result; }
 
    public:
-    ResourceFolderLoadTask(const QDir& resource_dir,
+    ResourceFolderLoadTask(const QDir& resourceDir,
-                           const QDir& index_dir,
+                           const QDir& indexDir,
-                           bool is_indexed,
+                           bool isIndexed,
-                           bool clean_orphan,
+                           bool cleanOrphan,
-                           std::function<Resource*(const QFileInfo&)> create_function);
+                           std::function<Resource*(const QFileInfo&)> createFunction);
 
     bool canAbort() const override { return true; }
     bool abort() override
@@ -76,7 +76,7 @@ class ResourceFolderLoadTask : public Task {
     QDir m_resource_dir, m_index_dir;
     bool m_is_indexed;
     bool m_clean_orphan;
-    std::function<Resource*(QFileInfo const&)> m_create_func;
+    std::function<Resource*(const QFileInfo&)> m_create_func;
     ResultPtr m_result;
 
     std::atomic<bool> m_aborted = false;

launcher/minecraft/skins/SkinList.cpp

@@ -121,7 +121,7 @@ bool SkinList::update()
     auto folderContents = m_dir.entryInfoList();
     // if there are any untracked files...
     for (QFileInfo entry : folderContents) {
-        if (!entry.isFile() && entry.suffix() != "png")
+        if (!entry.isFile() || entry.suffix() != "png")
             continue;
 
         SkinModel w(entry.absoluteFilePath());

launcher/modplatform/CheckUpdateTask.h

@@ -15,15 +15,15 @@ class CheckUpdateTask : public Task {
                     std::vector<Version>& mcVersions,
                     QList<ModPlatform::ModLoaderType> loadersList,
                     ResourceFolderModel* resourceModel)
-        : Task(), m_resources(resources), m_gameVersions(mcVersions), m_loadersList(std::move(loadersList)), m_resourceModel(resourceModel)
+        : m_resources(resources), m_gameVersions(mcVersions), m_loadersList(std::move(loadersList)), m_resourceModel(resourceModel)
     {}
 
     struct Update {
         QString name;
-        QString old_hash;
+        QString oldHash;
-        QString old_version;
+        QString oldVersion;
-        QString new_version;
+        QString newVersion;
-        std::optional<ModPlatform::IndexedVersionType> new_version_type;
+        std::optional<ModPlatform::IndexedVersionType> newVersionType;
         QString changelog;
         ModPlatform::ResourceProvider provider;
         shared_qobject_ptr<ResourceDownloadTask> download;
@@ -31,19 +31,19 @@ class CheckUpdateTask : public Task {
 
        public:
         Update(QString name,
-               QString old_h,
+               QString oldH,
-               QString old_v,
+               QString oldV,
-               QString new_v,
+               QString newV,
-               std::optional<ModPlatform::IndexedVersionType> new_v_type,
+               std::optional<ModPlatform::IndexedVersionType> newVType,
                QString changelog,
                ModPlatform::ResourceProvider p,
                shared_qobject_ptr<ResourceDownloadTask> t,
                bool enabled = true)
             : name(std::move(name))
-            , old_hash(std::move(old_h))
+            , oldHash(std::move(oldH))
-            , old_version(std::move(old_v))
+            , oldVersion(std::move(oldV))
-            , new_version(std::move(new_v))
+            , newVersion(std::move(newV))
-            , new_version_type(std::move(new_v_type))
+            , newVersionType(newVType)
             , changelog(std::move(changelog))
             , provider(p)
             , download(std::move(t))
@@ -54,14 +54,11 @@ class CheckUpdateTask : public Task {
     auto getUpdates() -> std::vector<Update>&& { return std::move(m_updates); }
     auto getDependencies() -> QList<std::shared_ptr<GetModDependenciesTask::PackDependency>>&& { return std::move(m_deps); }
 
-   public slots:
-    bool abort() override = 0;
-
    protected slots:
     void executeTask() override = 0;
 
    signals:
-    void checkFailed(Resource* failed, QString reason, QUrl recover_url = {});
+    void checkFailed(Resource* failed, QString reason, QUrl recoverUrl = {});
 
    protected:
     QList<Resource*>& m_resources;

launcher/modplatform/EnsureMetadataTask.cpp

@@ -99,7 +99,7 @@ void EnsureMetadataTask::executeTask()
         }
 
         // They already have the right metadata :o
-        if (resource->status() != ResourceStatus::NO_METADATA && resource->metadata() && resource->metadata()->provider == m_provider) {
+        if (resource->status() != ResourceStatus::NoMetadata && resource->metadata() && resource->metadata()->provider == m_provider) {
             qDebug() << "Resource" << resource->name() << "already has metadata!";
             emitReady(resource);
             continue;
@@ -263,7 +263,7 @@ Task::Ptr EnsureMetadataTask::modrinthVersionsTask()
 Task::Ptr EnsureMetadataTask::modrinthProjectsTask()
 {
     QHash<QString, QString> addonIds;
-    for (auto const& data : m_tempVersions)
+    for (const auto& data : m_tempVersions)
         addonIds.insert(data.addonId.toString(), data.hash);
 
     Task::Ptr proj_task;
@@ -404,7 +404,7 @@ Task::Ptr EnsureMetadataTask::flameVersionsTask()
 Task::Ptr EnsureMetadataTask::flameProjectsTask()
 {
     QHash<QString, QString> addonIds;
-    for (auto const& hash : m_resources.keys()) {
+    for (const auto& hash : m_resources.keys()) {
         if (m_tempVersions.contains(hash)) {
             auto data = m_tempVersions.find(hash).value();
 

launcher/modplatform/ModIndex.h

@@ -32,6 +32,7 @@ class QIODevice;
 namespace ModPlatform {
 
 enum class ModLoaderType : std::uint16_t {
+    None = 0U,
     NeoForge = 1U << 0U,
     Forge = 1U << 1U,
     Cauldron = 1U << 2U,
@@ -124,7 +125,7 @@ struct IndexedVersion {
     bool is_preferred = true;
     QString changelog;
     QList<Dependency> dependencies;
-    Side side;  // this is for flame API
+    Side side = Side::NoSide;  // this is for flame API
 
     // For internal use, not provided by APIs
     bool is_currently_selected = false;
@@ -172,7 +173,7 @@ struct IndexedPack {
     QString logoName;
     QString logoUrl;
     QString websiteUrl;
-    Side side;
+    Side side = Side::NoSide;
 
     bool versionsLoaded = false;
     QList<IndexedVersion> versions;

launcher/modplatform/ResourceAPI.cpp

@@ -2,7 +2,6 @@
 
 #include "Application.h"
 #include "Json.h"
-#include "Version.h"
 #include "net/NetJob.h"
 
 #include "modplatform/ModIndex.h"
@@ -117,7 +116,8 @@ Task::Ptr ResourceAPI::getProjectVersions(VersionSearchArgs&& args, Callback<QVe
             }
 
             auto orderSortPredicate = [](const ModPlatform::IndexedVersion& a, const ModPlatform::IndexedVersion& b) -> bool {
-                return Version(a.version) > Version(b.version);
+                // dates are in RFC 3339 format
+                return a.date > b.date;
             };
             std::sort(unsortedVersions.begin(), unsortedVersions.end(), orderSortPredicate);
         } catch (const JSONValidationError& e) {
@@ -148,9 +148,9 @@ Task::Ptr ResourceAPI::getProjectVersions(VersionSearchArgs&& args, Callback<QVe
     return netJob;
 }
 
-Task::Ptr ResourceAPI::getProjectInfo(ProjectInfoArgs&& args, Callback<ModPlatform::IndexedPack::Ptr>&& callbacks) const
+Task::Ptr ResourceAPI::getProjectInfo(ProjectInfoArgs&& args, Callback<ModPlatform::IndexedPack::Ptr>&& callbacks, bool askRetry) const
 {
-    auto [job, response] = getProject(args.pack->addonId.toString());
+    auto [job, response] = getProject(args.pack->addonId.toString(), askRetry);
 
     QObject::connect(job.get(), &NetJob::succeeded, [this, response, callbacks, args] {
         auto pack = args.pack;
@@ -284,7 +284,7 @@ QString ResourceAPI::mapMCVersionToModrinth(Version v) const
     return verStr;
 }
 
-std::pair<Task::Ptr, QByteArray*> ResourceAPI::getProject(QString addonId) const
+std::pair<Task::Ptr, QByteArray*> ResourceAPI::getProject(QString addonId, bool askRetry) const
 {
     auto project_url_optional = getInfoURL(addonId);
     if (!project_url_optional.has_value())
@@ -293,6 +293,7 @@ std::pair<Task::Ptr, QByteArray*> ResourceAPI::getProject(QString addonId) const
     auto project_url = project_url_optional.value();
 
     auto netJob = makeShared<NetJob>(QString("%1::GetProject").arg(addonId), APPLICATION->network());
+    netJob->setAskRetry(askRetry);
 
     auto [action, response] = Net::ApiDownload::makeByteArray(QUrl(project_url));
     netJob->addNetAction(action);

launcher/modplatform/ResourceAPI.h

@@ -115,10 +115,10 @@ class ResourceAPI {
    public slots:
     virtual Task::Ptr searchProjects(SearchArgs&&, Callback<QList<ModPlatform::IndexedPack::Ptr>>&&) const;
 
-    virtual std::pair<Task::Ptr, QByteArray*> getProject(QString addonId) const;
+    virtual std::pair<Task::Ptr, QByteArray*> getProject(QString addonId, bool askRetry = true) const;
     virtual std::pair<Task::Ptr, QByteArray*> getProjects(QStringList addonIds) const = 0;
 
-    virtual Task::Ptr getProjectInfo(ProjectInfoArgs&&, Callback<ModPlatform::IndexedPack::Ptr>&&) const;
+    virtual Task::Ptr getProjectInfo(ProjectInfoArgs&&, Callback<ModPlatform::IndexedPack::Ptr>&&, bool askRetry = true) const;
     Task::Ptr getProjectVersions(VersionSearchArgs&& args, Callback<QVector<ModPlatform::IndexedVersion>>&& callbacks) const;
     virtual Task::Ptr getDependencyVersion(DependencySearchArgs&&, Callback<ModPlatform::IndexedVersion>&&) const;
 

launcher/modplatform/atlauncher/ATLPackInstallTask.cpp

@@ -38,6 +38,7 @@
 
 #include <QtConcurrent>
 #include <algorithm>
+#include <utility>
 
 #include "FileSystem.h"
 #include "Json.h"
@@ -59,18 +60,28 @@
 #include "BuildConfig.h"
 #include "ui/dialogs/BlockedModsDialog.h"
 
+namespace {
+bool isPathTraversal(const QString& basePath, const QString& entryName)
+{
+    auto safeName = FS::RemoveInvalidPathChars(entryName);
+    auto fullPath = FS::PathCombine(basePath, safeName);
+    auto baseUrl = QUrl::fromLocalFile(basePath);
+    return !baseUrl.isParentOf(QUrl::fromLocalFile(fullPath));
+}
+
+Meta::Version::Ptr getComponentVersion(const QString& uid, const QString& version)
+{
+    return APPLICATION->metadataIndex()->getLoadedVersion(uid, version);
+}
+}  // namespace
+
 namespace ATLauncher {
 
-static Meta::Version::Ptr getComponentVersion(const QString& uid, const QString& version);
-
 PackInstallTask::PackInstallTask(UserInteractionSupport* support, QString packName, QString version, InstallMode installMode)
+    : m_support(support), m_install_mode(installMode), m_pack_name(packName), m_version_name(std::move(version))
 {
-    m_support = support;
-    m_pack_name = packName;
     static const QRegularExpression s_regex("[^A-Za-z0-9]");
     m_pack_safe_name = packName.replace(s_regex, "");
-    m_version_name = version;
-    m_install_mode = installMode;
 }
 
 bool PackInstallTask::abort()
@@ -107,11 +118,10 @@ void PackInstallTask::onDownloadSucceeded(QByteArray* responsePtr)
     QByteArray response = std::move(*responsePtr);
     jobPtr.reset();
 
-    QJsonParseError parse_error{};
+    QJsonParseError parseError{};
-    QJsonDocument doc = QJsonDocument::fromJson(response, &parse_error);
+    QJsonDocument doc = QJsonDocument::fromJson(response, &parseError);
-    if (parse_error.error != QJsonParseError::NoError) {
+    if (parseError.error != QJsonParseError::NoError) {
-        qWarning() << "Error while parsing JSON response from ATLauncher at" << parse_error.offset
+        qWarning() << "Error while parsing JSON response from ATLauncher at" << parseError.offset << "reason:" << parseError.errorString();
-                   << "reason:" << parse_error.errorString();
         qWarning() << response;
         return;
     }
@@ -128,7 +138,7 @@ void PackInstallTask::onDownloadSucceeded(QByteArray* responsePtr)
 
     // Derived from the installation mode
     QString message;
-    bool resetDirectory;
+    bool resetDirectory = false;
 
     switch (m_install_mode) {
         case InstallMode::Reinstall:
@@ -148,8 +158,9 @@ void PackInstallTask::onDownloadSucceeded(QByteArray* responsePtr)
     }
 
     // Display message if one exists
-    if (!message.isEmpty())
+    if (!message.isEmpty()) {
         m_support->displayMessage(message);
+    }
 
     auto ver = getComponentVersion("net.minecraft", m_version.minecraft);
     if (!ver) {
@@ -173,7 +184,7 @@ void PackInstallTask::onDownloadFailed(QString reason)
 {
     qDebug() << "PackInstallTask::onDownloadFailed:" << QThread::currentThreadId();
     jobPtr.reset();
-    emitFailed(reason);
+    emitFailed(std::move(reason));
 }
 
 void PackInstallTask::onDownloadAborted()
@@ -202,26 +213,30 @@ void PackInstallTask::deleteExistingFiles()
     keeps.files.append(VersionKeep{ "root", "servers.dat" });
 
     // Merge with version deletes and keeps
-    for (const auto& item : m_version.deletes.files)
+    for (const auto& item : m_version.deletes.files) {
         deletes.files.append(item);
-    for (const auto& item : m_version.deletes.folders)
+    }
+    for (const auto& item : m_version.deletes.folders) {
         deletes.folders.append(item);
-    for (const auto& item : m_version.keeps.files)
+    }
+    for (const auto& item : m_version.keeps.files) {
         keeps.files.append(item);
-    for (const auto& item : m_version.keeps.folders)
+    }
+    for (const auto& item : m_version.keeps.folders) {
         keeps.folders.append(item);
+    }
 
     auto getPathForBase = [this](const QString& base) {
         auto minecraftPath = FS::PathCombine(m_stagingPath, "minecraft");
 
         if (base == "root") {
             return minecraftPath;
-        } else if (base == "config") {
-            return FS::PathCombine(minecraftPath, "config");
-        } else {
-            qWarning() << "Unrecognised base path" << base;
-            return minecraftPath;
         }
+        if (base == "config") {
+            return FS::PathCombine(minecraftPath, "config");
+        }
+        qWarning() << "Unrecognised base path" << base;
+        return minecraftPath;
     };
 
     auto convertToSystemPath = [](const QString& path) {
@@ -231,24 +246,22 @@ void PackInstallTask::deleteExistingFiles()
     };
 
     auto shouldKeep = [keeps, getPathForBase, convertToSystemPath](const QString& fullPath) {
-        for (const auto& item : keeps.files) {
+        if (std::ranges::any_of(keeps.files, [&fullPath, &getPathForBase, &convertToSystemPath](const auto& item) {
-            auto basePath = getPathForBase(item.base);
+                auto basePath = getPathForBase(item.base);
-            auto targetPath = convertToSystemPath(item.target);
+                auto targetPath = convertToSystemPath(item.target);
-            auto path = FS::PathCombine(basePath, targetPath);
+                auto path = FS::PathCombine(basePath, targetPath);
-
+                return fullPath == path;
-            if (fullPath == path) {
+            })) {
-                return true;
+            return true;
-            }
         }
 
-        for (const auto& item : keeps.folders) {
+        if (std::ranges::any_of(keeps.folders, [&fullPath, &getPathForBase, &convertToSystemPath](const auto& item) {
-            auto basePath = getPathForBase(item.base);
+                auto basePath = getPathForBase(item.base);
-            auto targetPath = convertToSystemPath(item.target);
+                auto targetPath = convertToSystemPath(item.target);
-            auto path = FS::PathCombine(basePath, targetPath);
+                auto path = FS::PathCombine(basePath, targetPath);
-
+                return fullPath.startsWith(path);
-            if (fullPath.startsWith(path)) {
+            })) {
-                return true;
+            return true;
-            }
         }
 
         return false;
@@ -262,8 +275,9 @@ void PackInstallTask::deleteExistingFiles()
         auto targetPath = convertToSystemPath(item.target);
         auto fullPath = FS::PathCombine(basePath, targetPath);
 
-        if (shouldKeep(fullPath))
+        if (shouldKeep(fullPath)) {
             continue;
+        }
 
         filesToDelete.insert(fullPath);
     }
@@ -277,8 +291,9 @@ void PackInstallTask::deleteExistingFiles()
         while (it.hasNext()) {
             auto path = it.next();
 
-            if (shouldKeep(path))
+            if (shouldKeep(path)) {
                 continue;
+            }
 
             filesToDelete.insert(path);
         }
@@ -290,7 +305,7 @@ void PackInstallTask::deleteExistingFiles()
     }
 }
 
-QString PackInstallTask::getDirForModType(ModType type, QString raw)
+QString PackInstallTask::getDirForModType(ModType type, const QString& raw)
 {
     switch (type) {
         // Mod types that can either be ignored at this stage, or ignored
@@ -338,7 +353,7 @@ QString PackInstallTask::getDirForModType(ModType type, QString raw)
     return Q_NULLPTR;
 }
 
-QString PackInstallTask::getVersionForLoader(QString uid)
+QString PackInstallTask::getVersionForLoader(const QString& uid)
 {
     if (m_version.loader.recommended || m_version.loader.latest || m_version.loader.choose) {
         auto vlist = APPLICATION->metadataIndex()->get(uid);
@@ -359,16 +374,19 @@ QString PackInstallTask::getVersionForLoader(QString uid)
                 // filtering for those loaders.
                 if (m_version.loader.type != "fabric") {
                     auto iter = std::find_if(reqs.begin(), reqs.end(), [](const Meta::Require& req) { return req.uid == "net.minecraft"; });
-                    if (iter == reqs.end())
+                    if (iter == reqs.end()) {
                         continue;
-                    if (iter->equalsVersion != m_version.minecraft)
+                    }
+                    if (iter->equalsVersion != m_version.minecraft) {
                         continue;
+                    }
                 }
 
                 if (m_version.loader.recommended) {
                     // first recommended build we find, we use.
-                    if (!version->isRecommended())
+                    if (!version->isRecommended()) {
                         continue;
+                    }
                 }
 
                 return version->descriptor();
@@ -376,7 +394,8 @@ QString PackInstallTask::getVersionForLoader(QString uid)
 
             emitFailed(tr("Failed to find version for %1 loader").arg(m_version.loader.type));
             return Q_NULLPTR;
-        } else if (m_version.loader.choose) {
+        }
+        if (m_version.loader.choose) {
             // Fabric Loader doesn't depend on a given Minecraft version.
             if (m_version.loader.type == "fabric") {
                 return m_support->chooseVersion(vlist, Q_NULLPTR);
@@ -420,7 +439,8 @@ QString PackInstallTask::detectLibrary(const VersionLibrary& library)
 
         if (name == QString("guava")) {
             return "com.google.guava:guava:" + version;
-        } else if (name == QString("commons-lang3")) {
+        }
+        if (name == QString("commons-lang3")) {
             return "org.apache.commons:commons-lang3:" + version;
         }
     }
@@ -428,7 +448,7 @@ QString PackInstallTask::detectLibrary(const VersionLibrary& library)
     return "org.multimc.atlauncher:" + library.md5 + ":1";
 }
 
-bool PackInstallTask::createLibrariesComponent(QString instanceRoot, PackProfile* profile)
+bool PackInstallTask::createLibrariesComponent(const QString& instanceRoot, PackProfile* profile)
 {
     if (m_version.libraries.isEmpty()) {
         return true;
@@ -453,18 +473,18 @@ bool PackInstallTask::createLibrariesComponent(QString instanceRoot, PackProfile
     }
 
     auto id = QUuid::createUuid().toString(QUuid::WithoutBraces);
-    auto target_id = "org.multimc.atlauncher." + id;
+    auto targetId = "org.multimc.atlauncher." + id;
 
     auto patchDir = FS::PathCombine(instanceRoot, "patches");
     if (!FS::ensureFolderPathExists(patchDir)) {
         return false;
     }
-    auto patchFileName = FS::PathCombine(patchDir, target_id + ".json");
+    auto patchFileName = FS::PathCombine(patchDir, targetId + ".json");
 
     auto f = std::make_shared<VersionFile>();
     f->name = m_pack_name + " " + m_version_name + " (libraries)";
 
-    const static QMap<QString, QString> liteLoaderMap = {
+    const static QMap<QString, QString> s_liteLoaderMap = {
         { "61179803bcd5fb7790789b790908663d", "1.12-SNAPSHOT" },   { "1420785ecbfed5aff4a586c5c9dd97eb", "1.12.2-SNAPSHOT" },
         { "073f68e2fcb518b91fd0d99462441714", "1.6.2_03" },        { "10a15b52fc59b1bfb9c05b56de1097d6", "1.6.2_02" },
         { "b52f90f08303edd3d4c374e268a5acf1", "1.6.2_04" },        { "ea747e24e03e24b7cad5bc8a246e0319", "1.6.2_01" },
@@ -484,8 +504,8 @@ bool PackInstallTask::createLibrariesComponent(QString instanceRoot, PackProfile
 
     for (const auto& lib : m_version.libraries) {
         // If the library is LiteLoader, we need to ignore it and handle it separately.
-        if (liteLoaderMap.contains(lib.md5)) {
+        if (s_liteLoaderMap.contains(lib.md5)) {
-            auto ver = getComponentVersion("com.mumfrey.liteloader", liteLoaderMap.value(lib.md5));
+            auto ver = getComponentVersion("com.mumfrey.liteloader", s_liteLoaderMap.value(lib.md5));
             if (ver) {
                 componentsToInstall.insert("com.mumfrey.liteloader", ver);
                 continue;
@@ -502,8 +522,9 @@ bool PackInstallTask::createLibrariesComponent(QString instanceRoot, PackProfile
                 libExempt = Version(libSpecifier.version()) >= Version(existingLib.version());
             }
         }
-        if (libExempt)
+        if (libExempt) {
             continue;
+        }
 
         auto library = std::make_shared<Library>();
         library->setRawName(libName);
@@ -536,11 +557,11 @@ bool PackInstallTask::createLibrariesComponent(QString instanceRoot, PackProfile
     file.write(OneSixVersionFormat::versionFileToJson(f).toJson());
     file.close();
 
-    profile->appendComponent(ComponentPtr{ new Component(profile, target_id, f) });
+    profile->appendComponent(ComponentPtr{ new Component(profile, targetId, f) });
     return true;
 }
 
-bool PackInstallTask::createPackComponent(QString instanceRoot, PackProfile* profile)
+bool PackInstallTask::createPackComponent(const QString& instanceRoot, PackProfile* profile)
 {
     if (m_version.mainClass.mainClass.isEmpty() && m_version.extraArguments.arguments.isEmpty()) {
         return true;
@@ -571,13 +592,13 @@ bool PackInstallTask::createPackComponent(QString instanceRoot, PackProfile* pro
     }
 
     auto id = QUuid::createUuid().toString(QUuid::WithoutBraces);
-    auto target_id = "org.multimc.atlauncher." + id;
+    auto targetId = "org.multimc.atlauncher." + id;
 
     auto patchDir = FS::PathCombine(instanceRoot, "patches");
     if (!FS::ensureFolderPathExists(patchDir)) {
         return false;
     }
-    auto patchFileName = FS::PathCombine(patchDir, target_id + ".json");
+    auto patchFileName = FS::PathCombine(patchDir, targetId + ".json");
 
     QStringList mainClasses;
     QStringList tweakers;
@@ -604,8 +625,9 @@ bool PackInstallTask::createPackComponent(QString instanceRoot, PackProfile* pro
     for (auto arg : args) {
         if (arg.startsWith("--tweakClass=") || previous == "--tweakClass") {
             auto tweakClass = arg.remove("--tweakClass=");
-            if (tweakers.contains(tweakClass))
+            if (tweakers.contains(tweakClass)) {
                 continue;
+            }
 
             f->addTweakers.append(tweakClass);
         }
@@ -618,13 +640,13 @@ bool PackInstallTask::createPackComponent(QString instanceRoot, PackProfile* pro
 
     QFile file(patchFileName);
     if (!file.open(QFile::WriteOnly)) {
-        qCritical() << "Error opening" << file.fileName() << "for reading:" << file.errorString();
+        qCritical() << "Error opening" << file.fileName() << "for writing:" << file.errorString();
         return false;
     }
     file.write(OneSixVersionFormat::versionFileToJson(f).toJson());
     file.close();
 
-    profile->appendComponent(ComponentPtr{ new Component(profile, target_id, f) });
+    profile->appendComponent(ComponentPtr{ new Component(profile, targetId, f) });
     return true;
 }
 
@@ -654,7 +676,7 @@ void PackInstallTask::installConfigs()
     connect(jobPtr.get(), &NetJob::failed, [this](QString reason) {
         abortable = false;
         jobPtr.reset();
-        emitFailed(reason);
+        emitFailed(std::move(reason));
     });
     connect(jobPtr.get(), &NetJob::progress, [this](qint64 current, qint64 total) {
         abortable = true;
@@ -711,15 +733,17 @@ void PackInstallTask::downloadMods()
     jarmods.clear();
     jobPtr.reset(new NetJob(tr("Mod download"), APPLICATION->network()));
 
-    QList<VersionMod> blocked_mods;
+    QList<VersionMod> blockedMods;
     for (const auto& mod : m_version.mods) {
         // skip non-client mods
-        if (!mod.client)
+        if (!mod.client) {
             continue;
+        }
 
         // skip optional mods that were not selected
-        if (mod.optional && !selectedMods.contains(mod.name))
+        if (mod.optional && !selectedMods.contains(mod.name)) {
             continue;
+        }
 
         QString url;
         switch (mod.download) {
@@ -727,7 +751,7 @@ void PackInstallTask::downloadMods()
                 url = BuildConfig.ATL_DOWNLOAD_SERVER_URL + mod.url;
                 break;
             case DownloadType::Browser: {
-                blocked_mods.append(mod);
+                blockedMods.append(mod);
                 continue;
             }
             case DownloadType::Direct:
@@ -763,8 +787,9 @@ void PackInstallTask::downloadMods()
             jobPtr->addNetAction(dl);
         } else {
             auto relpath = getDirForModType(mod.type, mod.type_raw);
-            if (relpath == Q_NULLPTR)
+            if (relpath == Q_NULLPTR) {
                 continue;
+            }
 
             auto entry = APPLICATION->metacache()->resolveEntry("ATLauncherPacks", cacheName);
             entry->setStale(true);
@@ -798,49 +823,51 @@ void PackInstallTask::downloadMods()
             modsToCopy[entry->getFullPath()] = path;
         }
     }
-    if (!blocked_mods.isEmpty()) {
+    if (!blockedMods.isEmpty()) {
         QList<BlockedMod> mods;
 
-        for (auto mod : blocked_mods) {
+        for (const auto& mod : blockedMods) {
-            BlockedMod blocked_mod;
+            BlockedMod blockedMod;
-            blocked_mod.name = mod.file;
+            blockedMod.name = mod.file;
-            blocked_mod.websiteUrl = mod.url;
+            blockedMod.websiteUrl = mod.url;
-            blocked_mod.hash = mod.md5;
+            blockedMod.hash = mod.md5;
-            blocked_mod.matched = false;
+            blockedMod.matched = false;
-            blocked_mod.localPath = "";
+            blockedMod.localPath = "";
 
-            mods.append(blocked_mod);
+            mods.append(blockedMod);
         }
 
         qWarning() << "Blocked mods found, displaying mod list";
 
-        BlockedModsDialog message_dialog(nullptr, tr("Blocked mods found"),
+        BlockedModsDialog messageDialog(nullptr, tr("Blocked mods found"),
-                                         tr("The following files are not available for download in third party launchers.<br/>"
+                                        tr("The following files are not available for download in third party launchers.<br/>"
-                                            "You will need to manually download them and add them to the instance."),
+                                           "You will need to manually download them and add them to the instance."),
-                                         mods, "md5");
+                                        mods, "md5");
 
-        message_dialog.setModal(true);
+        messageDialog.setModal(true);
 
-        if (message_dialog.exec()) {
+        if (messageDialog.exec() != 0) {
             qDebug() << "Post dialog blocked mods list:" << mods;
-            for (auto blocked : mods) {
+            for (const auto& blocked : mods) {
                 if (!blocked.matched) {
                     qDebug() << blocked.name << "was not matched to a local file, skipping copy";
                     continue;
                 }
-                auto modIter = std::find_if(blocked_mods.begin(), blocked_mods.end(),
+                auto modIter =
-                                            [blocked](const VersionMod& mod) { return mod.url == blocked.websiteUrl; });
+                    std::ranges::find_if(blockedMods, [blocked](const VersionMod& mod) { return mod.url == blocked.websiteUrl; });
-                if (modIter == blocked_mods.end())
+                if (modIter == blockedMods.end()) {
                     continue;
-                auto mod = *modIter;
+                }
+                const auto& mod = *modIter;
                 if (mod.type == ModType::Extract || mod.type == ModType::TexturePackExtract || mod.type == ModType::ResourcePackExtract) {
                     modsToExtract.insert(blocked.localPath, mod);
                 } else if (mod.type == ModType::Decomp) {
                     modsToDecomp.insert(blocked.localPath, mod);
                 } else {
                     auto relpath = getDirForModType(mod.type, mod.type_raw);
-                    if (relpath == Q_NULLPTR)
+                    if (relpath == Q_NULLPTR) {
                         continue;
+                    }
 
                     auto path = FS::PathCombine(m_stagingPath, "minecraft", relpath, mod.file);
 
@@ -918,8 +945,8 @@ bool PackInstallTask::extractMods(const QMap<QString, VersionMod>& toExtract,
 
     setStatus(tr("Extracting mods..."));
     for (auto iter = toExtract.begin(); iter != toExtract.end(); iter++) {
-        auto& modPath = iter.key();
+        const auto& modPath = iter.key();
-        auto& mod = iter.value();
+        const auto& mod = iter.value();
 
         QString extractToDir;
         if (mod.type == ModType::Extract) {
@@ -938,6 +965,10 @@ bool PackInstallTask::extractMods(const QMap<QString, VersionMod>& toExtract,
             folderToExtract = mod.extractFolder;
             static const QRegularExpression s_regex("^/");
             folderToExtract.remove(s_regex);
+            if (isPathTraversal(extractToPath, folderToExtract)) {
+                qWarning() << "Blocked path traversal in" << mod.extractFolder;
+                return false;
+            }
         }
 
         qDebug() << "Extracting " + mod.file + " to " + extractToDir;
@@ -948,13 +979,18 @@ bool PackInstallTask::extractMods(const QMap<QString, VersionMod>& toExtract,
     }
 
     for (auto iter = toDecomp.begin(); iter != toDecomp.end(); iter++) {
-        auto& modPath = iter.key();
+        const auto& modPath = iter.key();
-        auto& mod = iter.value();
+        const auto& mod = iter.value();
         auto extractToDir = getDirForModType(mod.decompType, mod.decompType_raw);
 
         QDir extractDir(m_stagingPath);
         auto extractToPath = FS::PathCombine(extractDir.absolutePath(), "minecraft", extractToDir, mod.decompFile);
 
+        if (isPathTraversal(extractToPath, mod.decompFile)) {
+            qWarning() << "Blocked path traversal in decompFile" << mod.decompFile;
+            return false;
+        }
+
         qDebug() << "Extracting " + mod.decompFile + " to " + extractToDir;
         if (!MMCZip::extractFile(modPath, mod.decompFile, extractToPath)) {
             qWarning() << "Failed to extract" << mod.decompFile;
@@ -963,8 +999,8 @@ bool PackInstallTask::extractMods(const QMap<QString, VersionMod>& toExtract,
     }
 
     for (auto iter = toCopy.begin(); iter != toCopy.end(); iter++) {
-        auto& from = iter.key();
+        const auto& from = iter.key();
-        auto& to = iter.value();
+        const auto& to = iter.value();
 
         // If the file already exists, assume the mod is the correct copy - and remove
         // the copy from the Configs.zip
@@ -994,7 +1030,7 @@ void PackInstallTask::install()
     MinecraftInstance instance(m_globalSettings, std::make_unique<INISettingsObject>(instanceConfigPath), m_stagingPath);
     {
         SettingsObject::Lock lock(instance.settings());
-        auto components = instance.getPackProfile();
+        auto* components = instance.getPackProfile();
         components->buildingFromScratch();
 
         // Use a component to add libraries BEFORE Minecraft
@@ -1009,20 +1045,23 @@ void PackInstallTask::install()
         // Loader
         if (m_version.loader.type == QString("forge")) {
             auto version = getVersionForLoader("net.minecraftforge");
-            if (version == Q_NULLPTR)
+            if (version == Q_NULLPTR) {
                 return;
+            }
 
             components->setComponentVersion("net.minecraftforge", version);
         } else if (m_version.loader.type == QString("neoforge")) {
             auto version = getVersionForLoader("net.neoforged");
-            if (version == Q_NULLPTR)
+            if (version == Q_NULLPTR) {
                 return;
+            }
 
             components->setComponentVersion("net.neoforged", version);
         } else if (m_version.loader.type == QString("fabric")) {
             auto version = getVersionForLoader("net.fabricmc.fabric-loader");
-            if (version == Q_NULLPTR)
+            if (version == Q_NULLPTR) {
                 return;
+            }
 
             components->setComponentVersion("net.fabricmc.fabric-loader", version);
         } else if (m_version.loader.type != QString()) {
@@ -1055,9 +1094,4 @@ void PackInstallTask::install()
     emitSucceeded();
 }
 
-static Meta::Version::Ptr getComponentVersion(const QString& uid, const QString& version)
-{
-    return APPLICATION->metadataIndex()->getLoadedVersion(uid, version);
-}
-
 }  // namespace ATLauncher

launcher/modplatform/atlauncher/ATLPackInstallTask.h

@@ -44,14 +44,13 @@
 #include "minecraft/MinecraftInstance.h"
 #include "minecraft/PackProfile.h"
 #include "net/NetJob.h"
-#include "settings/INISettingsObject.h"
 
-#include <memory>
+#include <cstdint>
 #include <optional>
 
 namespace ATLauncher {
 
-enum class InstallMode {
+enum class InstallMode : std::uint8_t {
     Install,
     Reinstall,
     Update,
@@ -86,13 +85,13 @@ class PackInstallTask : public InstanceTask {
                              QString packName,
                              QString version,
                              InstallMode installMode = InstallMode::Install);
-    virtual ~PackInstallTask() { delete m_support; }
+    ~PackInstallTask() override { delete m_support; }
 
     bool canAbort() const override { return true; }
     bool abort() override;
 
    protected:
-    virtual void executeTask() override;
+    void executeTask() override;
 
    private slots:
     void onDownloadSucceeded(QByteArray* responsePtr);
@@ -103,12 +102,12 @@ class PackInstallTask : public InstanceTask {
     void onModsExtracted();
 
    private:
-    QString getDirForModType(ModType type, QString raw);
+    QString getDirForModType(ModType type, const QString& raw);
-    QString getVersionForLoader(QString uid);
+    QString getVersionForLoader(const QString& uid);
-    QString detectLibrary(const VersionLibrary& library);
+    static QString detectLibrary(const VersionLibrary& library);
 
-    bool createLibrariesComponent(QString instanceRoot, PackProfile* profile);
+    bool createLibrariesComponent(const QString& instanceRoot, PackProfile* profile);
-    bool createPackComponent(QString instanceRoot, PackProfile* profile);
+    bool createPackComponent(const QString& instanceRoot, PackProfile* profile);
 
     void deleteExistingFiles();
     void installConfigs();

launcher/modplatform/flame/FlameAPI.h

@@ -79,6 +79,7 @@ class FlameAPI : public ResourceAPI {
             case ModPlatform::LegacyFabric:
             case ModPlatform::Ornithe:
             case ModPlatform::Rift:
+            case ModPlatform::None:
                 break;  // not supported
         }
         return 0;