Merge branch 'develop' of https://github.com/PrismLauncher/PrismLauncher into feature/java-downloader

2024-05-18 14:14:31 +03:00 · 2024-05-18 14:14:31 +03:00 · 7a5348a179
commit 7a5348a179
parent 81874f22f7 3887cfe5df
172 changed files with 2052 additions and 3151 deletions
--- a/.github/scripts/prepare_JREs.sh
+++ b/.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
--- a/.github/workflows/backport.yml
+++ b/.github/workflows/backport.yml
@ -25,7 +25,7 @@ jobs:
        with:
          ref: ${{ github.event.pull_request.head.sha }}
      - name: Create backport PRs
-        uses: korthout/backport-action@v2.4.1
+        uses: korthout/backport-action@v2.5.0
        with:
          # Config README: https://github.com/korthout/backport-action#backport-action
          pull_description: |-
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@ -54,14 +54,17 @@ jobs:
        include:
          - os: ubuntu-20.04
            qt_ver: 5
+            qt_host: linux
+            qt_arch: ""
+            qt_version: "5.12.8"
+            qt_modules: "qtnetworkauth"

          - os: ubuntu-20.04
            qt_ver: 6
            qt_host: linux
            qt_arch: ""
            qt_version: "6.2.4"
-            qt_modules: "qt5compat qtimageformats"
-            qt_tools: ""
+            qt_modules: "qt5compat qtimageformats qtnetworkauth"

          - os: windows-2022
            name: "Windows-MinGW-w64"
@ -75,10 +78,9 @@ jobs:
            vcvars_arch: "amd64"
            qt_ver: 6
            qt_host: windows
-            qt_arch: ''
-            qt_version: '6.6.2'
-            qt_modules: 'qt5compat qtimageformats'
-            qt_tools: ''
+            qt_arch: ""
+            qt_version: "6.7.0"
+            qt_modules: "qt5compat qtimageformats qtnetworkauth"

          - os: windows-2022
            name: "Windows-MSVC-arm64"
@ -87,20 +89,18 @@ jobs:
            vcvars_arch: "amd64_arm64"
            qt_ver: 6
            qt_host: windows
-            qt_arch: 'win64_msvc2019_arm64'
-            qt_version: '6.6.2'
-            qt_modules: 'qt5compat qtimageformats'
-            qt_tools: ''
+            qt_arch: "win64_msvc2019_arm64"
+            qt_version: "6.7.0"
+            qt_modules: "qt5compat qtimageformats qtnetworkauth"

          - os: macos-12
            name: macOS
            macosx_deployment_target: 11.0
            qt_ver: 6
            qt_host: mac
-            qt_arch: ''
-            qt_version: '6.6.2'
-            qt_modules: 'qt5compat qtimageformats'
-            qt_tools: ''
+            qt_arch: ""
+            qt_version: "6.7.0"
+            qt_modules: "qt5compat qtimageformats qtnetworkauth"

          - os: macos-12
            name: macOS-Legacy
@ -108,8 +108,7 @@ jobs:
            qt_ver: 5
            qt_host: mac
            qt_version: "5.15.2"
-            qt_modules: ""
-            qt_tools: ""
+            qt_modules: "qtnetworkauth"

    runs-on: ${{ matrix.os }}

@ -151,6 +150,7 @@ jobs:
            quazip-qt6:p
            ccache:p
            qt6-5compat:p
+            qt6-networkauth:p
            cmark:p

      - name: Force newer ccache
@ -160,13 +160,13 @@ jobs:

      - name: Setup ccache
        if: (runner.os != 'Windows' || matrix.msystem == '') && inputs.build_type == 'Debug'
-        uses: hendrikmuhs/ccache-action@v1.2.12
+        uses: hendrikmuhs/ccache-action@v1.2.13
        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@v4.0.1
+        uses: actions/cache@v4.0.2
        with:
          path: '${{ github.workspace }}\.ccache'
          key: ${{ matrix.os }}-mingw-w64-ccache-${{ github.run_id }}
@ -207,11 +207,6 @@ jobs:
          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
@ -223,20 +218,18 @@ jobs:
          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 == '')
+      - name: Install Qt (macOS, Linux & Windows MSVC)
+        if: 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 }}
@ -259,7 +252,6 @@ jobs:

          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)
@ -433,12 +425,6 @@ jobs:
        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
@ -491,26 +477,6 @@ jobs:
            ":warning: Skipped code signing for Windows, as certificate was not present." >> $env:GITHUB_STEP_SUMMARY
          }

-      - 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
-
-          cd ${{ env.INSTALL_DIR }}
-          tar --owner root --group root -czf ../PrismLauncher.tar.gz *
-
-      - 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
-
-
-          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
@ -526,13 +492,9 @@ jobs:

          chmod +x linuxdeploy-*.AppImage

-          mkdir -p ${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib/jvm/java-{8,17}-openjdk
+          mkdir -p ${{ env.INSTALL_APPIMAGE_DIR }}/usr/lib
          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/
@ -540,10 +502,6 @@ jobs:
          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
@ -565,6 +523,25 @@ jobs:

          mv "PrismLauncher-Linux-x86_64.AppImage" "PrismLauncher-Linux-${{ env.VERSION }}-${{ inputs.build_type }}-x86_64.AppImage"

+      - name: Package (Linux, portable)
+        if: runner.os == 'Linux'
+        run: |
+          cmake -S . -B ${{ env.BUILD_DIR }} -DCMAKE_INSTALL_PREFIX=${{ env.INSTALL_PORTABLE_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 }} -DLauncher_BUILD_ARTIFACT=Linux-Qt${{ matrix.qt_ver }} -DINSTALL_BUNDLE=full -G Ninja
+          cmake --install ${{ env.BUILD_DIR }}
+          cmake --install ${{ env.BUILD_DIR }} --component portable
+
+          mkdir  ${{ env.INSTALL_PORTABLE_DIR }}/lib
+          cp /lib/x86_64-linux-gnu/libbz2.so.1.0 ${{ env.INSTALL_PORTABLE_DIR }}/lib
+          cp /usr/lib/x86_64-linux-gnu/libgobject-2.0.so.0 ${{ env.INSTALL_PORTABLE_DIR }}/lib
+          cp /usr/lib/x86_64-linux-gnu/libcrypto.so.1.1 ${{ env.INSTALL_PORTABLE_DIR }}/lib
+          cp /usr/lib/x86_64-linux-gnu/libssl.so.1.1 ${{ env.INSTALL_PORTABLE_DIR }}/lib
+          cp /usr/lib/x86_64-linux-gnu/libffi.so.7 ${{ env.INSTALL_PORTABLE_DIR }}/lib
+          mv ${{ env.INSTALL_PORTABLE_DIR }}/bin/*.so* ${{ env.INSTALL_PORTABLE_DIR }}/lib
+
+          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
+          cd ${{ env.INSTALL_PORTABLE_DIR }}
+          tar -czf ../PrismLauncher-portable.tar.gz *
+
      ##
      # UPLOAD BUILDS
      ##
@ -597,13 +574,6 @@ jobs:
          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@v4
-        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@v4
@ -611,13 +581,6 @@ jobs:
          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@v4
-        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@v4
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@ -23,7 +23,7 @@ jobs:
        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
+          sudo apt-get -y install ninja-build extra-cmake-modules scdoc qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools libqt5core5a libqt5network5 libqt5gui5 libqt5networkauth5 libqt5networkauth5-dev

      - name: Configure and Build
        run: |
--- a/.github/workflows/trigger_release.yml
+++ b/.github/workflows/trigger_release.yml
@ -46,9 +46,7 @@ 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.zip PrismLauncher-macOS-Legacy-${{ env.VERSION }}.zip
@ -92,11 +90,9 @@ jobs:
          draft: true
          prerelease: false
          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-Qt6-Portable-${{ env.VERSION }}.tar.gz
            PrismLauncher-Windows-MinGW-w64-${{ env.VERSION }}.zip
            PrismLauncher-Windows-MinGW-w64-Portable-${{ env.VERSION }}.zip
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -295,7 +295,7 @@ endif()
 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)
+    find_package(Qt5 REQUIRED COMPONENTS Core Widgets Concurrent Network Test Xml NetworkAuth)

    if(NOT Launcher_FORCE_BUNDLED_LIBS)
        find_package(QuaZip-Qt5 1.3 QUIET)
@ -309,7 +309,7 @@ if(Launcher_QT_VERSION_MAJOR EQUAL 5)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUNICODE -D_UNICODE")
 elseif(Launcher_QT_VERSION_MAJOR EQUAL 6)
    set(QT_VERSION_MAJOR 6)
-    find_package(Qt6 REQUIRED COMPONENTS Core CoreTools Widgets Concurrent Network Test Xml Core5Compat)
+    find_package(Qt6 REQUIRED COMPONENTS Core CoreTools Widgets Concurrent Network Test Xml Core5Compat NetworkAuth)
    list(APPEND Launcher_QT_LIBS Qt6::Core5Compat)

    if(NOT Launcher_FORCE_BUNDLED_LIBS)
@ -430,7 +430,19 @@ elseif(UNIX)
    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}")
+
+    if (INSTALL_BUNDLE STREQUAL full)
+        set(PLUGIN_DEST_DIR "plugins")
+        set(BUNDLE_DEST_DIR ".")
+        set(RESOURCES_DEST_DIR ".")
    
+        # Apps to bundle
+        set(APPS "\${CMAKE_INSTALL_PREFIX}/bin/${Launcher_APP_BINARY_NAME}")
+    
+        # directories to look for dependencies
+        set(DIRS ${QT_LIBS_DIR} ${QT_LIBEXECS_DIR} ${CMAKE_LIBRARY_OUTPUT_DIRECTORY} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+    endif()
+
    if(Launcher_ManPage)
        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${Launcher_ManPage} DESTINATION "${KDE_INSTALL_MANDIR}/man6")
    endif()
@ -524,7 +536,6 @@ if(NOT cmark_FOUND)
 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)
--- a/COPYING.md
+++ b/COPYING.md
@ -333,32 +333,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
--- a/cmake/MacOSXBundleInfo.plist.in
+++ b/cmake/MacOSXBundleInfo.plist.in
@ -6,6 +6,8 @@
    <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>NSPrincipalClass</key>
    <string>NSApplication</string>
    <key>NSHighResolutionCapable</key>
--- a/flake.lock
+++ b/flake.lock
@ -23,11 +23,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1709336216,
-        "narHash": "sha256-Dt/wOWeW6Sqm11Yh+2+t0dfEWxoMxGBvv3JpIocFl9E=",
+        "lastModified": 1714641030,
+        "narHash": "sha256-yzcRNDoyVP7+SCNX0wmuDju1NUCt8Dz9+lyUXEI0dbI=",
        "owner": "hercules-ci",
        "repo": "flake-parts",
-        "rev": "f7b3c975cf067e56e7cda6cb098ebe3fb4d74ca2",
+        "rev": "e5d10a24b66c3ea8f150e47dfdb0416ab7c3390e",
        "type": "github"
      },
      "original": {
@ -41,11 +41,11 @@
        "systems": "systems"
      },
      "locked": {
-        "lastModified": 1701680307,
-        "narHash": "sha256-kAuep2h5ajznlPMD9rnQyffWG8EM/C73lejGofXvdM8=",
+        "lastModified": 1710146030,
+        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
        "owner": "numtide",
        "repo": "flake-utils",
-        "rev": "4022d587cbbfd70fe950c1e2083a02621806a725",
+        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
        "type": "github"
      },
      "original": {
@ -62,11 +62,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1703887061,
-        "narHash": "sha256-gGPa9qWNc6eCXT/+Z5/zMkyYOuRZqeFZBDbopNZQkuY=",
+        "lastModified": 1709087332,
+        "narHash": "sha256-HG2cCnktfHsKV0s4XW83gU3F57gaTljL9KNSuG6bnQs=",
        "owner": "hercules-ci",
        "repo": "gitignore.nix",
-        "rev": "43e1aa1308018f37118e34d3a9cb4f5e75dc11d5",
+        "rev": "637db329424fd7e46cf4185293b9cc8c88c95394",
        "type": "github"
      },
      "original": {
@ -93,11 +93,11 @@
    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1710534455,
-        "narHash": "sha256-huQT4Xs0y4EeFKn2BTBVYgEwJSv8SDlm82uWgMnCMmI=",
+        "lastModified": 1715413075,
+        "narHash": "sha256-FCi3R1MeS5bVp0M0xTheveP6hhcCYfW/aghSTPebYL4=",
        "owner": "nixos",
        "repo": "nixpkgs",
-        "rev": "9af9c1c87ed3e3ed271934cb896e0cdd33dae212",
+        "rev": "e4e7a43a9db7e22613accfeb1005cca1b2b1ee0d",
        "type": "github"
      },
      "original": {
@ -122,11 +122,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1708018599,
-        "narHash": "sha256-M+Ng6+SePmA8g06CmUZWi1AjG2tFBX9WCXElBHEKnyM=",
+        "lastModified": 1714478972,
+        "narHash": "sha256-q//cgb52vv81uOuwz1LaXElp3XAe1TqrABXODAEF6Sk=",
        "owner": "cachix",
        "repo": "pre-commit-hooks.nix",
-        "rev": "5df5a70ad7575f6601d91f0efec95dd9bc619431",
+        "rev": "2849da033884f54822af194400f8dff435ada242",
        "type": "github"
      },
      "original": {
--- a/flatpak/org.prismlauncher.PrismLauncher.yml
+++ b/flatpak/org.prismlauncher.PrismLauncher.yml
@ -3,6 +3,7 @@ runtime: org.kde.Platform
 runtime-version: 5.15-23.08
 sdk: org.kde.Sdk
 sdk-extensions:
+  - org.freedesktop.Sdk.Extension.openjdk21
  - org.freedesktop.Sdk.Extension.openjdk17
  - org.freedesktop.Sdk.Extension.openjdk8

@ -50,6 +51,8 @@ modules:
    buildsystem: simple
    build-commands:
      - mkdir -p /app/jdk/
+      - /usr/lib/sdk/openjdk21/install.sh
+      - mv /app/jre /app/jdk/21
      - /usr/lib/sdk/openjdk17/install.sh
      - mv /app/jre /app/jdk/17
      - /usr/lib/sdk/openjdk8/install.sh
--- a/launcher/Application.cpp
+++ b/launcher/Application.cpp
@ -49,6 +49,7 @@
 #include "pathmatcher/MultiMatcher.h"
 #include "pathmatcher/SimplePrefixMatcher.h"
 #include "settings/INIFile.h"
+#include "tools/GenericProfiler.h"
 #include "ui/InstanceWindow.h"
 #include "ui/MainWindow.h"

@ -227,6 +228,7 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)

    // Don't quit on hiding the last window
    this->setQuitOnLastWindowClosed(false);
+    this->setQuitLockEnabled(false);

    // Commandline parsing
    QCommandLineParser parser;
@ -310,7 +312,11 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
        adjustedBy = "Persistent data path";

 #ifndef Q_OS_MACOS
-        if (QFile::exists(FS::PathCombine(m_rootPath, "portable.txt"))) {
+        if (auto portableUserData = FS::PathCombine(m_rootPath, "UserData"); QDir(portableUserData).exists()) {
+            dataPath = portableUserData;
+            adjustedBy = "Portable user data path";
+            m_portable = true;
+        } else if (QFile::exists(FS::PathCombine(m_rootPath, "portable.txt"))) {
            dataPath = m_rootPath;
            adjustedBy = "Portable data path";
            m_portable = true;
@ -880,6 +886,7 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
    // FIXME: what to do with these?
    m_profilers.insert("jprofiler", std::shared_ptr<BaseProfilerFactory>(new JProfilerFactory()));
    m_profilers.insert("jvisualvm", std::shared_ptr<BaseProfilerFactory>(new JVisualVMFactory()));
+    m_profilers.insert("generic", std::shared_ptr<BaseProfilerFactory>(new GenericProfilerFactory()));
    for (auto profiler : m_profilers.values()) {
        profiler->registerSettings(m_settings);
    }
--- a/launcher/CMakeLists.txt
+++ b/launcher/CMakeLists.txt
@ -128,7 +128,6 @@ set(NET_SOURCES
    net/MetaCacheSink.h
    net/Logging.h
    net/Logging.cpp
-    net/NetAction.h
    net/NetJob.cpp
    net/NetJob.h
    net/NetUtils.h
@ -212,28 +211,17 @@ set(MINECRAFT_SOURCES
    minecraft/auth/AccountData.h
    minecraft/auth/AccountList.cpp
    minecraft/auth/AccountList.h
-    minecraft/auth/AccountTask.cpp
-    minecraft/auth/AccountTask.h
-    minecraft/auth/AuthRequest.cpp
-    minecraft/auth/AuthRequest.h
    minecraft/auth/AuthSession.cpp
    minecraft/auth/AuthSession.h
-    minecraft/auth/AuthStep.cpp
    minecraft/auth/AuthStep.h
    minecraft/auth/MinecraftAccount.cpp
    minecraft/auth/MinecraftAccount.h
    minecraft/auth/Parsers.cpp
    minecraft/auth/Parsers.h

-    minecraft/auth/flows/AuthFlow.cpp
-    minecraft/auth/flows/AuthFlow.h
-    minecraft/auth/flows/MSA.cpp
-    minecraft/auth/flows/MSA.h
-    minecraft/auth/flows/Offline.cpp
-    minecraft/auth/flows/Offline.h
+    minecraft/auth/AuthFlow.cpp
+    minecraft/auth/AuthFlow.h

-    minecraft/auth/steps/OfflineStep.cpp
-    minecraft/auth/steps/OfflineStep.h
    minecraft/auth/steps/EntitlementsStep.cpp
    minecraft/auth/steps/EntitlementsStep.h
    minecraft/auth/steps/GetSkinStep.cpp
@ -242,6 +230,8 @@ set(MINECRAFT_SOURCES
    minecraft/auth/steps/LauncherLoginStep.h
    minecraft/auth/steps/MinecraftProfileStep.cpp
    minecraft/auth/steps/MinecraftProfileStep.h
+    minecraft/auth/steps/MSADeviceCodeStep.cpp
+    minecraft/auth/steps/MSADeviceCodeStep.h
    minecraft/auth/steps/MSAStep.cpp
    minecraft/auth/steps/MSAStep.h
    minecraft/auth/steps/XboxAuthorizationStep.cpp
@ -467,6 +457,8 @@ set(TOOLS_SOURCES
    tools/JVisualVM.h
    tools/MCEditTool.cpp
    tools/MCEditTool.h
+    tools/GenericProfiler.cpp
+    tools/GenericProfiler.h
 )

 set(META_SOURCES
@ -638,7 +630,6 @@ set(PRISMUPDATER_SOURCES
    net/HttpMetaCache.h
    net/Logging.h
    net/Logging.cpp
-    net/NetAction.h
    net/NetRequest.cpp
    net/NetRequest.h
    net/NetJob.cpp
@ -843,6 +834,8 @@ SET(LAUNCHER_SOURCES
    ui/themes/DarkTheme.h
    ui/themes/ITheme.cpp
    ui/themes/ITheme.h
+    ui/themes/HintOverrideProxyStyle.cpp
+    ui/themes/HintOverrideProxyStyle.h
    ui/themes/SystemTheme.cpp
    ui/themes/SystemTheme.h
    ui/themes/IconTheme.cpp
@ -1255,7 +1248,6 @@ target_link_libraries(Launcher_logic
    tomlplusplus::tomlplusplus
    qdcss
    BuildConfig
-    Katabasis
    Qt${QT_VERSION_MAJOR}::Widgets
    ghcFilesystem::ghc_filesystem
 )
@ -1273,6 +1265,7 @@ target_link_libraries(Launcher_logic
    Qt${QT_VERSION_MAJOR}::Concurrent
    Qt${QT_VERSION_MAJOR}::Gui
    Qt${QT_VERSION_MAJOR}::Widgets
+    Qt${QT_VERSION_MAJOR}::NetworkAuth
    ${Launcher_QT_LIBS}
 )
 target_link_libraries(Launcher_logic
@ -1343,7 +1336,6 @@ if(Launcher_BUILD_UPDATER)
        Qt${QT_VERSION_MAJOR}::Network
        ${Launcher_QT_LIBS}
        cmark::cmark
-        Katabasis
    )

    add_executable("${Launcher_Name}_updater" WIN32 updater/prismupdater/updater_main.cpp)
@ -1508,7 +1500,6 @@ if(INSTALL_BUNDLE STREQUAL "full")
            CONFIGURATIONS Debug RelWithDebInfo ""
            DESTINATION ${PLUGIN_DEST_DIR}
            COMPONENT Runtime
-            PATTERN "*qopensslbackend*" EXCLUDE
            PATTERN "*qcertonlybackend*" EXCLUDE
        )
        install(
@ -1519,10 +1510,78 @@ if(INSTALL_BUNDLE STREQUAL "full")
            REGEX "dd\\." EXCLUDE
            REGEX "_debug\\." EXCLUDE
            REGEX "\\.dSYM" EXCLUDE
-            PATTERN "*qopensslbackend*" EXCLUDE
            PATTERN "*qcertonlybackend*" EXCLUDE
        )
    endif()
+    # Wayland support
+    if(EXISTS "${QT_PLUGINS_DIR}/wayland-graphics-integration-client")
+        install(
+            DIRECTORY "${QT_PLUGINS_DIR}/wayland-graphics-integration-client"
+            CONFIGURATIONS Debug RelWithDebInfo ""
+            DESTINATION ${PLUGIN_DEST_DIR}
+            COMPONENT Runtime
+        )
+        install(
+            DIRECTORY "${QT_PLUGINS_DIR}/wayland-graphics-integration-client"
+            CONFIGURATIONS Release MinSizeRel
+            DESTINATION ${PLUGIN_DEST_DIR}
+            COMPONENT Runtime
+            REGEX "dd\\." EXCLUDE
+            REGEX "_debug\\." EXCLUDE
+            REGEX "\\.dSYM" EXCLUDE
+        )
+    endif()
+    if(EXISTS "${QT_PLUGINS_DIR}/wayland-graphics-integration-server")
+        install(
+            DIRECTORY "${QT_PLUGINS_DIR}/wayland-graphics-integration-server"
+            CONFIGURATIONS Debug RelWithDebInfo ""
+            DESTINATION ${PLUGIN_DEST_DIR}
+            COMPONENT Runtime
+        )
+        install(
+            DIRECTORY "${QT_PLUGINS_DIR}/wayland-graphics-integration-server"
+            CONFIGURATIONS Release MinSizeRel
+            DESTINATION ${PLUGIN_DEST_DIR}
+            COMPONENT Runtime
+            REGEX "dd\\." EXCLUDE
+            REGEX "_debug\\." EXCLUDE
+            REGEX "\\.dSYM" EXCLUDE
+        )
+    endif()
+    if(EXISTS "${QT_PLUGINS_DIR}/wayland-decoration-client")
+        install(
+            DIRECTORY "${QT_PLUGINS_DIR}/wayland-decoration-client"
+            CONFIGURATIONS Debug RelWithDebInfo ""
+            DESTINATION ${PLUGIN_DEST_DIR}
+            COMPONENT Runtime
+        )
+        install(
+            DIRECTORY "${QT_PLUGINS_DIR}/wayland-decoration-client"
+            CONFIGURATIONS Release MinSizeRel
+            DESTINATION ${PLUGIN_DEST_DIR}
+            COMPONENT Runtime
+            REGEX "dd\\." EXCLUDE
+            REGEX "_debug\\." EXCLUDE
+            REGEX "\\.dSYM" EXCLUDE
+        )
+    endif()
+    if(EXISTS "${QT_PLUGINS_DIR}/wayland-shell-integration")
+        install(
+            DIRECTORY "${QT_PLUGINS_DIR}/wayland-shell-integration"
+            CONFIGURATIONS Debug RelWithDebInfo ""
+            DESTINATION ${PLUGIN_DEST_DIR}
+            COMPONENT Runtime
+        )
+        install(
+            DIRECTORY "${QT_PLUGINS_DIR}/wayland-shell-integration"
+            CONFIGURATIONS Release MinSizeRel
+            DESTINATION ${PLUGIN_DEST_DIR}
+            COMPONENT Runtime
+            REGEX "dd\\." EXCLUDE
+            REGEX "_debug\\." EXCLUDE
+            REGEX "\\.dSYM" EXCLUDE
+        )
+    endif()
    configure_file(
        "${CMAKE_CURRENT_SOURCE_DIR}/install_prereqs.cmake.in"
        "${CMAKE_CURRENT_BINARY_DIR}/install_prereqs.cmake"
--- a/launcher/FileSystem.cpp
+++ b/launcher/FileSystem.cpp
@ -804,15 +804,24 @@ QString NormalizePath(QString path)
    }
 }

-QString badFilenameChars = "\"\\/?<>:;*|!+\r\n";
+static const QString BAD_PATH_CHARS = "\"?<>:;*|!+\r\n";
+static const QString BAD_FILENAME_CHARS = BAD_PATH_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 string, QChar replaceWith)
+{
+    for (int i = 0; i < string.length(); i++)
+        if (string.at(i) < ' ' || BAD_PATH_CHARS.contains(string.at(i)))
+            string[i] = replaceWith;
+
    return string;
 }

@ -1588,4 +1597,44 @@ 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
+
 }  // namespace FS
--- a/launcher/FileSystem.h
+++ b/launcher/FileSystem.h
@ -342,6 +342,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 "!"
@ -551,4 +553,8 @@ bool canLink(const QString& src, const QString& dst);

 uintmax_t hardLinkCount(const QString& path);

+#ifdef Q_OS_WIN
+QString getPathNameInLocal8bit(const QString& file);
+#endif
+
 }  // namespace FS
--- a/launcher/InstanceCreationTask.cpp
+++ b/launcher/InstanceCreationTask.cpp
@ -3,8 +3,6 @@
 #include <QDebug>
 #include <QFile>

-InstanceCreationTask::InstanceCreationTask() = default;
-
 void InstanceCreationTask::executeTask()
 {
    setAbortable(true);
--- a/launcher/InstanceCreationTask.h
+++ b/launcher/InstanceCreationTask.h
@ -6,7 +6,7 @@
 class InstanceCreationTask : public InstanceTask {
    Q_OBJECT
   public:
-    InstanceCreationTask();
+    InstanceCreationTask() = default;
    virtual ~InstanceCreationTask() = default;

   protected:
--- a/launcher/InstanceImportTask.h
+++ b/launcher/InstanceImportTask.h
@ -47,9 +47,6 @@
 #include <optional>

 class QuaZip;
-namespace Flame {
-class FileResolvingTask;
-}

 class InstanceImportTask : public InstanceTask {
    Q_OBJECT
@ -79,7 +76,6 @@ class InstanceImportTask : public InstanceTask {

   private: /* data */
    NetJob::Ptr m_filesNetJob;
-    shared_qobject_ptr<Flame::FileResolvingTask> m_modIdResolver;
    QUrl m_sourceUrl;
    QString m_archivePath;
    bool m_downloadRequired = false;
--- a/launcher/LaunchController.cpp
+++ b/launcher/LaunchController.cpp
@ -57,7 +57,6 @@
 #include "BuildConfig.h"
 #include "JavaCommon.h"
 #include "launch/steps/TextPrint.h"
-#include "minecraft/auth/AccountTask.h"
 #include "tasks/Task.h"

 LaunchController::LaunchController(QObject* parent) : Task(parent) {}
--- a/launcher/MMCZip.cpp
+++ b/launcher/MMCZip.cpp
@ -119,6 +119,7 @@ bool compressDirFiles(QuaZip* zip, QString dir, QFileInfoList files, bool follow
 bool compressDirFiles(QString fileCompressed, QString dir, QFileInfoList files, bool followSymlinks)
 {
    QuaZip zip(fileCompressed);
+    zip.setUtf8Enabled(true);
    QDir().mkpath(QFileInfo(fileCompressed).absolutePath());
    if (!zip.open(QuaZip::mdCreate)) {
        QFile::remove(fileCompressed);
@ -141,6 +142,7 @@ bool compressDirFiles(QString fileCompressed, QString dir, QFileInfoList files,
 bool createModdedJar(QString sourceJarPath, QString targetJarPath, const QList<Mod*>& mods)
 {
    QuaZip zipOut(targetJarPath);
+    zipOut.setUtf8Enabled(true);
    if (!zipOut.open(QuaZip::mdCreate)) {
        QFile::remove(targetJarPath);
        qCritical() << "Failed to open the minecraft.jar for modding";
@ -286,10 +288,13 @@ std::optional<QStringList> extractSubDir(QuaZip* zip, const QString& subdir, con

    do {
        QString file_name = zip->getCurrentFileName();
+#ifdef Q_OS_WIN
+        file_name = FS::RemoveInvalidPathChars(file_name);
+#endif
        if (!file_name.startsWith(subdir))
            continue;

-        auto relative_file_name = QDir::fromNativeSeparators(file_name.remove(0, subdir.size()));
+        auto relative_file_name = QDir::fromNativeSeparators(file_name.mid(subdir.size()));
        auto original_name = relative_file_name;

        // Fix subdirs/files ending with a / getting transformed into absolute paths
--- a/launcher/MMCZip.h
+++ b/launcher/MMCZip.h
@ -154,7 +154,12 @@ bool collectFileListRecursively(const QString& rootDir, const QString& subDir, Q
 #if defined(LAUNCHER_APPLICATION)
 class ExportToZipTask : public Task {
   public:
-    ExportToZipTask(QString outputPath, QDir dir, QFileInfoList files, QString destinationPrefix = "", bool followSymlinks = false)
+    ExportToZipTask(QString outputPath,
+                    QDir dir,
+                    QFileInfoList files,
+                    QString destinationPrefix = "",
+                    bool followSymlinks = false,
+                    bool utf8Enabled = false)
        : m_output_path(outputPath)
        , m_output(outputPath)
        , m_dir(dir)
@ -163,9 +168,15 @@ class ExportToZipTask : public Task {
        , m_follow_symlinks(followSymlinks)
    {
        setAbortable(true);
+        m_output.setUtf8Enabled(utf8Enabled);
    };
-    ExportToZipTask(QString outputPath, QString dir, QFileInfoList files, QString destinationPrefix = "", bool followSymlinks = false)
-        : ExportToZipTask(outputPath, QDir(dir), files, destinationPrefix, followSymlinks){};
+    ExportToZipTask(QString outputPath,
+                    QString dir,
+                    QFileInfoList files,
+                    QString destinationPrefix = "",
+                    bool followSymlinks = false,
+                    bool utf8Enabled = false)
+        : ExportToZipTask(outputPath, QDir(dir), files, destinationPrefix, followSymlinks, utf8Enabled){};

    virtual ~ExportToZipTask() = default;

--- a/launcher/install_prereqs.cmake.in
+++ b/launcher/install_prereqs.cmake.in
@ -1,5 +1,4 @@
 set(CMAKE_MODULE_PATH "@CMAKE_MODULE_PATH@")
-
 file(GLOB_RECURSE    QTPLUGINS "${CMAKE_INSTALL_PREFIX}/@PLUGIN_DEST_DIR@/*@CMAKE_SHARED_LIBRARY_SUFFIX@")
 function(gp_resolved_file_type_override resolved_file type_var)
    if(resolved_file MATCHES "^/(usr/)?lib/libQt")
--- a/launcher/java/JavaChecker.cpp
+++ b/launcher/java/JavaChecker.cpp
@ -55,6 +55,9 @@ void JavaChecker::executeTask()
        qDebug() << "Java checker library could not be found. Please check your installation.";
        return;
    }
+#ifdef Q_OS_WIN
+    checkerJar = FS::getPathNameInLocal8bit(checkerJar);
+#endif

    QStringList args;

--- a/launcher/java/JavaUtils.cpp
+++ b/launcher/java/JavaUtils.cpp
@ -363,6 +363,12 @@ QList<QString> JavaUtils::FindJavaPaths()
        javas.append(systemLibraryJVMDir.absolutePath() + "/" + java + "/Contents/Home/bin/java");
        javas.append(systemLibraryJVMDir.absolutePath() + "/" + java + "/Contents/Commands/java");
    }
+
+    auto home = qEnvironmentVariable("HOME");
+
+    // javas downloaded by sdkman
+    javas.append(FS::PathCombine(home, ".sdkman/candidates/java"));
+
    javas.append(getMinecraftJavaBundle());
    javas.append(getPrismJavaBundle());
    javas = addJavasFromEnv(javas);
@ -415,6 +421,8 @@ QList<QString> JavaUtils::FindJavaPaths()
    scanJavaDirs(FS::PathCombine(home, ".jdks"));
    // javas downloaded by sdkman
    scanJavaDirs(FS::PathCombine(home, ".sdkman/candidates/java"));
+    // javas downloaded by gradle (toolchains)
+    scanJavaDirs(FS::PathCombine(home, ".gradle/jdks"));

    javas.append(getMinecraftJavaBundle());
    javas.append(getPrismJavaBundle());
@ -444,26 +452,25 @@ QString JavaUtils::getJavaCheckPath()

 QStringList getMinecraftJavaBundle()
 {
-    QString partialPath;
    QString executable = "java";
    QStringList processpaths;
 #if defined(Q_OS_OSX)
-    partialPath = FS::PathCombine(QDir::homePath(), "Library/Application Support");
+    processpaths << FS::PathCombine(QDir::homePath(), FS::PathCombine("Library", "Application Support", "minecraft", "runtime"));
 #elif defined(Q_OS_WIN32)
-    partialPath = QProcessEnvironment::systemEnvironment().value("LOCALAPPDATA", "");
    executable += "w.exe";

+    auto appDataPath = QProcessEnvironment::systemEnvironment().value("APPDATA", "");
+    processpaths << FS::PathCombine(QFileInfo(appDataPath).absoluteFilePath(), ".minecraft", "runtime");
+
    // add the microsoft store version of the launcher to the search. the current path is:
    // C:\Users\USERNAME\AppData\Local\Packages\Microsoft.4297127D64EC6_8wekyb3d8bbwe\LocalCache\Local\runtime
+    auto localAppDataPath = QProcessEnvironment::systemEnvironment().value("LOCALAPPDATA", "");
    auto minecraftMSStorePath =
-        FS::PathCombine(QFileInfo(partialPath).absolutePath(), "Local", "Packages", "Microsoft.4297127D64EC6_8wekyb3d8bbwe");
-    minecraftMSStorePath = FS::PathCombine(minecraftMSStorePath, "LocalCache", "Local", "runtime");
-    processpaths << minecraftMSStorePath;
+        FS::PathCombine(QFileInfo(localAppDataPath).absoluteFilePath(), "Packages", "Microsoft.4297127D64EC6_8wekyb3d8bbwe");
+    processpaths << FS::PathCombine(minecraftMSStorePath, "LocalCache", "Local", "runtime");
 #else
-    partialPath = QDir::homePath();
+    processpaths << FS::PathCombine(QDir::homePath(), ".minecraft", "runtime");
 #endif
-    auto minecraftDataPath = FS::PathCombine(partialPath, ".minecraft", "runtime");
-    processpaths << minecraftDataPath;

    QStringList javas;
    while (!processpaths.isEmpty()) {
--- a/launcher/minecraft/AssetsUtils.cpp
+++ b/launcher/minecraft/AssetsUtils.cpp
@ -51,6 +51,7 @@
 #include "net/Download.h"

 #include "Application.h"
+#include "net/NetRequest.h"

 namespace {
 QSet<QString> collectPathsFromDir(QString dirPath)
@ -276,7 +277,7 @@ bool reconstructAssets(QString assetsId, QString resourcesFolder)

 }  // namespace AssetsUtils

-NetAction::Ptr AssetObject::getDownloadAction()
+Net::NetRequest::Ptr AssetObject::getDownloadAction()
 {
    QFileInfo objectFile(getLocalPath());
    if ((!objectFile.isFile()) || (objectFile.size() != size)) {
--- a/launcher/minecraft/AssetsUtils.h
+++ b/launcher/minecraft/AssetsUtils.h
@ -17,14 +17,14 @@

 #include <QMap>
 #include <QString>
-#include "net/NetAction.h"
 #include "net/NetJob.h"
+#include "net/NetRequest.h"

 struct AssetObject {
    QString getRelPath();
    QUrl getUrl();
    QString getLocalPath();
-    NetAction::Ptr getDownloadAction();
+    Net::NetRequest::Ptr getDownloadAction();

    QString hash;
    qint64 size;
--- a/launcher/minecraft/Library.cpp
+++ b/launcher/minecraft/Library.cpp
@ -35,6 +35,7 @@

 #include "Library.h"
 #include "MinecraftInstance.h"
+#include "net/NetRequest.h"

 #include <BuildConfig.h>
 #include <FileSystem.h>
@ -74,12 +75,12 @@ void Library::getApplicableFiles(const RuntimeContext& runtimeContext,
    }
 }

-QList<NetAction::Ptr> Library::getDownloads(const RuntimeContext& runtimeContext,
-                                            class HttpMetaCache* cache,
-                                            QStringList& failedLocalFiles,
-                                            const QString& overridePath) const
+QList<Net::NetRequest::Ptr> Library::getDownloads(const RuntimeContext& runtimeContext,
+                                                  class HttpMetaCache* cache,
+                                                  QStringList& failedLocalFiles,
+                                                  const QString& overridePath) const
 {
-    QList<NetAction::Ptr> out;
+    QList<Net::NetRequest::Ptr> out;
    bool stale = isAlwaysStale();
    bool local = isLocal();

--- a/launcher/minecraft/Library.h
+++ b/launcher/minecraft/Library.h
@ -34,7 +34,6 @@
 */

 #pragma once
-#include <net/NetAction.h>
 #include <QDir>
 #include <QList>
 #include <QMap>
@ -48,6 +47,7 @@
 #include "MojangDownloadInfo.h"
 #include "Rule.h"
 #include "RuntimeContext.h"
+#include "net/NetRequest.h"

 class Library;
 class MinecraftInstance;
@ -144,10 +144,10 @@ class Library {
    bool isForge() const;

    // Get a list of downloads for this library
-    QList<NetAction::Ptr> getDownloads(const RuntimeContext& runtimeContext,
-                                       class HttpMetaCache* cache,
-                                       QStringList& failedLocalFiles,
-                                       const QString& overridePath) const;
+    QList<Net::NetRequest::Ptr> getDownloads(const RuntimeContext& runtimeContext,
+                                             class HttpMetaCache* cache,
+                                             QStringList& failedLocalFiles,
+                                             const QString& overridePath) const;

    QString getCompatibleNative(const RuntimeContext& runtimeContext) const;

--- a/launcher/minecraft/MinecraftInstance.cpp
+++ b/launcher/minecraft/MinecraftInstance.cpp
@ -667,8 +667,12 @@ QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session, Mine
    }

    if (serverToJoin && !serverToJoin->address.isEmpty()) {
-        args_pattern += " --server " + serverToJoin->address;
-        args_pattern += " --port " + QString::number(serverToJoin->port);
+        if (profile->hasTrait("feature:is_quick_play_multiplayer")) {
+            args_pattern += " --quickPlayMultiplayer " + serverToJoin->address + ':' + QString::number(serverToJoin->port);
+        } else {
+            args_pattern += " --server " + serverToJoin->address;
+            args_pattern += " --port " + QString::number(serverToJoin->port);
+        }
    }

    QMap<QString, QString> token_mapping;
--- a/launcher/minecraft/auth/AccountData.cpp
+++ b/launcher/minecraft/auth/AccountData.cpp
@ -42,7 +42,7 @@
 #include <QUuid>

 namespace {
-void tokenToJSONV3(QJsonObject& parent, Katabasis::Token t, const char* tokenName)
+void tokenToJSONV3(QJsonObject& parent, Token t, const char* tokenName)
 {
    if (!t.persistent) {
        return;
@ -74,9 +74,9 @@ void tokenToJSONV3(QJsonObject& parent, Katabasis::Token t, const char* tokenNam
    }
 }

-Katabasis::Token tokenFromJSONV3(const QJsonObject& parent, const char* tokenName)
+Token tokenFromJSONV3(const QJsonObject& parent, const char* tokenName)
 {
-    Katabasis::Token out;
+    Token out;
    auto tokenObject = parent.value(tokenName).toObject();
    if (tokenObject.isEmpty()) {
        return out;
@ -94,7 +94,7 @@ Katabasis::Token tokenFromJSONV3(const QJsonObject& parent, const char* tokenNam
    auto token = tokenObject.value("token");
    if (token.isString()) {
        out.token = token.toString();
-        out.validity = Katabasis::Validity::Assumed;
+        out.validity = Validity::Assumed;
    }

    auto refresh_token = tokenObject.value("refresh_token");
@ -241,13 +241,13 @@ MinecraftProfile profileFromJSONV3(const QJsonObject& parent, const char* tokenN
            }
        }
    }
-    out.validity = Katabasis::Validity::Assumed;
+    out.validity = Validity::Assumed;
    return out;
 }

 void entitlementToJSONV3(QJsonObject& parent, MinecraftEntitlement p)
 {
-    if (p.validity == Katabasis::Validity::None) {
+    if (p.validity == Validity::None) {
        return;
    }
    QJsonObject out;
@ -271,7 +271,7 @@ bool entitlementFromJSONV3(const QJsonObject& parent, MinecraftEntitlement& out)
        }
        out.canPlayMinecraft = canPlayMinecraftV.toBool(false);
        out.ownsMinecraft = ownsMinecraftV.toBool(false);
-        out.validity = Katabasis::Validity::Assumed;
+        out.validity = Validity::Assumed;
    }
    return true;
 }
@ -313,10 +313,10 @@ bool AccountData::resumeStateFromV3(QJsonObject data)

    minecraftProfile = profileFromJSONV3(data, "profile");
    if (!entitlementFromJSONV3(data, minecraftEntitlement)) {
-        if (minecraftProfile.validity != Katabasis::Validity::None) {
+        if (minecraftProfile.validity != Validity::None) {
            minecraftEntitlement.canPlayMinecraft = true;
            minecraftEntitlement.ownsMinecraft = true;
-            minecraftEntitlement.validity = Katabasis::Validity::Assumed;
+            minecraftEntitlement.validity = Validity::Assumed;
        }
    }

--- a/launcher/minecraft/auth/AccountData.h
+++ b/launcher/minecraft/auth/AccountData.h
@ -34,12 +34,29 @@
 */

 #pragma once
-#include <katabasis/Bits.h>
 #include <QByteArray>
 #include <QJsonObject>
 #include <QString>
 #include <QVector>

+#include <QDateTime>
+#include <QMap>
+#include <QString>
+#include <QVariantMap>
+
+enum class Validity { None, Assumed, Certain };
+
+struct Token {
+    QDateTime issueInstant;
+    QDateTime notAfter;
+    QString token;
+    QString refresh_token;
+    QVariantMap extra;
+
+    Validity validity = Validity::None;
+    bool persistent = true;
+};
+
 struct Skin {
    QString id;
    QString url;
@ -59,7 +76,7 @@ struct Cape {
 struct MinecraftEntitlement {
    bool ownsMinecraft = false;
    bool canPlayMinecraft = false;
-    Katabasis::Validity validity = Katabasis::Validity::None;
+    Validity validity = Validity::None;
 };

 struct MinecraftProfile {
@ -68,7 +85,7 @@ struct MinecraftProfile {
    Skin skin;
    QString currentCape;
    QMap<QString, Cape> capes;
-    Katabasis::Validity validity = Katabasis::Validity::None;
+    Validity validity = Validity::None;
 };

 enum class AccountType { MSA, Offline };
@ -93,15 +110,15 @@ struct AccountData {
    AccountType type = AccountType::MSA;

    QString msaClientID;
-    Katabasis::Token msaToken;
-    Katabasis::Token userToken;
-    Katabasis::Token xboxApiToken;
-    Katabasis::Token mojangservicesToken;
+    Token msaToken;
+    Token userToken;
+    Token xboxApiToken;
+    Token mojangservicesToken;

-    Katabasis::Token yggdrasilToken;
+    Token yggdrasilToken;
    MinecraftProfile minecraftProfile;
    MinecraftEntitlement minecraftEntitlement;
-    Katabasis::Validity validity_ = Katabasis::Validity::None;
+    Validity validity_ = Validity::None;

    // runtime only information (not saved with the account)
    QString internalId;
--- a/launcher/minecraft/auth/AccountList.cpp
+++ b/launcher/minecraft/auth/AccountList.cpp
@ -35,7 +35,7 @@

 #include "AccountList.h"
 #include "AccountData.h"
-#include "AccountTask.h"
+#include "tasks/Task.h"

 #include <QDir>
 #include <QFile>
@ -639,8 +639,8 @@ void AccountList::tryNext()
            if (account->internalId() == accountId) {
                m_currentTask = account->refresh();
                if (m_currentTask) {
-                    connect(m_currentTask.get(), &AccountTask::succeeded, this, &AccountList::authSucceeded);
-                    connect(m_currentTask.get(), &AccountTask::failed, this, &AccountList::authFailed);
+                    connect(m_currentTask.get(), &Task::succeeded, this, &AccountList::authSucceeded);
+                    connect(m_currentTask.get(), &Task::failed, this, &AccountList::authFailed);
                    m_currentTask->start();
                    qDebug() << "RefreshSchedule: Processing account " << account->accountDisplayString() << " with internal ID "
                             << accountId;
--- a/launcher/minecraft/auth/AccountList.h
+++ b/launcher/minecraft/auth/AccountList.h
@ -36,6 +36,7 @@
 #pragma once

 #include "MinecraftAccount.h"
+#include "minecraft/auth/AuthFlow.h"

 #include <QAbstractListModel>
 #include <QObject>
@ -144,7 +145,7 @@ class AccountList : public QAbstractListModel {
    QList<QString> m_refreshQueue;
    QTimer* m_refreshTimer;
    QTimer* m_nextTimer;
-    shared_qobject_ptr<AccountTask> m_currentTask;
+    shared_qobject_ptr<AuthFlow> m_currentTask;

    /*!
     * Called whenever the list changes.
--- a/launcher/minecraft/auth/AccountTask.cpp
+++ b/launcher/minecraft/auth/AccountTask.cpp
@ -1,134 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-/*
- *  Prism Launcher - Minecraft Launcher
- *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
- *
- *  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.
- */
-
-#include "AccountTask.h"
-#include "MinecraftAccount.h"
-
-#include <QByteArray>
-#include <QJsonDocument>
-#include <QJsonObject>
-#include <QNetworkReply>
-#include <QObject>
-#include <QString>
-
-#include <QDebug>
-
-AccountTask::AccountTask(AccountData* data, QObject* parent) : Task(parent), m_data(data)
-{
-    changeState(AccountTaskState::STATE_CREATED);
-}
-
-QString AccountTask::getStateMessage() const
-{
-    switch (m_taskState) {
-        case AccountTaskState::STATE_CREATED:
-            return "Waiting...";
-        case AccountTaskState::STATE_WORKING:
-            return tr("Sending request to auth servers...");
-        case AccountTaskState::STATE_SUCCEEDED:
-            return tr("Authentication task succeeded.");
-        case AccountTaskState::STATE_OFFLINE:
-            return tr("Failed to contact the authentication server.");
-        case AccountTaskState::STATE_DISABLED:
-            return tr("Client ID has changed. New session needs to be created.");
-        case AccountTaskState::STATE_FAILED_SOFT:
-            return tr("Encountered an error during authentication.");
-        case AccountTaskState::STATE_FAILED_HARD:
-            return tr("Failed to authenticate. The session has expired.");
-        case AccountTaskState::STATE_FAILED_GONE:
-            return tr("Failed to authenticate. The account no longer exists.");
-        default:
-            return tr("...");
-    }
-}
-
-bool AccountTask::changeState(AccountTaskState newState, QString reason)
-{
-    m_taskState = newState;
-    // FIXME: virtual method invoked in constructor.
-    // We want that behavior, but maybe make it less weird?
-    setStatus(getStateMessage());
-    switch (newState) {
-        case AccountTaskState::STATE_CREATED: {
-            m_data->errorString.clear();
-            return true;
-        }
-        case AccountTaskState::STATE_WORKING: {
-            m_data->accountState = AccountState::Working;
-            return true;
-        }
-        case AccountTaskState::STATE_SUCCEEDED: {
-            m_data->accountState = AccountState::Online;
-            emitSucceeded();
-            return false;
-        }
-        case AccountTaskState::STATE_OFFLINE: {
-            m_data->errorString = reason;
-            m_data->accountState = AccountState::Offline;
-            emitFailed(reason);
-            return false;
-        }
-        case AccountTaskState::STATE_DISABLED: {
-            m_data->errorString = reason;
-            m_data->accountState = AccountState::Disabled;
-            emitFailed(reason);
-            return false;
-        }
-        case AccountTaskState::STATE_FAILED_SOFT: {
-            m_data->errorString = reason;
-            m_data->accountState = AccountState::Errored;
-            emitFailed(reason);
-            return false;
-        }
-        case AccountTaskState::STATE_FAILED_HARD: {
-            m_data->errorString = reason;
-            m_data->accountState = AccountState::Expired;
-            emitFailed(reason);
-            return false;
-        }
-        case AccountTaskState::STATE_FAILED_GONE: {
-            m_data->errorString = reason;
-            m_data->accountState = AccountState::Gone;
-            emitFailed(reason);
-            return false;
-        }
-        default: {
-            QString error = tr("Unknown account task state: %1").arg(int(newState));
-            m_data->accountState = AccountState::Errored;
-            emitFailed(error);
-            return false;
-        }
-    }
-}
--- a/launcher/minecraft/auth/AccountTask.h
+++ b/launcher/minecraft/auth/AccountTask.h
@ -1,92 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-/*
- *  Prism Launcher - Minecraft Launcher
- *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
- *
- *  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
-
-#include <tasks/Task.h>
-
-#include <qsslerror.h>
-#include <QJsonObject>
-#include <QString>
-#include <QTimer>
-
-#include "MinecraftAccount.h"
-
-class QNetworkReply;
-
-/**
- * Enum for describing the state of the current task.
- * Used by the getStateMessage function to determine what the status message should be.
- */
-enum class AccountTaskState {
-    STATE_CREATED,
-    STATE_WORKING,
-    STATE_SUCCEEDED,
-    STATE_DISABLED,     //!< MSA Client ID has changed. Tell user to reloginn
-    STATE_FAILED_SOFT,  //!< soft failure. authentication went through partially
-    STATE_FAILED_HARD,  //!< hard failure. main tokens are invalid
-    STATE_FAILED_GONE,  //!< hard failure. main tokens are invalid, and the account no longer exists
-    STATE_OFFLINE       //!< soft failure. authentication failed in the first step in a 'soft' way
-};
-
-class AccountTask : public Task {
-    Q_OBJECT
-   public:
-    explicit AccountTask(AccountData* data, QObject* parent = 0);
-    virtual ~AccountTask(){};
-
-    AccountTaskState m_taskState = AccountTaskState::STATE_CREATED;
-
-    AccountTaskState taskState() { return m_taskState; }
-
-   signals:
-    void showVerificationUriAndCode(const QUrl& uri, const QString& code, int expiresIn);
-    void hideVerificationUriAndCode();
-
-   protected:
-    /**
-     * Returns the state message for the given state.
-     * Used to set the status message for the task.
-     * Should be overridden by subclasses that want to change messages for a given state.
-     */
-    virtual QString getStateMessage() const;
-
-   protected slots:
-    // NOTE: true -> non-terminal state, false -> terminal state
-    bool changeState(AccountTaskState newState, QString reason = QString());
-
-   protected:
-    AccountData* m_data = nullptr;
-};
--- a/launcher/minecraft/auth/AuthFlow.cpp
+++ b/launcher/minecraft/auth/AuthFlow.cpp
@ -0,0 +1,146 @@
+#include <QDebug>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+
+#include "minecraft/auth/AccountData.h"
+#include "minecraft/auth/steps/EntitlementsStep.h"
+#include "minecraft/auth/steps/GetSkinStep.h"
+#include "minecraft/auth/steps/LauncherLoginStep.h"
+#include "minecraft/auth/steps/MSADeviceCodeStep.h"
+#include "minecraft/auth/steps/MSAStep.h"
+#include "minecraft/auth/steps/MinecraftProfileStep.h"
+#include "minecraft/auth/steps/XboxAuthorizationStep.h"
+#include "minecraft/auth/steps/XboxProfileStep.h"
+#include "minecraft/auth/steps/XboxUserStep.h"
+#include "tasks/Task.h"
+
+#include "AuthFlow.h"
+
+#include <Application.h>
+
+AuthFlow::AuthFlow(AccountData* data, Action action, QObject* parent) : Task(parent), m_data(data)
+{
+    if (data->type == AccountType::MSA) {
+        if (action == Action::DeviceCode) {
+            auto oauthStep = makeShared<MSADeviceCodeStep>(m_data);
+            connect(oauthStep.get(), &MSADeviceCodeStep::authorizeWithBrowser, this, &AuthFlow::authorizeWithBrowserWithExtra);
+            connect(this, &Task::aborted, oauthStep.get(), &MSADeviceCodeStep::abort);
+            m_steps.append(oauthStep);
+        } else {
+            auto oauthStep = makeShared<MSAStep>(m_data, action == Action::Refresh);
+            connect(oauthStep.get(), &MSAStep::authorizeWithBrowser, this, &AuthFlow::authorizeWithBrowser);
+            m_steps.append(oauthStep);
+        }
+        m_steps.append(makeShared<XboxUserStep>(m_data));
+        m_steps.append(makeShared<XboxAuthorizationStep>(m_data, &m_data->xboxApiToken, "http://xboxlive.com", "Xbox"));
+        m_steps.append(
+            makeShared<XboxAuthorizationStep>(m_data, &m_data->mojangservicesToken, "rp://api.minecraftservices.com/", "Mojang"));
+        m_steps.append(makeShared<LauncherLoginStep>(m_data));
+        m_steps.append(makeShared<XboxProfileStep>(m_data));
+        m_steps.append(makeShared<EntitlementsStep>(m_data));
+        m_steps.append(makeShared<MinecraftProfileStep>(m_data));
+        m_steps.append(makeShared<GetSkinStep>(m_data));
+    }
+    changeState(AccountTaskState::STATE_CREATED);
+}
+
+void AuthFlow::succeed()
+{
+    m_data->validity_ = Validity::Certain;
+    changeState(AccountTaskState::STATE_SUCCEEDED, tr("Finished all authentication steps"));
+}
+
+void AuthFlow::executeTask()
+{
+    changeState(AccountTaskState::STATE_WORKING, tr("Initializing"));
+    nextStep();
+}
+
+void AuthFlow::nextStep()
+{
+    if (m_steps.size() == 0) {
+        // we got to the end without an incident... assume this is all.
+        m_currentStep.reset();
+        succeed();
+        return;
+    }
+    m_currentStep = m_steps.front();
+    qDebug() << "AuthFlow:" << m_currentStep->describe();
+    m_steps.pop_front();
+    connect(m_currentStep.get(), &AuthStep::finished, this, &AuthFlow::stepFinished);
+
+    m_currentStep->perform();
+}
+
+void AuthFlow::stepFinished(AccountTaskState resultingState, QString message)
+{
+    if (changeState(resultingState, message))
+        nextStep();
+}
+
+bool AuthFlow::changeState(AccountTaskState newState, QString reason)
+{
+    m_taskState = newState;
+    setDetails(reason);
+    switch (newState) {
+        case AccountTaskState::STATE_CREATED: {
+            setStatus(tr("Waiting..."));
+            m_data->errorString.clear();
+            return true;
+        }
+        case AccountTaskState::STATE_WORKING: {
+            setStatus(m_currentStep ? m_currentStep->describe() : tr("Working..."));
+            m_data->accountState = AccountState::Working;
+            return true;
+        }
+        case AccountTaskState::STATE_SUCCEEDED: {
+            setStatus(tr("Authentication task succeeded."));
+            m_data->accountState = AccountState::Online;
+            emitSucceeded();
+            return false;
+        }
+        case AccountTaskState::STATE_OFFLINE: {
+            setStatus(tr("Failed to contact the authentication server."));
+            m_data->errorString = reason;
+            m_data->accountState = AccountState::Offline;
+            emitFailed(reason);
+            return false;
+        }
+        case AccountTaskState::STATE_DISABLED: {
+            setStatus(tr("Client ID has changed. New session needs to be created."));
+            m_data->errorString = reason;
+            m_data->accountState = AccountState::Disabled;
+            emitFailed(reason);
+            return false;
+        }
+        case AccountTaskState::STATE_FAILED_SOFT: {
+            setStatus(tr("Encountered an error during authentication."));
+            m_data->errorString = reason;
+            m_data->accountState = AccountState::Errored;
+            emitFailed(reason);
+            return false;
+        }
+        case AccountTaskState::STATE_FAILED_HARD: {
+            setStatus(tr("Failed to authenticate. The session has expired."));
+            m_data->errorString = reason;
+            m_data->accountState = AccountState::Expired;
+            emitFailed(reason);
+            return false;
+        }
+        case AccountTaskState::STATE_FAILED_GONE: {
+            setStatus(tr("Failed to authenticate. The account no longer exists."));
+            m_data->errorString = reason;
+            m_data->accountState = AccountState::Gone;
+            emitFailed(reason);
+            return false;
+        }
+        default: {
+            setStatus(tr("..."));
+            QString error = tr("Unknown account task state: %1").arg(int(newState));
+            m_data->accountState = AccountState::Errored;
+            emitFailed(error);
+            return false;
+        }
+    }
+}
--- a/launcher/minecraft/auth/AuthFlow.h
+++ b/launcher/minecraft/auth/AuthFlow.h
@ -0,0 +1,45 @@
+#pragma once
+
+#include <QImage>
+#include <QList>
+#include <QNetworkReply>
+#include <QObject>
+#include <QSet>
+#include <QVector>
+
+#include "minecraft/auth/AccountData.h"
+#include "minecraft/auth/AuthStep.h"
+#include "tasks/Task.h"
+
+class AuthFlow : public Task {
+    Q_OBJECT
+
+   public:
+    enum class Action { Refresh, Login, DeviceCode };
+
+    explicit AuthFlow(AccountData* data, Action action = Action::Refresh, QObject* parent = 0);
+    virtual ~AuthFlow() = default;
+
+    void executeTask() override;
+
+    AccountTaskState taskState() { return m_taskState; }
+
+   signals:
+    void authorizeWithBrowser(const QUrl& url);
+    void authorizeWithBrowserWithExtra(QString url, QString code, int expiresIn);
+
+   protected:
+    void succeed();
+    void nextStep();
+
+   private slots:
+    // NOTE: true -> non-terminal state, false -> terminal state
+    bool changeState(AccountTaskState newState, QString reason = QString());
+    void stepFinished(AccountTaskState resultingState, QString message);
+
+   private:
+    AccountTaskState m_taskState = AccountTaskState::STATE_CREATED;
+    QList<AuthStep::Ptr> m_steps;
+    AuthStep::Ptr m_currentStep;
+    AccountData* m_data = nullptr;
+};
--- a/launcher/minecraft/auth/AuthRequest.cpp
+++ b/launcher/minecraft/auth/AuthRequest.cpp
@ -1,175 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-/*
- *  Prism Launcher - Minecraft Launcher
- *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
- *
- *  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.
- */
-
-#include <cassert>
-
-#include <QBuffer>
-#include <QDebug>
-#include <QTimer>
-#include <QUrlQuery>
-
-#include "Application.h"
-#include "AuthRequest.h"
-#include "katabasis/Globals.h"
-
-AuthRequest::AuthRequest(QObject* parent) : QObject(parent) {}
-
-AuthRequest::~AuthRequest() {}
-
-void AuthRequest::get(const QNetworkRequest& req, int timeout /* = 60*1000*/)
-{
-    setup(req, QNetworkAccessManager::GetOperation);
-    reply_ = APPLICATION->network()->get(request_);
-    status_ = Requesting;
-    timedReplies_.add(new Katabasis::Reply(reply_, timeout));
-#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)  // QNetworkReply::errorOccurred added in 5.15
-    connect(reply_, &QNetworkReply::errorOccurred, this, &AuthRequest::onRequestError);
-#else  // &QNetworkReply::error SIGNAL depricated
-    connect(reply_, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &AuthRequest::onRequestError);
-#endif
-    connect(reply_, &QNetworkReply::finished, this, &AuthRequest::onRequestFinished);
-    connect(reply_, &QNetworkReply::sslErrors, this, &AuthRequest::onSslErrors);
-}
-
-void AuthRequest::post(const QNetworkRequest& req, const QByteArray& data, int timeout /* = 60*1000*/)
-{
-    setup(req, QNetworkAccessManager::PostOperation);
-    data_ = data;
-    status_ = Requesting;
-    reply_ = APPLICATION->network()->post(request_, data_);
-    timedReplies_.add(new Katabasis::Reply(reply_, timeout));
-#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)  // QNetworkReply::errorOccurred added in 5.15
-    connect(reply_, &QNetworkReply::errorOccurred, this, &AuthRequest::onRequestError);
-#else  // &QNetworkReply::error SIGNAL depricated
-    connect(reply_, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &AuthRequest::onRequestError);
-#endif
-    connect(reply_, &QNetworkReply::finished, this, &AuthRequest::onRequestFinished);
-    connect(reply_, &QNetworkReply::sslErrors, this, &AuthRequest::onSslErrors);
-    connect(reply_, &QNetworkReply::uploadProgress, this, &AuthRequest::onUploadProgress);
-}
-
-void AuthRequest::onRequestFinished()
-{
-    if (status_ == Idle) {
-        return;
-    }
-    if (reply_ != qobject_cast<QNetworkReply*>(sender())) {
-        return;
-    }
-    httpStatus_ = reply_->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-    finish();
-}
-
-void AuthRequest::onRequestError(QNetworkReply::NetworkError error)
-{
-    qWarning() << "AuthRequest::onRequestError: Error" << (int)error;
-    if (status_ == Idle) {
-        return;
-    }
-    if (reply_ != qobject_cast<QNetworkReply*>(sender())) {
-        return;
-    }
-    errorString_ = reply_->errorString();
-    httpStatus_ = reply_->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-    error_ = error;
-    qWarning() << "AuthRequest::onRequestError: Error string: " << errorString_;
-    qWarning() << "AuthRequest::onRequestError: HTTP status" << httpStatus_
-               << reply_->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString();
-
-    // QTimer::singleShot(10, this, SLOT(finish()));
-}
-
-void AuthRequest::onSslErrors(QList<QSslError> errors)
-{
-    int i = 1;
-    for (auto error : errors) {
-        qCritical() << "LOGIN SSL Error #" << i << " : " << error.errorString();
-        auto cert = error.certificate();
-        qCritical() << "Certificate in question:\n" << cert.toText();
-        i++;
-    }
-}
-
-void AuthRequest::onUploadProgress(qint64 uploaded, qint64 total)
-{
-    if (status_ == Idle) {
-        qWarning() << "AuthRequest::onUploadProgress: No pending request";
-        return;
-    }
-    if (reply_ != qobject_cast<QNetworkReply*>(sender())) {
-        return;
-    }
-    // Restart timeout because request in progress
-    Katabasis::Reply* o2Reply = timedReplies_.find(reply_);
-    if (o2Reply) {
-        o2Reply->start();
-    }
-    emit uploadProgress(uploaded, total);
-}
-
-void AuthRequest::setup(const QNetworkRequest& req, QNetworkAccessManager::Operation operation, const QByteArray& verb)
-{
-    request_ = req;
-    operation_ = operation;
-    url_ = req.url();
-
-    QUrl url = url_;
-    request_.setUrl(url);
-
-    if (!verb.isEmpty()) {
-        request_.setRawHeader(Katabasis::HTTP_HTTP_HEADER, verb);
-    }
-
-    status_ = Requesting;
-    error_ = QNetworkReply::NoError;
-    errorString_.clear();
-    httpStatus_ = 0;
-}
-
-void AuthRequest::finish()
-{
-    QByteArray data;
-    if (status_ == Idle) {
-        qWarning() << "AuthRequest::finish: No pending request";
-        return;
-    }
-    data = reply_->readAll();
-    status_ = Idle;
-    timedReplies_.remove(reply_);
-    reply_->disconnect(this);
-    reply_->deleteLater();
-    QList<QNetworkReply::RawHeaderPair> headers = reply_->rawHeaderPairs();
-    emit finished(error_, data, headers);
-}
--- a/launcher/minecraft/auth/AuthRequest.h
+++ b/launcher/minecraft/auth/AuthRequest.h
@ -1,67 +0,0 @@
-#pragma once
-#include <QByteArray>
-#include <QNetworkAccessManager>
-#include <QNetworkReply>
-#include <QNetworkRequest>
-#include <QObject>
-#include <QUrl>
-
-#include "katabasis/Reply.h"
-
-/// Makes authentication requests.
-class AuthRequest : public QObject {
-    Q_OBJECT
-
-   public:
-    explicit AuthRequest(QObject* parent = 0);
-    ~AuthRequest();
-
-   public slots:
-    void get(const QNetworkRequest& req, int timeout = 60 * 1000);
-    void post(const QNetworkRequest& req, const QByteArray& data, int timeout = 60 * 1000);
-
-   signals:
-
-    /// Emitted when a request has been completed or failed.
-    void finished(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers);
-
-    /// Emitted when an upload has progressed.
-    void uploadProgress(qint64 bytesSent, qint64 bytesTotal);
-
-   protected slots:
-
-    /// Handle request finished.
-    void onRequestFinished();
-
-    /// Handle request error.
-    void onRequestError(QNetworkReply::NetworkError error);
-
-    /// Handle ssl errors.
-    void onSslErrors(QList<QSslError> errors);
-
-    /// Finish the request, emit finished() signal.
-    void finish();
-
-    /// Handle upload progress.
-    void onUploadProgress(qint64 uploaded, qint64 total);
-
-   public:
-    QNetworkReply::NetworkError error_;
-    int httpStatus_ = 0;
-    QString errorString_;
-
-   protected:
-    void setup(const QNetworkRequest& request, QNetworkAccessManager::Operation operation, const QByteArray& verb = QByteArray());
-
-    enum Status { Idle, Requesting, ReRequesting };
-
-    QNetworkRequest request_;
-    QByteArray data_;
-    QNetworkReply* reply_;
-    Status status_;
-    QNetworkAccessManager::Operation operation_;
-    QUrl url_;
-    Katabasis::ReplyList timedReplies_;
-
-    QTimer* timer_;
-};
--- a/launcher/minecraft/auth/AuthStep.cpp
+++ b/launcher/minecraft/auth/AuthStep.cpp
@ -1,5 +0,0 @@
-#include "AuthStep.h"
-
-AuthStep::AuthStep(AccountData* data) : QObject(nullptr), m_data(data) {}
-
-AuthStep::~AuthStep() noexcept = default;
--- a/launcher/minecraft/auth/AuthStep.h
+++ b/launcher/minecraft/auth/AuthStep.h
@ -3,30 +3,40 @@
 #include <QNetworkReply>
 #include <QObject>

-#include "AccountTask.h"
 #include "QObjectPtr.h"
 #include "minecraft/auth/AccountData.h"

+/**
+ * Enum for describing the state of the current task.
+ * Used by the getStateMessage function to determine what the status message should be.
+ */
+enum class AccountTaskState {
+    STATE_CREATED,
+    STATE_WORKING,
+    STATE_SUCCEEDED,
+    STATE_DISABLED,     //!< MSA Client ID has changed. Tell user to reloginn
+    STATE_FAILED_SOFT,  //!< soft failure. authentication went through partially
+    STATE_FAILED_HARD,  //!< hard failure. main tokens are invalid
+    STATE_FAILED_GONE,  //!< hard failure. main tokens are invalid, and the account no longer exists
+    STATE_OFFLINE       //!< soft failure. authentication failed in the first step in a 'soft' way
+};
+
 class AuthStep : public QObject {
    Q_OBJECT

   public:
    using Ptr = shared_qobject_ptr<AuthStep>;

-   public:
-    explicit AuthStep(AccountData* data);
-    virtual ~AuthStep() noexcept;
+    explicit AuthStep(AccountData* data) : QObject(nullptr), m_data(data){};
+    virtual ~AuthStep() noexcept = default;

    virtual QString describe() = 0;

   public slots:
    virtual void perform() = 0;
-    virtual void rehydrate() = 0;

   signals:
    void finished(AccountTaskState resultingState, QString message);
-    void showVerificationUriAndCode(const QUrl& uri, const QString& code, int expiresIn);
-    void hideVerificationUriAndCode();

   protected:
    AccountData* m_data;
--- a/launcher/minecraft/auth/MinecraftAccount.cpp
+++ b/launcher/minecraft/auth/MinecraftAccount.cpp
@ -50,9 +50,8 @@

 #include <QPainter>

-#include "flows/MSA.h"
-#include "flows/Offline.h"
 #include "minecraft/auth/AccountData.h"
+#include "minecraft/auth/AuthFlow.h"

 MinecraftAccount::MinecraftAccount(QObject* parent) : QObject(parent)
 {
@ -80,7 +79,7 @@ MinecraftAccountPtr MinecraftAccount::createOffline(const QString& username)
    auto account = makeShared<MinecraftAccount>();
    account->data.type = AccountType::Offline;
    account->data.yggdrasilToken.token = "0";
-    account->data.yggdrasilToken.validity = Katabasis::Validity::Certain;
+    account->data.yggdrasilToken.validity = Validity::Certain;
    account->data.yggdrasilToken.issueInstant = QDateTime::currentDateTimeUtc();
    account->data.yggdrasilToken.extra["userName"] = username;
    account->data.yggdrasilToken.extra["clientToken"] = QUuid::createUuid().toString().remove(QRegularExpression("[{}-]"));
@ -88,7 +87,7 @@ MinecraftAccountPtr MinecraftAccount::createOffline(const QString& username)
    account->data.minecraftEntitlement.canPlayMinecraft = true;
    account->data.minecraftProfile.id = uuidFromUsername(username).toString().remove(QRegularExpression("[{}-]"));
    account->data.minecraftProfile.name = username;
-    account->data.minecraftProfile.validity = Katabasis::Validity::Certain;
+    account->data.minecraftProfile.validity = Validity::Certain;
    return account;
 }

@ -120,11 +119,11 @@ QPixmap MinecraftAccount::getFace() const
    return skin.scaled(64, 64, Qt::KeepAspectRatio);
 }

-shared_qobject_ptr<AccountTask> MinecraftAccount::loginMSA()
+shared_qobject_ptr<AuthFlow> MinecraftAccount::login(bool useDeviceCode)
 {
    Q_ASSERT(m_currentTask.get() == nullptr);

-    m_currentTask.reset(new MSAInteractive(&data));
+    m_currentTask.reset(new AuthFlow(&data, useDeviceCode ? AuthFlow::Action::DeviceCode : AuthFlow::Action::Login, this));
    connect(m_currentTask.get(), &Task::succeeded, this, &MinecraftAccount::authSucceeded);
    connect(m_currentTask.get(), &Task::failed, this, &MinecraftAccount::authFailed);
    connect(m_currentTask.get(), &Task::aborted, this, [this] { authFailed(tr("Aborted")); });
@ -132,29 +131,13 @@ shared_qobject_ptr<AccountTask> MinecraftAccount::loginMSA()
    return m_currentTask;
 }

-shared_qobject_ptr<AccountTask> MinecraftAccount::loginOffline()
-{
-    Q_ASSERT(m_currentTask.get() == nullptr);
-
-    m_currentTask.reset(new OfflineLogin(&data));
-    connect(m_currentTask.get(), &Task::succeeded, this, &MinecraftAccount::authSucceeded);
-    connect(m_currentTask.get(), &Task::failed, this, &MinecraftAccount::authFailed);
-    connect(m_currentTask.get(), &Task::aborted, this, [this] { authFailed(tr("Aborted")); });
-    emit activityChanged(true);
-    return m_currentTask;
-}
-
-shared_qobject_ptr<AccountTask> MinecraftAccount::refresh()
+shared_qobject_ptr<AuthFlow> MinecraftAccount::refresh()
 {
    if (m_currentTask) {
        return m_currentTask;
    }

-    if (data.type == AccountType::MSA) {
-        m_currentTask.reset(new MSASilent(&data));
-    } else {
-        m_currentTask.reset(new OfflineRefresh(&data));
-    }
+    m_currentTask.reset(new AuthFlow(&data, AuthFlow::Action::Refresh, this));

    connect(m_currentTask.get(), &Task::succeeded, this, &MinecraftAccount::authSucceeded);
    connect(m_currentTask.get(), &Task::failed, this, &MinecraftAccount::authFailed);
@ -163,7 +146,7 @@ shared_qobject_ptr<AccountTask> MinecraftAccount::refresh()
    return m_currentTask;
 }

-shared_qobject_ptr<AccountTask> MinecraftAccount::currentTask()
+shared_qobject_ptr<AuthFlow> MinecraftAccount::currentTask()
 {
    return m_currentTask;
 }
@ -189,17 +172,17 @@ void MinecraftAccount::authFailed(QString reason)
            if (accountType() == AccountType::MSA) {
                data.msaToken.token = QString();
                data.msaToken.refresh_token = QString();
-                data.msaToken.validity = Katabasis::Validity::None;
-                data.validity_ = Katabasis::Validity::None;
+                data.msaToken.validity = Validity::None;
+                data.validity_ = Validity::None;
            } else {
                data.yggdrasilToken.token = QString();
-                data.yggdrasilToken.validity = Katabasis::Validity::None;
-                data.validity_ = Katabasis::Validity::None;
+                data.yggdrasilToken.validity = Validity::None;
+                data.validity_ = Validity::None;
            }
            emit changed();
        } break;
        case AccountTaskState::STATE_FAILED_GONE: {
-            data.validity_ = Katabasis::Validity::None;
+            data.validity_ = Validity::None;
            emit changed();
        } break;
        case AccountTaskState::STATE_CREATED:
@ -229,13 +212,13 @@ bool MinecraftAccount::shouldRefresh() const
        return false;
    }
    switch (data.validity_) {
-        case Katabasis::Validity::Certain: {
+        case Validity::Certain: {
            break;
        }
-        case Katabasis::Validity::None: {
+        case Validity::None: {
            return false;
        }
-        case Katabasis::Validity::Assumed: {
+        case Validity::Assumed: {
            return true;
        }
    }
--- a/launcher/minecraft/auth/MinecraftAccount.h
+++ b/launcher/minecraft/auth/MinecraftAccount.h
@ -43,15 +43,13 @@
 #include <QPixmap>
 #include <QString>

-#include <memory>
-
 #include "AccountData.h"
 #include "AuthSession.h"
 #include "QObjectPtr.h"
 #include "Usable.h"
+#include "minecraft/auth/AuthFlow.h"

 class Task;
-class AccountTask;
 class MinecraftAccount;

 using MinecraftAccountPtr = shared_qobject_ptr<MinecraftAccount>;
@ -97,13 +95,11 @@ class MinecraftAccount : public QObject, public Usable {
    QJsonObject saveToJson() const;

   public: /* manipulation */
-    shared_qobject_ptr<AccountTask> loginMSA();
+    shared_qobject_ptr<AuthFlow> login(bool useDeviceCode = false);

-    shared_qobject_ptr<AccountTask> loginOffline();
+    shared_qobject_ptr<AuthFlow> refresh();

-    shared_qobject_ptr<AccountTask> refresh();
-
-    shared_qobject_ptr<AccountTask> currentTask();
+    shared_qobject_ptr<AuthFlow> currentTask();

   public: /* queries */
    QString internalId() const { return data.internalId; }
@ -166,7 +162,7 @@ class MinecraftAccount : public QObject, public Usable {
    AccountData data;

    // current task we are executing here
-    shared_qobject_ptr<AccountTask> m_currentTask;
+    shared_qobject_ptr<AuthFlow> m_currentTask;

   protected: /* methods */
    void incrementUses() override;
--- a/launcher/minecraft/auth/Parsers.cpp
+++ b/launcher/minecraft/auth/Parsers.cpp
@ -79,7 +79,7 @@ bool getBool(QJsonValue value, bool& out)
 // 2148916238 = child account not linked to a family
 */

-bool parseXTokenResponse(QByteArray& data, Katabasis::Token& output, QString name)
+bool parseXTokenResponse(QByteArray& data, Token& output, QString name)
 {
    qDebug() << "Parsing" << name << ":";
    qCDebug(authCredentials()) << data;
@ -135,7 +135,7 @@ bool parseXTokenResponse(QByteArray& data, Katabasis::Token& output, QString nam
        qWarning() << "Missing uhs";
        return false;
    }
-    output.validity = Katabasis::Validity::Certain;
+    output.validity = Validity::Certain;
    qDebug() << name << "is valid.";
    return true;
 }
@ -213,7 +213,7 @@ bool parseMinecraftProfile(QByteArray& data, MinecraftProfile& output)
        output.capes[capeOut.id] = capeOut;
    }
    output.currentCape = currentCape;
-    output.validity = Katabasis::Validity::Certain;
+    output.validity = Validity::Certain;
    return true;
 }

@ -388,7 +388,7 @@ bool parseMinecraftProfileMojang(QByteArray& data, MinecraftProfile& output)
        output.currentCape = capeOut.alias;
    }

-    output.validity = Katabasis::Validity::Certain;
+    output.validity = Validity::Certain;
    return true;
 }

@ -422,7 +422,7 @@ bool parseMinecraftEntitlements(QByteArray& data, MinecraftEntitlement& output)
            output.ownsMinecraft = true;
        }
    }
-    output.validity = Katabasis::Validity::Certain;
+    output.validity = Validity::Certain;
    return true;
 }

@ -456,7 +456,7 @@ bool parseRolloutResponse(QByteArray& data, bool& result)
    return true;
 }

-bool parseMojangResponse(QByteArray& data, Katabasis::Token& output)
+bool parseMojangResponse(QByteArray& data, Token& output)
 {
    QJsonParseError jsonError;
    qDebug() << "Parsing Mojang response...";
@ -488,7 +488,7 @@ bool parseMojangResponse(QByteArray& data, Katabasis::Token& output)
        qWarning() << "access_token is not valid";
        return false;
    }
-    output.validity = Katabasis::Validity::Certain;
+    output.validity = Validity::Certain;
    qDebug() << "Mojang response is valid.";
    return true;
 }
--- a/launcher/minecraft/auth/Parsers.h
+++ b/launcher/minecraft/auth/Parsers.h
@ -9,8 +9,8 @@ bool getNumber(QJsonValue value, double& out);
 bool getNumber(QJsonValue value, int64_t& out);
 bool getBool(QJsonValue value, bool& out);

-bool parseXTokenResponse(QByteArray& data, Katabasis::Token& output, QString name);
-bool parseMojangResponse(QByteArray& data, Katabasis::Token& output);
+bool parseXTokenResponse(QByteArray& data, Token& output, QString name);
+bool parseMojangResponse(QByteArray& data, Token& output);

 bool parseMinecraftProfile(QByteArray& data, MinecraftProfile& output);
 bool parseMinecraftProfileMojang(QByteArray& data, MinecraftProfile& output);
--- a/launcher/minecraft/auth/flows/AuthFlow.cpp
+++ b/launcher/minecraft/auth/flows/AuthFlow.cpp
@ -1,67 +0,0 @@
-#include <QDebug>
-#include <QNetworkAccessManager>
-#include <QNetworkReply>
-#include <QNetworkRequest>
-
-#include "AuthFlow.h"
-#include "katabasis/Globals.h"
-
-#include <Application.h>
-
-AuthFlow::AuthFlow(AccountData* data, QObject* parent) : AccountTask(data, parent) {}
-
-void AuthFlow::succeed()
-{
-    m_data->validity_ = Katabasis::Validity::Certain;
-    changeState(AccountTaskState::STATE_SUCCEEDED, tr("Finished all authentication steps"));
-}
-
-void AuthFlow::executeTask()
-{
-    if (m_currentStep) {
-        return;
-    }
-    changeState(AccountTaskState::STATE_WORKING, tr("Initializing"));
-    nextStep();
-}
-
-void AuthFlow::nextStep()
-{
-    if (m_steps.size() == 0) {
-        // we got to the end without an incident... assume this is all.
-        m_currentStep.reset();
-        succeed();
-        return;
-    }
-    m_currentStep = m_steps.front();
-    qDebug() << "AuthFlow:" << m_currentStep->describe();
-    m_steps.pop_front();
-    connect(m_currentStep.get(), &AuthStep::finished, this, &AuthFlow::stepFinished);
-    connect(m_currentStep.get(), &AuthStep::showVerificationUriAndCode, this, &AuthFlow::showVerificationUriAndCode);
-    connect(m_currentStep.get(), &AuthStep::hideVerificationUriAndCode, this, &AuthFlow::hideVerificationUriAndCode);
-
-    m_currentStep->perform();
-}
-
-QString AuthFlow::getStateMessage() const
-{
-    switch (m_taskState) {
-        case AccountTaskState::STATE_WORKING: {
-            if (m_currentStep) {
-                return m_currentStep->describe();
-            } else {
-                return tr("Working...");
-            }
-        }
-        default: {
-            return AccountTask::getStateMessage();
-        }
-    }
-}
-
-void AuthFlow::stepFinished(AccountTaskState resultingState, QString message)
-{
-    if (changeState(resultingState, message)) {
-        nextStep();
-    }
-}
--- a/launcher/minecraft/auth/flows/AuthFlow.h
+++ b/launcher/minecraft/auth/flows/AuthFlow.h
@ -1,41 +0,0 @@
-#pragma once
-
-#include <QImage>
-#include <QList>
-#include <QNetworkReply>
-#include <QObject>
-#include <QSet>
-#include <QVector>
-
-#include <katabasis/DeviceFlow.h>
-
-#include "minecraft/auth/AccountData.h"
-#include "minecraft/auth/AccountTask.h"
-#include "minecraft/auth/AuthStep.h"
-
-class AuthFlow : public AccountTask {
-    Q_OBJECT
-
-   public:
-    explicit AuthFlow(AccountData* data, QObject* parent = 0);
-
-    Katabasis::Validity validity() { return m_data->validity_; };
-
-    QString getStateMessage() const override;
-
-    void executeTask() override;
-
-   signals:
-    void activityChanged(Katabasis::Activity activity);
-
-   private slots:
-    void stepFinished(AccountTaskState resultingState, QString message);
-
-   protected:
-    void succeed();
-    void nextStep();
-
-   protected:
-    QList<AuthStep::Ptr> m_steps;
-    AuthStep::Ptr m_currentStep;
-};
--- a/launcher/minecraft/auth/flows/MSA.cpp
+++ b/launcher/minecraft/auth/flows/MSA.cpp
@ -1,36 +0,0 @@
-#include "MSA.h"
-
-#include "minecraft/auth/steps/EntitlementsStep.h"
-#include "minecraft/auth/steps/GetSkinStep.h"
-#include "minecraft/auth/steps/LauncherLoginStep.h"
-#include "minecraft/auth/steps/MSAStep.h"
-#include "minecraft/auth/steps/MinecraftProfileStep.h"
-#include "minecraft/auth/steps/XboxAuthorizationStep.h"
-#include "minecraft/auth/steps/XboxProfileStep.h"
-#include "minecraft/auth/steps/XboxUserStep.h"
-
-MSASilent::MSASilent(AccountData* data, QObject* parent) : AuthFlow(data, parent)
-{
-    m_steps.append(makeShared<MSAStep>(m_data, MSAStep::Action::Refresh));
-    m_steps.append(makeShared<XboxUserStep>(m_data));
-    m_steps.append(makeShared<XboxAuthorizationStep>(m_data, &m_data->xboxApiToken, "http://xboxlive.com", "Xbox"));
-    m_steps.append(makeShared<XboxAuthorizationStep>(m_data, &m_data->mojangservicesToken, "rp://api.minecraftservices.com/", "Mojang"));
-    m_steps.append(makeShared<LauncherLoginStep>(m_data));
-    m_steps.append(makeShared<XboxProfileStep>(m_data));
-    m_steps.append(makeShared<EntitlementsStep>(m_data));
-    m_steps.append(makeShared<MinecraftProfileStep>(m_data));
-    m_steps.append(makeShared<GetSkinStep>(m_data));
-}
-
-MSAInteractive::MSAInteractive(AccountData* data, QObject* parent) : AuthFlow(data, parent)
-{
-    m_steps.append(makeShared<MSAStep>(m_data, MSAStep::Action::Login));
-    m_steps.append(makeShared<XboxUserStep>(m_data));
-    m_steps.append(makeShared<XboxAuthorizationStep>(m_data, &m_data->xboxApiToken, "http://xboxlive.com", "Xbox"));
-    m_steps.append(makeShared<XboxAuthorizationStep>(m_data, &m_data->mojangservicesToken, "rp://api.minecraftservices.com/", "Mojang"));
-    m_steps.append(makeShared<LauncherLoginStep>(m_data));
-    m_steps.append(makeShared<XboxProfileStep>(m_data));
-    m_steps.append(makeShared<EntitlementsStep>(m_data));
-    m_steps.append(makeShared<MinecraftProfileStep>(m_data));
-    m_steps.append(makeShared<GetSkinStep>(m_data));
-}
--- a/launcher/minecraft/auth/flows/MSA.h
+++ b/launcher/minecraft/auth/flows/MSA.h
@ -1,14 +0,0 @@
-#pragma once
-#include "AuthFlow.h"
-
-class MSAInteractive : public AuthFlow {
-    Q_OBJECT
-   public:
-    explicit MSAInteractive(AccountData* data, QObject* parent = 0);
-};
-
-class MSASilent : public AuthFlow {
-    Q_OBJECT
-   public:
-    explicit MSASilent(AccountData* data, QObject* parent = 0);
-};
--- a/launcher/minecraft/auth/flows/Offline.cpp
+++ b/launcher/minecraft/auth/flows/Offline.cpp
@ -1,13 +0,0 @@
-#include "Offline.h"
-
-#include "minecraft/auth/steps/OfflineStep.h"
-
-OfflineRefresh::OfflineRefresh(AccountData* data, QObject* parent) : AuthFlow(data, parent)
-{
-    m_steps.append(makeShared<OfflineStep>(m_data));
-}
-
-OfflineLogin::OfflineLogin(AccountData* data, QObject* parent) : AuthFlow(data, parent)
-{
-    m_steps.append(makeShared<OfflineStep>(m_data));
-}
--- a/launcher/minecraft/auth/flows/Offline.h
+++ b/launcher/minecraft/auth/flows/Offline.h
@ -1,14 +0,0 @@
-#pragma once
-#include "AuthFlow.h"
-
-class OfflineRefresh : public AuthFlow {
-    Q_OBJECT
-   public:
-    explicit OfflineRefresh(AccountData* data, QObject* parent = 0);
-};
-
-class OfflineLogin : public AuthFlow {
-    Q_OBJECT
-   public:
-    explicit OfflineLogin(AccountData* data, QObject* parent = 0);
-};
--- a/launcher/minecraft/auth/steps/EntitlementsStep.cpp
+++ b/launcher/minecraft/auth/steps/EntitlementsStep.cpp
@ -1,16 +1,20 @@
 #include "EntitlementsStep.h"

+#include <QList>
 #include <QNetworkRequest>
+#include <QUrl>
 #include <QUuid>
+#include <memory>

+#include "Application.h"
 #include "Logging.h"
-#include "minecraft/auth/AuthRequest.h"
 #include "minecraft/auth/Parsers.h"
+#include "net/Download.h"
+#include "net/StaticHeaderProxy.h"
+#include "tasks/Task.h"

 EntitlementsStep::EntitlementsStep(AccountData* data) : AuthStep(data) {}

-EntitlementsStep::~EntitlementsStep() noexcept = default;
-
 QString EntitlementsStep::describe()
 {
    return tr("Determining game ownership.");
@ -19,35 +23,31 @@ QString EntitlementsStep::describe()
 void EntitlementsStep::perform()
 {
    auto uuid = QUuid::createUuid();
-    m_entitlementsRequestId = uuid.toString().remove('{').remove('}');
-    auto url = "https://api.minecraftservices.com/entitlements/license?requestId=" + m_entitlementsRequestId;
-    QNetworkRequest request = QNetworkRequest(url);
-    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-    request.setRawHeader("Accept", "application/json");
-    request.setRawHeader("Authorization", QString("Bearer %1").arg(m_data->yggdrasilToken.token).toUtf8());
-    AuthRequest* requestor = new AuthRequest(this);
-    connect(requestor, &AuthRequest::finished, this, &EntitlementsStep::onRequestDone);
-    requestor->get(request);
+    m_entitlements_request_id = uuid.toString().remove('{').remove('}');
+
+    QUrl url("https://api.minecraftservices.com/entitlements/license?requestId=" + m_entitlements_request_id);
+    auto headers = QList<Net::HeaderPair>{ { "Content-Type", "application/json" },
+                                           { "Accept", "application/json" },
+                                           { "Authorization", QString("Bearer %1").arg(m_data->yggdrasilToken.token).toUtf8() } };
+
+    m_response.reset(new QByteArray());
+    m_task = Net::Download::makeByteArray(url, m_response);
+    m_task->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+
+    connect(m_task.get(), &Task::finished, this, &EntitlementsStep::onRequestDone);
+
+    m_task->setNetwork(APPLICATION->network());
+    m_task->start();
    qDebug() << "Getting entitlements...";
 }

-void EntitlementsStep::rehydrate()
+void EntitlementsStep::onRequestDone()
 {
-    // NOOP, for now. We only save bools and there's nothing to check.
-}
-
-void EntitlementsStep::onRequestDone([[maybe_unused]] QNetworkReply::NetworkError error,
-                                     QByteArray data,
-                                     [[maybe_unused]] QList<QNetworkReply::RawHeaderPair> headers)
-{
-    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
-    requestor->deleteLater();
-
-    qCDebug(authCredentials()) << data;
+    qCDebug(authCredentials()) << *m_response;

    // TODO: check presence of same entitlementsRequestId?
    // TODO: validate JWTs?
-    Parsers::parseMinecraftEntitlements(data, m_data->minecraftEntitlement);
+    Parsers::parseMinecraftEntitlements(*m_response, m_data->minecraftEntitlement);

    emit finished(AccountTaskState::STATE_WORKING, tr("Got entitlements"));
 }
--- a/launcher/minecraft/auth/steps/EntitlementsStep.h
+++ b/launcher/minecraft/auth/steps/EntitlementsStep.h
@ -1,24 +1,26 @@
 #pragma once
 #include <QObject>
+#include <memory>

-#include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
+#include "net/Download.h"

 class EntitlementsStep : public AuthStep {
    Q_OBJECT

   public:
    explicit EntitlementsStep(AccountData* data);
-    virtual ~EntitlementsStep() noexcept;
+    virtual ~EntitlementsStep() noexcept = default;

    void perform() override;
-    void rehydrate() override;

    QString describe() override;

   private slots:
-    void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
+    void onRequestDone();

   private:
-    QString m_entitlementsRequestId;
+    QString m_entitlements_request_id;
+    std::shared_ptr<QByteArray> m_response;
+    Net::Download::Ptr m_task;
 };
--- a/launcher/minecraft/auth/steps/GetSkinStep.cpp
+++ b/launcher/minecraft/auth/steps/GetSkinStep.cpp
@ -3,13 +3,10 @@

 #include <QNetworkRequest>

-#include "minecraft/auth/AuthRequest.h"
-#include "minecraft/auth/Parsers.h"
+#include "Application.h"

 GetSkinStep::GetSkinStep(AccountData* data) : AuthStep(data) {}

-GetSkinStep::~GetSkinStep() noexcept = default;
-
 QString GetSkinStep::describe()
 {
    return tr("Getting skin.");
@ -17,25 +14,20 @@ QString GetSkinStep::describe()

 void GetSkinStep::perform()
 {
-    auto url = QUrl(m_data->minecraftProfile.skin.url);
-    QNetworkRequest request = QNetworkRequest(url);
-    AuthRequest* requestor = new AuthRequest(this);
-    connect(requestor, &AuthRequest::finished, this, &GetSkinStep::onRequestDone);
-    requestor->get(request);
+    QUrl url(m_data->minecraftProfile.skin.url);
+
+    m_response.reset(new QByteArray());
+    m_task = Net::Download::makeByteArray(url, m_response);
+
+    connect(m_task.get(), &Task::finished, this, &GetSkinStep::onRequestDone);
+
+    m_task->setNetwork(APPLICATION->network());
+    m_task->start();
 }

-void GetSkinStep::rehydrate()
+void GetSkinStep::onRequestDone()
 {
-    // NOOP, for now.
-}
-
-void GetSkinStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
-{
-    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
-    requestor->deleteLater();
-
-    if (error == QNetworkReply::NoError) {
-        m_data->minecraftProfile.skin.data = data;
-    }
+    if (m_task->error() == QNetworkReply::NoError)
+        m_data->minecraftProfile.skin.data = *m_response;
    emit finished(AccountTaskState::STATE_SUCCEEDED, tr("Got skin"));
 }
--- a/launcher/minecraft/auth/steps/GetSkinStep.h
+++ b/launcher/minecraft/auth/steps/GetSkinStep.h
@ -1,21 +1,25 @@
 #pragma once
 #include <QObject>
+#include <memory>

-#include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
+#include "net/Download.h"

 class GetSkinStep : public AuthStep {
    Q_OBJECT

   public:
    explicit GetSkinStep(AccountData* data);
-    virtual ~GetSkinStep() noexcept;
+    virtual ~GetSkinStep() noexcept = default;

    void perform() override;
-    void rehydrate() override;

    QString describe() override;

   private slots:
-    void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
+    void onRequestDone();
+
+   private:
+    std::shared_ptr<QByteArray> m_response;
+    Net::Download::Ptr m_task;
 };
--- a/launcher/minecraft/auth/steps/LauncherLoginStep.cpp
+++ b/launcher/minecraft/auth/steps/LauncherLoginStep.cpp
@ -1,17 +1,17 @@
 #include "LauncherLoginStep.h"

 #include <QNetworkRequest>
+#include <QUrl>

+#include "Application.h"
 #include "Logging.h"
-#include "minecraft/auth/AccountTask.h"
-#include "minecraft/auth/AuthRequest.h"
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
+#include "net/StaticHeaderProxy.h"
+#include "net/Upload.h"

 LauncherLoginStep::LauncherLoginStep(AccountData* data) : AuthStep(data) {}

-LauncherLoginStep::~LauncherLoginStep() noexcept = default;
-
 QString LauncherLoginStep::describe()
 {
    return tr("Accessing Mojang services.");
@ -19,7 +19,7 @@ QString LauncherLoginStep::describe()

 void LauncherLoginStep::perform()
 {
-    auto requestURL = "https://api.minecraftservices.com/launcher/login";
+    QUrl url("https://api.minecraftservices.com/launcher/login");
    auto uhs = m_data->mojangservicesToken.extra["uhs"].toString();
    auto xToken = m_data->mojangservicesToken.token;

@ -31,40 +31,37 @@ void LauncherLoginStep::perform()
 )XXX";
    auto requestBody = mc_auth_template.arg(uhs, xToken);

-    QNetworkRequest request = QNetworkRequest(QUrl(requestURL));
-    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-    request.setRawHeader("Accept", "application/json");
-    AuthRequest* requestor = new AuthRequest(this);
-    connect(requestor, &AuthRequest::finished, this, &LauncherLoginStep::onRequestDone);
-    requestor->post(request, requestBody.toUtf8());
+    auto headers = QList<Net::HeaderPair>{
+        { "Content-Type", "application/json" },
+        { "Accept", "application/json" },
+    };
+
+    m_response.reset(new QByteArray());
+    m_task = Net::Upload::makeByteArray(url, m_response, requestBody.toUtf8());
+    m_task->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+
+    connect(m_task.get(), &Task::finished, this, &LauncherLoginStep::onRequestDone);
+
+    m_task->setNetwork(APPLICATION->network());
+    m_task->start();
    qDebug() << "Getting Minecraft access token...";
 }

-void LauncherLoginStep::rehydrate()
+void LauncherLoginStep::onRequestDone()
 {
-    // TODO: check the token validity
-}
-
-void LauncherLoginStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
-{
-    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
-    requestor->deleteLater();
-
-    qCDebug(authCredentials()) << data;
-    if (error != QNetworkReply::NoError) {
-        qWarning() << "Reply error:" << error;
-        qCDebug(authCredentials()) << data;
-        if (Net::isApplicationError(error)) {
-            emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Failed to get Minecraft access token: %1").arg(requestor->errorString_));
+    qCDebug(authCredentials()) << *m_response;
+    if (m_task->error() != QNetworkReply::NoError) {
+        qWarning() << "Reply error:" << m_task->error();
+        if (Net::isApplicationError(m_task->error())) {
+            emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Failed to get Minecraft access token: %1").arg(m_task->errorString()));
        } else {
-            emit finished(AccountTaskState::STATE_OFFLINE, tr("Failed to get Minecraft access token: %1").arg(requestor->errorString_));
+            emit finished(AccountTaskState::STATE_OFFLINE, tr("Failed to get Minecraft access token: %1").arg(m_task->errorString()));
        }
        return;
    }

-    if (!Parsers::parseMojangResponse(data, m_data->yggdrasilToken)) {
+    if (!Parsers::parseMojangResponse(*m_response, m_data->yggdrasilToken)) {
        qWarning() << "Could not parse login_with_xbox response...";
-        qCDebug(authCredentials()) << data;
        emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Failed to parse the Minecraft access token response."));
        return;
    }
--- a/launcher/minecraft/auth/steps/LauncherLoginStep.h
+++ b/launcher/minecraft/auth/steps/LauncherLoginStep.h
@ -1,21 +1,25 @@
 #pragma once
 #include <QObject>
+#include <memory>

-#include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
+#include "net/Upload.h"

 class LauncherLoginStep : public AuthStep {
    Q_OBJECT

   public:
    explicit LauncherLoginStep(AccountData* data);
-    virtual ~LauncherLoginStep() noexcept;
+    virtual ~LauncherLoginStep() noexcept = default;

    void perform() override;
-    void rehydrate() override;

    QString describe() override;

   private slots:
-    void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
+    void onRequestDone();
+
+   private:
+    std::shared_ptr<QByteArray> m_response;
+    Net::Upload::Ptr m_task;
 };
--- a/launcher/minecraft/auth/steps/MSADeviceCodeStep.cpp
+++ b/launcher/minecraft/auth/steps/MSADeviceCodeStep.cpp
@ -0,0 +1,270 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2024 Trial97 <alexandru.tripon97@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * 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.
+ */
+
+#include "MSADeviceCodeStep.h"
+
+#include <QDateTime>
+#include <QUrlQuery>
+
+#include "Application.h"
+#include "Json.h"
+#include "net/StaticHeaderProxy.h"
+
+// https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-device-code
+MSADeviceCodeStep::MSADeviceCodeStep(AccountData* data) : AuthStep(data)
+{
+    m_clientId = APPLICATION->getMSAClientID();
+}
+
+QString MSADeviceCodeStep::describe()
+{
+    return tr("Logging in with Microsoft account(device code).");
+}
+
+void MSADeviceCodeStep::perform()
+{
+    QUrlQuery data;
+    data.addQueryItem("client_id", m_clientId);
+    data.addQueryItem("scope", "XboxLive.SignIn XboxLive.offline_access");
+    auto payload = data.query(QUrl::FullyEncoded).toUtf8();
+    QUrl url("https://login.microsoftonline.com/consumers/oauth2/v2.0/devicecode");
+    auto headers = QList<Net::HeaderPair>{
+        { "Content-Type", "application/x-www-form-urlencoded" },
+        { "Accept", "application/json" },
+    };
+    m_response.reset(new QByteArray());
+    m_task = Net::Upload::makeByteArray(url, m_response, payload);
+    m_task->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+
+    connect(m_task.get(), &Task::finished, this, &MSADeviceCodeStep::deviceAutorizationFinished);
+
+    m_task->setNetwork(APPLICATION->network());
+    m_task->start();
+}
+
+struct DeviceAutorizationResponse {
+    QString device_code;
+    QString user_code;
+    QString verification_uri;
+    int expires_in;
+    int interval;
+
+    QString error;
+    QString error_description;
+};
+
+DeviceAutorizationResponse parseDeviceAutorizationResponse(const QByteArray& data)
+{
+    QJsonParseError err;
+    QJsonDocument doc = QJsonDocument::fromJson(data, &err);
+    if (err.error != QJsonParseError::NoError) {
+        qWarning() << "Failed to parse device autorization response due to err:" << err.errorString();
+        return {};
+    }
+
+    if (!doc.isObject()) {
+        qWarning() << "Device autorization response is not an object";
+        return {};
+    }
+    auto obj = doc.object();
+    return {
+        Json::ensureString(obj, "device_code"),       Json::ensureString(obj, "user_code"), Json::ensureString(obj, "verification_uri"),
+        Json::ensureInteger(obj, "expires_in"),       Json::ensureInteger(obj, "interval"), Json::ensureString(obj, "error"),
+        Json::ensureString(obj, "error_description"),
+    };
+}
+
+void MSADeviceCodeStep::deviceAutorizationFinished()
+{
+    auto rsp = parseDeviceAutorizationResponse(*m_response);
+    if (!rsp.error.isEmpty() || !rsp.error_description.isEmpty()) {
+        qWarning() << "Device authorization failed:" << rsp.error;
+        emit finished(AccountTaskState::STATE_FAILED_HARD,
+                      tr("Device authorization failed: %1").arg(rsp.error_description.isEmpty() ? rsp.error : rsp.error_description));
+        return;
+    }
+    if (!m_task->wasSuccessful() || m_task->error() != QNetworkReply::NoError) {
+        emit finished(AccountTaskState::STATE_FAILED_HARD, tr("Failed to retrieve device authorization"));
+        qDebug() << *m_response;
+        return;
+    }
+
+    if (rsp.device_code.isEmpty() || rsp.user_code.isEmpty() || rsp.verification_uri.isEmpty() || rsp.expires_in == 0) {
+        emit finished(AccountTaskState::STATE_FAILED_HARD, tr("Device authorization failed: required fields missing"));
+        return;
+    }
+    if (rsp.interval != 0) {
+        interval = rsp.interval;
+    }
+    m_device_code = rsp.device_code;
+    emit authorizeWithBrowser(rsp.verification_uri, rsp.user_code, rsp.expires_in);
+    m_expiration_timer.setTimerType(Qt::VeryCoarseTimer);
+    m_expiration_timer.setInterval(rsp.expires_in * 1000);
+    m_expiration_timer.setSingleShot(true);
+    connect(&m_expiration_timer, &QTimer::timeout, this, &MSADeviceCodeStep::abort);
+    m_expiration_timer.start();
+
+    m_pool_timer.setTimerType(Qt::VeryCoarseTimer);
+    m_pool_timer.setSingleShot(true);
+    startPoolTimer();
+}
+
+void MSADeviceCodeStep::abort()
+{
+    m_expiration_timer.stop();
+    m_pool_timer.stop();
+    if (m_task) {
+        m_task->abort();
+    }
+    m_is_aborted = true;
+    emit finished(AccountTaskState::STATE_FAILED_HARD, tr("Task aborted"));
+}
+
+void MSADeviceCodeStep::startPoolTimer()
+{
+    if (m_is_aborted) {
+        return;
+    }
+    m_pool_timer.setInterval(interval * 1000);
+    connect(&m_pool_timer, &QTimer::timeout, this, &MSADeviceCodeStep::authenticateUser);
+    m_pool_timer.start();
+}
+
+void MSADeviceCodeStep::authenticateUser()
+{
+    QUrlQuery data;
+    data.addQueryItem("client_id", m_clientId);
+    data.addQueryItem("grant_type", "urn:ietf:params:oauth:grant-type:device_code");
+    data.addQueryItem("device_code", m_device_code);
+    auto payload = data.query(QUrl::FullyEncoded).toUtf8();
+    QUrl url("https://login.microsoftonline.com/consumers/oauth2/v2.0/token");
+    auto headers = QList<Net::HeaderPair>{
+        { "Content-Type", "application/x-www-form-urlencoded" },
+        { "Accept", "application/json" },
+    };
+    m_response.reset(new QByteArray());
+    m_task = Net::Upload::makeByteArray(url, m_response, payload);
+    m_task->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+
+    connect(m_task.get(), &Task::finished, this, &MSADeviceCodeStep::authenticationFinished);
+
+    m_task->setNetwork(APPLICATION->network());
+    m_task->start();
+}
+
+struct AuthenticationResponse {
+    QString access_token;
+    QString token_type;
+    QString refresh_token;
+    int expires_in;
+
+    QString error;
+    QString error_description;
+
+    QVariantMap extra;
+};
+
+AuthenticationResponse parseAuthenticationResponse(const QByteArray& data)
+{
+    QJsonParseError err;
+    QJsonDocument doc = QJsonDocument::fromJson(data, &err);
+    if (err.error != QJsonParseError::NoError) {
+        qWarning() << "Failed to parse device autorization response due to err:" << err.errorString();
+        return {};
+    }
+
+    if (!doc.isObject()) {
+        qWarning() << "Device autorization response is not an object";
+        return {};
+    }
+    auto obj = doc.object();
+    return { Json::ensureString(obj, "access_token"),
+             Json::ensureString(obj, "token_type"),
+             Json::ensureString(obj, "refresh_token"),
+             Json::ensureInteger(obj, "expires_in"),
+             Json::ensureString(obj, "error"),
+             Json::ensureString(obj, "error_description"),
+             obj.toVariantMap() };
+}
+
+void MSADeviceCodeStep::authenticationFinished()
+{
+    if (m_task->error() == QNetworkReply::TimeoutError) {
+        // rfc8628#section-3.5
+        // "On encountering a connection timeout, clients MUST unilaterally
+        // reduce their polling frequency before retrying.  The use of an
+        // exponential backoff algorithm to achieve this, such as doubling the
+        // polling interval on each such connection timeout, is RECOMMENDED."
+        interval *= 2;
+        startPoolTimer();
+        return;
+    }
+    auto rsp = parseAuthenticationResponse(*m_response);
+    if (rsp.error == "slow_down") {
+        // rfc8628#section-3.5
+        // "A variant of 'authorization_pending', the authorization request is
+        // still pending and polling should continue, but the interval MUST
+        // be increased by 5 seconds for this and all subsequent requests."
+        interval += 5;
+        startPoolTimer();
+        return;
+    }
+    if (rsp.error == "authorization_pending") {
+        // keep trying - rfc8628#section-3.5
+        // "The authorization request is still pending as the end user hasn't
+        // yet completed the user-interaction steps (Section 3.3)."
+        startPoolTimer();
+        return;
+    }
+    if (!rsp.error.isEmpty() || !rsp.error_description.isEmpty()) {
+        qWarning() << "Device Access failed:" << rsp.error;
+        emit finished(AccountTaskState::STATE_FAILED_HARD,
+                      tr("Device Access failed: %1").arg(rsp.error_description.isEmpty() ? rsp.error : rsp.error_description));
+        return;
+    }
+    if (!m_task->wasSuccessful() || m_task->error() != QNetworkReply::NoError) {
+        startPoolTimer();  // it failed so just try again without increasing the interval
+        return;
+    }
+
+    m_expiration_timer.stop();
+    m_data->msaClientID = m_clientId;
+    m_data->msaToken.issueInstant = QDateTime::currentDateTimeUtc();
+    m_data->msaToken.notAfter = QDateTime::currentDateTime().addSecs(rsp.expires_in);
+    m_data->msaToken.extra = rsp.extra;
+    m_data->msaToken.refresh_token = rsp.refresh_token;
+    m_data->msaToken.token = rsp.access_token;
+    emit finished(AccountTaskState::STATE_WORKING, tr("Got"));
+}
--- a/launcher/minecraft/auth/steps/MSADeviceCodeStep.h
+++ b/launcher/minecraft/auth/steps/MSADeviceCodeStep.h
@ -0,0 +1,76 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2024 Trial97 <alexandru.tripon97@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * 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
+#include <QObject>
+#include <QTimer>
+
+#include "minecraft/auth/AuthStep.h"
+#include "net/Upload.h"
+
+class MSADeviceCodeStep : public AuthStep {
+    Q_OBJECT
+   public:
+    explicit MSADeviceCodeStep(AccountData* data);
+    virtual ~MSADeviceCodeStep() noexcept = default;
+
+    void perform() override;
+
+    QString describe() override;
+
+   public slots:
+    void abort();
+
+   signals:
+    void authorizeWithBrowser(QString url, QString code, int expiresIn);
+
+   private slots:
+    void deviceAutorizationFinished();
+    void startPoolTimer();
+    void authenticateUser();
+    void authenticationFinished();
+
+   private:
+    QString m_clientId;
+    QString m_device_code;
+    bool m_is_aborted = false;
+    int interval = 5;
+
+    QTimer m_pool_timer;
+    QTimer m_expiration_timer;
+
+    std::shared_ptr<QByteArray> m_response;
+    Net::Upload::Ptr m_task;
+};
--- a/launcher/minecraft/auth/steps/MSAStep.cpp
+++ b/launcher/minecraft/auth/steps/MSAStep.cpp
@ -35,123 +35,74 @@

 #include "MSAStep.h"

+#include <QtNetworkAuth/qoauthhttpserverreplyhandler.h>
+#include <QAbstractOAuth2>
 #include <QNetworkRequest>

-#include "BuildConfig.h"
-#include "minecraft/auth/AuthRequest.h"
-#include "minecraft/auth/Parsers.h"
-
 #include "Application.h"
-#include "Logging.h"

-using OAuth2 = Katabasis::DeviceFlow;
-using Activity = Katabasis::Activity;
-
-MSAStep::MSAStep(AccountData* data, Action action) : AuthStep(data), m_action(action)
+MSAStep::MSAStep(AccountData* data, bool silent) : AuthStep(data), m_silent(silent)
 {
    m_clientId = APPLICATION->getMSAClientID();
-    OAuth2::Options opts;
-    opts.scope = "XboxLive.signin offline_access";
-    opts.clientIdentifier = m_clientId;
-    opts.authorizationUrl = "https://login.microsoftonline.com/consumers/oauth2/v2.0/devicecode";
-    opts.accessTokenUrl = "https://login.microsoftonline.com/consumers/oauth2/v2.0/token";

-    // FIXME: OAuth2 is not aware of our fancy shared pointers
-    m_oauth2 = new OAuth2(opts, m_data->msaToken, this, APPLICATION->network().get());
+    auto replyHandler = new QOAuthHttpServerReplyHandler(1337, this);
+    replyHandler->setCallbackText(
+        " <iframe src=\"https://prismlauncher.org/successful-login\" title=\"PrismLauncher Microsoft login\" style=\"position:fixed; "
+        "top:0; left:0; bottom:0; right:0; width:100%; height:100%; border:none; margin:0; padding:0; overflow:hidden; "
+        "z-index:999999;\"/> ");
+    oauth2.setReplyHandler(replyHandler);
+    oauth2.setAuthorizationUrl(QUrl("https://login.microsoftonline.com/consumers/oauth2/v2.0/authorize"));
+    oauth2.setAccessTokenUrl(QUrl("https://login.microsoftonline.com/consumers/oauth2/v2.0/token"));
+    oauth2.setScope("XboxLive.SignIn XboxLive.offline_access");
+    oauth2.setClientIdentifier(m_clientId);
+    oauth2.setNetworkAccessManager(APPLICATION->network().get());

-    connect(m_oauth2, &OAuth2::activityChanged, this, &MSAStep::onOAuthActivityChanged);
-    connect(m_oauth2, &OAuth2::showVerificationUriAndCode, this, &MSAStep::showVerificationUriAndCode);
+    connect(&oauth2, &QOAuth2AuthorizationCodeFlow::granted, this, [this] {
+        m_data->msaClientID = oauth2.clientIdentifier();
+        m_data->msaToken.issueInstant = QDateTime::currentDateTimeUtc();
+        m_data->msaToken.notAfter = oauth2.expirationAt();
+        m_data->msaToken.extra = oauth2.extraTokens();
+        m_data->msaToken.refresh_token = oauth2.refreshToken();
+        m_data->msaToken.token = oauth2.token();
+        emit finished(AccountTaskState::STATE_WORKING, tr("Got "));
+    });
+    connect(&oauth2, &QOAuth2AuthorizationCodeFlow::authorizeWithBrowser, this, &MSAStep::authorizeWithBrowser);
+    connect(&oauth2, &QOAuth2AuthorizationCodeFlow::requestFailed, this, [this](const QAbstractOAuth2::Error err) {
+        emit finished(AccountTaskState::STATE_FAILED_HARD, tr("Microsoft user authentication failed."));
+    });
+
+    connect(&oauth2, &QOAuth2AuthorizationCodeFlow::extraTokensChanged, this,
+            [this](const QVariantMap& tokens) { m_data->msaToken.extra = tokens; });
+
+    connect(&oauth2, &QOAuth2AuthorizationCodeFlow::clientIdentifierChanged, this,
+            [this](const QString& clientIdentifier) { m_data->msaClientID = clientIdentifier; });
 }

-MSAStep::~MSAStep() noexcept = default;
-
 QString MSAStep::describe()
 {
    return tr("Logging in with Microsoft account.");
 }

-void MSAStep::rehydrate()
-{
-    switch (m_action) {
-        case Refresh: {
-            // TODO: check the tokens and see if they are old (older than a day)
-            return;
-        }
-        case Login: {
-            // NOOP
-            return;
-        }
-    }
-}
-
 void MSAStep::perform()
 {
-    switch (m_action) {
-        case Refresh: {
-            if (m_data->msaClientID != m_clientId) {
-                emit hideVerificationUriAndCode();
-                emit finished(AccountTaskState::STATE_DISABLED,
-                              tr("Microsoft user authentication failed - client identification has changed."));
-            }
-            m_oauth2->refresh();
-            return;
+    if (m_silent) {
+        if (m_data->msaClientID != m_clientId) {
+            emit finished(AccountTaskState::STATE_DISABLED,
+                          tr("Microsoft user authentication failed - client identification has changed."));
        }
-        case Login: {
-            QVariantMap extraOpts;
-            extraOpts["prompt"] = "select_account";
-            m_oauth2->setExtraRequestParams(extraOpts);
+        oauth2.setRefreshToken(m_data->msaToken.refresh_token);
+        oauth2.refreshAccessToken();
+    } else {
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)  // QMultiMap param changed in 6.0
+        oauth2.setModifyParametersFunction([](QAbstractOAuth::Stage stage, QMultiMap<QString, QVariant>* map) {
+#else
+        oauth2.setModifyParametersFunction([](QAbstractOAuth::Stage stage, QMap<QString, QVariant>* map) {
+#endif
+            map->insert("prompt", "select_account");
+        });

-            *m_data = AccountData();
-            m_data->msaClientID = m_clientId;
-            m_oauth2->login();
-            return;
-        }
-    }
-}
-
-void MSAStep::onOAuthActivityChanged(Katabasis::Activity activity)
-{
-    switch (activity) {
-        case Katabasis::Activity::Idle:
-        case Katabasis::Activity::LoggingIn:
-        case Katabasis::Activity::Refreshing:
-        case Katabasis::Activity::LoggingOut: {
-            // We asked it to do something, it's doing it. Nothing to act upon.
-            return;
-        }
-        case Katabasis::Activity::Succeeded: {
-            // Succeeded or did not invalidate tokens
-            emit hideVerificationUriAndCode();
-            QVariantMap extraTokens = m_oauth2->extraTokens();
-            if (!extraTokens.isEmpty()) {
-                qCDebug(authCredentials()) << "Extra tokens in response:";
-                foreach (QString key, extraTokens.keys()) {
-                    qCDebug(authCredentials()) << "\t" << key << ":" << extraTokens.value(key);
-                }
-            }
-            emit finished(AccountTaskState::STATE_WORKING, tr("Got "));
-            return;
-        }
-        case Katabasis::Activity::FailedSoft: {
-            // NOTE: soft error in the first step means 'offline'
-            emit hideVerificationUriAndCode();
-            emit finished(AccountTaskState::STATE_OFFLINE, tr("Microsoft user authentication ended with a network error."));
-            return;
-        }
-        case Katabasis::Activity::FailedGone: {
-            emit hideVerificationUriAndCode();
-            emit finished(AccountTaskState::STATE_FAILED_GONE, tr("Microsoft user authentication failed - user no longer exists."));
-            return;
-        }
-        case Katabasis::Activity::FailedHard: {
-            emit hideVerificationUriAndCode();
-            emit finished(AccountTaskState::STATE_FAILED_HARD, tr("Microsoft user authentication failed."));
-            return;
-        }
-        default: {
-            emit hideVerificationUriAndCode();
-            emit finished(AccountTaskState::STATE_FAILED_HARD, tr("Microsoft user authentication completed with an unrecognized result."));
-            return;
-        }
+        *m_data = AccountData();
+        m_data->msaClientID = m_clientId;
+        oauth2.grant();
    }
 }
--- a/launcher/minecraft/auth/steps/MSAStep.h
+++ b/launcher/minecraft/auth/steps/MSAStep.h
@ -36,30 +36,24 @@
 #pragma once
 #include <QObject>

-#include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"

-#include <katabasis/DeviceFlow.h>
-
+#include <QtNetworkAuth/qoauth2authorizationcodeflow.h>
 class MSAStep : public AuthStep {
    Q_OBJECT
   public:
-    enum Action { Refresh, Login };
-
-   public:
-    explicit MSAStep(AccountData* data, Action action);
-    virtual ~MSAStep() noexcept;
+    explicit MSAStep(AccountData* data, bool silent = false);
+    virtual ~MSAStep() noexcept = default;

    void perform() override;
-    void rehydrate() override;

    QString describe() override;

-   private slots:
-    void onOAuthActivityChanged(Katabasis::Activity activity);
+   signals:
+    void authorizeWithBrowser(const QUrl& url);

   private:
-    Katabasis::DeviceFlow* m_oauth2 = nullptr;
-    Action m_action;
+    bool m_silent;
    QString m_clientId;
+    QOAuth2AuthorizationCodeFlow oauth2;
 };
--- a/launcher/minecraft/auth/steps/MinecraftProfileStep.cpp
+++ b/launcher/minecraft/auth/steps/MinecraftProfileStep.cpp
@ -2,15 +2,13 @@

 #include <QNetworkRequest>

-#include "Logging.h"
-#include "minecraft/auth/AuthRequest.h"
+#include "Application.h"
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
+#include "net/StaticHeaderProxy.h"

 MinecraftProfileStep::MinecraftProfileStep(AccountData* data) : AuthStep(data) {}

-MinecraftProfileStep::~MinecraftProfileStep() noexcept = default;
-
 QString MinecraftProfileStep::describe()
 {
    return tr("Fetching the Minecraft profile.");
@ -18,52 +16,47 @@ QString MinecraftProfileStep::describe()

 void MinecraftProfileStep::perform()
 {
-    auto url = QUrl("https://api.minecraftservices.com/minecraft/profile");
-    QNetworkRequest request = QNetworkRequest(url);
-    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-    request.setRawHeader("Authorization", QString("Bearer %1").arg(m_data->yggdrasilToken.token).toUtf8());
+    QUrl url("https://api.minecraftservices.com/minecraft/profile");
+    auto headers = QList<Net::HeaderPair>{ { "Content-Type", "application/json" },
+                                           { "Accept", "application/json" },
+                                           { "Authorization", QString("Bearer %1").arg(m_data->yggdrasilToken.token).toUtf8() } };

-    AuthRequest* requestor = new AuthRequest(this);
-    connect(requestor, &AuthRequest::finished, this, &MinecraftProfileStep::onRequestDone);
-    requestor->get(request);
+    m_response.reset(new QByteArray());
+    m_task = Net::Download::makeByteArray(url, m_response);
+    m_task->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+
+    connect(m_task.get(), &Task::finished, this, &MinecraftProfileStep::onRequestDone);
+
+    m_task->setNetwork(APPLICATION->network());
+    m_task->start();
 }

-void MinecraftProfileStep::rehydrate()
+void MinecraftProfileStep::onRequestDone()
 {
-    // NOOP, for now. We only save bools and there's nothing to check.
-}
-
-void MinecraftProfileStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
-{
-    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
-    requestor->deleteLater();
-
-    qCDebug(authCredentials()) << data;
-    if (error == QNetworkReply::ContentNotFoundError) {
+    if (m_task->error() == QNetworkReply::ContentNotFoundError) {
        // NOTE: Succeed even if we do not have a profile. This is a valid account state.
        m_data->minecraftProfile = MinecraftProfile();
        emit finished(AccountTaskState::STATE_SUCCEEDED, tr("Account has no Minecraft profile."));
        return;
    }
-    if (error != QNetworkReply::NoError) {
+    if (m_task->error() != QNetworkReply::NoError) {
        qWarning() << "Error getting profile:";
-        qWarning() << " HTTP Status:        " << requestor->httpStatus_;
-        qWarning() << " Internal error no.: " << error;
-        qWarning() << " Error string:       " << requestor->errorString_;
+        qWarning() << " HTTP Status:        " << m_task->replyStatusCode();
+        qWarning() << " Internal error no.: " << m_task->error();
+        qWarning() << " Error string:       " << m_task->errorString();

        qWarning() << " Response:";
-        qWarning() << QString::fromUtf8(data);
+        qWarning() << QString::fromUtf8(*m_response);

-        if (Net::isApplicationError(error)) {
+        if (Net::isApplicationError(m_task->error())) {
            emit finished(AccountTaskState::STATE_FAILED_SOFT,
-                          tr("Minecraft Java profile acquisition failed: %1").arg(requestor->errorString_));
+                          tr("Minecraft Java profile acquisition failed: %1").arg(m_task->errorString()));
        } else {
-            emit finished(AccountTaskState::STATE_OFFLINE,
-                          tr("Minecraft Java profile acquisition failed: %1").arg(requestor->errorString_));
+            emit finished(AccountTaskState::STATE_OFFLINE, tr("Minecraft Java profile acquisition failed: %1").arg(m_task->errorString()));
        }
        return;
    }
-    if (!Parsers::parseMinecraftProfile(data, m_data->minecraftProfile)) {
+    if (!Parsers::parseMinecraftProfile(*m_response, m_data->minecraftProfile)) {
        m_data->minecraftProfile = MinecraftProfile();
        emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Minecraft Java profile response could not be parsed"));
        return;
--- a/launcher/minecraft/auth/steps/MinecraftProfileStep.h
+++ b/launcher/minecraft/auth/steps/MinecraftProfileStep.h
@ -1,21 +1,25 @@
 #pragma once
 #include <QObject>
+#include <memory>

-#include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
+#include "net/Download.h"

 class MinecraftProfileStep : public AuthStep {
    Q_OBJECT

   public:
    explicit MinecraftProfileStep(AccountData* data);
-    virtual ~MinecraftProfileStep() noexcept;
+    virtual ~MinecraftProfileStep() noexcept = default;

    void perform() override;
-    void rehydrate() override;

    QString describe() override;

   private slots:
-    void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
+    void onRequestDone();
+
+   private:
+    std::shared_ptr<QByteArray> m_response;
+    Net::Download::Ptr m_task;
 };
--- a/launcher/minecraft/auth/steps/OfflineStep.cpp
+++ b/launcher/minecraft/auth/steps/OfflineStep.cpp
@ -1,21 +0,0 @@
-#include "OfflineStep.h"
-
-#include "Application.h"
-
-OfflineStep::OfflineStep(AccountData* data) : AuthStep(data) {}
-OfflineStep::~OfflineStep() noexcept = default;
-
-QString OfflineStep::describe()
-{
-    return tr("Creating offline account.");
-}
-
-void OfflineStep::rehydrate()
-{
-    // NOOP
-}
-
-void OfflineStep::perform()
-{
-    emit finished(AccountTaskState::STATE_WORKING, tr("Created offline account."));
-}
--- a/launcher/minecraft/auth/steps/OfflineStep.h
+++ b/launcher/minecraft/auth/steps/OfflineStep.h
@ -1,19 +0,0 @@
-#pragma once
-#include <QObject>
-
-#include "QObjectPtr.h"
-#include "minecraft/auth/AuthStep.h"
-
-#include <katabasis/DeviceFlow.h>
-
-class OfflineStep : public AuthStep {
-    Q_OBJECT
-   public:
-    explicit OfflineStep(AccountData* data);
-    virtual ~OfflineStep() noexcept;
-
-    void perform() override;
-    void rehydrate() override;
-
-    QString describe() override;
-};
--- a/launcher/minecraft/auth/steps/XboxAuthorizationStep.cpp
+++ b/launcher/minecraft/auth/steps/XboxAuthorizationStep.cpp
@ -4,27 +4,22 @@
 #include <QJsonParseError>
 #include <QNetworkRequest>

+#include "Application.h"
 #include "Logging.h"
-#include "minecraft/auth/AuthRequest.h"
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
+#include "net/StaticHeaderProxy.h"
+#include "net/Upload.h"

-XboxAuthorizationStep::XboxAuthorizationStep(AccountData* data, Katabasis::Token* token, QString relyingParty, QString authorizationKind)
+XboxAuthorizationStep::XboxAuthorizationStep(AccountData* data, Token* token, QString relyingParty, QString authorizationKind)
    : AuthStep(data), m_token(token), m_relyingParty(relyingParty), m_authorizationKind(authorizationKind)
 {}

-XboxAuthorizationStep::~XboxAuthorizationStep() noexcept = default;
-
 QString XboxAuthorizationStep::describe()
 {
    return tr("Getting authorization to access %1 services.").arg(m_authorizationKind);
 }

-void XboxAuthorizationStep::rehydrate()
-{
-    // FIXME: check if the tokens are good?
-}
-
 void XboxAuthorizationStep::perform()
 {
    QString xbox_auth_template = R"XXX(
@ -41,40 +36,44 @@ void XboxAuthorizationStep::perform()
 )XXX";
    auto xbox_auth_data = xbox_auth_template.arg(m_data->userToken.token, m_relyingParty);
    // http://xboxlive.com
-    QNetworkRequest request = QNetworkRequest(QUrl("https://xsts.auth.xboxlive.com/xsts/authorize"));
-    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-    request.setRawHeader("Accept", "application/json");
-    AuthRequest* requestor = new AuthRequest(this);
-    connect(requestor, &AuthRequest::finished, this, &XboxAuthorizationStep::onRequestDone);
-    requestor->post(request, xbox_auth_data.toUtf8());
+    QUrl url("https://xsts.auth.xboxlive.com/xsts/authorize");
+    auto headers = QList<Net::HeaderPair>{
+        { "Content-Type", "application/json" },
+        { "Accept", "application/json" },
+    };
+    m_response.reset(new QByteArray());
+    m_task = Net::Upload::makeByteArray(url, m_response, xbox_auth_data.toUtf8());
+    m_task->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+
+    connect(m_task.get(), &Task::finished, this, &XboxAuthorizationStep::onRequestDone);
+
+    m_task->setNetwork(APPLICATION->network());
+    m_task->start();
    qDebug() << "Getting authorization token for " << m_relyingParty;
 }

-void XboxAuthorizationStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
+void XboxAuthorizationStep::onRequestDone()
 {
-    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
-    requestor->deleteLater();
-
-    qCDebug(authCredentials()) << data;
-    if (error != QNetworkReply::NoError) {
-        qWarning() << "Reply error:" << error;
-        if (Net::isApplicationError(error)) {
-            if (!processSTSError(error, data, headers)) {
+    qCDebug(authCredentials()) << *m_response;
+    if (m_task->error() != QNetworkReply::NoError) {
+        qWarning() << "Reply error:" << m_task->error();
+        if (Net::isApplicationError(m_task->error())) {
+            if (!processSTSError()) {
                emit finished(AccountTaskState::STATE_FAILED_SOFT,
-                              tr("Failed to get authorization for %1 services. Error %2.").arg(m_authorizationKind, error));
+                              tr("Failed to get authorization for %1 services. Error %2.").arg(m_authorizationKind, m_task->error()));
            } else {
                emit finished(AccountTaskState::STATE_FAILED_SOFT,
-                              tr("Unknown STS error for %1 services: %2").arg(m_authorizationKind, requestor->errorString_));
+                              tr("Unknown STS error for %1 services: %2").arg(m_authorizationKind, m_task->errorString()));
            }
        } else {
            emit finished(AccountTaskState::STATE_OFFLINE,
-                          tr("Failed to get authorization for %1 services: %2").arg(m_authorizationKind, requestor->errorString_));
+                          tr("Failed to get authorization for %1 services: %2").arg(m_authorizationKind, m_task->errorString()));
        }
        return;
    }

-    Katabasis::Token temp;
-    if (!Parsers::parseXTokenResponse(data, temp, m_authorizationKind)) {
+    Token temp;
+    if (!Parsers::parseXTokenResponse(*m_response, temp, m_authorizationKind)) {
        emit finished(AccountTaskState::STATE_FAILED_SOFT,
                      tr("Could not parse authorization response for access to %1 services.").arg(m_authorizationKind));
        return;
@ -91,11 +90,11 @@ void XboxAuthorizationStep::onRequestDone(QNetworkReply::NetworkError error, QBy
    emit finished(AccountTaskState::STATE_WORKING, tr("Got authorization to access %1").arg(m_relyingParty));
 }

-bool XboxAuthorizationStep::processSTSError(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
+bool XboxAuthorizationStep::processSTSError()
 {
-    if (error == QNetworkReply::AuthenticationRequiredError) {
+    if (m_task->error() == QNetworkReply::AuthenticationRequiredError) {
        QJsonParseError jsonError;
-        QJsonDocument doc = QJsonDocument::fromJson(data, &jsonError);
+        QJsonDocument doc = QJsonDocument::fromJson(*m_response, &jsonError);
        if (jsonError.error) {
            qWarning() << "Cannot parse error XSTS response as JSON: " << jsonError.errorString();
            emit finished(AccountTaskState::STATE_FAILED_SOFT,
@ -126,7 +125,35 @@ bool XboxAuthorizationStep::processSTSError(QNetworkReply::NetworkError error, Q
                emit finished(
                    AccountTaskState::STATE_FAILED_SOFT,
                    tr("This Microsoft account is underaged and is not linked to a family.\n\nPlease set up your account according to %1.")
-                        .arg("<a href=\"https://help.minecraft.net/hc/en-us/articles/4403181904525\">help.minecraft.net</a>"));
+                        .arg("<a href=\"https://help.minecraft.net/hc/en-us/articles/4408968616077\">help.minecraft.net</a>"));
+                return true;
+            }
+            // the following codes where copied from: https://github.com/PrismarineJS/prismarine-auth/pull/44
+            case 2148916236: {
+                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                              tr("This Microsoft account requires proof of age to play. Please login to %1 to provide proof of age.")
+                                  .arg("<a href=\"https://login.live.com/login.srf\">login.live.com</a>"));
+                return true;
+            }
+            case 2148916237:
+                emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("This Microsoft account has reached its limit for playtime. This "
+                                                                      "Microsoft account has been blocked from logging in."));
+                return true;
+            case 2148916227: {
+                emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("This Microsoft account was banned by Xbox for violating one or more "
+                                                                      "Community Standards for Xbox and is unable to be used."));
+                return true;
+            }
+            case 2148916229: {
+                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                              tr("This Microsoft account is currently restricted and your guardian has not given you permission to play "
+                                 "online. Login to %1 and have your guardian change your permissions.")
+                                  .arg("<a href=\"https://account.microsoft.com/family/\">account.microsoft.com</a>"));
+                return true;
+            }
+            case 2148916234: {
+                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                              tr("This Microsoft account has not accepted Xbox's Terms of Service. Please login and accept them."));
                return true;
            }
            default: {
--- a/launcher/minecraft/auth/steps/XboxAuthorizationStep.h
+++ b/launcher/minecraft/auth/steps/XboxAuthorizationStep.h
@ -1,29 +1,32 @@
 #pragma once
 #include <QObject>
+#include <memory>

-#include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
+#include "net/Upload.h"

 class XboxAuthorizationStep : public AuthStep {
    Q_OBJECT

   public:
-    explicit XboxAuthorizationStep(AccountData* data, Katabasis::Token* token, QString relyingParty, QString authorizationKind);
-    virtual ~XboxAuthorizationStep() noexcept;
+    explicit XboxAuthorizationStep(AccountData* data, Token* token, QString relyingParty, QString authorizationKind);
+    virtual ~XboxAuthorizationStep() noexcept = default;

    void perform() override;
-    void rehydrate() override;

    QString describe() override;

   private:
-    bool processSTSError(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers);
+    bool processSTSError();

   private slots:
-    void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
+    void onRequestDone();

   private:
-    Katabasis::Token* m_token;
+    Token* m_token;
    QString m_relyingParty;
    QString m_authorizationKind;
+
+    std::shared_ptr<QByteArray> m_response;
+    Net::Upload::Ptr m_task;
 };
--- a/launcher/minecraft/auth/steps/XboxProfileStep.cpp
+++ b/launcher/minecraft/auth/steps/XboxProfileStep.cpp
@ -3,28 +3,21 @@
 #include <QNetworkRequest>
 #include <QUrlQuery>

+#include "Application.h"
 #include "Logging.h"
-#include "minecraft/auth/AuthRequest.h"
-#include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
+#include "net/StaticHeaderProxy.h"

 XboxProfileStep::XboxProfileStep(AccountData* data) : AuthStep(data) {}

-XboxProfileStep::~XboxProfileStep() noexcept = default;
-
 QString XboxProfileStep::describe()
 {
    return tr("Fetching Xbox profile.");
 }

-void XboxProfileStep::rehydrate()
-{
-    // NOOP, for now. We only save bools and there's nothing to check.
-}
-
 void XboxProfileStep::perform()
 {
-    auto url = QUrl("https://profile.xboxlive.com/users/me/profile/settings");
+    QUrl url("https://profile.xboxlive.com/users/me/profile/settings");
    QUrlQuery q;
    q.addQueryItem("settings",
                   "GameDisplayName,AppDisplayName,AppDisplayPicRaw,GameDisplayPicRaw,"
@ -33,36 +26,38 @@ void XboxProfileStep::perform()
                   "PreferredColor,Location,Bio,Watermarks,"
                   "RealName,RealNameOverride,IsQuarantined");
    url.setQuery(q);
+    auto headers = QList<Net::HeaderPair>{
+        { "Content-Type", "application/json" },
+        { "Accept", "application/json" },
+        { "x-xbl-contract-version", "3" },
+        { "Authorization", QString("XBL3.0 x=%1;%2").arg(m_data->userToken.extra["uhs"].toString(), m_data->xboxApiToken.token).toUtf8() }
+    };

-    QNetworkRequest request = QNetworkRequest(url);
-    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-    request.setRawHeader("Accept", "application/json");
-    request.setRawHeader("x-xbl-contract-version", "3");
-    request.setRawHeader("Authorization",
-                         QString("XBL3.0 x=%1;%2").arg(m_data->userToken.extra["uhs"].toString(), m_data->xboxApiToken.token).toUtf8());
-    AuthRequest* requestor = new AuthRequest(this);
-    connect(requestor, &AuthRequest::finished, this, &XboxProfileStep::onRequestDone);
-    requestor->get(request);
+    m_response.reset(new QByteArray());
+    m_task = Net::Download::makeByteArray(url, m_response);
+    m_task->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+
+    connect(m_task.get(), &Task::finished, this, &XboxProfileStep::onRequestDone);
+
+    m_task->setNetwork(APPLICATION->network());
+    m_task->start();
    qDebug() << "Getting Xbox profile...";
 }

-void XboxProfileStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
+void XboxProfileStep::onRequestDone()
 {
-    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
-    requestor->deleteLater();
-
-    if (error != QNetworkReply::NoError) {
-        qWarning() << "Reply error:" << error;
-        qCDebug(authCredentials()) << data;
-        if (Net::isApplicationError(error)) {
-            emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Failed to retrieve the Xbox profile: %1").arg(requestor->errorString_));
+    if (m_task->error() != QNetworkReply::NoError) {
+        qWarning() << "Reply error:" << m_task->error();
+        qCDebug(authCredentials()) << *m_response;
+        if (Net::isApplicationError(m_task->error())) {
+            emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Failed to retrieve the Xbox profile: %1").arg(m_task->errorString()));
        } else {
-            emit finished(AccountTaskState::STATE_OFFLINE, tr("Failed to retrieve the Xbox profile: %1").arg(requestor->errorString_));
+            emit finished(AccountTaskState::STATE_OFFLINE, tr("Failed to retrieve the Xbox profile: %1").arg(m_task->errorString()));
        }
        return;
    }

-    qCDebug(authCredentials()) << "XBox profile: " << data;
+    qCDebug(authCredentials()) << "XBox profile: " << *m_response;

    emit finished(AccountTaskState::STATE_WORKING, tr("Got Xbox profile"));
 }
--- a/launcher/minecraft/auth/steps/XboxProfileStep.h
+++ b/launcher/minecraft/auth/steps/XboxProfileStep.h
@ -1,21 +1,25 @@
 #pragma once
 #include <QObject>
+#include <memory>

-#include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
+#include "net/Download.h"

 class XboxProfileStep : public AuthStep {
    Q_OBJECT

   public:
    explicit XboxProfileStep(AccountData* data);
-    virtual ~XboxProfileStep() noexcept;
+    virtual ~XboxProfileStep() noexcept = default;

    void perform() override;
-    void rehydrate() override;

    QString describe() override;

   private slots:
-    void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
+    void onRequestDone();
+
+   private:
+    std::shared_ptr<QByteArray> m_response;
+    Net::Download::Ptr m_task;
 };
--- a/launcher/minecraft/auth/steps/XboxUserStep.cpp
+++ b/launcher/minecraft/auth/steps/XboxUserStep.cpp
@ -2,24 +2,18 @@

 #include <QNetworkRequest>

-#include "minecraft/auth/AuthRequest.h"
+#include "Application.h"
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
+#include "net/StaticHeaderProxy.h"

 XboxUserStep::XboxUserStep(AccountData* data) : AuthStep(data) {}

-XboxUserStep::~XboxUserStep() noexcept = default;
-
 QString XboxUserStep::describe()
 {
    return tr("Logging in as an Xbox user.");
 }

-void XboxUserStep::rehydrate()
-{
-    // NOOP, for now. We only save bools and there's nothing to check.
-}
-
 void XboxUserStep::perform()
 {
    QString xbox_auth_template = R"XXX(
@ -35,36 +29,39 @@ void XboxUserStep::perform()
 )XXX";
    auto xbox_auth_data = xbox_auth_template.arg(m_data->msaToken.token);

-    QNetworkRequest request = QNetworkRequest(QUrl("https://user.auth.xboxlive.com/user/authenticate"));
-    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-    request.setRawHeader("Accept", "application/json");
-    // set contract-version header (prevent err 400 bad-request?)
-    // https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/reference/live/rest/additional/httpstandardheaders
-    request.setRawHeader("x-xbl-contract-version", "1");
+    QUrl url("https://user.auth.xboxlive.com/user/authenticate");
+    auto headers = QList<Net::HeaderPair>{
+        { "Content-Type", "application/json" },
+        { "Accept", "application/json" },
+        // set contract-version header (prevent err 400 bad-request?)
+        // https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/reference/live/rest/additional/httpstandardheaders
+        { "x-xbl-contract-version", "1" }
+    };
+    m_response.reset(new QByteArray());
+    m_task = Net::Upload::makeByteArray(url, m_response, xbox_auth_data.toUtf8());
+    m_task->addHeaderProxy(new Net::StaticHeaderProxy(headers));

-    auto* requestor = new AuthRequest(this);
-    connect(requestor, &AuthRequest::finished, this, &XboxUserStep::onRequestDone);
-    requestor->post(request, xbox_auth_data.toUtf8());
+    connect(m_task.get(), &Task::finished, this, &XboxUserStep::onRequestDone);
+
+    m_task->setNetwork(APPLICATION->network());
+    m_task->start();
    qDebug() << "First layer of XBox auth ... commencing.";
 }

-void XboxUserStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
+void XboxUserStep::onRequestDone()
 {
-    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
-    requestor->deleteLater();
-
-    if (error != QNetworkReply::NoError) {
-        qWarning() << "Reply error:" << error;
-        if (Net::isApplicationError(error)) {
-            emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("XBox user authentication failed: %1").arg(requestor->errorString_));
+    if (m_task->error() != QNetworkReply::NoError) {
+        qWarning() << "Reply error:" << m_task->error();
+        if (Net::isApplicationError(m_task->error())) {
+            emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("XBox user authentication failed: %1").arg(m_task->errorString()));
        } else {
-            emit finished(AccountTaskState::STATE_OFFLINE, tr("XBox user authentication failed: %1").arg(requestor->errorString_));
+            emit finished(AccountTaskState::STATE_OFFLINE, tr("XBox user authentication failed: %1").arg(m_task->errorString()));
        }
        return;
    }

-    Katabasis::Token temp;
-    if (!Parsers::parseXTokenResponse(data, temp, "UToken")) {
+    Token temp;
+    if (!Parsers::parseXTokenResponse(*m_response, temp, "UToken")) {
        qWarning() << "Could not parse user authentication response...";
        emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("XBox user authentication response could not be understood."));
        return;
--- a/launcher/minecraft/auth/steps/XboxUserStep.h
+++ b/launcher/minecraft/auth/steps/XboxUserStep.h
@ -1,21 +1,25 @@
 #pragma once
 #include <QObject>
+#include <memory>

-#include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
+#include "net/Upload.h"

 class XboxUserStep : public AuthStep {
    Q_OBJECT

   public:
    explicit XboxUserStep(AccountData* data);
-    virtual ~XboxUserStep() noexcept;
+    virtual ~XboxUserStep() noexcept = default;

    void perform() override;
-    void rehydrate() override;

    QString describe() override;

   private slots:
-    void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
+    void onRequestDone();
+
+   private:
+    std::shared_ptr<QByteArray> m_response;
+    Net::Upload::Ptr m_task;
 };
--- a/launcher/minecraft/launch/ExtractNatives.cpp
+++ b/launcher/minecraft/launch/ExtractNatives.cpp
@ -79,6 +79,7 @@ void ExtractNatives::executeTask()
    auto settings = minecraftInstance->settings();

    auto outputPath = minecraftInstance->getNativePath();
+    FS::ensureFolderPathExists(outputPath);
    auto javaVersion = minecraftInstance->getJavaVersion();
    bool jniHackEnabled = javaVersion.major() >= 8;
    for (const auto& source : toExtract) {
--- a/launcher/minecraft/launch/ExtractNatives.h
+++ b/launcher/minecraft/launch/ExtractNatives.h
@ -16,8 +16,6 @@
 #pragma once

 #include <launch/LaunchStep.h>
-#include <memory>
-#include "minecraft/auth/AuthSession.h"

 // FIXME: temporary wrapper for existing task.
 class ExtractNatives : public LaunchStep {
--- a/launcher/minecraft/launch/LauncherPartLaunch.cpp
+++ b/launcher/minecraft/launch/LauncherPartLaunch.cpp
@ -66,32 +66,6 @@ LauncherPartLaunch::LauncherPartLaunch(LaunchTask* parent) : LaunchStep(parent)
    connect(&m_process, &LoggedProcess::stateChanged, this, &LauncherPartLaunch::on_state);
 }

-#ifdef Q_OS_WIN
-// returns 8.3 file format from long path
-#include <windows.h>
-QString shortPathName(const QString& file)
-{
-    auto input = file.toStdWString();
-    std::wstring output;
-    long length = GetShortPathNameW(input.c_str(), NULL, 0);
-    // 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);
-    GetShortPathNameW(input.c_str(), (LPWSTR)output.c_str(), length);
-    output.resize(length - 1);
-    QString ret = QString::fromStdWString(output);
-    return ret;
-}
-#endif
-
-// if the string survives roundtrip through local 8bit encoding...
-bool fitsInLocal8bit(const QString& string)
-{
-    return string == QString::fromLocal8Bit(string.toLocal8Bit());
-}
-
 void LauncherPartLaunch::executeTask()
 {
    QString jarPath = APPLICATION->getJarPath("NewLaunch.jar");
@ -136,24 +110,15 @@ void LauncherPartLaunch::executeTask()

    auto natPath = minecraftInstance->getNativePath();
 #ifdef Q_OS_WIN
-    if (!fitsInLocal8bit(natPath)) {
-        args << "-Djava.library.path=" + shortPathName(natPath);
-    } else {
-        args << "-Djava.library.path=" + natPath;
-    }
-#else
-    args << "-Djava.library.path=" + natPath;
+    natPath = FS::getPathNameInLocal8bit(natPath);
 #endif
+    args << "-Djava.library.path=" + natPath;

    args << "-cp";
 #ifdef Q_OS_WIN
    QStringList processed;
    for (auto& item : classPath) {
-        if (!fitsInLocal8bit(item)) {
-            processed << shortPathName(item);
-        } else {
-            processed << item;
-        }
+        processed << FS::getPathNameInLocal8bit(item);
    }
    args << processed.join(';');
 #else
--- a/launcher/minecraft/mod/Mod.cpp
+++ b/launcher/minecraft/mod/Mod.cpp
@ -274,7 +274,7 @@ QPixmap Mod::icon(QSize size, Qt::AspectRatioMode mode) const
        return {};

    if (m_pack_image_cache_key.was_ever_used) {
-        qDebug() << "Mod" << name() << "Had it's icon evicted form the cache. reloading...";
+        qDebug() << "Mod" << name() << "Had it's icon evicted from the cache. reloading...";
        PixmapCache::markCacheMissByEviciton();
    }
    // Image got evicted from the cache or an attempt to load it has not been made. load it and retry.
--- a/launcher/minecraft/mod/ResourceFolderModel.cpp
+++ b/launcher/minecraft/mod/ResourceFolderModel.cpp
@ -284,7 +284,12 @@ void ResourceFolderModel::resolveResource(Resource* res)
    connect(
        task.get(), &Task::failed, this, [=] { onParseFailed(ticket, res->internal_id()); }, Qt::ConnectionType::QueuedConnection);
    connect(
-        task.get(), &Task::finished, this, [=] { m_active_parse_tasks.remove(ticket); }, Qt::ConnectionType::QueuedConnection);
+        task.get(), &Task::finished, this,
+        [=] {
+            m_active_parse_tasks.remove(ticket);
+            emit parseFinished();
+        },
+        Qt::ConnectionType::QueuedConnection);

    m_helper_thread_task.addTask(task);

@ -617,3 +622,26 @@ QString ResourceFolderModel::instDirPath() const
 {
    return QFileInfo(m_instance->instanceRoot()).absoluteFilePath();
 }
+
+void ResourceFolderModel::onParseFailed(int ticket, QString resource_id)
+{
+    auto iter = m_active_parse_tasks.constFind(ticket);
+    if (iter == m_active_parse_tasks.constEnd())
+        return;
+
+    auto removed_index = m_resources_index[resource_id];
+    auto removed_it = m_resources.begin() + removed_index;
+    Q_ASSERT(removed_it != m_resources.end());
+
+    beginRemoveRows(QModelIndex(), removed_index, removed_index);
+    m_resources.erase(removed_it);
+
+    // update index
+    m_resources_index.clear();
+    int idx = 0;
+    for (auto const& mod : qAsConst(m_resources)) {
+        m_resources_index[mod->internal_id()] = idx;
+        idx++;
+    }
+    endRemoveRows();
+}
--- a/launcher/minecraft/mod/ResourceFolderModel.h
+++ b/launcher/minecraft/mod/ResourceFolderModel.h
@ -143,6 +143,7 @@ class ResourceFolderModel : public QAbstractListModel {

   signals:
    void updateFinished();
+    void parseFinished();

   protected:
    /** This creates a new update task to be executed by update().
@ -189,11 +190,7 @@ class ResourceFolderModel : public QAbstractListModel {
     *  if the resource is complex and has more stuff to parse.
     */
    virtual void onParseSucceeded(int ticket, QString resource_id);
-    virtual void onParseFailed(int ticket, QString resource_id)
-    {
-        Q_UNUSED(ticket);
-        Q_UNUSED(resource_id);
-    }
+    virtual void onParseFailed(int ticket, QString resource_id);

   protected:
    // Represents the relationship between a column's index (represented by the list index), and it's sorting key.
--- a/launcher/minecraft/mod/ShaderPack.cpp
+++ b/launcher/minecraft/mod/ShaderPack.cpp
@ -35,8 +35,3 @@ bool ShaderPack::valid() const
 {
    return m_pack_format != ShaderPackFormat::INVALID;
 }
-
-bool ShaderPack::applyFilter(QRegularExpression filter) const
-{
-    return valid() && Resource::applyFilter(filter);
-}
--- a/launcher/minecraft/mod/ShaderPack.h
+++ b/launcher/minecraft/mod/ShaderPack.h
@ -54,7 +54,6 @@ class ShaderPack : public Resource {
    void setPackFormat(ShaderPackFormat new_format);

    bool valid() const override;
-    [[nodiscard]] bool applyFilter(QRegularExpression filter) const override;

   protected:
    mutable QMutex m_data_lock;
--- a/launcher/minecraft/mod/tasks/GetModDependenciesTask.cpp
+++ b/launcher/minecraft/mod/tasks/GetModDependenciesTask.cpp
@ -57,9 +57,11 @@ GetModDependenciesTask::GetModDependenciesTask(QObject* parent,
    , m_version(mcVersion(instance))
    , m_loaderType(mcLoaders(instance))
 {
-    for (auto mod : folder->allMods())
+    for (auto mod : folder->allMods()) {
+        m_mods_file_names << mod->fileinfo().fileName();
        if (auto meta = mod->metadata(); meta)
            m_mods.append(meta);
+    }
    prepare();
 }

@ -231,8 +233,13 @@ Task::Ptr GetModDependenciesTask::prepareDependencyTask(const ModPlatform::Depen
            if (dep_.addonId != pDep->version.addonId) {
                removePack(pDep->version.addonId);
                addTask(prepareDependencyTask(dep_, provider.name, level));
-            } else
+            } else {
                addTask(getProjectInfoTask(pDep));
+            }
+        }
+        if (isLocalyInstalled(pDep)) {
+            removePack(pDep->version.addonId);
+            return;
        }
        for (auto dep_ : getDependenciesForVersion(pDep->version, provider.name)) {
            addTask(prepareDependencyTask(dep_, provider.name, level - 1));
@ -258,9 +265,9 @@ void GetModDependenciesTask::removePack(const QVariant& addonId)
 #endif
 }

-QHash<QString, QStringList> GetModDependenciesTask::getRequiredBy()
+auto GetModDependenciesTask::getExtraInfo() -> QHash<QString, PackDependencyExtraInfo>
 {
-    QHash<QString, QStringList> rby;
+    QHash<QString, PackDependencyExtraInfo> rby;
    auto fullList = m_selected + m_pack_dependencies;
    for (auto& mod : fullList) {
        auto addonId = mod->pack->addonId;
@ -282,7 +289,61 @@ QHash<QString, QStringList> GetModDependenciesTask::getRequiredBy()
                req.append(smod->pack->name);
            }
        }
-        rby[addonId.toString()] = req;
+        rby[addonId.toString()] = { maybeInstalled(mod), req };
    }
    return rby;
 }
+
+// super lax compare (but not fuzzy)
+// convert to lowercase
+// convert all speratores to whitespace
+// simplify sequence of internal whitespace to a single space
+// efectivly compare two strings ignoring all separators and case
+auto laxCompare = [](QString fsfilename, QString metadataFilename, bool excludeDigits = false) {
+    // allowed character seperators
+    QList<QChar> allowedSeperators = { '-', '+', '.', '_' };
+    if (excludeDigits)
+        allowedSeperators.append({ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' });
+
+    // copy in lowercase
+    auto fsName = fsfilename.toLower();
+    auto metaName = metadataFilename.toLower();
+
+    // replace all potential allowed seperatores with whitespace
+    for (auto sep : allowedSeperators) {
+        fsName = fsName.replace(sep, ' ');
+        metaName = metaName.replace(sep, ' ');
+    }
+
+    // remove extraneous whitespace
+    fsName = fsName.simplified();
+    metaName = metaName.simplified();
+
+    return fsName.compare(metaName) == 0;
+};
+
+bool GetModDependenciesTask::isLocalyInstalled(std::shared_ptr<PackDependency> pDep)
+{
+    return pDep->version.fileName.isEmpty() ||
+
+           std::find_if(m_selected.begin(), m_selected.end(),
+                        [pDep](std::shared_ptr<PackDependency> i) {
+                            return !i->version.fileName.isEmpty() && laxCompare(i->version.fileName, pDep->version.fileName);
+                        }) != m_selected.end() ||  // check the selected versions
+
+           std::find_if(m_mods_file_names.begin(), m_mods_file_names.end(),
+                        [pDep](QString i) { return !i.isEmpty() && laxCompare(i, pDep->version.fileName); }) !=
+               m_mods_file_names.end() ||  // check the existing mods
+
+           std::find_if(m_pack_dependencies.begin(), m_pack_dependencies.end(), [pDep](std::shared_ptr<PackDependency> i) {
+               return pDep->pack->addonId != i->pack->addonId && !i->version.fileName.isEmpty() &&
+                      laxCompare(pDep->version.fileName, i->version.fileName);
+           }) != m_pack_dependencies.end();  // check loaded dependencies
+}
+
+bool GetModDependenciesTask::maybeInstalled(std::shared_ptr<PackDependency> pDep)
+{
+    return std::find_if(m_mods_file_names.begin(), m_mods_file_names.end(), [pDep](QString i) {
+               return !i.isEmpty() && laxCompare(i, pDep->version.fileName, true);
+           }) != m_mods_file_names.end();  // check the existing mods
+}
--- a/launcher/minecraft/mod/tasks/GetModDependenciesTask.h
+++ b/launcher/minecraft/mod/tasks/GetModDependenciesTask.h
@ -50,6 +50,11 @@ class GetModDependenciesTask : public SequentialTask {
        }
    };

+    struct PackDependencyExtraInfo {
+        bool maybe_installed;
+        QStringList required_by;
+    };
+
    struct Provider {
        ModPlatform::ResourceProvider name;
        std::shared_ptr<ResourceDownload::ModModel> mod;
@ -62,7 +67,7 @@ class GetModDependenciesTask : public SequentialTask {
                                    QList<std::shared_ptr<PackDependency>> selected);

    auto getDependecies() const -> QList<std::shared_ptr<PackDependency>> { return m_pack_dependencies; }
-    QHash<QString, QStringList> getRequiredBy();
+    QHash<QString, PackDependencyExtraInfo> getExtraInfo();

   protected slots:
    Task::Ptr prepareDependencyTask(const ModPlatform::Dependency&, ModPlatform::ResourceProvider, int);
@ -73,10 +78,14 @@ class GetModDependenciesTask : public SequentialTask {
    ModPlatform::Dependency getOverride(const ModPlatform::Dependency&, ModPlatform::ResourceProvider providerName);
    void removePack(const QVariant& addonId);

+    bool isLocalyInstalled(std::shared_ptr<PackDependency> pDep);
+    bool maybeInstalled(std::shared_ptr<PackDependency> pDep);
+
   private:
    QList<std::shared_ptr<PackDependency>> m_pack_dependencies;
    QList<std::shared_ptr<Metadata::ModStruct>> m_mods;
    QList<std::shared_ptr<PackDependency>> m_selected;
+    QStringList m_mods_file_names;
    Provider m_flame_provider;
    Provider m_modrinth_provider;

--- a/launcher/minecraft/mod/tasks/LocalModParseTask.cpp
+++ b/launcher/minecraft/mod/tasks/LocalModParseTask.cpp
@ -469,7 +469,7 @@ bool processZIP(Mod& mod, [[maybe_unused]] ProcessingLevel level)

    QuaZipFile file(&zip);

-    if (zip.setCurrentFile("META-INF/mods.toml")) {
+    if (zip.setCurrentFile("META-INF/mods.toml") || zip.setCurrentFile("META-INF/neoforge.mods.toml")) {
        if (!file.open(QIODevice::ReadOnly)) {
            zip.close();
            return false;
@ -746,7 +746,7 @@ void LocalModParseTask::executeTask()
    m_result->details = mod.details();

    if (m_aborted)
-        emit finished();
+        emitAborted();
    else
        emitSucceeded();
 }
--- a/launcher/minecraft/mod/tasks/LocalResourcePackParseTask.cpp
+++ b/launcher/minecraft/mod/tasks/LocalResourcePackParseTask.cpp
@ -286,8 +286,10 @@ bool LocalResourcePackParseTask::abort()

 void LocalResourcePackParseTask::executeTask()
 {
-    if (!ResourcePackUtils::process(m_resource_pack))
+    if (!ResourcePackUtils::process(m_resource_pack)) {
+        emitFailed("this is not a resource pack");
        return;
+    }

    if (m_aborted)
        emitAborted();
--- a/launcher/minecraft/mod/tasks/LocalShaderPackParseTask.cpp
+++ b/launcher/minecraft/mod/tasks/LocalShaderPackParseTask.cpp
@ -103,8 +103,10 @@ bool LocalShaderPackParseTask::abort()

 void LocalShaderPackParseTask::executeTask()
 {
-    if (!ShaderPackUtils::process(m_shader_pack))
+    if (!ShaderPackUtils::process(m_shader_pack)) {
+        emitFailed("this is not a shader pack");
        return;
+    }

    if (m_aborted)
        emitAborted();
--- a/launcher/minecraft/mod/tasks/LocalTexturePackParseTask.cpp
+++ b/launcher/minecraft/mod/tasks/LocalTexturePackParseTask.cpp
@ -241,8 +241,10 @@ bool LocalTexturePackParseTask::abort()

 void LocalTexturePackParseTask::executeTask()
 {
-    if (!TexturePackUtils::process(m_texture_pack))
+    if (!TexturePackUtils::process(m_texture_pack)) {
+        emitFailed("this is not a texture pack");
        return;
+    }

    if (m_aborted)
        emitAborted();
--- a/launcher/modplatform/CheckUpdateTask.h
+++ b/launcher/modplatform/CheckUpdateTask.h
@ -28,6 +28,7 @@ class CheckUpdateTask : public Task {
        QString changelog;
        ModPlatform::ResourceProvider provider;
        shared_qobject_ptr<ResourceDownloadTask> download;
+        bool enabled = true;

       public:
        UpdatableMod(QString name,
@ -37,7 +38,8 @@ class CheckUpdateTask : public Task {
                     std::optional<ModPlatform::IndexedVersionType> new_v_type,
                     QString changelog,
                     ModPlatform::ResourceProvider p,
-                     shared_qobject_ptr<ResourceDownloadTask> t)
+                     shared_qobject_ptr<ResourceDownloadTask> t,
+                     bool enabled = true)
            : name(name)
            , old_hash(old_h)
            , old_version(old_v)
@ -46,6 +48,7 @@ class CheckUpdateTask : public Task {
            , changelog(changelog)
            , provider(p)
            , download(t)
+            , enabled(enabled)
        {}
    };

--- a/launcher/modplatform/atlauncher/ATLPackInstallTask.cpp
+++ b/launcher/modplatform/atlauncher/ATLPackInstallTask.cpp
@ -1031,6 +1031,12 @@ void PackInstallTask::install()
            return;

        components->setComponentVersion("net.minecraftforge", version);
+    } else if (m_version.loader.type == QString("neoforge")) {
+        auto version = getVersionForLoader("net.neoforged");
+        if (version == Q_NULLPTR)
+            return;
+
+        components->setComponentVersion("net.neoforged", version);
    } else if (m_version.loader.type == QString("fabric")) {
        auto version = getVersionForLoader("net.fabricmc.fabric-loader");
        if (version == Q_NULLPTR)
--- a/launcher/modplatform/flame/FlameInstanceCreationTask.cpp
+++ b/launcher/modplatform/flame/FlameInstanceCreationTask.cpp
@ -537,7 +537,12 @@ void FlameCreationTask::setupDownloadJob(QEventLoop& loop)
        selectedOptionalMods = optionalModDialog.getResult();
    }
    for (const auto& result : results) {
-        auto relpath = FS::PathCombine(result.targetFolder, result.fileName);
+        auto fileName = result.fileName;
+#ifdef Q_OS_WIN
+        fileName = FS::RemoveInvalidPathChars(fileName);
+#endif
+        auto relpath = FS::PathCombine(result.targetFolder, fileName);
+
        if (!result.required && !selectedOptionalMods.contains(relpath)) {
            relpath += ".disabled";
        }
--- a/launcher/modplatform/flame/FlameModIndex.cpp
+++ b/launcher/modplatform/flame/FlameModIndex.cpp
@ -1,5 +1,6 @@
 #include "FlameModIndex.h"

+#include "FileSystem.h"
 #include "Json.h"
 #include "minecraft/MinecraftInstance.h"
 #include "minecraft/PackProfile.h"
@ -138,6 +139,9 @@ auto FlameMod::loadIndexedPackVersion(QJsonObject& obj, bool load_changelog) ->
    file.version = Json::requireString(obj, "displayName");
    file.downloadUrl = Json::ensureString(obj, "downloadUrl");
    file.fileName = Json::requireString(obj, "fileName");
+#ifdef Q_OS_WIN
+    file.fileName = FS::RemoveInvalidPathChars(file.fileName);
+#endif

    ModPlatform::IndexedVersionType::VersionType ver_type;
    switch (Json::requireInteger(obj, "releaseType")) {
--- a/launcher/modplatform/flame/FlamePackExportTask.cpp
+++ b/launcher/modplatform/flame/FlamePackExportTask.cpp
@ -201,7 +201,7 @@ void FlamePackExportTask::makeApiRequest()
                       << " reason: " << parseError.errorString();
            qWarning() << *response;

-            failed(parseError.errorString());
+            emitFailed(parseError.errorString());
            return;
        }

@ -213,6 +213,7 @@ void FlamePackExportTask::makeApiRequest()
            if (dataArr.isEmpty()) {
                qWarning() << "No matches found for fingerprint search!";

+                getProjectsInfo();
                return;
            }
            for (auto match : dataArr) {
@ -243,9 +244,9 @@ void FlamePackExportTask::makeApiRequest()
            qDebug() << doc;
        }
        pendingHashes.clear();
+        getProjectsInfo();
    });
-    connect(task.get(), &Task::finished, this, &FlamePackExportTask::getProjectsInfo);
-    connect(task.get(), &NetJob::failed, this, &FlamePackExportTask::emitFailed);
+    connect(task.get(), &NetJob::failed, this, &FlamePackExportTask::getProjectsInfo);
    task->start();
 }

@ -279,7 +280,7 @@ void FlamePackExportTask::getProjectsInfo()
            qWarning() << "Error while parsing JSON response from CurseForge projects task at " << parseError.offset
                       << " reason: " << parseError.errorString();
            qWarning() << *response;
-            failed(parseError.errorString());
+            emitFailed(parseError.errorString());
            return;
        }

@ -333,7 +334,7 @@ void FlamePackExportTask::buildZip()
    setStatus(tr("Adding files..."));
    setProgress(4, 5);

-    auto zipTask = makeShared<MMCZip::ExportToZipTask>(output, gameRoot, files, "overrides/", true);
+    auto zipTask = makeShared<MMCZip::ExportToZipTask>(output, gameRoot, files, "overrides/", true, false);
    zipTask->addExtraFile("manifest.json", generateIndex());
    zipTask->addExtraFile("modlist.html", generateHTML());

@ -393,16 +394,16 @@ QByteArray FlamePackExportTask::generateIndex()
            version["version"] = minecraft->m_version;
        QString id;
        if (quilt != nullptr)
-            id = "quilt-" + quilt->getVersion();
+            id = "quilt-" + quilt->m_version;
        else if (fabric != nullptr)
-            id = "fabric-" + fabric->getVersion();
+            id = "fabric-" + fabric->m_version;
        else if (forge != nullptr)
-            id = "forge-" + forge->getVersion();
+            id = "forge-" + forge->m_version;
        else if (neoforge != nullptr) {
            id = "neoforge-";
            if (minecraft->m_version == "1.20.1")
                id += "1.20.1-";
-            id += neoforge->getVersion();
+            id += neoforge->m_version;
        }
        version["modLoaders"] = QJsonArray();
        if (!id.isEmpty()) {
--- a/launcher/modplatform/helpers/NetworkResourceAPI.cpp
+++ b/launcher/modplatform/helpers/NetworkResourceAPI.cpp
@ -45,8 +45,8 @@ Task::Ptr NetworkResourceAPI::searchProjects(SearchArgs&& args, SearchCallbacks&

    QObject::connect(netJob.get(), &NetJob::failed, [netJob, callbacks](const QString& reason) {
        int network_error_code = -1;
-        if (auto* failed_action = netJob->getFailedActions().at(0); failed_action && failed_action->m_reply)
-            network_error_code = failed_action->m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+        if (auto* failed_action = netJob->getFailedActions().at(0); failed_action)
+            network_error_code = failed_action->replyStatusCode();

        callbacks.on_fail(reason, network_error_code);
    });
@ -104,8 +104,8 @@ Task::Ptr NetworkResourceAPI::getProjectVersions(VersionSearchArgs&& args, Versi
    });
    QObject::connect(netJob.get(), &NetJob::failed, [netJob, callbacks](const QString& reason) {
        int network_error_code = -1;
-        if (auto* failed_action = netJob->getFailedActions().at(0); failed_action && failed_action->m_reply)
-            network_error_code = failed_action->m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+        if (auto* failed_action = netJob->getFailedActions().at(0); failed_action)
+            network_error_code = failed_action->replyStatusCode();

        callbacks.on_fail(reason, network_error_code);
    });
@ -155,8 +155,8 @@ Task::Ptr NetworkResourceAPI::getDependencyVersion(DependencySearchArgs&& args,
    });
    QObject::connect(netJob.get(), &NetJob::failed, [netJob, callbacks](const QString& reason) {
        int network_error_code = -1;
-        if (auto* failed_action = netJob->getFailedActions().at(0); failed_action && failed_action->m_reply)
-            network_error_code = failed_action->m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+        if (auto* failed_action = netJob->getFailedActions().at(0); failed_action)
+            network_error_code = failed_action->replyStatusCode();

        callbacks.on_fail(reason, network_error_code);
    });
--- a/launcher/modplatform/import_ftb/PackHelpers.cpp
+++ b/launcher/modplatform/import_ftb/PackHelpers.cpp
@ -43,6 +43,7 @@ Modpack parseDirectory(QString path)
        modpack.version = Json::requireString(root, "version", "version");
        modpack.mcVersion = Json::requireString(root, "mcVersion", "mcVersion");
        modpack.jvmArgs = Json::ensureVariant(root, "jvmArgs", {}, "jvmArgs");
+        modpack.totalPlayTime = Json::requireInteger(root, "totalPlayTime", "totalPlayTime");
    } catch (const Exception& e) {
        qDebug() << "Couldn't load ftb instance json: " << e.cause();
        return {};
--- a/launcher/modplatform/import_ftb/PackHelpers.h
+++ b/launcher/modplatform/import_ftb/PackHelpers.h
@ -36,6 +36,7 @@ struct Modpack {
    QString name;
    QString version;
    QString mcVersion;
+    int totalPlayTime;
    // not needed for instance creation
    QVariant jvmArgs;

--- a/launcher/modplatform/import_ftb/PackInstallTask.cpp
+++ b/launcher/modplatform/import_ftb/PackInstallTask.cpp
@ -55,6 +55,7 @@ void PackInstallTask::copySettings()
    instanceSettings->suspendSave();
    MinecraftInstance instance(m_globalSettings, instanceSettings, m_stagingPath);
    instance.settings()->set("InstanceType", "OneSix");
+    instance.settings()->set("totalTimePlayed", m_pack.totalPlayTime / 1000);

    if (m_pack.jvmArgs.isValid() && !m_pack.jvmArgs.toString().isEmpty()) {
        instance.settings()->set("OverrideJavaArgs", true);
--- a/launcher/modplatform/modrinth/ModrinthInstanceCreationTask.cpp
+++ b/launcher/modplatform/modrinth/ModrinthInstanceCreationTask.cpp
@ -20,6 +20,7 @@
 #include "ui/pages/modplatform/OptionalModDialog.h"

 #include <QAbstractButton>
+#include <QFileInfo>
 #include <vector>

 bool ModrinthCreationTask::abort()
@ -58,6 +59,7 @@ bool ModrinthCreationTask::updateInstance()
        return false;

    auto version_name = inst->getManagedPackVersionName();
+    m_root_path = QFileInfo(inst->gameRoot()).fileName();
    auto version_str = !version_name.isEmpty() ? tr(" (version %1)").arg(version_name) : "";

    if (shouldConfirmUpdate()) {
@ -173,7 +175,7 @@ bool ModrinthCreationTask::createInstance()
    FS::ensureFilePathExists(new_index_place);
    QFile::rename(index_path, new_index_place);

-    auto mcPath = FS::PathCombine(m_stagingPath, "minecraft");
+    auto mcPath = FS::PathCombine(m_stagingPath, m_root_path);

    auto override_path = FS::PathCombine(m_stagingPath, "overrides");
    if (QFile::exists(override_path)) {
@ -234,15 +236,19 @@ bool ModrinthCreationTask::createInstance()

    m_files_job.reset(new NetJob(tr("Mod Download Modrinth"), APPLICATION->network()));

-    auto root_modpack_path = FS::PathCombine(m_stagingPath, "minecraft");
+    auto root_modpack_path = FS::PathCombine(m_stagingPath, m_root_path);
    auto root_modpack_url = QUrl::fromLocalFile(root_modpack_path);

    for (auto file : m_files) {
-        auto file_path = FS::PathCombine(root_modpack_path, file.path);
+        auto fileName = file.path;
+#ifdef Q_OS_WIN
+        fileName = FS::RemoveInvalidPathChars(fileName);
+#endif
+        auto file_path = FS::PathCombine(root_modpack_path, fileName);
        if (!root_modpack_url.isParentOf(QUrl::fromLocalFile(file_path))) {
            // This means we somehow got out of the root folder, so abort here to prevent exploits
            setError(tr("One of the files has a path that leads to an arbitrary location (%1). This is a security risk and isn't allowed.")
-                         .arg(file.path));
+                         .arg(fileName));
            return false;
        }

@ -255,7 +261,7 @@ bool ModrinthCreationTask::createInstance()
            // FIXME: This really needs to be put into a ConcurrentTask of
            // MultipleOptionsTask's , once those exist :)
            auto param = dl.toWeakRef();
-            connect(dl.get(), &NetAction::failed, [this, &file, file_path, param] {
+            connect(dl.get(), &Task::failed, [this, &file, file_path, param] {
                auto ndl = Net::ApiDownload::makeFile(file.downloads.dequeue(), file_path);
                ndl->addValidator(new Net::ChecksumValidator(file.hashAlgorithm, file.hash));
                m_files_job->addNetAction(ndl);
--- a/launcher/modplatform/modrinth/ModrinthInstanceCreationTask.h
+++ b/launcher/modplatform/modrinth/ModrinthInstanceCreationTask.h
@ -46,4 +46,6 @@ class ModrinthCreationTask final : public InstanceCreationTask {
    NetJob::Ptr m_files_job;

    std::optional<InstancePtr> m_instance;
+
+    QString m_root_path = "minecraft";
 };
--- a/launcher/modplatform/modrinth/ModrinthPackExportTask.cpp
+++ b/launcher/modplatform/modrinth/ModrinthPackExportTask.cpp
@ -200,7 +200,7 @@ void ModrinthPackExportTask::buildZip()
 {
    setStatus(tr("Adding files..."));

-    auto zipTask = makeShared<MMCZip::ExportToZipTask>(output, gameRoot, files, "overrides/", true);
+    auto zipTask = makeShared<MMCZip::ExportToZipTask>(output, gameRoot, files, "overrides/", true, true);
    zipTask->addExtraFile("modrinth.index.json", generateIndex());

    zipTask->setExcludeFiles(resolvedFiles.keys());
--- a/launcher/modplatform/modrinth/ModrinthPackIndex.cpp
+++ b/launcher/modplatform/modrinth/ModrinthPackIndex.cpp
@ -17,6 +17,7 @@
 */

 #include "ModrinthPackIndex.h"
+#include "FileSystem.h"
 #include "ModrinthAPI.h"

 #include "Json.h"
@ -226,6 +227,9 @@ auto Modrinth::loadIndexedPackVersion(QJsonObject& obj, QString preferred_hash_t
    if (parent.contains("url")) {
        file.downloadUrl = Json::requireString(parent, "url");
        file.fileName = Json::requireString(parent, "filename");
+#ifdef Q_OS_WIN
+        file.fileName = FS::RemoveInvalidPathChars(file.fileName);
+#endif
        file.is_preferred = Json::requireBoolean(parent, "primary") || (files.count() == 1);
        auto hash_list = Json::requireObject(parent, "hashes");

--- a/launcher/modplatform/technic/TechnicPackProcessor.cpp
+++ b/launcher/modplatform/technic/TechnicPackProcessor.cpp
@ -155,8 +155,26 @@ void Technic::TechnicPackProcessor::run(SettingsObjectPtr globalSettings,
            auto libraryObject = Json::ensureObject(library, {}, "");
            auto libraryName = Json::ensureString(libraryObject, "name", "", "");

-            if ((libraryName.startsWith("net.minecraftforge:forge:") || libraryName.startsWith("net.minecraftforge:fmlloader:")) &&
-                libraryName.contains('-')) {
+            if (libraryName.startsWith("net.neoforged.fancymodloader:")) {  // it is neoforge
+                // no easy way to get the version from the libs so use the arguments
+                auto arguments = Json::ensureObject(root, "arguments", {});
+                bool isVersionArg = false;
+                QString neoforgeVersion;
+                for (auto arg : Json::ensureArray(arguments, "game", {})) {
+                    auto argument = Json::ensureString(arg, "");
+                    if (isVersionArg) {
+                        neoforgeVersion = argument;
+                        break;
+                    } else {
+                        isVersionArg = "--fml.neoForgeVersion" == argument || "--fml.forgeVersion" == argument;
+                    }
+                }
+                if (!neoforgeVersion.isEmpty()) {
+                    components->setComponentVersion("net.neoforged", neoforgeVersion);
+                }
+                break;
+            } else if ((libraryName.startsWith("net.minecraftforge:forge:") || libraryName.startsWith("net.minecraftforge:fmlloader:")) &&
+                       libraryName.contains('-')) {
                QString libraryVersion = libraryName.section(':', 2);
                if (!libraryVersion.startsWith("1.7.10-")) {
                    components->setComponentVersion("net.minecraftforge", libraryName.section('-', 1));
@ -164,6 +182,7 @@ void Technic::TechnicPackProcessor::run(SettingsObjectPtr globalSettings,
                    // 1.7.10 versions sometimes look like 1.7.10-10.13.4.1614-1.7.10, this filters out the 10.13.4.1614 part
                    components->setComponentVersion("net.minecraftforge", libraryName.section('-', 1, 1));
                }
+                break;
            } else {
                // <Technic library name prefix> -> <our component name>
                static QMap<QString, QString> loaderMap{ { "net.minecraftforge:minecraftforge:", "net.minecraftforge" },
--- a/launcher/net/ApiDownload.cpp
+++ b/launcher/net/ApiDownload.cpp
@ -21,7 +21,6 @@
 #include "ByteArraySink.h"
 #include "ChecksumValidator.h"
 #include "MetaCacheSink.h"
-#include "net/NetAction.h"

 namespace Net {

--- a/launcher/net/ApiUpload.cpp
+++ b/launcher/net/ApiUpload.cpp
@ -19,9 +19,6 @@

 #include "net/ApiUpload.h"
 #include "ByteArraySink.h"
-#include "ChecksumValidator.h"
-#include "MetaCacheSink.h"
-#include "net/NetAction.h"

 namespace Net {

--- a/Show More
+++ b/Show More