MSAStep: Log server errors (#4895)

Signed-off-by: Octol1ttle <l1ttleofficial@outlook.com>

.clang-format

@@ -5,6 +5,7 @@ AllowShortIfStatementsOnASingleLine: false
 ColumnLimit: 140
 ---
 Language: Cpp
+AccessModifierOffset: -1
 AlignConsecutiveMacros: None
 AlignConsecutiveAssignments: None
 BraceWrapping:

.clang-tidy

@@ -1,4 +1,23 @@
 Checks:
   - modernize-use-using
+  - readability-avoid-const-params-in-decls
+  - misc-unused-parameters,
+  - readability-identifier-naming
 
-SystemHeaders: false
+# ^ Without unused-parameters the readability-identifier-naming check doesn't cause any warnings.
+
+CheckOptions:
+  - { key: readability-identifier-naming.ClassCase,                   value: PascalCase }
+  - { key: readability-identifier-naming.EnumCase,                    value: PascalCase }
+  - { key: readability-identifier-naming.FunctionCase,                value: camelCase }
+  - { key: readability-identifier-naming.GlobalVariableCase,          value: camelCase }
+  - { key: readability-identifier-naming.GlobalFunctionCase,          value: camelCase }
+  - { key: readability-identifier-naming.GlobalConstantCase,          value: SCREAMING_SNAKE_CASE }
+  - { key: readability-identifier-naming.MacroDefinitionCase,         value: SCREAMING_SNAKE_CASE }
+  - { key: readability-identifier-naming.ClassMemberCase,             value: camelCase }
+  - { key: readability-identifier-naming.PrivateMemberPrefix,         value: m_ }
+  - { key: readability-identifier-naming.ProtectedMemberPrefix,       value: m_ }
+  - { key: readability-identifier-naming.PrivateStaticMemberPrefix,   value: s_ }
+  - { key: readability-identifier-naming.ProtectedStaticMemberPrefix, value: s_ }
+  - { key: readability-identifier-naming.PublicStaticConstantCase,    value: SCREAMING_SNAKE_CASE }
+  - { key: readability-identifier-naming.EnumConstantCase,            value: PascalCase }

.editorconfig

@@ -1,8 +1,22 @@
-# EditorConfig specs and documentation: https://EditorConfig.org
-
-# top-most EditorConfig file
-root = true
-
-# C++ Code Style settings
-[*.{c++,cc,cpp,cppm,cxx,h,h++,hh,hpp,hxx,inl,ipp,ixx,tlh,tli}]
-cpp_generate_documentation_comments = doxygen_slash_star
+# EditorConfig specs and documentation: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{yml,nix}]
+indent_size = 2
+
+# C++ Code Style settings
+[*.{c++,cc,cpp,cppm,cxx,h,h++,hh,hpp,hxx,inl,ipp,ixx,tlh,tli}]
+cpp_generate_documentation_comments = doxygen_slash_star
+
+[CMakeLists.txt]
+ij_continuation_indent_size = 4

.envrc

@@ -1,2 +1,2 @@
-use flake
+use nix
 watch_file nix/*.nix

.git-blame-ignore-revs

@@ -2,3 +2,12 @@
 
 # tabs -> spaces
 bbb3b3e6f6e3c0f95873f22e6d0a4aaf350f49d9
+
+# (nix) alejandra -> nixfmt
+4c81d8c53d09196426568c4a31a4e752ed05397a
+
+# reformat codebase
+1d468ac35ad88d8c77cc83f25e3704d9bd7df01b
+
+# format a part of codebase
+5c8481a118c8fefbfe901001d7828eaf6866eac4

.github/ISSUE_TEMPLATE/rfc.yml

@@ -44,8 +44,8 @@ body:
   attributes:
     label: Unresolved Questions
     description: |
-      Are there any portions of your proposal which need to be discussed with the community before the RFC can proceed? 
-      Be careful here -- an RFC with a lot of remaining questions is likely to be stalled. 
+      Are there any portions of your proposal which need to be discussed with the community before the RFC can proceed?
+      Be careful here -- an RFC with a lot of remaining questions is likely to be stalled.
       If your RFC is mostly unresolved questions and not too much substance, it may not be ready.
     placeholder: Do a lot of users care about the cat?
   validations:

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

@@ -0,0 +1,139 @@
+name: Package for Linux
+description: Create Linux packages for Prism Launcher
+
+inputs:
+  version:
+    description: Launcher version
+    required: true
+  build-type:
+    description: Type for the build
+    required: true
+    default: Debug
+  artifact-name:
+    description: Name of the uploaded artifact
+    required: true
+    default: Linux
+  qt-version:
+    description: Version of Qt to use
+    required: true
+  gpg-private-key:
+    description: Private key for AppImage signing
+    required: false
+  gpg-private-key-id:
+    description: ID for the gpg-private-key, to select the signing key
+    required: false
+
+runs:
+  using: composite
+
+  steps:
+    - name: Setup build variables
+      shell: bash
+      run: |
+        # Fixup architecture naming for AppImages
+        dpkg_arch="$(dpkg-architecture -q DEB_HOST_ARCH_CPU)"
+        case "$dpkg_arch" in
+          "amd64")
+            APPIMAGE_ARCH="x86_64"
+            ;;
+          "arm64")
+            APPIMAGE_ARCH="aarch64"
+            ;;
+          *)
+            echo "# 🚨 The Debian architecture \"$deb_arch\" is not recognized!" >> "$GITHUB_STEP_SUMMARY"
+            exit 1
+            ;;
+        esac
+        echo "APPIMAGE_ARCH=$APPIMAGE_ARCH" >> "$GITHUB_ENV"
+
+        # Used for the file paths of libraries
+        echo "DEB_HOST_MULTIARCH=$(dpkg-architecture -q DEB_HOST_MULTIARCH)" >> "$GITHUB_ENV"
+
+    - name: Package AppImage
+      shell: bash
+      env:
+        VERSION: ${{ github.ref_type == 'tag' && github.ref_name || inputs.version }}
+        BUILD_DIR: build
+        INSTALL_APPIMAGE_DIR: install-appdir
+
+        GPG_PRIVATE_KEY: ${{ inputs.gpg-private-key }}
+      run: |
+        cmake --install ${{ env.BUILD_DIR }} --config ${{ inputs.build-type }} --prefix ${{ env.INSTALL_APPIMAGE_DIR }}
+
+        if [ '${{ inputs.gpg-private-key-id }}' != '' ]; then
+          echo "$GPG_PRIVATE_KEY" > privkey.asc
+          gpg --import privkey.asc
+          gpg --export --armor 9C7A2C9B62603299 > pubkey.asc
+        else
+          echo ":warning: Skipped code signing for Linux AppImage, as gpg key was not present." >> $GITHUB_STEP_SUMMARY
+        fi
+
+        sharun lib4bin \
+          --hard-links \
+          --with-hooks \
+          --dst-dir "$INSTALL_APPIMAGE_DIR" \
+          "$INSTALL_APPIMAGE_DIR"/bin/* "$QT_PLUGIN_PATH"/*/*.so
+
+        cp ~/bin/AppImageUpdate.AppImage "$INSTALL_APPIMAGE_DIR"/bin/
+        # FIXME(@getchoo): gamemode doesn't seem to be very portable with DBus. Find a way to make it work!
+        find "$INSTALL_APPIMAGE_DIR" -name '*gamemode*' -exec rm {} +
+
+        #makes the launcher use portals for file picking
+        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"
+        mv "$INSTALL_APPIMAGE_DIR"/{sharun,AppRun}
+        ls -la "$INSTALL_APPIMAGE_DIR"
+
+        if [[ "${{ github.ref_type }}" == "tag" ]]; then
+          APPIMAGE_DEST="PrismLauncher-Linux-$APPIMAGE_ARCH.AppImage"
+        else
+          APPIMAGE_DEST="PrismLauncher-Linux-$VERSION-${{ inputs.build-type }}-$APPIMAGE_ARCH.AppImage"
+        fi
+
+        mkappimage \
+          --updateinformation "gh-releases-zsync|${{ github.repository_owner }}|${{ github.event.repository.name }}|latest|PrismLauncher-Linux-$APPIMAGE_ARCH.AppImage.zsync" \
+          "$INSTALL_APPIMAGE_DIR" \
+          "$APPIMAGE_DEST"
+
+    - name: Package portable tarball
+      shell: bash
+      env:
+        BUILD_DIR: build
+
+        INSTALL_PORTABLE_DIR: install-portable
+      run: |
+        cmake --install ${{ env.BUILD_DIR }} --config ${{ inputs.build-type }} --prefix ${{ env.INSTALL_PORTABLE_DIR }}
+        cmake --install ${{ env.BUILD_DIR }} --config ${{ inputs.build-type }} --prefix ${{ env.INSTALL_PORTABLE_DIR }} --component portable
+
+        sharun lib4bin \
+          --with-hooks \
+          --hard-links \
+          --dst-dir "$INSTALL_PORTABLE_DIR" \
+          "$INSTALL_PORTABLE_DIR"/bin/* "$QT_PLUGIN_PATH"/*/*.so
+
+        # FIXME(@getchoo): gamemode doesn't seem to be very portable with DBus. Find a way to make it work!
+        find "$INSTALL_PORTABLE_DIR" -name '*gamemode*' -exec rm {} +
+
+        for l in $(find ${{ env.INSTALL_PORTABLE_DIR }} -type f -o -type l); do l=${l#$(pwd)/}; l=${l#${{ env.INSTALL_PORTABLE_DIR }}/}; l=${l#./}; echo $l; done > ${{ env.INSTALL_PORTABLE_DIR }}/manifest.txt
+        cd ${{ env.INSTALL_PORTABLE_DIR }}
+        tar -czf ../PrismLauncher-portable.tar.gz *
+
+    - name: Upload binary tarball
+      uses: actions/upload-artifact@v6
+      with:
+        name: PrismLauncher-${{ inputs.artifact-name }}-Qt6-Portable-${{ inputs.version }}-${{ inputs.build-type }}
+        path: PrismLauncher-portable.tar.gz
+
+    - name: Upload AppImage
+      uses: actions/upload-artifact@v6
+      with:
+        name: PrismLauncher-${{ runner.os }}-${{ inputs.version }}-${{ inputs.build-type }}-${{ env.APPIMAGE_ARCH }}.AppImage
+        path: PrismLauncher-${{ runner.os }}-*${{ env.APPIMAGE_ARCH }}.AppImage
+
+    - name: Upload AppImage Zsync
+      uses: actions/upload-artifact@v6
+      with:
+        name: PrismLauncher-${{ runner.os }}-${{ inputs.version }}-${{ inputs.build-type }}-${{ env.APPIMAGE_ARCH }}.AppImage.zsync
+        path: PrismLauncher-${{ runner.os }}-*${{ env.APPIMAGE_ARCH }}.AppImage.zsync

.github/actions/package/macos/action.yml

@@ -0,0 +1,121 @@
+name: Package for macOS
+description: Create a macOS package for Prism Launcher
+
+inputs:
+  version:
+    description: Launcher version
+    required: true
+  build-type:
+    description: Type for the build
+    required: true
+    default: Debug
+  artifact-name:
+    description: Name of the uploaded artifact
+    required: true
+    default: macOS
+  apple-codesign-cert:
+    description: Certificate for signing macOS builds
+    required: false
+  apple-codesign-password:
+    description: Password for signing macOS builds
+    required: false
+  apple-codesign-id:
+    description: Certificate ID for signing macOS builds
+    required: false
+  apple-notarize-apple-id:
+    description: Apple ID used for notarizing macOS builds
+    required: false
+  apple-notarize-team-id:
+    description: Team ID used for notarizing macOS builds
+    required: false
+  apple-notarize-password:
+    description: Password used for notarizing macOS builds
+    required: false
+  sparkle-ed25519-key:
+    description: Private key for signing Sparkle updates
+    required: false
+
+runs:
+  using: composite
+
+  steps:
+    - name: Fetch codesign certificate
+      shell: bash
+      run: |
+        echo '${{ inputs.apple-codesign-cert }}' | base64 --decode > codesign.p12
+        if [ -n '${{ inputs.apple-codesign-id }}' ]; then
+          security create-keychain -p '${{ inputs.apple-codesign-password }}' build.keychain
+          security default-keychain -s build.keychain
+          security unlock-keychain -p '${{ inputs.apple-codesign-password }}' build.keychain
+          security import codesign.p12 -k build.keychain -P '${{ inputs.apple-codesign-password }}' -T /usr/bin/codesign
+          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k '${{ inputs.apple-codesign-password }}' build.keychain
+        else
+          echo ":warning: Using ad-hoc code signing for macOS, as certificate was not present." >> $GITHUB_STEP_SUMMARY
+        fi
+
+    - name: Package
+      shell: bash
+      env:
+        BUILD_DIR: build
+        INSTALL_DIR: install
+      run: |
+        cmake --install ${{ env.BUILD_DIR }} --config ${{ inputs.build-type }}
+
+        cd ${{ env.INSTALL_DIR }}
+        chmod +x "PrismLauncher.app/Contents/MacOS/prismlauncher"
+
+        if [ -n '${{ inputs.apple-codesign-id }}' ]; then
+          APPLE_CODESIGN_ID='${{ inputs.apple-codesign-id }}'
+          ENTITLEMENTS_FILE='../program_info/App.entitlements'
+        else
+          APPLE_CODESIGN_ID='-'
+          ENTITLEMENTS_FILE='../program_info/AdhocSignedApp.entitlements'
+        fi
+
+        sudo codesign --sign "$APPLE_CODESIGN_ID" --deep --force --entitlements "$ENTITLEMENTS_FILE" --options runtime "PrismLauncher.app/Contents/MacOS/prismlauncher"
+        mv "PrismLauncher.app" "Prism Launcher.app"
+
+    - name: Notarize
+      shell: bash
+      env:
+        INSTALL_DIR: install
+      run: |
+        cd ${{ env.INSTALL_DIR }}
+
+        if [ -n '${{ inputs.apple-notarize-password }}' ]; then
+          ditto -c -k --sequesterRsrc --keepParent "Prism Launcher.app" ../PrismLauncher.zip
+          xcrun notarytool submit ../PrismLauncher.zip \
+            --wait --progress \
+            --apple-id '${{ inputs.apple-notarize-apple-id }}' \
+            --team-id '${{ inputs.apple-notarize-team-id }}' \
+            --password '${{ inputs.apple-notarize-password }}'
+
+          xcrun stapler staple "Prism Launcher.app"
+        else
+          echo ":warning: Skipping notarization as credentials are not present." >> $GITHUB_STEP_SUMMARY
+        fi
+        ditto -c -k --sequesterRsrc --keepParent "Prism Launcher.app" ../PrismLauncher.zip
+
+    - name: Make Sparkle signature
+      shell: bash
+      run: |
+        if [ '${{ inputs.sparkle-ed25519-key }}' != '' ]; then
+          echo '${{ inputs.sparkle-ed25519-key }}' > ed25519-priv.pem
+          signature=$(/opt/homebrew/opt/openssl@3/bin/openssl pkeyutl -sign -rawin -in ${{ github.workspace }}/PrismLauncher.zip -inkey ed25519-priv.pem | openssl base64 | tr -d \\n)
+          rm ed25519-priv.pem
+          cat >> $GITHUB_STEP_SUMMARY << EOF
+        ### Artifact Information :information_source:
+        - :memo: Sparkle Signature (ed25519): \`$signature\`
+        EOF
+        else
+          cat >> $GITHUB_STEP_SUMMARY << EOF
+        ### Artifact Information :information_source:
+        - :warning: Sparkle Signature (ed25519): No private key available (likely a pull request or fork)
+        EOF
+        fi
+
+    - name: Upload binary tarball
+      uses: actions/upload-artifact@v6
+      with:
+        name: PrismLauncher-${{ inputs.artifact-name }}-${{ inputs.version }}-${{ inputs.build-type }}
+        path: PrismLauncher.zip

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

@@ -0,0 +1,182 @@
+name: Package for Windows
+description: Create a Windows package for Prism Launcher
+
+inputs:
+  version:
+    description: Launcher version
+    required: true
+  build-type:
+    description: Type for the build
+    required: true
+    default: Debug
+  artifact-name:
+    description: Name of the uploaded artifact
+    required: true
+  msystem:
+    description: MSYS2 subsystem to use
+    required: false
+  azure-client-id:
+    description: Client ID for the Azure Signer Application
+    required: true
+  azure-tenant-id:
+    description: Tenant ID for the Azure Signer Application
+    required: true
+  azure-subscription-id:
+    description: Subscription ID for the Azure Signer Application
+    required: true
+
+runs:
+  using: composite
+
+  steps:
+    - name: Package (MinGW)
+      if: ${{ inputs.msystem != '' }}
+      shell: msys2 {0}
+      env:
+        BUILD_DIR: build
+        INSTALL_DIR: install
+      run: |
+        cmake --install ${{ env.BUILD_DIR }} --config ${{ inputs.build-type }}
+        touch ${{ env.INSTALL_DIR }}/manifest.txt
+        for l in $(find ${{ env.INSTALL_DIR }} -type f); do l=$(cygpath -u $l); l=${l#$(pwd)/}; l=${l#${{ env.INSTALL_DIR }}/}; l=${l#./}; echo $l; done >> ${{ env.INSTALL_DIR }}/manifest.txt
+
+    - name: Package (MSVC)
+      if: ${{ inputs.msystem == '' }}
+      shell: pwsh
+      env:
+        BUILD_DIR: build
+        INSTALL_DIR: install
+      run: |
+        cmake --install ${{ env.BUILD_DIR }} --config ${{ inputs.build-type }}
+
+        cd ${{ github.workspace }}
+
+        Get-ChildItem ${{ env.INSTALL_DIR }} -Recurse | ForEach FullName | Resolve-Path -Relative | %{ $_.TrimStart('.\') } | %{ $_.TrimStart('${{ env.INSTALL_DIR }}') } | %{ $_.TrimStart('\') } | Out-File -FilePath ${{ env.INSTALL_DIR }}/manifest.txt
+
+    - name: Emit warning for unsigned builds
+      if: ${{ env.CI_HAS_ACCESS_TO_AZURE == '' || inputs.azure-client-id == '' }}
+      shell: pwsh
+      run: |
+        ":warning: Skipped code signing for Windows, as certificate was not present." >> $env:GITHUB_STEP_SUMMARY
+
+    - name: Login to Azure
+      if: ${{ env.CI_HAS_ACCESS_TO_AZURE != '' && inputs.azure-client-id != '' }}
+      uses: azure/login@v2
+      with:
+        client-id: ${{ inputs.azure-client-id }}
+        tenant-id: ${{ inputs.azure-tenant-id }}
+        subscription-id: ${{ inputs.azure-subscription-id }}
+
+    - name: Sign executables
+      if: ${{ env.CI_HAS_ACCESS_TO_AZURE != '' && inputs.azure-client-id != '' }}
+      uses: azure/trusted-signing-action@v1
+      with:
+        endpoint: https://eus.codesigning.azure.net/
+        trusted-signing-account-name: PrismLauncher
+        certificate-profile-name: PrismLauncher
+
+        files: |
+          ${{ github.workspace }}\install\prismlauncher.exe
+          ${{ github.workspace }}\install\prismlauncher_filelink.exe
+          ${{ github.workspace }}\install\prismlauncher_updater.exe
+
+        # TODO(@getchoo): Is this all really needed???
+        # https://github.com/Azure/trusted-signing-action/blob/fc390cf8ed0f14e248a542af1d838388a47c7a7c/docs/OIDC.md
+        exclude-environment-credential: true
+        exclude-workload-identity-credential: true
+        exclude-managed-identity-credential: true
+        exclude-shared-token-cache-credential: true
+        exclude-visual-studio-credential: true
+        exclude-visual-studio-code-credential: true
+        exclude-azure-cli-credential: false
+        exclude-azure-powershell-credential: true
+        exclude-azure-developer-cli-credential: true
+        exclude-interactive-browser-credential: true
+
+    - name: Package (MinGW, portable)
+      if: ${{ inputs.msystem != '' }}
+      shell: msys2 {0}
+      env:
+        BUILD_DIR: build
+        INSTALL_DIR: install
+        INSTALL_PORTABLE_DIR: install-portable
+      run: |
+        cp -r ${{ env.INSTALL_DIR }} ${{ env.INSTALL_PORTABLE_DIR }}  # cmake install on Windows is slow, let's just copy instead
+        cmake --install ${{ env.BUILD_DIR }} --config ${{ inputs.build-type }} --prefix ${{ env.INSTALL_PORTABLE_DIR }} --component portable
+        for l in $(find ${{ env.INSTALL_PORTABLE_DIR }} -type f); do l=$(cygpath -u $l); l=${l#$(pwd)/}; l=${l#${{ env.INSTALL_PORTABLE_DIR }}/}; l=${l#./}; echo $l; done >> ${{ env.INSTALL_PORTABLE_DIR }}/manifest.txt
+
+    - name: Package (MSVC, portable)
+      if: ${{ inputs.msystem == '' }}
+      shell: pwsh
+      env:
+        BUILD_DIR: build
+        INSTALL_DIR: install
+        INSTALL_PORTABLE_DIR: install-portable
+      run: |
+        cp -r ${{ env.INSTALL_DIR }} ${{ env.INSTALL_PORTABLE_DIR }}  # cmake install on Windows is slow, let's just copy instead
+        cmake --install ${{ env.BUILD_DIR }} --config ${{ inputs.build-type }} --prefix ${{ env.INSTALL_PORTABLE_DIR }} --component portable
+
+        Get-ChildItem ${{ env.INSTALL_PORTABLE_DIR }} -Recurse | ForEach FullName | Resolve-Path -Relative | %{ $_.TrimStart('.\') } | %{ $_.TrimStart('${{ env.INSTALL_PORTABLE_DIR }}') } | %{ $_.TrimStart('\') } | Out-File -FilePath ${{ env.INSTALL_DIR }}/manifest.txt
+
+    - name: Package (installer)
+      shell: pwsh
+      env:
+        BUILD_DIR: build
+        INSTALL_DIR: install
+
+        NSCURL_VERSION: "v24.9.26.122"
+        NSCURL_SHA256: "AEE6C4BE3CB6455858E9C1EE4B3AFE0DB9960FA03FE99CCDEDC28390D57CCBB0"
+      run: |
+        New-Item -Name NSISPlugins -ItemType Directory
+        Invoke-Webrequest https://github.com/negrutiu/nsis-nscurl/releases/download/"${{ env.NSCURL_VERSION }}"/NScurl.zip -OutFile NSISPlugins\NScurl.zip
+        $nscurl_hash = Get-FileHash NSISPlugins\NScurl.zip -Algorithm Sha256 | Select-Object -ExpandProperty Hash
+        if ( $nscurl_hash -ne "${{ env.nscurl_sha256 }}") {
+          echo "::error:: NSCurl.zip sha256 mismatch"
+          exit 1
+        }
+        Expand-Archive -Path NSISPlugins\NScurl.zip -DestinationPath NSISPlugins\NScurl
+
+        cd ${{ env.INSTALL_DIR }}
+        makensis -NOCD "${{ github.workspace }}/${{ env.BUILD_DIR }}/program_info/win_install.nsi"
+
+    - name: Sign installer
+      if: ${{ env.CI_HAS_ACCESS_TO_AZURE != '' && inputs.azure-client-id != '' }}
+      uses: azure/trusted-signing-action@v1
+      with:
+        endpoint: https://eus.codesigning.azure.net/
+        trusted-signing-account-name: PrismLauncher
+        certificate-profile-name: PrismLauncher
+
+        files: |
+          ${{ github.workspace }}\PrismLauncher-Setup.exe
+
+        # TODO(@getchoo): Is this all really needed???
+        # https://github.com/Azure/trusted-signing-action/blob/fc390cf8ed0f14e248a542af1d838388a47c7a7c/docs/OIDC.md
+        exclude-environment-credential: true
+        exclude-workload-identity-credential: true
+        exclude-managed-identity-credential: true
+        exclude-shared-token-cache-credential: true
+        exclude-visual-studio-credential: true
+        exclude-visual-studio-code-credential: true
+        exclude-azure-cli-credential: false
+        exclude-azure-powershell-credential: true
+        exclude-azure-developer-cli-credential: true
+        exclude-interactive-browser-credential: true
+
+    - name: Upload binary zip
+      uses: actions/upload-artifact@v6
+      with:
+        name: PrismLauncher-${{ inputs.artifact-name }}-${{ inputs.version }}-${{ inputs.build-type }}
+        path: install/**
+
+    - name: Upload portable zip
+      uses: actions/upload-artifact@v6
+      with:
+        name: PrismLauncher-${{ inputs.artifact-name }}-Portable-${{ inputs.version }}-${{ inputs.build-type }}
+        path: install-portable/**
+
+    - name: Upload installer
+      uses: actions/upload-artifact@v6
+      with:
+        name: PrismLauncher-${{ inputs.artifact-name }}-Setup-${{ inputs.version }}-${{ inputs.build-type }}
+        path: PrismLauncher-Setup.exe

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

@@ -0,0 +1,81 @@
+name: Setup Dependencies
+description: Install and setup dependencies for building Prism Launcher
+
+inputs:
+  build-type:
+    description: Type for the build
+    required: true
+    default: Debug
+  artifact-name:
+    description: Name of the uploaded artifact
+    required: true
+  msystem:
+    description: MSYS2 subsystem to use
+    required: false
+  vcvars-arch:
+    description: Visual Studio architecture to use
+    required: false
+  qt-architecture:
+    description: Qt architecture
+    required: false
+  qt-version:
+    description: Version of Qt to use
+    required: true
+
+outputs:
+  build-type:
+    description: Type of build used
+    value: ${{ inputs.build-type }}
+  qt-version:
+    description: Version of Qt used
+    value: ${{ inputs.qt-version }}
+
+runs:
+  using: composite
+
+  steps:
+    - name: Setup Linux dependencies
+      if: ${{ runner.os == 'Linux' }}
+      uses: ./.github/actions/setup-dependencies/linux
+
+    - name: Setup macOS dependencies
+      if: ${{ runner.os == 'macOS' }}
+      uses: ./.github/actions/setup-dependencies/macos
+      with:
+        build-type: ${{ inputs.build-type }}
+
+    - name: Setup Windows dependencies
+      if: ${{ runner.os == 'Windows' }}
+      uses: ./.github/actions/setup-dependencies/windows
+      with:
+        build-type: ${{ inputs.build-type }}
+        msystem: ${{ inputs.msystem }}
+        vcvars-arch: ${{ inputs.vcvars-arch }}
+
+    # 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.20
+      with:
+        variant: sccache
+        create-symlink: ${{ runner.os != 'Windows' }}
+        key: ${{ runner.os }}-${{ runner.arch }}-${{ inputs.artifact-name }}-sccache
+
+    - name: Use ccache on debug builds
+      if: ${{ inputs.build-type == 'Debug' }}
+      shell: bash
+      env:
+        # Only use ccache on MSYS2
+        CCACHE_VARIANT: ${{ (runner.os == 'Windows' && inputs.msystem != '') && 'ccache' || 'sccache' }}
+      run: |
+        echo "CMAKE_C_COMPILER_LAUNCHER=$CCACHE_VARIANT" >> "$GITHUB_ENV"
+        echo "CMAKE_CXX_COMPILER_LAUNCHER=$CCACHE_VARIANT" >> "$GITHUB_ENV"
+
+    - name: Install Qt
+      if: ${{ inputs.msystem == '' }}
+      uses: jurplel/install-qt-action@v4
+      with:
+        aqtversion: "==3.1.*"
+        version: ${{ inputs.qt-version }}
+        modules: qtimageformats qtnetworkauth
+        cache: ${{ inputs.build-type == 'Debug' }}

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

@@ -0,0 +1,53 @@
+name: Setup Linux dependencies
+
+runs:
+  using: composite
+
+  steps:
+    - name: Install host dependencies
+      shell: bash
+      run: |
+        sudo apt-get -y update
+        sudo apt-get -y install \
+          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
+
+    - name: Setup AppImage tooling
+      shell: bash
+      env:
+        GH_TOKEN: ${{ github.token }}
+      run: |
+        # Determinate AppImage architecture to use
+        dpkg_arch="$(dpkg-architecture -q DEB_HOST_ARCH_CPU)"
+        case "$dpkg_arch" in
+          "amd64")
+            APPIMAGE_ARCH="x86_64"
+            ;;
+          "arm64")
+            APPIMAGE_ARCH="aarch64"
+            ;;
+          *)
+            echo "# 🚨 The Debian architecture \"$deb_arch\" is not recognized!" >> "$GITHUB_STEP_SUMMARY"
+            exit 1
+            ;;
+        esac
+
+        gh release download \
+          --repo VHSgunzo/sharun \
+          --pattern "sharun-$APPIMAGE_ARCH-aio" \
+          --output ~/bin/sharun
+
+        # FIXME!: revert this to probonopd/go-appimage once https://github.com/probonopd/go-appimage/pull/377 is merged!
+        gh release download continuous \
+          --repo DioEgizio/go-appimage \
+          --pattern "mkappimage-*-$APPIMAGE_ARCH.AppImage" \
+          --output ~/bin/mkappimage
+
+        gh release download \
+          --repo AppImageCommunity/AppImageUpdate \
+          --pattern "AppImageUpdate-$APPIMAGE_ARCH.AppImage" \
+          --output ~/bin/AppImageUpdate.AppImage
+        chmod +x ~/bin/*
+        echo "$HOME/bin" >> "$GITHUB_PATH"

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

@@ -0,0 +1,47 @@
+name: Setup macOS dependencies
+
+inputs:
+  build-type:
+    description: Type for the build
+    required: true
+    default: Debug
+
+runs:
+  using: composite
+
+  steps:
+    - name: Install dependencies
+      shell: bash
+      run: |
+        brew update
+        brew install ninja extra-cmake-modules temurin@17 mono
+
+    - name: Set JAVA_HOME
+      shell: bash
+      run: |
+        echo "JAVA_HOME=$(/usr/libexec/java_home -v 17)" >> "$GITHUB_ENV"
+
+    - name: Setup vcpkg cache
+      if: ${{ inputs.build-type == 'Debug' }}
+      shell: bash
+      env:
+        USERNAME: ${{ github.repository_owner }}
+        GITHUB_TOKEN: ${{ github.token }}
+        FEED_URL: https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json
+      run: |
+        mono `vcpkg fetch nuget | tail -n 1` \
+          sources add \
+          -Source "$FEED_URL" \
+          -StorePasswordInClearText \
+          -Name GitHubPackages \
+          -UserName "$USERNAME" \
+          -Password "$GITHUB_TOKEN"
+        mono `vcpkg fetch nuget | tail -n 1` \
+          setapikey "$GITHUB_TOKEN" \
+          -Source "$FEED_URL"
+        echo "VCPKG_BINARY_SOURCES=clear;nuget,$FEED_URL,readwrite" >> "$GITHUB_ENV"
+
+    - name: Setup vcpkg environment
+      shell: bash
+      run: |
+        echo "VCPKG_ROOT=$VCPKG_INSTALLATION_ROOT" >> "$GITHUB_ENV"

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

@@ -0,0 +1,107 @@
+name: Setup Windows Dependencies
+
+inputs:
+  build-type:
+    description: Type for the build
+    required: true
+    default: Debug
+  msystem:
+    description: MSYS2 subsystem to use
+    required: false
+  vcvars-arch:
+    description: Visual Studio architecture to use
+    required: true
+    default: amd64
+
+runs:
+  using: composite
+
+  steps:
+    # NOTE: Installed on MinGW as well for SignTool
+    - name: Enter VS Developer shell
+      if: ${{ runner.os == 'Windows' }}
+      uses: ilammy/msvc-dev-cmd@v1
+      with:
+        arch: ${{ inputs.vcvars-arch }}
+        vsversion: 2022
+
+    - name: Setup Java (MSVC)
+      uses: actions/setup-java@v5
+      with:
+        # NOTE(@getchoo): We should probably stay on Zulu.
+        # Temurin doesn't have Java 17 builds for WoA
+        distribution: zulu
+        java-version: 17
+
+    - name: Setup vcpkg cache (MSVC)
+      if: ${{ inputs.msystem == '' && inputs.build-type == 'Debug' }}
+      shell: pwsh
+      env:
+        USERNAME: ${{ github.repository_owner }}
+        GITHUB_TOKEN: ${{ github.token }}
+        FEED_URL: https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json
+      run: |
+        .$(vcpkg fetch nuget) `
+          sources add `
+          -Source "$env:FEED_URL" `
+          -StorePasswordInClearText `
+          -Name GitHubPackages `
+          -UserName "$env:USERNAME" `
+          -Password "$env:GITHUB_TOKEN"
+        .$(vcpkg fetch nuget) `
+          setapikey "$env:GITHUB_TOKEN" `
+          -Source "$env:FEED_URL"
+        "VCPKG_BINARY_SOURCES=clear;nuget,$env:FEED_URL,readwrite" | Out-File -Append $env:GITHUB_ENV
+
+    - name: Setup vcpkg environment (MSVC)
+      if: ${{ inputs.msystem == '' }}
+      shell: bash
+      run: |
+        echo "VCPKG_ROOT=$VCPKG_INSTALLATION_ROOT" >> "$GITHUB_ENV"
+
+    - name: Setup MSYS2 (MinGW)
+      if: ${{ inputs.msystem != '' }}
+      uses: msys2/setup-msys2@v2
+      with:
+        msystem: ${{ inputs.msystem }}
+        update: true
+        install: >-
+          git
+        pacboy: >-
+          toolchain:p
+          ccache:p
+          cmake:p
+          extra-cmake-modules:p
+          ninja:p
+          qt6-base:p
+          qt6-svg:p
+          qt6-imageformats:p
+          qt6-networkauth:p
+          cmark:p
+          qrencode:p
+          tomlplusplus:p
+          libarchive:p
+
+    - name: List pacman packages (MinGW)
+      if: ${{ inputs.msystem != '' }}
+      shell: msys2 {0}
+      run: |
+        pacman -Qe
+
+    - name: Retrieve ccache cache (MinGW)
+      if: ${{ inputs.msystem != '' && inputs.build-type == 'Debug' }}
+      uses: actions/cache@v5.0.2
+      with:
+        path: '${{ github.workspace }}\.ccache'
+        key: ${{ runner.os }}-mingw-w64-ccache-${{ github.run_id }}
+        restore-keys: |
+          ${{ runner.os }}-mingw-w64-ccache
+
+    - name: Setup ccache (MinGW)
+      if: ${{ inputs.msystem != '' && inputs.build-type == 'Debug' }}
+      shell: msys2 {0}
+      run: |
+        ccache --set-config=cache_dir='${{ github.workspace }}\.ccache'
+        ccache --set-config=max_size='500M'
+        ccache --set-config=compression=true
+        ccache -p  # Show config

.github/scripts/prepare_JREs.sh

@@ -1,41 +0,0 @@
-#!/usr/bin/env bash
-
-URL_JDK8="https://api.adoptium.net/v3/binary/version/jdk8u312-b07/linux/x64/jre/hotspot/normal/eclipse"
-URL_JDK17="https://api.adoptium.net/v3/binary/latest/17/ga/linux/x64/jre/hotspot/normal/eclipse"
-
-mkdir -p JREs
-pushd JREs
-
-wget --content-disposition "$URL_JDK8"
-wget --content-disposition "$URL_JDK17"
-
-for file in *;
-do
-    mkdir temp
-
-    re='(OpenJDK([[:digit:]]+)U-jre_x64_linux_hotspot_([[:digit:]]+)(.*).tar.gz)'
-    if [[ $file =~ $re ]];
-    then
-        version_major=${BASH_REMATCH[2]}
-        version_trailing=${BASH_REMATCH[4]}
-
-        if [ $version_major = 17 ];
-        then
-            hyphen='-'
-        else
-            hyphen=''
-        fi
-
-        version_edit=$(echo $version_trailing | sed -e 's/_/+/g' | sed -e 's/b/-b/g')
-        dir_name=jdk$hyphen$version_major$version_edit-jre
-        mkdir jre$version_major
-        tar -xzf $file -C temp
-        pushd temp/$dir_name
-        cp -r . ../../jre$version_major
-        popd
-    fi
-
-    rm -rf temp
-done
-
-popd

.github/workflows/backport.yml

@@ -16,15 +16,16 @@ jobs:
     permissions:
       contents: write # for korthout/backport-action to create branch
       pull-requests: write # for korthout/backport-action to create PR to backport
+      actions: write # for korthout/backport-action to create PR with workflow changes
     name: Backport Pull Request
     if: github.repository_owner == 'PrismLauncher' && github.event.pull_request.merged == true && (github.event_name != 'labeled' || startsWith('backport', github.event.label.name))
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ github.event.pull_request.head.sha }}
       - name: Create backport PRs
-        uses: korthout/backport-action@v2.1.0
+        uses: korthout/backport-action@v4.0.1
         with:
           # Config README: https://github.com/korthout/backport-action#backport-action
           pull_description: |-

.github/workflows/blocked-prs.yml

@@ -0,0 +1,255 @@
+name: Blocked/Stacked Pull Requests Automation
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - reopened
+      - edited
+      - synchronize
+  workflow_dispatch:
+    inputs:
+      pr_id:
+        description: Local Pull Request number to work on
+        required: true
+        type: number
+
+jobs:
+  blocked_status:
+    name: Check Blocked Status
+    runs-on: ubuntu-slim
+
+    steps:
+      - name: Generate token
+        id: generate-token
+        uses: actions/create-github-app-token@v2
+        with:
+          app-id: ${{ vars.PULL_REQUEST_APP_ID }}
+          private-key: ${{ secrets.PULL_REQUEST_APP_PRIVATE_KEY }}
+
+      - name: Setup From Dispatch Event
+        if: github.event_name == 'workflow_dispatch'
+        id: dispatch_event_setup
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+          PR_NUMBER: ${{ inputs.pr_id }}
+        run: |
+          # setup env for the rest of the workflow
+          OWNER=$(dirname "${{ github.repository }}")
+          REPO=$(basename "${{ github.repository }}")
+          PR_JSON=$(
+            gh api \
+              -H "Accept: application/vnd.github.raw+json" \
+              -H "X-GitHub-Api-Version: 2022-11-28" \
+              "/repos/$OWNER/$REPO/pulls/$PR_NUMBER"
+          )
+          echo "PR_JSON=$PR_JSON" >> "$GITHUB_ENV"
+
+      - name: Setup Environment
+        id: env_setup
+        env:
+          EVENT_PR_JSON: ${{ toJSON(github.event.pull_request) }}
+        run: |
+          # setup env for the rest of the workflow
+          PR_JSON=${PR_JSON:-"$EVENT_PR_JSON"}
+          {
+            echo "REPO=$(jq -r '.base.repo.name' <<< "$PR_JSON")"
+            echo "OWNER=$(jq -r '.base.repo.owner.login' <<< "$PR_JSON")"
+            echo "PR_NUMBER=$(jq -r '.number' <<< "$PR_JSON")"
+            echo "JOB_DATA=$(jq -c '
+              {
+                "repo": .base.repo.name,
+                "owner": .base.repo.owner.login,
+                "repoUrl": .base.repo.html_url,
+                "prNumber": .number,
+                "prHeadSha": .head.sha,
+                "prHeadLabel": .head.label,
+                "prBody": (.body // ""),
+                "prLabels": (reduce .labels[].name as $l ([]; . + [$l]))
+              }
+            ' <<< "$PR_JSON")"
+          } >> "$GITHUB_ENV"
+
+
+      - name: Find Blocked/Stacked PRs in body
+        id: pr_ids
+        run: |
+          prs=$(
+            jq -c '
+              .prBody as $body
+                | (
+                    $body |
+                      reduce (
+                        . | scan("[Bb]locked (?:[Bb]y|[Oo]n):? #([0-9]+)")
+                        | map({
+                          "type": "Blocked on",
+                          "number": ( . | tonumber )
+                        })
+                      ) as $i ([]; . + [$i[]])
+                  ) as $bprs
+                | (
+                    $body |
+                      reduce (
+                        . | scan("[Ss]tacked [Oo]n:? #([0-9]+)")
+                        | map({
+                          "type": "Stacked on",
+                          "number": ( . | tonumber )
+                        })
+                      ) as $i ([]; . + [$i[]])
+                  ) as $sprs
+                | ($bprs + $sprs) as $prs
+                | {
+                    "blocking": $prs,
+                    "numBlocking": ( $prs | length),
+                  }
+              ' <<< "$JOB_DATA"
+          )
+          echo "prs=$prs" >> "$GITHUB_OUTPUT"
+
+      - name: Collect Blocked PR Data
+        id: blocking_data
+        if: fromJSON(steps.pr_ids.outputs.prs).numBlocking > 0
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+          BLOCKING_PRS: ${{ steps.pr_ids.outputs.prs }}
+        run: |
+          blocked_pr_data=$(
+            while read -r pr_data ; do
+              gh api \
+                -H "Accept: application/vnd.github+json" \
+                -H "X-GitHub-Api-Version: 2022-11-28" \
+                "/repos/$OWNER/$REPO/pulls/$(jq -r '.number' <<< "$pr_data")" \
+                | jq -c --arg type "$(jq -r '.type' <<< "$pr_data")" \
+                  '
+                    . | {
+                      "type": $type,
+                      "number": .number,
+                      "merged": .merged,
+                      "state": (if .state == "open" then "Open" elif .merged then "Merged" else "Closed" end),
+                      "labels": (reduce .labels[].name as $l ([]; . + [$l])),
+                      "basePrUrl": .html_url,
+                      "baseRepoName": .head.repo.name,
+                      "baseRepoOwner": .head.repo.owner.login,
+                      "baseRepoUrl": .head.repo.html_url,
+                      "baseSha": .head.sha,
+                      "baseRefName": .head.ref,
+                    }
+                  '
+            done < <(jq -c '.blocking[]' <<< "$BLOCKING_PRS") | jq -c -s
+          )
+          {
+            echo "data=$blocked_pr_data";
+            echo "all_merged=$(jq -r 'all(.[] | (.type == "Stacked on" and .merged) or (.type == "Blocked on" and (.state != "Open")); .)' <<< "$blocked_pr_data")";
+            echo "current_blocking=$(jq -c 'map(
+                select(
+                  (.type == "Stacked on" and (.merged | not)) or
+                  (.type == "Blocked on" and (.state == "Open"))
+                ) | .number
+              )' <<< "$blocked_pr_data" )";
+          } >> "$GITHUB_OUTPUT"
+
+      - name: Add 'blocked' Label if Missing
+        id: label_blocked
+        if: (fromJSON(steps.pr_ids.outputs.prs).numBlocking > 0) && !contains(fromJSON(env.JOB_DATA).prLabels, 'blocked') && !fromJSON(steps.blocking_data.outputs.all_merged)
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+        run: |
+          gh -R ${{ github.repository }} issue edit --add-label 'blocked' "$PR_NUMBER"
+
+      - name: Remove 'blocked' Label if All Dependencies Are Merged
+        id: unlabel_blocked
+        if: fromJSON(steps.pr_ids.outputs.prs).numBlocking > 0 && fromJSON(steps.blocking_data.outputs.all_merged)
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+        run: |
+          gh -R ${{ github.repository }} issue edit --remove-label 'blocked' "$PR_NUMBER"
+
+      - name: Apply 'blocking' Label to Unmerged Dependencies
+        id: label_blocking
+        if: fromJSON(steps.pr_ids.outputs.prs).numBlocking > 0
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+          BLOCKING_ISSUES: ${{ steps.blocking_data.outputs.current_blocking }}
+        run: |
+          while read -r pr ; do
+            gh -R ${{ github.repository }} issue edit --add-label 'blocking' "$pr" || true
+          done < <(jq -c '.[]' <<< "$BLOCKING_ISSUES")
+
+      - name: Apply Blocking PR Status Check
+        id: blocked_check
+        if: fromJSON(steps.pr_ids.outputs.prs).numBlocking > 0
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+          BLOCKING_DATA: ${{ steps.blocking_data.outputs.data }}
+        run: |
+          pr_head_sha=$(jq -r '.prHeadSha' <<< "$JOB_DATA")
+          # create commit Status, overwrites previous identical context
+          while read -r pr_data ; do
+            DESC=$(
+              jq -r 'if .type == "Stacked on" then
+                  "Stacked PR #" + (.number | tostring) + " is " + (if .merged then "" else "not yet " end) + "merged"
+                else
+                  "Blocking PR #" + (.number | tostring) + " is " + (if .state == "Open" then "" else "not yet " end) + "merged or closed"
+                end ' <<< "$pr_data"
+            )
+            gh api \
+              --method POST \
+              -H "Accept: application/vnd.github+json" \
+              -H "X-GitHub-Api-Version: 2022-11-28" \
+              "/repos/${OWNER}/${REPO}/statuses/${pr_head_sha}" \
+              -f "state=$(jq -r 'if (.type == "Stacked on" and .merged) or (.type == "Blocked on" and (.state != "Open")) then "success" else "failure" end' <<< "$pr_data")" \
+              -f "target_url=$(jq -r '.basePrUrl' <<< "$pr_data" )" \
+              -f "description=$DESC" \
+              -f "context=ci/blocking-pr-check:$(jq '.number' <<< "$pr_data")"
+          done < <(jq -c '.[]' <<< "$BLOCKING_DATA")
+
+      - name: Context Comment
+        id: generate-comment
+        if: fromJSON(steps.pr_ids.outputs.prs).numBlocking > 0
+        continue-on-error: true
+        env:
+          BLOCKING_DATA: ${{ steps.blocking_data.outputs.data }}
+        run: |
+          COMMENT_PATH="$(pwd)/temp_comment_file.txt"
+          echo '<h3>PR Dependencies :pushpin:</h3>' > "$COMMENT_PATH"
+          echo >> "$COMMENT_PATH"
+          pr_head_label=$(jq -r '.prHeadLabel' <<< "$JOB_DATA")
+          while read -r pr_data ; do
+            base_pr=$(jq -r '.number' <<< "$pr_data")
+            base_ref_name=$(jq -r '.baseRefName' <<< "$pr_data")
+            base_repo_owner=$(jq -r '.baseRepoOwner' <<< "$pr_data")
+            base_repo_name=$(jq -r '.baseRepoName' <<< "$pr_data")
+            compare_url="https://github.com/$base_repo_owner/$base_repo_name/compare/$base_ref_name...$pr_head_label"
+            status=$(jq -r '
+                if .type == "Stacked on" then
+                  if .merged then ":heavy_check_mark: Merged" else ":x: Not Merged (" + .state + ")" end
+                else
+                  if .state != "Open" then ":white_check_mark: " + .state else ":x: Open" end
+                end
+              ' <<< "$pr_data")
+            type=$(jq -r '.type' <<< "$pr_data")
+            echo "  - $type #$base_pr $status [(compare)]($compare_url)" >> "$COMMENT_PATH"
+          done < <(jq -c '.[]'  <<< "$BLOCKING_DATA")
+
+          {
+            echo 'body<<EOF';
+            cat "${COMMENT_PATH}";
+            echo 'EOF';
+          } >> "$GITHUB_OUTPUT"
+
+      - name: 💬 PR Comment
+        if: fromJSON(steps.pr_ids.outputs.prs).numBlocking > 0
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+          COMMENT_BODY: ${{ steps.generate-comment.outputs.body }}
+        run: |
+          gh -R ${{ github.repository }} issue comment "$PR_NUMBER" \
+            --body "$COMMENT_BODY" \
+            --create-if-none \
+            --edit-last
+

.github/workflows/build.yml

@@ -1,610 +1,233 @@
 name: Build
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 on:
+  push:
+    branches:
+      - "develop"
+      - "release-*"
+    paths:
+      # File types
+      - "**.cpp"
+      - "**.h"
+      - "**.java"
+      - "**.ui"
+
+      # Directories
+      - "buildconfig/**"
+      - "cmake/**"
+      - "launcher/**"
+      - "libraries/**"
+      - "program_info/**"
+      - "tests/**"
+
+      # Files
+      - "CMakeLists.txt"
+      - "COPYING.md"
+
+      # Workflows
+      - ".github/workflows/build.yml"
+      - ".github/actions/package/**"
+      - ".github/actions/setup-dependencies/**"
+  pull_request:
+    paths:
+      # File types
+      - "**.cpp"
+      - "**.h"
+      - "**.java"
+      - "**.ui"
+
+      # Directories
+      - "buildconfig/**"
+      - "cmake/**"
+      - "launcher/**"
+      - "libraries/**"
+      - "program_info/**"
+      - "tests/**"
+
+      # Files
+      - "CMakeLists.txt"
+      - "COPYING.md"
+
+      # Workflows
+      - ".github/workflows/build.yml"
+      - ".github/actions/package/**"
+      - ".github/actions/setup-dependencies/**"
   workflow_call:
     inputs:
-      build_type:
-        description: Type of build (Debug, Release, RelWithDebInfo, MinSizeRel)
+      build-type:
+        description: Type of build (Debug or Release)
         type: string
         default: Debug
-      is_qt_cached:
-        description: Enable Qt caching or not
+      environment:
+        description: Deployment environment to run under
         type: string
-        default: true
-    secrets:
-      SPARKLE_ED25519_KEY:
-        description: Private key for signing Sparkle updates
-        required: false
-      WINDOWS_CODESIGN_CERT:
-        description: Certificate for signing Windows builds
-        required: false
-      WINDOWS_CODESIGN_PASSWORD:
-        description: Password for signing Windows builds
-        required: false
-      CACHIX_AUTH_TOKEN:
-        description: Private token for authenticating against Cachix cache
-        required: false
-      GPG_PRIVATE_KEY:
-        description: Private key for AppImage signing
-        required: false
-      GPG_PRIVATE_KEY_ID:
-        description: ID for the GPG_PRIVATE_KEY, to select the signing key
-        required: false
+  workflow_dispatch:
+    inputs:
+      build-type:
+        description: Type of build (Debug or Release)
+        type: string
+        default: Debug
 
 jobs:
   build:
+    name: Build (${{ matrix.artifact-name }})
+
+    environment: ${{ inputs.environment || '' }}
+
+    permissions:
+      # Required for Azure Trusted Signing
+      id-token: write
+      # Required for vcpkg binary cache
+      packages: write
+
     strategy:
       fail-fast: false
       matrix:
         include:
-          - os: ubuntu-20.04
-            qt_ver: 5
+          - os: ubuntu-24.04
+            artifact-name: Linux
+            cmake-preset: linux
+            qt-version: 6.10.1
 
-          - os: ubuntu-20.04
-            qt_ver: 6
-            qt_host: linux
-            qt_arch: ""
-            qt_version: "6.2.4"
-            qt_modules: "qt5compat qtimageformats"
-            qt_tools: ""
+          - os: ubuntu-24.04-arm
+            artifact-name: Linux-aarch64
+            cmake-preset: linux
+            qt-version: 6.10.1
 
           - os: windows-2022
-            name: "Windows-MinGW-w64"
-            msystem: clang64
-            vcvars_arch: "amd64_x86"
+            artifact-name: Windows-MinGW-w64
+            cmake-preset: windows_mingw
+            msystem: CLANG64
+            vcvars-arch: amd64_x86
+
+          - os: windows-11-arm
+            artifact-name: Windows-MinGW-arm64
+            cmake-preset: windows_mingw
+            msystem: CLANGARM64
+            vcvars-arch: arm64
 
           - os: windows-2022
-            name: "Windows-MSVC"
-            msystem: ""
-            architecture: "x64"
-            vcvars_arch: "amd64"
-            qt_ver: 6
-            qt_host: windows
-            qt_arch: ''
-            qt_version: '6.6.0'
-            qt_modules: 'qt5compat qtimageformats'
-            qt_tools: ''
+            artifact-name: Windows-MSVC
+            cmake-preset: windows_msvc
+            # TODO(@getchoo): This is the default in setup-dependencies/windows. Why isn't it working?!?!
+            vcvars-arch: amd64
+            qt-version: 6.10.1
 
-          - os: windows-2022
-            name: "Windows-MSVC-arm64"
-            msystem: ""
-            architecture: "arm64"
-            vcvars_arch: "amd64_arm64"
-            qt_ver: 6
-            qt_host: windows
-            qt_arch: 'win64_msvc2019_arm64'
-            qt_version: '6.6.0'
-            qt_modules: 'qt5compat qtimageformats'
-            qt_tools: ''
+          - os: windows-11-arm
+            artifact-name: Windows-MSVC-arm64
+            cmake-preset: windows_msvc
+            vcvars-arch: arm64
+            qt-version: 6.10.1
 
-          - os: macos-12
-            name: macOS
-            macosx_deployment_target: 11.0
-            qt_ver: 6
-            qt_host: mac
-            qt_arch: ''
-            qt_version: '6.6.0'
-            qt_modules: 'qt5compat qtimageformats'
-            qt_tools: ''
-
-          - os: macos-12
-            name: macOS-Legacy
-            macosx_deployment_target: 10.13
-            qt_ver: 5
-            qt_host: mac
-            qt_version: "5.15.2"
-            qt_modules: ""
-            qt_tools: ""
+          - os: macos-26
+            artifact-name: macOS
+            cmake-preset: macos_universal
+            macosx-deployment-target: 12.0
+            qt-version: 6.9.3
 
     runs-on: ${{ matrix.os }}
 
+    defaults:
+      run:
+        shell: ${{ matrix.msystem != '' && 'msys2 {0}' || 'bash' }}
+
     env:
-      MACOSX_DEPLOYMENT_TARGET: ${{ matrix.macosx_deployment_target }}
-      INSTALL_DIR: "install"
-      INSTALL_PORTABLE_DIR: "install-portable"
-      INSTALL_APPIMAGE_DIR: "install-appdir"
-      BUILD_DIR: "build"
-      CCACHE_VAR: ""
-      HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1
+      ARTIFACT_NAME: ${{ matrix.artifact-name }}-Qt6
+      BUILD_PLATFORM: official
+      BUILD_TYPE: ${{ inputs.build-type || 'Debug' }}
+      CMAKE_PRESET: ${{ matrix.cmake-preset }}
+
+      MACOSX_DEPLOYMENT_TARGET: ${{ matrix.macosx-deployment-target }}
 
     steps:
       ##
-      # PREPARE
+      # SETUP
       ##
+
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
-          submodules: "true"
+          submodules: true
 
-      - name: "Setup MSYS2"
-        if: runner.os == 'Windows' && matrix.msystem != ''
-        uses: msys2/setup-msys2@v2
+      - name: Setup dependencies
+        id: setup-dependencies
+        uses: ./.github/actions/setup-dependencies
         with:
+          build-type: ${{ env.BUILD_TYPE }}
+          artifact-name: ${{ matrix.artifact-name }}
           msystem: ${{ matrix.msystem }}
-          update: true
-          install: >-
-            git
-            mingw-w64-x86_64-binutils
-          pacboy: >-
-            toolchain:p
-            cmake:p
-            extra-cmake-modules:p
-            ninja:p
-            qt6-base:p
-            qt6-svg:p
-            qt6-imageformats:p
-            quazip-qt6:p
-            ccache:p
-            qt6-5compat:p
-            cmark:p
-
-      - name: Force newer ccache
-        if: runner.os == 'Windows' && matrix.msystem == '' && inputs.build_type == 'Debug'
-        run: |
-          choco install ccache --version 4.7.1
-
-      - name: Setup ccache
-        if: (runner.os != 'Windows' || matrix.msystem == '') && inputs.build_type == 'Debug'
-        uses: hendrikmuhs/ccache-action@v1.2.10
-        with:
-          key: ${{ matrix.os }}-qt${{ matrix.qt_ver }}-${{ matrix.architecture }}
-
-      - name: Retrieve ccache cache (Windows MinGW-w64)
-        if: runner.os == 'Windows' && matrix.msystem != '' && inputs.build_type == 'Debug'
-        uses: actions/cache@v3.3.2
-        with:
-          path: '${{ github.workspace }}\.ccache'
-          key: ${{ matrix.os }}-mingw-w64-ccache-${{ github.run_id }}
-          restore-keys: |
-            ${{ matrix.os }}-mingw-w64-ccache
-
-      - name: Setup ccache (Windows MinGW-w64)
-        if: runner.os == 'Windows' && matrix.msystem != '' && inputs.build_type == 'Debug'
-        shell: msys2 {0}
-        run: |
-          ccache --set-config=cache_dir='${{ github.workspace }}\.ccache'
-          ccache --set-config=max_size='500M'
-          ccache --set-config=compression=true
-          ccache -p  # Show config
-          ccache -z  # Zero stats
-
-      - name: Use ccache on Debug builds only
-        if: inputs.build_type == 'Debug'
-        shell: bash
-        run: |
-          echo "CCACHE_VAR=ccache" >> $GITHUB_ENV
-
-      - name: Set short version
-        shell: bash
-        run: |
-          ver_short=`git rev-parse --short HEAD`
-          echo "VERSION=$ver_short" >> $GITHUB_ENV
-
-      - name: Install Dependencies (Linux)
-        if: runner.os == 'Linux'
-        run: |
-          sudo apt-get -y update
-          sudo apt-get -y install ninja-build extra-cmake-modules scdoc appstream
-
-      - name: Install Dependencies (macOS)
-        if: runner.os == 'macOS'
-        run: |
-          brew update
-          brew install ninja extra-cmake-modules
-
-      - name: Install Qt (Linux)
-        if: runner.os == 'Linux' && matrix.qt_ver != 6
-        run: |
-          sudo apt-get -y install qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools libqt5core5a libqt5network5 libqt5gui5
-
-      - name: Install host Qt (Windows MSVC arm64)
-        if: runner.os == 'Windows' && matrix.architecture == 'arm64'
-        uses: jurplel/install-qt-action@v3
-        with:
-          aqtversion: "==3.1.*"
-          py7zrversion: ">=0.20.2"
-          version: ${{ matrix.qt_version }}
-          host: "windows"
-          target: "desktop"
-          arch: ""
-          modules: ${{ matrix.qt_modules }}
-          tools: ${{ matrix.qt_tools }}
-          cache: ${{ inputs.is_qt_cached }}
-          cache-key-prefix: host-qt-arm64-windows
-          dir: ${{ github.workspace }}\HostQt
-          set-env: false
-
-      - name: Install Qt (macOS, Linux, Qt 6 & Windows MSVC)
-        if: runner.os == 'Linux' && matrix.qt_ver == 6 || runner.os == 'macOS' || (runner.os == 'Windows' && matrix.msystem == '')
-        uses: jurplel/install-qt-action@v3
-        with:
-          aqtversion: "==3.1.*"
-          py7zrversion: ">=0.20.2"
-          version: ${{ matrix.qt_version }}
-          host: ${{ matrix.qt_host }}
-          target: "desktop"
-          arch: ${{ matrix.qt_arch }}
-          modules: ${{ matrix.qt_modules }}
-          tools: ${{ matrix.qt_tools }}
-          cache: ${{ inputs.is_qt_cached }}
-
-      - name: Install MSVC (Windows MSVC)
-        if: runner.os == 'Windows' # We want this for MinGW builds as well, as we need SignTool
-        uses: ilammy/msvc-dev-cmd@v1
-        with:
-          vsversion: 2022
-          arch: ${{ matrix.vcvars_arch }}
-
-      - name: Prepare AppImage (Linux)
-        if: runner.os == 'Linux' && matrix.qt_ver != 5
-        run: |
-          wget "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage"
-          wget "https://github.com/linuxdeploy/linuxdeploy-plugin-appimage/releases/download/continuous/linuxdeploy-plugin-appimage-x86_64.AppImage"
-          wget "https://github.com/linuxdeploy/linuxdeploy-plugin-qt/releases/download/continuous/linuxdeploy-plugin-qt-x86_64.AppImage"
-
-          wget "https://github.com/AppImageCommunity/AppImageUpdate/releases/download/continuous/AppImageUpdate-x86_64.AppImage"
-
-          ${{ github.workspace }}/.github/scripts/prepare_JREs.sh
-          sudo apt install libopengl0
-
-      - name: Add QT_HOST_PATH var (Windows MSVC arm64)
-        if: runner.os == 'Windows' && matrix.architecture == 'arm64'
-        run: |
-          echo "QT_HOST_PATH=${{ github.workspace }}\HostQt\Qt\${{ matrix.qt_version }}\msvc2019_64" >> $env:GITHUB_ENV
-
-      ##
-      # CONFIGURE
-      ##
-
-      - name: Configure CMake (macOS)
-        if: runner.os == 'macOS' && matrix.qt_ver == 6
-        run: |
-          cmake -S . -B ${{ env.BUILD_DIR }} -DCMAKE_INSTALL_PREFIX=${{ env.INSTALL_DIR }} -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} -DENABLE_LTO=ON -DLauncher_BUILD_PLATFORM=official -DCMAKE_C_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -DCMAKE_CXX_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -DLauncher_QT_VERSION_MAJOR=${{ matrix.qt_ver }} -DCMAKE_OSX_ARCHITECTURES="x86_64;arm64" -G Ninja
-
-      - name: Configure CMake (macOS-Legacy)
-        if: runner.os == 'macOS' && matrix.qt_ver == 5
-        run: |
-          cmake -S . -B ${{ env.BUILD_DIR }} -DCMAKE_INSTALL_PREFIX=${{ env.INSTALL_DIR }} -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} -DENABLE_LTO=ON -DLauncher_BUILD_PLATFORM=official -DCMAKE_C_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -DCMAKE_CXX_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -DLauncher_QT_VERSION_MAJOR=${{ matrix.qt_ver }} -DMACOSX_SPARKLE_UPDATE_PUBLIC_KEY="" -DMACOSX_SPARKLE_UPDATE_FEED_URL="" -G Ninja
-
-      - name: Configure CMake (Windows MinGW-w64)
-        if: runner.os == 'Windows' && matrix.msystem != ''
-        shell: msys2 {0}
-        run: |
-          cmake -S . -B ${{ env.BUILD_DIR }} -DCMAKE_INSTALL_PREFIX=${{ env.INSTALL_DIR }} -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} -DENABLE_LTO=ON -DLauncher_BUILD_PLATFORM=official -DCMAKE_C_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -DCMAKE_CXX_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -DLauncher_QT_VERSION_MAJOR=6 -DCMAKE_OBJDUMP=/mingw64/bin/objdump.exe -DLauncher_BUILD_ARTIFACT=${{ matrix.name }}-Qt${{ matrix.qt_ver }} -G Ninja
-
-      - name: Configure CMake (Windows MSVC)
-        if: runner.os == 'Windows' && matrix.msystem == ''
-        run: |
-          cmake -S . -B ${{ env.BUILD_DIR }} -DCMAKE_INSTALL_PREFIX=${{ env.INSTALL_DIR }} -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} -DENABLE_LTO=ON -DLauncher_BUILD_PLATFORM=official -DLauncher_QT_VERSION_MAJOR=${{ matrix.qt_ver }} -DCMAKE_MSVC_RUNTIME_LIBRARY="MultiThreadedDLL" -A${{ matrix.architecture}} -DLauncher_FORCE_BUNDLED_LIBS=ON  -DLauncher_BUILD_ARTIFACT=${{ matrix.name }}-Qt${{ matrix.qt_ver }}
-          # https://github.com/ccache/ccache/wiki/MS-Visual-Studio (I coudn't figure out the compiler prefix)
-          if ("${{ env.CCACHE_VAR }}")
-          {
-            Copy-Item C:/ProgramData/chocolatey/lib/ccache/tools/ccache-4.7.1-windows-x86_64/ccache.exe -Destination C:/ProgramData/chocolatey/lib/ccache/tools/ccache-4.7.1-windows-x86_64/cl.exe
-            echo "CLToolExe=cl.exe" >> $env:GITHUB_ENV
-            echo "CLToolPath=C:/ProgramData/chocolatey/lib/ccache/tools/ccache-4.7.1-windows-x86_64/" >> $env:GITHUB_ENV
-            echo "TrackFileAccess=false" >> $env:GITHUB_ENV
-          }
-          # Needed for ccache, but also speeds up compile
-          echo "UseMultiToolTask=true" >> $env:GITHUB_ENV
-
-      - name: Configure CMake (Linux)
-        if: runner.os == 'Linux'
-        run: |
-          cmake -S . -B ${{ env.BUILD_DIR }} -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} -DENABLE_LTO=ON -DLauncher_BUILD_PLATFORM=official -DCMAKE_C_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -DCMAKE_CXX_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -DLauncher_QT_VERSION_MAJOR=${{ matrix.qt_ver }} -DLauncher_BUILD_ARTIFACT=Linux-Qt${{ matrix.qt_ver }} -G Ninja
+          vcvars-arch: ${{ matrix.vcvars-arch }}
+          qt-version: ${{ matrix.qt-version }}
 
       ##
       # BUILD
       ##
 
-      - name: Build
-        if: runner.os != 'Windows'
+      - name: Configure project
         run: |
-          cmake --build ${{ env.BUILD_DIR }}
+          cmake --preset "$CMAKE_PRESET"
 
-      - name: Build (Windows MinGW-w64)
-        if: runner.os == 'Windows' && matrix.msystem != ''
-        shell: msys2 {0}
+      - name: Run build
         run: |
-          cmake --build ${{ env.BUILD_DIR }}
+          cmake --build --preset "$CMAKE_PRESET" --config "$BUILD_TYPE"
 
-      - name: Build (Windows MSVC)
-        if: runner.os == 'Windows' && matrix.msystem == ''
+      - name: Run tests
         run: |
-          cmake --build ${{ env.BUILD_DIR }} --config ${{ inputs.build_type }}
+          ctest --preset "$CMAKE_PRESET" --build-config "$BUILD_TYPE"
 
       ##
-      # TEST
+      # PACKAGE
       ##
 
-      - name: Test
-        if: runner.os != 'Windows'
+      - name: Get short version
+        id: short-version
+        shell: bash
         run: |
-          ctest -E "^example64|example$" --test-dir build --output-on-failure
-
-      - name: Test (Windows MinGW-w64)
-        if: runner.os == 'Windows' && matrix.msystem != ''
-        shell: msys2 {0}
-        run: |
-          ctest -E "^example64|example$" --test-dir build --output-on-failure
-
-      - name: Test (Windows MSVC)
-        if: runner.os == 'Windows' && matrix.msystem == '' && matrix.architecture != 'arm64'
-        run: |
-          ctest -E "^example64|example$" --test-dir build --output-on-failure -C ${{ inputs.build_type }}
-
-      ##
-      # PACKAGE BUILDS
-      ##
-
-      - name: Package (macOS)
-        if: runner.os == 'macOS'
-        run: |
-          cmake --install ${{ env.BUILD_DIR }}
-
-          cd ${{ env.INSTALL_DIR }}
-          chmod +x "PrismLauncher.app/Contents/MacOS/prismlauncher"
-          sudo codesign --sign - --deep --force --entitlements "../program_info/App.entitlements" --options runtime "PrismLauncher.app/Contents/MacOS/prismlauncher"
-          mv "PrismLauncher.app" "Prism Launcher.app"
-          tar -czf ../PrismLauncher.tar.gz *
-
-      - name: Make Sparkle signature (macOS)
-        if: matrix.name == 'macOS'
-        run: |
-          if [ '${{ secrets.SPARKLE_ED25519_KEY }}' != '' ]; then
-            brew install openssl@3
-            echo '${{ secrets.SPARKLE_ED25519_KEY }}' > ed25519-priv.pem
-            signature=$(/usr/local/opt/openssl@3/bin/openssl pkeyutl -sign -rawin -in ${{ github.workspace }}/PrismLauncher.tar.gz -inkey ed25519-priv.pem | openssl base64 | tr -d \\n)
-            rm ed25519-priv.pem
-            cat >> $GITHUB_STEP_SUMMARY << EOF
-          ### Artifact Information :information_source:
-          - :memo: Sparkle Signature (ed25519): \`$signature\`
-          EOF
-          else
-            cat >> $GITHUB_STEP_SUMMARY << EOF
-          ### Artifact Information :information_source:
-          - :warning: Sparkle Signature (ed25519): No private key available (likely a pull request or fork)
-          EOF
-          fi
-
-      - name: Package (Windows MinGW-w64)
-        if: runner.os == 'Windows' && matrix.msystem != ''
-        shell: msys2 {0}
-        run: |
-          cmake --install ${{ env.BUILD_DIR }}
-          touch ${{ env.INSTALL_DIR }}/manifest.txt
-          for l in $(find ${{ env.INSTALL_DIR }} -type f); do l=$(cygpath -u $l); l=${l#$(pwd)/}; l=${l#${{ env.INSTALL_DIR }}/}; l=${l#./}; echo $l; done >> ${{ env.INSTALL_DIR }}/manifest.txt
-
-      - name: Package (Windows MSVC)
-        if: runner.os == 'Windows' && matrix.msystem == ''
-        run: |
-          cmake --install ${{ env.BUILD_DIR }} --config ${{ inputs.build_type }}
-
-          cd ${{ env.INSTALL_DIR }}
-          if ("${{ matrix.qt_ver }}" -eq "5")
-          {
-            Copy-Item ${{ runner.workspace }}/Qt/Tools/OpenSSL/Win_x86/bin/libcrypto-1_1.dll -Destination libcrypto-1_1.dll
-            Copy-Item ${{ runner.workspace }}/Qt/Tools/OpenSSL/Win_x86/bin/libssl-1_1.dll -Destination libssl-1_1.dll
-          }
-          cd ${{ github.workspace }}
-
-          Get-ChildItem ${{ env.INSTALL_DIR }} -Recurse | ForEach FullName | Resolve-Path -Relative | %{ $_.TrimStart('.\') } | %{ $_.TrimStart('${{ env.INSTALL_DIR }}') } | %{ $_.TrimStart('\') } | Out-File -FilePath ${{ env.INSTALL_DIR }}/manifest.txt
-
-      - name: Fetch codesign certificate (Windows)
-        if: runner.os == 'Windows'
-        shell: bash # yes, we are not using MSYS2 or PowerShell here
-        run: |
-          echo '${{ secrets.WINDOWS_CODESIGN_CERT }}' | base64 --decode > codesign.pfx
-
-      - name: Sign executable (Windows)
-        if: runner.os == 'Windows'
-        run: |
-          if (Get-Content ./codesign.pfx){
-            cd ${{ env.INSTALL_DIR }}
-            # We ship the exact same executable for portable and non-portable editions, so signing just once is fine
-            SignTool sign /fd sha256 /td sha256 /f ../codesign.pfx /p '${{ secrets.WINDOWS_CODESIGN_PASSWORD }}' /tr http://timestamp.digicert.com prismlauncher.exe prismlauncher_updater.exe prismlauncher_filelink.exe 
-          } else {
-            ":warning: Skipped code signing for Windows, as certificate was not present." >> $env:GITHUB_STEP_SUMMARY
-          }
-
-      - name: Package (Windows MinGW-w64, portable)
-        if: runner.os == 'Windows' && matrix.msystem != ''
-        shell: msys2 {0}
-        run: |
-          cp -r ${{ env.INSTALL_DIR }} ${{ env.INSTALL_PORTABLE_DIR }}  # cmake install on Windows is slow, let's just copy instead
-          cmake --install ${{ env.BUILD_DIR }} --prefix ${{ env.INSTALL_PORTABLE_DIR }} --component portable
-          for l in $(find ${{ env.INSTALL_PORTABLE_DIR }} -type f); do l=$(cygpath -u $l); l=${l#$(pwd)/}; l=${l#${{ env.INSTALL_PORTABLE_DIR }}/}; l=${l#./}; echo $l; done >> ${{ env.INSTALL_PORTABLE_DIR }}/manifest.txt
-
-      - name: Package (Windows MSVC, portable)
-        if: runner.os == 'Windows' && matrix.msystem == ''
-        run: |
-          cp -r ${{ env.INSTALL_DIR }} ${{ env.INSTALL_PORTABLE_DIR }}  # cmake install on Windows is slow, let's just copy instead
-          cmake --install ${{ env.BUILD_DIR }} --prefix ${{ env.INSTALL_PORTABLE_DIR }} --component portable
-
-          Get-ChildItem ${{ env.INSTALL_PORTABLE_DIR }} -Recurse | ForEach FullName | Resolve-Path -Relative | %{ $_.TrimStart('.\') } | %{ $_.TrimStart('${{ env.INSTALL_PORTABLE_DIR }}') } | %{ $_.TrimStart('\') } | Out-File -FilePath ${{ env.INSTALL_DIR }}/manifest.txt
-
-      - name: Package (Windows, installer)
-        if: runner.os == 'Windows'
-        run: |
-          cd ${{ env.INSTALL_DIR }}
-          makensis -NOCD "${{ github.workspace }}/${{ env.BUILD_DIR }}/program_info/win_install.nsi"
-
-      - name: Sign installer (Windows)
-        if: runner.os == 'Windows'
-        run: |
-          if (Get-Content ./codesign.pfx){
-            SignTool sign /fd sha256 /td sha256 /f codesign.pfx /p '${{ secrets.WINDOWS_CODESIGN_PASSWORD }}' /tr http://timestamp.digicert.com PrismLauncher-Setup.exe
-          } else {
-            ":warning: Skipped code signing for Windows, as certificate was not present." >> $env:GITHUB_STEP_SUMMARY
-          }
+          echo "version=$(git rev-parse --short HEAD)" >> "$GITHUB_OUTPUT"
 
       - name: Package (Linux)
-        if: runner.os == 'Linux'
-        run: |
-          cmake --install ${{ env.BUILD_DIR }} --prefix ${{ env.INSTALL_DIR }}
-          for l in $(find ${{ env.INSTALL_DIR }} -type f); do l=${l#$(pwd)/}; l=${l#${{ env.INSTALL_DIR }}/}; l=${l#./}; echo $l; done > ${{ env.INSTALL_DIR }}/manifest.txt
+        if: ${{ runner.os == 'Linux' }}
+        uses: ./.github/actions/package/linux
+        with:
+          version: ${{ steps.short-version.outputs.version }}
+          build-type: ${{ steps.setup-dependencies.outputs.build-type }}
+          artifact-name: ${{ matrix.artifact-name }}
+          qt-version: ${{ steps.setup-dependencies.outputs.qt-version }}
 
-          cd ${{ env.INSTALL_DIR }}
-          tar --owner root --group root -czf ../PrismLauncher.tar.gz *
+          gpg-private-key: ${{ secrets.GPG_PRIVATE_KEY }}
+          gpg-private-key-id: ${{ secrets.GPG_PRIVATE_KEY_ID }}
 
-      - name: Package (Linux, portable)
-        if: runner.os == 'Linux'
-        run: |
-          cmake --install ${{ env.BUILD_DIR }} --prefix ${{ env.INSTALL_PORTABLE_DIR }}
-          cmake --install ${{ env.BUILD_DIR }} --prefix ${{ env.INSTALL_PORTABLE_DIR }} --component portable
-          for l in $(find ${{ env.INSTALL_PORTABLE_DIR }} -type f); do l=${l#$(pwd)/}; l=${l#${{ env.INSTALL_PORTABLE_DIR }}/}; l=${l#./}; echo $l; done > ${{ env.INSTALL_PORTABLE_DIR }}/manifest.txt
+      - name: Package (macOS)
+        if: ${{ runner.os == 'macOS' }}
+        uses: ./.github/actions/package/macos
+        with:
+          version: ${{ steps.short-version.outputs.version }}
+          build-type: ${{ steps.setup-dependencies.outputs.build-type }}
+          artifact-name: ${{ matrix.artifact-name }}
 
+          apple-codesign-cert: ${{ secrets.APPLE_CODESIGN_CERT }}
+          apple-codesign-password: ${{ secrets.APPLE_CODESIGN_PASSWORD }}
+          apple-codesign-id: ${{ secrets.APPLE_CODESIGN_ID }}
+          apple-notarize-apple-id: ${{ secrets.APPLE_NOTARIZE_APPLE_ID }}
+          apple-notarize-team-id: ${{ secrets.APPLE_NOTARIZE_TEAM_ID }}
+          apple-notarize-password: ${{ secrets.APPLE_NOTARIZE_PASSWORD }}
+          sparkle-ed25519-key: ${{ secrets.SPARKLE_ED25519_KEY }}
 
-          cd ${{ env.INSTALL_PORTABLE_DIR }}
-          tar -czf ../PrismLauncher-portable.tar.gz *
-
-      - name: Package AppImage (Linux)
-        if: runner.os == 'Linux' && matrix.qt_ver != 5
-        shell: bash
+      - name: Package (Windows)
+        if: ${{ runner.os == 'Windows' }}
+        uses: ./.github/actions/package/windows
         env:
-          GPG_PRIVATE_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
-        run: |
-          cmake --install ${{ env.BUILD_DIR }} --prefix ${{ env.INSTALL_APPIMAGE_DIR }}/usr
-
-          mv ${{ env.INSTALL_APPIMAGE_DIR }}/usr/share/metainfo/org.prismlauncher.PrismLauncher.metainfo.xml ${{ env.INSTALL_APPIMAGE_DIR }}/usr/share/metainfo/org.prismlauncher.PrismLauncher.appdata.xml
-          export "NO_APPSTREAM=1" # we have to skip appstream checking because appstream on ubuntu 20.04 is outdated
-
-          export OUTPUT="PrismLauncher-Linux-x86_64.AppImage"
-
-          chmod +x linuxdeploy-*.AppImage
-
-          mkdir -p ${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib/jvm/java-{8,17}-openjdk
-          mkdir -p ${{ env.INSTALL_APPIMAGE_DIR }}/usr/plugins/iconengines
-
-          cp -r ${{ github.workspace }}/JREs/jre8/* ${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib/jvm/java-8-openjdk
-
-          cp -r ${{ github.workspace }}/JREs/jre17/* ${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib/jvm/java-17-openjdk
-
-          cp -r ${{ runner.workspace }}/Qt/${{ matrix.qt_version }}/gcc_64/plugins/iconengines/* ${{ env.INSTALL_APPIMAGE_DIR }}/usr/plugins/iconengines
-
-          cp /usr/lib/x86_64-linux-gnu/libcrypto.so.1.1 ${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib/
-          cp /usr/lib/x86_64-linux-gnu/libssl.so.1.1 ${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib/
-          cp /usr/lib/x86_64-linux-gnu/libOpenGL.so.0* ${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib/
-
-          LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib"
-          LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib/jvm/java-8-openjdk/lib/amd64/server"
-          LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib/jvm/java-8-openjdk/lib/amd64"
-          LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib/jvm/java-17-openjdk/lib/server"
-          LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib/jvm/java-17-openjdk/lib"
-          export LD_LIBRARY_PATH
-
-          chmod +x AppImageUpdate-x86_64.AppImage
-          cp AppImageUpdate-x86_64.AppImage ${{ env.INSTALL_APPIMAGE_DIR }}/usr/bin
-
-          export UPDATE_INFORMATION="gh-releases-zsync|${{ github.repository_owner }}|${{ github.event.repository.name }}|latest|PrismLauncher-Linux-x86_64.AppImage.zsync" 
-
-          if [ '${{ secrets.GPG_PRIVATE_KEY_ID }}' != '' ]; then
-            export SIGN=1
-            export SIGN_KEY=${{ secrets.GPG_PRIVATE_KEY_ID }}
-            mkdir -p ~/.gnupg/
-            echo "$GPG_PRIVATE_KEY" > ~/.gnupg/private.key
-            gpg --import ~/.gnupg/private.key
-          else
-            echo ":warning: Skipped code signing for Linux AppImage, as gpg key was not present." >> $GITHUB_STEP_SUMMARY
-          fi
-
-          ./linuxdeploy-x86_64.AppImage --appdir ${{ env.INSTALL_APPIMAGE_DIR }} --output appimage --plugin qt -i ${{ env.INSTALL_APPIMAGE_DIR }}/usr/share/icons/hicolor/scalable/apps/org.prismlauncher.PrismLauncher.svg
-
-          mv "PrismLauncher-Linux-x86_64.AppImage" "PrismLauncher-Linux-${{ env.VERSION }}-${{ inputs.build_type }}-x86_64.AppImage"
-
-      ##
-      # UPLOAD BUILDS
-      ##
-
-      - name: Upload binary tarball (macOS)
-        if: runner.os == 'macOS'
-        uses: actions/upload-artifact@v3
+          CI_HAS_ACCESS_TO_AZURE: ${{ vars.CI_HAS_ACCESS_TO_AZURE || '' }}
         with:
-          name: PrismLauncher-${{ matrix.name }}-${{ env.VERSION }}-${{ inputs.build_type }}
-          path: PrismLauncher.tar.gz
+          version: ${{ steps.short-version.outputs.version }}
+          build-type: ${{ steps.setup-dependencies.outputs.build-type }}
+          artifact-name: ${{ matrix.artifact-name }}
+          msystem: ${{ matrix.msystem }}
 
-      - name: Upload binary zip (Windows)
-        if: runner.os == 'Windows'
-        uses: actions/upload-artifact@v3
-        with:
-          name: PrismLauncher-${{ matrix.name }}-${{ env.VERSION }}-${{ inputs.build_type }}
-          path: ${{ env.INSTALL_DIR }}/**
-
-      - name: Upload binary zip (Windows, portable)
-        if: runner.os == 'Windows'
-        uses: actions/upload-artifact@v3
-        with:
-          name: PrismLauncher-${{ matrix.name }}-Portable-${{ env.VERSION }}-${{ inputs.build_type }}
-          path: ${{ env.INSTALL_PORTABLE_DIR }}/**
-
-      - name: Upload installer (Windows)
-        if: runner.os == 'Windows'
-        uses: actions/upload-artifact@v3
-        with:
-          name: PrismLauncher-${{ matrix.name }}-Setup-${{ env.VERSION }}-${{ inputs.build_type }}
-          path: PrismLauncher-Setup.exe
-
-      - name: Upload binary tarball (Linux, Qt 5)
-        if: runner.os == 'Linux' && matrix.qt_ver != 6
-        uses: actions/upload-artifact@v3
-        with:
-          name: PrismLauncher-${{ runner.os }}-Qt5-${{ env.VERSION }}-${{ inputs.build_type }}
-          path: PrismLauncher.tar.gz
-
-      - name: Upload binary tarball (Linux, portable, Qt 5)
-        if: runner.os == 'Linux' && matrix.qt_ver != 6
-        uses: actions/upload-artifact@v3
-        with:
-          name: PrismLauncher-${{ runner.os }}-Qt5-Portable-${{ env.VERSION }}-${{ inputs.build_type }}
-          path: PrismLauncher-portable.tar.gz
-
-      - name: Upload binary tarball (Linux, Qt 6)
-        if: runner.os == 'Linux' && matrix.qt_ver !=5
-        uses: actions/upload-artifact@v3
-        with:
-          name: PrismLauncher-${{ runner.os }}-Qt6-${{ env.VERSION }}-${{ inputs.build_type }}
-          path: PrismLauncher.tar.gz
-
-      - name: Upload binary tarball (Linux, portable, Qt 6)
-        if: runner.os == 'Linux' && matrix.qt_ver != 5
-        uses: actions/upload-artifact@v3
-        with:
-          name: PrismLauncher-${{ runner.os }}-Qt6-Portable-${{ env.VERSION }}-${{ inputs.build_type }}
-          path: PrismLauncher-portable.tar.gz
-
-      - name: Upload AppImage (Linux)
-        if: runner.os == 'Linux' && matrix.qt_ver != 5
-        uses: actions/upload-artifact@v3
-        with:
-          name: PrismLauncher-${{ runner.os }}-${{ env.VERSION }}-${{ inputs.build_type }}-x86_64.AppImage
-          path: PrismLauncher-${{ runner.os }}-${{ env.VERSION }}-${{ inputs.build_type }}-x86_64.AppImage
-
-      - name: Upload AppImage Zsync (Linux)
-        if: runner.os == 'Linux' && matrix.qt_ver != 5
-        uses: actions/upload-artifact@v3
-        with:
-          name: PrismLauncher-${{ runner.os }}-${{ env.VERSION }}-${{ inputs.build_type }}-x86_64.AppImage.zsync
-          path: PrismLauncher-Linux-x86_64.AppImage.zsync
-
-      - name: ccache stats (Windows MinGW-w64)
-        if: runner.os == 'Windows' && matrix.msystem != ''
-        shell: msys2 {0}
-        run: |
-          ccache -s
-
-  flatpak:
-    runs-on: ubuntu-latest
-    container:
-      image: bilelmoussaoui/flatpak-github-actions:kde-5.15-22.08
-      options: --privileged
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        if: inputs.build_type == 'Debug'
-        with:
-          submodules: "true"
-      - name: Build Flatpak (Linux)
-        if: inputs.build_type == 'Debug'
-        uses: flatpak/flatpak-github-actions/flatpak-builder@v6
-        with:
-          bundle: "Prism Launcher.flatpak"
-          manifest-path: flatpak/org.prismlauncher.PrismLauncher.yml
+          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
+          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
+          azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

.github/workflows/codeql.yml

@@ -1,35 +1,90 @@
 name: "CodeQL Code Scanning"
 
-on: [ push, pull_request, workflow_dispatch ]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches:
+      - "develop"
+      - "release-*"
+    paths:
+      # File types
+      - "**.cpp"
+      - "**.h"
+      - "**.java"
+      - "**.ui"
+
+      # Directories
+      - "buildconfig/**"
+      - "cmake/**"
+      - "launcher/**"
+      - "libraries/**"
+      - "program_info/**"
+      - "tests/**"
+
+      # Files
+      - "CMakeLists.txt"
+      - "COPYING.md"
+
+      # Workflows
+      - ".github/codeql/**"
+      - ".github/workflows/codeql.yml"
+      - ".github/actions/setup-dependencies/**"
+  pull_request:
+    paths:
+      # File types
+      - "**.cpp"
+      - "**.h"
+      - "**.java"
+      - "**.ui"
+
+      # Directories
+      - "buildconfig/**"
+      - "cmake/**"
+      - "launcher/**"
+      - "libraries/**"
+      - "program_info/**"
+      - "tests/**"
+
+      # Files
+      - "CMakeLists.txt"
+      - "COPYING.md"
+
+      # Workflows
+      - ".github/codeql/**"
+      - ".github/workflows/codeql.yml"
+      - ".github/actions/setup-dependencies/**"
+  workflow_dispatch:
 
 jobs:
   CodeQL:
     runs-on: ubuntu-latest
-    
+
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
-          submodules: 'true'
+          submodules: "true"
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
+        uses: github/codeql-action/init@v4
         with:
           config-file: ./.github/codeql/codeql-config.yml
           queries: security-and-quality
           languages: cpp, java
 
-      - name: Install Dependencies
-        run:  
-          sudo apt-get -y update
-
-          sudo apt-get -y install ninja-build extra-cmake-modules scdoc qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools libqt5core5a libqt5network5 libqt5gui5
+      - name: Setup dependencies
+        uses: ./.github/actions/setup-dependencies
+        with:
+          build-type: Debug
+          qt-version: 6.10.1
 
       - name: Configure and Build
         run: |
-          cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr -DLauncher_QT_VERSION_MAJOR=5 -G Ninja
-
-          cmake --build build
+          cmake --preset linux
+          cmake --build --preset linux --config Debug
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v2
+        uses: github/codeql-action/analyze@v4

.github/workflows/merge-blocking-pr.yml

@@ -0,0 +1,62 @@
+name: Merged Blocking Pull Request Automation
+
+on:
+  pull_request_target:
+    types:
+      - closed
+  workflow_dispatch:
+    inputs:
+      pr_id:
+        description: Local Pull Request number to work on
+        required: true
+        type: number
+
+jobs:
+  update-blocked-status:
+    name: Update Blocked Status
+    runs-on: ubuntu-slim
+
+    # a pr that was a `blocking:<id>` label was merged.
+    # find the open pr's it was blocked by and trigger a refresh of their state
+    if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.merged == true && contains(github.event.pull_request.labels.*.name, 'blocking') }}
+
+    steps:
+      - name: Generate token
+        id: generate-token
+        uses: actions/create-github-app-token@v2
+        with:
+          app-id: ${{ vars.PULL_REQUEST_APP_ID }}
+          private-key: ${{ secrets.PULL_REQUEST_APP_PRIVATE_KEY }}
+
+      - name: Gather Dependent PRs
+        id: gather_deps
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+          PR_NUMBER: ${{ inputs.pr_id || github.event.pull_request.number }}
+        run: |
+          blocked_prs=$(
+          gh -R ${{ github.repository }} pr list --label 'blocked' --json 'number,body' \
+            | jq -c --argjson pr "$PR_NUMBER" '
+                reduce ( .[] | select(
+                  .body |
+                    scan("(?:blocked (?:by|on)|stacked on):? #([0-9]+)") |
+                    map(tonumber) |
+                    any(.[]; . == $pr)
+                )) as $i ([]; . + [$i])
+              '
+          )
+          {
+            echo "deps=$blocked_prs"
+            echo "numdeps=$(jq -r '. | length' <<< "$blocked_prs")"
+          }  >> "$GITHUB_OUTPUT"
+
+      - name: Trigger Blocked PR Workflows for Dependants
+        if: fromJSON(steps.gather_deps.outputs.numdeps) > 0
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+          DEPS: ${{ steps.gather_deps.outputs.deps }}
+        run: |
+          while read -r pr ; do
+            gh -R ${{ github.repository }} workflow run 'blocked-prs.yml' -r "${{ github.ref_name }}" -f pr_id="$pr"
+          done < <(jq -c '.[].number' <<< "$DEPS")
+

.github/workflows/nix.yml

@@ -0,0 +1,136 @@
+name: Nix
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches:
+      - "develop"
+      - "release-*"
+    tags:
+      - "*"
+    paths:
+      # File types
+      - "**.cpp"
+      - "**.h"
+      - "**.java"
+      - "**.ui"
+
+      # Build files
+      - "**.nix"
+      - "nix/**"
+      - "flake.lock"
+
+      # Directories
+      - "buildconfig/**"
+      - "cmake/**"
+      - "launcher/**"
+      - "libraries/**"
+      - "program_info/**"
+      - "tests/**"
+
+      # Files
+      - "CMakeLists.txt"
+      - "COPYING.md"
+
+      # Workflows
+      - ".github/workflows/nix.yml"
+  pull_request:
+    paths:
+      # File types
+      - "**.cpp"
+      - "**.h"
+      - "**.java"
+      - "**.ui"
+
+      # Build files
+      - "**.nix"
+      - "nix/**"
+      - "flake.lock"
+
+      # Directories
+      - "buildconfig/**"
+      - "cmake/**"
+      - "launcher/**"
+      - "libraries/**"
+      - "program_info/**"
+      - "tests/**"
+
+      # Files
+      - "CMakeLists.txt"
+      - "COPYING.md"
+
+      # Workflows
+      - ".github/workflows/nix.yml"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  DEBUG: ${{ github.ref_type != 'tag' }}
+
+jobs:
+  build:
+    name: Build (${{ matrix.system }})
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            system: x86_64-linux
+
+          - os: ubuntu-22.04-arm
+            system: aarch64-linux
+
+          - os: macos-14
+            system: aarch64-darwin
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Install Nix
+        uses: cachix/install-nix-action@v31
+
+        # For PRs
+      - name: Setup Nix Magic Cache
+        if: ${{ github.event_name == 'pull_request' }}
+        uses: DeterminateSystems/magic-nix-cache-action@v13
+        with:
+          diagnostic-endpoint: ""
+          use-flakehub: false
+
+        # For in-tree builds
+      - name: Setup Cachix
+        if: ${{ github.event_name == 'push' || github.event_name == 'workflow_dispatch' }}
+        uses: cachix/cachix-action@v16
+        with:
+          name: prismlauncher
+          authToken: ${{ secrets.CACHIX_AUTH_TOKEN }}
+
+      - name: Run Flake checks
+        run: |
+          nix flake check --print-build-logs --show-trace
+
+      - name: Build debug package
+        if: ${{ env.DEBUG == 'true' }}
+        run: |
+          nix build \
+            --no-link --print-build-logs --print-out-paths \
+            .#prismlauncher-debug >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Build release package
+        if: ${{ env.DEBUG == 'false' }}
+        env:
+          TAG: ${{ github.ref_name }}
+          SYSTEM: ${{ matrix.system }}
+        run: |
+          nix build --no-link --print-out-paths .#prismlauncher \
+            | tee -a "$GITHUB_STEP_SUMMARY" \
+            | xargs cachix pin prismlauncher "$TAG"-"$SYSTEM"

.github/workflows/publish.yml

@@ -1,13 +1,21 @@
-name: Publish to WinGet
+name: Publish
+
 on:
   release:
-    types: [released]
+    types: [ released ]
+
+permissions:
+  contents: read
 
 jobs:
-  publish:
-    runs-on: windows-latest
+  winget:
+    name: Winget
+
+    runs-on: ubuntu-slim
+
     steps:
-      - uses: vedantmgoyal2009/winget-releaser@v2
+      - name: Publish on Winget
+        uses: vedantmgoyal2009/winget-releaser@v2
         with:
           identifier: PrismLauncher.PrismLauncher
           version: ${{ github.event.release.tag_name }}

.github/workflows/release.yml

@@ -10,29 +10,23 @@ jobs:
     name: Build Release
     uses: ./.github/workflows/build.yml
     with:
-      build_type: Release
-      is_qt_cached: false
-    secrets:
-      SPARKLE_ED25519_KEY: ${{ secrets.SPARKLE_ED25519_KEY }}
-      WINDOWS_CODESIGN_CERT: ${{ secrets.WINDOWS_CODESIGN_CERT }}
-      WINDOWS_CODESIGN_PASSWORD: ${{ secrets.WINDOWS_CODESIGN_PASSWORD }}
-      CACHIX_AUTH_TOKEN: ${{ secrets.CACHIX_AUTH_TOKEN }}
-      GPG_PRIVATE_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
-      GPG_PRIVATE_KEY_ID: ${{ secrets.GPG_PRIVATE_KEY_ID }}
+      build-type: Release
+      environment: Release
+    secrets: inherit
 
   create_release:
     needs: build_release
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     outputs:
       upload_url: ${{ steps.create_release.outputs.upload_url }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           submodules: "true"
           path: "PrismLauncher-source"
       - name: Download artifacts
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v7
       - name: Grab and store version
         run: |
           tag_name=$(echo ${{ github.ref }} | grep -oE "[^/]+$")
@@ -41,13 +35,12 @@ jobs:
         run: |
           mv ${{ github.workspace }}/PrismLauncher-source PrismLauncher-${{ env.VERSION }}
           mv PrismLauncher-Linux-Qt6-Portable*/PrismLauncher-portable.tar.gz PrismLauncher-Linux-Qt6-Portable-${{ env.VERSION }}.tar.gz
-          mv PrismLauncher-Linux-Qt6*/PrismLauncher.tar.gz PrismLauncher-Linux-Qt6-${{ env.VERSION }}.tar.gz
-          mv PrismLauncher-Linux-Qt5-Portable*/PrismLauncher-portable.tar.gz PrismLauncher-Linux-Qt5-Portable-${{ env.VERSION }}.tar.gz
-          mv PrismLauncher-Linux-Qt5*/PrismLauncher.tar.gz PrismLauncher-Linux-Qt5-${{ env.VERSION }}.tar.gz       
-          mv PrismLauncher-*.AppImage/PrismLauncher-*.AppImage PrismLauncher-Linux-x86_64.AppImage
-          mv PrismLauncher-*.AppImage.zsync/PrismLauncher-*.AppImage.zsync PrismLauncher-Linux-x86_64.AppImage.zsync
-          mv PrismLauncher-macOS-Legacy*/PrismLauncher.tar.gz PrismLauncher-macOS-Legacy-${{ env.VERSION }}.tar.gz
-          mv PrismLauncher-macOS*/PrismLauncher.tar.gz PrismLauncher-macOS-${{ env.VERSION }}.tar.gz
+          mv PrismLauncher-Linux-aarch64-Qt6-Portable*/PrismLauncher-portable.tar.gz PrismLauncher-Linux-aarch64-Qt6-Portable-${{ env.VERSION }}.tar.gz
+          mv PrismLauncher-*.AppImage/PrismLauncher-*-x86_64.AppImage PrismLauncher-Linux-x86_64.AppImage
+          mv PrismLauncher-*.AppImage.zsync/PrismLauncher-*-x86_64.AppImage.zsync PrismLauncher-Linux-x86_64.AppImage.zsync
+          mv PrismLauncher-*.AppImage/PrismLauncher-*-aarch64.AppImage PrismLauncher-Linux-aarch64.AppImage
+          mv PrismLauncher-*.AppImage.zsync/PrismLauncher-*-aarch64.AppImage.zsync PrismLauncher-Linux-aarch64.AppImage.zsync
+          mv PrismLauncher-macOS*/PrismLauncher.zip PrismLauncher-macOS-${{ env.VERSION }}.zip
 
           tar --exclude='.git' -czf PrismLauncher-${{ env.VERSION }}.tar.gz PrismLauncher-${{ env.VERSION }}
 
@@ -77,31 +70,45 @@ jobs:
             cd ..
           done
 
+          for d in PrismLauncher-Windows-MinGW-arm64*; do
+            cd "${d}" || continue
+            INST="$(echo -n ${d} | grep -o Setup || true)"
+            PORT="$(echo -n ${d} | grep -o Portable || true)"
+            NAME="PrismLauncher-Windows-MinGW-arm64"
+            test -z "${PORT}" || NAME="${NAME}-Portable"
+            test -z "${INST}" || mv PrismLauncher-*.exe ../${NAME}-Setup-${{ env.VERSION }}.exe
+            test -n "${INST}" || zip -r -9 "../${NAME}-${{ env.VERSION }}.zip" *
+            cd ..
+          done
+
       - name: Create release
         id: create_release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           tag_name: ${{ github.ref }}
           name: Prism Launcher ${{ env.VERSION }}
           draft: true
           prerelease: false
+          fail_on_unmatched_files: true
           files: |
-            PrismLauncher-Linux-Qt5-${{ env.VERSION }}.tar.gz
-            PrismLauncher-Linux-Qt5-Portable-${{ env.VERSION }}.tar.gz
             PrismLauncher-Linux-x86_64.AppImage
             PrismLauncher-Linux-x86_64.AppImage.zsync
-            PrismLauncher-Linux-Qt6-${{ env.VERSION }}.tar.gz
+            PrismLauncher-Linux-aarch64.AppImage
+            PrismLauncher-Linux-aarch64.AppImage.zsync
             PrismLauncher-Linux-Qt6-Portable-${{ env.VERSION }}.tar.gz
+            PrismLauncher-Linux-aarch64-Qt6-Portable-${{ env.VERSION }}.tar.gz
             PrismLauncher-Windows-MinGW-w64-${{ env.VERSION }}.zip
             PrismLauncher-Windows-MinGW-w64-Portable-${{ env.VERSION }}.zip
             PrismLauncher-Windows-MinGW-w64-Setup-${{ env.VERSION }}.exe
+            PrismLauncher-Windows-MinGW-arm64-${{ env.VERSION }}.zip
+            PrismLauncher-Windows-MinGW-arm64-Portable-${{ env.VERSION }}.zip
+            PrismLauncher-Windows-MinGW-arm64-Setup-${{ env.VERSION }}.exe
             PrismLauncher-Windows-MSVC-arm64-${{ env.VERSION }}.zip
             PrismLauncher-Windows-MSVC-arm64-Portable-${{ env.VERSION }}.zip
             PrismLauncher-Windows-MSVC-arm64-Setup-${{ env.VERSION }}.exe
             PrismLauncher-Windows-MSVC-${{ env.VERSION }}.zip
             PrismLauncher-Windows-MSVC-Portable-${{ env.VERSION }}.zip
             PrismLauncher-Windows-MSVC-Setup-${{ env.VERSION }}.exe
-            PrismLauncher-macOS-${{ env.VERSION }}.tar.gz
-            PrismLauncher-macOS-Legacy-${{ env.VERSION }}.tar.gz
+            PrismLauncher-macOS-${{ env.VERSION }}.zip
             PrismLauncher-${{ env.VERSION }}.tar.gz

.github/workflows/stale.yml

@@ -0,0 +1,29 @@
+name: Stale
+
+on:
+  schedule:
+    # run weekly on sunday
+    - cron: "0 0 * * 0"
+  workflow_dispatch:
+
+jobs:
+  label:
+    name: Label issues and PRs
+
+    runs-on: ubuntu-slim
+
+    permissions:
+      issues: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/stale@v10
+        with:
+          days-before-stale: 60
+          days-before-close: -1 # Don't close anything
+          exempt-issue-labels: rfc,nostale,help wanted
+          exempt-all-milestones: true
+          exempt-all-assignees: true
+          operations-per-run: 1000
+          stale-issue-label: inactive
+          stale-pr-label: inactive

.github/workflows/trigger_builds.yml

@@ -1,37 +0,0 @@
-name: Build Application
-
-on:
-  push:
-    branches-ignore:
-      - "renovate/**"
-    paths-ignore:
-      - "**.md"
-      - "**/LICENSE"
-      - "flake.lock"
-      - "packages/**"
-      - ".github/ISSUE_TEMPLATE/**"
-      - ".markdownlint**"
-  pull_request:
-    paths-ignore:
-      - "**.md"
-      - "**/LICENSE"
-      - "flake.lock"
-      - "packages/**"
-      - ".github/ISSUE_TEMPLATE/**"
-      - ".markdownlint**"
-  workflow_dispatch:
-
-jobs:
-  build_debug:
-    name: Build Debug
-    uses: ./.github/workflows/build.yml
-    with:
-      build_type: Debug
-      is_qt_cached: true
-    secrets:
-      SPARKLE_ED25519_KEY: ${{ secrets.SPARKLE_ED25519_KEY }}
-      WINDOWS_CODESIGN_CERT: ${{ secrets.WINDOWS_CODESIGN_CERT }}
-      WINDOWS_CODESIGN_PASSWORD: ${{ secrets.WINDOWS_CODESIGN_PASSWORD }}
-      CACHIX_AUTH_TOKEN: ${{ secrets.CACHIX_AUTH_TOKEN }}
-      GPG_PRIVATE_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
-      GPG_PRIVATE_KEY_ID: ${{ secrets.GPG_PRIVATE_KEY_ID }}

.github/workflows/update-flake.yml

@@ -13,13 +13,13 @@ permissions:
 jobs:
   update-flake:
     if: github.repository == 'PrismLauncher/PrismLauncher'
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
 
     steps:
-      - uses: actions/checkout@v4
-      - uses: cachix/install-nix-action@6a9a9e84a173d90b3ffb42c5ddaf9ea033fad011 # v23
+      - uses: actions/checkout@v6
+      - uses: cachix/install-nix-action@4e002c8ec80594ecd40e759629461e26c8abed15 # v31
 
-      - uses: DeterminateSystems/update-flake-lock@v20
+      - uses: DeterminateSystems/update-flake-lock@v28
         with:
           commit-msg: "chore(nix): update lockfile"
           pr-title: "chore(nix): update lockfile"

.gitignore

@@ -14,6 +14,7 @@ CMakeLists.txt.user.*
 CMakeSettings.json
 /CMakeFiles
 CMakeCache.txt
+CMakeUserPresets.json
 /.project
 /.settings
 /.idea
@@ -21,6 +22,7 @@ CMakeCache.txt
 /.vs
 cmake-build-*/
 Debug
+compile_commands.json
 
 # Build dirs
 build
@@ -47,8 +49,12 @@ run/
 
 # Nix/NixOS
 .direnv/
-.pre-commit-config.yaml
+## Used when manually invoking stdenv phases
+outputs/
+## Regular artifacts
 result
+result-*
+repl-result-*
 
 # Flatpak
 .flatpak-builder

.gitmodules

@@ -1,24 +1,3 @@
-[submodule "libraries/quazip"]
-	path = libraries/quazip
-	url = https://github.com/stachenov/quazip.git
-[submodule "libraries/tomlplusplus"]
-	path = libraries/tomlplusplus
-	url = https://github.com/marzer/tomlplusplus.git
-[submodule "libraries/filesystem"]
-	path = libraries/filesystem
-	url = https://github.com/gulrak/filesystem
 [submodule "libraries/libnbtplusplus"]
 	path = libraries/libnbtplusplus
 	url = https://github.com/PrismLauncher/libnbtplusplus.git
-[submodule "libraries/zlib"]
-	path = libraries/zlib
-	url = https://github.com/madler/zlib.git
-[submodule "libraries/extra-cmake-modules"]
-	path = libraries/extra-cmake-modules
-	url = https://github.com/KDE/extra-cmake-modules
-[submodule "libraries/cmark"]
-	path = libraries/cmark
-	url = https://github.com/commonmark/cmark.git
-[submodule "flatpak/shared-modules"]
-	path = flatpak/shared-modules
-	url = https://github.com/flathub/shared-modules.git

.markdownlintignore

@@ -1,2 +1 @@
 libraries/nbtplusplus
-libraries/quazip

BUILD.md

@@ -1,3 +0,0 @@
-# Build Instructions
-
-Full build instructions are available on [the website](https://prismlauncher.org/wiki/development/build-instructions/).

CMakeLists.txt

@@ -1,6 +1,9 @@
-cmake_minimum_required(VERSION 3.15)  # minimum version required by QuaZip
+cmake_minimum_required(VERSION 3.22)  # minimum version required by Qt
 
-project(Launcher)
+project(Launcher LANGUAGES C CXX)
+if(APPLE)
+    enable_language(OBJC OBJCXX)
+endif()
 
 string(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BUILD_DIR}" IS_IN_SOURCE_BUILD)
 if(IS_IN_SOURCE_BUILD)
@@ -24,7 +27,7 @@ set(CMAKE_JAVA_TARGET_OUTPUT_DIR ${PROJECT_BINARY_DIR}/jars)
 ######## Set compiler flags ########
 set(CMAKE_CXX_STANDARD_REQUIRED true)
 set(CMAKE_C_STANDARD_REQUIRED true)
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_C_STANDARD 11)
 include(GenerateExportHeader)
 if(MSVC)
@@ -78,47 +81,49 @@ else()
     # ATL's pack list needs more than the default 1 Mib stack on windows
     if(WIN32)
         set(CMAKE_EXE_LINKER_FLAGS "-Wl,--stack,8388608 ${CMAKE_EXE_LINKER_FLAGS}")
+
+        # -ffunction-sections and -fdata-sections help reduce binary size
+        # -mguard=cf enables Control Flow Guard
+        # TODO: Look into -gc-sections to further reduce binary size
+        foreach(lang C CXX)
+            set("CMAKE_${lang}_FLAGS_RELEASE" "-ffunction-sections -fdata-sections -mguard=cf")
+        endforeach()
     endif()
 endif()
 
-# Fix build with Qt 5.13
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DQT_NO_DEPRECATED_WARNINGS=Y")
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DQT_DISABLE_DEPRECATED_BEFORE=0x050C00")
-
-# Fix aarch64 build for toml++
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DTOML_ENABLE_FLOAT16=0")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DQT_WARN_DEPRECATED_UP_TO=0x060200")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DQT_DISABLE_DEPRECATED_UP_TO=0x060000")
 
 # set CXXFLAGS for build targets
 set(CMAKE_CXX_FLAGS_RELEASE "-O2 -D_FORTIFY_SOURCE=2 ${CMAKE_CXX_FLAGS_RELEASE}")
 
+# Export compile commands for debug builds if we can (useful in LSPs like clangd)
+# https://cmake.org/cmake/help/v3.31/variable/CMAKE_EXPORT_COMPILE_COMMANDS.html
+if(CMAKE_GENERATOR STREQUAL "Unix Makefiles" OR CMAKE_GENERATOR MATCHES "^Ninja")
+    set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+endif()
+
 option(DEBUG_ADDRESS_SANITIZER "Enable Address Sanitizer in Debug builds" OFF)
 
 # If this is a Debug build turn on address sanitiser
-if ((CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo") AND DEBUG_ADDRESS_SANITIZER)
+if (DEBUG_ADDRESS_SANITIZER)
     message(STATUS "Address Sanitizer enabled for Debug builds, Turn it off with -DDEBUG_ADDRESS_SANITIZER=off")
-    if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-        if (CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
-            # using clang with clang-cl front end 
-            message(STATUS "Address Sanitizer available on Clang MSVC frontend")
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /fsanitize=address /Oy-")
-            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /fsanitize=address /Oy-")
-        else()
-            # AppleClang and Clang
-            message(STATUS "Address Sanitizer available on Clang")
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
-            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
-        endif()
-    elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        # GCC
-        message(STATUS "Address Sanitizer available on GCC")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
-        link_libraries("asan")
-    elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-        message(STATUS "Address Sanitizer available on MSVC")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /fsanitize=address /Oy-")
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /fsanitize=address /Oy-")
+
+    set(USE_ASAN_COMPILE_OPTIONS $<AND:$<CONFIG:Debug,RelWithDebInfo>,$<COMPILE_LANGUAGE:C,CXX>>)
+    if (CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
+        message(STATUS "Using Address Sanitizer compile options for MSVC frontend")
+        add_compile_options(
+                $<${USE_ASAN_COMPILE_OPTIONS}:/fsanitize=address>
+                $<${USE_ASAN_COMPILE_OPTIONS}:/Oy->
+        )
+    elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+        message(STATUS "Using Address Sanitizer compile options for GCC/Clang")
+        add_compile_options(
+                $<${USE_ASAN_COMPILE_OPTIONS}:-fsanitize=address,undefined>
+                $<${USE_ASAN_COMPILE_OPTIONS}:-fno-omit-frame-pointer>
+                $<${USE_ASAN_COMPILE_OPTIONS}:-fno-sanitize-recover=null>
+        )
+        link_libraries("asan" "ubsan")
     else()
         message(STATUS "Address Sanitizer not available on compiler ${CMAKE_CXX_COMPILER_ID}")
     endif()
@@ -150,20 +155,9 @@ endif()
 
 option(BUILD_TESTING "Build the testing tree." ON)
 
-find_package(ECM QUIET NO_MODULE)
-if(NOT ECM_FOUND)
-    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/libraries/extra-cmake-modules/CMakeLists.txt")
-        message(STATUS "Using bundled ECM")
-        set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/libraries/extra-cmake-modules/modules;${CMAKE_MODULE_PATH}")
-    else()
-        message(FATAL_ERROR
-            " Could not find ECM\n \n"
-            " Either install ECM using the system package manager or clone submodules\n"
-            " Submodules can be cloned with 'git submodule update --init --recursive'")
-    endif()
-else()
-    set(CMAKE_MODULE_PATH "${ECM_MODULE_PATH};${CMAKE_MODULE_PATH}")
-endif()
+find_package(ECM NO_MODULE REQUIRED)
+set(CMAKE_MODULE_PATH "${ECM_MODULE_PATH};${CMAKE_MODULE_PATH}")
+
 include(CTest)
 include(ECMAddTests)
 if(BUILD_TESTING)
@@ -176,14 +170,17 @@ endif()
 set(Launcher_NEWS_RSS_URL "https://prismlauncher.org/feed/feed.xml" CACHE STRING "URL to fetch Prism Launcher's news RSS feed from.")
 set(Launcher_NEWS_OPEN_URL "https://prismlauncher.org/news" CACHE STRING "URL that gets opened when the user clicks 'More News'")
 set(Launcher_HELP_URL "https://prismlauncher.org/wiki/help-pages/%1" CACHE STRING "URL (with arg %1 to be substituted with page-id) that gets opened when the user requests help")
+set(Launcher_LOGIN_CALLBACK_URL "https://prismlauncher.org/successful-login" CACHE STRING "URL that gets opened when the user successfully logins.")
+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 8)
+set(Launcher_VERSION_MAJOR 10)
 set(Launcher_VERSION_MINOR 0)
+set(Launcher_VERSION_PATCH 2)
 
-set(Launcher_VERSION_NAME "${Launcher_VERSION_MAJOR}.${Launcher_VERSION_MINOR}")
-set(Launcher_VERSION_NAME4 "${Launcher_VERSION_MAJOR}.${Launcher_VERSION_MINOR}.0.0")
-set(Launcher_VERSION_NAME4_COMMA "${Launcher_VERSION_MAJOR},${Launcher_VERSION_MINOR},0,0")
+set(Launcher_VERSION_NAME "${Launcher_VERSION_MAJOR}.${Launcher_VERSION_MINOR}.${Launcher_VERSION_PATCH}")
+set(Launcher_VERSION_NAME4 "${Launcher_VERSION_MAJOR}.${Launcher_VERSION_MINOR}.${Launcher_VERSION_PATCH}.0")
+set(Launcher_VERSION_NAME4_COMMA "${Launcher_VERSION_MAJOR},${Launcher_VERSION_MINOR},${Launcher_VERSION_PATCH},0")
 
 # Build platform.
 set(Launcher_BUILD_PLATFORM "unknown" CACHE STRING "A short string identifying the platform that this build was built for. Only used to display in the about dialog.")
@@ -205,6 +202,7 @@ set(Launcher_BUG_TRACKER_URL "https://github.com/PrismLauncher/PrismLauncher/iss
 
 # Translations Platform URL
 set(Launcher_TRANSLATIONS_URL "https://hosted.weblate.org/projects/prismlauncher/launcher/" CACHE STRING "URL for the translations platform.")
+set(Launcher_TRANSLATION_FILES_URL "https://i18n.prismlauncher.org/" CACHE STRING "URL for the translations files.")
 
 # Matrix Space
 set(Launcher_MATRIX_URL "https://prismlauncher.org/matrix" CACHE STRING "URL to the Matrix Space")
@@ -216,9 +214,23 @@ set(Launcher_DISCORD_URL "https://prismlauncher.org/discord" CACHE STRING "URL f
 set(Launcher_SUBREDDIT_URL "https://prismlauncher.org/reddit" CACHE STRING "URL for the subreddit.")
 
 # Builds
-set(Launcher_FORCE_BUNDLED_LIBS OFF CACHE BOOL "Prevent using system libraries, if they are available as submodules")
 set(Launcher_QT_VERSION_MAJOR "6" CACHE STRING "Major Qt version to build against")
 
+option(Launcher_USE_PCH "Use precompiled headers where possible" ON)
+
+# Java downloader
+set(Launcher_ENABLE_JAVA_DOWNLOADER_DEFAULT ON)
+
+# Although we recommend enabling this, we cannot guarantee binary compatibility on
+# differing Linux/BSD/etc distributions. Downstream packagers should be explicitly opt-ing into this
+# feature if they know it will work with their distribution.
+if(UNIX AND NOT APPLE)
+    set(Launcher_ENABLE_JAVA_DOWNLOADER_DEFAULT OFF)
+endif()
+
+# Java downloader
+option(Launcher_ENABLE_JAVA_DOWNLOADER "Build the java downloader feature" ${Launcher_ENABLE_JAVA_DOWNLOADER_DEFAULT})
+
 # Native libraries
 if(UNIX AND APPLE)
     set(Launcher_GLFW_LIBRARY_NAME "libglfw.dylib" CACHE STRING "Name of native glfw library")
@@ -268,75 +280,59 @@ set(Launcher_BUILD_TIMESTAMP "${TODAY}")
 
 ################################ 3rd Party Libs ################################
 
-# Successive configurations of cmake without cleaning the build dir will cause zlib fallback to fail due to cached values
-# Record when fallback triggered and skip this find_package
-if(NOT Launcher_FORCE_BUNDLED_LIBS AND NOT FORCE_BUNDLED_ZLIB)
-    find_package(ZLIB QUIET)
-endif()
-if(NOT ZLIB_FOUND)
-    set(FORCE_BUNDLED_ZLIB TRUE CACHE BOOL "")
-    mark_as_advanced(FORCE_BUNDLED_ZLIB)
-endif()
-
 # Find the required Qt parts
-include(QtVersionlessBackport)
-if(Launcher_QT_VERSION_MAJOR EQUAL 5)
-    set(QT_VERSION_MAJOR 5)
-    find_package(Qt5 REQUIRED COMPONENTS Core Widgets Concurrent Network Test Xml)
-
-    if(NOT Launcher_FORCE_BUNDLED_LIBS)
-        find_package(QuaZip-Qt5 1.3 QUIET)
-    endif()
-    if (NOT QuaZip-Qt5_FOUND)
-        set(QUAZIP_QT_MAJOR_VERSION ${QT_VERSION_MAJOR} CACHE STRING "Qt version to use (4, 5 or 6), defaults to ${QT_VERSION_MAJOR}" FORCE)
-        set(FORCE_BUNDLED_QUAZIP 1)
-    endif()
-
-    # Qt 6 sets these by default. Notably causes Windows APIs to use UNICODE strings.
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUNICODE -D_UNICODE")
-elseif(Launcher_QT_VERSION_MAJOR EQUAL 6)
+if(Launcher_QT_VERSION_MAJOR EQUAL 6)
     set(QT_VERSION_MAJOR 6)
-    find_package(Qt6 REQUIRED COMPONENTS Core CoreTools Widgets Concurrent Network Test Xml Core5Compat)
-    list(APPEND Launcher_QT_LIBS Qt6::Core5Compat)
-
-    if(NOT Launcher_FORCE_BUNDLED_LIBS)
-        find_package(QuaZip-Qt6 1.3 QUIET)
-    endif()
-    if (NOT QuaZip-Qt6_FOUND)
-        set(QUAZIP_QT_MAJOR_VERSION ${QT_VERSION_MAJOR} CACHE STRING "Qt version to use (4, 5 or 6), defaults to ${QT_VERSION_MAJOR}" FORCE)
-        set(FORCE_BUNDLED_QUAZIP 1)
-    endif()
+    find_package(Qt6 REQUIRED COMPONENTS Core CoreTools Widgets Concurrent Network Test Xml NetworkAuth OpenGL)
+    find_package(Qt6 COMPONENTS DBus)
+    list(APPEND Launcher_QT_DBUS Qt6::DBus)
 else()
     message(FATAL_ERROR "Qt version ${Launcher_QT_VERSION_MAJOR} is not supported")
 endif()
 
-if(Launcher_QT_VERSION_MAJOR EQUAL 5)
-    include(ECMQueryQt)
-    ecm_query_qt(QT_PLUGINS_DIR  QT_INSTALL_PLUGINS)
-    ecm_query_qt(QT_LIBS_DIR     QT_INSTALL_LIBS)
-    ecm_query_qt(QT_LIBEXECS_DIR QT_INSTALL_LIBEXECS)
-else()
+if(Launcher_QT_VERSION_MAJOR EQUAL 6)
     set(QT_PLUGINS_DIR  ${QT${QT_VERSION_MAJOR}_INSTALL_PREFIX}/${QT${QT_VERSION_MAJOR}_INSTALL_PLUGINS})
     set(QT_LIBS_DIR     ${QT${QT_VERSION_MAJOR}_INSTALL_PREFIX}/${QT${QT_VERSION_MAJOR}_INSTALL_LIBS})
     set(QT_LIBEXECS_DIR ${QT${QT_VERSION_MAJOR}_INSTALL_PREFIX}/${QT${QT_VERSION_MAJOR}_INSTALL_LIBEXECS})
 endif()
 
-# NOTE: Qt 6 already sets this by default
-if (Qt5_POSITION_INDEPENDENT_CODE)
-    SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
+find_package(cmark REQUIRED)
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(gamemode REQUIRED IMPORTED_TARGET gamemode)
 endif()
 
-if(NOT Launcher_FORCE_BUNDLED_LIBS)
-    # Find toml++
-    find_package(tomlplusplus 3.2.0 QUIET)
-
-    # Find ghc_filesystem
-    find_package(ghc_filesystem QUIET)
-
-    # Find cmark
-    find_package(cmark QUIET)
+# Find libqrencode
+## NOTE(@getchoo): Never use pkg-config with MSVC since the vcpkg port makes our install bundle fail to find the dll
+if(MSVC)
+    find_path(LIBQRENCODE_INCLUDE_DIR qrencode.h REQUIRED)
+    find_library(LIBQRENCODE_LIBRARY_RELEASE qrencode REQUIRED)
+    find_library(LIBQRENCODE_LIBRARY_DEBUG qrencoded)
+    set(LIBQRENCODE_LIBRARIES optimized ${LIBQRENCODE_LIBRARY_RELEASE} debug ${LIBQRENCODE_LIBRARY_DEBUG})
+else()
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(libqrencode REQUIRED IMPORTED_TARGET libqrencode)
 endif()
 
+# Find libarchive through CMake packages, mainly for vcpkg
+find_package(LibArchive)
+# CMake packages aren't available in most distributions of libarchive, so fallback to pkg-config
+if(NOT LibArchive_FOUND)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(libarchive REQUIRED IMPORTED_TARGET libarchive)
+endif()
+
+find_package(tomlplusplus 3.2.0)
+# fallback to pkgconfig, important especially as many distros package toml++ built with meson
+if(NOT tomlplusplus_FOUND)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(tomlplusplus REQUIRED IMPORTED_TARGET tomlplusplus>=3.2.0)
+endif()
+
+find_package(ZLIB REQUIRED)
+
+
 include(ECMQtDeclareLoggingCategory)
 
 ####################################### Program Info #######################################
@@ -350,7 +346,7 @@ set(Launcher_ENABLE_UPDATER NO)
 set(Launcher_BUILD_UPDATER NO)
 
 if (NOT APPLE AND (NOT Launcher_UPDATER_GITHUB_REPO STREQUAL "" AND NOT Launcher_BUILD_ARTIFACT STREQUAL ""))
-	set(Launcher_BUILD_UPDATER YES)
+    set(Launcher_BUILD_UPDATER YES)
 endif()
 
 if(NOT (UNIX AND APPLE))
@@ -366,38 +362,75 @@ if(UNIX AND APPLE)
     set(RESOURCES_DEST_DIR "${Launcher_Name}.app/Contents/Resources")
     set(JARS_DEST_DIR "${Launcher_Name}.app/Contents/MacOS/jars")
 
-    # Apps to bundle
-    set(APPS "\${CMAKE_INSTALL_PREFIX}/${Launcher_Name}.app")
-
     # Mac bundle settings
     set(MACOSX_BUNDLE_BUNDLE_NAME "${Launcher_DisplayName}")
     set(MACOSX_BUNDLE_INFO_STRING "${Launcher_DisplayName}: A custom launcher for Minecraft that allows you to easily manage multiple installations of Minecraft at once.")
-    set(MACOSX_BUNDLE_GUI_IDENTIFIER "org.prismlauncher.${Launcher_Name}")
+    set(MACOSX_BUNDLE_GUI_IDENTIFIER "${Launcher_AppID}")
     set(MACOSX_BUNDLE_BUNDLE_VERSION "${Launcher_VERSION_NAME}")
     set(MACOSX_BUNDLE_SHORT_VERSION_STRING "${Launcher_VERSION_NAME}")
     set(MACOSX_BUNDLE_LONG_VERSION_STRING "${Launcher_VERSION_NAME}")
     set(MACOSX_BUNDLE_ICON_FILE ${Launcher_Name}.icns)
-    set(MACOSX_BUNDLE_COPYRIGHT "© 2022-2023 ${Launcher_Copyright_Mac}")
+    set(MACOSX_BUNDLE_COPYRIGHT "${Launcher_Copyright_Mac}")
     set(MACOSX_SPARKLE_UPDATE_PUBLIC_KEY "v55ZWWD6QlPoXGV6VLzOTZxZUggWeE51X8cRQyQh6vA=" CACHE STRING "Public key for Sparkle update feed")
     set(MACOSX_SPARKLE_UPDATE_FEED_URL "https://prismlauncher.org/feed/appcast.xml" CACHE STRING "URL for Sparkle update feed")
 
-    set(MACOSX_SPARKLE_DOWNLOAD_URL "https://github.com/sparkle-project/Sparkle/releases/download/2.1.0/Sparkle-2.1.0.tar.xz" CACHE STRING "URL to Sparkle release archive")
-    set(MACOSX_SPARKLE_SHA256 "bf6ac1caa9f8d321d5784859c88da874f28412f37fb327bc21b7b14c5d61ef94" CACHE STRING "SHA256 checksum for Sparkle release archive")
+    set(MACOSX_SPARKLE_DOWNLOAD_URL "https://github.com/sparkle-project/Sparkle/releases/download/2.8.0/Sparkle-2.8.0.tar.xz" CACHE STRING "URL to Sparkle release archive")
+    set(MACOSX_SPARKLE_SHA256 "fd5681ee92bf238aaac2d08214ceaf0cc8976e452d7f882d80bac1e61581f3b1" CACHE STRING "SHA256 checksum for Sparkle release archive")
     set(MACOSX_SPARKLE_DIR "${CMAKE_BINARY_DIR}/frameworks/Sparkle")
 
-    # directories to look for dependencies
-    set(DIRS ${QT_LIBS_DIR} ${QT_LIBEXECS_DIR} ${CMAKE_LIBRARY_OUTPUT_DIRECTORY} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} ${MACOSX_SPARKLE_DIR})
-
     if(NOT MACOSX_SPARKLE_UPDATE_PUBLIC_KEY STREQUAL "" AND NOT MACOSX_SPARKLE_UPDATE_FEED_URL STREQUAL "")
         set(Launcher_ENABLE_UPDATER YES)
     endif()
 
-    # install as bundle
-    set(INSTALL_BUNDLE "full" CACHE STRING "Use fixup_bundle to bundle dependencies")
-
     # Add the icon
     install(FILES ${Launcher_Branding_ICNS} DESTINATION ${RESOURCES_DEST_DIR} RENAME ${Launcher_Name}.icns)
 
+    find_program(ACTOOL_EXE actool DOC "Path to the apple asset catalog compiler")
+    if(ACTOOL_EXE)
+        execute_process(
+            COMMAND xcodebuild -version
+            OUTPUT_VARIABLE XCODE_VERSION_OUTPUT
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+
+        string(REGEX MATCH "Xcode ([0-9]+\.[0-9]+)" XCODE_VERSION_MATCH "${XCODE_VERSION_OUTPUT}")
+        if(XCODE_VERSION_MATCH)
+            set(XCODE_VERSION ${CMAKE_MATCH_1})
+        else()
+            set(XCODE_VERSION 0.0)
+        endif()
+
+        if(XCODE_VERSION VERSION_GREATER_EQUAL 26.0)
+            set(ASSETS_OUT_DIR "${CMAKE_BINARY_DIR}/program_info")
+            set(GENERATED_ASSETS_CAR "${ASSETS_OUT_DIR}/Assets.car")
+            set(ICON_SOURCE "${CMAKE_CURRENT_SOURCE_DIR}/${Launcher_Branding_MAC_ICON}")
+
+            add_custom_command(
+                OUTPUT "${GENERATED_ASSETS_CAR}"
+                COMMAND ${ACTOOL_EXE} "${ICON_SOURCE}"
+                        --compile "${ASSETS_OUT_DIR}"
+                        --output-partial-info-plist /dev/null
+                        --app-icon PrismLauncher
+                        --enable-on-demand-resources NO
+                        --target-device mac
+                        --minimum-deployment-target ${CMAKE_OSX_DEPLOYMENT_TARGET}
+                        --platform macosx
+                DEPENDS "${ICON_SOURCE}"
+                COMMENT "Compiling asset catalog (${ICON_SOURCE})"
+                VERBATIM
+            )
+            add_custom_target(compile_assets ALL DEPENDS "${GENERATED_ASSETS_CAR}")
+            install(FILES "${GENERATED_ASSETS_CAR}" DESTINATION "${RESOURCES_DEST_DIR}")
+        else()
+            message(WARNING "Xcode ${XCODE_VERSION} is too old. Minimum required version is 26.0. Not compiling liquid glass icons.")
+        endif()
+
+    else()
+        message(WARNING "actool not found. Cannot compile macOS app icons.\n"
+                "Install Xcode command line tools: 'xcode-select --install'")
+    endif()
+
+
 elseif(UNIX)
     include(KDEInstallDirs)
 
@@ -405,19 +438,21 @@ elseif(UNIX)
     set(LIBRARY_DEST_DIR "lib${LIB_SUFFIX}")
     set(JARS_DEST_DIR "share/${Launcher_Name}")
 
-    # install as bundle with no dependencies included
-    set(INSTALL_BUNDLE "nodeps" CACHE STRING "Use fixup_bundle to bundle dependencies")
-
     # Set RPATH
     SET(Launcher_BINARY_RPATH "$ORIGIN/")
 
     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${Launcher_Desktop} DESTINATION ${KDE_INSTALL_APPDIR})
     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${Launcher_MetaInfo} DESTINATION ${KDE_INSTALL_METAINFODIR})
     install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${Launcher_SVG} DESTINATION "${KDE_INSTALL_ICONDIR}/hicolor/scalable/apps")
+    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${Launcher_PNG_256} DESTINATION "${KDE_INSTALL_ICONDIR}/hicolor/256x256/apps" RENAME "${Launcher_AppID}.png")
     install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${Launcher_mrpack_MIMEInfo} DESTINATION ${KDE_INSTALL_MIMEDIR})
 
     install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/launcher/qtlogging.ini" DESTINATION "share/${Launcher_Name}")
-    
+
+    set(PLUGIN_DEST_DIR "plugins")
+    set(BUNDLE_DEST_DIR ".")
+    set(RESOURCES_DEST_DIR ".")
+
     if(Launcher_ManPage)
         install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${Launcher_ManPage} DESTINATION "${KDE_INSTALL_MANDIR}/man6")
     endif()
@@ -432,15 +467,6 @@ elseif(WIN32)
     set(PLUGIN_DEST_DIR ".")
     set(RESOURCES_DEST_DIR ".")
     set(JARS_DEST_DIR "jars")
-
-    # Apps to bundle
-    set(APPS "\${CMAKE_INSTALL_PREFIX}/${Launcher_Name}.exe")
-
-    # directories to look for dependencies
-    set(DIRS ${QT_LIBS_DIR} ${QT_LIBEXECS_DIR} ${CMAKE_LIBRARY_OUTPUT_DIRECTORY} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
-
-    # install as bundle
-    set(INSTALL_BUNDLE "full" CACHE STRING "Use fixup_bundle to bundle dependencies")
 else()
     message(FATAL_ERROR "Platform not supported")
 endif()
@@ -460,67 +486,10 @@ add_subdirectory(libraries/libnbtplusplus)
 add_subdirectory(libraries/systeminfo) # system information library
 add_subdirectory(libraries/launcher) # java based launcher part for Minecraft
 add_subdirectory(libraries/javacheck) # java compatibility checker
-if(FORCE_BUNDLED_ZLIB)
-    message(STATUS "Using bundled zlib")
 
-    set(CMAKE_POLICY_DEFAULT_CMP0069 NEW) # Suppress cmake warnings and allow INTERPROCEDURAL_OPTIMIZATION for zlib
-    set(SKIP_INSTALL_ALL ON)
-    add_subdirectory(libraries/zlib EXCLUDE_FROM_ALL)
-
-    # On OS where unistd.h exists, zlib's generated header defines `Z_HAVE_UNISTD_H`, while the included header does not. 
-    # We cannot safely undo the rename on those systems, and they generally have packages for zlib anyway.
-    check_include_file(unistd.h NEED_GENERATED_ZCONF)
-    if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/libraries/zlib/zconf.h.included" AND NOT NEED_GENERATED_ZCONF)
-        # zlib's cmake script renames a file, dirtying the submodule, see https://github.com/madler/zlib/issues/162
-        message(STATUS "Undoing Rename")
-        message(STATUS "    ${CMAKE_CURRENT_SOURCE_DIR}/libraries/zlib/zconf.h")
-        file(RENAME "${CMAKE_CURRENT_SOURCE_DIR}/libraries/zlib/zconf.h.included" "${CMAKE_CURRENT_SOURCE_DIR}/libraries/zlib/zconf.h")
-    endif()
-
-    set(ZLIB_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/libraries/zlib" "${CMAKE_CURRENT_SOURCE_DIR}/libraries/zlib" CACHE STRING "" FORCE)
-    set_target_properties(zlibstatic PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${ZLIB_INCLUDE_DIR}")
-    add_library(ZLIB::ZLIB ALIAS zlibstatic)
-    set(ZLIB_LIBRARY ZLIB::ZLIB CACHE STRING "zlib library name")
-
-    find_package(ZLIB REQUIRED)
-else()
-    message(STATUS "Using system zlib")
-endif()
-if (FORCE_BUNDLED_QUAZIP)
-    message(STATUS "Using bundled QuaZip")
-    set(BUILD_SHARED_LIBS 0)  # link statically to avoid conflicts.
-    set(QUAZIP_INSTALL 0)
-    add_subdirectory(libraries/quazip) # zip manipulation library
-else()
-    message(STATUS "Using system QuaZip")
-endif()
 add_subdirectory(libraries/rainbow) # Qt extension for colors
 add_subdirectory(libraries/LocalPeer) # fork of a library from Qt solutions
-if(NOT tomlplusplus_FOUND)
-    message(STATUS "Using bundled tomlplusplus")
-    add_subdirectory(libraries/tomlplusplus) # toml parser
-else()
-    message(STATUS "Using system tomlplusplus")
-endif()
-if(NOT cmark_FOUND)
-    message(STATUS "Using bundled cmark")
-    set(CMARK_STATIC ON CACHE BOOL "Build static libcmark library" FORCE)
-    set(CMARK_SHARED OFF CACHE BOOL "Build shared libcmark library" FORCE)
-    set(CMARK_TESTS OFF CACHE BOOL "Build cmark tests and enable testing" FORCE)
-    add_subdirectory(libraries/cmark EXCLUDE_FROM_ALL) # Markdown parser
-    add_library(cmark::cmark ALIAS cmark_static)
-else()
-    message(STATUS "Using system cmark")
-endif()
-add_subdirectory(libraries/katabasis) # An OAuth2 library that tried to do too much
-add_subdirectory(libraries/gamemode)
 add_subdirectory(libraries/murmur2) # Hash for usage with the CurseForge API
-if (NOT ghc_filesystem_FOUND)
-    message(STATUS "Using bundled ghc_filesystem")
-    add_subdirectory(libraries/filesystem) # Implementation of std::filesystem for old C++, for usage in old macOS
-else()
-    message(STATUS "Using system ghc_filesystem")
-endif()
 add_subdirectory(libraries/qdcss) # css parser
 
 ############################### Built Artifacts ###############################

CMakePresets.json

@@ -0,0 +1,221 @@
+{
+    "$schema": "https://cmake.org/cmake/help/latest/_downloads/3e2d73bff478d88a7de0de736ba5e361/schema.json",
+    "version": 8,
+    "cmakeMinimumRequired": {
+        "major": 3,
+        "minor": 28
+    },
+    "configurePresets": [
+        {
+            "name": "base",
+            "hidden": true,
+            "binaryDir": "build",
+            "installDir": "install",
+            "generator": "Ninja Multi-Config",
+            "cacheVariables": {
+                "Launcher_BUILD_ARTIFACT": "$penv{ARTIFACT_NAME}",
+                "Launcher_BUILD_PLATFORM": "$penv{BUILD_PLATFORM}",
+                "Launcher_ENABLE_JAVA_DOWNLOADER": "ON",
+                "ENABLE_LTO": "ON"
+            }
+        },
+        {
+            "name": "linux",
+            "displayName": "Linux",
+            "inherits": [
+                "base"
+            ],
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Linux"
+            }
+        },
+        {
+            "name": "macos",
+            "displayName": "macOS",
+            "inherits": [
+                "base"
+            ],
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Darwin"
+            },
+            "cacheVariables": {
+                "CMAKE_TOOLCHAIN_FILE": "$penv{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
+            }
+        },
+        {
+            "name": "macos_universal",
+            "displayName": "macOS (Universal Binary)",
+            "inherits": [
+                "macos"
+            ],
+            "cacheVariables": {
+                "CMAKE_TOOLCHAIN_FILE": "$penv{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
+                "CMAKE_OSX_ARCHITECTURES": "x86_64;arm64",
+                "VCPKG_TARGET_TRIPLET": "universal-osx"
+            }
+        },
+        {
+            "name": "windows_mingw",
+            "displayName": "Windows (MinGW)",
+            "inherits": [
+                "base"
+            ],
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Windows"
+            }
+        },
+        {
+            "name": "windows_msvc",
+            "displayName": "Windows (MSVC)",
+            "inherits": [
+                "base"
+            ],
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Windows"
+            },
+            "cacheVariables": {
+                "CMAKE_TOOLCHAIN_FILE": "$penv{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
+            }
+        }
+    ],
+    "buildPresets": [
+        {
+            "name": "linux",
+            "displayName": "Linux",
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Linux"
+            },
+            "configurePreset": "linux"
+        },
+        {
+            "name": "macos",
+            "displayName": "macOS",
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Darwin"
+            },
+      "configurePreset": "macos"
+        },
+        {
+            "name": "macos_universal",
+            "displayName": "macOS (Universal Binary)",
+            "inherits": [
+                "macos"
+            ],
+            "configurePreset": "macos_universal"
+        },
+        {
+            "name": "windows_mingw",
+            "displayName": "Windows (MinGW)",
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Windows"
+            },
+            "configurePreset": "windows_mingw"
+        },
+        {
+            "name": "windows_msvc",
+            "displayName": "Windows (MSVC)",
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Windows"
+            },
+            "configurePreset": "windows_msvc"
+        }
+    ],
+    "testPresets": [
+        {
+            "name": "base",
+            "hidden": true,
+            "output": {
+                "outputOnFailure": true
+            },
+            "execution": {
+                "noTestsAction": "error"
+            },
+            "filter": {
+                "exclude": {
+                    "name": "^example64|example$"
+                }
+            }
+        },
+      {
+          "name": "linux",
+            "displayName": "Linux",
+            "inherits": [
+              "base"
+            ],
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Linux"
+            },
+            "configurePreset": "linux"
+        },
+      {
+          "name": "macos",
+            "displayName": "macOS",
+            "inherits": [
+              "base"
+            ],
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Darwin"
+            },
+            "configurePreset": "macos"
+        },
+      {
+          "name": "macos_universal",
+            "displayName": "macOS (Universal Binary)",
+            "inherits": [
+              "base"
+            ],
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Darwin"
+            },
+            "configurePreset": "macos_universal"
+        },
+      {
+          "name": "windows_mingw",
+            "displayName": "Windows (MinGW)",
+            "inherits": [
+              "base"
+            ],
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Windows"
+            },
+            "configurePreset": "windows_mingw"
+        },
+      {
+          "name": "windows_msvc",
+            "displayName": "Windows (MSVC)",
+            "inherits": [
+              "base"
+            ],
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Windows"
+            },
+            "configurePreset": "windows_msvc"
+        }
+    ]
+}

CONTRIBUTING.md

@@ -1,17 +1,66 @@
 # Contributions Guidelines
 
-## Code formatting
+## Code style
 
-Try to follow the existing formatting.
-If there is no existing formatting, you may use `clang-format` with our included `.clang-format` configuration.
+All files are formatted with `clang-format` using the configuration in `.clang-format`. Ensure it is run on changed files before committing!
 
-In general, in order of importance:
+Please also follow the project's conventions for C++:
 
-- Make sure your IDE is not messing up line endings or whitespace and avoid using linters.
-- Prefer readability over dogma.
-- Keep to the existing formatting.
-- Indent with 4 space unless it's in a submodule.
-- Keep lists (of arguments, parameters, initializers...) as lists, not paragraphs. It should either read from top to bottom, or left to right. Not both.
+- Class and type names should be formatted as `PascalCase`: `MyClass`.
+- Private or protected class data members should be formatted as `camelCase` prefixed with `m_`: `m_myCounter`.
+- Private or protected `static` class data members should be formatted as `camelCase` prefixed with `s_`: `s_instance`.
+- Public class data members should be formatted as `camelCase` without the prefix: `dateOfBirth`.
+- Public, private or protected `static const` class data members should be formatted as `SCREAMING_SNAKE_CASE`: `MAX_VALUE`.
+- Class function members should be formatted as `camelCase` without a prefix: `incrementCounter`.
+- Global functions and non-`const` global variables should be formatted as `camelCase` without a prefix: `globalData`.
+- `const` global variables and macros should be formatted as `SCREAMING_SNAKE_CASE`: `LIGHT_GRAY`.
+- enum constants should be formatted as `PascalCase`: `CamelusBactrianus`
+- Avoid inventing acronyms or abbreviations especially for a name of multiple words - like `tp` for `texturePack`.
+- Avoid using `[[nodiscard]]` unless ignoring the return value is likely to cause a bug in cases such as:
+  - A function allocates memory or another resource and the caller needs to clean it up.
+  - A function has side effects and an error status is returned.
+  - A function is likely be mistaken for having side effects.
+- A plain getter is unlikely to cause confusion and adding `[[nodiscard]]` can create clutter and inconsistency.
+
+Most of these rules are included in the `.clang-tidy` file, so you can run `clang-tidy` to check for any violations.
+
+Here is what these conventions with the formatting configuration look like:
+
+```c++
+#define AWESOMENESS 10
+
+constexpr double PI = 3.14159;
+
+enum class PizzaToppings { HamAndPineapple, OreoAndKetchup };
+
+struct Person {
+    QString name;
+    QDateTime dateOfBirth;
+
+    long daysOld() const { return dateOfBirth.daysTo(QDateTime::currentDateTime()); }
+};
+
+class ImportantClass {
+   public:
+    void incrementCounter()
+    {
+        if (m_counter + 1 > MAX_COUNTER_VALUE)
+            throw std::runtime_error("Counter has reached limit!");
+
+        ++m_counter;
+    }
+
+    int counter() const { return m_counter; }
+
+   private:
+    static constexpr int MAX_COUNTER_VALUE = 100;
+    int m_counter;
+};
+
+ImportantClass importantClassInstance;
+```
+
+If you see any names which do not follow these conventions, it is preferred that you leave them be - renames increase the number of changes therefore make reviewing harder and make your PR more prone to conflicts. However, if you're refactoring a whole class anyway, it's fine.
 
 ## Signing your work
 

COPYING.md

@@ -1,7 +1,7 @@
 ## Prism Launcher
 
      Prism Launcher - Minecraft Launcher
-     Copyright (C) 2022-2023 Prism Launcher Contributors
+     Copyright (C) 2022-2026 Prism Launcher Contributors
 
      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
@@ -108,7 +108,7 @@
 
     Information on third party licenses used in MinGW-w64 can be found in its COPYING.MinGW-w64-runtime.txt.
 
-## Qt 5/6
+## Qt 6
 
     Copyright (C) 2022 The Qt Company Ltd and other contributors.
     Contact: https://www.qt.io/licensing
@@ -212,30 +212,6 @@
     This license is copied below, and is also available with a FAQ at:
     http://scripts.sil.org/OFL
 
-## Quazip
-
-    Copyright (C) 2005-2021 Sergey A. Tachenov
-
-    The QuaZip library is licensed under the GNU Lesser General Public
-    License V2.1 plus a static linking exception.
-
-    The original ZIP/UNZIP package (MiniZip) is copyrighted by Gilles
-    Vollant and contributors, see quazip/(un)zip.h files for details.
-    Basically it's the zlib license.
-
-    STATIC LINKING EXCEPTION
-
-    The copyright holders give you permission to link this library with
-    independent modules to produce an executable, regardless of the license
-    terms of these independent modules, and to copy and distribute the
-    resulting executable under terms of your choice, provided that you also
-    meet, for each linked independent module, the terms and conditions of
-    the license of that module. An independent module is a module which is
-    not derived from or based on this library. If you modify this library,
-    you must extend this exception to your version of the library.
-
-    See COPYING file for the full LGPL text.
-
 ## launcher (`libraries/launcher`)
 
      PolyMC - Minecraft Launcher
@@ -333,32 +309,6 @@
     COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
     OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-## O2 (Katabasis fork)
-
-    Copyright (c) 2012, Akos Polster
-    All rights reserved.
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
 ## Gamemode
 
     Copyright (c) 2017-2022, Feral Interactive
@@ -388,28 +338,6 @@
     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     POSSIBILITY OF SUCH DAMAGE.
 
-## gulrak/filesystem
-
-    Copyright (c) 2018, Steffen Schümann <s.schuemann@pobox.com>
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE.
-
 ## Breeze icons
 
     Copyright (C) 2014 Uri Herrera <uri_herrera@nitrux.in> and others
@@ -436,7 +364,7 @@
         Copyright (C) 2007 Johann Ollivier Lapeyre <johann@oxygen-icons.org>
         Copyright (C) 2007 Kenneth Wimer <kwwii@bootsplash.org>
         Copyright (C) 2007 Riccardo Iaconelli <riccardo@oxygen-icons.org>
-    
+
     and others
 
     This library is free software; you can redistribute it and/or
@@ -451,3 +379,44 @@
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library. If not, see <http://www.gnu.org/licenses/>.
+
+## libqrencode (`fukuchi/libqrencode`)
+
+    Copyright (C) 2020 libqrencode Authors
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+## vcpkg (`cmake/vcpkg-ports`)
+
+    MIT License
+    
+    Copyright (c) Microsoft Corporation
+    
+    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+    software and associated documentation files (the "Software"), to deal in the Software
+    without restriction, including without limitation the rights to use, copy, modify,
+    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to the following
+    conditions:
+    
+    The above copyright notice and this permission notice shall be included in all copies
+    or substantial portions of the Software.
+    
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+    OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -26,8 +26,8 @@ Please understand that these builds are not intended for most users. There may b
 
 There are development builds available through:
 
-- [GitHub Actions](https://github.com/PrismLauncher/PrismLauncher/actions) (includes builds from pull requests opened by contribuitors)
-- [nightly.link](https://nightly.link/PrismLauncher/PrismLauncher/workflows/trigger_builds/develop) (this will always point only to the latest version of develop)
+- [GitHub Actions](https://github.com/PrismLauncher/PrismLauncher/actions) (includes builds from pull requests opened by contributors)
+- [nightly.link](https://nightly.link/PrismLauncher/PrismLauncher/workflows/build/develop) (this will always point only to the latest version of develop)
 
 These have debug information in the binaries, so their file sizes are relatively larger.
 
@@ -35,7 +35,7 @@ Prebuilt Development builds are provided for **Linux**, **Windows** and **macOS*
 
 For **Arch**, **Debian**, **Fedora**, **OpenSUSE (Tumbleweed)** and **Gentoo**, respectively, you can use these packages for the latest development versions:
 
-[![prismlauncher-git](https://img.shields.io/badge/aur-prismlauncher--git-1793D1?label=AUR&logo=archlinux&logoColor=white)](https://aur.archlinux.org/packages/prismlauncher-git) [![prismlauncher-git](https://img.shields.io/badge/aur-prismlauncher--qt5--git-1793D1?label=AUR&logo=archlinux&logoColor=white)](https://aur.archlinux.org/packages/prismlauncher-qt5-git) [![prismlauncher-git](https://img.shields.io/badge/mpr-prismlauncher--git-A80030?label=MPR&logo=debian&logoColor=white)](https://mpr.makedeb.org/packages/prismlauncher-git)<br />[![prismlauncher-nightly](https://img.shields.io/badge/copr-prismlauncher--nightly-51A2DA?label=COPR&logo=fedora&logoColor=white)](https://copr.fedorainfracloud.org/coprs/g3tchoo/prismlauncher/) [![prismlauncher-nightly](https://img.shields.io/badge/OBS-prismlauncher--nightly-3AB6A9?logo=opensuse&logoColor=white)](https://build.opensuse.org/project/show/home:getchoo) [![prismlauncher-9999](https://img.shields.io/badge/gentoo-prismlauncher--9999-4D4270?label=Gentoo&logo=gentoo&logoColor=white)](https://packages.gentoo.org/packages/games-action/prismlauncher)
+[![prismlauncher-git](https://img.shields.io/badge/aur-prismlauncher--git-1793D1?label=AUR&logo=archlinux&logoColor=white)](https://aur.archlinux.org/packages/prismlauncher-git) [![prismlauncher-git](https://img.shields.io/badge/mpr-prismlauncher--git-A80030?label=MPR&logo=debian&logoColor=white)](https://mpr.makedeb.org/packages/prismlauncher-git)<br />[![prismlauncher-nightly](https://img.shields.io/badge/copr-prismlauncher--nightly-51A2DA?label=COPR&logo=fedora&logoColor=white)](https://copr.fedorainfracloud.org/coprs/g3tchoo/prismlauncher/) [![prismlauncher-nightly](https://img.shields.io/badge/OBS-prismlauncher--nightly-3AB6A9?logo=opensuse&logoColor=white)](https://build.opensuse.org/project/show/home:getchoo) [![prismlauncher-9999](https://img.shields.io/badge/gentoo-prismlauncher--9999-4D4270?label=Gentoo&logo=gentoo&logoColor=white)](https://packages.gentoo.org/packages/games-action/prismlauncher)
 
 These packages are also available to all the distributions based on the ones mentioned above.
 
@@ -61,7 +61,7 @@ The translation effort for Prism Launcher is hosted on [Weblate](https://hosted.
 
 ## Building
 
-If you want to build Prism Launcher yourself, check the [Build Instructions](https://prismlauncher.org/wiki/development/build-instructions/).
+If you want to build Prism Launcher yourself, check the [build instructions](https://prismlauncher.org/wiki/development/build-instructions).
 
 ## Sponsors & Partners
 
@@ -71,7 +71,13 @@ We thank all the wonderful backers over at Open Collective! Support Prism Launch
 
 Thanks to JetBrains for providing us a few licenses for all their products, as part of their [Open Source program](https://www.jetbrains.com/opensource/).
 
-[![JetBrains](https://resources.jetbrains.com/storage/products/company/brand/logos/jb_beam.svg)](https://www.jetbrains.com/opensource/)
+<a href="https://jb.gg/OpenSource">
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://www.jetbrains.com/company/brand/img/logo_jb_dos_4.svg">
+  <source media="(prefers-color-scheme: light)" srcset="https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.svg">
+  <img alt="JetBrains logo" src="https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.svg" width="40%">
+</picture>
+</a>
 
 Thanks to Weblate for hosting our translation efforts.
 

buildconfig/BuildConfig.cpp.in

@@ -33,9 +33,8 @@
  *      limitations under the License.
  */
 
-#include <qstringliteral.h>
-#include "BuildConfig.h"
 #include <QObject>
+#include "BuildConfig.h"
 
 const Config BuildConfig;
 
@@ -49,15 +48,15 @@ Config::Config()
     LAUNCHER_DOMAIN = "@Launcher_Domain@";
     LAUNCHER_CONFIGFILE = "@Launcher_ConfigFile@";
     LAUNCHER_GIT = "@Launcher_Git@";
-    LAUNCHER_DESKTOPFILENAME = "@Launcher_DesktopFileName@";
+    LAUNCHER_APPID = "@Launcher_AppID@";
     LAUNCHER_SVGFILENAME = "@Launcher_SVGFileName@";
 
     USER_AGENT = "@Launcher_UserAgent@";
-    USER_AGENT_UNCACHED = USER_AGENT + " (Uncached)";
 
     // Version information
     VERSION_MAJOR = @Launcher_VERSION_MAJOR@;
     VERSION_MINOR = @Launcher_VERSION_MINOR@;
+    VERSION_PATCH = @Launcher_VERSION_PATCH@;
 
     BUILD_PLATFORM = "@Launcher_BUILD_PLATFORM@";
     BUILD_ARTIFACT = "@Launcher_BUILD_ARTIFACT@";
@@ -74,55 +73,52 @@ Config::Config()
     MAC_SPARKLE_PUB_KEY = "@MACOSX_SPARKLE_UPDATE_PUBLIC_KEY@";
     MAC_SPARKLE_APPCAST_URL = "@MACOSX_SPARKLE_UPDATE_FEED_URL@";
 
-    if (!MAC_SPARKLE_PUB_KEY.isEmpty() && !MAC_SPARKLE_APPCAST_URL.isEmpty())
-    {
+    if (!MAC_SPARKLE_PUB_KEY.isEmpty() && !MAC_SPARKLE_APPCAST_URL.isEmpty()) {
         UPDATER_ENABLED = true;
-    } else if(!UPDATER_GITHUB_REPO.isEmpty() && !BUILD_ARTIFACT.isEmpty()) {
+    } else if (!UPDATER_GITHUB_REPO.isEmpty() && !BUILD_ARTIFACT.isEmpty()) {
         UPDATER_ENABLED = true;
     }
 
+#cmakedefine01 Launcher_ENABLE_JAVA_DOWNLOADER
+    JAVA_DOWNLOADER_ENABLED = Launcher_ENABLE_JAVA_DOWNLOADER;
+
     GIT_COMMIT = "@Launcher_GIT_COMMIT@";
     GIT_TAG = "@Launcher_GIT_TAG@";
     GIT_REFSPEC = "@Launcher_GIT_REFSPEC@";
 
     // Assume that builds outside of Git repos are "stable"
-    if (GIT_REFSPEC == QStringLiteral("GITDIR-NOTFOUND")
-        || GIT_TAG == QStringLiteral("GITDIR-NOTFOUND")
-        || GIT_REFSPEC == QStringLiteral("")
-        || GIT_TAG == QStringLiteral("GIT-NOTFOUND"))
-    {
+    if (GIT_REFSPEC == QStringLiteral("GITDIR-NOTFOUND") || GIT_TAG == QStringLiteral("GITDIR-NOTFOUND") ||
+        GIT_REFSPEC == QStringLiteral("") || GIT_TAG == QStringLiteral("GIT-NOTFOUND")) {
         GIT_REFSPEC = "refs/heads/stable";
         GIT_TAG = versionString();
         GIT_COMMIT = "";
     }
 
-    if (GIT_REFSPEC.startsWith("refs/heads/"))
-    {
+    if (GIT_REFSPEC.startsWith("refs/heads/")) {
         VERSION_CHANNEL = GIT_REFSPEC;
-        VERSION_CHANNEL.remove("refs/heads/"); 
-    }
-    else if (!GIT_COMMIT.isEmpty())
-    {
+        VERSION_CHANNEL.remove("refs/heads/");
+    } else if (!GIT_COMMIT.isEmpty()) {
         VERSION_CHANNEL = GIT_COMMIT.mid(0, 8);
-    }
-    else
-    {
+    } else {
         VERSION_CHANNEL = "unknown";
     }
 
     NEWS_RSS_URL = "@Launcher_NEWS_RSS_URL@";
     NEWS_OPEN_URL = "@Launcher_NEWS_OPEN_URL@";
     HELP_URL = "@Launcher_HELP_URL@";
+    LOGIN_CALLBACK_URL = "@Launcher_LOGIN_CALLBACK_URL@";
     IMGUR_CLIENT_ID = "@Launcher_IMGUR_CLIENT_ID@";
     MSA_CLIENT_ID = "@Launcher_MSA_CLIENT_ID@";
     FLAME_API_KEY = "@Launcher_CURSEFORGE_API_KEY@";
     META_URL = "@Launcher_META_URL@";
+    LEGACY_FMLLIBS_BASE_URL = "@Launcher_LEGACY_FMLLIBS_BASE_URL@";
 
     GLFW_LIBRARY_NAME = "@Launcher_GLFW_LIBRARY_NAME@";
     OPENAL_LIBRARY_NAME = "@Launcher_OPENAL_LIBRARY_NAME@";
 
     BUG_TRACKER_URL = "@Launcher_BUG_TRACKER_URL@";
     TRANSLATIONS_URL = "@Launcher_TRANSLATIONS_URL@";
+    TRANSLATION_FILES_URL = "@Launcher_TRANSLATION_FILES_URL@";
     MATRIX_URL = "@Launcher_MATRIX_URL@";
     DISCORD_URL = "@Launcher_DISCORD_URL@";
     SUBREDDIT_URL = "@Launcher_SUBREDDIT_URL@";
@@ -130,7 +126,7 @@ Config::Config()
 
 QString Config::versionString() const
 {
-    return QString("%1.%2").arg(VERSION_MAJOR).arg(VERSION_MINOR);
+    return QString("%1.%2.%3").arg(VERSION_MAJOR).arg(VERSION_MINOR).arg(VERSION_PATCH);
 }
 
 QString Config::printableVersionString() const
@@ -138,8 +134,7 @@ QString Config::printableVersionString() const
     QString vstr = versionString();
 
     // If the build is not a main release, append the channel
-    if(VERSION_CHANNEL != "stable" && GIT_TAG != vstr)
-    {
+    if (VERSION_CHANNEL != "stable" && GIT_TAG != vstr) {
         vstr += "-" + VERSION_CHANNEL;
     }
     return vstr;
@@ -156,4 +151,3 @@ QString Config::systemID() const
 {
     return QStringLiteral("%1 %2 %3").arg(COMPILER_TARGET_SYSTEM, COMPILER_TARGET_SYSTEM_VERSION, COMPILER_TARGET_SYSTEM_PROCESSOR);
 }
-

buildconfig/BuildConfig.h

@@ -52,13 +52,15 @@ class Config {
     QString LAUNCHER_DOMAIN;
     QString LAUNCHER_CONFIGFILE;
     QString LAUNCHER_GIT;
-    QString LAUNCHER_DESKTOPFILENAME;
+    QString LAUNCHER_APPID;
     QString LAUNCHER_SVGFILENAME;
 
     /// The major version number.
     int VERSION_MAJOR;
     /// The minor version number.
     int VERSION_MINOR;
+    /// The patch version number.
+    int VERSION_PATCH;
 
     /**
      * The version channel
@@ -67,6 +69,7 @@ class Config {
     QString VERSION_CHANNEL;
 
     bool UPDATER_ENABLED = false;
+    bool JAVA_DOWNLOADER_ENABLED = false;
 
     /// A short string identifying this build's platform or distribution.
     QString BUILD_PLATFORM;
@@ -104,9 +107,6 @@ class Config {
     /// User-Agent to use.
     QString USER_AGENT;
 
-    /// User-Agent to use for uncached requests.
-    QString USER_AGENT_UNCACHED;
-
     /// The git commit hash of this build
     QString GIT_COMMIT;
 
@@ -132,6 +132,11 @@ class Config {
      */
     QString HELP_URL;
 
+    /**
+     * URL that gets opened when the user succesfully logins.
+     */
+    QString LOGIN_CALLBACK_URL;
+
     /**
      * Client ID you can get from Imgur when you register an application
      */
@@ -161,12 +166,11 @@ class Config {
     QString DISCORD_URL;
     QString SUBREDDIT_URL;
 
-    QString RESOURCE_BASE = "https://resources.download.minecraft.net/";
+    QString DEFAULT_RESOURCE_BASE = "https://resources.download.minecraft.net/";
     QString LIBRARY_BASE = "https://libraries.minecraft.net/";
-    QString AUTH_BASE = "https://authserver.mojang.com/";
     QString IMGUR_BASE_URL = "https://api.imgur.com/3/";
-    QString FMLLIBS_BASE_URL = "https://files.prismlauncher.org/fmllibs/";  // FIXME: move into CMakeLists
-    QString TRANSLATIONS_BASE_URL = "https://i18n.prismlauncher.org/";      // FIXME: move into CMakeLists
+    QString LEGACY_FMLLIBS_BASE_URL;
+    QString TRANSLATION_FILES_URL;
 
     QString MODPACKSCH_API_BASE_URL = "https://api.modpacks.ch/";
 

cmake/CompilerWarnings.cmake

@@ -68,6 +68,8 @@ function(
         /w14906 # string literal cast to 'LPWSTR'
         /w14928 # illegal copy-initialization; more than one user-defined conversion has been implicitly applied
         /permissive- # standards conformance mode for MSVC compiler.
+
+        /we4062 # forbid omitting a possible value of an enum in a switch statement
     )
   endif()
 
@@ -93,6 +95,8 @@ function(
         # in a lot of noise. This warning is only notifying us that clang is emulating the GCC behaviour
         # instead of the exact standard wording so we can safely ignore it
         -Wno-gnu-zero-variadic-macro-arguments
+
+        -Werror=switch # forbid omitting a possible value of an enum in a switch statement
     )
   endif()
 
@@ -104,6 +108,8 @@ function(
         -Wduplicated-branches # warn if if / else branches have duplicated code
         -Wlogical-op # warn about logical operations being used where bitwise were probably wanted
         -Wuseless-cast # warn if you perform a cast to the same type
+
+        -Werror=switch # forbid omitting a possible value of an enum in a switch statement
     )
   endif()
 
@@ -128,6 +134,8 @@ function(
     -Woverloaded-virtual
     -Wuseless-cast
     -Wextra-semi
+
+    -Werror=switch # forbid omitting a possible value of an enum in a switch statement
   )
 
   target_compile_options(

cmake/ECMQueryQt.cmake

@@ -1,100 +0,0 @@
-# SPDX-FileCopyrightText: 2014 Rohan Garg <rohan16garg@gmail.com>
-# SPDX-FileCopyrightText: 2014 Alex Merry <alex.merry@kde.org>
-# SPDX-FileCopyrightText: 2014-2016 Aleix Pol <aleixpol@kde.org>
-# SPDX-FileCopyrightText: 2017 Friedrich W. H. Kossebau <kossebau@kde.org>
-# SPDX-FileCopyrightText: 2022 Ahmad Samir <a.samir78@gmail.com>
-#
-# SPDX-License-Identifier: BSD-3-Clause
-#[=======================================================================[.rst:
-ECMQueryQt
----------------
-This module can be used to query the installation paths used by Qt.
-
-For Qt5 this uses ``qmake``, and for Qt6 this used ``qtpaths`` (the latter has built-in
-support to query the paths of a target platform when cross-compiling).
-
-This module defines the following function:
-::
-
-    ecm_query_qt(<result_variable> <qt_variable> [TRY])
-
-Passing ``TRY`` will result in the method not making the build fail if the executable
-used for querying has not been found, but instead simply print a warning message and
-return an empty string.
-
-Example usage:
-
-.. code-block:: cmake
-
-    include(ECMQueryQt)
-    ecm_query_qt(bin_dir QT_INSTALL_BINS)
-
-If the call succeeds ``${bin_dir}`` will be set to ``<prefix>/path/to/bin/dir`` (e.g.
-``/usr/lib64/qt/bin/``).
-
-Since: 5.93
-#]=======================================================================]
-
-include(${CMAKE_CURRENT_LIST_DIR}/QtVersionOption.cmake)
-include(CheckLanguage)
-check_language(CXX)
-if (CMAKE_CXX_COMPILER)
-    # Enable the CXX language to let CMake look for config files in library dirs.
-    # See: https://gitlab.kitware.com/cmake/cmake/-/issues/23266
-    enable_language(CXX)
-endif()
-
-if (QT_MAJOR_VERSION STREQUAL "5")
-    # QUIET to accommodate the TRY option
-    find_package(Qt${QT_MAJOR_VERSION}Core QUIET)
-    if(TARGET Qt5::qmake)
-        get_target_property(_qmake_executable_default Qt5::qmake LOCATION)
-
-        set(QUERY_EXECUTABLE ${_qmake_executable_default}
-            CACHE FILEPATH "Location of the Qt5 qmake executable")
-        set(_exec_name_text "Qt5 qmake")
-        set(_cli_option "-query")
-    endif()
-elseif(QT_MAJOR_VERSION STREQUAL "6")
-    # QUIET to accommodate the TRY option
-    find_package(Qt6 COMPONENTS CoreTools QUIET CONFIG)
-    if (TARGET Qt6::qtpaths)
-        get_target_property(_qtpaths_executable Qt6::qtpaths LOCATION)
-
-        set(QUERY_EXECUTABLE ${_qtpaths_executable}
-            CACHE FILEPATH "Location of the Qt6 qtpaths executable")
-        set(_exec_name_text "Qt6 qtpaths")
-        set(_cli_option "--query")
-    endif()
-endif()
-
-function(ecm_query_qt result_variable qt_variable)
-    set(options TRY)
-    set(oneValueArgs)
-    set(multiValueArgs)
-
-    cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-    if(NOT QUERY_EXECUTABLE)
-        if(ARGS_TRY)
-            set(${result_variable} "" PARENT_SCOPE)
-            message(STATUS "No ${_exec_name_text} executable found. Can't check ${qt_variable}")
-            return()
-        else()
-            message(FATAL_ERROR "No ${_exec_name_text} executable found. Can't check ${qt_variable} as required")
-        endif()
-    endif()
-    execute_process(
-        COMMAND ${QUERY_EXECUTABLE} ${_cli_option} "${qt_variable}"
-        RESULT_VARIABLE return_code
-        OUTPUT_VARIABLE output
-    )
-    if(return_code EQUAL 0)
-        string(STRIP "${output}" output)
-        file(TO_CMAKE_PATH "${output}" output_path)
-        set(${result_variable} "${output_path}" PARENT_SCOPE)
-    else()
-        message(WARNING "Failed call: ${_command} \"${qt_variable}\"")
-        message(FATAL_ERROR "${_exec_name_text} call failed: ${return_code}")
-    endif()
-endfunction()

cmake/MacOSXBundleInfo.plist.in

@@ -6,6 +6,10 @@
     <string>A Minecraft mod wants to access your camera.</string>
     <key>NSMicrophoneUsageDescription</key>
     <string>A Minecraft mod wants to access your microphone.</string>
+    <key>NSDownloadsFolderUsageDescription</key>
+    <string>Prism uses access to your Downloads folder to help you more quickly add mods that can't be automatically downloaded to your instance. You can change where Prism scans for downloaded mods in Settings or the prompt that appears.</string>
+    <key>NSLocalNetworkUsageDescription</key>
+    <string>Minecraft uses the local network to find and connect to LAN servers.</string>
     <key>NSPrincipalClass</key>
     <string>NSApplication</string>
     <key>NSHighResolutionCapable</key>
@@ -17,7 +21,9 @@
     <key>CFBundleGetInfoString</key>
     <string>${MACOSX_BUNDLE_INFO_STRING}</string>
     <key>CFBundleIconFile</key>
-    <string>${MACOSX_BUNDLE_ICON_FILE}</string>
+    <string>${Launcher_Name}</string>
+    <key>CFBundleIconName</key>
+    <string>${Launcher_Name}</string>
     <key>CFBundleIdentifier</key>
     <string>${MACOSX_BUNDLE_GUI_IDENTIFIER}</string>
     <key>CFBundleInfoDictionaryVersion</key>
@@ -38,6 +44,8 @@
     <true/>
     <key>LSRequiresCarbon</key>
     <true/>
+    <key>LSApplicationCategoryType</key>
+    <string>public.app-category.games</string>
     <key>NSHumanReadableCopyright</key>
     <string>${MACOSX_BUNDLE_COPYRIGHT}</string>
     <key>SUPublicEDKey</key>
@@ -77,6 +85,14 @@
             <string>curseforge</string>
             </array>
         </dict>
+        <dict>
+            <key>CFBundleURLName</key>
+            <string>Prismlauncher</string>
+            <key>CFBundleURLSchemes</key>
+            <array>
+            <string>prismlauncher</string>
+            </array>
+        </dict>
     </array>
 </dict>
 </plist>

cmake/QtVersionOption.cmake

@@ -1,38 +0,0 @@
-#.rst:
-# QtVersionOption
-# ---------------
-#
-# Adds a build option to select the major Qt version if necessary,
-# that is, if the major Qt version has not yet been determined otherwise
-# (e.g. by a corresponding find_package() call).
-#
-# This module is typically included by other modules requiring knowledge
-# about the major Qt version.
-#
-# ``QT_MAJOR_VERSION`` is defined to either be "5" or "6".
-#
-#
-# Since 5.82.0.
-
-#=============================================================================
-# SPDX-FileCopyrightText: 2021 Volker Krause <vkrause@kde.org>
-#
-# SPDX-License-Identifier: BSD-3-Clause
-
-if (DEFINED QT_MAJOR_VERSION)
-    return()
-endif()
-
-if (TARGET Qt5::Core)
-    set(QT_MAJOR_VERSION 5)
-elseif (TARGET Qt6::Core)
-    set(QT_MAJOR_VERSION 6)
-else()
-    option(BUILD_WITH_QT6 "Build against Qt 6" OFF)
-
-    if (BUILD_WITH_QT6)
-        set(QT_MAJOR_VERSION 6)
-    else()
-        set(QT_MAJOR_VERSION 5)
-    endif()
-endif()

cmake/QtVersionlessBackport.cmake

@@ -1,97 +0,0 @@
-#=============================================================================
-# Copyright 2005-2011 Kitware, Inc.
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# * Redistributions of source code must retain the above copyright
-#   notice, this list of conditions and the following disclaimer.
-#
-# * Redistributions in binary form must reproduce the above copyright
-#   notice, this list of conditions and the following disclaimer in the
-#   documentation and/or other materials provided with the distribution.
-#
-# * Neither the name of Kitware, Inc. nor the names of its
-#   contributors may be used to endorse or promote products derived
-#   from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#=============================================================================
-
-# From Qt5CoreMacros.cmake
-
-function(qt_generate_moc)
-    if(QT_VERSION_MAJOR EQUAL 5)
-        qt5_generate_moc(${ARGV})
-    elseif(QT_VERSION_MAJOR EQUAL 6)
-        qt6_generate_moc(${ARGV})
-    endif()
-endfunction()
-
-function(qt_wrap_cpp outfiles)
-    if(QT_VERSION_MAJOR EQUAL 5)
-        qt5_wrap_cpp("${outfiles}" ${ARGN})
-    elseif(QT_VERSION_MAJOR EQUAL 6)
-        qt6_wrap_cpp("${outfiles}" ${ARGN})
-    endif()
-    set("${outfiles}" "${${outfiles}}" PARENT_SCOPE)
-endfunction()
-
-function(qt_add_binary_resources)
-    if(QT_VERSION_MAJOR EQUAL 5)
-        qt5_add_binary_resources(${ARGV})
-    elseif(QT_VERSION_MAJOR EQUAL 6)
-        qt6_add_binary_resources(${ARGV})
-    endif()
-endfunction()
-
-function(qt_add_resources outfiles)
-    if(QT_VERSION_MAJOR EQUAL 5)
-        qt5_add_resources("${outfiles}" ${ARGN})
-    elseif(QT_VERSION_MAJOR EQUAL 6)
-        qt6_add_resources("${outfiles}" ${ARGN})
-    endif()
-    set("${outfiles}" "${${outfiles}}" PARENT_SCOPE)
-endfunction()
-
-function(qt_add_big_resources outfiles)
-    if(QT_VERSION_MAJOR EQUAL 5)
-        qt5_add_big_resources(${outfiles} ${ARGN})
-    elseif(QT_VERSION_MAJOR EQUAL 6)
-        qt6_add_big_resources(${outfiles} ${ARGN})
-    endif()
-    set("${outfiles}" "${${outfiles}}" PARENT_SCOPE)
-endfunction()
-
-function(qt_import_plugins)
-    if(QT_VERSION_MAJOR EQUAL 5)
-        qt5_import_plugins(${ARGV})
-    elseif(QT_VERSION_MAJOR EQUAL 6)
-        qt6_import_plugins(${ARGV})
-    endif()
-endfunction()
-
-
-# From Qt5WidgetsMacros.cmake
-
-function(qt_wrap_ui outfiles)
-    if(QT_VERSION_MAJOR EQUAL 5)
-        qt5_wrap_ui("${outfiles}" ${ARGN})
-    elseif(QT_VERSION_MAJOR EQUAL 6)
-        qt6_wrap_ui("${outfiles}" ${ARGN})
-    endif()
-    set("${outfiles}" "${${outfiles}}" PARENT_SCOPE)
-endfunction()
-

cmake/vcpkg-ports/vcpkg-tool-meson/README.md

@@ -0,0 +1,3 @@
+The only difference between this and the upstream vcpkg port is the addition of `universal-osx.patch`. It's very annoying we need to bundle this entire tree to do that.
+
+-@getchoo

cmake/vcpkg-ports/vcpkg-tool-meson/adjust-args.patch

@@ -0,0 +1,13 @@
+diff --git a/mesonbuild/cmake/toolchain.py b/mesonbuild/cmake/toolchain.py
+index 11a00be5d..89ae490ff 100644
+--- a/mesonbuild/cmake/toolchain.py
++++ b/mesonbuild/cmake/toolchain.py
+@@ -202,7 +202,7 @@ class CMakeToolchain:
+     @staticmethod
+     def is_cmdline_option(compiler: 'Compiler', arg: str) -> bool:
+         if compiler.get_argument_syntax() == 'msvc':
+-            return arg.startswith('/')
++            return arg.startswith(('/','-'))
+         else:
+             if os.path.basename(compiler.get_exe()) == 'zig' and arg in {'ar', 'cc', 'c++', 'dlltool', 'lib', 'ranlib', 'objcopy', 'rc'}:
+                 return True

cmake/vcpkg-ports/vcpkg-tool-meson/adjust-python-dep.patch

@@ -0,0 +1,45 @@
+diff --git a/mesonbuild/dependencies/python.py b/mesonbuild/dependencies/python.py
+index 883a29a..d9a82af 100644
+--- a/mesonbuild/dependencies/python.py
++++ b/mesonbuild/dependencies/python.py
+@@ -232,8 +232,10 @@ class _PythonDependencyBase(_Base):
+                 else:
+                     if self.is_freethreaded:
+                         libpath = Path('libs') / f'python{vernum}t.lib'
++                        libpath = Path('libs') / f'..' / f'..' / f'..' / f'lib' / f'python{vernum}t.lib'
+                     else:
+                         libpath = Path('libs') / f'python{vernum}.lib'
++                        libpath = Path('libs') / f'..' / f'..' / f'..' / f'lib' / f'python{vernum}.lib'
+                     # For a debug build, pyconfig.h may force linking with
+                     # pythonX_d.lib (see meson#10776). This cannot be avoided
+                     # and won't work unless we also have a debug build of
+@@ -250,6 +252,8 @@ class _PythonDependencyBase(_Base):
+                         vscrt = self.env.coredata.optstore.get_value('b_vscrt')
+                         if vscrt in {'mdd', 'mtd', 'from_buildtype', 'static_from_buildtype'}:
+                             vscrt_debug = True
++                    if is_debug_build:
++                       libpath = Path('libs') / f'..' / f'..' / f'..' / f'debug/lib' / f'python{vernum}_d.lib'
+                     if is_debug_build and vscrt_debug and not self.variables.get('Py_DEBUG'):
+                         mlog.warning(textwrap.dedent('''\
+                             Using a debug build type with MSVC or an MSVC-compatible compiler
+@@ -350,9 +354,10 @@ class PythonSystemDependency(SystemDependency, _PythonDependencyBase):
+             self.is_found = True
+ 
+         # compile args
++        verdot = self.variables.get('py_version_short')
+         inc_paths = mesonlib.OrderedSet([
+             self.variables.get('INCLUDEPY'),
+-            self.paths.get('include'),
++            self.paths.get('include') + f'/../../../include/python${verdot}',
+             self.paths.get('platinclude')])
+ 
+         self.compile_args += ['-I' + path for path in inc_paths if path]
+@@ -416,7 +421,7 @@ def python_factory(env: 'Environment', for_machine: 'MachineChoice',
+             candidates.append(functools.partial(wrap_in_pythons_pc_dir, pkg_name, env, kwargs, installation))
+             # We only need to check both, if a python install has a LIBPC. It might point to the wrong location,
+             # e.g. relocated / cross compilation, but the presence of LIBPC indicates we should definitely look for something.
+-            if pkg_libdir is not None:
++            if True or pkg_libdir is not None:
+                 candidates.append(functools.partial(PythonPkgConfigDependency, pkg_name, env, kwargs, installation))
+         else:
+             candidates.append(functools.partial(PkgConfigDependency, 'python3', env, kwargs))

cmake/vcpkg-ports/vcpkg-tool-meson/fix-libcpp-enable-assertions.patch

@@ -0,0 +1,52 @@
+From a16ec8b0fb6d7035b669a13edd4d97ff0c307a0b Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Martin=20D=C3=B8rum?= <martid0311@gmail.com>
+Date: Fri, 2 May 2025 10:56:28 +0200
+Subject: [PATCH] cpp: fix _LIBCPP_ENABLE_ASSERTIONS warning
+
+libc++ deprecated _LIBCPP_ENABLE_ASSERTIONS from version 18.
+However, the libc++ shipped with Apple Clang backported that
+deprecation in version 17 already,
+which is the version which Apple currently ships for macOS.
+This PR changes the _LIBCPP_ENABLE_ASSERTIONS deprecation check
+to use version ">=17" on Apple Clang.
+---
+ mesonbuild/compilers/cpp.py | 12 ++++++++++--
+ 1 file changed, 10 insertions(+), 2 deletions(-)
+
+diff --git a/mesonbuild/compilers/cpp.py b/mesonbuild/compilers/cpp.py
+index 01b9bb9fa34f..f7dc150e8608 100644
+--- a/mesonbuild/compilers/cpp.py
++++ b/mesonbuild/compilers/cpp.py
+@@ -311,6 +311,9 @@ def get_option_link_args(self, target: 'BuildTarget', env: 'Environment', subpro
+             return libs
+         return []
+ 
++    def is_libcpp_enable_assertions_deprecated(self) -> bool:
++        return version_compare(self.version, ">=18")
++
+     def get_assert_args(self, disable: bool, env: 'Environment') -> T.List[str]:
+         if disable:
+             return ['-DNDEBUG']
+@@ -323,7 +326,7 @@ def get_assert_args(self, disable: bool, env: 'Environment') -> T.List[str]:
+         if self.language_stdlib_provider(env) == 'stdc++':
+             return ['-D_GLIBCXX_ASSERTIONS=1']
+         else:
+-            if version_compare(self.version, '>=18'):
++            if self.is_libcpp_enable_assertions_deprecated():
+                 return ['-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_FAST']
+             elif version_compare(self.version, '>=15'):
+                 return ['-D_LIBCPP_ENABLE_ASSERTIONS=1']
+@@ -343,7 +346,12 @@ class ArmLtdClangCPPCompiler(ClangCPPCompiler):
+ 
+ 
+ class AppleClangCPPCompiler(AppleCompilerMixin, AppleCPPStdsMixin, ClangCPPCompiler):
+-    pass
++    def is_libcpp_enable_assertions_deprecated(self) -> bool:
++        # Upstream libc++ deprecated _LIBCPP_ENABLE_ASSERTIONS
++        # in favor of _LIBCPP_HARDENING_MODE from version 18 onwards,
++        # but Apple Clang 17's libc++ has back-ported that change.
++        # See: https://github.com/mesonbuild/meson/issues/14440
++        return version_compare(self.version, ">=17")
+ 
+ 
+ class EmscriptenCPPCompiler(EmscriptenMixin, ClangCPPCompiler):

cmake/vcpkg-ports/vcpkg-tool-meson/install.cmake

@@ -0,0 +1,5 @@
+file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/tools/meson")
+file(INSTALL "${SOURCE_PATH}/meson.py"
+             "${SOURCE_PATH}/mesonbuild"
+    DESTINATION "${CURRENT_PACKAGES_DIR}/tools/meson"
+)

cmake/vcpkg-ports/vcpkg-tool-meson/meson-intl.patch

@@ -0,0 +1,13 @@
+diff --git a/mesonbuild/dependencies/misc.py b/mesonbuild/dependencies/misc.py
+--- a/mesonbuild/dependencies/misc.py
++++ b/mesonbuild/dependencies/misc.py
+@@ -593,7 +593,8 @@ iconv_factory = DependencyFactory(
+ 
+ packages['intl'] = intl_factory = DependencyFactory(
+     'intl',
++    [DependencyMethods.BUILTIN, DependencyMethods.SYSTEM, DependencyMethods.CMAKE],
++    cmake_name='Intl',
+-    [DependencyMethods.BUILTIN, DependencyMethods.SYSTEM],
+     builtin_class=IntlBuiltinDependency,
+     system_class=IntlSystemDependency,
+ )

cmake/vcpkg-ports/vcpkg-tool-meson/meson.template.in

@@ -0,0 +1,43 @@
+[binaries]
+cmake = ['@CMAKE_COMMAND@']
+ninja = ['@NINJA@']
+pkg-config = ['@PKGCONFIG@']
+@MESON_MT@
+@MESON_AR@
+@MESON_RC@
+@MESON_C@
+@MESON_C_LD@
+@MESON_CXX@
+@MESON_CXX_LD@
+@MESON_OBJC@
+@MESON_OBJC_LD@
+@MESON_OBJCPP@
+@MESON_OBJCPP_LD@
+@MESON_FC@
+@MESON_FC_LD@
+@MESON_WINDRES@
+@MESON_ADDITIONAL_BINARIES@
+[properties]
+cmake_toolchain_file  = '@SCRIPTS@/buildsystems/vcpkg.cmake'
+@MESON_ADDITIONAL_PROPERTIES@
+[cmake]
+CMAKE_BUILD_TYPE = '@MESON_CMAKE_BUILD_TYPE@'
+VCPKG_TARGET_TRIPLET = '@TARGET_TRIPLET@'
+VCPKG_HOST_TRIPLET = '@_HOST_TRIPLET@'
+VCPKG_CHAINLOAD_TOOLCHAIN_FILE = '@VCPKG_CHAINLOAD_TOOLCHAIN_FILE@'
+VCPKG_CRT_LINKAGE = '@VCPKG_CRT_LINKAGE@'
+_VCPKG_INSTALLED_DIR = '@_VCPKG_INSTALLED_DIR@'
+@MESON_HOST_MACHINE@
+@MESON_BUILD_MACHINE@
+[built-in options]
+default_library = '@MESON_DEFAULT_LIBRARY@'
+werror = false
+@MESON_CFLAGS@
+@MESON_CXXFLAGS@
+@MESON_FCFLAGS@
+@MESON_OBJCFLAGS@
+@MESON_OBJCPPFLAGS@
+# b_vscrt
+@MESON_VSCRT_LINKAGE@
+# c_winlibs/cpp_winlibs
+@MESON_WINLIBS@

cmake/vcpkg-ports/vcpkg-tool-meson/portfile.cmake

@@ -0,0 +1,45 @@
+# This port represents a dependency on the Meson build system.
+# In the future, it is expected that this port acquires and installs Meson.
+# Currently is used in ports that call vcpkg_find_acquire_program(MESON) in order to force rebuilds.
+
+set(VCPKG_POLICY_CMAKE_HELPER_PORT enabled)
+
+set(patches
+  meson-intl.patch
+  adjust-python-dep.patch
+  adjust-args.patch
+  remove-freebsd-pcfile-specialization.patch
+  fix-libcpp-enable-assertions.patch # https://github.com/mesonbuild/meson/pull/14548, Remove in 1.8.3
+  universal-osx.patch # NOTE(@getchoo): THIS IS THE ONLY CHANGE NEEDED FOR PRISM
+)
+set(scripts
+  vcpkg-port-config.cmake
+  vcpkg_configure_meson.cmake
+  vcpkg_install_meson.cmake
+  meson.template.in
+)
+set(to_hash 
+  "${CMAKE_CURRENT_LIST_DIR}/vcpkg.json"
+  "${CMAKE_CURRENT_LIST_DIR}/portfile.cmake"
+)
+foreach(file IN LISTS patches scripts)
+  set(filepath  "${CMAKE_CURRENT_LIST_DIR}/${file}")
+  list(APPEND to_hash "${filepath}")
+  file(COPY "${filepath}" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}")
+endforeach()
+
+set(meson_path_hash "")
+foreach(filepath IN LISTS to_hash)
+  file(SHA1 "${filepath}" to_append)
+  string(APPEND meson_path_hash "${to_append}")
+endforeach()
+string(SHA512 meson_path_hash "${meson_path_hash}")
+
+string(SUBSTRING "${meson_path_hash}" 0 6 MESON_SHORT_HASH)
+list(TRANSFORM patches REPLACE [[^(..*)$]] [["${CMAKE_CURRENT_LIST_DIR}/\0"]])
+list(JOIN patches "\n            " PATCHES)
+configure_file("${CMAKE_CURRENT_LIST_DIR}/vcpkg-port-config.cmake" "${CURRENT_PACKAGES_DIR}/share/${PORT}/vcpkg-port-config.cmake" @ONLY)
+
+vcpkg_install_copyright(FILE_LIST "${VCPKG_ROOT_DIR}/LICENSE.txt")
+
+include("${CURRENT_PACKAGES_DIR}/share/${PORT}/vcpkg-port-config.cmake")

cmake/vcpkg-ports/vcpkg-tool-meson/remove-freebsd-pcfile-specialization.patch

@@ -0,0 +1,23 @@
+diff --git a/mesonbuild/modules/pkgconfig.py b/mesonbuild/modules/pkgconfig.py
+index cc0450a52..13501466d 100644
+--- a/mesonbuild/modules/pkgconfig.py
++++ b/mesonbuild/modules/pkgconfig.py
+@@ -701,16 +701,8 @@ class PkgConfigModule(NewExtensionModule):
+         pcfile = filebase + '.pc'
+         pkgroot = pkgroot_name = kwargs['install_dir'] or default_install_dir
+         if pkgroot is None:
+-            m = state.environment.machines.host
+-            if m.is_freebsd():
+-                pkgroot = os.path.join(_as_str(state.environment.coredata.optstore.get_value_for(OptionKey('prefix'))), 'libdata', 'pkgconfig')
+-                pkgroot_name = os.path.join('{prefix}', 'libdata', 'pkgconfig')
+-            elif m.is_haiku():
+-                pkgroot = os.path.join(_as_str(state.environment.coredata.optstore.get_value_for(OptionKey('prefix'))), 'develop', 'lib', 'pkgconfig')
+-                pkgroot_name = os.path.join('{prefix}', 'develop', 'lib', 'pkgconfig')
+-            else:
+-                pkgroot = os.path.join(_as_str(state.environment.coredata.optstore.get_value_for(OptionKey('libdir'))), 'pkgconfig')
+-                pkgroot_name = os.path.join('{libdir}', 'pkgconfig')
++            pkgroot = os.path.join(_as_str(state.environment.coredata.optstore.get_value_for(OptionKey('libdir'))), 'pkgconfig')
++            pkgroot_name = os.path.join('{libdir}', 'pkgconfig')
+         relocatable = state.get_option('pkgconfig.relocatable')
+         self._generate_pkgconfig_file(state, deps, subdirs, name, description, url,
+                                       version, pcfile, conflicts, variables,

cmake/vcpkg-ports/vcpkg-tool-meson/universal-osx.patch

@@ -0,0 +1,16 @@
+diff --git a/mesonbuild/compilers/detect.py b/mesonbuild/compilers/detect.py
+index f57957f0b..a72e72a0b 100644
+--- a/mesonbuild/compilers/detect.py
++++ b/mesonbuild/compilers/detect.py
+@@ -1472,6 +1472,11 @@ def _get_clang_compiler_defines(compiler: T.List[str], lang: str) -> T.Dict[str,
+     """
+     from .mixins.clang import clang_lang_map
+ 
++    # Filter out `-arch` flags passed to the compiler for Universal Binaries
++    # https://github.com/mesonbuild/meson/issues/5290
++    # https://github.com/mesonbuild/meson/issues/8206
++    compiler = [arg for i, arg in enumerate(compiler) if not (i > 0 and compiler[i - 1] == "-arch") and not arg == "-arch"]
++
+     def _try_obtain_compiler_defines(args: T.List[str]) -> str:
+         mlog.debug(f'Running command: {join_args(args)}')
+         p, output, error = Popen_safe(compiler + args, write='', stdin=subprocess.PIPE)

cmake/vcpkg-ports/vcpkg-tool-meson/vcpkg-port-config.cmake

@@ -0,0 +1,62 @@
+include("${CURRENT_HOST_INSTALLED_DIR}/share/vcpkg-cmake-get-vars/vcpkg-port-config.cmake")
+# Overwrite builtin scripts
+include("${CMAKE_CURRENT_LIST_DIR}/vcpkg_configure_meson.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/vcpkg_install_meson.cmake")
+
+set(meson_short_hash @MESON_SHORT_HASH@)
+
+# Setup meson:
+set(program MESON)
+set(program_version @VERSION@)
+set(program_name meson)
+set(search_names meson meson.py)
+set(ref "${program_version}")
+set(path_to_search "${DOWNLOADS}/tools/meson-${program_version}-${meson_short_hash}")
+set(download_urls "https://github.com/mesonbuild/meson/archive/${ref}.tar.gz")
+set(download_filename "meson-${ref}.tar.gz")
+set(download_sha512 bd2e65f0863d9cb974e659ff502d773e937b8a60aaddfd7d81e34cd2c296c8e82bf214d790ac089ba441543059dfc2677ba95ed51f676df9da420859f404a907)
+
+find_program(SCRIPT_MESON NAMES ${search_names} PATHS "${path_to_search}" NO_DEFAULT_PATH) # NO_DEFAULT_PATH due top patching
+
+if(NOT SCRIPT_MESON)
+    vcpkg_download_distfile(archive_path
+        URLS ${download_urls}
+        SHA512 "${download_sha512}"
+        FILENAME "${download_filename}"
+    )
+    file(REMOVE_RECURSE "${path_to_search}")
+    file(REMOVE_RECURSE "${path_to_search}-tmp")
+    file(MAKE_DIRECTORY "${path_to_search}-tmp")
+    file(ARCHIVE_EXTRACT INPUT "${archive_path}"
+        DESTINATION "${path_to_search}-tmp"
+        #PATTERNS "**/mesonbuild/*" "**/*.py"
+        )
+    z_vcpkg_apply_patches(
+        SOURCE_PATH "${path_to_search}-tmp/meson-${ref}"
+        PATCHES
+            @PATCHES@
+    )
+    file(MAKE_DIRECTORY "${path_to_search}")
+    file(RENAME "${path_to_search}-tmp/meson-${ref}/meson.py" "${path_to_search}/meson.py")
+    file(RENAME "${path_to_search}-tmp/meson-${ref}/mesonbuild" "${path_to_search}/mesonbuild")
+    file(REMOVE_RECURSE "${path_to_search}-tmp")
+    set(SCRIPT_MESON "${path_to_search}/meson.py")
+endif()
+
+# Check required python version
+vcpkg_find_acquire_program(PYTHON3)
+vcpkg_execute_in_download_mode(
+    COMMAND "${PYTHON3}" --version
+    OUTPUT_VARIABLE version_contents
+    WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}"
+)
+string(REGEX MATCH [[[0-9]+\.[0-9]+\.[0-9]+]] python_ver "${version_contents}")
+
+set(min_required 3.7)
+if(python_ver VERSION_LESS "${min_required}")
+    message(FATAL_ERROR "Found Python version '${python_ver} at ${PYTHON3}' is insufficient for meson. meson requires at least version '${min_required}'")
+else()
+    message(STATUS "Found Python version '${python_ver} at ${PYTHON3}'")
+endif()
+
+message(STATUS "Using meson: ${SCRIPT_MESON}")

cmake/vcpkg-ports/vcpkg-tool-meson/vcpkg.json

@@ -0,0 +1,11 @@
+{
+  "name": "vcpkg-tool-meson",
+  "version": "1.8.2",
+  "description": "Meson build system",
+  "homepage": "https://github.com/mesonbuild/meson",
+  "license": "Apache-2.0",
+  "supports": "native",
+  "dependencies": [
+    "vcpkg-cmake-get-vars"
+  ]
+}

cmake/vcpkg-ports/vcpkg-tool-meson/vcpkg_configure_meson.cmake

@@ -0,0 +1,480 @@
+function(z_vcpkg_meson_set_proglist_variables config_type)
+    if(VCPKG_TARGET_IS_WINDOWS)
+        set(proglist MT AR)
+    else()
+        set(proglist AR RANLIB STRIP NM OBJDUMP DLLTOOL MT)
+    endif()
+    foreach(prog IN LISTS proglist)
+        if(VCPKG_DETECTED_CMAKE_${prog})
+            if(meson_${prog})
+                string(TOUPPER "MESON_${meson_${prog}}" var_to_set)
+                set("${var_to_set}" "${meson_${prog}} = ['${VCPKG_DETECTED_CMAKE_${prog}}']" PARENT_SCOPE)
+            elseif(${prog} STREQUAL AR AND VCPKG_COMBINED_STATIC_LINKER_FLAGS_${config_type})
+                # Probably need to move AR somewhere else
+                string(TOLOWER "${prog}" proglower)
+                z_vcpkg_meson_convert_compiler_flags_to_list(ar_flags "${VCPKG_COMBINED_STATIC_LINKER_FLAGS_${config_type}}")
+                list(PREPEND ar_flags "${VCPKG_DETECTED_CMAKE_${prog}}")
+                z_vcpkg_meson_convert_list_to_python_array(ar_flags ${ar_flags})
+                set("MESON_AR" "${proglower} = ${ar_flags}" PARENT_SCOPE)
+            else()
+                string(TOUPPER "MESON_${prog}" var_to_set)
+                string(TOLOWER "${prog}" proglower)
+                set("${var_to_set}" "${proglower} = ['${VCPKG_DETECTED_CMAKE_${prog}}']" PARENT_SCOPE)
+            endif()
+        endif()
+    endforeach()
+    set(compilers "${arg_LANGUAGES}")
+    if(VCPKG_TARGET_IS_WINDOWS)
+        list(APPEND compilers RC)
+    endif()
+    set(meson_RC windres)
+    set(meson_Fortran fortran)
+    set(meson_CXX cpp)
+    foreach(prog IN LISTS compilers)
+        if(VCPKG_DETECTED_CMAKE_${prog}_COMPILER)
+            string(TOUPPER "MESON_${prog}" var_to_set)
+            if(meson_${prog})
+                if(VCPKG_COMBINED_${prog}_FLAGS_${config_type})
+                    # Need compiler flags in prog vars for sanity check.
+                    z_vcpkg_meson_convert_compiler_flags_to_list(${prog}flags "${VCPKG_COMBINED_${prog}_FLAGS_${config_type}}")
+                endif()
+                list(PREPEND ${prog}flags "${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}")
+                list(FILTER ${prog}flags EXCLUDE REGEX "(-|/)nologo") # Breaks compiler detection otherwise
+                z_vcpkg_meson_convert_list_to_python_array(${prog}flags ${${prog}flags})
+                set("${var_to_set}" "${meson_${prog}} = ${${prog}flags}" PARENT_SCOPE)
+                if (DEFINED VCPKG_DETECTED_CMAKE_${prog}_COMPILER_ID
+                    AND NOT VCPKG_DETECTED_CMAKE_${prog}_COMPILER_ID MATCHES "^(GNU|Intel)$"
+                    AND VCPKG_DETECTED_CMAKE_LINKER)
+                    string(TOUPPER "MESON_${prog}_LD" var_to_set)
+                    set(${var_to_set} "${meson_${prog}}_ld = ['${VCPKG_DETECTED_CMAKE_LINKER}']" PARENT_SCOPE)
+                endif()
+            else()
+                if(VCPKG_COMBINED_${prog}_FLAGS_${config_type})
+                     # Need compiler flags in prog vars for sanity check.
+                    z_vcpkg_meson_convert_compiler_flags_to_list(${prog}flags "${VCPKG_COMBINED_${prog}_FLAGS_${config_type}}")
+                endif()
+                list(PREPEND ${prog}flags "${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}")
+                list(FILTER ${prog}flags EXCLUDE REGEX "(-|/)nologo") # Breaks compiler detection otherwise
+                z_vcpkg_meson_convert_list_to_python_array(${prog}flags ${${prog}flags})
+                string(TOLOWER "${prog}" proglower)
+                set("${var_to_set}" "${proglower} = ${${prog}flags}" PARENT_SCOPE)
+                if (DEFINED VCPKG_DETECTED_CMAKE_${prog}_COMPILER_ID
+                    AND NOT VCPKG_DETECTED_CMAKE_${prog}_COMPILER_ID MATCHES "^(GNU|Intel)$"
+                    AND VCPKG_DETECTED_CMAKE_LINKER)
+                    string(TOUPPER "MESON_${prog}_LD" var_to_set)
+                    set(${var_to_set} "${proglower}_ld = ['${VCPKG_DETECTED_CMAKE_LINKER}']" PARENT_SCOPE)
+                endif()
+            endif()
+        endif()
+    endforeach()
+endfunction()
+
+function(z_vcpkg_meson_convert_compiler_flags_to_list out_var compiler_flags)
+    separate_arguments(cmake_list NATIVE_COMMAND "${compiler_flags}")
+    list(TRANSFORM cmake_list REPLACE ";" [[\\;]])
+    set("${out_var}" "${cmake_list}" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_meson_convert_list_to_python_array out_var)
+    z_vcpkg_function_arguments(flag_list 1)
+    vcpkg_list(REMOVE_ITEM flag_list "") # remove empty elements if any
+    vcpkg_list(JOIN flag_list "', '" flag_list)
+    set("${out_var}" "['${flag_list}']" PARENT_SCOPE)
+endfunction()
+
+# Generates the required compiler properties for meson
+function(z_vcpkg_meson_set_flags_variables config_type)
+    if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
+        set(libpath_flag /LIBPATH:)
+    else()
+        set(libpath_flag -L)
+    endif()
+    if(config_type STREQUAL "DEBUG")
+        set(path_suffix "/debug")
+    else()
+        set(path_suffix "")
+    endif()
+
+    set(includepath "-I${CURRENT_INSTALLED_DIR}/include")
+    set(libpath "${libpath_flag}${CURRENT_INSTALLED_DIR}${path_suffix}/lib")
+
+    foreach(lang IN LISTS arg_LANGUAGES)
+        z_vcpkg_meson_convert_compiler_flags_to_list(${lang}flags "${VCPKG_COMBINED_${lang}_FLAGS_${config_type}}")
+        if(lang MATCHES "^(C|CXX)$")
+            vcpkg_list(APPEND ${lang}flags "${includepath}")
+        endif()
+        z_vcpkg_meson_convert_list_to_python_array(${lang}flags ${${lang}flags})
+        set(lang_mapping "${lang}")
+        if(lang STREQUAL "Fortran")
+            set(lang_mapping "FC")
+        endif()
+        string(TOLOWER "${lang_mapping}" langlower)
+        if(lang STREQUAL "CXX")
+            set(langlower cpp)
+        endif()
+        set(MESON_${lang_mapping}FLAGS "${langlower}_args = ${${lang}flags}\n")
+        set(linker_flags "${VCPKG_COMBINED_SHARED_LINKER_FLAGS_${config_type}}")
+        z_vcpkg_meson_convert_compiler_flags_to_list(linker_flags "${linker_flags}")
+        vcpkg_list(APPEND linker_flags "${libpath}")
+        z_vcpkg_meson_convert_list_to_python_array(linker_flags ${linker_flags})
+        string(APPEND MESON_${lang_mapping}FLAGS "${langlower}_link_args = ${linker_flags}\n")
+        set(MESON_${lang_mapping}FLAGS "${MESON_${lang_mapping}FLAGS}" PARENT_SCOPE)
+    endforeach()
+endfunction()
+
+function(z_vcpkg_get_build_and_host_system build_system host_system is_cross) #https://mesonbuild.com/Cross-compilation.html
+    set(build_unknown FALSE)
+    if(CMAKE_HOST_WIN32)
+        if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
+            set(build_arch $ENV{PROCESSOR_ARCHITEW6432})
+        else()
+            set(build_arch $ENV{PROCESSOR_ARCHITECTURE})
+        endif()
+        if(build_arch MATCHES "(amd|AMD)64")
+            set(build_cpu_fam x86_64)
+            set(build_cpu x86_64)
+        elseif(build_arch MATCHES "(x|X)86")
+            set(build_cpu_fam x86)
+            set(build_cpu i686)
+        elseif(build_arch MATCHES "^(ARM|arm)64$")
+            set(build_cpu_fam aarch64)
+            set(build_cpu armv8)
+        elseif(build_arch MATCHES "^(ARM|arm)$")
+            set(build_cpu_fam arm)
+            set(build_cpu armv7hl)
+        else()
+            if(NOT DEFINED VCPKG_MESON_CROSS_FILE OR NOT DEFINED VCPKG_MESON_NATIVE_FILE)
+                message(WARNING "Unsupported build architecture ${build_arch}! Please set VCPKG_MESON_(CROSS|NATIVE)_FILE to a meson file containing the build_machine entry!")
+            endif()
+            set(build_unknown TRUE)
+        endif()
+    elseif(CMAKE_HOST_UNIX)
+        # at this stage, CMAKE_HOST_SYSTEM_PROCESSOR is not defined
+        execute_process(
+            COMMAND uname -m
+            OUTPUT_VARIABLE MACHINE
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            COMMAND_ERROR_IS_FATAL ANY)
+
+        # Show real machine architecture to visually understand whether we are in a native Apple Silicon terminal or running under Rosetta emulation
+        debug_message("Machine: ${MACHINE}")
+
+        if(MACHINE MATCHES "arm64|aarch64")
+            set(build_cpu_fam aarch64)
+            set(build_cpu armv8)
+        elseif(MACHINE MATCHES "armv7h?l")
+            set(build_cpu_fam arm)
+            set(build_cpu ${MACHINE})
+        elseif(MACHINE MATCHES "x86_64|amd64")
+            set(build_cpu_fam x86_64)
+            set(build_cpu x86_64)
+        elseif(MACHINE MATCHES "x86|i686")
+            set(build_cpu_fam x86)
+            set(build_cpu i686)
+        elseif(MACHINE MATCHES "i386")
+            set(build_cpu_fam x86)
+            set(build_cpu i386)
+        elseif(MACHINE MATCHES "loongarch64")
+            set(build_cpu_fam loongarch64)
+            set(build_cpu loongarch64)
+        else()
+            # https://github.com/mesonbuild/meson/blob/master/docs/markdown/Reference-tables.md#cpu-families
+            if(NOT DEFINED VCPKG_MESON_CROSS_FILE OR NOT DEFINED VCPKG_MESON_NATIVE_FILE)
+                message(WARNING "Unhandled machine: ${MACHINE}! Please set VCPKG_MESON_(CROSS|NATIVE)_FILE to a meson file containing the build_machine entry!")
+            endif()
+            set(build_unknown TRUE)
+        endif()
+    else()
+        if(NOT DEFINED VCPKG_MESON_CROSS_FILE OR NOT DEFINED VCPKG_MESON_NATIVE_FILE)
+            message(WARNING "Failed to detect the build architecture! Please set VCPKG_MESON_(CROSS|NATIVE)_FILE to a meson file containing the build_machine entry!")
+        endif()
+        set(build_unknown TRUE)
+    endif()
+
+    set(build "[build_machine]\n") # Machine the build is performed on
+    string(APPEND build "endian = 'little'\n")
+    if(CMAKE_HOST_WIN32)
+        string(APPEND build "system = 'windows'\n")
+    elseif(CMAKE_HOST_APPLE)
+        string(APPEND build "system = 'darwin'\n")
+    elseif(CYGWIN)
+        string(APPEND build "system = 'cygwin'\n")
+    elseif(CMAKE_HOST_UNIX)
+        string(APPEND build "system = 'linux'\n")
+    else()
+        set(build_unknown TRUE)
+    endif()
+
+    if(DEFINED build_cpu_fam)
+        string(APPEND build "cpu_family = '${build_cpu_fam}'\n")
+    endif()
+    if(DEFINED build_cpu)
+        string(APPEND build "cpu = '${build_cpu}'")
+    endif()
+    if(NOT build_unknown)
+        set(${build_system} "${build}" PARENT_SCOPE)
+    endif()
+
+    set(host_unkown FALSE)
+    if(VCPKG_TARGET_ARCHITECTURE MATCHES "(amd|AMD|x|X)64")
+        set(host_cpu_fam x86_64)
+        set(host_cpu x86_64)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86")
+        set(host_cpu_fam x86)
+        set(host_cpu i686)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)64$")
+        set(host_cpu_fam aarch64)
+        set(host_cpu armv8)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)$")
+        set(host_cpu_fam arm)
+        set(host_cpu armv7hl)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "loongarch64")
+        set(host_cpu_fam loongarch64)
+        set(host_cpu loongarch64)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "wasm32")
+        set(host_cpu_fam wasm32)
+        set(host_cpu wasm32)
+    else()
+        if(NOT DEFINED VCPKG_MESON_CROSS_FILE OR NOT DEFINED VCPKG_MESON_NATIVE_FILE)
+            message(WARNING "Unsupported target architecture ${VCPKG_TARGET_ARCHITECTURE}! Please set VCPKG_MESON_(CROSS|NATIVE)_FILE to a meson file containing the host_machine entry!" )
+        endif()
+        set(host_unkown TRUE)
+    endif()
+
+    set(host "[host_machine]\n") # host=target in vcpkg. 
+    string(APPEND host "endian = 'little'\n")
+    if(NOT VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_TARGET_IS_MINGW OR VCPKG_TARGET_IS_UWP)
+        set(meson_system_name "windows")
+    else()
+        string(TOLOWER "${VCPKG_CMAKE_SYSTEM_NAME}" meson_system_name)
+    endif()
+    string(APPEND host "system = '${meson_system_name}'\n")
+    string(APPEND host "cpu_family = '${host_cpu_fam}'\n")
+    string(APPEND host "cpu = '${host_cpu}'")
+    if(NOT host_unkown)
+        set(${host_system} "${host}" PARENT_SCOPE)
+    endif()
+
+    if(NOT build_cpu_fam MATCHES "${host_cpu_fam}"
+       OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_IOS OR VCPKG_TARGET_IS_UWP
+       OR (VCPKG_TARGET_IS_MINGW AND NOT CMAKE_HOST_WIN32))
+        set(${is_cross} TRUE PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(z_vcpkg_meson_setup_extra_windows_variables config_type)
+    ## b_vscrt
+    if(VCPKG_CRT_LINKAGE STREQUAL "static")
+        set(crt_type "mt")
+    else()
+        set(crt_type "md")
+    endif()
+    if(config_type STREQUAL "DEBUG")
+        set(crt_type "${crt_type}d")
+    endif()
+    set(MESON_VSCRT_LINKAGE "b_vscrt = '${crt_type}'" PARENT_SCOPE)
+    ## winlibs
+    separate_arguments(c_winlibs NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES}")
+    separate_arguments(cpp_winlibs NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}")
+    z_vcpkg_meson_convert_list_to_python_array(c_winlibs ${c_winlibs})
+    z_vcpkg_meson_convert_list_to_python_array(cpp_winlibs ${cpp_winlibs})
+    set(MESON_WINLIBS "c_winlibs = ${c_winlibs}\n")
+    string(APPEND MESON_WINLIBS "cpp_winlibs = ${cpp_winlibs}")
+    set(MESON_WINLIBS "${MESON_WINLIBS}" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_meson_setup_variables config_type)
+    set(meson_var_list VSCRT_LINKAGE WINLIBS MT AR RC C C_LD CXX CXX_LD OBJC OBJC_LD OBJCXX OBJCXX_LD FC FC_LD WINDRES CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS FCFLAGS SHARED_LINKER_FLAGS)
+    foreach(var IN LISTS meson_var_list)
+        set(MESON_${var} "")
+    endforeach()
+
+    if(VCPKG_TARGET_IS_WINDOWS)
+        z_vcpkg_meson_setup_extra_windows_variables("${config_type}")
+    endif()
+
+    z_vcpkg_meson_set_proglist_variables("${config_type}")
+    z_vcpkg_meson_set_flags_variables("${config_type}")
+
+    foreach(var IN LISTS meson_var_list)
+        set(MESON_${var} "${MESON_${var}}" PARENT_SCOPE)
+    endforeach()
+endfunction()
+
+function(vcpkg_generate_meson_cmd_args)
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        ""
+        "OUTPUT;CONFIG"
+        "OPTIONS;LANGUAGES;ADDITIONAL_BINARIES;ADDITIONAL_PROPERTIES"
+    )
+
+    if(NOT arg_LANGUAGES)
+        set(arg_LANGUAGES C CXX)
+    endif()
+
+    vcpkg_list(JOIN arg_ADDITIONAL_BINARIES "\n" MESON_ADDITIONAL_BINARIES)
+    vcpkg_list(JOIN arg_ADDITIONAL_PROPERTIES "\n" MESON_ADDITIONAL_PROPERTIES)
+
+    set(buildtype "${arg_CONFIG}")
+
+    if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
+        z_vcpkg_select_default_vcpkg_chainload_toolchain()
+    endif()
+    vcpkg_list(APPEND VCPKG_CMAKE_CONFIGURE_OPTIONS "-DVCPKG_LANGUAGES=${arg_LANGUAGES}")
+    vcpkg_cmake_get_vars(cmake_vars_file)
+    debug_message("Including cmake vars from: ${cmake_vars_file}")
+    include("${cmake_vars_file}")
+
+    vcpkg_list(APPEND arg_OPTIONS --backend ninja --wrap-mode nodownload -Doptimization=plain)
+
+    z_vcpkg_get_build_and_host_system(MESON_HOST_MACHINE MESON_BUILD_MACHINE IS_CROSS)
+
+    if(arg_CONFIG STREQUAL "DEBUG")
+      set(suffix "dbg")
+    else()
+      string(SUBSTRING "${arg_CONFIG}" 0 3 suffix)
+      string(TOLOWER "${suffix}" suffix)
+    endif()
+    set(meson_input_file_${buildtype} "${CURRENT_BUILDTREES_DIR}/meson-${TARGET_TRIPLET}-${suffix}.log")
+
+    if(IS_CROSS)
+        # VCPKG_CROSSCOMPILING is not used since it regresses a lot of ports in x64-windows-x triplets
+        # For consistency this should proably be changed in the future?
+        vcpkg_list(APPEND arg_OPTIONS --native "${SCRIPTS}/buildsystems/meson/none.txt")
+        vcpkg_list(APPEND arg_OPTIONS --cross "${meson_input_file_${buildtype}}")
+    else()
+        vcpkg_list(APPEND arg_OPTIONS --native "${meson_input_file_${buildtype}}")
+    endif()
+
+    # User provided cross/native files
+    if(VCPKG_MESON_NATIVE_FILE)
+        vcpkg_list(APPEND arg_OPTIONS --native "${VCPKG_MESON_NATIVE_FILE}")
+    endif()
+    if(VCPKG_MESON_NATIVE_FILE_${buildtype})
+        vcpkg_list(APPEND arg_OPTIONS --native "${VCPKG_MESON_NATIVE_FILE_${buildtype}}")
+    endif()
+    if(VCPKG_MESON_CROSS_FILE)
+        vcpkg_list(APPEND arg_OPTIONS --cross "${VCPKG_MESON_CROSS_FILE}")
+    endif()
+    if(VCPKG_MESON_CROSS_FILE_${buildtype})
+        vcpkg_list(APPEND arg_OPTIONS --cross "${VCPKG_MESON_CROSS_FILE_${buildtype}}")
+    endif()
+
+    vcpkg_list(APPEND arg_OPTIONS --libdir lib) # else meson install into an architecture describing folder
+    vcpkg_list(APPEND arg_OPTIONS --pkgconfig.relocatable)
+
+    if(arg_CONFIG STREQUAL "RELEASE")
+      vcpkg_list(APPEND arg_OPTIONS -Ddebug=false --prefix "${CURRENT_PACKAGES_DIR}")
+      vcpkg_list(APPEND arg_OPTIONS "--pkg-config-path;['${CURRENT_INSTALLED_DIR}/lib/pkgconfig','${CURRENT_INSTALLED_DIR}/share/pkgconfig']")
+      if(VCPKG_TARGET_IS_WINDOWS)
+        vcpkg_list(APPEND arg_OPTIONS "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}/share']")
+      else()
+        vcpkg_list(APPEND arg_OPTIONS "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug']")
+      endif()
+    elseif(arg_CONFIG STREQUAL "DEBUG")
+      vcpkg_list(APPEND arg_OPTIONS -Ddebug=true --prefix "${CURRENT_PACKAGES_DIR}/debug" --includedir ../include)
+      vcpkg_list(APPEND arg_OPTIONS "--pkg-config-path;['${CURRENT_INSTALLED_DIR}/debug/lib/pkgconfig','${CURRENT_INSTALLED_DIR}/share/pkgconfig']")
+      if(VCPKG_TARGET_IS_WINDOWS)
+        vcpkg_list(APPEND arg_OPTIONS "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/share']")
+      else()
+        vcpkg_list(APPEND arg_OPTIONS "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}']")
+      endif()
+    else()
+      message(FATAL_ERROR "Unknown configuration. Only DEBUG and RELEASE are valid values.")
+    endif()
+
+    # Allow overrides / additional configuration variables from triplets
+    if(DEFINED VCPKG_MESON_CONFIGURE_OPTIONS)
+        vcpkg_list(APPEND arg_OPTIONS ${VCPKG_MESON_CONFIGURE_OPTIONS})
+    endif()
+    if(DEFINED VCPKG_MESON_CONFIGURE_OPTIONS_${buildtype})
+        vcpkg_list(APPEND arg_OPTIONS ${VCPKG_MESON_CONFIGURE_OPTIONS_${buildtype}})
+    endif()
+
+    if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
+        set(MESON_DEFAULT_LIBRARY shared)
+    else()
+        set(MESON_DEFAULT_LIBRARY static)
+    endif()
+    set(MESON_CMAKE_BUILD_TYPE "${cmake_build_type_${buildtype}}")
+    z_vcpkg_meson_setup_variables(${buildtype})
+    configure_file("${CMAKE_CURRENT_FUNCTION_LIST_DIR}/meson.template.in" "${meson_input_file_${buildtype}}" @ONLY)
+    set("${arg_OUTPUT}" ${arg_OPTIONS} PARENT_SCOPE)
+endfunction()
+
+function(vcpkg_configure_meson)
+    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "NO_PKG_CONFIG"
+        "SOURCE_PATH"
+        "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;LANGUAGES;ADDITIONAL_BINARIES;ADDITIONAL_NATIVE_BINARIES;ADDITIONAL_CROSS_BINARIES;ADDITIONAL_PROPERTIES"
+    )
+
+    if(DEFINED arg_ADDITIONAL_NATIVE_BINARIES OR DEFINED arg_ADDITIONAL_CROSS_BINARIES)
+        message(WARNING "Options ADDITIONAL_(NATIVE|CROSS)_BINARIES have been deprecated. Only use ADDITIONAL_BINARIES!")
+    endif()
+    vcpkg_list(APPEND arg_ADDITIONAL_BINARIES ${arg_ADDITIONAL_NATIVE_BINARIES} ${arg_ADDITIONAL_CROSS_BINARIES})
+    vcpkg_list(REMOVE_DUPLICATES arg_ADDITIONAL_BINARIES)
+
+    file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
+    file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
+
+    vcpkg_find_acquire_program(MESON)
+
+    get_filename_component(CMAKE_PATH "${CMAKE_COMMAND}" DIRECTORY)
+    vcpkg_add_to_path("${CMAKE_PATH}") # Make CMake invokeable for Meson
+
+    vcpkg_find_acquire_program(NINJA)
+
+    if(NOT arg_NO_PKG_CONFIG)
+      vcpkg_find_acquire_program(PKGCONFIG)
+      set(ENV{PKG_CONFIG} "${PKGCONFIG}")
+    endif()
+
+    vcpkg_find_acquire_program(PYTHON3)
+    get_filename_component(PYTHON3_DIR "${PYTHON3}" DIRECTORY)
+    vcpkg_add_to_path(PREPEND "${PYTHON3_DIR}")
+
+    set(buildtypes "")
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
+        set(buildname "DEBUG")
+        set(cmake_build_type_${buildname} "Debug")
+        vcpkg_list(APPEND buildtypes "${buildname}")
+        set(path_suffix_${buildname} "debug/")
+        set(suffix_${buildname} "dbg")
+    endif()
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+        set(buildname "RELEASE")
+        set(cmake_build_type_${buildname} "Release")
+        vcpkg_list(APPEND buildtypes "${buildname}")
+        set(path_suffix_${buildname} "")
+        set(suffix_${buildname} "rel")
+    endif()
+
+    # configure build
+    foreach(buildtype IN LISTS buildtypes)
+        message(STATUS "Configuring ${TARGET_TRIPLET}-${suffix_${buildtype}}")
+        file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}")
+
+        vcpkg_generate_meson_cmd_args(
+          OUTPUT cmd_args
+          CONFIG ${buildtype}
+          LANGUAGES ${arg_LANGUAGES}
+          OPTIONS ${arg_OPTIONS} ${arg_OPTIONS_${buildtype}}
+          ADDITIONAL_BINARIES ${arg_ADDITIONAL_BINARIES}
+          ADDITIONAL_PROPERTIES ${arg_ADDITIONAL_PROPERTIES}
+        )
+
+        vcpkg_execute_required_process(
+            COMMAND ${MESON} setup ${cmd_args} ${arg_SOURCE_PATH}
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}"
+            LOGNAME config-${TARGET_TRIPLET}-${suffix_${buildtype}}
+            SAVE_LOG_FILES
+                meson-logs/meson-log.txt
+                meson-info/intro-dependencies.json
+                meson-logs/install-log.txt
+        )
+
+        message(STATUS "Configuring ${TARGET_TRIPLET}-${suffix_${buildtype}} done")
+    endforeach()
+endfunction()

cmake/vcpkg-ports/vcpkg-tool-meson/vcpkg_install_meson.cmake

@@ -0,0 +1,71 @@
+function(vcpkg_install_meson)
+    cmake_parse_arguments(PARSE_ARGV 0 arg "ADD_BIN_TO_PATH" "" "")
+
+    vcpkg_find_acquire_program(NINJA)
+    unset(ENV{DESTDIR}) # installation directory was already specified with '--prefix' option
+
+    if(VCPKG_TARGET_IS_OSX)
+        vcpkg_backup_env_variables(VARS SDKROOT MACOSX_DEPLOYMENT_TARGET)
+        set(ENV{SDKROOT} "${VCPKG_DETECTED_CMAKE_OSX_SYSROOT}")
+        set(ENV{MACOSX_DEPLOYMENT_TARGET} "${VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET}")
+    endif()
+
+    foreach(buildtype IN ITEMS "debug" "release")
+        if(DEFINED VCPKG_BUILD_TYPE AND NOT VCPKG_BUILD_TYPE STREQUAL buildtype)
+            continue()
+        endif()
+
+        if(buildtype STREQUAL "debug")
+            set(short_buildtype "dbg")
+        else()
+            set(short_buildtype "rel")
+        endif()
+
+        message(STATUS "Package ${TARGET_TRIPLET}-${short_buildtype}")
+        if(arg_ADD_BIN_TO_PATH)
+            vcpkg_backup_env_variables(VARS PATH)
+            if(buildtype STREQUAL "debug")
+                vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/debug/bin")
+            else()
+                vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/bin")
+            endif()
+        endif()
+        vcpkg_execute_required_process(
+            COMMAND "${NINJA}" install -v
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_buildtype}"
+            LOGNAME package-${TARGET_TRIPLET}-${short_buildtype}
+        )
+        if(arg_ADD_BIN_TO_PATH)
+            vcpkg_restore_env_variables(VARS PATH)
+        endif()
+    endforeach()
+
+    vcpkg_list(SET renamed_libs)
+    if(VCPKG_TARGET_IS_WINDOWS AND VCPKG_LIBRARY_LINKAGE STREQUAL static AND NOT VCPKG_TARGET_IS_MINGW)
+        # Meson names all static libraries lib<name>.a which basically breaks the world
+        file(GLOB_RECURSE gen_libraries "${CURRENT_PACKAGES_DIR}*/**/lib*.a")
+        foreach(gen_library IN LISTS gen_libraries)
+            get_filename_component(libdir "${gen_library}" DIRECTORY)
+            get_filename_component(libname "${gen_library}" NAME)
+            string(REGEX REPLACE ".a$" ".lib" fixed_librawname "${libname}")
+            string(REGEX REPLACE "^lib" "" fixed_librawname "${fixed_librawname}")
+            file(RENAME "${gen_library}" "${libdir}/${fixed_librawname}")
+            # For cmake fixes.
+            string(REGEX REPLACE ".a$" "" origin_librawname "${libname}")
+            string(REGEX REPLACE ".lib$" "" fixed_librawname "${fixed_librawname}")
+            vcpkg_list(APPEND renamed_libs ${fixed_librawname})
+            set(${librawname}_old ${origin_librawname})
+            set(${librawname}_new ${fixed_librawname})
+        endforeach()
+        file(GLOB_RECURSE cmake_files "${CURRENT_PACKAGES_DIR}*/*.cmake")
+        foreach(cmake_file IN LISTS cmake_files)
+            foreach(current_lib IN LISTS renamed_libs)
+                vcpkg_replace_string("${cmake_file}" "${${current_lib}_old}" "${${current_lib}_new}" IGNORE_UNCHANGED)
+            endforeach()
+        endforeach()
+    endif()
+
+    if(VCPKG_TARGET_IS_OSX)
+        vcpkg_restore_env_variables(VARS SDKROOT MACOSX_DEPLOYMENT_TARGET)
+    endif()
+endfunction()

cmake/vcpkg-triplets/universal-osx.cmake

@@ -0,0 +1,8 @@
+# See https://github.com/microsoft/vcpkg/discussions/19454
+# NOTE: Try to keep in sync with default arm64-osx definition
+set(VCPKG_TARGET_ARCHITECTURE x64)
+set(VCPKG_CRT_LINKAGE dynamic)
+set(VCPKG_LIBRARY_LINKAGE static)
+
+set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
+set(VCPKG_OSX_ARCHITECTURES "arm64;x86_64")

default.nix

@@ -1,14 +1,4 @@
-(
-  import
-  (
-    let
-      lock = builtins.fromJSON (builtins.readFile ./flake.lock);
-    in
-      fetchTarball {
-        url = "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz";
-        sha256 = lock.nodes.flake-compat.locked.narHash;
-      }
-  )
-  {src = ./.;}
-)
-.defaultNix
+(import (fetchTarball {
+  url = "https://github.com/edolstra/flake-compat/archive/ff81ac966bb2cae68946d5ed5fc4994f96d0ffec.tar.gz";
+  sha256 = "sha256-NeCCThCEP3eCl2l/+27kNNK7QrwZB1IJCrXfrbv5oqU=";
+}) { src = ./.; }).defaultNix

flake.lock

@@ -1,86 +1,13 @@
 {
   "nodes": {
-    "flake-compat": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1696426674,
-        "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=",
-        "owner": "edolstra",
-        "repo": "flake-compat",
-        "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33",
-        "type": "github"
-      },
-      "original": {
-        "owner": "edolstra",
-        "repo": "flake-compat",
-        "type": "github"
-      }
-    },
-    "flake-parts": {
-      "inputs": {
-        "nixpkgs-lib": "nixpkgs-lib"
-      },
-      "locked": {
-        "lastModified": 1698882062,
-        "narHash": "sha256-HkhafUayIqxXyHH1X8d9RDl1M2CkFgZLjKD3MzabiEo=",
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "rev": "8c9fa2545007b49a5db5f650ae91f227672c3877",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "type": "github"
-      }
-    },
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1685518550,
-        "narHash": "sha256-o2d0KcvaXzTrPRIo0kOLV0/QXHhDQ5DTi+OxcjO8xqY=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "a1720a10a6cfe8234c0e93907ffe81be440f4cef",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "gitignore": {
-      "inputs": {
-        "nixpkgs": [
-          "pre-commit-hooks",
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1660459072,
-        "narHash": "sha256-8DFJjXG8zqoONA1vXtgeKXy68KdJL5UaXR8NtVMUbx8=",
-        "owner": "hercules-ci",
-        "repo": "gitignore.nix",
-        "rev": "a20de23b925fd8264fd7fad6454652e142fd7f73",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hercules-ci",
-        "repo": "gitignore.nix",
-        "type": "github"
-      }
-    },
     "libnbtplusplus": {
       "flake": false,
       "locked": {
-        "lastModified": 1690036783,
-        "narHash": "sha256-A5kTgICnx+Qdq3Fir/bKTfdTt/T1NQP2SC+nhN1ENug=",
+        "lastModified": 1744811532,
+        "narHash": "sha256-qhmjaRkt+O7A+gu6HjUkl7QzOEb4r8y8vWZMG2R/C6o=",
         "owner": "PrismLauncher",
         "repo": "libnbtplusplus",
-        "rev": "a5e8fd52b8bf4ab5d5bcc042b2a247867589985f",
+        "rev": "531449ba1c930c98e0bcf5d332b237a8566f9d78",
         "type": "github"
       },
       "original": {
@@ -89,106 +16,23 @@
         "type": "github"
       }
     },
-    "nix-filter": {
-      "locked": {
-        "lastModified": 1694857738,
-        "narHash": "sha256-bxxNyLHjhu0N8T3REINXQ2ZkJco0ABFPn6PIe2QUfqo=",
-        "owner": "numtide",
-        "repo": "nix-filter",
-        "rev": "41fd48e00c22b4ced525af521ead8792402de0ea",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "nix-filter",
-        "type": "github"
-      }
-    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1699094435,
-        "narHash": "sha256-YLZ5/KKZ1PyLrm2MO8UxRe4H3M0/oaYqNhSlq6FDeeA=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "9d5d25bbfe8c0297ebe85324addcb5020ed1a454",
-        "type": "github"
+        "lastModified": 1769089682,
+        "narHash": "sha256-Xu+7iYcAuOvsI2wdkUcIEmkqEJbvvE6n7qR9QNjJyP4=",
+        "rev": "078d69f03934859a181e81ba987c2bb033eebfc5",
+        "type": "tarball",
+        "url": "https://releases.nixos.org/nixos/25.11/nixos-25.11.4506.078d69f03934/nixexprs.tar.xz"
       },
       "original": {
-        "owner": "nixos",
-        "ref": "nixpkgs-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs-lib": {
-      "locked": {
-        "dir": "lib",
-        "lastModified": 1698611440,
-        "narHash": "sha256-jPjHjrerhYDy3q9+s5EAsuhyhuknNfowY6yt6pjn9pc=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "0cbe9f69c234a7700596e943bfae7ef27a31b735",
-        "type": "github"
-      },
-      "original": {
-        "dir": "lib",
-        "owner": "NixOS",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "pre-commit-hooks": {
-      "inputs": {
-        "flake-compat": [
-          "flake-compat"
-        ],
-        "flake-utils": "flake-utils",
-        "gitignore": "gitignore",
-        "nixpkgs": [
-          "nixpkgs"
-        ],
-        "nixpkgs-stable": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1698852633,
-        "narHash": "sha256-Hsc/cCHud8ZXLvmm8pxrXpuaPEeNaaUttaCvtdX/Wug=",
-        "owner": "cachix",
-        "repo": "pre-commit-hooks.nix",
-        "rev": "dec10399e5b56aa95fcd530e0338be72ad6462a0",
-        "type": "github"
-      },
-      "original": {
-        "owner": "cachix",
-        "repo": "pre-commit-hooks.nix",
-        "type": "github"
+        "type": "tarball",
+        "url": "https://channels.nixos.org/nixos-25.11/nixexprs.tar.xz"
       }
     },
     "root": {
       "inputs": {
-        "flake-compat": "flake-compat",
-        "flake-parts": "flake-parts",
         "libnbtplusplus": "libnbtplusplus",
-        "nix-filter": "nix-filter",
-        "nixpkgs": "nixpkgs",
-        "pre-commit-hooks": "pre-commit-hooks"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
+        "nixpkgs": "nixpkgs"
       }
     }
   },

flake.nix

@@ -1,44 +1,220 @@
 {
   description = "A custom launcher for Minecraft that allows you to easily manage multiple installations of Minecraft at once (Fork of MultiMC)";
 
+  nixConfig = {
+    extra-substituters = [ "https://prismlauncher.cachix.org" ];
+    extra-trusted-public-keys = [
+      "prismlauncher.cachix.org-1:9/n/FGyABA2jLUVfY+DEp4hKds/rwO+SCOtbOkDzd+c="
+    ];
+  };
+
   inputs = {
-    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
-    flake-parts.url = "github:hercules-ci/flake-parts";
-    nix-filter.url = "github:numtide/nix-filter";
-    pre-commit-hooks = {
-      url = "github:cachix/pre-commit-hooks.nix";
-      inputs.nixpkgs.follows = "nixpkgs";
-      inputs.nixpkgs-stable.follows = "nixpkgs";
-      inputs.flake-compat.follows = "flake-compat";
-    };
-    flake-compat = {
-      url = "github:edolstra/flake-compat";
-      flake = false;
-    };
+    nixpkgs.url = "https://channels.nixos.org/nixos-25.11/nixexprs.tar.xz";
+
     libnbtplusplus = {
       url = "github:PrismLauncher/libnbtplusplus";
       flake = false;
     };
   };
 
-  outputs = {
-    flake-parts,
-    pre-commit-hooks,
-    ...
-  } @ inputs:
-    flake-parts.lib.mkFlake {inherit inputs;} {
-      imports = [
-        pre-commit-hooks.flakeModule
+  outputs =
+    {
+      self,
+      nixpkgs,
+      libnbtplusplus,
+    }:
 
-        ./nix/dev.nix
-        ./nix/distribution.nix
-      ];
+    let
+      inherit (nixpkgs) lib;
 
-      systems = [
-        "x86_64-linux"
-        "aarch64-linux"
-        "x86_64-darwin"
-        "aarch64-darwin"
-      ];
+      # While we only officially support aarch and x86_64 on Linux and MacOS,
+      # we expose a reasonable amount of other systems for users who want to
+      # build for most exotic platforms
+      systems = lib.systems.flakeExposed;
+
+      forAllSystems = lib.genAttrs systems;
+      nixpkgsFor = forAllSystems (system: nixpkgs.legacyPackages.${system});
+    in
+
+    {
+      checks = forAllSystems (
+        system:
+
+        let
+          pkgs = nixpkgsFor.${system};
+          llvm = pkgs.llvmPackages_19;
+        in
+
+        {
+          formatting =
+            pkgs.runCommand "check-formatting"
+              {
+                nativeBuildInputs = with pkgs; [
+                  deadnix
+                  llvm.clang-tools
+                  markdownlint-cli
+                  nixfmt-rfc-style
+                  statix
+                ];
+              }
+              ''
+                cd ${self}
+
+                echo "Running clang-format...."
+                clang-format --dry-run --style='file' --Werror */**.{c,cc,cpp,h,hh,hpp}
+
+                echo "Running deadnix..."
+                deadnix --fail
+
+                echo "Running markdownlint..."
+                markdownlint --dot .
+
+                echo "Running nixfmt..."
+                find -type f -name '*.nix' -exec nixfmt --check {} +
+
+                echo "Running statix"
+                statix check .
+
+                touch $out
+              '';
+        }
+      );
+
+      devShells = forAllSystems (
+        system:
+
+        let
+          pkgs = nixpkgsFor.${system};
+          llvm = pkgs.llvmPackages_19;
+
+          packages' = self.packages.${system};
+
+          welcomeMessage = ''
+            Welcome to the Prism Launcher repository! 🌈
+
+            We just set some things up for you. To get building, you can run:
+
+            ```
+            $ cd "$cmakeBuildDir"
+            $ ninjaBuildPhase
+            $ ninjaInstallPhase
+            ```
+
+            Feel free to ask any questions in our Discord server or Matrix space:
+              - https://prismlauncher.org/discord
+              - https://matrix.to/#/#prismlauncher:matrix.org
+
+            And thanks for helping out :)
+          '';
+
+          # Re-use our package wrapper to wrap our development environment
+          qt-wrapper-env = packages'.prismlauncher.overrideAttrs (old: {
+            name = "qt-wrapper-env";
+
+            # Required to use script-based makeWrapper below
+            strictDeps = true;
+
+            # We don't need/want the unwrapped Prism package
+            paths = [ ];
+
+            nativeBuildInputs = old.nativeBuildInputs or [ ] ++ [
+              # Ensure the wrapper is script based so it can be sourced
+              pkgs.makeWrapper
+            ];
+
+            # Inspired by https://discourse.nixos.org/t/python-qt-woes/11808/10
+            buildCommand = ''
+              makeQtWrapper ${lib.getExe pkgs.runtimeShellPackage} "$out"
+              sed -i '/^exec/d' "$out"
+            '';
+          });
+        in
+
+        {
+          default = pkgs.mkShell {
+            name = "prism-launcher";
+
+            inputsFrom = [ packages'.prismlauncher-unwrapped ];
+
+            packages = with pkgs; [
+              ccache
+              llvm.clang-tools
+            ];
+
+            cmakeBuildType = "Debug";
+            cmakeFlags = [ "-GNinja" ] ++ packages'.prismlauncher.cmakeFlags;
+            dontFixCmake = true;
+
+            shellHook = ''
+              echo "Sourcing ${qt-wrapper-env}"
+              source ${qt-wrapper-env}
+
+              git submodule update --init --force
+
+              if [ ! -f compile_commands.json ]; then
+                cmakeConfigurePhase
+                cd ..
+                ln -s "$cmakeBuildDir"/compile_commands.json compile_commands.json
+              fi
+
+              echo ${lib.escapeShellArg welcomeMessage}
+            '';
+          };
+        }
+      );
+
+      formatter = forAllSystems (system: nixpkgsFor.${system}.nixfmt-rfc-style);
+
+      overlays.default = final: prev: {
+        prismlauncher-unwrapped = prev.callPackage ./nix/unwrapped.nix {
+          inherit
+            libnbtplusplus
+            self
+            ;
+        };
+
+        prismlauncher = final.callPackage ./nix/wrapper.nix { };
+      };
+
+      packages = forAllSystems (
+        system:
+
+        let
+          pkgs = nixpkgsFor.${system};
+
+          # Build a scope from our overlay
+          prismPackages = lib.makeScope pkgs.newScope (final: self.overlays.default final pkgs);
+
+          # Grab our packages from it and set the default
+          packages = {
+            inherit (prismPackages) prismlauncher-unwrapped prismlauncher;
+            default = prismPackages.prismlauncher;
+          };
+        in
+
+        # Only output them if they're available on the current system
+        lib.filterAttrs (_: lib.meta.availableOn pkgs.stdenv.hostPlatform) packages
+      );
+
+      # We put these under legacyPackages as they are meant for CI, not end user consumption
+      legacyPackages = forAllSystems (
+        system:
+
+        let
+          packages' = self.packages.${system};
+          legacyPackages' = self.legacyPackages.${system};
+        in
+
+        {
+          prismlauncher-debug = packages'.prismlauncher.override {
+            prismlauncher-unwrapped = legacyPackages'.prismlauncher-unwrapped-debug;
+          };
+
+          prismlauncher-unwrapped-debug = packages'.prismlauncher-unwrapped.overrideAttrs {
+            cmakeBuildType = "Debug";
+            dontStrip = true;
+          };
+        }
+      );
     };
 }

flatpak/libdecor.json

@@ -1,22 +0,0 @@
-{
-    "name": "libdecor",
-    "buildsystem": "meson",
-    "config-opts": [
-        "-Ddemo=false"
-    ],
-    "sources": [
-        {
-            "type": "git",
-            "url": "https://gitlab.freedesktop.org/libdecor/libdecor.git",
-            "commit": "73260393a97291c887e1074ab7f318e031be0ac6"
-        },
-        {
-            "type": "patch",
-            "path": "patches/weird_libdecor.patch"
-        }
-    ],
-    "cleanup": [
-        "/include",
-        "/lib/pkgconfig"
-    ]
-}

flatpak/org.prismlauncher.PrismLauncher.yml

@@ -1,158 +0,0 @@
-id: org.prismlauncher.PrismLauncher
-runtime: org.kde.Platform
-runtime-version: "5.15-22.08"
-sdk: org.kde.Sdk
-sdk-extensions:
-  - org.freedesktop.Sdk.Extension.openjdk17
-  - org.freedesktop.Sdk.Extension.openjdk8
-
-command: prismlauncher
-finish-args:
-  - --share=ipc
-  - --socket=x11
-  - --socket=wayland
-  - --device=all
-  - --share=network
-  - --socket=pulseaudio
-    # for Discord RPC mods
-  - --filesystem=xdg-run/app/com.discordapp.Discord:create
-    # Mod drag&drop
-  - --filesystem=xdg-download:ro
-    # FTBApp import
-  - --filesystem=~/.ftba:ro
-
-cleanup:
-  - /lib/libGLU*
-
-modules:
-  # Might be needed by some Controller mods (see https://github.com/isXander/Controlify/issues/31)
-  - shared-modules/libusb/libusb.json
-
-  # Needed for proper Wayland support
-  - libdecor.json
-
-  - name: prismlauncher
-    buildsystem: cmake-ninja
-    builddir: true
-    config-opts:
-      - -DLauncher_BUILD_PLATFORM=flatpak
-      - -DCMAKE_BUILD_TYPE=RelWithDebInfo
-      - -DLauncher_QT_VERSION_MAJOR=5
-    build-options:
-      env:
-        JAVA_HOME: /usr/lib/sdk/openjdk17/jvm/openjdk-17
-        JAVA_COMPILER: /usr/lib/sdk/openjdk17/jvm/openjdk-17/bin/javac
-    sources:
-      - type: dir
-        path: ../
-
-  - name: openjdk
-    buildsystem: simple
-    build-commands:
-      - mkdir -p /app/jdk/
-      - /usr/lib/sdk/openjdk17/install.sh
-      - mv /app/jre /app/jdk/17
-      - /usr/lib/sdk/openjdk8/install.sh
-      - mv /app/jre /app/jdk/8
-    cleanup:
-      - /jre
-
-  - name: glfw
-    buildsystem: cmake-ninja
-    config-opts:
-      - -DCMAKE_BUILD_TYPE=RelWithDebInfo
-      - -DBUILD_SHARED_LIBS:BOOL=ON
-      - -DGLFW_USE_WAYLAND=ON
-    sources:
-      - type: git
-        url: https://github.com/glfw/glfw.git
-        commit: 3fa2360720eeba1964df3c0ecf4b5df8648a8e52
-      - type: patch
-        path: patches/0003-Don-t-crash-on-calls-to-focus-or-icon.patch
-      - type: patch
-        path: patches/0005-Add-warning-about-being-an-unofficial-patch.patch
-      - type: patch
-        path: patches/0007-Platform-Prefer-Wayland-over-X11.patch
-    cleanup:
-      - /include
-      - /lib/cmake
-      - /lib/pkgconfig
-
-  - name: xrandr
-    buildsystem: autotools
-    sources:
-      - type: archive
-        url: https://xorg.freedesktop.org/archive/individual/app/xrandr-1.5.2.tar.xz
-        sha256: c8bee4790d9058bacc4b6246456c58021db58a87ddda1a9d0139bf5f18f1f240
-        x-checker-data:
-          type: anitya
-          project-id: 14957
-          stable-only: true
-          url-template: https://xorg.freedesktop.org/archive/individual/app/xrandr-$version.tar.xz
-    cleanup:
-      - /share/man
-      - /bin/xkeystone
-
-  - name: gamemode
-    buildsystem: meson
-    config-opts:
-      - -Dwith-sd-bus-provider=no-daemon
-      - -Dwith-examples=false
-    post-install:
-      # gamemoderun is installed for users who want to use wrapper commands
-      # post-install is running inside the build dir, we need it from the source though
-      - install -Dm755 ../data/gamemoderun -t /app/bin
-    sources:
-      - type: archive
-        archive-type: tar-gzip
-        url: https://api.github.com/repos/FeralInteractive/gamemode/tarball/1.7
-        sha256: 57ce73ba605d1cf12f8d13725006a895182308d93eba0f69f285648449641803
-        x-checker-data:
-          type: json
-          url: https://api.github.com/repos/FeralInteractive/gamemode/releases/latest
-          version-query: .tag_name
-          url-query: .tarball_url
-          timestamp-query: .published_at
-    cleanup:
-      - /include
-      - /lib/pkgconfig
-      - /lib/libgamemodeauto.a
-
-  - name: glxinfo
-    buildsystem: meson
-    config-opts:
-      - --bindir=/app/mesa-demos
-      - -Degl=disabled
-      - -Dglut=disabled
-      - -Dosmesa=disabled
-      - -Dvulkan=disabled
-      - -Dwayland=disabled
-    post-install:
-      - mv -v /app/mesa-demos/glxinfo /app/bin
-    sources:
-      - type: archive
-        url: https://archive.mesa3d.org/demos/mesa-demos-9.0.0.tar.xz
-        sha256: 3046a3d26a7b051af7ebdd257a5f23bfeb160cad6ed952329cdff1e9f1ed496b
-        x-checker-data:
-          type: anitya
-          project-id: 16781
-          stable-only: true
-          url-template: https://archive.mesa3d.org/demos/mesa-demos-$version.tar.xz
-    cleanup:
-      - /include
-      - /mesa-demos
-      - /share
-    modules:
-      - shared-modules/glu/glu-9.json
-
-  - name: enhance
-    buildsystem: simple
-    build-commands:
-      - install -Dm755 prime-run /app/bin/prime-run
-      - mv /app/bin/prismlauncher /app/bin/prismrun
-      - install -Dm755 prismlauncher /app/bin/prismlauncher
-    sources:
-      - type: file
-        path: prime-run
-      - type: file
-        path: prismlauncher

flatpak/patches/0003-Don-t-crash-on-calls-to-focus-or-icon.patch

@@ -1,24 +0,0 @@
-diff --git a/src/wl_window.c b/src/wl_window.c
-index 52d3b9eb..4ac4eb5d 100644
---- a/src/wl_window.c
-+++ b/src/wl_window.c
-@@ -2117,8 +2117,7 @@ void _glfwSetWindowTitleWayland(_GLFWwindow* window, const char* title)
- void _glfwSetWindowIconWayland(_GLFWwindow* window,
-                                int count, const GLFWimage* images)
- {
--    _glfwInputError(GLFW_FEATURE_UNAVAILABLE,
--                    "Wayland: The platform does not support setting the window icon");
-+    fprintf(stderr, "!!! Ignoring Error: Wayland: The platform does not support setting the window icon\n");
- }
- 
- void _glfwGetWindowPosWayland(_GLFWwindow* window, int* xpos, int* ypos)
-@@ -2361,8 +2360,7 @@ void _glfwRequestWindowAttentionWayland(_GLFWwindow* window)
- 
- void _glfwFocusWindowWayland(_GLFWwindow* window)
- {
--    _glfwInputError(GLFW_FEATURE_UNAVAILABLE,
--                    "Wayland: The platform does not support setting the input focus");
-+    fprintf(stderr, "!!! Ignoring Error: Wayland: The platform does not support setting the input focus\n");
- }
- 
- void _glfwSetWindowMonitorWayland(_GLFWwindow* window,

flatpak/patches/0005-Add-warning-about-being-an-unofficial-patch.patch

@@ -1,17 +0,0 @@
-diff --git a/src/init.c b/src/init.c
-index 06dbb3f2..a7c6da86 100644
---- a/src/init.c
-+++ b/src/init.c
-@@ -449,6 +449,12 @@ GLFWAPI int glfwInit(void)
-     _glfw.initialized = GLFW_TRUE;
- 
-     glfwDefaultWindowHints();
-+
-+    fprintf(stderr, "!!! Patched GLFW from https://github.com/Admicos/minecraft-wayland\n"
-+         "!!! If any issues with the window, or some issues with rendering, occur, "
-+         "first try with the built-in GLFW, and if that solves the issue, report there first.\n"
-+         "!!! Use outside Minecraft is untested, and things might break.\n");
-+
-     return GLFW_TRUE;
- }
- 

flatpak/patches/0007-Platform-Prefer-Wayland-over-X11.patch

@@ -1,20 +0,0 @@
-diff --git a/src/platform.c b/src/platform.c
-index c5966ae7..3e7442f9 100644
---- a/src/platform.c
-+++ b/src/platform.c
-@@ -49,12 +49,12 @@ static const struct
- #if defined(_GLFW_COCOA)
-     { GLFW_PLATFORM_COCOA, _glfwConnectCocoa },
- #endif
--#if defined(_GLFW_X11)
--    { GLFW_PLATFORM_X11, _glfwConnectX11 },
--#endif
- #if defined(_GLFW_WAYLAND)
-     { GLFW_PLATFORM_WAYLAND, _glfwConnectWayland },
- #endif
-+#if defined(_GLFW_X11)
-+    { GLFW_PLATFORM_X11, _glfwConnectX11 },
-+#endif
- };
- 
- GLFWbool _glfwSelectPlatform(int desiredID, _GLFWplatform* platform)

flatpak/patches/weird_libdecor.patch

@@ -1,40 +0,0 @@
-diff --git a/src/libdecor.c b/src/libdecor.c
-index a9c1106..1aa38b3 100644
---- a/src/libdecor.c
-+++ b/src/libdecor.c
-@@ -1391,22 +1391,32 @@ calculate_priority(const struct libdecor_plugin_description *plugin_description)
- static bool
- check_symbol_conflicts(const struct libdecor_plugin_description *plugin_description)
- {
-+	bool ret = true;
- 	char * const *symbol;
-+	void* main_prog = dlopen(NULL, RTLD_LAZY);
-+	if (!main_prog) {
-+		fprintf(stderr, "Plugin \"%s\" couldn't check conflicting symbols: \"%s\".\n",
-+					plugin_description->description, dlerror());
-+		return false;
-+	}
-+
- 
- 	symbol = plugin_description->conflicting_symbols;
- 	while (*symbol) {
- 		dlerror();
--		dlsym (RTLD_DEFAULT, *symbol);
-+		dlsym (main_prog, *symbol);
- 		if (!dlerror()) {
- 			fprintf(stderr, "Plugin \"%s\" uses conflicting symbol \"%s\".\n",
- 					plugin_description->description, *symbol);
--			return false;
-+			ret = false;
-+			break;
- 		}
- 
- 		symbol++;
- 	}
- 
--	return true;
-+	dlclose(main_prog);
-+	return ret;
- }
- 
- static struct plugin_loader *

flatpak/prime-run

@@ -1,4 +0,0 @@
-#!/bin/sh
-
-export __NV_PRIME_RENDER_OFFLOAD=1 __VK_LAYER_NV_optimus=NVIDIA_only __GLX_VENDOR_LIBRARY_NAME=nvidia
-exec "$@"

flatpak/prismlauncher

@@ -1,11 +0,0 @@
-#!/bin/bash
-
-# discord RPC
-for i in {0..9}; do
-    test -S "$XDG_RUNTIME_DIR"/discord-ipc-"$i" || ln -sf {app/com.discordapp.Discord,"$XDG_RUNTIME_DIR"}/discord-ipc-"$i";
-done
-
-export PATH="${PATH}${PATH:+:}/usr/lib/extensions/vulkan/gamescope/bin:/usr/lib/extensions/vulkan/MangoHud/bin"
-export VK_LAYER_PATH="/usr/lib/extensions/vulkan/share/vulkan/implicit_layer.d/"
-
-exec /app/bin/prismrun "$@"

garnix.yaml

@@ -1,6 +0,0 @@
-builds:
-  exclude: []
-  include:
-    - "checks.x86_64-linux.*"
-    - "devShells.*.*"
-    - "packages.*.*"

launcher/Application.h

@@ -42,18 +42,20 @@
 #include <QDebug>
 #include <QFlag>
 #include <QIcon>
+#include <QMutex>
 #include <QUrl>
 #include <memory>
 
 #include <BaseInstance.h>
 
-#include "minecraft/launch/MinecraftServerTarget.h"
-#include "ui/themes/CatPack.h"
+#include "launch/LogModel.h"
+#include "minecraft/launch/MinecraftTarget.h"
 
 class LaunchController;
 class LocalPeer;
 class InstanceWindow;
 class MainWindow;
+class ViewLogWindow;
 class SetupWizard;
 class GenericPageProvider;
 class QFile;
@@ -82,6 +84,12 @@ class Index;
 #endif
 #define APPLICATION (static_cast<Application*>(QCoreApplication::instance()))
 
+// Used for checking if is a test
+#if defined(APPLICATION_DYN)
+#undef APPLICATION_DYN
+#endif
+#define APPLICATION_DYN (dynamic_cast<Application*>(QCoreApplication::instance()))
+
 class Application : public QApplication {
     // friends for the purpose of limiting access to deprecated stuff
     Q_OBJECT
@@ -104,29 +112,29 @@ class Application : public QApplication {
 
     bool event(QEvent* event) override;
 
-    std::shared_ptr<SettingsObject> settings() const { return m_settings; }
+    SettingsObject* settings() const { return m_settings.get(); }
 
-    qint64 timeSinceStart() const { return startTime.msecsTo(QDateTime::currentDateTime()); }
+    qint64 timeSinceStart() const { return m_startTime.msecsTo(QDateTime::currentDateTime()); }
 
-    QIcon getThemedIcon(const QString& name);
+    QIcon logo();
 
     ThemeManager* themeManager() { return m_themeManager.get(); }
 
-    shared_qobject_ptr<ExternalUpdater> updater() { return m_updater; }
+    ExternalUpdater* updater() { return m_updater.get(); }
 
     void triggerUpdateCheck();
 
-    std::shared_ptr<TranslationsModel> translations();
+    TranslationsModel* translations();
 
-    std::shared_ptr<JavaInstallList> javalist();
+    JavaInstallList* javalist();
 
-    std::shared_ptr<InstanceList> instances() const { return m_instances; }
+    InstanceList* instances() const { return m_instances.get(); }
 
-    std::shared_ptr<IconList> icons() const { return m_icons; }
+    IconList* icons() const { return m_icons.get(); }
 
     MCEditTool* mcedit() const { return m_mcedit.get(); }
 
-    shared_qobject_ptr<AccountList> accounts() const { return m_accounts; }
+    AccountList* accounts() const { return m_accounts.get(); }
 
     Status status() const { return m_status; }
 
@@ -134,11 +142,11 @@ class Application : public QApplication {
 
     void updateProxySettings(QString proxyTypeStr, QString addr, int port, QString user, QString password);
 
-    shared_qobject_ptr<QNetworkAccessManager> network();
+    QNetworkAccessManager* network();
 
-    shared_qobject_ptr<HttpMetaCache> metacache();
+    HttpMetaCache* metacache();
 
-    shared_qobject_ptr<Meta::Index> metadataIndex();
+    Meta::Index* metadataIndex();
 
     void updateCapabilities();
 
@@ -154,7 +162,6 @@ class Application : public QApplication {
     QString getFlameAPIKey();
     QString getModrinthAPIToken();
     QString getUserAgent();
-    QString getUserAgentUncached();
 
     /// this is the root of the 'installation'. Used for automatic updates
     const QString& root() { return m_rootPath; }
@@ -162,6 +169,9 @@ class Application : public QApplication {
     /// the data path the application is using
     const QString& dataRoot() { return m_dataPath; }
 
+    /// the java installed path the application is using
+    const QString javaPath();
+
     bool isPortable() { return m_portable; }
 
     const Capabilities capabilities() { return m_capabilities; }
@@ -172,16 +182,15 @@ class Application : public QApplication {
      */
     bool openJsonEditor(const QString& filename);
 
-    InstanceWindow* showInstanceWindow(InstancePtr instance, QString page = QString());
+    InstanceWindow* showInstanceWindow(BaseInstance* instance, QString page = QString());
     MainWindow* showMainWindow(bool minimized = false);
+    ViewLogWindow* showLogWindow();
 
     void updateIsRunning(bool running);
     bool updatesAreAllowed();
 
     void ShowGlobalSettings(class QWidget* parent, QString open_page = QString());
 
-    int suitableMaxMem();
-
     bool updaterEnabled();
     QString updaterBinaryName();
 
@@ -190,27 +199,29 @@ class Application : public QApplication {
    signals:
     void updateAllowedChanged(bool status);
     void globalSettingsAboutToOpen();
-    void globalSettingsClosed();
+    void globalSettingsApplied();
     int currentCatChanged(int index);
 
+    void oauthReplyRecieved(QVariantMap);
+
 #ifdef Q_OS_MACOS
     void clickedOnDock();
 #endif
 
    public slots:
-    bool launch(InstancePtr instance,
+    bool launch(BaseInstance* instance,
                 bool online = true,
                 bool demo = false,
-                MinecraftServerTargetPtr serverToJoin = nullptr,
-                MinecraftAccountPtr accountToUse = nullptr);
-    bool kill(InstancePtr instance);
+                MinecraftTarget::Ptr targetToJoin = nullptr,
+                MinecraftAccountPtr accountToUse = nullptr,
+                const QString& offlineName = QString());
+    bool kill(BaseInstance* instance);
     void closeCurrentWindow();
 
    private slots:
     void on_windowClose();
     void messageReceived(const QByteArray& message);
-    void controllerSucceeded();
-    void controllerFailed(const QString& error);
+    void controllerFinished();
     void setupWizardFinished(int status);
 
    private:
@@ -227,22 +238,26 @@ class Application : public QApplication {
     bool shouldExitNow() const;
 
    private:
-    QDateTime startTime;
+    QHash<QString, int> m_qsaveResources;
+    mutable QMutex m_qsaveResourcesMutex;
 
-    shared_qobject_ptr<QNetworkAccessManager> m_network;
+   private:
+    QDateTime m_startTime;
 
-    shared_qobject_ptr<ExternalUpdater> m_updater;
-    shared_qobject_ptr<AccountList> m_accounts;
+    std::unique_ptr<QNetworkAccessManager> m_network;
 
-    shared_qobject_ptr<HttpMetaCache> m_metacache;
-    shared_qobject_ptr<Meta::Index> m_metadataIndex;
+    std::unique_ptr<ExternalUpdater> m_updater;
+    std::unique_ptr<AccountList> m_accounts;
 
-    std::shared_ptr<SettingsObject> m_settings;
-    std::shared_ptr<InstanceList> m_instances;
-    std::shared_ptr<IconList> m_icons;
-    std::shared_ptr<JavaInstallList> m_javalist;
-    std::shared_ptr<TranslationsModel> m_translations;
-    std::shared_ptr<GenericPageProvider> m_globalSettingsProvider;
+    std::unique_ptr<HttpMetaCache> m_metacache;
+    std::unique_ptr<Meta::Index> m_metadataIndex;
+
+    std::unique_ptr<SettingsObject> m_settings;
+    std::unique_ptr<InstanceList> m_instances;
+    std::unique_ptr<IconList> m_icons;
+    std::unique_ptr<JavaInstallList> m_javalist;
+    std::unique_ptr<TranslationsModel> m_translations;
+    std::unique_ptr<GenericPageProvider> m_globalSettingsProvider;
     std::unique_ptr<MCEditTool> m_mcedit;
     QSet<QString> m_features;
     std::unique_ptr<ThemeManager> m_themeManager;
@@ -267,9 +282,10 @@ class Application : public QApplication {
     // FIXME: attach to instances instead.
     struct InstanceXtras {
         InstanceWindow* window = nullptr;
-        shared_qobject_ptr<LaunchController> controller;
+        std::unique_ptr<LaunchController> controller;
     };
     std::map<QString, InstanceXtras> m_instanceExtras;
+    mutable QMutex m_instanceExtrasMutex;
 
     // main state variables
     size_t m_openWindows = 0;
@@ -279,6 +295,9 @@ class Application : public QApplication {
     // main window, if any
     MainWindow* m_mainWindow = nullptr;
 
+    // log window, if any
+    ViewLogWindow* m_viewLogWindow = nullptr;
+
     // peer launcher instance connector - used to implement single instance launcher and signalling
     LocalPeer* m_peerInstance = nullptr;
 
@@ -289,9 +308,18 @@ class Application : public QApplication {
     QString m_detectedOpenALPath;
     QString m_instanceIdToLaunch;
     QString m_serverToJoin;
+    QString m_worldToJoin;
     QString m_profileToUse;
+    bool m_offline = false;
+    QString m_offlineName;
     bool m_liveCheck = false;
     QList<QUrl> m_urlsToImport;
     QString m_instanceIdToShowWindowOf;
     std::unique_ptr<QFile> logFile;
+    std::unique_ptr<LogModel> logModel;
+
+   public:
+    void addQSavePath(QString);
+    void removeQSavePath(QString);
+    bool checkQSavePath(QString);
 };

launcher/AssertHelpers.h

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2025 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
+
+#if defined(ASSERT_NEVER)
+#error ASSERT_NEVER already defined
+#else
+#define ASSERT_NEVER(cond) (Q_ASSERT((cond) == false), (cond))
+#endif

launcher/BaseInstaller.cpp

@@ -16,6 +16,7 @@
 #include <QFile>
 
 #include "BaseInstaller.h"
+#include "FileSystem.h"
 #include "minecraft/MinecraftInstance.h"
 
 BaseInstaller::BaseInstaller() {}
@@ -42,7 +43,7 @@ bool BaseInstaller::add(MinecraftInstance* to)
 
 bool BaseInstaller::remove(MinecraftInstance* from)
 {
-    return QFile::remove(filename(from->instanceRoot()));
+    return FS::deletePath(filename(from->instanceRoot()));
 }
 
 QString BaseInstaller::filename(const QString& root) const

launcher/BaseInstaller.h

@@ -29,7 +29,7 @@ class BaseVersion;
 class BaseInstaller {
    public:
     BaseInstaller();
-    virtual ~BaseInstaller(){};
+    virtual ~BaseInstaller() {};
     bool isApplied(MinecraftInstance* on);
 
     virtual bool add(MinecraftInstance* to);

launcher/BaseInstance.cpp

@@ -42,8 +42,10 @@
 #include <QFileInfo>
 #include <QJsonDocument>
 #include <QJsonObject>
-#include <QRegularExpression>
 
+#include "Application.h"
+#include "Json.h"
+#include "launch/LaunchTask.h"
 #include "settings/INISettingsObject.h"
 #include "settings/OverrideSetting.h"
 #include "settings/Setting.h"
@@ -52,9 +54,26 @@
 #include "Commandline.h"
 #include "FileSystem.h"
 
-BaseInstance::BaseInstance(SettingsObjectPtr globalSettings, SettingsObjectPtr settings, const QString& rootDir) : QObject()
+int getConsoleMaxLines(SettingsObject* settings)
 {
-    m_settings = settings;
+    auto lineSetting = settings->getSetting("ConsoleMaxLines");
+    bool conversionOk = false;
+    int maxLines = lineSetting->get().toInt(&conversionOk);
+    if (!conversionOk) {
+        maxLines = lineSetting->defValue().toInt();
+        qWarning() << "ConsoleMaxLines has nonsensical value, defaulting to" << maxLines;
+    }
+    return maxLines;
+}
+
+bool shouldStopOnConsoleOverflow(SettingsObject* settings)
+{
+    return settings->get("ConsoleOverflowStop").toBool();
+}
+
+BaseInstance::BaseInstance(SettingsObject* globalSettings, std::unique_ptr<SettingsObject> settings, const QString& rootDir) : QObject()
+{
+    m_settings = std::move(settings);
     m_global_settings = globalSettings;
     m_rootDir = rootDir;
 
@@ -64,9 +83,12 @@ BaseInstance::BaseInstance(SettingsObjectPtr globalSettings, SettingsObjectPtr s
 
     m_settings->registerSetting("lastLaunchTime", 0);
     m_settings->registerSetting("totalTimePlayed", 0);
+    if (m_settings->get("totalTimePlayed").toLongLong() < 0)
+        m_settings->reset("totalTimePlayed");
     m_settings->registerSetting("lastTimePlayed", 0);
 
     m_settings->registerSetting("linkedInstances", "[]");
+    m_settings->registerSetting("shortcuts", QString());
 
     // Game time override
     auto gameTimeOverride = m_settings->registerSetting("OverrideGameTime", false);
@@ -105,6 +127,8 @@ BaseInstance::BaseInstance(SettingsObjectPtr globalSettings, SettingsObjectPtr s
     m_settings->registerSetting("Profiler", "");
 }
 
+BaseInstance::~BaseInstance() {}
+
 QString BaseInstance::getPreLaunchCommand()
 {
     return settings()->get("PreLaunchCommand").toString();
@@ -172,46 +196,35 @@ void BaseInstance::copyManagedPack(BaseInstance& other)
     m_settings->set("ManagedPackName", other.getManagedPackName());
     m_settings->set("ManagedPackVersionID", other.getManagedPackVersionID());
     m_settings->set("ManagedPackVersionName", other.getManagedPackVersionName());
-}
 
-int BaseInstance::getConsoleMaxLines() const
-{
-    auto lineSetting = m_settings->getSetting("ConsoleMaxLines");
-    bool conversionOk = false;
-    int maxLines = lineSetting->get().toInt(&conversionOk);
-    if (!conversionOk) {
-        maxLines = lineSetting->defValue().toInt();
-        qWarning() << "ConsoleMaxLines has nonsensical value, defaulting to" << maxLines;
+    if (APPLICATION->settings()->get("AutomaticJavaSwitch").toBool() && m_settings->get("AutomaticJava").toBool() &&
+        m_settings->get("OverrideJavaLocation").toBool()) {
+        m_settings->set("OverrideJavaLocation", false);
+        m_settings->set("JavaPath", "");
     }
-    return maxLines;
-}
-
-bool BaseInstance::shouldStopOnConsoleOverflow() const
-{
-    return m_settings->get("ConsoleOverflowStop").toBool();
 }
 
 QStringList BaseInstance::getLinkedInstances() const
 {
-    return m_settings->get("linkedInstances").toStringList();
+    auto setting = m_settings->get("linkedInstances").toString();
+    return Json::toStringList(setting);
 }
 
 void BaseInstance::setLinkedInstances(const QStringList& list)
 {
-    auto linkedInstances = m_settings->get("linkedInstances").toStringList();
-    m_settings->set("linkedInstances", list);
+    m_settings->set("linkedInstances", Json::fromStringList(list));
 }
 
 void BaseInstance::addLinkedInstanceId(const QString& id)
 {
-    auto linkedInstances = m_settings->get("linkedInstances").toStringList();
+    auto linkedInstances = getLinkedInstances();
     linkedInstances.append(id);
     setLinkedInstances(linkedInstances);
 }
 
 bool BaseInstance::removeLinkedInstanceId(const QString& id)
 {
-    auto linkedInstances = m_settings->get("linkedInstances").toStringList();
+    auto linkedInstances = getLinkedInstances();
     int numRemoved = linkedInstances.removeAll(id);
     setLinkedInstances(linkedInstances);
     return numRemoved > 0;
@@ -219,7 +232,7 @@ bool BaseInstance::removeLinkedInstanceId(const QString& id)
 
 bool BaseInstance::isLinkedToInstanceId(const QString& id) const
 {
-    auto linkedInstances = m_settings->get("linkedInstances").toStringList();
+    auto linkedInstances = getLinkedInstances();
     return linkedInstances.contains(id);
 }
 
@@ -267,13 +280,18 @@ void BaseInstance::setRunning(bool running)
 
     m_isRunning = running;
 
-    if (!m_settings->get("RecordGameTime").toBool()) {
-        emit runningStatusChanged(running);
+    emit runningStatusChanged(running);
+}
+
+void BaseInstance::setMinecraftRunning(bool running)
+{
+    if (!settings()->get("RecordGameTime").toBool()) {
         return;
     }
 
     if (running) {
         m_timeStarted = QDateTime::currentDateTime();
+        setLastLaunch(m_timeStarted.toMSecsSinceEpoch());
     } else {
         QDateTime timeEnded = QDateTime::currentDateTime();
 
@@ -283,8 +301,6 @@ void BaseInstance::setRunning(bool running)
 
         emit propertiesChanged(this);
     }
-
-    emit runningStatusChanged(running);
 }
 
 int64_t BaseInstance::totalTimePlayed() const
@@ -322,11 +338,11 @@ QString BaseInstance::instanceRoot() const
     return m_rootDir;
 }
 
-SettingsObjectPtr BaseInstance::settings()
+SettingsObject* BaseInstance::settings()
 {
     loadSpecificSettings();
 
-    return m_settings;
+    return m_settings.get();
 }
 
 bool BaseInstance::canLaunch() const
@@ -381,6 +397,63 @@ void BaseInstance::setName(QString val)
     emit propertiesChanged(this);
 }
 
+bool BaseInstance::syncInstanceDirName(const QString& newRoot) const
+{
+    auto oldRoot = instanceRoot();
+    return oldRoot == newRoot || QFile::rename(oldRoot, newRoot);
+}
+
+void BaseInstance::registerShortcut(const ShortcutData& data)
+{
+    auto currentShortcuts = shortcuts();
+    currentShortcuts.append(data);
+    qDebug() << "Registering shortcut for instance" << id() << "with name" << data.name << "and path" << data.filePath;
+    setShortcuts(currentShortcuts);
+}
+
+void BaseInstance::setShortcuts(const QList<ShortcutData>& shortcuts)
+{
+    // FIXME: if no change, do not set. setting involves saving a file.
+    QJsonArray array;
+    for (const auto& elem : shortcuts) {
+        array.append(QJsonObject{ { "name", elem.name }, { "filePath", elem.filePath }, { "target", static_cast<int>(elem.target) } });
+    }
+
+    QJsonDocument document;
+    document.setArray(array);
+    m_settings->set("shortcuts", QString::fromUtf8(document.toJson(QJsonDocument::Compact)));
+}
+
+QList<ShortcutData> BaseInstance::shortcuts() const
+{
+    auto data = m_settings->get("shortcuts").toString().toUtf8();
+    QJsonParseError parseError;
+    auto document = QJsonDocument::fromJson(data, &parseError);
+    if (parseError.error != QJsonParseError::NoError || !document.isArray())
+        return {};
+
+    QList<ShortcutData> results;
+    for (const auto& elem : document.array()) {
+        if (!elem.isObject())
+            continue;
+        auto dict = elem.toObject();
+        if (!dict.contains("name") || !dict.contains("filePath") || !dict.contains("target"))
+            continue;
+        int value = dict["target"].toInt(-1);
+        if (!dict["name"].isString() || !dict["filePath"].isString() || value < 0 || value >= 3)
+            continue;
+
+        QString shortcutName = dict["name"].toString();
+        QString filePath = dict["filePath"].toString();
+        if (!QDir(filePath).exists()) {
+            qWarning() << "Shortcut" << shortcutName << "for instance" << name() << "have non-existent path" << filePath;
+            continue;
+        }
+        results.append({ shortcutName, filePath, static_cast<ShortcutTarget>(value) });
+    }
+    return results;
+}
+
 QString BaseInstance::name() const
 {
     return m_settings->get("name").toString();
@@ -397,12 +470,17 @@ QStringList BaseInstance::extraArguments()
     return Commandline::splitArgs(settings()->get("JvmArgs").toString());
 }
 
-shared_qobject_ptr<LaunchTask> BaseInstance::getLaunchTask()
+LaunchTask* BaseInstance::getLaunchTask()
 {
-    return m_launchProcess;
+    return m_launchProcess.get();
 }
 
 void BaseInstance::updateRuntimeContext()
 {
     // NOOP
 }
+
+bool BaseInstance::isLegacy()
+{
+    return traits().contains("legacyLaunch") || traits().contains("alphaLaunch");
+}

launcher/BaseInstance.h

@@ -38,7 +38,9 @@
 #pragma once
 #include <cassert>
 
+#include <QDataStream>
 #include <QDateTime>
+#include <QList>
 #include <QMenu>
 #include <QObject>
 #include <QProcess>
@@ -50,21 +52,31 @@
 #include "BaseVersionList.h"
 #include "MessageLevel.h"
 #include "minecraft/auth/MinecraftAccount.h"
-#include "pathmatcher/IPathMatcher.h"
 #include "settings/INIFile.h"
 
 #include "net/Mode.h"
 
 #include "RuntimeContext.h"
-#include "minecraft/launch/MinecraftServerTarget.h"
+#include "minecraft/launch/MinecraftTarget.h"
 
 class QDir;
 class Task;
 class LaunchTask;
 class BaseInstance;
 
-// pointer for lazy people
-using InstancePtr = std::shared_ptr<BaseInstance>;
+/// Shortcut saving target representations
+enum class ShortcutTarget { Desktop, Applications, Other };
+
+/// Shortcut data representation
+struct ShortcutData {
+    QString name;
+    QString filePath;
+    ShortcutTarget target = ShortcutTarget::Other;
+};
+
+/// Console settings
+int getConsoleMaxLines(SettingsObject* settings);
+bool shouldStopOnConsoleOverflow(SettingsObject* settings);
 
 /*!
  * \brief Base class for instances.
@@ -74,11 +86,11 @@ using InstancePtr = std::shared_ptr<BaseInstance>;
  * To create a new instance type, create a new class inheriting from this class
  * and implement the pure virtual functions.
  */
-class BaseInstance : public QObject, public std::enable_shared_from_this<BaseInstance> {
+class BaseInstance : public QObject {
     Q_OBJECT
    protected:
     /// no-touchy!
-    BaseInstance(SettingsObjectPtr globalSettings, SettingsObjectPtr settings, const QString& rootDir);
+    BaseInstance(SettingsObject* globalSettings, std::unique_ptr<SettingsObject> settings, const QString& rootDir);
 
    public: /* types */
     enum class Status {
@@ -88,7 +100,7 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
 
    public:
     /// virtual destructor to make sure the destruction is COMPLETE
-    virtual ~BaseInstance() {}
+    virtual ~BaseInstance();
 
     virtual void saveNow() = 0;
 
@@ -104,6 +116,7 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
     /// be unique.
     virtual QString id() const;
 
+    void setMinecraftRunning(bool running);
     void setRunning(bool running);
     bool isRunning() const;
     int64_t totalTimePlayed() const;
@@ -125,6 +138,14 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
     QString name() const;
     void setName(QString val);
 
+    /// Sync name and rename instance dir accordingly; returns true if successful
+    bool syncInstanceDirName(const QString& newRoot) const;
+
+    /// Register a created shortcut
+    void registerShortcut(const ShortcutData& data);
+    QList<ShortcutData> shortcuts() const;
+    void setShortcuts(const QList<ShortcutData>& shortcuts);
+
     /// Value used for instance window titles
     QString windowTitle() const;
 
@@ -147,9 +168,6 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
     void setManagedPack(const QString& type, const QString& id, const QString& name, const QString& versionId, const QString& version);
     void copyManagedPack(BaseInstance& other);
 
-    /// guess log level from a line of game log
-    virtual MessageLevel::Enum guessLevel([[maybe_unused]] const QString& line, MessageLevel::Enum level) { return level; }
-
     virtual QStringList extraArguments();
 
     /// Traits. Normally inside the version, depends on instance implementation.
@@ -172,7 +190,7 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
      *
      * \return A pointer to this instance's settings object.
      */
-    virtual SettingsObjectPtr settings();
+    virtual SettingsObject* settings();
 
     /*!
      * \brief Loads settings specific to an instance type if they're not already loaded.
@@ -180,13 +198,13 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
     virtual void loadSpecificSettings() = 0;
 
     /// returns a valid update task
-    virtual Task::Ptr createUpdateTask(Net::Mode mode) = 0;
+    virtual QList<Task::Ptr> createUpdateTask() = 0;
 
     /// returns a valid launcher (task container)
-    virtual shared_qobject_ptr<LaunchTask> createLaunchTask(AuthSessionPtr account, MinecraftServerTargetPtr serverToJoin) = 0;
+    virtual LaunchTask* createLaunchTask(AuthSessionPtr account, MinecraftTarget::Ptr targetToJoin) = 0;
 
     /// returns the current launch task (if any)
-    shared_qobject_ptr<LaunchTask> getLaunchTask();
+    LaunchTask* getLaunchTask();
 
     /*!
      * Create envrironment variables for running the instance
@@ -194,15 +212,10 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
     virtual QProcessEnvironment createEnvironment() = 0;
     virtual QProcessEnvironment createLaunchEnvironment() = 0;
 
-    /*!
-     * Returns a matcher that can maps relative paths within the instance to whether they are 'log files'
-     */
-    virtual IPathMatcher::Ptr getLogFileMatcher() = 0;
-
     /*!
      * Returns the root folder to use for looking up log files
      */
-    virtual QString getLogFileRoot() = 0;
+    virtual QStringList getLogFileSearchPaths() = 0;
 
     virtual QString getStatusbarDescription() = 0;
 
@@ -214,7 +227,7 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
 
     virtual QString typeName() const = 0;
 
-    void updateRuntimeContext();
+    virtual void updateRuntimeContext();
     RuntimeContext runtimeContext() const { return m_runtimeContext; }
 
     bool hasVersionBroken() const { return m_hasBrokenVersion; }
@@ -255,23 +268,22 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
     /**
      * 'print' a verbose description of the instance into a QStringList
      */
-    virtual QStringList verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) = 0;
+    virtual QStringList verboseDescription(AuthSessionPtr session, MinecraftTarget::Ptr targetToJoin) = 0;
 
     Status currentStatus() const;
 
-    int getConsoleMaxLines() const;
-    bool shouldStopOnConsoleOverflow() const;
-
     QStringList getLinkedInstances() const;
     void setLinkedInstances(const QStringList& list);
     void addLinkedInstanceId(const QString& id);
     bool removeLinkedInstanceId(const QString& id);
     bool isLinkedToInstanceId(const QString& id) const;
 
+    bool isLegacy();
+
    protected:
     void changeStatus(Status newStatus);
 
-    SettingsObjectPtr globalSettings() const { return m_global_settings.lock(); }
+    SettingsObject* globalSettings() const { return m_global_settings; }
 
     bool isSpecificSettingsLoaded() const { return m_specific_settings_loaded; }
     void setSpecificSettingsLoaded(bool loaded) { m_specific_settings_loaded = loaded; }
@@ -282,7 +294,7 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
      */
     void propertiesChanged(BaseInstance* inst);
 
-    void launchTaskChanged(shared_qobject_ptr<LaunchTask>);
+    void launchTaskChanged(LaunchTask*);
 
     void runningStatusChanged(bool running);
 
@@ -295,10 +307,10 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
 
    protected: /* data */
     QString m_rootDir;
-    SettingsObjectPtr m_settings;
+    std::unique_ptr<SettingsObject> m_settings;
     // InstanceFlags m_flags;
     bool m_isRunning = false;
-    shared_qobject_ptr<LaunchTask> m_launchProcess;
+    std::unique_ptr<LaunchTask> m_launchProcess;
     QDateTime m_timeStarted;
     RuntimeContext m_runtimeContext;
 
@@ -308,7 +320,7 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
     bool m_hasUpdate = false;
     bool m_hasBrokenVersion = false;
 
-    SettingsObjectWeakPtr m_global_settings;
+    SettingsObject* m_global_settings;
     bool m_specific_settings_loaded = false;
 };
 

launcher/BaseVersion.h

@@ -24,27 +24,28 @@
  */
 class BaseVersion {
    public:
+    // TODO: delete
     using Ptr = std::shared_ptr<BaseVersion>;
     virtual ~BaseVersion() {}
     /*!
      * A string used to identify this version in config files.
      * This should be unique within the version list or shenanigans will occur.
      */
-    virtual QString descriptor() = 0;
+    virtual QString descriptor() const = 0;
 
     /*!
      * The name of this version as it is displayed to the user.
      * For example: "1.5.1"
      */
-    virtual QString name() = 0;
+    virtual QString name() const = 0;
 
     /*!
      * This should return a string that describes
      * the kind of version this is (Stable, Beta, Snapshot, whatever)
      */
     virtual QString typeString() const = 0;
-    virtual bool operator<(BaseVersion& a) { return name() < a.name(); }
-    virtual bool operator>(BaseVersion& a) { return name() > a.name(); }
+    virtual bool operator<(BaseVersion& a) const { return name() < a.name(); }
+    virtual bool operator>(BaseVersion& a) const { return name() > a.name(); }
 };
 
 Q_DECLARE_METATYPE(BaseVersion::Ptr)

launcher/BaseVersionList.cpp

@@ -78,6 +78,14 @@ QVariant BaseVersionList::data(const QModelIndex& index, int role) const
         case TypeRole:
             return version->typeString();
 
+        case JavaMajorRole: {
+            auto major = version->name();
+            if (major.startsWith("java")) {
+                major = "Java " + major.mid(4);
+            }
+            return major;
+        }
+
         default:
             return QVariant();
     }
@@ -110,6 +118,8 @@ QHash<int, QByteArray> BaseVersionList::roleNames() const
     roles.insert(TypeRole, "type");
     roles.insert(BranchRole, "branch");
     roles.insert(PathRole, "path");
-    roles.insert(ArchitectureRole, "architecture");
+    roles.insert(JavaNameRole, "javaName");
+    roles.insert(CPUArchitectureRole, "architecture");
+    roles.insert(JavaMajorRole, "javaMajor");
     return roles;
 }

launcher/BaseVersionList.h

@@ -48,7 +48,9 @@ class BaseVersionList : public QAbstractListModel {
         TypeRole,
         BranchRole,
         PathRole,
-        ArchitectureRole,
+        JavaNameRole,
+        JavaMajorRole,
+        CPUArchitectureRole,
         SortRole
     };
     using RoleList = QList<int>;

launcher/DataMigrationTask.cpp

@@ -12,13 +12,10 @@
 
 #include <QtConcurrent>
 
-DataMigrationTask::DataMigrationTask(QObject* parent,
-                                     const QString& sourcePath,
-                                     const QString& targetPath,
-                                     const IPathMatcher::Ptr pathMatcher)
-    : Task(parent), m_sourcePath(sourcePath), m_targetPath(targetPath), m_pathMatcher(pathMatcher), m_copy(sourcePath, targetPath)
+DataMigrationTask::DataMigrationTask(const QString& sourcePath, const QString& targetPath, Filter pathMatcher)
+    : Task(), m_sourcePath(sourcePath), m_targetPath(targetPath), m_pathMatcher(pathMatcher), m_copy(sourcePath, targetPath)
 {
-    m_copy.matcher(m_pathMatcher.get()).whitelist(true);
+    m_copy.matcher(m_pathMatcher).whitelist(true);
 }
 
 void DataMigrationTask::executeTask()
@@ -27,7 +24,7 @@ void DataMigrationTask::executeTask()
 
     // 1. Scan
     // Check how many files we gotta copy
-    m_copyFuture = QtConcurrent::run(QThreadPool::globalInstance(), [&] {
+    m_copyFuture = QtConcurrent::run(QThreadPool::globalInstance(), [this] {
         return m_copy(true);  // dry run to collect amount of files
     });
     connect(&m_copyFutureWatcher, &QFutureWatcher<bool>::finished, this, &DataMigrationTask::dryRunFinished);
@@ -40,11 +37,7 @@ void DataMigrationTask::dryRunFinished()
     disconnect(&m_copyFutureWatcher, &QFutureWatcher<bool>::finished, this, &DataMigrationTask::dryRunFinished);
     disconnect(&m_copyFutureWatcher, &QFutureWatcher<bool>::canceled, this, &DataMigrationTask::dryRunAborted);
 
-#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
     if (!m_copyFuture.isValid() || !m_copyFuture.result()) {
-#else
-    if (!m_copyFuture.result()) {
-#endif
         emitFailed(tr("Failed to scan source path."));
         return;
     }
@@ -60,7 +53,7 @@ void DataMigrationTask::dryRunFinished()
         setProgress(m_copy.totalCopied(), m_toCopy);
         setStatus(tr("Copying %1…").arg(shortenedName));
     });
-    m_copyFuture = QtConcurrent::run(QThreadPool::globalInstance(), [&] {
+    m_copyFuture = QtConcurrent::run(QThreadPool::globalInstance(), [this] {
         return m_copy(false);  // actually copy now
     });
     connect(&m_copyFutureWatcher, &QFutureWatcher<bool>::finished, this, &DataMigrationTask::copyFinished);
@@ -78,11 +71,7 @@ void DataMigrationTask::copyFinished()
     disconnect(&m_copyFutureWatcher, &QFutureWatcher<bool>::finished, this, &DataMigrationTask::copyFinished);
     disconnect(&m_copyFutureWatcher, &QFutureWatcher<bool>::canceled, this, &DataMigrationTask::copyAborted);
 
-#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
     if (!m_copyFuture.isValid() || !m_copyFuture.result()) {
-#else
-    if (!m_copyFuture.result()) {
-#endif
         emitFailed(tr("Some paths could not be copied!"));
         return;
     }

launcher/DataMigrationTask.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include "FileSystem.h"
-#include "pathmatcher/IPathMatcher.h"
+#include "Filter.h"
 #include "tasks/Task.h"
 
 #include <QFuture>
@@ -18,7 +18,7 @@
 class DataMigrationTask : public Task {
     Q_OBJECT
    public:
-    explicit DataMigrationTask(QObject* parent, const QString& sourcePath, const QString& targetPath, const IPathMatcher::Ptr pathmatcher);
+    explicit DataMigrationTask(const QString& sourcePath, const QString& targetPath, Filter pathmatcher);
     ~DataMigrationTask() override = default;
 
    protected:
@@ -33,7 +33,7 @@ class DataMigrationTask : public Task {
    private:
     const QString& m_sourcePath;
     const QString& m_targetPath;
-    const IPathMatcher::Ptr m_pathMatcher;
+    const Filter m_pathMatcher;
 
     FS::copy m_copy;
     int m_toCopy = 0;

launcher/DesktopServices.cpp

@@ -37,143 +37,33 @@
 #include <QDesktopServices>
 #include <QDir>
 #include <QProcess>
-
-/**
- * This shouldn't exist, but until QTBUG-9328 and other unreported bugs are fixed, it needs to be a thing.
- */
-#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD)
-
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-
-template <typename T>
-bool IndirectOpen(T callable, qint64* pid_forked = nullptr)
-{
-    auto pid = fork();
-    if (pid_forked) {
-        if (pid > 0)
-            *pid_forked = pid;
-        else
-            *pid_forked = 0;
-    }
-    if (pid == -1) {
-        qWarning() << "IndirectOpen failed to fork: " << errno;
-        return false;
-    }
-    // child - do the stuff
-    if (pid == 0) {
-        // unset all this garbage so it doesn't get passed to the child process
-        qunsetenv("LD_PRELOAD");
-        qunsetenv("LD_LIBRARY_PATH");
-        qunsetenv("LD_DEBUG");
-        qunsetenv("QT_PLUGIN_PATH");
-        qunsetenv("QT_FONTPATH");
-
-        // open the URL
-        auto status = callable();
-
-        // detach from the parent process group.
-        setsid();
-
-        // die. now. do not clean up anything, it would just hang forever.
-        _exit(status ? 0 : 1);
-    } else {
-        // parent - assume it worked.
-        int status;
-        while (waitpid(pid, &status, 0)) {
-            if (WIFEXITED(status)) {
-                return WEXITSTATUS(status) == 0;
-            }
-            if (WIFSIGNALED(status)) {
-                return false;
-            }
-        }
-        return true;
-    }
-}
-#endif
+#include "FileSystem.h"
 
 namespace DesktopServices {
-bool openDirectory(const QString& path, [[maybe_unused]] bool ensureExists)
+bool openPath(const QFileInfo& path, bool ensureFolderPathExists)
 {
-    qDebug() << "Opening directory" << path;
-    QDir parentPath;
-    QDir dir(path);
-    if (ensureExists && !dir.exists()) {
-        parentPath.mkpath(dir.absolutePath());
+    qDebug() << "Opening path" << path;
+    if (ensureFolderPathExists) {
+        FS::ensureFolderPathExists(path);
     }
-    auto f = [&]() { return QDesktopServices::openUrl(QUrl::fromLocalFile(dir.absolutePath())); };
-#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD)
-    if (!isSandbox()) {
-        return IndirectOpen(f);
-    } else {
-        return f();
-    }
-#else
-    return f();
-#endif
+    return openUrl(QUrl::fromLocalFile(QFileInfo(path).absoluteFilePath()));
 }
 
-bool openFile(const QString& path)
+bool openPath(const QString& path, bool ensureFolderPathExists)
 {
-    qDebug() << "Opening file" << path;
-    auto f = [&]() { return QDesktopServices::openUrl(QUrl::fromLocalFile(path)); };
-#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD)
-    if (!isSandbox()) {
-        return IndirectOpen(f);
-    } else {
-        return f();
-    }
-#else
-    return f();
-#endif
-}
-
-bool openFile(const QString& application, const QString& path, const QString& workingDirectory, qint64* pid)
-{
-    qDebug() << "Opening file" << path << "using" << application;
-#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD)
-    // FIXME: the pid here is fake. So if something depends on it, it will likely misbehave
-    if (!isSandbox()) {
-        return IndirectOpen([&]() { return QProcess::startDetached(application, QStringList() << path, workingDirectory); }, pid);
-    } else {
-        return QProcess::startDetached(application, QStringList() << path, workingDirectory, pid);
-    }
-#else
-    return QProcess::startDetached(application, QStringList() << path, workingDirectory, pid);
-#endif
+    return openPath(QFileInfo(path), ensureFolderPathExists);
 }
 
 bool run(const QString& application, const QStringList& args, const QString& workingDirectory, qint64* pid)
 {
     qDebug() << "Running" << application << "with args" << args.join(' ');
-#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD)
-    if (!isSandbox()) {
-        // FIXME: the pid here is fake. So if something depends on it, it will likely misbehave
-        return IndirectOpen([&]() { return QProcess::startDetached(application, args, workingDirectory); }, pid);
-    } else {
-        return QProcess::startDetached(application, args, workingDirectory, pid);
-    }
-#else
     return QProcess::startDetached(application, args, workingDirectory, pid);
-#endif
 }
 
 bool openUrl(const QUrl& url)
 {
     qDebug() << "Opening URL" << url.toString();
-    auto f = [&]() { return QDesktopServices::openUrl(url); };
-#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD)
-    if (!isSandbox()) {
-        return IndirectOpen(f);
-    } else {
-        return f();
-    }
-#else
-    return f();
-#endif
+    return QDesktopServices::openUrl(url);
 }
 
 bool isFlatpak()
@@ -194,9 +84,4 @@ bool isSnap()
 #endif
 }
 
-bool isSandbox()
-{
-    return isSnap() || isFlatpak();
-}
-
 }  // namespace DesktopServices

launcher/DesktopServices.h

@@ -3,31 +3,30 @@
 #include <QString>
 #include <QUrl>
 
+class QFileInfo;
+
 /**
  * This wraps around QDesktopServices and adds workarounds where needed
  * Use this instead of QDesktopServices!
  */
 namespace DesktopServices {
 /**
- * Open a file in whatever application is applicable
+ * Open a path in whatever application is applicable.
+ * @param ensureFolderPathExists Make sure the path exists
  */
-bool openFile(const QString& path);
+bool openPath(const QFileInfo& path, bool ensureFolderPathExists = false);
 
 /**
- * Open a file in the specified application
+ * Open a path in whatever application is applicable.
+ * @param ensureFolderPathExists Make sure the path exists
  */
-bool openFile(const QString& application, const QString& path, const QString& workingDirectory = QString(), qint64* pid = 0);
+bool openPath(const QString& path, bool ensureFolderPathExists = false);
 
 /**
  * Run an application
  */
 bool run(const QString& application, const QStringList& args, const QString& workingDirectory = QString(), qint64* pid = 0);
 
-/**
- * Open a directory
- */
-bool openDirectory(const QString& path, bool ensureExists = false);
-
 /**
  * Open the URL, most likely in a browser. Maybe.
  */
@@ -42,9 +41,4 @@ bool isFlatpak();
  * Determine whether the launcher is running in a Snap environment
  */
 bool isSnap();
-
-/**
- * Determine whether the launcher is running in a sandboxed (Flatpak or Snap) environment
- */
-bool isSandbox();
 }  // namespace DesktopServices

launcher/Exception.h

@@ -1,4 +1,37 @@
-// Licensed under the Apache-2.0 license. See README.md for details.
+// SPDX-License-Identifier: GPL-3.0-only AND Apache-2.0
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2024 TheKodeToad <TheKodeToad@proton.me>
+ *
+ *  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/>.
+ *
+ * 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
 
@@ -8,12 +41,12 @@
 
 class Exception : public std::exception {
    public:
-    Exception(const QString& message) : std::exception(), m_message(message) { qCritical() << "Exception:" << message; }
-    Exception(const Exception& other) : std::exception(), m_message(other.cause()) {}
+    Exception(const QString& message) : std::exception(), m_message(message.toUtf8()) { qCritical() << "Exception:" << message; }
+    Exception(const Exception& other) : std::exception(), m_message(other.m_message) {}
     virtual ~Exception() noexcept {}
-    const char* what() const noexcept { return m_message.toLatin1().constData(); }
-    QString cause() const { return m_message; }
+    const char* what() const noexcept { return m_message.constData(); }
+    QString cause() const { return QString::fromUtf8(m_message); }
 
    private:
-    QString m_message;
+    QByteArray m_message;
 };

launcher/FastFileIconProvider.cpp

@@ -44,4 +44,4 @@ QIcon FastFileIconProvider::icon(const QFileInfo& info) const
     }
 
     return QApplication::style()->standardIcon(icon);
-}
+}

launcher/FastFileIconProvider.h

@@ -23,4 +23,4 @@
 class FastFileIconProvider : public QFileIconProvider {
    public:
     QIcon icon(const QFileInfo& info) const override;
-};
+};

launcher/FileIgnoreProxy.cpp

@@ -40,12 +40,11 @@
 #include <QFileSystemModel>
 #include <QSortFilterProxyModel>
 #include <QStack>
-#include <algorithm>
 #include "FileSystem.h"
 #include "SeparatorPrefixTree.h"
 #include "StringUtils.h"
 
-FileIgnoreProxy::FileIgnoreProxy(QString root, QObject* parent) : QSortFilterProxyModel(parent), root(root) {}
+FileIgnoreProxy::FileIgnoreProxy(QString root, QObject* parent) : QSortFilterProxyModel(parent), m_root(root) {}
 // NOTE: Sadly, we have to do sorting ourselves.
 bool FileIgnoreProxy::lessThan(const QModelIndex& left, const QModelIndex& right) const
 {
@@ -104,10 +103,10 @@ QVariant FileIgnoreProxy::data(const QModelIndex& index, int role) const
     if (index.column() == 0 && role == Qt::CheckStateRole) {
         QFileSystemModel* fsm = qobject_cast<QFileSystemModel*>(sourceModel());
         auto blockedPath = relPath(fsm->filePath(sourceIndex));
-        auto cover = blocked.cover(blockedPath);
+        auto cover = m_blocked.cover(blockedPath);
         if (!cover.isNull()) {
             return QVariant(Qt::Unchecked);
-        } else if (blocked.exists(blockedPath)) {
+        } else if (m_blocked.exists(blockedPath)) {
             return QVariant(Qt::PartiallyChecked);
         } else {
             return QVariant(Qt::Checked);
@@ -130,7 +129,7 @@ bool FileIgnoreProxy::setData(const QModelIndex& index, const QVariant& value, i
 
 QString FileIgnoreProxy::relPath(const QString& path) const
 {
-    return QDir(root).relativeFilePath(path);
+    return QDir(m_root).relativeFilePath(path);
 }
 
 bool FileIgnoreProxy::setFilterState(QModelIndex index, Qt::CheckState state)
@@ -146,18 +145,18 @@ bool FileIgnoreProxy::setFilterState(QModelIndex index, Qt::CheckState state)
     bool changed = false;
     if (state == Qt::Unchecked) {
         // blocking a path
-        auto& node = blocked.insert(blockedPath);
+        auto& node = m_blocked.insert(blockedPath);
         // get rid of all blocked nodes below
         node.clear();
         changed = true;
     } else if (state == Qt::Checked || state == Qt::PartiallyChecked) {
-        if (!blocked.remove(blockedPath)) {
-            auto cover = blocked.cover(blockedPath);
+        if (!m_blocked.remove(blockedPath)) {
+            auto cover = m_blocked.cover(blockedPath);
             qDebug() << "Blocked by cover" << cover;
             // uncover
-            blocked.remove(cover);
+            m_blocked.remove(cover);
             // block all contents, except for any cover
-            QModelIndex rootIndex = fsm->index(FS::PathCombine(root, cover));
+            QModelIndex rootIndex = fsm->index(FS::PathCombine(m_root, cover));
             QModelIndex doing = rootIndex;
             int row = 0;
             QStack<QModelIndex> todo;
@@ -179,7 +178,7 @@ bool FileIgnoreProxy::setFilterState(QModelIndex index, Qt::CheckState state)
                     todo.push(node);
                 } else {
                     // or just block this one.
-                    blocked.insert(relpath);
+                    m_blocked.insert(relpath);
                 }
                 row++;
             }
@@ -229,7 +228,7 @@ bool FileIgnoreProxy::shouldExpand(QModelIndex index)
         return false;
     }
     auto blockedPath = relPath(fsm->filePath(sourceIndex));
-    auto found = blocked.find(blockedPath);
+    auto found = m_blocked.find(blockedPath);
     if (found) {
         return !found->leaf();
     }
@@ -239,8 +238,8 @@ bool FileIgnoreProxy::shouldExpand(QModelIndex index)
 void FileIgnoreProxy::setBlockedPaths(QStringList paths)
 {
     beginResetModel();
-    blocked.clear();
-    blocked.insert(paths);
+    m_blocked.clear();
+    m_blocked.insert(paths);
     endResetModel();
 }
 
@@ -267,10 +266,45 @@ bool FileIgnoreProxy::filterAcceptsRow(int sourceRow, const QModelIndex& sourceP
 
 bool FileIgnoreProxy::ignoreFile(QFileInfo fileInfo) const
 {
-    return m_ignoreFiles.contains(fileInfo.fileName()) || m_ignoreFilePaths.covers(relPath(fileInfo.absoluteFilePath()));
+    if (m_ignoreFiles.contains(fileInfo.fileName())) {
+        return true;
+    }
+
+    for (const auto& suffix : m_ignoreFilesSuffixes) {
+        if (fileInfo.fileName().endsWith(suffix)) {
+            return true;
+        }
+    }
+
+    if (m_ignoreFilePaths.covers(relPath(fileInfo.absoluteFilePath()))) {
+        return true;
+    }
+
+    return false;
 }
 
-bool FileIgnoreProxy::filterFile(const QString& fileName) const
+bool FileIgnoreProxy::filterFile(const QFileInfo& file) const
 {
-    return blocked.covers(fileName) || ignoreFile(QFileInfo(QDir(root), fileName));
+    return m_blocked.covers(relPath(file.absoluteFilePath())) || ignoreFile(file);
+}
+
+void FileIgnoreProxy::loadBlockedPathsFromFile(const QString& fileName)
+{
+    QFile ignoreFile(fileName);
+    if (!ignoreFile.open(QIODevice::ReadOnly)) {
+        return;
+    }
+    auto ignoreData = ignoreFile.readAll();
+    auto string = QString::fromUtf8(ignoreData);
+    setBlockedPaths(string.split('\n', Qt::SkipEmptyParts));
+}
+
+void FileIgnoreProxy::saveBlockedPathsToFile(const QString& fileName)
+{
+    auto ignoreData = blockedPaths().toStringList().join('\n').toUtf8();
+    try {
+        FS::write(fileName, ignoreData);
+    } catch (const Exception& e) {
+        qWarning() << e.cause();
+    }
 }

launcher/FileIgnoreProxy.h

@@ -61,15 +61,20 @@ class FileIgnoreProxy : public QSortFilterProxyModel {
 
     void setBlockedPaths(QStringList paths);
 
-    inline const SeparatorPrefixTree<'/'>& blockedPaths() const { return blocked; }
-    inline SeparatorPrefixTree<'/'>& blockedPaths() { return blocked; }
+    inline const SeparatorPrefixTree<'/'>& blockedPaths() const { return m_blocked; }
+    inline SeparatorPrefixTree<'/'>& blockedPaths() { return m_blocked; }
 
     // list of file names that need to be removed completely from model
     inline QStringList& ignoreFilesWithName() { return m_ignoreFiles; }
+    inline QStringList& ignoreFilesWithSuffix() { return m_ignoreFilesSuffixes; }
     // list of relative paths that need to be removed completely from model
     inline SeparatorPrefixTree<'/'>& ignoreFilesWithPath() { return m_ignoreFilePaths; }
 
-    bool filterFile(const QString& fileName) const;
+    bool filterFile(const QFileInfo& fileName) const;
+
+    void loadBlockedPathsFromFile(const QString& fileName);
+
+    void saveBlockedPathsToFile(const QString& fileName);
 
    protected:
     bool filterAcceptsColumn(int source_column, const QModelIndex& source_parent) const;
@@ -78,8 +83,9 @@ class FileIgnoreProxy : public QSortFilterProxyModel {
     bool ignoreFile(QFileInfo file) const;
 
    private:
-    const QString root;
-    SeparatorPrefixTree<'/'> blocked;
+    const QString m_root;
+    SeparatorPrefixTree<'/'> m_blocked;
     QStringList m_ignoreFiles;
+    QStringList m_ignoreFilesSuffixes;
     SeparatorPrefixTree<'/'> m_ignoreFilePaths;
 };

launcher/FileSystem.cpp

@@ -45,7 +45,6 @@
 #include <QDirIterator>
 #include <QFile>
 #include <QFileInfo>
-#include <QSaveFile>
 #include <QStandardPaths>
 #include <QStorageInfo>
 #include <QTextStream>
@@ -54,15 +53,14 @@
 #include <system_error>
 
 #include "DesktopServices.h"
+#include "PSaveFile.h"
 #include "StringUtils.h"
 
 #if defined Q_OS_WIN32
 #define NOMINMAX
 #define WIN32_LEAN_AND_MEAN
-#include <objbase.h>
 #include <objidl.h>
 #include <shlguid.h>
-#include <shlobj.h>
 #include <shobjidl.h>
 #include <sys/utime.h>
 #include <versionhelpers.h>
@@ -77,24 +75,8 @@
 #include <utime.h>
 #endif
 
-// Snippet from https://github.com/gulrak/filesystem#using-it-as-single-file-header
-
-#ifdef __APPLE__
-#include <Availability.h>  // for deployment target to support pre-catalina targets without std::fs
-#endif                     // __APPLE__
-
-#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
-#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
-#define GHC_USE_STD_FS
 #include <filesystem>
 namespace fs = std::filesystem;
-#endif  // MacOS min version check
-#endif  // Other OSes version check
-
-#ifndef GHC_USE_STD_FS
-#include <ghc/filesystem.hpp>
-namespace fs = ghc::filesystem;
-#endif
 
 // clone
 #if defined(Q_OS_LINUX)
@@ -123,6 +105,10 @@ namespace fs = ghc::filesystem;
 
 #if defined(__MINGW32__)
 
+// Avoid re-defining structs retroactively added to MinGW
+// https://github.com/mingw-w64/mingw-w64/issues/90#issuecomment-2829284729
+#if __MINGW64_VERSION_MAJOR < 13
+
 struct _DUPLICATE_EXTENTS_DATA {
     HANDLE FileHandle;
     LARGE_INTEGER SourceFileOffset;
@@ -132,6 +118,7 @@ struct _DUPLICATE_EXTENTS_DATA {
 
 using DUPLICATE_EXTENTS_DATA = _DUPLICATE_EXTENTS_DATA;
 using PDUPLICATE_EXTENTS_DATA = _DUPLICATE_EXTENTS_DATA*;
+#endif
 
 struct _FSCTL_GET_INTEGRITY_INFORMATION_BUFFER {
     WORD ChecksumAlgorithm;  // Checksum algorithm. e.g. CHECKSUM_TYPE_UNCHANGED, CHECKSUM_TYPE_NONE, CHECKSUM_TYPE_CRC32
@@ -191,8 +178,8 @@ void ensureExists(const QDir& dir)
 void write(const QString& filename, const QByteArray& data)
 {
     ensureExists(QFileInfo(filename).dir());
-    QSaveFile file(filename);
-    if (!file.open(QSaveFile::WriteOnly)) {
+    PSaveFile file(filename);
+    if (!file.open(PSaveFile::WriteOnly)) {
         throw FileSystemException("Couldn't open " + filename + " for writing: " + file.errorString());
     }
     if (data.size() != file.write(data)) {
@@ -213,8 +200,8 @@ void appendSafe(const QString& filename, const QByteArray& data)
         buffer = QByteArray();
     }
     buffer.append(data);
-    QSaveFile file(filename);
-    if (!file.open(QSaveFile::WriteOnly)) {
+    PSaveFile file(filename);
+    if (!file.open(PSaveFile::WriteOnly)) {
         throw FileSystemException("Couldn't open " + filename + " for writing: " + file.errorString());
     }
     if (buffer.size() != file.write(buffer)) {
@@ -272,15 +259,22 @@ bool ensureFilePathExists(QString filenamepath)
     return success;
 }
 
-bool ensureFolderPathExists(QString foldernamepath)
+bool ensureFolderPathExists(const QFileInfo folderPath)
 {
-    QFileInfo a(foldernamepath);
     QDir dir;
-    QString ensuredPath = a.filePath();
+    QString ensuredPath = folderPath.filePath();
+    if (folderPath.exists())
+        return true;
+
     bool success = dir.mkpath(ensuredPath);
     return success;
 }
 
+bool ensureFolderPathExists(const QString folderPathName)
+{
+    return ensureFolderPathExists(QFileInfo(folderPathName));
+}
+
 bool copyFileAttributes(QString src, QString dst)
 {
 #ifdef Q_OS_WIN32
@@ -334,8 +328,8 @@ bool copy::operator()(const QString& offset, bool dryRun)
         opt |= copy_opts::overwrite_existing;
 
     // Function that'll do the actual copying
-    auto copy_file = [&](QString src_path, QString relative_dst_path) {
-        if (m_matcher && (m_matcher->matches(relative_dst_path) != m_whitelist))
+    auto copy_file = [this, dryRun, src, dst, opt, &err](QString src_path, QString relative_dst_path) {
+        if (m_matcher && (m_matcher(relative_dst_path) != m_whitelist))
             return;
 
         auto dst_path = PathCombine(dst, relative_dst_path);
@@ -421,8 +415,8 @@ void create_link::make_link_list(const QString& offset)
             m_recursive = true;
 
         // Function that'll do the actual linking
-        auto link_file = [&](QString src_path, QString relative_dst_path) {
-            if (m_matcher && (m_matcher->matches(relative_dst_path) != m_whitelist)) {
+        auto link_file = [this, dst](QString src_path, QString relative_dst_path) {
+            if (m_matcher && (m_matcher(relative_dst_path) != m_whitelist)) {
                 qDebug() << "path" << relative_dst_path << "in black list or not in whitelist";
                 return;
             }
@@ -516,7 +510,7 @@ void create_link::runPrivileged(const QString& offset)
 
     QString serverName = BuildConfig.LAUNCHER_APP_BINARY_NAME + "_filelink_server" + StringUtils::getRandomAlphaNumeric();
 
-    connect(&m_linkServer, &QLocalServer::newConnection, this, [&]() {
+    connect(&m_linkServer, &QLocalServer::newConnection, this, [this, &gotResults]() {
         qDebug() << "Client connected, sending out pairs";
         // construct block of data to send
         QByteArray block;
@@ -598,7 +592,7 @@ void create_link::runPrivileged(const QString& offset)
     }
 
     ExternalLinkFileProcess* linkFileProcess = new ExternalLinkFileProcess(serverName, m_useHardLinks, this);
-    connect(linkFileProcess, &ExternalLinkFileProcess::processExited, this, [&]() { emit finishedPrivileged(gotResults); });
+    connect(linkFileProcess, &ExternalLinkFileProcess::processExited, this, [this, gotResults]() { emit finishedPrivileged(gotResults); });
     connect(linkFileProcess, &ExternalLinkFileProcess::finished, linkFileProcess, &QObject::deleteLater);
 
     linkFileProcess->start();
@@ -643,6 +637,19 @@ void ExternalLinkFileProcess::runLinkFile()
     qDebug() << "Process exited";
 }
 
+bool moveByCopy(const QString& source, const QString& dest)
+{
+    if (!copy(source, dest)()) {  // copy
+        qDebug() << "Copy of" << source << "to" << dest << "failed!";
+        return false;
+    }
+    if (!deletePath(source)) {  // remove original
+        qDebug() << "Deletion of" << source << "failed!";
+        return false;
+    };
+    return true;
+}
+
 bool move(const QString& source, const QString& dest)
 {
     std::error_code err;
@@ -650,13 +657,14 @@ bool move(const QString& source, const QString& dest)
     ensureFilePathExists(dest);
     fs::rename(StringUtils::toStdString(source), StringUtils::toStdString(dest), err);
 
-    if (err) {
-        qWarning() << "Failed to move file:" << QString::fromStdString(err.message());
-        qDebug() << "Source file:" << source;
-        qDebug() << "Destination file:" << dest;
+    if (err.value() != 0) {
+        if (moveByCopy(source, dest))
+            return true;
+        qDebug() << "Move of" << source << "to" << dest << "failed!";
+        qWarning() << "Failed to move file:" << QString::fromStdString(err.message()) << QString::number(err.value());
+        return false;
     }
-
-    return err.value() == 0;
+    return true;
 }
 
 bool deletePath(QString path)
@@ -674,9 +682,6 @@ bool deletePath(QString path)
 
 bool trash(QString path, QString* pathInTrash)
 {
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
-    return false;
-#else
     // FIXME: Figure out trash in Flatpak. Qt seemingly doesn't use the Trash portal
     if (DesktopServices::isFlatpak())
         return false;
@@ -685,7 +690,6 @@ bool trash(QString path, QString* pathInTrash)
         return false;
 #endif
     return QFile::moveToTrash(path, pathInTrash);
-#endif
 }
 
 QString PathCombine(const QString& path1, const QString& path2)
@@ -719,11 +723,7 @@ int pathDepth(const QString& path)
 
     QFileInfo info(path);
 
-#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
-    auto parts = QDir::toNativeSeparators(info.path()).split(QDir::separator(), QString::SkipEmptyParts);
-#else
     auto parts = QDir::toNativeSeparators(info.path()).split(QDir::separator(), Qt::SkipEmptyParts);
-#endif
 
     int numParts = parts.length();
     numParts -= parts.count(".");
@@ -743,11 +743,7 @@ QString pathTruncate(const QString& path, int depth)
         return pathTruncate(trunc, depth);
     }
 
-#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
-    auto parts = QDir::toNativeSeparators(trunc).split(QDir::separator(), QString::SkipEmptyParts);
-#else
     auto parts = QDir::toNativeSeparators(trunc).split(QDir::separator(), Qt::SkipEmptyParts);
-#endif
 
     if (parts.startsWith(".") && !path.startsWith(".")) {
         parts.removeFirst();
@@ -797,16 +793,68 @@ QString NormalizePath(QString path)
     }
 }
 
-QString badFilenameChars = "\"\\/?<>:;*|!+\r\n";
+static const QString BAD_WIN_CHARS = "<>:\"|?*\r\n";
+static const QString BAD_NTFS_CHARS = "<>:\"|?*";
+static const QString BAD_HFS_CHARS = ":";
+
+static const QString BAD_FILENAME_CHARS = BAD_WIN_CHARS + "\\/";
 
 QString RemoveInvalidFilenameChars(QString string, QChar replaceWith)
 {
-    for (int i = 0; i < string.length(); i++) {
-        if (badFilenameChars.contains(string[i])) {
+    for (int i = 0; i < string.length(); i++)
+        if (string.at(i) < ' ' || BAD_FILENAME_CHARS.contains(string.at(i)))
             string[i] = replaceWith;
+    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 (int i = 0; i < path.length(); i++) {
+            if (path.at(i) < ' ' || invalidChars.contains(path.at(i))) {
+                path[i] = replaceWith;
+            }
         }
     }
-    return string;
+
+    return path;
 }
 
 QString DirNameFromString(QString string, QString inDir)
@@ -842,42 +890,65 @@ QString getDesktopDir()
     return QStandardPaths::writableLocation(QStandardPaths::DesktopLocation);
 }
 
+QString getApplicationsDir()
+{
+    return QStandardPaths::writableLocation(QStandardPaths::ApplicationsLocation);
+}
+
+QString quoteArgs(const QStringList& args, const QString& wrap, const QString& escapeChar, bool wrapOnlyIfNeeded = false)
+{
+    QString result;
+
+    auto size = args.size();
+    for (int i = 0; i < size; ++i) {
+        QString arg = args[i];
+        arg.replace(wrap, escapeChar);
+
+        bool needsWrapping = !wrapOnlyIfNeeded || arg.contains(' ') || arg.contains('\t') || arg.contains(wrap);
+
+        if (needsWrapping)
+            result += wrap + arg + wrap;
+        else
+            result += arg;
+
+        if (i < size - 1)
+            result += ' ';
+    }
+
+    return result;
+}
+
 // Cross-platform Shortcut creation
-bool createShortcut(QString destination, QString target, QStringList args, QString name, QString icon)
+QString createShortcut(QString destination, QString target, QStringList args, QString name, QString icon)
 {
     if (destination.isEmpty()) {
         destination = PathCombine(getDesktopDir(), RemoveInvalidFilenameChars(name));
     }
-#if defined(Q_OS_MACOS)
-    // Create the Application
-    QDir applicationDirectory =
-        QStandardPaths::writableLocation(QStandardPaths::ApplicationsLocation) + "/" + BuildConfig.LAUNCHER_NAME + " Instances/";
-
-    if (!applicationDirectory.mkpath(".")) {
-        qWarning() << "Couldn't create application directory";
-        return false;
+    if (!ensureFilePathExists(destination)) {
+        qWarning() << "Destination path can't be created!";
+        return QString();
     }
-
-    QDir application = applicationDirectory.path() + "/" + name + ".app/";
+#if defined(Q_OS_MACOS)
+    QDir application = destination + ".app/";
 
     if (application.exists()) {
         qWarning() << "Application already exists!";
-        return false;
+        return QString();
     }
 
     if (!application.mkpath(".")) {
         qWarning() << "Couldn't create application";
-        return false;
+        return QString();
     }
 
     QDir content = application.path() + "/Contents/";
     QDir resources = content.path() + "/Resources/";
     QDir binaryDir = content.path() + "/MacOS/";
-    QFile info = content.path() + "/Info.plist";
+    QFile info(content.path() + "/Info.plist");
 
     if (!(content.mkpath(".") && resources.mkpath(".") && binaryDir.mkpath("."))) {
         qWarning() << "Couldn't create directories within application";
-        return false;
+        return QString();
     }
     info.open(QIODevice::WriteOnly | QIODevice::Text);
 
@@ -890,12 +961,9 @@ bool createShortcut(QString destination, QString target, QStringList args, QStri
     f.open(QIODevice::WriteOnly | QIODevice::Text);
     QTextStream stream(&f);
 
-    QString argstring;
-    if (!args.empty())
-        argstring = " \"" + args.join("\" \"") + "\"";
+    auto argstring = quoteArgs(args, "\"", "\\\"");
 
-    stream << "#!/bin/bash"
-           << "\n";
+    stream << "#!/bin/bash" << "\n";
     stream << "\"" << target << "\" " << argstring << "\n";
 
     stream.flush();
@@ -927,23 +995,23 @@ bool createShortcut(QString destination, QString target, QStringList args, QStri
                   "</dict>\n"
                   "</plist>";
 
-    return true;
+    return application.path();
 #elif defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
     if (!destination.endsWith(".desktop"))  // in case of isFlatpak destination is already populated
         destination += ".desktop";
     QFile f(destination);
-    f.open(QIODevice::WriteOnly | QIODevice::Text);
+    if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        qWarning() << "Failed to open file '" << f.fileName() << "' for writing!";
+        return QString();
+    }
     QTextStream stream(&f);
 
-    QString argstring;
-    if (!args.empty())
-        argstring = " '" + args.join("' '") + "'";
+    auto argstring = quoteArgs(args, "'", "'\\''");
 
-    stream << "[Desktop Entry]"
-           << "\n";
-    stream << "Type=Application"
-           << "\n";
-    stream << "Exec=\"" << target.toLocal8Bit() << "\"" << argstring.toLocal8Bit() << "\n";
+    stream << "[Desktop Entry]" << "\n";
+    stream << "Type=Application" << "\n";
+    stream << "Categories=Game;ActionGame;AdventureGame;Simulation" << "\n";
+    stream << "Exec=\"" << target.toLocal8Bit() << "\" " << argstring.toLocal8Bit() << "\n";
     stream << "Name=" << name.toLocal8Bit() << "\n";
     if (!icon.isEmpty()) {
         stream << "Icon=" << icon.toLocal8Bit() << "\n";
@@ -954,51 +1022,38 @@ bool createShortcut(QString destination, QString target, QStringList args, QStri
 
     f.setPermissions(f.permissions() | QFileDevice::ExeOwner | QFileDevice::ExeGroup | QFileDevice::ExeOther);
 
-    return true;
+    return destination;
 #elif defined(Q_OS_WIN)
     QFileInfo targetInfo(target);
 
     if (!targetInfo.exists()) {
         qWarning() << "Target file does not exist!";
-        return false;
+        return QString();
     }
 
     target = targetInfo.absoluteFilePath();
 
     if (target.length() >= MAX_PATH) {
         qWarning() << "Target file path is too long!";
-        return false;
+        return QString();
     }
 
     if (!icon.isEmpty() && icon.length() >= MAX_PATH) {
         qWarning() << "Icon path is too long!";
-        return false;
+        return QString();
     }
 
     destination += ".lnk";
 
     if (destination.length() >= MAX_PATH) {
         qWarning() << "Destination path is too long!";
-        return false;
-    }
-
-    QString argStr;
-    int argCount = args.count();
-    for (int i = 0; i < argCount; i++) {
-        if (args[i].contains(' ')) {
-            argStr.append('"').append(args[i]).append('"');
-        } else {
-            argStr.append(args[i]);
-        }
-
-        if (i < argCount - 1) {
-            argStr.append(" ");
-        }
+        return QString();
     }
 
+    auto argStr = quoteArgs(args, "\"", "\\\"", true);
     if (argStr.length() >= MAX_PATH) {
         qWarning() << "Arguments string is too long!";
-        return false;
+        return QString();
     }
 
     HRESULT hres;
@@ -1007,7 +1062,7 @@ bool createShortcut(QString destination, QString target, QStringList args, QStri
     hres = CoInitialize(nullptr);
     if (FAILED(hres)) {
         qWarning() << "Failed to initialize COM!";
-        return false;
+        return QString();
     }
 
     WCHAR wsz[MAX_PATH];
@@ -1061,10 +1116,12 @@ bool createShortcut(QString destination, QString target, QStringList args, QStri
     // go away COM, nobody likes you
     CoUninitialize();
 
-    return SUCCEEDED(hres);
+    if (SUCCEEDED(hres))
+        return destination;
+    return QString();
 #else
     qWarning("Desktop Shortcuts not supported on your platform!");
-    return false;
+    return QString();
 #endif
 }
 
@@ -1220,8 +1277,8 @@ bool clone::operator()(const QString& offset, bool dryRun)
     std::error_code err;
 
     // Function that'll do the actual cloneing
-    auto cloneFile = [&](QString src_path, QString relative_dst_path) {
-        if (m_matcher && (m_matcher->matches(relative_dst_path) != m_whitelist))
+    auto cloneFile = [this, dryRun, dst, &err](QString src_path, QString relative_dst_path) {
+        if (m_matcher && (m_matcher(relative_dst_path) != m_whitelist))
             return;
 
         auto dst_path = PathCombine(dst, relative_dst_path);
@@ -1579,4 +1636,80 @@ uintmax_t hardLinkCount(const QString& path)
     return count;
 }
 
+#ifdef Q_OS_WIN
+// returns 8.3 file format from long path
+QString shortPathName(const QString& file)
+{
+    auto input = file.toStdWString();
+    std::wstring output;
+    long length = GetShortPathNameW(input.c_str(), NULL, 0);
+    if (length == 0)
+        return {};
+    // NOTE: this resizing might seem weird...
+    // when GetShortPathNameW fails, it returns length including null character
+    // when it succeeds, it returns length excluding null character
+    // See: https://msdn.microsoft.com/en-us/library/windows/desktop/aa364989(v=vs.85).aspx
+    output.resize(length);
+    if (GetShortPathNameW(input.c_str(), (LPWSTR)output.c_str(), length) == 0)
+        return {};
+    output.resize(length - 1);
+    QString ret = QString::fromStdWString(output);
+    return ret;
+}
+
+// if the string survives roundtrip through local 8bit encoding...
+bool fitsInLocal8bit(const QString& string)
+{
+    return string == QString::fromLocal8Bit(string.toLocal8Bit());
+}
+
+QString getPathNameInLocal8bit(const QString& file)
+{
+    if (!fitsInLocal8bit(file)) {
+        auto path = shortPathName(file);
+        if (!path.isEmpty()) {
+            return path;
+        }
+        // in case shortPathName fails just return the path as is
+    }
+    return file;
+}
+#endif
+
+QString getUniqueResourceName(const QString& filePath)
+{
+    auto newFileName = filePath;
+    if (!newFileName.endsWith(".disabled")) {
+        return newFileName;  // prioritize enabled mods
+    }
+    newFileName.chop(9);
+    if (!QFile::exists(newFileName)) {
+        return filePath;
+    }
+    QFileInfo fileInfo(filePath);
+    auto baseName = fileInfo.completeBaseName();
+    auto path = fileInfo.absolutePath();
+
+    int counter = 1;
+    do {
+        if (counter == 1) {
+            newFileName = FS::PathCombine(path, baseName + ".duplicate");
+        } else {
+            newFileName = FS::PathCombine(path, baseName + ".duplicate" + QString::number(counter));
+        }
+        counter++;
+    } while (QFile::exists(newFileName));
+
+    return newFileName;
+}
+bool removeFiles(QStringList listFile)
+{
+    bool ret = true;
+    // For each file
+    for (int i = 0; i < listFile.count(); i++) {
+        // Remove
+        ret = ret && QFile::remove(listFile.at(i));
+    }
+    return ret;
+}
 }  // namespace FS

launcher/FileSystem.h

@@ -38,7 +38,7 @@
 #pragma once
 
 #include "Exception.h"
-#include "pathmatcher/IPathMatcher.h"
+#include "Filter.h"
 
 #include <system_error>
 
@@ -72,7 +72,7 @@ void appendSafe(const QString& filename, const QByteArray& data);
 void append(const QString& filename, const QByteArray& data);
 
 /**
- * read data from a file safely\
+ * read data from a file safely
  */
 QByteArray read(const QString& filename);
 
@@ -91,7 +91,13 @@ bool ensureFilePathExists(QString filenamepath);
  * Creates all the folders in a path for the specified path
  * last segment of the path is treated as a folder name and is created!
  */
-bool ensureFolderPathExists(QString filenamepath);
+bool ensureFolderPathExists(const QFileInfo folderPath);
+
+/**
+ * Creates all the folders in a path for the specified path
+ * last segment of the path is treated as a folder name and is created!
+ */
+bool ensureFolderPathExists(const QString folderPathName);
 
 /**
  * @brief Copies a directory and it's contents from src to dest
@@ -109,9 +115,9 @@ class copy : public QObject {
         m_followSymlinks = follow;
         return *this;
     }
-    copy& matcher(const IPathMatcher* filter)
+    copy& matcher(Filter filter)
     {
-        m_matcher = filter;
+        m_matcher = std::move(filter);
         return *this;
     }
     copy& whitelist(bool whitelist)
@@ -141,7 +147,7 @@ class copy : public QObject {
 
    private:
     bool m_followSymlinks = true;
-    const IPathMatcher* m_matcher = nullptr;
+    Filter m_matcher = nullptr;
     bool m_whitelist = false;
     bool m_overwrite = false;
     QDir m_src;
@@ -203,9 +209,9 @@ class create_link : public QObject {
         m_useHardLinks = useHard;
         return *this;
     }
-    create_link& matcher(const IPathMatcher* filter)
+    create_link& matcher(Filter filter)
     {
-        m_matcher = filter;
+        m_matcher = std::move(filter);
         return *this;
     }
     create_link& whitelist(bool whitelist)
@@ -234,6 +240,7 @@ class create_link : public QObject {
     bool operator()(bool dryRun = false) { return operator()(QString(), dryRun); }
 
     int totalLinked() { return m_linked; }
+    int totalToLink() { return static_cast<int>(m_links_to_make.size()); }
 
     void runPrivileged() { runPrivileged(QString()); }
     void runPrivileged(const QString& offset);
@@ -253,7 +260,7 @@ class create_link : public QObject {
 
    private:
     bool m_useHardLinks = false;
-    const IPathMatcher* m_matcher = nullptr;
+    Filter m_matcher = nullptr;
     bool m_whitelist = false;
     bool m_recursive = true;
 
@@ -284,6 +291,8 @@ bool move(const QString& source, const QString& dest);
  */
 bool deletePath(QString path);
 
+bool removeFiles(QStringList listFile);
+
 /**
  * Trash a folder / file
  */
@@ -336,6 +345,8 @@ QString NormalizePath(QString path);
 
 QString RemoveInvalidFilenameChars(QString string, QChar replaceWith = '-');
 
+QString RemoveInvalidPathChars(QString string, QChar replaceWith = '-');
+
 QString DirNameFromString(QString string, QString inDir = ".");
 
 /// Checks if the a given Path contains "!"
@@ -344,14 +355,18 @@ bool checkProblemticPathJava(QDir folder);
 // Get the Directory representing the User's Desktop
 QString getDesktopDir();
 
+// Get the Directory representing the User's Applications directory
+QString getApplicationsDir();
+
 // Overrides one folder with the contents of another, preserving items exclusive to the first folder
 // Equivalent to doing QDir::rename, but allowing for overrides
 bool overrideFolder(QString overwritten_path, QString override_path);
 
 /**
  * Creates a shortcut to the specified target file at the specified destination path.
+ * Returns null QString if creation failed; otherwise returns the path to the created shortcut.
  */
-bool createShortcut(QString destination, QString target, QStringList args, QString name, QString icon);
+QString createShortcut(QString destination, QString target, QStringList args, QString name, QString icon);
 
 enum class FilesystemType {
     FAT,
@@ -370,6 +385,7 @@ enum class FilesystemType {
     HFSX,
     FUSEBLK,
     F2FS,
+    BCACHEFS,
     UNKNOWN
 };
 
@@ -398,6 +414,7 @@ static const QMap<FilesystemType, QStringList> s_filesystem_type_names = { { Fil
                                                                            { FilesystemType::HFSX, { "HFSX" } },
                                                                            { FilesystemType::FUSEBLK, { "FUSEBLK" } },
                                                                            { FilesystemType::F2FS, { "F2FS" } },
+                                                                           { FilesystemType::BCACHEFS, { "BCACHEFS" } },
                                                                            { FilesystemType::UNKNOWN, { "UNKNOWN" } } };
 
 /**
@@ -450,7 +467,7 @@ QString nearestExistentAncestor(const QString& path);
 FilesystemInfo statFS(const QString& path);
 
 static const QList<FilesystemType> s_clone_filesystems = { FilesystemType::BTRFS, FilesystemType::APFS, FilesystemType::ZFS,
-                                                           FilesystemType::XFS, FilesystemType::REFS };
+                                                           FilesystemType::XFS,   FilesystemType::REFS, FilesystemType::BCACHEFS };
 
 /**
  * @brief if the Filesystem is reflink/clone capable
@@ -477,9 +494,9 @@ class clone : public QObject {
         m_src.setPath(src);
         m_dst.setPath(dst);
     }
-    clone& matcher(const IPathMatcher* filter)
+    clone& matcher(Filter filter)
     {
-        m_matcher = filter;
+        m_matcher = std::move(filter);
         return *this;
     }
     clone& whitelist(bool whitelist)
@@ -503,7 +520,7 @@ class clone : public QObject {
     bool operator()(const QString& offset, bool dryRun = false);
 
    private:
-    const IPathMatcher* m_matcher = nullptr;
+    Filter m_matcher = nullptr;
     bool m_whitelist = false;
     QDir m_src;
     QDir m_dst;
@@ -545,4 +562,10 @@ bool canLink(const QString& src, const QString& dst);
 
 uintmax_t hardLinkCount(const QString& path);
 
+#ifdef Q_OS_WIN
+QString getPathNameInLocal8bit(const QString& file);
+#endif
+
+QString getUniqueResourceName(const QString& filePath);
+
 }  // namespace FS

launcher/Filter.cpp

@@ -1,36 +0,0 @@
-#include "Filter.h"
-
-Filter::~Filter() {}
-
-ContainsFilter::ContainsFilter(const QString& pattern) : pattern(pattern) {}
-ContainsFilter::~ContainsFilter() {}
-bool ContainsFilter::accepts(const QString& value)
-{
-    return value.contains(pattern);
-}
-
-ExactFilter::ExactFilter(const QString& pattern) : pattern(pattern) {}
-ExactFilter::~ExactFilter() {}
-bool ExactFilter::accepts(const QString& value)
-{
-    return value == pattern;
-}
-
-ExactIfPresentFilter::ExactIfPresentFilter(const QString& pattern) : pattern(pattern) {}
-bool ExactIfPresentFilter::accepts(const QString& value)
-{
-    return value.isEmpty() || value == pattern;
-}
-
-RegexpFilter::RegexpFilter(const QString& regexp, bool invert) : invert(invert)
-{
-    pattern.setPattern(regexp);
-    pattern.optimize();
-}
-RegexpFilter::~RegexpFilter() {}
-bool RegexpFilter::accepts(const QString& value)
-{
-    auto match = pattern.match(value);
-    bool matched = match.hasMatch();
-    return invert ? (!matched) : (matched);
-}

launcher/Filter.h

@@ -3,49 +3,52 @@
 #include <QRegularExpression>
 #include <QString>
 
-class Filter {
-   public:
-    virtual ~Filter();
-    virtual bool accepts(const QString& value) = 0;
-};
+using Filter = std::function<bool(const QString&)>;
 
-class ContainsFilter : public Filter {
-   public:
-    ContainsFilter(const QString& pattern);
-    virtual ~ContainsFilter();
-    bool accepts(const QString& value) override;
+namespace Filters {
+inline Filter inverse(Filter filter)
+{
+    return [filter = std::move(filter)](const QString& src) { return !filter(src); };
+}
 
-   private:
-    QString pattern;
-};
+inline Filter any(QList<Filter> filters)
+{
+    return [filters = std::move(filters)](const QString& src) {
+        for (auto& filter : filters)
+            if (filter(src))
+                return true;
 
-class ExactFilter : public Filter {
-   public:
-    ExactFilter(const QString& pattern);
-    virtual ~ExactFilter();
-    bool accepts(const QString& value) override;
+        return false;
+    };
+}
 
-   private:
-    QString pattern;
-};
+inline Filter equals(QString pattern)
+{
+    return [pattern = std::move(pattern)](const QString& src) { return src == pattern; };
+}
 
-class ExactIfPresentFilter : public Filter {
-   public:
-    ExactIfPresentFilter(const QString& pattern);
-    ~ExactIfPresentFilter() override = default;
-    bool accepts(const QString& value) override;
+inline Filter equalsAny(QStringList patterns = {})
+{
+    return [patterns = std::move(patterns)](const QString& src) { return patterns.isEmpty() || patterns.contains(src); };
+}
 
-   private:
-    QString pattern;
-};
+inline Filter equalsOrEmpty(QString pattern)
+{
+    return [pattern = std::move(pattern)](const QString& src) { return src.isEmpty() || src == pattern; };
+}
 
-class RegexpFilter : public Filter {
-   public:
-    RegexpFilter(const QString& regexp, bool invert);
-    virtual ~RegexpFilter();
-    bool accepts(const QString& value) override;
+inline Filter contains(QString pattern)
+{
+    return [pattern = std::move(pattern)](const QString& src) { return src.contains(pattern); };
+}
 
-   private:
-    QRegularExpression pattern;
-    bool invert = false;
-};
+inline Filter startsWith(QString pattern)
+{
+    return [pattern = std::move(pattern)](const QString& src) { return src.startsWith(pattern); };
+}
+
+inline Filter regexp(QRegularExpression pattern)
+{
+    return [pattern = std::move(pattern)](const QString& src) { return pattern.match(src).hasMatch(); };
+}
+}  // namespace Filters

launcher/GZip.cpp

@@ -36,6 +36,8 @@
 #include "GZip.h"
 #include <zlib.h>
 #include <QByteArray>
+#include <QDebug>
+#include <QFile>
 
 bool GZip::unzip(const QByteArray& compressedBytes, QByteArray& uncompressedBytes)
 {
@@ -136,3 +138,81 @@ bool GZip::zip(const QByteArray& uncompressedBytes, QByteArray& compressedBytes)
     }
     return true;
 }
+
+int inf(QFile* source, std::function<bool(const QByteArray&)> handleBlock)
+{
+    constexpr auto CHUNK = 16384;
+    int ret;
+    unsigned have;
+    z_stream strm;
+    memset(&strm, 0, sizeof(strm));
+    char in[CHUNK];
+    unsigned char out[CHUNK];
+
+    ret = inflateInit2(&strm, (16 + MAX_WBITS));
+    if (ret != Z_OK)
+        return ret;
+
+    /* decompress until deflate stream ends or end of file */
+    do {
+        strm.avail_in = source->read(in, CHUNK);
+        if (source->error()) {
+            (void)inflateEnd(&strm);
+            return Z_ERRNO;
+        }
+        if (strm.avail_in == 0)
+            break;
+        strm.next_in = reinterpret_cast<Bytef*>(in);
+
+        /* run inflate() on input until output buffer not full */
+        do {
+            strm.avail_out = CHUNK;
+            strm.next_out = out;
+            ret = inflate(&strm, Z_NO_FLUSH);
+            assert(ret != Z_STREAM_ERROR); /* state not clobbered */
+            switch (ret) {
+                case Z_NEED_DICT:
+                    ret = Z_DATA_ERROR; /* and fall through */
+                case Z_DATA_ERROR:
+                case Z_MEM_ERROR:
+                    (void)inflateEnd(&strm);
+                    return ret;
+            }
+            have = CHUNK - strm.avail_out;
+            if (!handleBlock(QByteArray(reinterpret_cast<const char*>(out), have))) {
+                (void)inflateEnd(&strm);
+                return Z_OK;
+            }
+
+        } while (strm.avail_out == 0);
+
+        /* done when inflate() says it's done */
+    } while (ret != Z_STREAM_END);
+
+    /* clean up and return */
+    (void)inflateEnd(&strm);
+    return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
+}
+
+QString zerr(int ret)
+{
+    switch (ret) {
+        case Z_ERRNO:
+            return QObject::tr("error handling file");
+        case Z_STREAM_ERROR:
+            return QObject::tr("invalid compression level");
+        case Z_DATA_ERROR:
+            return QObject::tr("invalid or incomplete deflate data");
+        case Z_MEM_ERROR:
+            return QObject::tr("out of memory");
+        case Z_VERSION_ERROR:
+            return QObject::tr("zlib version mismatch!");
+    }
+    return {};
+}
+
+QString GZip::readGzFileByBlocks(QFile* source, std::function<bool(const QByteArray&)> handleBlock)
+{
+    auto ret = inf(source, handleBlock);
+    return zerr(ret);
+}

launcher/GZip.h

@@ -1,8 +1,11 @@
 #pragma once
 #include <QByteArray>
+#include <QFile>
 
-class GZip {
-   public:
-    static bool unzip(const QByteArray& compressedBytes, QByteArray& uncompressedBytes);
-    static bool zip(const QByteArray& uncompressedBytes, QByteArray& compressedBytes);
-};
+namespace GZip {
+
+bool unzip(const QByteArray& compressedBytes, QByteArray& uncompressedBytes);
+bool zip(const QByteArray& uncompressedBytes, QByteArray& compressedBytes);
+QString readGzFileByBlocks(QFile* source, std::function<bool(const QByteArray&)> handleBlock);
+
+}  // namespace GZip

launcher/InstanceCopyPrefs.cpp

@@ -189,4 +189,4 @@ void InstanceCopyPrefs::enableDontLinkSaves(bool b)
 void InstanceCopyPrefs::enableUseClone(bool b)
 {
     useClone = b;
-}
+}

launcher/InstanceCopyPrefs.h

@@ -8,23 +8,23 @@
 
 struct InstanceCopyPrefs {
    public:
-    [[nodiscard]] bool allTrue() const;
-    [[nodiscard]] QString getSelectedFiltersAsRegex() const;
-    [[nodiscard]] QString getSelectedFiltersAsRegex(const QStringList& additionalFilters) const;
+    bool allTrue() const;
+    QString getSelectedFiltersAsRegex() const;
+    QString getSelectedFiltersAsRegex(const QStringList& additionalFilters) const;
     // Getters
-    [[nodiscard]] bool isCopySavesEnabled() const;
-    [[nodiscard]] bool isKeepPlaytimeEnabled() const;
-    [[nodiscard]] bool isCopyGameOptionsEnabled() const;
-    [[nodiscard]] bool isCopyResourcePacksEnabled() const;
-    [[nodiscard]] bool isCopyShaderPacksEnabled() const;
-    [[nodiscard]] bool isCopyServersEnabled() const;
-    [[nodiscard]] bool isCopyModsEnabled() const;
-    [[nodiscard]] bool isCopyScreenshotsEnabled() const;
-    [[nodiscard]] bool isUseSymLinksEnabled() const;
-    [[nodiscard]] bool isLinkRecursivelyEnabled() const;
-    [[nodiscard]] bool isUseHardLinksEnabled() const;
-    [[nodiscard]] bool isDontLinkSavesEnabled() const;
-    [[nodiscard]] bool isUseCloneEnabled() const;
+    bool isCopySavesEnabled() const;
+    bool isKeepPlaytimeEnabled() const;
+    bool isCopyGameOptionsEnabled() const;
+    bool isCopyResourcePacksEnabled() const;
+    bool isCopyShaderPacksEnabled() const;
+    bool isCopyServersEnabled() const;
+    bool isCopyModsEnabled() const;
+    bool isCopyScreenshotsEnabled() const;
+    bool isUseSymLinksEnabled() const;
+    bool isLinkRecursivelyEnabled() const;
+    bool isUseHardLinksEnabled() const;
+    bool isDontLinkSavesEnabled() const;
+    bool isUseCloneEnabled() const;
     // Setters
     void enableCopySaves(bool b);
     void enableKeepPlaytime(bool b);

launcher/InstanceCopyTask.cpp

@@ -1,12 +1,14 @@
 #include "InstanceCopyTask.h"
 #include <QDebug>
 #include <QtConcurrentRun>
+#include <memory>
 #include "FileSystem.h"
+#include "Filter.h"
 #include "NullInstance.h"
-#include "pathmatcher/RegexpMatcher.h"
 #include "settings/INISettingsObject.h"
+#include "tasks/Task.h"
 
-InstanceCopyTask::InstanceCopyTask(InstancePtr origInstance, const InstanceCopyPrefs& prefs)
+InstanceCopyTask::InstanceCopyTask(BaseInstance* origInstance, const InstanceCopyPrefs& prefs)
 {
     m_origInstance = origInstance;
     m_keepPlaytime = prefs.isKeepPlaytimeEnabled();
@@ -28,9 +30,8 @@ InstanceCopyTask::InstanceCopyTask(InstancePtr origInstance, const InstanceCopyP
     if (!filters.isEmpty()) {
         // Set regex filter:
         // FIXME: get this from the original instance type...
-        auto matcherReal = new RegexpMatcher(filters);
-        matcherReal->caseSensitive(false);
-        m_matcher.reset(matcherReal);
+        QRegularExpression regexp(filters, QRegularExpression::CaseInsensitiveOption);
+        m_matcher = Filters::regexp(regexp);
     }
 }
 
@@ -38,38 +39,50 @@ void InstanceCopyTask::executeTask()
 {
     setStatus(tr("Copying instance %1").arg(m_origInstance->name()));
 
-    auto copySaves = [&]() {
-        QFileInfo mcDir(FS::PathCombine(m_stagingPath, "minecraft"));
-        QFileInfo dotMCDir(FS::PathCombine(m_stagingPath, ".minecraft"));
-
-        QString staging_mc_dir;
-        if (mcDir.exists() && !dotMCDir.exists())
-            staging_mc_dir = mcDir.filePath();
-        else
-            staging_mc_dir = dotMCDir.filePath();
-
-        FS::copy savesCopy(FS::PathCombine(m_origInstance->gameRoot(), "saves"), FS::PathCombine(staging_mc_dir, "saves"));
-        savesCopy.followSymlinks(true);
-
-        return savesCopy();
-    };
-
-    m_copyFuture = QtConcurrent::run(QThreadPool::globalInstance(), [this, copySaves] {
+    m_copyFuture = QtConcurrent::run(QThreadPool::globalInstance(), [this] {
         if (m_useClone) {
             FS::clone folderClone(m_origInstance->instanceRoot(), m_stagingPath);
-            folderClone.matcher(m_matcher.get());
+            folderClone.matcher(m_matcher);
 
+            folderClone(true);
+            setProgress(0, folderClone.totalCloned());
+            connect(&folderClone, &FS::clone::fileCloned,
+                    [this](QString src, QString dst) { setProgress(m_progress + 1, m_progressTotal); });
             return folderClone();
-        } else if (m_useLinks || m_useHardLinks) {
+        }
+        if (m_useLinks || m_useHardLinks) {
+            std::unique_ptr<FS::copy> savesCopy;
+            if (m_copySaves) {
+                QFileInfo mcDir(FS::PathCombine(m_stagingPath, "minecraft"));
+                QFileInfo dotMCDir(FS::PathCombine(m_stagingPath, ".minecraft"));
+
+                QString staging_mc_dir;
+                if (dotMCDir.exists() && !mcDir.exists())
+                    staging_mc_dir = dotMCDir.filePath();
+                else
+                    staging_mc_dir = mcDir.filePath();
+
+                savesCopy = std::make_unique<FS::copy>(FS::PathCombine(m_origInstance->gameRoot(), "saves"),
+                                                       FS::PathCombine(staging_mc_dir, "saves"));
+                savesCopy->followSymlinks(true);
+                (*savesCopy)(true);
+                setProgress(0, savesCopy->totalCopied());
+                connect(savesCopy.get(), &FS::copy::fileCopied, [this](QString src) { setProgress(m_progress + 1, m_progressTotal); });
+            }
             FS::create_link folderLink(m_origInstance->instanceRoot(), m_stagingPath);
             int depth = m_linkRecursively ? -1 : 0;  // we need to at least link the top level instead of the instance folder
-            folderLink.linkRecursively(true).setMaxDepth(depth).useHardLinks(m_useHardLinks).matcher(m_matcher.get());
+            folderLink.linkRecursively(true).setMaxDepth(depth).useHardLinks(m_useHardLinks).matcher(m_matcher);
 
+            folderLink(true);
+            setProgress(0, m_progressTotal + folderLink.totalToLink());
+            connect(&folderLink, &FS::create_link::fileLinked,
+                    [this](QString src, QString dst) { setProgress(m_progress + 1, m_progressTotal); });
             bool there_were_errors = false;
 
             if (!folderLink()) {
 #if defined Q_OS_WIN32
                 if (!m_useHardLinks) {
+                    setProgress(0, m_progressTotal);
                     qDebug() << "EXPECTED: Link failure, Windows requires permissions for symlinks";
 
                     qDebug() << "attempting to run with privelage";
@@ -77,7 +90,7 @@ void InstanceCopyTask::executeTask()
                     QEventLoop loop;
                     bool got_priv_results = false;
 
-                    connect(&folderLink, &FS::create_link::finishedPrivileged, this, [&](bool gotResults) {
+                    connect(&folderLink, &FS::create_link::finishedPrivileged, this, [&got_priv_results, &loop](bool gotResults) {
                         if (!gotResults) {
                             qDebug() << "Privileged run exited without results!";
                         }
@@ -94,13 +107,11 @@ void InstanceCopyTask::executeTask()
                         }
                     }
 
-                    if (m_copySaves) {
-                        there_were_errors |= !copySaves();
+                    if (savesCopy) {
+                        there_were_errors |= !(*savesCopy)();
                     }
 
                     return got_priv_results && !there_were_errors;
-                } else {
-                    qDebug() << "Link Failed!" << folderLink.getOSError().value() << folderLink.getOSError().message().c_str();
                 }
 #else
                 qDebug() << "Link Failed!" << folderLink.getOSError().value() << folderLink.getOSError().message().c_str();
@@ -108,17 +119,19 @@ void InstanceCopyTask::executeTask()
                 return false;
             }
 
-            if (m_copySaves) {
-                there_were_errors |= !copySaves();
+            if (savesCopy) {
+                there_were_errors |= !(*savesCopy)();
             }
 
             return !there_were_errors;
-        } else {
-            FS::copy folderCopy(m_origInstance->instanceRoot(), m_stagingPath);
-            folderCopy.followSymlinks(false).matcher(m_matcher.get());
-
-            return folderCopy();
         }
+        FS::copy folderCopy(m_origInstance->instanceRoot(), m_stagingPath);
+        folderCopy.followSymlinks(false).matcher(m_matcher);
+
+        folderCopy(true);
+        setProgress(0, folderCopy.totalCopied());
+        connect(&folderCopy, &FS::copy::fileCopied, [this](QString src) { setProgress(m_progress + 1, m_progressTotal); });
+        return folderCopy();
     });
     connect(&m_copyFutureWatcher, &QFutureWatcher<bool>::finished, this, &InstanceCopyTask::copyFinished);
     connect(&m_copyFutureWatcher, &QFutureWatcher<bool>::canceled, this, &InstanceCopyTask::copyAborted);
@@ -134,17 +147,16 @@ void InstanceCopyTask::copyFinished()
     }
 
     // FIXME: shouldn't this be able to report errors?
-    auto instanceSettings = std::make_shared<INISettingsObject>(FS::PathCombine(m_stagingPath, "instance.cfg"));
+    auto instanceSettings = std::make_unique<INISettingsObject>(FS::PathCombine(m_stagingPath, "instance.cfg"));
 
-    InstancePtr inst(new NullInstance(m_globalSettings, instanceSettings, m_stagingPath));
+    BaseInstance* inst(new NullInstance(m_globalSettings, std::move(instanceSettings), m_stagingPath));
     inst->setName(name());
     inst->setIconKey(m_instIcon);
     if (!m_keepPlaytime) {
         inst->resetTimePlayed();
     }
-    if (m_useLinks)
-        inst->addLinkedInstanceId(m_origInstance->id());
     if (m_useLinks) {
+        inst->addLinkedInstanceId(m_origInstance->id());
         auto allowed_symlinks_file = QFileInfo(FS::PathCombine(inst->gameRoot(), "allowed_symlinks.txt"));
 
         QByteArray allowed_symlinks;
@@ -160,7 +172,11 @@ void InstanceCopyTask::copyFinished()
                 allowed_symlinks_file
                     .filePath());  // we dont want to modify the original. also make sure the resulting file is not itself a link.
 
-        FS::write(allowed_symlinks_file.filePath(), allowed_symlinks);
+        try {
+            FS::write(allowed_symlinks_file.filePath(), allowed_symlinks);
+        } catch (const FS::FileSystemException& e) {
+            qCritical() << "Failed to write symlink :" << e.cause();
+        }
     }
 
     emitSucceeded();
@@ -171,3 +187,14 @@ void InstanceCopyTask::copyAborted()
     emitFailed(tr("Instance folder copy has been aborted."));
     return;
 }
+
+bool InstanceCopyTask::abort()
+{
+    if (m_copyFutureWatcher.isRunning()) {
+        m_copyFutureWatcher.cancel();
+        // NOTE: Here we don't do `emitAborted()` because it will be done when `m_copyFutureWatcher` actually cancels, which may not occur
+        // immediately.
+        return true;
+    }
+    return false;
+}

launcher/InstanceCopyTask.h

@@ -5,6 +5,7 @@
 #include <QUrl>
 #include "BaseInstance.h"
 #include "BaseVersion.h"
+#include "Filter.h"
 #include "InstanceCopyPrefs.h"
 #include "InstanceTask.h"
 #include "net/NetJob.h"
@@ -14,20 +15,21 @@
 class InstanceCopyTask : public InstanceTask {
     Q_OBJECT
    public:
-    explicit InstanceCopyTask(InstancePtr origInstance, const InstanceCopyPrefs& prefs);
+    explicit InstanceCopyTask(BaseInstance* origInstance, const InstanceCopyPrefs& prefs);
 
    protected:
     //! Entry point for tasks.
     virtual void executeTask() override;
+    bool abort() override;
     void copyFinished();
     void copyAborted();
 
    private:
     /* data */
-    InstancePtr m_origInstance;
+    BaseInstance* m_origInstance;
     QFuture<bool> m_copyFuture;
     QFutureWatcher<bool> m_copyFutureWatcher;
-    std::unique_ptr<IPathMatcher> m_matcher;
+    Filter m_matcher;
     bool m_keepPlaytime;
     bool m_useLinks = false;
     bool m_useHardLinks = false;

launcher/InstanceCreationTask.cpp

@@ -2,8 +2,7 @@
 
 #include <QDebug>
 #include <QFile>
-
-InstanceCreationTask::InstanceCreationTask() = default;
+#include "FileSystem.h"
 
 void InstanceCreationTask::executeTask()
 {
@@ -39,22 +38,29 @@ void InstanceCreationTask::executeTask()
     // files scheduled to, and we'd better not let the user abort in the middle of it, since it'd
     // put the instance in an invalid state.
     if (shouldOverride()) {
+        bool deleteFailed = false;
+
         setAbortable(false);
         setStatus(tr("Removing old conflicting files..."));
         qDebug() << "Removing old files";
 
-        for (auto path : m_files_to_remove) {
+        for (const QString& path : m_files_to_remove) {
             if (!QFile::exists(path))
                 continue;
+
             qDebug() << "Removing" << path;
+
             if (!QFile::remove(path)) {
-                qCritical() << "Couldn't remove the old conflicting files.";
-                emitFailed(tr("Failed to remove old conflicting files."));
-                return;
+                qCritical() << "Could not remove" << path;
+                deleteFailed = true;
             }
         }
-    }
 
-    emitSucceeded();
-    return;
+        if (deleteFailed) {
+            emitFailed(tr("Failed to remove old conflicting files."));
+            return;
+        }
+    }
+    if (!m_abort)
+        emitSucceeded();
 }