Better logging WIP

2021-05-11 14:44:02 +02:00
80 changed files with 21828 additions and 29042 deletions
--- a/.github/release.yaml
+++ b/.github/release.yaml
@@ -1,109 +0,0 @@
-name: Create Release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  draft_release:
-    name: Create Release
-    runs-on: ubuntu-latest
-    outputs:
-      upload_url: ${{ steps.create_release.outputs.upload_url }}
-
-    steps:
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          body: |
-            Changes in this Release
-            - First Change
-            - Second Change
-          draft: true
-          prerelease: false
-
-  release-mac:
-    name: Create Release for macOS
-    needs: draft_release
-    runs-on: ${{ matrix.os }}
-    env:
-      MACOSX_DEPLOYMENT_TARGET: 10.13
-    strategy:
-      matrix:
-        os:
-          - macOS-10.15
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-
-      - uses: haskell/actions/setup@v1.2
-        with:
-          ghc-version: 8.10.4
-          cabal-version: 3.4.0.0
-
-      - name: create ~/.local/bin
-        run: mkdir -p "$HOME/.local/bin"
-        shell: bash
-
-      - name: Add ~/.local/bin to PATH
-        run: echo "$HOME/.local/bin" >> $GITHUB_PATH
-        shell: bash
-
-      - name: Update cabal cache
-        run: cabal update
-        shell: bash
-
-      - name: Install cabal dependencies
-        run: cabal build --only-dependencies
-        shell: bash
-
-      - name: Build
-        run: cabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
-        shell: bash
-
-      - name: Install
-        run: cp "$(cabal list-bin exe:ghcup)" ~/.local/bin/ghcup
-        shell: bash
-
-      - name: Strip
-        run: strip ~/.local/bin/ghcup
-        shell: bash
-
-      - name: Run tests
-        run: cabal test --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" all
-        shell: bash
-
-      - name: Install git
-        run: brew install git
-
-      - name: set HOME
-        run: echo "HOME=$HOME" >> $GITHUB_ENV
-        shell: bash
-
-      - name: Set ASSET_PATH
-        run: echo "ASSET_PATH=$HOME/.local/bin/ghcup" >> $GITHUB_ENV
-        shell: bash
-
-      - name: Upload Release Asset
-        id: upload-release-asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.draft_release.outputs.upload_url }}
-          asset_path: ${{ env.ASSET_PATH }}
-          asset_name: ghcup-${{ matrix.os }}
-          asset_content_type: application/octet-stream
-
-      - if: always()
-        uses: actions/upload-artifact@v2
-        with:
-          name: plan.json
-          path: ./dist-newstyle/cache/plan.json
-
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -1,109 +0,0 @@
-name: Create Release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  draft_release:
-    name: Draft Release
-    runs-on: ubuntu-latest
-    outputs:
-      upload_url: ${{ steps.create_release.outputs.upload_url }}
-
-    steps:
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          body: |
-            Changes in this Release
-            - First Change
-            - Second Change
-          draft: true
-          prerelease: false
-
-  release-mac:
-    name: Create Release
-    needs: draft_release
-    runs-on: ${{ matrix.os }}
-    env:
-      MACOSX_DEPLOYMENT_TARGET: 10.13
-    strategy:
-      matrix:
-        os:
-          - macOS-10.15
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-
-      - uses: haskell/actions/setup@v1.2
-        with:
-          ghc-version: 8.10.4
-          cabal-version: 3.4.0.0
-
-      - name: create ~/.local/bin
-        run: mkdir -p "$HOME/.local/bin"
-        shell: bash
-
-      - name: Add ~/.local/bin to PATH
-        run: echo "$HOME/.local/bin" >> $GITHUB_PATH
-        shell: bash
-
-      - name: Update cabal cache
-        run: cabal update
-        shell: bash
-
-      - name: Install cabal dependencies
-        run: cabal build --only-dependencies --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
-        shell: bash
-
-      - name: Build
-        run: cabal build --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
-        shell: bash
-
-      - name: Install
-        run: cp "$(cabal list-bin exe:ghcup)" ~/.local/bin/ghcup
-        shell: bash
-
-      - name: Strip
-        run: strip ~/.local/bin/ghcup
-        shell: bash
-
-      - name: Run tests
-        run: cabal test --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" all
-        shell: bash
-
-      - name: Install git
-        run: brew install git
-
-      - name: set HOME
-        run: echo "HOME=$HOME" >> $GITHUB_ENV
-        shell: bash
-
-      - name: Set ASSET_PATH
-        run: echo "ASSET_PATH=$HOME/.local/bin/ghcup" >> $GITHUB_ENV
-        shell: bash
-
-      - name: Upload Release Asset
-        id: upload-release-asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.draft_release.outputs.upload_url }}
-          asset_path: ${{ env.ASSET_PATH }}
-          asset_name: ghcup-${{ matrix.os }}
-          asset_content_type: application/octet-stream
-
-      - if: always()
-        uses: actions/upload-artifact@v2
-        with:
-          name: plan.json
-          path: ./dist-newstyle/cache/plan.json
-
--- a/.github/workflows/shimgen.yaml
+++ b/.github/workflows/shimgen.yaml
@@ -1,29 +0,0 @@
-name: Shimgen CI
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build-shimgen:
-
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [windows-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - uses: ilammy/msvc-dev-cmd@v1
-
-    - name: compile
-      run: cl /O1 scoop-better-shimexe/shim.c
-
-    - uses: actions/upload-artifact@v2
-      with:
-        name: shim.exe
-        path: shim.exe
-
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -7,7 +7,7 @@ variables:
  GIT_SSL_NO_VERIFY: "1"

  # Commit of ghc/ci-images repository from which to pull Docker images
-  DOCKER_REV: 8d0224e6b2a08157649651e69302380b2bd24e11
+  DOCKER_REV: 1ac7f435c9312f10422a82d304194778378e2a1a

 ############################################################
 # CI Step
@@ -20,8 +20,6 @@ variables:
  variables:
    OS: "LINUX"
    ARCH: "64"
-    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
-    CROSS: ""

 .alpine:64bit:
  image: "alpine:3.12"
@@ -30,7 +28,6 @@ variables:
  variables:
    OS: "LINUX"
    ARCH: "64"
-    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .alpine:32bit:
  image: "i386/alpine:3.12"
@@ -39,25 +36,22 @@ variables:
  variables:
    OS: "LINUX"
    ARCH: "32"
-    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .linux:armv7:
-  image: "registry.gitlab.haskell.org/ghc/ci-images/armv7-linux-deb10:$DOCKER_REV"
+  image: "arm32v7/fedora"
  tags:
    - armv7-linux
  variables:
    OS: "LINUX"
    ARCH: "ARM"
-    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .linux:aarch64:
-  image: "registry.gitlab.haskell.org/ghc/ci-images/aarch64-linux-deb10:$DOCKER_REV"
+  image: "arm64v8/fedora"
  tags:
    - aarch64-linux
  variables:
    OS: "LINUX"
    ARCH: "ARM64"
-    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .darwin:
  tags:
@@ -65,15 +59,6 @@ variables:
  variables:
    OS: "DARWIN"
    ARCH: "64"
-    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
-
-.darwin:aarch64:
-  tags:
-    - aarch64-darwin-m1
-  variables:
-    OS: "DARWIN"
-    ARCH: "ARM64"
-    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .freebsd:
  tags:
@@ -81,36 +66,28 @@ variables:
  variables:
    OS: "FREEBSD"
    ARCH: "64"
-    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
-
-.windows:
-  tags:
-    - new-x86_64-windows
-  variables:
-    OS: "WINDOWS"
-    ARCH: "64"
-    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .root_cleanup:
  after_script:
-    - bash ./.gitlab/after_script.sh
+    - BUILD_DIR=$CI_PROJECT_DIR
+    - echo "Cleaning $BUILD_DIR"
+    - cd $HOME
+    - test -n "$BUILD_DIR"
+    - shopt -s extglob
+    - rm -Rf "$BUILD_DIR"/!(out)
+    - exit 0

 .test_ghcup_version:
  script:
-    - bash ./.gitlab/script/ghcup_version.sh
+    - ./.gitlab/script/ghcup_version.sh
  variables:
-    JSON_VERSION: "0.0.6"
+    JSON_VERSION: "0.0.4"
  artifacts:
    expire_in: 2 week
    paths:
      - golden
-      - dist-newstyle/cache/
    when: on_failure

-# .test_ghcup_scoop:
-  # script:
-    # - cl /O1 scoop-better-shimexe/shim.c
-
 .test_ghcup_version:linux:
  extends:
    - .test_ghcup_version
@@ -130,14 +107,14 @@ variables:
    - .test_ghcup_version
    - .linux:armv7
  before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
+    - ./.gitlab/before_script/linux/install_deps_manual.sh

 .test_ghcup_version:aarch64:
  extends:
    - .test_ghcup_version
    - .linux:aarch64
  before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
+    - ./.gitlab/before_script/linux/install_deps_manual.sh

 .test_ghcup_version:darwin:
  extends:
@@ -147,32 +124,6 @@ variables:
  before_script:
    - ./.gitlab/before_script/darwin/install_deps.sh

-.test_ghcup_version:darwin:aarch64:
-  extends:
-    - .test_ghcup_version
-    - .darwin:aarch64
-    - .root_cleanup
-  script: |
-    set -Eeuo pipefail
-    function runInNixShell() {
-      time nix-shell $CI_PROJECT_DIR/.gitlab/shell.nix \
-        -I nixpkgs=https://github.com/angerman/nixpkgs/archive/75f7281738b.tar.gz \
-        --argstr system "aarch64-darwin" \
-        --pure \
-        --keep CI_PROJECT_DIR \
-        --keep MACOSX_DEPLOYMENT_TARGET \
-        --keep JSON_VERSION \
-        --keep ARTIFACT \
-        --keep OS \
-        --keep ARCH \
-        --keep CABAL_DIR \
-        --keep GHC_VERSION \
-        --keep CABAL_VERSION \
-        --run "$1" 2>&1
-    }
-    runInNixShell ./.gitlab/before_script/darwin/install_deps.sh 2>&1
-    runInNixShell ./.gitlab/script/ghcup_version.sh 2>&1
-
 .test_ghcup_version:freebsd:
  extends:
    - .test_ghcup_version
@@ -181,33 +132,17 @@ variables:
  before_script:
    - ./.gitlab/before_script/freebsd/install_deps.sh

-.test_ghcup_version:windows:
-  extends:
-    - .test_ghcup_version
-    - .windows
-    - .root_cleanup
-  before_script:
-    - set CABAL_DIR="$CI_PROJECT_DIR/cabal"
-    - bash ./.gitlab/before_script/windows/install_deps.sh
-
-# .test_ghcup_scoop:windows:
-  # extends:
-    # - .windows
-    # - .test_ghcup_scoop
-    # - .root_cleanup
-
 .release_ghcup:
  script:
-    - bash ./.gitlab/script/ghcup_release.sh
+    - ./.gitlab/script/ghcup_release.sh
  artifacts:
    expire_in: 2 week
    paths:
      - out
-      - dist-newstyle/cache/
  only:
    - tags
  variables:
-    JSON_VERSION: "0.0.6"
+    JSON_VERSION: "0.0.4"

 ######## stack test ########

@@ -230,27 +165,10 @@ test:linux:bootstrap_script:
  script:
    - ./.gitlab/script/ghcup_bootstrap.sh
  variables:
-    GHC_VERSION: "8.10.5"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
  extends:
    - .debian
-    - .root_cleanup
-  needs: []
-
-test:windows:bootstrap_powershell_script:
-  stage: test
-  script:
-    - ./bootstrap-haskell.ps1 -InstallDir $CI_PROJECT_DIR -BootstrapUrl $CI_PROJECT_DIR/bootstrap-haskell -InBash
-  after_script:
-    - "[Environment]::SetEnvironmentVariable('GHCUP_INSTALL_BASE_PREFIX', $null, [System.EnvironmentVariableTarget]::User)"
-    - "[Environment]::SetEnvironmentVariable('GHCUP_MSYS2', $null, [System.EnvironmentVariableTarget]::User)"
-    - "[Environment]::SetEnvironmentVariable('CABAL_DIR', $null, [System.EnvironmentVariableTarget]::User)"
-    - bash ./.gitlab/after_script.sh
-  variables:
-    GHC_VERSION: "8.10.5"
-    CABAL_VERSION: "3.4.0.0"
-  extends:
-    - .windows
  needs: []

 ######## linux test ########
@@ -259,55 +177,17 @@ test:linux:recommended:
  stage: test
  extends: .test_ghcup_version:linux
  variables:
-    GHC_VERSION: "8.10.5"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
  needs: []

 test:linux:latest:
  stage: test
  extends: .test_ghcup_version:linux
-  variables:
-    GHC_VERSION: "9.0.1"
-    CABAL_VERSION: "3.4.0.0"
-  needs: []
-
-test:linux:cross-armv7:
-  stage: test
-  extends:
-    - .test_ghcup_version
-    - .debian
  variables:
    GHC_VERSION: "8.10.4"
-    GHC_TARGET_VERSION: "8.10.5"
    CABAL_VERSION: "3.4.0.0"
-    CROSS: "arm-linux-gnueabihf"
  needs: []
-  when: manual
-  allow_failure: true
-  before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
-  script:
-    - ./.gitlab/script/ghcup_cross.sh
-
-test:linux:git:hadrian:
-  stage: test
-  extends:
-    - .test_ghcup_version
-    - .debian
-  variables:
-    GHC_VERSION: "8.10.5"
-    GHC_GIT_TAG: "ghc-9.0.1-release"
-    GHC_GIT_VERSION: "9.0.1"
-    CABAL_VERSION: "3.4.0.0"
-    CROSS: ""
-  needs: []
-  when: manual
-  allow_failure: true
-  before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
-  script:
-    - ./.gitlab/script/ghcup_git.sh
-

 ######## linux 32bit test ########

@@ -315,7 +195,7 @@ test:linux:recommended:32bit:
  stage: test
  extends: .test_ghcup_version:linux32
  variables:
-    GHC_VERSION: "8.10.5"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.2.0.0"
  needs: []

@@ -327,7 +207,6 @@ test:linux:recommended:armv7:
  variables:
    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
-    CROSS: ""
  when: manual
  needs: []

@@ -337,7 +216,6 @@ test:linux:recommended:aarch64:
  variables:
    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
-    CROSS: ""
  when: manual
  needs: []

@@ -355,19 +233,10 @@ test:mac:latest:
  stage: test
  extends: .test_ghcup_version:darwin
  variables:
-    GHC_VERSION: "9.0.1"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
  needs: []

-test:mac:recommended:aarch64:
-  stage: test
-  extends: .test_ghcup_version:darwin:aarch64
-  variables:
-    GHC_VERSION: "8.10.5"
-    CABAL_VERSION: "3.4.0.0"
-  needs: []
-  allow_failure: true
-

 ######## freebsd test ########

@@ -381,20 +250,16 @@ test:freebsd:recommended:
  when: manual
  needs: []

-######## windows test ########
-
-test:windows:recommended:
+test:freebsd:latest:
  stage: test
-  extends: .test_ghcup_version:windows
+  extends: .test_ghcup_version:freebsd
  variables:
-    GHC_VERSION: "8.10.5"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
+  allow_failure: true # freebsd runners are unreliable
+  when: manual
  needs: []

-# test:windows:scoop:
-  # stage: test
-  # extends: .test_ghcup_scoop:windows
-  # needs: []

 ######## linux release ########

@@ -408,7 +273,7 @@ release:linux:64bit:
    - ./.gitlab/before_script/linux/alpine/install_deps.sh
  variables:
    ARTIFACT: "x86_64-linux-ghcup"
-    GHC_VERSION: "8.10.5"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"


@@ -422,7 +287,7 @@ release:linux:32bit:
    - ./.gitlab/before_script/linux/alpine/install_deps.sh
  variables:
    ARTIFACT: "i386-linux-ghcup"
-    GHC_VERSION: "8.10.5"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.2.0.0"

 release:linux:armv7:
@@ -432,12 +297,11 @@ release:linux:armv7:
    - .linux:armv7
    - .release_ghcup
  before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
  variables:
    ARTIFACT: "armv7-linux-ghcup"
    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
-    CROSS: ""

 release:linux:aarch64:
  stage: release
@@ -446,12 +310,11 @@ release:linux:aarch64:
    - .linux:aarch64
    - .release_ghcup
  before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
  variables:
    ARTIFACT: "aarch64-linux-ghcup"
    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
-    CROSS: ""

 ######## darwin release ########

@@ -466,50 +329,16 @@ release:darwin:
    - ./.gitlab/before_script/darwin/install_deps.sh
  variables:
    ARTIFACT: "x86_64-apple-darwin-ghcup"
-    GHC_VERSION: "8.10.5"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
    MACOSX_DEPLOYMENT_TARGET: "10.7"

-release:darwin:aarch64:
-  stage: release
-  needs: ["test:mac:recommended:aarch64"]
-  extends:
-    - .darwin:aarch64
-    - .release_ghcup
-    - .root_cleanup
-  script: |
-    set -Eeuo pipefail
-    function runInNixShell() {
-      time nix-shell $CI_PROJECT_DIR/.gitlab/shell.nix \
-        -I nixpkgs=https://github.com/angerman/nixpkgs/archive/75f7281738b.tar.gz \
-        --argstr system "aarch64-darwin" \
-        --pure \
-        --keep CI_PROJECT_DIR \
-        --keep MACOSX_DEPLOYMENT_TARGET \
-        --keep JSON_VERSION \
-        --keep ARTIFACT \
-        --keep OS \
-        --keep ARCH \
-        --keep CABAL_DIR \
-        --keep GHC_VERSION \
-        --keep CABAL_VERSION \
-        --run "$1" 2>&1
-    }
-    runInNixShell ./.gitlab/before_script/darwin/install_deps.sh 2>&1
-    runInNixShell ./.gitlab/script/ghcup_release.sh 2>&1
-  variables:
-    ARTIFACT: "aarch64-apple-darwin-ghcup"
-    GHC_VERSION: "8.10.5"
-    CABAL_VERSION: "3.4.0.0"
-    MACOSX_DEPLOYMENT_TARGET: "10.7"
-  allow_failure: true
-

 ######## freebsd release ########

 release:freebsd:
  stage: release
-  needs: ["test:freebsd:recommended"]
+  needs: ["test:freebsd:recommended", "test:freebsd:latest"]
  extends:
    - .freebsd
    - .release_ghcup
@@ -518,25 +347,9 @@ release:freebsd:
    - ./.gitlab/before_script/freebsd/install_deps.sh
  variables:
    ARTIFACT: "x86_64-portbld-freebsd-ghcup"
-    GHC_VERSION: "8.10.5"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
-  allow_failure: true

-######## windows release ########
-
-release:windows:
-  stage: release
-  needs: ["test:windows:recommended"]
-  extends:
-    - .windows
-    - .release_ghcup
-    - .root_cleanup
-  before_script:
-    - bash ./.gitlab/before_script/windows/install_deps.sh
-  variables:
-    ARTIFACT: "x86_64-mingw64-ghcup"
-    GHC_VERSION: "8.10.5"
-    CABAL_VERSION: "3.4.0.0"

 ######## hlint ########

@@ -549,7 +362,7 @@ hlint:
  script:
    - ./.gitlab/script/hlint.sh
  variables:
-    GHC_VERSION: "8.10.5"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
    JSON_VERSION: "0.0.4"
  allow_failure: true
--- a/.gitlab/after_script.sh
+++ b/.gitlab/after_script.sh
@@ -1,15 +0,0 @@
-#!/bin/sh
-
-set -eux
-
-BUILD_DIR=$CI_PROJECT_DIR
-echo "Cleaning $BUILD_DIR"
-cd $HOME
-test -n "$BUILD_DIR"
-shopt -s extglob
-rm -Rf "$BUILD_DIR"/!(out)
-if [ "${OS}" = "WINDOWS" ] ; then
-	rm -Rf /c/ghcup
-fi
-
-exit 0
--- a/.gitlab/before_script/darwin/install_deps.sh
+++ b/.gitlab/before_script/darwin/install_deps.sh
@@ -6,27 +6,12 @@ set -eux

 mkdir -p "${TMPDIR}"

-if [ $ARCH = 'ARM64' ] ; then
-	curl -sSfL https://downloads.haskell.org/~ghcup/0.1.15.1/aarch64-apple-darwin-ghcup-0.1.15.1 > ./ghcup-bin
-	chmod +x ghcup-bin
-else
-	curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup > ./ghcup-bin
-	chmod +x ghcup-bin
-	./ghcup-bin upgrade -i -f
-fi
+curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup > ./ghcup-bin
+chmod +x ghcup-bin

-./ghcup-bin install ${GHC_VERSION}
-./ghcup-bin set ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
-
-if [ $ARCH = 'ARM64' ] ; then
-	cabal update
-	mkdir vendored
-	cd vendored
-	cabal unpack network-3.1.2.1
-	cd network*
-	autoreconf -fi
-	cd ../..
-fi
+./ghcup-bin upgrade -i -f
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}

 exit 0
--- a/.gitlab/before_script/freebsd/install_deps.sh
+++ b/.gitlab/before_script/freebsd/install_deps.sh
@@ -12,8 +12,8 @@ curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-portbld-freebsd-ghcup > .
 chmod +x ghcup-bin

 ./ghcup-bin upgrade -i -f
-./ghcup-bin install ${GHC_VERSION}
-./ghcup-bin set ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}

 exit 0
--- a/.gitlab/before_script/linux/alpine/install_deps.sh
+++ b/.gitlab/before_script/linux/alpine/install_deps.sh
@@ -28,8 +28,8 @@ else
 fi
 chmod +x ghcup-bin
 ./ghcup-bin upgrade -i -f
-./ghcup-bin install ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}

 # utils
 apk add --no-cache \
@@ -41,9 +41,6 @@ apk add --no-cache \
 	zlib \
 	zlib-dev \
 	zlib-static \
-	bzip2 \
-	bzip2-dev \
-	bzip2-static \
 	gmp \
 	gmp-dev \
 	openssl-dev \
--- a/.gitlab/before_script/linux/install_deps.sh
+++ b/.gitlab/before_script/linux/install_deps.sh
@@ -7,67 +7,13 @@ set -eux
 mkdir -p "${TMPDIR}"

 sudo apt-get update -y
-sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget lsb-release software-properties-common gnupg2 apt-transport-https
+sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev git wget

-if [ "${CROSS}" = "arm-linux-gnueabihf" ] ; then
-	sudo apt-get install -y autoconf build-essential gcc-arm-linux-gnueabihf
-	sudo dpkg --add-architecture armhf
-	sudo apt-get update -y
-	sudo apt-get install -y libncurses-dev:armhf
-fi
+curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup > ./ghcup-bin
+chmod +x ghcup-bin

-case "${ARCH}" in
-	ARM*)
-		case "${ARCH}" in
-			"ARM")
-				ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-armv7-deb10-linux.tar.xz
-				cabal_url=home.smart-cactus.org/~ben/cabal-install-${CABAL_VERSION}-armv7-linux-bootstrapped.tar.xz
-				;;
-			"ARM64")
-				ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-aarch64-deb10-linux.tar.xz
-				cabal_url=https://downloads.haskell.org/~cabal/cabal-install-${CABAL_VERSION}/cabal-install-${CABAL_VERSION}-aarch64-ubuntu-18.04.tar.xz
-				;;
-			*)
-				exit 1 ;;
-		esac
-
-		mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
-
-		curl -O "${ghc_url}"
-		tar -xf ghc-*.tar.*
-		cd ghc-${GHC_VERSION}
-		./configure --prefix="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}
-		make install
-		for i in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}/bin/*-${GHC_VERSION} ; do
-			ln -s "${i}" "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/${i##*/}
-		done
-		for x in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/*-${GHC_VERSION} ; do
-			ln -s ${x##*/} ${x%-${GHC_VERSION}}
-		done
-		cd ..
-		rm -rf ghc-${GHC_VERSION} ghc-*.tar.*
-		unset x i
-
-		mkdir cabal-install
-		cd cabal-install
-		curl -O "${cabal_url}"
-		tar -xf cabal-install-*
-		mv cabal "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/cabal
-		cd ..
-		rm -rf cabal-install
-
-		;;
-	*) 
-		url=https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup
-
-		curl -sSfL "${url}" > ./ghcup-bin
-		chmod +x ghcup-bin
-
-		./ghcup-bin upgrade -i -f
-		./ghcup-bin install ghc ${GHC_VERSION}
-		./ghcup-bin set ghc ${GHC_VERSION}
-		./ghcup-bin install cabal ${CABAL_VERSION}
-
-		;;
-esac
+./ghcup-bin upgrade -i -f
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}

--- a/.gitlab/before_script/linux/install_deps_manual.sh
+++ b/.gitlab/before_script/linux/install_deps_manual.sh
@@ -0,0 +1,64 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+ednf() {
+	case "${ARCH}" in
+		"ARM")
+			sudo dnf -y --forcearch armv7hl "$@"
+			;;
+		"ARM64")
+			sudo dnf -y --forcearch aarch64 "$@"
+			;;
+		*) exit 1 ;;
+	esac
+}
+
+ednf update
+ednf install gcc gcc-c++ gmp gmp-devel make ncurses ncurses-devel xz xz-devel perl zlib zlib-devel openssl-devel openssl-libs openssl libffi libffi-devel lbzip2 lbzip2-utils
+if [ "${ARCH}" = "ARM64" ] ; then
+	ednf install numactl numactl-libs numactl-devel
+fi
+ednf install bash wget curl git tar
+ednf install llvm9.0 llvm9.0-devel llvm9.0-libs llvm9.0-static
+
+case "${ARCH}" in
+	"ARM")
+		ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-armv7-deb10-linux.tar.xz
+		cabal_url=home.smart-cactus.org/~ben/cabal-install-${CABAL_VERSION}-armv7-linux-bootstrapped.tar.xz
+		;;
+	"ARM64")
+		ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-aarch64-deb10-linux.tar.xz
+		cabal_url=https://downloads.haskell.org/~cabal/cabal-install-${CABAL_VERSION}/cabal-install-${CABAL_VERSION}-aarch64-ubuntu-18.04.tar.xz
+		;;
+	*) exit 1 ;;
+esac
+
+mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
+
+curl -O "${ghc_url}"
+tar -xf ghc-*.tar.*
+cd ghc-${GHC_VERSION}
+./configure --prefix="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}
+make install
+for i in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}/bin/*-${GHC_VERSION} ; do
+	ln -s "${i}" "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/${i##*/}
+done
+for x in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/*-${GHC_VERSION} ; do
+	ln -s ${x##*/} ${x%-${GHC_VERSION}}
+done
+cd ..
+rm -rf ghc-${GHC_VERSION} ghc-*.tar.*
+unset x i
+
+mkdir cabal-install
+cd cabal-install
+curl -O "${cabal_url}"
+tar -xf cabal-install-*
+mv cabal "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/cabal
+cd ..
+rm -rf cabal-install
--- a/.gitlab/before_script/linux/install_deps_minimal.sh
+++ b/.gitlab/before_script/linux/install_deps_minimal.sh
@@ -7,4 +7,4 @@ set -eux
 mkdir -p "${TMPDIR}"

 sudo apt-get update -y
-sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget
+sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev git wget
--- a/.gitlab/before_script/windows/install_deps.sh
+++ b/.gitlab/before_script/windows/install_deps.sh
@@ -1,21 +0,0 @@
-#!/bin/sh
-
-set -eux
-
-. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
-
-mkdir -p "${TMPDIR}" "${CABAL_DIR}"
-
-mkdir -p "$GHCUP_INSTALL_BASE_PREFIX/ghcup/bin"
-
-CI_PROJECT_DIR=$(pwd)
-curl -o ghcup.exe https://downloads.haskell.org/~ghcup/0.1.15.1/x86_64-mingw64-ghcup-0.1.15.1.exe
-chmod +x ghcup.exe
-
-./ghcup.exe install ${GHC_VERSION}
-./ghcup.exe set ${GHC_VERSION}
-./ghcup.exe install-cabal ${CABAL_VERSION}
-
-rm ./ghcup.exe
-
-exit 0
--- a/.gitlab/ghcup_env
+++ b/.gitlab/ghcup_env
@@ -1,9 +1,3 @@
-if [ "${OS}" = "WINDOWS" ] ; then
-	export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
-	export PATH="$GHCUP_INSTALL_BASE_PREFIX/ghcup/bin:$CI_PROJECT_DIR/.local/bin:$PATH"
-	export TMPDIR="$CI_PROJECT_DIR/tmp"
-else
-	export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
-	export PATH="$CI_PROJECT_DIR/.ghcup/bin:$CI_PROJECT_DIR/.local/bin:/opt/llvm/bin:$PATH"
-	export TMPDIR="$CI_PROJECT_DIR/tmp"
-fi
+export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
+export PATH="$CI_PROJECT_DIR/.ghcup/bin:$CI_PROJECT_DIR/.local/bin:$PATH"
+export TMPDIR="$CI_PROJECT_DIR/tmp"
--- a/.gitlab/script/ghcup_bootstrap.sh
+++ b/.gitlab/script/ghcup_bootstrap.sh
@@ -7,7 +7,7 @@ set -eux
 mkdir -p "$CI_PROJECT_DIR"/.local/bin

 ecabal() {
-	cabal "$@"
+	cabal --store-dir="$(pwd)"/.store "$@"
 }

 eghcup() {
--- a/.gitlab/script/ghcup_cross.sh
+++ b/.gitlab/script/ghcup_cross.sh
@@ -1,52 +0,0 @@
-#!/bin/sh
-
-set -eux
-
-. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
-
-mkdir -p "$CI_PROJECT_DIR"/.local/bin
-
-CI_PROJECT_DIR=$(pwd)
-
-ecabal() {
-	cabal "$@"
-}
-
-eghcup() {
-	ghcup -v -c -s file://$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
-}
-
-git describe --always
-
-### build
-
-ecabal update
-
-ecabal build -w ghc-${GHC_VERSION}
-cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" "$CI_PROJECT_DIR"/.local/bin/ghcup
-
-### cleanup
-
-rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
-
-### manual cli based testing
-
-eghcup --numeric-version
-
-eghcup install ghc ${GHC_VERSION}
-eghcup set ghc ${GHC_VERSION}
-eghcup install cabal ${CABAL_VERSION}
-
-cabal --version
-
-eghcup debug-info
-
-eghcup compile ghc -j $(nproc) -v ${GHC_TARGET_VERSION} -b ${GHC_VERSION} -x ${CROSS} -- --enable-unregisterised
-eghcup set ghc ${CROSS}-${GHC_TARGET_VERSION}
-
-[ `$(eghcup whereis ghc ${CROSS}-${GHC_TARGET_VERSION}) --numeric-version` = "${GHC_TARGET_VERSION}" ]
-
-# nuke
-eghcup nuke
-[ ! -e "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup" ]
-
--- a/.gitlab/script/ghcup_git.sh
+++ b/.gitlab/script/ghcup_git.sh
@@ -1,52 +0,0 @@
-#!/bin/sh
-
-set -eux
-
-. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
-
-mkdir -p "$CI_PROJECT_DIR"/.local/bin
-
-CI_PROJECT_DIR=$(pwd)
-
-ecabal() {
-	cabal "$@"
-}
-
-eghcup() {
-	ghcup -v -c -s file://$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
-}
-
-git describe --always
-
-### build
-
-ecabal update
-
-ecabal build -w ghc-${GHC_VERSION}
-cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" "$CI_PROJECT_DIR"/.local/bin/ghcup
-
-### cleanup
-
-rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
-
-### manual cli based testing
-
-eghcup --numeric-version
-
-eghcup install ghc ${GHC_VERSION}
-eghcup set ghc ${GHC_VERSION}
-eghcup install cabal ${CABAL_VERSION}
-
-cabal --version
-
-eghcup debug-info
-
-eghcup compile ghc -j $(nproc) -g ${GHC_GIT_TAG} -b ${GHC_VERSION} -- --enable-unregisterised
-eghcup set ghc ${GHC_GIT_VERSION}
-
-[ `$(eghcup whereis ghc ${GHC_GIT_VERSION}) --numeric-version` = "${GHC_GIT_VERSION}" ]
-
-# nuke
-eghcup nuke
-[ ! -e "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup" ]
-
--- a/.gitlab/script/ghcup_release.sh
+++ b/.gitlab/script/ghcup_release.sh
@@ -7,7 +7,7 @@ set -eux
 mkdir -p "$CI_PROJECT_DIR"/.local/bin

 ecabal() {
-	cabal "$@"
+	cabal --store-dir="$(pwd)"/.store "$@"
 }

 git describe
@@ -15,6 +15,10 @@ git describe
 # build
 ecabal update

+(
+	cd /tmp
+	ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hspec-discover
+)

 if [ "${OS}" = "LINUX" ] ; then
 	if [ "${ARCH}" = "32" ] ; then
@@ -25,20 +29,18 @@ if [ "${OS}" = "LINUX" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} -ftui
 	fi
 elif [ "${OS}" = "FREEBSD" ] ; then
-	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib +bundled-c-zlib" --constraint="zip +disable-zstd" -ftui
-elif [ "${OS}" = "WINDOWS" ] ; then
-	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static"
+	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib +bundled-c-zlib" -ftui
 else
 	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
 fi

 mkdir out
-binary=$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')
-ver=$("${binary}" --numeric-version)
+cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" .
+ver=$(./ghcup --numeric-version)
 if [ "${OS}" = "DARWIN" ] ; then
-	strip "${binary}"
+	strip ./ghcup
 else
-	strip -s "${binary}"
+	strip -s ./ghcup
 fi
-cp "${binary}" out/${ARTIFACT}-${ver}
+cp ghcup out/${ARTIFACT}-${ver}

--- a/.gitlab/script/ghcup_version.sh
+++ b/.gitlab/script/ghcup_version.sh
@@ -6,76 +6,53 @@ set -eux

 mkdir -p "$CI_PROJECT_DIR"/.local/bin

-CI_PROJECT_DIR=$(pwd)
-
 ecabal() {
-	cabal "$@"
-}
-
-raw_eghcup() {
-	ghcup -v -c "$@"
+	cabal --store-dir="$(pwd)"/.store "$@"
 }

 eghcup() {
-	if [ "${OS}" = "WINDOWS" ] ; then
-		ghcup -v -c -s file:/$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
-	else
-		ghcup -v -c -s file://$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
-	fi
+	ghcup -v -c -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml "$@"
 }

-if [ "${OS}" = "WINDOWS" ] ; then
-	GHCUP_DIR="${GHCUP_INSTALL_BASE_PREFIX}"/ghcup
-else
-	GHCUP_DIR="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
-fi
-
 git describe --always

 ### build

 ecabal update

+(
+	cd /tmp
+	ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hspec-discover
+)
+
 if [ "${OS}" = "DARWIN" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} -ftui
 	ecabal test -w ghc-${GHC_VERSION} -ftui ghcup-test
-	ecabal haddock -w ghc-${GHC_VERSION} -ftui
 elif [ "${OS}" = "LINUX" ] ; then
 	if [ "${ARCH}" = "32" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
 		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar ghcup-test
-		ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
 	else
 		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
 		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
-		ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui
 	fi
-elif [ "${OS}" = "FREEBSD" ] ; then
-	ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui --constraint="zip +disable-zstd"
-	ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui --constraint="zip +disable-zstd" ghcup-test
-	ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui --constraint="zip +disable-zstd"
-elif [ "${OS}" = "WINDOWS" ] ; then
-	ecabal build -w ghc-${GHC_VERSION}
-	ecabal test -w ghc-${GHC_VERSION} ghcup-test
-	ecabal haddock -w ghc-${GHC_VERSION}
 else
 	ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
 	ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
-	ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui
 fi

+ecabal haddock -w ghc-${GHC_VERSION} -ftar

-if [ "${OS}" = "WINDOWS" ] ; then
-	ext=".exe"
-else
-	ext=''
-fi
-	cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" "$CI_PROJECT_DIR"/.local/bin/ghcup${ext}
-	cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup-gen')" "$CI_PROJECT_DIR"/.local/bin/ghcup-gen${ext}
+cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" .
+cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup-gen')" .
+
+cp ./ghcup "$CI_PROJECT_DIR"/.local/bin/ghcup
+cp ./ghcup-gen "$CI_PROJECT_DIR"/.local/bin/ghcup-gen

 ### cleanup

-rm -rf "${GHCUP_DIR}"
+rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
+

 ### manual cli based testing

@@ -84,123 +61,59 @@ ghcup-gen check -f ghcup-${JSON_VERSION}.yaml

 eghcup --numeric-version

-eghcup install ghc ${GHC_VERSION}
-[ `$(eghcup whereis ghc ${GHC_VERSION}) --numeric-version` = "${GHC_VERSION}" ]
-eghcup set ghc ${GHC_VERSION}
-eghcup install cabal ${CABAL_VERSION}
-[ `$(eghcup whereis cabal ${CABAL_VERSION}) --numeric-version` = "${CABAL_VERSION}" ]
+eghcup install ${GHC_VERSION}
+eghcup set ${GHC_VERSION}
+eghcup install-cabal ${CABAL_VERSION}

 cabal --version

 eghcup debug-info

-# also test etags
 eghcup list
 eghcup list -t ghc
 eghcup list -t cabal

 ghc_ver=$(ghc --numeric-version)
 ghc --version
-ghc-${ghc_ver} --version
-if [ "${OS}" != "WINDOWS" ] ; then
-		ghci --version
-		ghci-${ghc_ver} --version
+ghci --version
+ghc-$(ghc --numeric-version) --version
+ghci-$(ghc --numeric-version) --version
+
+
+# test installing new ghc doesn't mess with currently set GHC
+# https://gitlab.haskell.org/haskell/ghcup-hs/issues/7
+if [ "${OS}" = "LINUX" ] ; then
+	eghcup --downloader=wget install 8.10.3
+else # test wget a bit
+	eghcup install 8.10.3
 fi
+[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
+eghcup set 8.10.3
+eghcup set 8.10.3
+[ "$(ghc --numeric-version)" = "8.10.3" ]
+eghcup set ${GHC_VERSION}
+[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
+eghcup rm 8.10.3
+[ "$(ghc --numeric-version)" = "${ghc_ver}" ]

-
-if [ "${OS}" = "DARWIN" ] && [ "${ARCH}" = "ARM64" ] ; then
-	echo
-else
-	# test installing new ghc doesn't mess with currently set GHC
-	# https://gitlab.haskell.org/haskell/ghcup-hs/issues/7
-	if [ "${OS}" = "LINUX" ] ; then
-		eghcup --downloader=wget prefetch ghc 8.10.3
-		eghcup --offline install ghc 8.10.3
-	else # test wget a bit
-		eghcup prefetch ghc 8.10.3
-		eghcup --offline install ghc 8.10.3
-	fi
-	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-	eghcup --offline set 8.10.3
-	eghcup set 8.10.3
-	[ "$(ghc --numeric-version)" = "8.10.3" ]
-	eghcup set ${GHC_VERSION}
-	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-	eghcup --offline rm 8.10.3
-	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-
-	if [ "${OS}" = "DARWIN" ] ; then
+# install hls
+if [ "${OS}" = "DARWIN" ] ; then
+	eghcup install hls
+	haskell-language-server-wrapper --version
+elif [ "${OS}" = "LINUX" ] ; then
+	if [ "${ARCH}" = "64" ] ; then
 		eghcup install hls
-		$(eghcup whereis hls) --version
-
-		eghcup install stack
-		$(eghcup whereis stack) --version
-	elif [ "${OS}" = "LINUX" ] ; then
-		if [ "${ARCH}" = "64" ] ; then
-			eghcup install hls
-			haskell-language-server-wrapper --version
-
-			eghcup install stack
-			stack --version
-		fi
+		haskell-language-server-wrapper --version
 	fi
 fi

-# check that lazy loading works for 'whereis'
-cp "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml" "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml.bak"
-echo '**' > "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml"
-eghcup whereis ghc $(ghc --numeric-version)
-mv -f "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml.bak" "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml"

 eghcup rm $(ghc --numeric-version)

 # https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/116
-if [ "${OS}" = "LINUX" ] ; then
-	if [ "${ARCH}" = "64" ] ; then
-		eghcup install cabal -u https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-ubuntu-16.04.tar.xz 3.4.0.0-rc4
-		eghcup rm cabal 3.4.0.0-rc4
-	fi
-fi
-
-sha_sum() {
-	if [ "${OS}" = "FREEBSD" ] ; then
-		sha256 "$@"
-	else
-		sha256sum "$@"
-	fi
-
-}
-
-# test etags
-rm -f "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml"
-raw_eghcup -s https://www.haskell.org/ghcup/data/ghcup-${JSON_VERSION}.yaml list
-# snapshot yaml and etags file
-etag=$(cat "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml.etags")
-sha=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
-# invalidate access time timer, which is 5minutes, so we re-download
-touch -a -m -t '199901010101' "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml"
-# redownload same file with some newlines added
-raw_eghcup -s https://www.haskell.org/ghcup/exp/ghcup-${JSON_VERSION}.yaml list
-# snapshot new yaml and etags file
-etag2=$(cat "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml.etags")
-sha2=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
-# compare
-[ "${etag}" != "${etag2}" ]
-[ "${sha}" != "${sha2}" ]
-# invalidate access time timer, which is 5minutes, but don't expect a re-download
-touch -a -m -t '199901010101' "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml"
-# this time, we expect the same hash and etag
-raw_eghcup -s https://www.haskell.org/ghcup/exp/ghcup-${JSON_VERSION}.yaml list
-etag3=$(cat "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml.etags")
-sha3=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
-[ "${etag2}" = "${etag3}" ]
-[ "${sha2}" = "${sha3}" ]
-
+eghcup install cabal -u https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-ubuntu-16.04.tar.xz 3.4.0.0-rc4
+eghcup rm cabal 3.4.0.0-rc4

 eghcup upgrade
 eghcup upgrade -f

-
-# nuke
-eghcup nuke
-[ ! -e "${GHCUP_DIR}" ]
--- a/.gitlab/shell.nix
+++ b/.gitlab/shell.nix
@@ -1,89 +0,0 @@
-{ system ? "aarch64-darwin"
-#, nixpkgs ? fetchTarball https://github.com/angerman/nixpkgs/archive/257cb120334.tar.gz #apple-silicon.tar.gz
-, pkgs ? import <nixpkgs> { inherit system; }
-, compiler ? if system == "aarch64-darwin" then "ghc8103Binary" else "ghc8103"
-}: pkgs.mkShell {
-  # this prevents nix from trying to write the env-vars file.
-  # we can't really, as NIX_BUILD_TOP/env-vars is not set.
-  noDumpEnvVars=1;
-
-  # stop polluting LDFLAGS with -liconv
-  dontAddExtraLibs = true;
-
-  # we need to inject ncurses into --with-curses-libraries.
-  # the real fix is to teach terminfo to use libcurses on macOS.
-  # CONFIGURE_ARGS = "--with-intree-gmp --with-curses-libraries=${pkgs.ncurses.out}/lib";
-  CONFIGURE_ARGS = "--with-intree-gmp --with-curses-libraries=/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib --with-iconv-includes=/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include --with-iconv-libraries=/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib SH=/bin/bash";
-
-  # magic speedup pony :facepalm:
-  #
-  # nix has the ugly habbit of duplicating ld flags more than necessary.  This
-  # somewhat consolidates this.
-  shellHook = ''
-  export NIX_LDFLAGS=$(for a in $NIX_LDFLAGS; do echo $a; done |sort|uniq|xargs)
-  export NIX_LDFLAGS_FOR_TARGET=$(for a in $NIX_LDFLAGS_FOR_TARGET; do echo $a; done |sort|uniq|xargs)
-  export NIX_LDFLAGS_FOR_TARGET=$(comm -3 <(for l in $NIX_LDFLAGS_FOR_TARGET; do echo $l; done) <(for l in $NIX_LDFLAGS; do echo $l; done))
-
-
-  # Impurity hack for GHC releases.
-  #################################
-  # We don't want binary releases to depend on nix, thus we'll need to make sure we don't leak in references.
-  # GHC externally depends only on iconv and curses.  However we can't force a specific curses library for
-  # the terminfo package, as such we'll need to make sure we only look in the system path for the curses library
-  # and not pick up the tinfo from the nix provided ncurses package.
-  #
-  # We also need to force us to use the systems COREFOUNDATION, not the one that nix builds. Again this is impure,
-  # but it will allow us to have proper binary distributions.
-  #
-  # do not use nixpkgs provided core foundation
-  export NIX_COREFOUNDATION_RPATH=/System/Library/Frameworks
-  # drop curses from the LDFLAGS, we really want the system ones, not the nix ones.
-  export NIX_LDFLAGS=$(for lib in $NIX_LDFLAGS; do case "$lib" in *curses*);; *) echo -n "$lib ";; esac; done;)
-  export NIX_CFLAGS_COMPILE+=" -Wno-nullability-completeness -Wno-availability -Wno-expansion-to-defined -Wno-builtin-requires-header -Wno-unused-command-line-argument"
-
-  # unconditionally add the MacOSX.sdk and TargetConditional.h
-  export NIX_CFLAGS_COMPILE+=" -isystem /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include"
-
-  '';
-
-  nativeBuildInputs = (with pkgs; [
-    # This needs to come *before* ghc,
-    # otherwise we migth end up with the clang from
-    # the bootstrap GHC in PATH with higher priority.
-    clang_11
-    llvm_11
-
-    haskell.compiler.${compiler}
-    haskell.packages.${compiler}.cabal-install
-    haskell.packages.${compiler}.alex
-    haskell.packages.${compiler}.happy # _1_19_12 is needed for older GHCs.
-
-    automake
-    autoconf
-    m4
-
-    gmp
-    zlib.out
-    zlib.dev
-    glibcLocales
-    # locale doesn't build yet :-/
-    # locale
-
-    git
-
-    python3
-    # python3Full
-    # python3Packages.sphinx
-    perl
-
-    which
-    wget
-	curl
-    file
-
-    xz
-    xlibs.lndir
-
-    cacert ])
-  ++ (with pkgs.darwin.apple_sdk.frameworks; [ Foundation Security ]);
-}
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,10 @@
 jobs:
  include:
+    - os: osx
+      osx_image: xcode8
+      language: generic
+      env: ARTIFACT=x86_64-apple-darwin-10.11-ghcup
+
    - os: osx
      osx_image: xcode10.1
      language: generic
@@ -10,16 +15,23 @@ jobs:
      language: generic
      env: ARTIFACT=x86_64-apple-darwin-10.14-ghcup

+  allow_failures:
+    - os: osx
+      osx_image: xcode8
+      language: generic
+      env: ARTIFACT=x86_64-apple-darwin-10.11-ghcup
+

 script: ".travis/build.sh"

 deploy:
  provider: releases
  api_key:
-    secure: "hT2od8Iy04tdFVuonPSWv0NX5hZDmv4al8Q0GbIWmviUetROuM7c6/MCHUcgyiw6H2L3pmH4F24GBYWpKBT3ZMbxrKXhZOZ3KPLXzlnuRlm1qymKqqwsJs3466bMftaiBr16rx1VpAuditN4A32oSmTFcQAJc84Bxn2WZ4t8hk9muS8YPyLhqg3/NxT6ob8dzNp9eS2cA0WODMb/fMzaMruRtepSK8JvuXb/SnTvaDcl9plmPzEa+eW54jwVsDps8ZpQMQlTtGIjYHIwTQ36/iLH4LoAvD7OEnB7qf753LOzmI/bvlB75xYGsLxe1qgpzPMjuG3AK0jb2KGSZCzyAyrbBFSQMIyC1gNKMtab3CohnA9WdQqAT1xrzPzA9zNw516G5Fn/z+t9Ek1f6L2OYO2hJfweNhWh+ChAIsOags2QBpqc0qjkwUS4wqxCWBdyVfgPTUoGelvjCfjQgypgIyLEHFvXt9rlj+kd97FY7nG3vxZrsvWTKKKT551OqUYX5zWTyvGR71jKyNst/p93Pg3DkRy31gHrGnG9zfNgN5tWxJqDd/suR/BAFTp0VtkFb8fR3ct7WMVeJXtE2+bKqxO5Fnocs1VjEm8pKPk7glnp0muu08kaO0h54wiSOCbk1RvO1KZtHue4wKWrHcI18dwW2WtzoBQ4P1lOSkS81UY="
+    secure: GQESg4TcYf3PQJRRaZV/kWS0hsF+OFnH2+EcwpgnIcfx4+aogMyprdh745KtBXe1FlFN1luKHksFjqceqhcg/xcNyeCJiSnLWMn4D/i4WUperEHseRBi5yZZCB1AvOjIlHrE4DS3a8pyEm1GV3G7CKY5Fu8jBjof2SnyENfd7fofhjtNHWmeFS+jBn8HRDf1YaSRYxzTw6uHLrPLsybfgQZVl7babMu/38Ghin0f5pz5OlNokzDxaubIYQHOZ7st7YndHJtBWWql/KualBWbMILy88dUVQBnbqQLP2P8d1ME8ILUjJVqz33HiRU0JzlEJyWfbvEjcJ6iD8M6n4nXTaxfu3i2UhhGsQ6SSBNKssMP4tji8nkNpMqG59wLQ/zhcetEm71fKkgJNrIMNllkqlWSo5K74IqqP9kiLg/qm8ipOJjui0gPk8tZXKcV+ztX1d1OVCapoLfiDM5l/0LLQXaTOXOV1x3e5LLQ/w2doNiH3eh5CV4II9dRu7owpaiiMBHMssmT0pH99jEeF6giHLKtt3y7l2GWoRLPdhsZZ54gxsaBxZt9GuypmkbNcr97CEnAVaWij5v0CF3w4rAWqy/tAxQpIDJOIOQBgmwG5WrBAKyKrFvEpBL5a8BPcRWJDvqKC83QeWpvPrEVdgJevC6ZN1MKzrb2SiPOwC2Kerc=
  file: $ARTIFACT
  on:
-    repo: hasufell/ghcup-hs
+    repo: haskell/ghcup-hs
    tags: true
  skip_cleanup: true
  draft: true
+
--- a/.travis/build.sh
+++ b/.travis/build.sh
@@ -18,8 +18,8 @@ ghcup set 8.10.4
 cabal update

 (
-       cd /tmp
-       cabal install --installdir="$HOME"/.ghcup/bin hspec-discover
+	cd /tmp
+	cabal install --installdir="$HOME"/.ghcup/bin hspec-discover
 )

 cabal build --constraint="zlib +static" --constraint="lzma +static" -ftui
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,45 +1,10 @@
 # Revision history for ghcup

-## 0.1.16.1 -- 2021-07-29
+## 0.1.15 -- ????-??-??

-* Add 'nuke' subcommand wrt [#135](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/135), implemented by Arjun Kathuria
-* Add uninstallation powershell script on windows wrt [#150](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/150)
-* Improve logging
-* Fix building GHC cross compiler wrt [#180](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/180)
-* Allow to use hadrian as build system (for git based versions only) wrt [#35](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/35)
-* Allow passing `--flavor` to `ghcup compile ghc`
-* Support new GHC `bin/` directory format wrt [ghc/ghc#20074](https://gitlab.haskell.org/ghc/ghc/-/issues/20074#note_363720)
-* Implement `whereis` subcommand wrt [#173](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/173)
-* Add `--offline` switch and `prefetch` subcommand wrt [#186](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/186)
-* Implement ETAGs hashing for metadata downloads to speed up `ghcup list` wrt [#193](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/193)
-* Avoid unnecessary fetching of ghcup metadata in some commands
-* Avoid unnecessary update checks for some commands
-* Preserve mtimes on unpacked GHC tarballs on windows wrt [#187](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/187), fixing issues with `ghc-pkg`
-* Fix lesser bug in `ghcup list` for stray stack versions wrt [#183](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/183)
-* Major redo on how file removal on windows works, avoiding partial removals etc, wrt [#165](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/165)
-* Improve ghcup tui for screen readers wrt [github/#4](https://github.com/haskell/ghcup-hs/pull/4), thanks to Mario Lang
-
-## 0.1.15.2 -- 2021-06-13
-
-* Remove legacy handling of cabal binary and be more graceful about binaries not installed by ghcup (e.g. stack)
-* Fix GHC compilation from git
-* Fix 'ghcup upgrade' on windows
-* Allow to skip update checks via `GHCUP_SKIP_UPDATE_CHECK`
-* Use libarchive on windows as well, fixing unpack errors wrt [#147](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/147)
-
-## 0.1.15.1 -- 2021-06-11
-
-* Add Apple Silicon support
-* Add windows support wrt [#130](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/130)
-* Add stack support
+* Add date to GHC bindist names created by ghcup
 * Warn when /tmp doesn't have 5GB or more of disk space
 * Allow to compile GHC from git repo wrt [#126](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/126)
-* Allow to set custom ghc version when running 'ghcup compile ghc' wrt [#136](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/136)
-* Add date to GHC bindist names created by ghcup
-
-## 0.1.14.2 -- 2021-05-12
-
-* Remove dead dependency on ascii-string

 ## 0.1.14.1 -- 2021-04-11

--- a/HACKING.md
+++ b/HACKING.md
@@ -6,6 +6,10 @@

 This is an open variant, similar to [plucky](https://hackage.haskell.org/package/plucky) or [oops](https://github.com/i-am-tom/oops) and allows us to combine different error types. Maybe it is too much and it's a little bit [unergonomic](https://github.com/haskus/packages/issues/32) at times. If it really hurts maintenance, it will be removed. It was more of an experiment.

+### No use of filepath or directory
+
+Filepath and directory have two fundamental problems: 1. they use String as filepath (see [AFPP](https://gitlab.haskell.org/ghc/ghc/-/wikis/proposal/abstract-file-path) as to why this is wrong) and 2. they try very hard to be cross-platform at the expense of low-level correctness. Instead, we use the [hpath](https://github.com/hasufell/hpath) libraries for file and filepath related stuff, which also gives us stronger filepath types.
+
 ### No use of haskell-TLS

 I consider haskell-TLS an interesting experiment, but not a battle-tested and peer-reviewed crypto implementation. There is little to no research about what the intricacies of using haskell for low-level crypto are and how vulnerable such binaries are. Instead, we use either curl the binary (for FreeBSD and mac) or http-io-streams, which works with OpenSSL bindings.
@@ -69,7 +73,3 @@ yaml files: `ghcup-<yaml-ver>.yaml`.
   Most of the `Version` parameters to functions had to be replaced with
   that and ensured the logic is consistent for cross and non-cross
   installs.
-2. This refactor added windows support wrt [#130](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/130).
-   The major changes here were switching `hpath` library out for `filepath`/`directory` (sadly) and
-   introducing a non-unix way of handling processes via the `process` library. It also introduced considerable
-   amounts of CPP wrt file handling, installation etc.
--- a/README.md
+++ b/README.md
@@ -1,9 +1,11 @@
 `ghcup` makes it easy to install specific versions of `ghc` on GNU/Linux,
-macOS (aka Darwin), FreeBSD and Windows and can also bootstrap a fresh Haskell developer environment from scratch.
+macOS (aka Darwin) and FreeBSD and can also bootstrap a fresh Haskell developer environment from scratch.
 It follows the unix UNIX philosophy of [do one thing and do it well](https://en.wikipedia.org/wiki/Unix_philosophy#Do_One_Thing_and_Do_It_Well).

 Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [pyenv](https://github.com/pyenv/pyenv) and [jenv](http://www.jenv.be).

+*Ubuntu users may prefer [hvr's ppa](https://launchpad.net/~hvr/+archive/ubuntu/ghc).*
+
 ## Table of Contents

   * [Installation](#installation)
@@ -77,7 +79,7 @@ ghcup install cabal
 ghcup upgrade
 ```

-GHCup works very well with [`cabal-install`](https://hackage.haskell.org/package/cabal-install), which
+Generally this is meant to be used with [`cabal-install`](https://hackage.haskell.org/package/cabal-install), which
 handles your haskell packages and can demand that [a specific version](https://cabal.readthedocs.io/en/latest/nix-local-build.html#cfg-flag---with-compiler)  of `ghc` is available, which `ghcup` can do.

 ### Configuration
@@ -85,7 +87,7 @@ handles your haskell packages and can demand that [a specific version](https://c
 A configuration file can be put in `~/.ghcup/config.yaml`. The default config file
 explaining all possible configurations can be found in this repo: [config.yaml](./config.yaml).

-Partial configuration is fine. Command line options always override the config file settings.
+Partial configuration is fine. Command line options always overwrite the config file settings.

 ### Manpages

@@ -123,9 +125,6 @@ Then you can control the locations via XDG environment variables as such:
 * `XDG_BIN_HOME`: binaries end up here (default: `~/.local/bin`)
 * `XDG_CONFIG_HOME`: the config file is stored in `ghcup` subdir as `config.yaml` (default: `~/.config`)

-**Note that `ghcup` makes some assumptions about structure of files in `XDG_BIN_HOME`. So if you have other tools
-installing e.g. stack/cabal/ghc into it, this will likely clash. In that case consider disabling XDG support.**
-
 ### Env variables

 This is the complete list of env variables that change GHCup behavior:
@@ -135,7 +134,6 @@ This is the complete list of env variables that change GHCup behavior:
 * `GHCUP_INSTALL_BASE_PREFIX`: the base of ghcup (default: `$HOME`)
 * `GHCUP_CURL_OPTS`: additional options that can be passed to curl
 * `GHCUP_WGET_OPTS`: additional options that can be passed to wget
-* `GHCUP_SKIP_UPDATE_CHECK`: Skip the (possibly annoying) update check when you run a command
 * `CC`/`LD` etc.: full environment is passed to the build system when compiling GHC via GHCup

 ### Installing custom bindists
@@ -230,29 +228,6 @@ to figure out whether you have the correct toolchain and
 the correct dependencies. Refer to [the official docs](https://ghc.haskell.org/trac/ghc/wiki/Building/Preparation/Linux)
 on how to prepare your environment for building GHC.

-### Stack support
-
-There may be a number of bugs when trying to make ghcup installed GHC versions work with stack,
-such as:
-
- https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/188
-
-Further, stack's upgrade procedure may break/confuse ghcup. There are a number of integration
-issues discussed here:
-
- https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/153
-
-### Windows support
-
-Windows support is in early stages. Since windows doesn't support symbolic links properly,
-ghcup uses a [shimgen wrapper](https://github.com/71/scoop-better-shimexe). It seems to work
-well, but there may be unknown issues with that approach.
-
-Windows 7 and Powershell 2.0 aren't well supported at the moment, also see:
-
- https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/140
- https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/197
-
 ## FAQ

 1. Why reimplement stack?
@@ -261,14 +236,8 @@ ghcup is not a reimplementation of stack. The only common part is automatic inst

 2. Why not support windows?

-We do.
+Consider using [Chocolatey](https://chocolatey.org/search?q=ghc) or [ghcups](https://github.com/kakkun61/ghcups).

 3. Why the haskell reimplementation?

-ghcup started as a portable posix shell script of maybe 50 LOC. GHC installation itself can be carried out in
-about ~3 lines of shell code (download, unpack , configure+make install). However, much convenient functionality
-has been added since, as well as ensuring that all operations are safe and correct. The shell script ended up with
-over 2k LOC, which was very hard to maintain.
-The main concern when switching from a portable shell script to haskell was platform/architecture support.
-However, ghcup now re-uses GHCs CI infrastructure and as such is perfectly in sync with all platforms that
-GHC supports.
+Why not?
--- a/app/ghcup-gen/Main.hs
+++ b/app/ghcup-gen/Main.hs
@@ -69,15 +69,13 @@ tarballFilterP = option readm $
  long "tarball-filter" <> short 'u' <> metavar "<tool>-<version>" <> value def
    <> help "Only check certain tarballs (format: <tool>-<version>)"
  where
-    def = TarballFilter (Right Nothing) (makeRegex ("" :: String))
+    def = TarballFilter Nothing (makeRegex ("" :: String))
    readm = do
      s <- str
      case span (/= '-') s of
        (_, []) -> fail "invalid format, missing '-' after the tool name"
        (t, v) | [tool] <- [ tool | tool <- [minBound..maxBound], low (show tool) == low t ] ->
-          pure (TarballFilter $ Right $ Just tool) <*> makeRegexOptsM compIgnoreCase execBlank (drop 1 v)
-        (t, v) | [tool] <- [ tool | tool <- [minBound..maxBound], low (show tool) == low t ] ->
-          pure (TarballFilter $ Left tool) <*> makeRegexOptsM compIgnoreCase execBlank (drop 1 v)
+          pure (TarballFilter $ Just tool) <*> makeRegexOptsM compIgnoreCase execBlank (drop 1 v)
        _ -> fail "invalid tool"
    low = fmap toLower

@@ -107,21 +105,26 @@ main :: IO ()
 main = do
  _ <- customExecParser (prefs showHelpOnError) (info (opts <**> helper) idm)
    >>= \Options {..} -> case optCommand of
-          ValidateYAML vopts -> withValidateYamlOpts vopts validate
-          ValidateTarballs vopts tarballFilter -> withValidateYamlOpts vopts (validateTarballs tarballFilter)
+          ValidateYAML vopts -> case vopts of
+            ValidateYAMLOpts { vInput = Nothing } ->
+              B.getContents >>= valAndExit validate
+            ValidateYAMLOpts { vInput = Just StdInput } ->
+              B.getContents >>= valAndExit validate
+            ValidateYAMLOpts { vInput = Just (FileInput file) } ->
+              B.readFile file >>= valAndExit validate
+          ValidateTarballs vopts tarballFilter -> case vopts of
+            ValidateYAMLOpts { vInput = Nothing } ->
+              B.getContents >>= valAndExit (validateTarballs tarballFilter)
+            ValidateYAMLOpts { vInput = Just StdInput } ->
+              B.getContents >>= valAndExit (validateTarballs tarballFilter)
+            ValidateYAMLOpts { vInput = Just (FileInput file) } ->
+              B.readFile file >>= valAndExit (validateTarballs tarballFilter)
  pure ()

 where
-  withValidateYamlOpts vopts f = case vopts of
-    ValidateYAMLOpts { vInput = Nothing } ->
-      B.getContents >>= valAndExit f
-    ValidateYAMLOpts { vInput = Just StdInput } ->
-      B.getContents >>= valAndExit f
-    ValidateYAMLOpts { vInput = Just (FileInput file) } ->
-      B.readFile file >>= valAndExit f
  valAndExit f contents = do
-    (GHCupInfo _ av gt) <- case Y.decodeEither' contents of
+    (GHCupInfo _ av) <- case Y.decodeEither' contents of
      Right r -> pure r
      Left  e -> die (color Red $ show e)
-    myLoggerT (LoggerConfig True (B.hPut stdout) (\_ -> pure ())) (f av gt)
+    myLoggerT (LoggerConfig True (B.hPut stdout) (\_ -> pure ())) (f av)
      >>= exitWith
--- a/app/ghcup-gen/Validate.hs
+++ b/app/ghcup-gen/Validate.hs
@@ -11,8 +11,7 @@ module Validate where
 import           GHCup
 import           GHCup.Download
 import           GHCup.Errors
-import           GHCup.Platform
-import           GHCup.Types                  hiding ( LeanAppState (..) )
+import           GHCup.Types
 import           GHCup.Types.Optics
 import           GHCup.Utils
 import           GHCup.Utils.Logger
@@ -23,7 +22,6 @@ import qualified Codec.Archive.Tar             as Tar
 #else
 import           Codec.Archive
 #endif
-import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Class
@@ -39,11 +37,12 @@ import           Data.IORef
 import           Data.List
 import           Data.String.Interpolate
 import           Data.Versions
+import           HPath                          ( toFilePath, rel )
 import           Haskus.Utils.Variant.Excepts
 import           Optics
-import           System.FilePath
 import           System.Exit
 import           System.IO
+import           System.Posix.FilePath
 import           Text.ParserCombinators.ReadP
 import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           Text.Regex.Posix
@@ -68,9 +67,8 @@ addError = do

 validate :: (Monad m, MonadLogger m, MonadThrow m, MonadIO m, MonadUnliftIO m)
         => GHCupDownloads
-         -> M.Map GlobalTool DownloadInfo
         -> m ExitCode
-validate dls _ = do
+validate dls = do
  ref <- liftIO $ newIORef 0

  -- verify binary downloads --
@@ -108,10 +106,6 @@ validate dls _ = do
      addError
    when ((notElem FreeBSD pspecs) && arch == A_64) $ lift $ $(logWarn)
      [i|FreeBSD missing for #{t} #{v'} #{arch'}|]
-    when (notElem Windows pspecs && arch == A_64) $ do
-      lift $ $(logError)
-        [i|Windows missing for for #{t} #{v'} #{arch'}|]
-      addError

    -- alpine needs to be set explicitly, because
    -- we cannot assume that "Linux UnknownLinux" runs on Alpine
@@ -126,7 +120,7 @@ validate dls _ = do
        _ -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]

  checkUniqueTags tool = do
-    let allTags = join $ fmap _viTags $ M.elems $ availableToolVersions dls tool
+    let allTags = join $ M.elems $ availableToolVersions dls tool
    let nonUnique =
          fmap fst
            .   filter (\(_, b) -> not b)
@@ -164,7 +158,7 @@ validate dls _ = do

  -- a tool must have at least one of each mandatory tags
  checkMandatoryTags tool = do
-    let allTags = join $ fmap _viTags $ M.elems $ availableToolVersions dls tool
+    let allTags = join $ M.elems $ availableToolVersions dls tool
    forM_ [Latest, Recommended] $ \t -> case elem t allTags of
      False -> do
        lift $ $(logError) [i|Tag #{t} missing from #{tool}|]
@@ -174,7 +168,7 @@ validate dls _ = do
  -- all GHC versions must have a base tag
  checkGHCHasBaseVersion = do
    let allTags = M.toList $ availableToolVersions dls GHC
-    forM allTags $ \(ver, _viTags -> tags) -> case any isBase tags of
+    forM allTags $ \(ver, tags) -> case any isBase tags of
      False -> do
        lift $ $(logError) [i|Base tag missing from GHC ver #{ver}|]
        addError
@@ -184,7 +178,7 @@ validate dls _ = do
  isBase _        = False

 data TarballFilter = TarballFilter
-  { tfTool    :: Either GlobalTool (Maybe Tool)
+  { tfTool    :: Maybe Tool
  , tfVersion :: Regex
  }

@@ -194,23 +188,22 @@ validateTarballs :: ( Monad m
                    , MonadIO m
                    , MonadUnliftIO m
                    , MonadMask m
-                    , Alternative m
-                    , MonadFail m
                    )
                 => TarballFilter
                 -> GHCupDownloads
-                 -> M.Map GlobalTool DownloadInfo
                 -> m ExitCode
-validateTarballs (TarballFilter etool versionRegex) dls gt = do
+validateTarballs (TarballFilter tool versionRegex) dls = do
  ref <- liftIO $ newIORef 0

  flip runReaderT ref $ do
     -- download/verify all tarballs
-    let dlis = either (const []) (\tool -> nubOrd $ dls ^.. each %& indices (maybe (const True) (==) tool) %> each %& indices (matchTest versionRegex . T.unpack . prettyVer) % (viSourceDL % _Just `summing` viArch % each % each % each)) etool
-    let gdlis = nubOrd $ gt ^.. each
-    let allDls = either (const gdlis) (const dlis) etool
-    when (null allDls) $ $(logError) [i|no tarballs selected by filter|] *> addError
-    forM_ allDls downloadAll
+    let dlis = nubOrd $ dls ^.. each
+          %& indices (maybe (const True) (==) tool) %> each
+          %& indices (matchTest versionRegex . T.unpack . prettyVer)
+          % (viSourceDL % _Just `summing` viArch % each % each % each)
+    when (null dlis) $ $(logError) [i|no tarballs selected by filter|] *> addError
+
+    forM_ dlis downloadAll

    -- exit
    e <- liftIO $ readIORef ref
@@ -226,22 +219,12 @@ validateTarballs (TarballFilter etool versionRegex) dls gt = do
                                     , rawOutter    = \_ -> pure ()
                                     }
  downloadAll dli = do
-    dirs <- liftIO getAllDirs
-
-    pfreq <- (
-      runLogger . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound] . liftE $ platformRequest
-      ) >>= \case
-              VRight r -> pure r
-              VLeft e -> do
-                lift $ runLogger
-                  ($(logError) $ T.pack $ prettyShow e)
-                liftIO $ exitWith (ExitFailure 2)
-
-    let appstate = AppState (Settings True False Never Curl False GHCupURL False) dirs defaultKeyBindings (GHCupInfo mempty mempty mempty) pfreq
+    dirs <- liftIO getDirs
+    let settings = AppState (Settings True False Never Curl False GHCupURL) dirs defaultKeyBindings

    r <-
      runLogger
-      . flip runReaderT appstate
+      . flip runReaderT settings
      . runResourceT
      . runE @'[DigestError
               , DownloadFailed
@@ -253,25 +236,23 @@ validateTarballs (TarballFilter etool versionRegex) dls gt = do
 #endif
               ]
      $ do
-        case etool of
-          Right (Just GHCup) -> do
-            tmpUnpack <- lift mkGhcupTmpDir
-            _ <- liftE $ download (_dlUri dli) (Just (_dlHash dli)) tmpUnpack Nothing False
+        case tool of
+          Just GHCup -> do
+            let fn = [rel|ghcup|]
+            dir <- liftIO ghcupCacheDir
+            p <- liftE $ download dli dir (Just fn)
+            liftE $ checkDigest dli p
            pure Nothing
-          Right _ -> do
+          _ -> do
            p <- liftE $ downloadCached dli Nothing
            fmap (Just . head . splitDirectories . head)
              . liftE
              . getArchiveFiles
              $ p
-          Left ShimGen -> do
-            tmpUnpack <- lift mkGhcupTmpDir
-            _ <- liftE $ download (_dlUri dli) (Just (_dlHash dli)) tmpUnpack Nothing False
-            pure Nothing
    case r of
      VRight (Just basePath) -> do
        case _dlSubdir dli of
-          Just (RealDir prel) -> do
+          Just (RealDir (toFilePath -> prel)) -> do
            lift $ $(logInfo)
              [i|verifying subdir: #{prel}|]
            when (basePath /= prel) $ do
--- a/app/ghcup/BrickMain.hs
+++ b/app/ghcup/BrickMain.hs
@@ -6,16 +6,14 @@
 {-# LANGUAGE TemplateHaskell   #-}
 {-# LANGUAGE TypeApplications  #-}
 {-# LANGUAGE ViewPatterns      #-}
-{-# LANGUAGE RankNTypes        #-}

 module BrickMain where

 import           GHCup
 import           GHCup.Download
 import           GHCup.Errors
-import           GHCup.Types         hiding ( LeanAppState(..) )
+import           GHCup.Types
 import           GHCup.Utils
-import           GHCup.Utils.Prelude ( decUTF8Safe )
 import           GHCup.Utils.File
 import           GHCup.Utils.Logger

@@ -33,7 +31,6 @@ import           Codec.Archive
 import           Control.Exception.Safe
 import           Control.Monad.Logger
 import           Control.Monad.Reader
-import           Control.Monad.Trans.Except
 import           Control.Monad.Trans.Resource
 import           Data.Bool
 import           Data.Functor
@@ -53,23 +50,23 @@ import           System.IO.Unsafe
 import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           URI.ByteString

+import qualified GHCup.Types                   as GT
+
 import qualified Data.Text                     as T
 import qualified Graphics.Vty                  as Vty
 import qualified Data.Vector                   as V


-hiddenTools :: [Tool]
-hiddenTools = []
-

 data BrickData = BrickData
  { lr    :: [ListResult]
+  , dls   :: GHCupDownloads
+  , pfreq :: PlatformRequest
  }
  deriving Show

 data BrickSettings = BrickSettings
-  { showAllVersions :: Bool
-  , showAllTools    :: Bool
+  { showAll :: Bool
  }
  deriving Show

@@ -98,24 +95,19 @@ keyHandlers KeyBindings {..} =
  [ (bQuit, const "Quit"     , halt)
  , (bInstall, const "Install"  , withIOAction install')
  , (bUninstall, const "Uninstall", withIOAction del')
-  , (bSet, const "Set"      , withIOAction ((liftIO .) . set'))
+  , (bSet, const "Set"      , withIOAction set')
  , (bChangelog, const "ChangeLog", withIOAction changelog')
-  , ( bShowAllVersions
+  , ( bShowAll
    , \BrickSettings {..} ->
-       if showAllVersions then "Don't show all versions" else "Show all versions"
-    , hideShowHandler (not . showAllVersions) showAllTools
-    )
-  , ( bShowAllTools
-    , \BrickSettings {..} ->
-       if showAllTools then "Don't show all tools" else "Show all tools"
-    , hideShowHandler showAllVersions (not . showAllTools)
+       if showAll then "Hide old versions" else "Show all versions"
+    , hideShowHandler
    )
  , (bUp, const "Up", \BrickState {..} -> continue BrickState{ appState = moveCursor 1 appState Up, .. })
  , (bDown, const "Down", \BrickState {..} -> continue BrickState{ appState = moveCursor 1 appState Down, .. })
  ]
 where
-  hideShowHandler f p BrickState{..} =
-    let newAppSettings   = appSettings { showAllVersions = f appSettings , showAllTools = p appSettings }
+  hideShowHandler BrickState{..} =
+    let newAppSettings   = appSettings { showAll = not . showAll $ appSettings }
        newInternalState = constructList appData newAppSettings (Just appState)
    in  continue (BrickState appData newAppSettings newInternalState appKeys)

@@ -169,7 +161,7 @@ ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
          | elem Latest lTag && not lInstalled =
              withAttr "hooray"
          | otherwise = id
-        active = if b then putCursor "GHCup" (Location (0,0)) . forceAttr "active" else id
+        active = if b then forceAttr "active" else id
    in  hooray $ active $ dim
          (   marks
          <+> padLeft (Pad 2)
@@ -202,7 +194,6 @@ ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
  printTool GHC = str "GHC"
  printTool GHCup = str "GHCup"
  printTool HLS = str "HLS"
-  printTool Stack = str "Stack"

  printNotes ListResult {..} =
    (if hlsPowered then [withAttr "hls-powered" $ str "hls-powered"] else mempty
@@ -257,7 +248,7 @@ app attrs dimAttrs =
  , appHandleEvent  = eventHandler
  , appStartEvent   = return
  , appAttrMap      = const attrs
-  , appChooseCursor = showFirstCursor
+  , appChooseCursor = neverShowCursor
  }

 defaultAttributes :: Bool -> AttrMap
@@ -325,25 +316,21 @@ moveCursor steps ais@BrickInternalState{..} direction =

 -- | Suspend the current UI and run an IO action in terminal. If the
 -- IO action returns a Left value, then it's thrown as userError.
-withIOAction :: (BrickState
-                 -> (Int, ListResult)
-                 -> ReaderT AppState IO (Either String a))
+withIOAction :: (BrickState -> (Int, ListResult) -> IO (Either String a))
             -> BrickState
             -> EventM n (Next BrickState)
 withIOAction action as = case listSelectedElement' (appState as) of
  Nothing      -> continue as
-  Just (ix, e) -> do
-    suspendAndResume $ do
-      settings <- readIORef settings'
-      flip runReaderT settings $ action as (ix, e) >>= \case
-        Left  err -> liftIO $ putStrLn ("Error: " <> err)
-        Right _   -> liftIO $ putStrLn "Success"
-      getAppData Nothing >>= \case
-        Right data' -> do
-          putStrLn "Press enter to continue"
-          _ <- getLine
-          pure (updateList data' as)
-        Left err -> throwIO $ userError err
+  Just (ix, e) -> suspendAndResume $ do
+    action as (ix, e) >>= \case
+      Left  err -> putStrLn ("Error: " <> err)
+      Right _   -> putStrLn "Success"
+    getAppData Nothing (pfreq . appData $ as) >>= \case
+      Right data' -> do
+        putStrLn "Press enter to continue"
+        _ <- getLine
+        pure (updateList data' as)
+      Left err -> throwIO $ userError err


 -- | Update app data and list internal state based on new evidence.
@@ -364,9 +351,7 @@ constructList :: BrickData
              -> Maybe BrickInternalState
              -> BrickInternalState
 constructList appD appSettings =
-  replaceLR (filterVisible (showAllVersions appSettings)
-                           (showAllTools appSettings))
-            (lr appD)
+  replaceLR (filterVisible (showAll appSettings)) (lr appD)

 listSelectedElement' :: BrickInternalState -> Maybe (Int, ListResult)
 listSelectedElement' BrickInternalState{..} = fmap (ix, ) $ clr !? ix
@@ -399,32 +384,21 @@ replaceLR filterF lr s =
    lTool e1 == lTool e2 && lVer e1 == lVer e2 && lCross e1 == lCross e2


-filterVisible :: Bool -> Bool -> ListResult -> Bool
-filterVisible v t e | lInstalled e = True
-                    | v
-                    , not t
-                    , not (elem (lTool e) hiddenTools) = True
-                    | not v
-                    , t
-                    , not (elem Old (lTag e)) = True
-                    | v
-                    , t = True
-                    | otherwise = not (elem Old (lTag e)) &&
-                                  not (elem (lTool e) hiddenTools)
+filterVisible :: Bool -> ListResult -> Bool
+filterVisible showAll e | lInstalled e = True
+                        | showAll      = True
+                        | otherwise    = not (elem Old (lTag e))


-install' :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadFail m, MonadMask m, MonadUnliftIO m)
-         => BrickState
-         -> (Int, ListResult)
-         -> m (Either String ())
-install' _ (_, ListResult {..}) = do
-  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
-
-  l        <- liftIO $ readIORef logger'
+install' :: BrickState -> (Int, ListResult) -> IO (Either String ())
+install' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
+  settings <- readIORef settings'
+  l        <- readIORef logger'
  let runLogger = myLoggerT l

  let run =
        runLogger
+          . flip runReaderT settings
          . runResourceT
          . runE
            @'[ AlreadyInstalled
@@ -448,24 +422,21 @@ install' _ (_, ListResult {..}) = do
      case lTool of
        GHC   -> do
          let vi = getVersionInfo lVer GHC dls
-          liftE $ installGHCBin lVer $> vi
+          liftE $ installGHCBin dls lVer pfreq $> vi
        Cabal -> do
          let vi = getVersionInfo lVer Cabal dls
-          liftE $ installCabalBin lVer $> vi
+          liftE $ installCabalBin dls lVer pfreq $> vi
        GHCup -> do
          let vi = snd <$> getLatest dls GHCup
-          liftE $ upgradeGHCup Nothing False $> vi
+          liftE $ upgradeGHCup dls Nothing False pfreq $> vi
        HLS   -> do
          let vi = getVersionInfo lVer HLS dls
-          liftE $ installHLSBin lVer $> vi
-        Stack -> do
-          let vi = getVersionInfo lVer Stack dls
-          liftE $ installStackBin lVer $> vi
+          liftE $ installHLSBin dls lVer pfreq $> vi
    )
    >>= \case
          VRight vi                         -> do
            forM_ (_viPostInstall =<< vi) $ \msg ->
-              myLoggerT l $ $(logInfo) msg
+              runLogger $ $(logInfo) msg
            pure $ Right ()
          VLeft  (V (AlreadyInstalled _ _)) -> pure $ Right ()
          VLeft (V NoUpdate) -> pure $ Right ()
@@ -489,7 +460,6 @@ set' _ (_, ListResult {..}) = do
        GHC   -> liftE $ setGHC (GHCTargetVersion lCross lVer) SetGHCOnly $> ()
        Cabal -> liftE $ setCabal lVer $> ()
        HLS   -> liftE $ setHLS lVer $> ()
-        Stack -> liftE $ setStack lVer $> ()
        GHCup -> pure ()
    )
    >>= \case
@@ -497,16 +467,13 @@ set' _ (_, ListResult {..}) = do
          VLeft  e -> pure $ Left (prettyShow e)


-del' :: (MonadReader AppState m, MonadIO m, MonadFail m, MonadMask m, MonadUnliftIO m)
-     => BrickState
-     -> (Int, ListResult)
-     -> m (Either String ())
-del' _ (_, ListResult {..}) = do
-  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
-
-  l <- liftIO $ readIORef logger'
+del' :: BrickState -> (Int, ListResult) -> IO (Either String ())
+del' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
+  settings <- readIORef settings'
+  l        <- readIORef logger'
  let runLogger = myLoggerT l
-  let run = myLoggerT l . runE @'[NotInstalled]
+
+  let run = runLogger . flip runReaderT settings . runE @'[NotInstalled]

  run (do
      let vi = getVersionInfo lVer lTool dls
@@ -514,7 +481,6 @@ del' _ (_, ListResult {..}) = do
        GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> vi
        Cabal -> liftE $ rmCabalVer lVer $> vi
        HLS   -> liftE $ rmHLSVer lVer $> vi
-        Stack -> liftE $ rmStackVer lVer $> vi
        GHCup -> pure Nothing
    )
    >>= \case
@@ -525,12 +491,8 @@ del' _ (_, ListResult {..}) = do
          VLeft  e -> pure $ Left (prettyShow e)


-changelog' :: (MonadReader AppState m, MonadIO m)
-           => BrickState
-           -> (Int, ListResult)
-           -> m (Either String ())
-changelog' _ (_, ListResult {..}) = do
-  AppState { pfreq, ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+changelog' :: BrickState -> (Int, ListResult) -> IO (Either String ())
+changelog' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
  case getChangeLog dls lTool (Left lVer) of
    Nothing -> pure $ Left
      [i|Could not find ChangeLog for #{lTool}, version #{prettyVer lVer}|]
@@ -539,8 +501,7 @@ changelog' _ (_, ListResult {..}) = do
            Darwin  -> "open"
            Linux _ -> "xdg-open"
            FreeBSD -> "xdg-open"
-            Windows -> "start"
-      exec cmd [T.unpack $ decUTF8Safe $ serializeURIRef' uri] Nothing Nothing >>= \case
+      exec cmd True [serializeURIRef' uri] Nothing Nothing >>= \case
        Right _ -> pure $ Right ()
        Left  e -> pure $ Left $ prettyShow e

@@ -548,20 +509,17 @@ changelog' _ (_, ListResult {..}) = do
 settings' :: IORef AppState
 {-# NOINLINE settings' #-}
 settings' = unsafePerformIO $ do
-  dirs <- getAllDirs
+  dirs <- getDirs
  newIORef $ AppState (Settings { cache      = True
                                , noVerify   = False
                                , keepDirs   = Never
                                , downloader = Curl
                                , verbose    = False
                                , urlSource  = GHCupURL
-                                , noNetwork  = False
                                , ..
                                })
                      dirs
                      defaultKeyBindings
-                      (GHCupInfo mempty mempty mempty)
-                      (PlatformRequest A_64 Darwin Nothing)



@@ -577,8 +535,10 @@ logger' = unsafePerformIO

 brickMain :: AppState
          -> LoggerConfig
+          -> GHCupDownloads
+          -> PlatformRequest
          -> IO ()
-brickMain s l = do
+brickMain s l av pfreq' = do
  writeIORef settings' s
  -- logger interpreter
  writeIORef logger'   l
@@ -586,7 +546,7 @@ brickMain s l = do

  no_color <- isJust <$> lookupEnv "NO_COLOR"

-  eAppData <- getAppData (Just $ ghcupInfo s)
+  eAppData <- getAppData (Just av) pfreq'
  case eAppData of
    Right ad ->
      defaultMain
@@ -594,7 +554,7 @@ brickMain s l = do
          (BrickState ad
                    defaultAppSettings
                    (constructList ad defaultAppSettings Nothing)
-                    (keyBindings (s :: AppState))
+                    (keyBindings s)

          )
        $> ()
@@ -604,11 +564,11 @@ brickMain s l = do


 defaultAppSettings :: BrickSettings
-defaultAppSettings = BrickSettings { showAllVersions = False, showAllTools = False }
+defaultAppSettings = BrickSettings { showAll = False }


-getGHCupInfo :: IO (Either String GHCupInfo)
-getGHCupInfo = do
+getDownloads' :: IO (Either String GHCupDownloads)
+getDownloads' = do
  settings <- readIORef settings'
  l        <- readIORef logger'
  let runLogger = myLoggerT l
@@ -617,25 +577,29 @@ getGHCupInfo = do
    runLogger
    . flip runReaderT settings
    . runE @'[JSONError , DownloadFailed , FileDoesNotExistError]
+    $ fmap _ghcupDownloads
    $ liftE
-    $ getDownloadsF
+    $ getDownloadsF (urlSource . GT.settings $ settings)

  case r of
    VRight a -> pure $ Right a
    VLeft  e -> pure $ Left (prettyShow e)


-getAppData :: Maybe GHCupInfo
+getAppData :: Maybe GHCupDownloads
+           -> PlatformRequest
           -> IO (Either String BrickData)
-getAppData mgi = runExceptT $ do
-  l        <- liftIO $ readIORef logger'
+getAppData mg pfreq' = do
+  settings <- readIORef settings'
+  l        <- readIORef logger'
  let runLogger = myLoggerT l

-  r <- ExceptT $ maybe getGHCupInfo (pure . Right) mgi
-  liftIO $ modifyIORef settings' (\s -> s { ghcupInfo = r })
-  settings <- liftIO $ readIORef settings'
+  r <- maybe getDownloads' (pure . Right) mg

  runLogger . flip runReaderT settings $ do
-    lV <- listVersions Nothing Nothing
-    pure $ BrickData (reverse lV)
+    case r of
+      Right dls -> do
+        lV <- listVersions dls Nothing Nothing pfreq'
+        pure $ Right $ BrickData (reverse lV) dls pfreq'
+      Left e -> pure $ Left [i|#{e}|]

--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
--- a/712
+++ b/712
@@ -5,12 +5,8 @@
 #   * BOOTSTRAP_HASKELL_NO_UPGRADE - any nonzero value to not trigger the upgrade
 #   * GHCUP_USE_XDG_DIRS - any nonzero value to respect The XDG Base Directory Specification
 #   * BOOTSTRAP_HASKELL_VERBOSE - any nonzero value for more verbose installation
-#   * BOOTSTRAP_HASKELL_GHC_VERSION - the ghc version to install
-#   * BOOTSTRAP_HASKELL_CABAL_VERSION - the cabal version to install
-#   * BOOTSTRAP_HASKELL_INSTALL_STACK - whether to install latest stack
-#   * BOOTSTRAP_HASKELL_INSTALL_HLS - whether to install latest hls
-#   * BOOTSTRAP_HASKELL_ADJUST_BASHRC - whether to adjust PATH in bashrc (prepend)
-#   * BOOTSTRAP_HASKELL_ADJUST_CABAL_CONFIG - whether to adjust mingw paths in cabal.config on windows
+#   * BOOTSTRAP_HASKELL_GHC_VERSION
+#   * BOOTSTRAP_HASKELL_CABAL_VERSION

 # License: LGPL-3.0

@@ -18,76 +14,26 @@
 # safety subshell to avoid executing anything in case this script is not downloaded properly
 (

-plat="$(uname -s)"
-arch=$(uname -m)
-ghver="0.1.15.2"
-base_url="https://downloads.haskell.org/~ghcup"
+: "${GHCUP_INSTALL_BASE_PREFIX:=$HOME}"

-export GHCUP_SKIP_UPDATE_CHECK=yes
+export GHCUP_USE_XDG_DIRS

-case "${plat}" in
-        MSYS*|MINGW*)
-			: "${GHCUP_INSTALL_BASE_PREFIX:=/c}"
-			GHCUP_DIR=$(cygpath -u "${GHCUP_INSTALL_BASE_PREFIX}/ghcup")
-			GHCUP_BIN=$(cygpath -u "${GHCUP_INSTALL_BASE_PREFIX}/ghcup/bin")
-			: "${GHCUP_MSYS2:=${GHCUP_DIR}/msys64}"
-			;;
-		*)
-			: "${GHCUP_INSTALL_BASE_PREFIX:=$HOME}"
-			export GHCUP_USE_XDG_DIRS
-
-			if [ -n "${GHCUP_USE_XDG_DIRS}" ] ; then
-				GHCUP_DIR=${XDG_DATA_HOME:=$HOME/.local/share}/ghcup
-				GHCUP_BIN=${XDG_BIN_HOME:=$HOME/.local/bin}
-			else
-				GHCUP_DIR=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup
-				GHCUP_BIN=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin
-			fi
-			;;
-esac
+if [ -n "${GHCUP_USE_XDG_DIRS}" ] ; then
+	GHCUP_DIR=${XDG_DATA_HOME:=$HOME/.local/share}/ghcup
+	GHCUP_BIN=${XDG_BIN_HOME:=$HOME/.local/bin}
+else
+	GHCUP_DIR=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup
+	GHCUP_BIN=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin
+fi

 : "${BOOTSTRAP_HASKELL_GHC_VERSION:=recommended}"
 : "${BOOTSTRAP_HASKELL_CABAL_VERSION:=recommended}"

-
 die() {
    (>&2 printf "\\033[0;31m%s\\033[0m\\n" "$1")
    exit 2
 }

-warn() {
-	case "${plat}" in
-			MSYS*|MINGW*)
-				echo -e "\\033[0;35m$1\\033[0m"
-				;;
-			*)
-				printf "\\033[0;35m%s\\033[0m\\n" "$1"
-				;;
-	esac
-}
-
-yellow() {
-	case "${plat}" in
-			MSYS*|MINGW*)
-				echo -e "\\033[0;33m$1\\033[0m"
-				;;
-			*)
-				printf "\\033[0;33m%s\\033[0m\\n" "$1"
-				;;
-	esac
-}
-
-green() {
-	case "${plat}" in
-			MSYS*|MINGW*)
-				echo -e "\\033[0;32m$1\\033[0m"
-				;;
-			*)
-				printf "\\033[0;32m%s\\033[0m\\n" "$1"
-				;;
-	esac
-}
-
 edo() {
    "$@" || die "\"$*\" failed!"
 }
@@ -97,155 +43,196 @@ eghcup() {
 }

 _eghcup() {
-	if [ -n "${BOOTSTRAP_HASKELL_YAML}" ] ; then
-		args="-s ${BOOTSTRAP_HASKELL_YAML}"
-	fi 
    if [ -z "${BOOTSTRAP_HASKELL_VERBOSE}" ] ; then
-        "${GHCUP_BIN}/ghcup" ${args} "$@"
+        ghcup "$@"
    else
-        "${GHCUP_BIN}/ghcup" ${args} --verbose "$@"
+        ghcup --verbose "$@"
    fi
 }

 _done() {
 	echo
-	echo "==============================================================================="
-	case "${plat}" in
-			MSYS*|MINGW*)
-				green
-				green "All done!"
-				green
-				green "In a new powershell or cmd.exe session, now you can..."
-				green
-				green "Start a simple repl via:"
-				green "  ghci"
-				green
-				green "Start a new haskell project in the current directory via:"
-				green "  cabal init --interactive"
-				green
-				green "Install other GHC versions and tools via:"
-				green "  ghcup list"
-				green "  ghcup install <tool> <version>"
-				green
-				green "To install system libraries and update msys2/mingw64,"
-				green "open the \"Mingw haskell shell\""
-				green "and the \"Mingw package management docs\""
-				green "desktop shortcuts."
-				;;
-			*)
-				green
-				green "All done!"
-				green
-				green "To start a simple repl, run:"
-				green "  ghci"
-				green
-				green "To start a new haskell project in the current directory, run:"
-				green "  cabal init --interactive"
-				green
-				green "To install other GHC versions and tools, run:"
-				green "  ghcup tui"
-				;;
-
-	esac
-
+    echo "All done!"
+	echo
+	echo "To start a simple repl, run:"
+	echo "  ghci"
+	echo
+	echo "To start a new haskell project in the current directory, run:"
+	echo "  cabal init --interactive"
+	echo
+	echo "To install other GHC versions, run:"
+	echo "  ghcup tui"

 	exit 0
 }

 download_ghcup() {
+	_plat="$(uname -s)"
+	_arch=$(uname -m)
+	_ghver="0.1.14.1"
+	_base_url="https://downloads.haskell.org/~ghcup"

-    case "${plat}" in
+    case "${_plat}" in
        "linux"|"Linux")
-			case "${arch}" in
+			case "${_arch}" in
 				x86_64|amd64)
 					# we could be in a 32bit docker container, in which
 					# case uname doesn't give us what we want
 					if [ "$(getconf LONG_BIT)" = "32" ] ; then
-						_url=${base_url}/${ghver}/i386-linux-ghcup-${ghver}
+						_url=${_base_url}/${_ghver}/i386-linux-ghcup-${_ghver}
 					elif [ "$(getconf LONG_BIT)" = "64" ] ; then
-						_url=${base_url}/${ghver}/x86_64-linux-ghcup-${ghver}
+						_url=${_base_url}/${_ghver}/x86_64-linux-ghcup-${_ghver}
 					else
 						die "Unknown long bit size: $(getconf LONG_BIT)"
 					fi
 					;;
 				i*86)
-					_url=${base_url}/${ghver}/i386-linux-ghcup-${ghver}
+					_url=${_base_url}/${_ghver}/i386-linux-ghcup-${_ghver}
 					;;
 				armv7*)
-					_url=${base_url}/${ghver}/armv7-linux-ghcup-${ghver}
+					_url=${_base_url}/${_ghver}/armv7-linux-ghcup-${_ghver}
 					;;
 				aarch64|arm64|armv8l)
-					_url=${base_url}/${ghver}/aarch64-linux-ghcup-${ghver}
+					_url=${_base_url}/${_ghver}/aarch64-linux-ghcup-${_ghver}
 					;;
-				*) die "Unknown architecture: ${arch}"
+				*) die "Unknown architecture: ${_arch}"
 					;;
 			esac
 			;;
        "FreeBSD"|"freebsd")
-			case "${arch}" in
+			case "${_arch}" in
 				x86_64|amd64)
 					;;
 				i*86)
 					die "i386 currently not supported!"
 					;;
-				*) die "Unknown architecture: ${arch}"
+				*) die "Unknown architecture: ${_arch}"
 					;;
 			esac
-			_url=${base_url}/${ghver}/x86_64-portbld-freebsd-ghcup-${ghver}
+			_url=${_base_url}/${_ghver}/x86_64-portbld-freebsd-ghcup-${_ghver}
            ;;
        "Darwin"|"darwin")
-			case "${arch}" in
+			case "${_arch}" in
 				x86_64|amd64)
-					_url=${base_url}/${ghver}/x86_64-apple-darwin-ghcup-${ghver}
-					;;
-				aarch64|arm64|armv8l)
-					_url=${base_url}/${ghver}/aarch64-apple-darwin-ghcup-${ghver}
 					;;
 				i*86)
 					die "i386 currently not supported!"
 					;;
-				*) die "Unknown architecture: ${arch}"
+				*) die "Unknown architecture: ${_arch}"
 					;;
 			esac
-			;;
-        MSYS*|MINGW*)
-			case "${arch}" in
-				x86_64|amd64)
-					_url=${base_url}/${ghver}/x86_64-mingw64-ghcup-${ghver}.exe
-					;;
-				*) die "Unknown architecture: ${arch}"
-					;;
-			esac
-			;;
-        *) die "Unknown platform: ${plat}"
+			_url=${_base_url}/${_ghver}/x86_64-apple-darwin-ghcup-${_ghver} ;;
+        *) die "Unknown platform: ${_plat}"
 			;;
    esac
-    case "${plat}" in
-        MSYS*|MINGW*)
-			edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup.exe
-			edo chmod +x "${GHCUP_BIN}"/ghcup.exe
-			;;
-		*)
-			edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup
-			edo chmod +x "${GHCUP_BIN}"/ghcup
-			;;
-	esac

-	edo mkdir -p "${GHCUP_DIR}"
+	edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup

-	# we may overwrite this in adjust_bashrc
+    edo chmod +x "${GHCUP_BIN}"/ghcup
+
+  edo mkdir -p "${GHCUP_DIR}"
 	cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
 		export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
 		EOF
-
 	# shellcheck disable=SC1090
    edo . "${GHCUP_DIR}"/env
    eghcup upgrade
+
+	unset _plat _arch _url _ghver _base_url
 }

-# Figures out the users login shell and sets
-# GHCUP_PROFILE_FILE and MY_SHELL variables.
-find_shell() {
+
+echo
+echo "Welcome to Haskell!"
+echo
+echo "This script will download and install the following binaries:"
+echo "  * ghcup - The Haskell toolchain installer"
+echo "            (for managing GHC/cabal versions)"
+echo "  * ghc   - The Glasgow Haskell Compiler"
+echo "  * cabal - The Cabal build tool"
+echo
+if [ -z "${GHCUP_USE_XDG_DIRS}" ] ; then
+	echo "ghcup installs only into the following directory,"
+    echo "which can be removed anytime:"
+	echo "  $GHCUP_INSTALL_BASE_PREFIX/.ghcup"
+else
+	echo "ghcup installs into XDG directories as long as"
+    echo "'GHCUP_USE_XDG_DIRS' is set."
+fi
+echo
+
+if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+    printf "\\033[0;35m%s\\033[0m\\n" "Press ENTER to proceed or ctrl-c to abort."
+    printf "\\033[0;35m%s\\033[0m\\n" "Note that this script can be re-run at any given time."
+    echo
+    # Wait for user input to continue.
+    # shellcheck disable=SC2034
+    read -r answer </dev/tty
+fi
+
+edo mkdir -p "${GHCUP_BIN}"
+
+if command -V "ghcup" >/dev/null 2>&1 ; then
+    if [ -z "${BOOTSTRAP_HASKELL_NO_UPGRADE}" ] ; then
+        _eghcup upgrade || download_ghcup
+    fi
+else
+	download_ghcup
+fi
+
+echo
+echo "$(ghcup tool-requirements)"
+echo
+
+if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+    printf "\\033[0;35m%s\\033[0m\\n" "Press ENTER to proceed or ctrl-c to abort."
+    printf "\\033[0;35m%s\\033[0m\\n" "Installation may take a while."
+    echo
+
+    # Wait for user input to continue.
+    # shellcheck disable=SC2034
+    read -r answer </dev/tty
+fi
+
+eghcup --cache install ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
+
+eghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
+eghcup --cache install cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
+
+edo cabal new-update
+
+printf "\\033[0;35m%s\\033[0m\\n" ""
+printf "\\033[0;35m%s\\033[0m\\n" "Installation done!"
+printf "\\033[0;35m%s\\033[0m\\n" ""
+
+
+if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+	printf "\\033[0;35m%s\\033[0m\\n" "Do you want to install haskell-language-server (HLS) now?"
+	printf "\\033[0;35m%s\\033[0m\\n" "HLS is a language-server that provides IDE-like functionality"
+	printf "\\033[0;35m%s\\033[0m\\n" "and can integrate with different editors, such as Vim, Emacs, VS Code, Atom, ..."
+	printf "\\033[0;35m%s\\033[0m\\n" "Also see https://github.com/haskell/haskell-language-server/blob/master/README.md"
+	printf "\\033[0;35m%s\\033[0m\\n" ""
+	printf "\\033[0;35m%s\\033[0m\\n" "Answer with YES or NO and press ENTER."
+	printf "\\033[0;35m%s\\033[0m\\n" ""
+
+	while true; do
+		read -r hls_answer </dev/tty
+
+		case $hls_answer in
+			[Yy]*)
+				eghcup --cache install hls
+				break ;;
+			[Nn]*)
+				break ;;
+			*)
+				echo "Please type YES or NO and press enter.";;
+		esac
+	done
+
+    echo "In order to run ghc and cabal, you need to adjust your PATH variable."
+    echo "You may want to source '$GHCUP_DIR/env' in your shell"
+    echo "configuration to do so (e.g. ~/.bashrc)."
+
 	case $SHELL in
 		*/zsh) # login shell is zsh
 			GHCUP_PROFILE_FILE="$HOME/.zshrc"
@@ -261,392 +248,67 @@ find_shell() {
 				GHCUP_PROFILE_FILE="$HOME/.zshrc"
 				MY_SHELL="zsh"
 			else
-				return
+			    _done
 			fi
 			;;
 		*/fish) # login shell is fish
 			GHCUP_PROFILE_FILE="$HOME/.config/fish/config.fish"
 			MY_SHELL="fish" ;;
-		*) return ;;
-	esac
-}
-
-# Ask user if they want to adjust the bashrc.
-ask_bashrc() {
-	if [ -n "${BOOTSTRAP_HASKELL_ADJUST_BASHRC}" ] ; then
-		return 1
-	fi
-
-	while true; do
-		if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-			echo "-------------------------------------------------------------------------------"
-
-			warn ""
-			warn "Detected ${MY_SHELL} shell on your system..."
-			warn "Do you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\"?"
-			warn ""
-			warn "[P] Yes, prepend  [A] Yes, append  [N] No  [?] Help (default is \"P\")."
-			warn ""
-
-			read -r bashrc_answer </dev/tty
-		else
-			# On windows .bashrc isn't an important user config, so we adjust it
-			# always. On other platforms, let's be a bit more conservative.
-			case "${plat}" in
-					MSYS*|MINGW*)
-						return 1
-						;;
-					*)
-						return 0
-						;;
-			esac
-		fi
-		case $bashrc_answer in
-			[Pp]* | "")
-				return 1
-				;;
-			[Aa]*)
-				return 2
-				;;
-			[Nn]*)
-				return 0;;
-			*)
-				echo "Possible choices are:"
-				echo
-				echo "P - Yes, prepend to PATH, taking precedence (default)"
-				echo "A - Yes, append to PATH"
-				echo "N - No, don't mess with my configuration"
-				echo
-				echo "Please make your choice and press ENTER."
-				;;
-		esac
-	done
-
-	unset bashrc_answer
-}
-
-# Needs 'find_shell' to be called beforehand.
-adjust_bashrc() {
-	case $1 in
-		1)
-			cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-				export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
-				EOF
-			;;
-		2)
-			cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-				export PATH="\$PATH:\$HOME/.cabal/bin:${GHCUP_BIN}"
-				EOF
-			;;
-		*) ;;
+		*) _done ;;
 	esac

-	case $1 in
-		1 | 2)
-			case $MY_SHELL in
-				"")
-					warn_path "Couldn't figure out login shell!"
-					return
-					;;
-				fish)
-					mkdir -p "${GHCUP_PROFILE_FILE%/*}"
-					sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
-					case $1 in
-						1)
-							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-							;;
-						2)
-							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; set -gx PATH \$HOME/.cabal/bin \$PATH $GHCUP_BIN # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-							;;
-					esac
-					break ;;
-				bash)
-					sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
-					echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-					case "${plat}" in
-						"Darwin"|"darwin")
-							if ! grep -q "ghcup-env" "${HOME}/.bash_profile" ; then
-								echo "[[ -f ~/.bashrc ]] && source ~/.bashrc # ghcup-env" >> "${HOME}/.bash_profile"
-							fi
-							;;
-					esac
-					break ;;

-				zsh)
-					sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
-					echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-					break ;;
-			esac
-			echo
-			echo "==============================================================================="
-			echo
-			warn "OK! ${GHCUP_PROFILE_FILE} has been modified. Restart your terminal for the changes to take effect,"
-			warn "or type \"source ${GHCUP_DIR}/env\" to apply them in your current terminal session."
-			return
-			;;
-		*)
-			warn_path
-			;;
-	esac
-}
+	printf "\\033[0;35m%s\\033[0m\\n" ""
+	printf "\\033[0;35m%s\\033[0m\\n" "Detected ${MY_SHELL} shell on your system..."
+	printf "\\033[0;35m%s\\033[0m\\n" "If you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\""
+	printf "\\033[0;35m%s\\033[0m\\n" "answer with YES, otherwise with NO and press ENTER."
+	printf "\\033[0;35m%s\\033[0m\\n" ""

-warn_path() {
-	echo
-	echo "==============================================================================="
-	echo
-	[ -n "$1" ] && warn "$1"
-	yellow "In order to run ghc and cabal, you need to adjust your PATH variable."
-	yellow "To do so, you may want run 'source $GHCUP_DIR/env' in your current terminal"
-	yellow "session as well as your shell configuration (e.g. ~/.bashrc)."
+    while true; do
+        read -r next_answer </dev/tty

-}
-
-adjust_cabal_config() {
-	edo cabal user-config -a "extra-prog-path: $(cygpath -w "$GHCUP_BIN"), $(cygpath -w "$HOME"/AppData/Roaming/cabal/bin), $(cygpath -w "$GHCUP_MSYS2"/usr/bin), $(cygpath -w "$GHCUP_MSYS2"/mingw64/bin)" -a "extra-include-dirs: $(cygpath -w "$GHCUP_MSYS2"/mingw64/include)" -a "extra-lib-dirs: $(cygpath -w "$GHCUP_MSYS2"/mingw64/lib)" -f init
-}
-
-ask_cabal_config_init() {
-	case "${plat}" in
-			MSYS*|MINGW*)
-				if [ -n "${BOOTSTRAP_HASKELL_ADJUST_CABAL_CONFIG}" ] ; then
-					return 1
-				fi
-
-				if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-					echo "-------------------------------------------------------------------------------"
-					warn "Create an initial cabal.config including relevant msys2 paths (recommended)?"
-					warn "[Y] Yes  [N] No  [?] Help (default is \"Y\")."
-					echo
-					while true; do
-						read -r mingw_answer </dev/tty
-
-						case $mingw_answer in
-							[Yy]* | "")
-								return 1 ;;
-							[Nn]*)
-								return 0 ;;
-							*)
-								echo "Possible choices are:"
-								echo
-								echo "Y - Yes, create a cabal.config with pre-set paths to msys2/mingw64 (default)"
-								echo "N - No, leave the current/default cabal config untouched"
-								echo
-								echo "Please make your choice and press ENTER."
+        case $next_answer in
+            [Yy]*)
+				case $MY_SHELL in
+					"") break ;;
+					fish)
+						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
+							mkdir -p "${GHCUP_PROFILE_FILE%/*}"
+							echo "# ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME" >> "${GHCUP_PROFILE_FILE}"
+							echo "test -f $GHCUP_DIR/env ; and set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH" >> "${GHCUP_PROFILE_FILE}"
+						fi
+						break ;;
+					bash)
+						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
+							echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+						fi
+						case "$(uname -s)" in
+							"Darwin"|"darwin")
+								if ! grep -q "ghcup-env" "${HOME}/.bash_profile" ; then
+									echo "[[ -f ~/.bashrc ]] && source ~/.bashrc # ghcup-env" >> "${HOME}/.bash_profile"
+								fi
 								;;
 						esac
-					done
-				else
-					return 1
-				fi
-				;;
-	esac
+						break ;;

-	unset mingw_answer
-
-    return 0
-}
-
-do_cabal_config_init() {
-	case "${plat}" in
-			MSYS*|MINGW*)
-		case $1 in
-			1)
-				adjust_cabal_config
-				;;
-			0)
-				echo "Make sure that your global cabal.config references the correct mingw64 paths (extra-prog-path, extra-include-dirs and extra-lib-dirs)."
-				echo "And set the environment variable GHCUP_MSYS2 to the root path of your msys2 installation."
-				sleep 5
-				return ;;
-			*) ;;
-		esac
-	esac
-}
-
-ask_hls() {
-	if [ -n "${BOOTSTRAP_HASKELL_INSTALL_HLS}" ] ; then
-		return 1
-	fi
-
-	if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-		echo "-------------------------------------------------------------------------------"
-
-		warn "Do you want to install haskell-language-server (HLS)?"
-		warn "HLS is a language-server that provides IDE-like functionality"
-		warn "and can integrate with different editors, such as Vim, Emacs, VS Code, Atom, ..."
-		warn "Also see https://github.com/haskell/haskell-language-server/blob/master/README.md"
-		warn ""
-		warn "[Y] Yes  [N] No  [?] Help (default is \"N\")."
-		warn ""
-
-		while true; do
-			read -r hls_answer </dev/tty
-
-			case $hls_answer in
-				[Yy]*)
-					return 1
-					;;
-				[Nn]* | "")
-					return 0
-					;;
-				*)
-					echo "Possible choices are:"
-					echo
-					echo "Y - Yes, install the haskell-langauge-server"
-					echo "N - No, don't install anything more (default)"
-					echo
-					echo "Please make your choice and press ENTER."
-					;;
-			esac
-		done
-	else
-		return 0
-	fi
-
-	unset hls_answer
-}
-
-ask_stack() {
-	if [ -n "${BOOTSTRAP_HASKELL_INSTALL_STACK}" ] ; then
-		return 1
-	fi
-
-	if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-		echo "-------------------------------------------------------------------------------"
-
-		warn "Do you want to install stack?"
-		warn "Stack is a haskell build tool similar to cabal that is used by some projects."
-		warn "Also see https://docs.haskellstack.org/"
-		warn ""
-		warn "[Y] Yes  [N] No  [?] Help (default is \"N\")."
-		warn ""
-
-		while true; do
-			read -r stack_answer </dev/tty
-
-			case $stack_answer in
-				[Yy]*)
-					return 1 ;;
-				[Nn]* | "")
-					return 0 ;;
-				*)
-					echo "Possible choices are:"
-					echo
-					echo "Y - Yes, install stack"
-					echo "N - No, don't install anything more (default)"
-					echo
-					echo "Please make your choice and press ENTER."
-					;;
-			esac
-		done
-	else
-		return 0
-	fi
-
-	unset stack_answer
-}
-
-
-find_shell
-
-
-echo
-echo "Welcome to Haskell!"
-echo
-echo "This script will download and install the following binaries:"
-echo "  * ghcup - The Haskell toolchain installer"
-echo "  * ghc   - The Glasgow Haskell Compiler"
-echo "  * cabal - The Cabal build tool for managing Haskell software"
-echo "  * stack - (optional) A cross-platform program for developing Haskell projects"
-echo "  * hls   - (optional) A language server for developers to integrate with their editor/IDE"
-echo
-if [ -z "${GHCUP_USE_XDG_DIRS}" ] ; then
-	echo "ghcup installs only into the following directory,"
-    echo "which can be removed anytime:"
-	case "${plat}" in
-			MSYS*|MINGW*)
-				echo "  $(cygpath -w "$GHCUP_DIR")"
-				;;
-			*)
-				echo "  $GHCUP_DIR"
-				;;
-	esac
-else
-	echo "ghcup installs into XDG directories as long as"
-    echo "'GHCUP_USE_XDG_DIRS' is set."
+					zsh)
+						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
+							echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+						fi
+						break ;;
+				esac
+                printf "\\033[0;35m%s\\033[0m\\n" "OK! ${GHCUP_PROFILE_FILE} has been modified. Restart your terminal for the changes to take effect,"
+                printf "\\033[0;35m%s\\033[0m\\n" "or type \"source ${GHCUP_DIR}/env\" to apply them in your current terminal session."
+				_done
+                ;;
+            [Nn]*)
+                _done ;;
+            *)
+                echo "Please type YES or NO and press enter.";;
+        esac
+    done
 fi
-echo
-
-if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-    warn "Press ENTER to proceed or ctrl-c to abort."
-    warn "Note that this script can be re-run at any given time."
-    # Wait for user input to continue.
-    # shellcheck disable=SC2034
-    read -r answer </dev/tty
-fi
-
-ask_bashrc
-ask_bashrc_answer=$?
-ask_cabal_config_init
-ask_cabal_config_init_answer=$?
-ask_hls
-ask_hls_answer=$?
-ask_stack
-ask_stack_answer=$?
-
-edo mkdir -p "${GHCUP_BIN}"
-
-if command -V "ghcup" >/dev/null 2>&1 ; then
-    if [ -z "${BOOTSTRAP_HASKELL_NO_UPGRADE}" ] ; then
-        _eghcup upgrade || download_ghcup
-    fi
-else
-	download_ghcup
-fi
-
-echo
-echo "$(if [ -n "${BOOTSTRAP_HASKELL_YAML}" ] ; then ghcup -s "${BOOTSTRAP_HASKELL_YAML}" tool-requirements ; else ghcup tool-requirements ; fi)"
-echo
-
-if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-    warn "Press ENTER to proceed or ctrl-c to abort."
-    warn "Installation may take a while."
-    echo
-
-    # Wait for user input to continue.
-    # shellcheck disable=SC2034
-    read -r answer </dev/tty
-fi
-
-eghcup --cache install ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
-
-eghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
-eghcup --cache install cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
-
-do_cabal_config_init $ask_cabal_config_init_answer
-
-edo cabal new-update
-
-case $ask_hls_answer in
-	1)
-		_eghcup --cache install hls || warn "HLS installation failed, continuing anyway"
-		;;
-	*) ;;
-esac
-
-case $ask_stack_answer in
-	1)
-		_eghcup --cache install stack || warn "Stack installation failed, continuing anyway"
-		;;
-	*) ;;
-esac
-
-
-adjust_bashrc $ask_bashrc_answer
-
-
-_done
-
 )

 # vim: tabstop=4 shiftwidth=4 expandtab
--- a/bootstrap-haskell.ps1
+++ b/bootstrap-haskell.ps1
@@ -1,548 +0,0 @@
-<#
-    .SYNOPSIS
-    Script to bootstrap a Haskell environment
-
-    .DESCRIPTION
-    This is the windows GHCup installer, installing:
-
-    * ghcup - The Haskell toolchain installer"
-    * ghc   - The Glasgow Haskell Compiler"
-    * msys2 - Unix-style toolchain needed for dependencies and tools
-    * cabal - The Cabal build tool for managing Haskell software"
-    * stack - (optional) A cross-platform program for developing Haskell projects"
-    * hls   - (optional) A language server for developers to integrate with their editor/IDE"
-#>
-param (
-    # Run an interactive installation
-    [switch]$Interactive,
-    # Specify the install root (default: 'C:\')
-    [string]$InstallDir,
-    # Instead of installing a new MSys2, use an existing installation
-    [string]$ExistingMsys2Dir,
-    # Specify the cabal root directory (default: '$InstallDir\cabal')
-    [string]$CabalDir,
-    # Overwrite (or rather backup) a previous install
-    [switch]$Overwrite,
-    # Specify the bootstrap url (default: 'https://www.haskell.org/ghcup/sh/bootstrap-haskell')
-    [string]$BootstrapUrl,
-    # Run the final bootstrap script via 'bash' instead of a full newly spawned msys2 shell
-    [switch]$InBash,
-    # Whether to install stack as well
-    [switch]$InstallStack,
-    # Whether to install hls as well
-    [switch]$InstallHLS,
-    # Skip adjusting cabal.config with mingw paths
-    [switch]$NoAdjustCabalConfig
-)
-
-$Silent = !$Interactive
-
-function Print-Msg {
-  param ( [Parameter(Mandatory=$true, HelpMessage='String to output')][string]$msg, [string]$color = "Green" )
-  Write-Host ('{0}' -f $msg) -ForegroundColor $color
-}
-
-function Create-Shortcut {
-    param ( [Parameter(Mandatory=$true,HelpMessage='Target path')][string]$SourceExe, [Parameter(Mandatory=$true,HelpMessage='Arguments to the path/exe')][AllowEmptyString()]$ArgumentsToSourceExe, [Parameter(Mandatory=$true,HelpMessage='The destination of the desktop link')][string]$DestinationPath )
-    $WshShell = New-Object -comObject WScript.Shell
-    $Shortcut = $WshShell.CreateShortcut($DestinationPath)
-    $Shortcut.TargetPath = $SourceExe
-    if($ArgumentsToSourceExe) {
-      $Shortcut.Arguments = $ArgumentsToSourceExe
-    }
-    $Shortcut.Save()
-}
-
-function Add-EnvPath {
-  param(
-      [Parameter(Mandatory=$true,HelpMessage='The Path to add to Users environment')]
-      [string] $Path,
-
-      [ValidateSet('Machine', 'User', 'Session')]
-      [string] $Container = 'Session'
-  )
-
-  if ($Container -eq 'Session') {
-      $envPaths = [Collections.Generic.List[String]]($env:Path -split ([IO.Path]::PathSeparator))
-      if ($envPaths -notcontains $Path) {
-          $envPaths.Add($Path)
-          $env:PATH = $envPaths -join ([IO.Path]::PathSeparator)
-      }
-  }
-  else {
-      [Microsoft.Win32.RegistryHive]$hive, $keyPath = switch ($Container) {
-          'Machine' { 'LocalMachine', 'SYSTEM\CurrentControlSet\Control\Session Manager\Environment' }
-          'User' { 'CurrentUser', 'Environment' }
-      }
-
-      $hiveKey = $envKey = $null
-      try {
-          $hiveKey = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey($hive, '')
-          $envKey = $hiveKey.OpenSubKey($keyPath, $true)
-          $rawPath = $envKey.GetValue('PATH', '', 'DoNotExpandEnvironmentNames')
-
-          $envPaths = [Collections.Generic.List[String]]($rawPath -split ([IO.Path]::PathSeparator))
-          if ($envPaths -notcontains $Path) {
-              $envPaths.Add($Path)
-              $envKey.SetValue('PATH', ($envPaths -join ([IO.Path]::PathSeparator)), 'ExpandString')
-          }
-      }
-      finally {
-          if ($envKey) { $envKey.Close() }
-          if ($hiveKey) { $hiveKey.Close() }
-      }
-  }
-}
-
-
-
-filter Get-FileSize {
-	'{0:N2} {1}' -f $(
-	if ($_ -lt 1kb) { $_, 'Bytes' }
-	elseif ($_ -lt 1mb) { ($_/1kb), 'KB' }
-	elseif ($_ -lt 1gb) { ($_/1mb), 'MB' }
-	elseif ($_ -lt 1tb) { ($_/1gb), 'GB' }
-	elseif ($_ -lt 1pb) { ($_/1tb), 'TB' }
-	else { ($_/1pb), 'PB' }
-	)
-}
-
-function Get-FileWCSynchronous{
-    param(
-        [Parameter(Mandatory=$true)]
-        [string]$url, 
-        [string]$destinationFolder="$env:USERPROFILE\Downloads",
-        [switch]$includeStats
-    )
-    $wc = New-Object -TypeName Net.WebClient
-    $wc.UseDefaultCredentials = $true
-    $destination = Join-Path -Path $destinationFolder -ChildPath ($url | Split-Path -Leaf)
-    $start = Get-Date
-    $wc.DownloadFile($url, $destination)
-    $elapsed = ((Get-Date) - $start).ToString('hh\:mm\:ss')
-    $totalSize = (Get-Item -Path $destination).Length | Get-FileSize
-    if ($includeStats.IsPresent){
-        [PSCustomObject]@{Name=$MyInvocation.MyCommand;TotalSize=$totalSize;Time=$elapsed}
-    }
-    Get-Item -Path $destination | Unblock-File
-}
-
-function Test-AbsolutePath {
-  Param (
-      [Parameter(Mandatory=$True)]
-      [ValidateScript({[System.IO.Path]::IsPathRooted($_)})]
-      [String]$Path
-  )
-}
-
-function Exec
-{
-    [CmdletBinding()]
-    param(
-        [Parameter(Position = 0, Mandatory = 1)][string]$cmd,
-        [Parameter()][string]$errorMessage,
-        [parameter(ValueFromRemainingArguments = $true)]
-        [string[]]$Passthrough
-    )
-    & $cmd @Passthrough
-    if ($lastexitcode -ne 0) {
-        if (!($errorMessage)) {
-          throw ('Exec: Error executing command {0} with arguments ''{1}''' -f $cmd, "$Passthrough")
-        } else {
-          throw ('Exec: ' + $errorMessage)
-        }
-    }
-}
-
-$ErrorActionPreference = 'Stop'
-
-$GhcupBasePrefixEnv = [System.Environment]::GetEnvironmentVariable('GHCUP_INSTALL_BASE_PREFIX', 'user')
-
-if ($GhcupBasePrefixEnv) {
-  $defaultGhcupBasePrefix = $GhcupBasePrefixEnv
-} else {
-  $partitions = Get-CimInstance win32_logicaldisk
-  $defaultGhcupBasePrefix = $null
-  foreach ($p in $partitions){
-    try {
-      if ($p."FreeSpace" -lt 5368709120) { # at least 5 GB are needed
-        throw ("Not enough free space on {0}" -f $p."DeviceId")
-      }
-      $null = New-Item -Path ('{0}\' -f $p."DeviceId") -Name "ghcup.test" -ItemType "directory" -Force
-      $defaultGhcupBasePrefix = ('{0}\' -f $p."DeviceId")
-      Remove-Item -LiteralPath ('{0}\ghcup.test' -f $p."DeviceId")
-      break
-    } catch {
-      Print-Msg -color Yellow -msg ("{0} not writable or not enough disk space, trying next device" -f $p."DeviceId")
-    }
-  }
-  if ($defaultGhcupBasePrefix) {
-    Print-Msg -color Green -msg ("Picked {0} as default Install prefix!" -f $defaultGhcupBasePrefix)
-  } else {
-    Print-Msg -color Red -msg "Couldn't find a writable partition with at least 5GB free disk space!"
-    Exit 1    
-  }
-}
-
-# ask for base install prefix
-if ($Silent -and !($InstallDir)) {
-  $GhcupBasePrefix = $defaultGhcupBasePrefix
-} elseif ($InstallDir) {
-  if (!(Test-Path -LiteralPath ('{0}' -f $InstallDir) -IsValid)) {
-    Print-Msg -color Red -msg "Not a valid directory!"
-    Exit 1
-  } elseif (!(Split-Path -IsAbsolute -Path "$InstallDir")) {
-    Print-Msg -color Red -msg "Non-absolute Path specified!"
-    Exit 1
-  } else {
-    $GhcupBasePrefix = $InstallDir
-  }
-} else {
-  while ($true) {
-    Print-Msg -color Magenta -msg ('Where to install to (this should be a short Path, preferably a Drive like ''C:\''){1}Press enter to accept the default [{0}]:' -f $defaultGhcupBasePrefix, "`n")
-    $basePrefixPrompt = Read-Host
-    $GhcupBasePrefix = ($defaultGhcupBasePrefix,$basePrefixPrompt)[[bool]$basePrefixPrompt]
-    if (!($GhcupBasePrefix.EndsWith('\'))) {
-      $GhcupBasePrefix = ('{0}\' -f $GhcupBasePrefix)
-    }
-  
-    if (!($GhcupBasePrefix)) {
-      Print-Msg -color Red -msg "No directory specified!"
-    } elseif (!(Test-Path -LiteralPath ('{0}' -f $GhcupBasePrefix))) {
-      Print-Msg -color Red -msg "Directory does not exist, need to specify an existing Drive/Directory"
-    } elseif (!(Split-Path -IsAbsolute -Path "$GhcupBasePrefix")) {
-      Print-Msg -color Red -msg "Invalid/Non-absolute Path specified"
-    } else {
-      Break
-    }
-  }
-}
-
-Print-Msg -msg ('Setting env variable GHCUP_INSTALL_BASE_PREFIX to ''{0}''' -f $GhcupBasePrefix)
-$null = [Environment]::SetEnvironmentVariable("GHCUP_INSTALL_BASE_PREFIX", $GhcupBasePrefix, [System.EnvironmentVariableTarget]::User)
-
-
-$GhcupDir = ('{0}\ghcup' -f $GhcupBasePrefix)
-$MsysDir = ('{0}\msys64' -f $GhcupDir)
-$Bash = ('{0}\usr\bin\bash' -f $MsysDir)
-if (!($BootstrapUrl)) {
-  $BootstrapUrl = 'https://www.haskell.org/ghcup/sh/bootstrap-haskell'
-}
-$GhcupMsys2 = [System.Environment]::GetEnvironmentVariable('GHCUP_MSYS2', 'user')
-
-Print-Msg -msg 'Preparing for GHCup installation...'
-
-# ask what to do in case ghcup is already installed
-if (Test-Path -LiteralPath ('{0}' -f $GhcupDir)) {
-  Print-Msg -msg ('GHCup already installed at ''{0}''...' -f $GhcupDir)
-  if ($Overwrite) {
-    $decision = 0
-  } elseif (!($Silent)) {
-    $decision = $Host.UI.PromptForChoice('Install GHCup'
-                                        , 'GHCup is already installed, what do you want to do?'
-                                        , [System.Management.Automation.Host.ChoiceDescription[]] @('&Reinstall'
-                                            '&Continue'
-                                            '&Abort'), 1)
-  } else {
-    $decision = 1
-  }
-
-  if ($decision -eq 0) {
-    $suffix = [IO.Path]::GetRandomFileName()
-    Print-Msg -msg ('Backing up {0} to {0}-{1} ...' -f $GhcupDir, $suffix)
-    Rename-Item -Path ('{0}' -f $GhcupDir) -NewName ('{0}-{1}' -f $GhcupDir, $suffix)
-  } elseif ($decision -eq 1) {
-    Print-Msg -msg 'Continuing installation...'
-  } elseif ($decision -eq 2) {
-    Exit 0
-  }
-}
-
-
-$null = New-Item -Path ('{0}' -f $GhcupDir) -ItemType 'directory' -ErrorAction SilentlyContinue
-$null = New-Item -Path ('{0}' -f $GhcupDir) -Name 'bin' -ItemType 'directory' -ErrorAction SilentlyContinue
-
-# ask for cabal dir destination
-if ($CabalDir) {
-  $CabDirEnv = $CabalDir
-  if (!($CabDirEnv)) {
-    Print-Msg -color Red -msg "No directory specified!"
-    Exit 1        
-  } elseif (!(Split-Path -IsAbsolute -Path "$CabDirEnv")) {
-    Print-Msg -color Red -msg "Invalid/Non-absolute Path specified"
-    Exit 1
-  }
-} elseif (!($Silent)) {
-  while ($true) {
-
-    $defaultCabalDir = ('{0}\cabal' -f $GhcupBasePrefix)
-    Print-Msg -color Magenta -msg ('Specify Cabal directory (this is where haskell packages end up){1}Press enter to accept the default [{0}]:' -f $defaultCabalDir, "`n")
-    $CabalDirPrompt = Read-Host
-    $CabDirEnv = ($defaultCabalDir,$CabalDirPrompt)[[bool]$CabalDirPrompt]
-
-    if (!($CabDirEnv)) {
-      Print-Msg -color Red -msg "No directory specified!"         
-    } elseif (!(Split-Path -IsAbsolute -Path "$CabDirEnv")) {
-      Print-Msg -color Red -msg "Invalid/Non-absolute Path specified"
-    } else {
-      Break
-    }
-  }
-} else {
-  $CabDirEnv = ('{0}\cabal' -f $GhcupBasePrefix)
-}
-
-# ask whether to install HLS
-if (!($InstallHLS)) {
-  if (!($Silent)) {
-    $HLSdecision = $Host.UI.PromptForChoice('Install HLS'
-      , 'Do you want to install the haskell-language-server (HLS) for development purposes as well?'
-      , [System.Management.Automation.Host.ChoiceDescription[]] @('&Yes'
-          '&No'
-          '&Abort'), 1)
-
-    if ($HLSdecision -eq 0) {
-      $InstallHLS = $true
-    } elseif ($HLSdecision -eq 2) {
-      Exit 0
-    }
-  }
-}
-
-# ask whether to install stack
-if (!($InstallStack)) {
-  if (!($Silent)) {
-    $StackDecision = $Host.UI.PromptForChoice('Install stack'
-      , 'Do you want to install stack as well?'
-      , [System.Management.Automation.Host.ChoiceDescription[]] @('&Yes'
-          '&No'
-          '&Abort'), 1)
-
-    if ($StackDecision -eq 0) {
-      $InstallStack = $true
-    } elseif ($StackDecision -eq 2) {
-      Exit 0
-    }
-  }
-}
-
-
-# mingw foo
-Print-Msg -msg 'First checking for Msys2...'
-if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
-  if ($Silent) {
-    $msys2Decision = 0
-  } else {
-    $msys2Decision = $Host.UI.PromptForChoice('Install MSys2'
-        , 'Do you want GHCup to install a default MSys2 toolchain (recommended)?'
-        , [System.Management.Automation.Host.ChoiceDescription[]] @('&Yes'
-            '&No'), 0)
-  }
-
-  if ($msys2Decision -eq 0) {
-    Print-Msg -msg ('...Msys2 doesn''t exist, installing into {0}' -f $MsysDir)
-
-	Print-Msg -msg 'Starting installation in 5 seconds, this may take a while...'
-	Start-Sleep -s 5
-
-    # Download the archive
-    Print-Msg -msg 'Downloading Msys2 archive...'
-    $archive = 'msys2-x86_64-latest.sfx.exe'
-    
-    if (Get-Command -Name 'curl.exe' -ErrorAction SilentlyContinue) {
-      Exec "curl.exe" '-o' ('{0}\{1}' -f $env:TEMP, $archive) ('https://repo.msys2.org/distrib/{0}' -f $archive)
-    } else {
-      Get-FileWCSynchronous -url ('https://repo.msys2.org/distrib/{0}' -f $archive) -destinationFolder "$env:TEMP" -includeStats
-    }
-
-    Print-Msg -msg 'Extracting Msys2 archive...'
-    $null = & "$env:TEMP\$archive" '-y' ('-o{0}' -f $GhcupDir)  # Extract
-    Remove-Item -Path ('{0}/{1}' -f $env:TEMP, $archive)
-
-    Print-Msg -msg 'Processing MSYS2 bash for first time use...'
-    Exec "$Bash" '-lc' 'exit'
-
-    Exec "$env:windir\system32\taskkill.exe" /F /FI `"MODULES eq msys-2.0.dll`"
-
-    Print-Msg -msg 'Upgrading full system...'
-    Exec "$Bash" '-lc' 'pacman --noconfirm -Syuu'
-
-    Print-Msg -msg 'Upgrading full system twice...'
-    Exec "$Bash" '-lc' 'pacman --noconfirm -Syuu'
-
-    Print-Msg -msg 'Installing Dependencies...'
-    Exec "$Bash" '-lc' 'pacman --noconfirm -S --needed curl mingw-w64-x86_64-pkgconf'
-
-    Print-Msg -msg 'Updating SSL root certificate authorities...'
-    Exec "$Bash" '-lc' 'pacman --noconfirm -S ca-certificates'
-
-    Print-Msg -msg 'Setting default home directory...'
-    Exec "$Bash" '-lc' "sed -i -e 's/db_home:.*$/db_home: windows/' /etc/nsswitch.conf"
-  } elseif ($msys2Decision -eq 1) {
-    Print-Msg -color Yellow -msg 'Skipping MSys2 installation.'
-    while ($true) {
-      if ($GhcupMsys2) {
-        $defaultMsys2Dir = $GhcupMsys2
-        Print-Msg -color Magenta -msg ('Input existing MSys2 toolchain directory.{1}Press enter to accept the default [{0}]:' -f $defaultMsys2Dir, "`n")
-        $MsysDirPrompt = Read-Host
-        $MsysDir = ($defaultMsys2Dir,$MsysDirPrompt)[[bool]$MsysDirPrompt]
-      } else {
-        Print-Msg -color Magenta -msg 'Input existing MSys2 toolchain directory:' 
-        $MsysDir = Read-Host
-      }
-      if (!($MsysDir)) {
-        Print-Msg -color Red -msg "No directory specified!"         
-      } elseif (!(Test-Path -LiteralPath ('{0}' -f $MsysDir))) {
-        Print-Msg -color Red -msg ('MSys2 installation at ''{0}'' could not be found!' -f $MsysDir)
-      } elseif (!(Split-Path -IsAbsolute -Path "$MsysDir")) {
-        Print-Msg -color Red -msg "Invalid/Non-absolute Path specified"
-      } else {
-        Break
-      }
-    }
-    Print-Msg -msg ('Setting GHCUP_MSYS2 env var to ''{0}''' -f $MsysDir)
-    $null = [Environment]::SetEnvironmentVariable("GHCUP_MSYS2", $MsysDir, [System.EnvironmentVariableTarget]::User)
-    $Bash = ('{0}\usr\bin\bash' -f $MsysDir)
-  }
-} else {
-    Print-Msg -msg ('...Msys2 found in {0} ...skipping Msys2 installation.' -f $MsysDir)
-
-	Print-Msg -msg 'Starting installation in 5 seconds, this may take a while...'
-	Start-Sleep -s 5
-}
-
-Print-Msg -msg 'Creating shortcuts...'
-$uninstallShortCut = @'
-$decision = $Host.UI.PromptForChoice('Uninstall Haskell'
-, 'Do you want to uninstall all of the haskell toolchain, including GHC, Cabal, Stack and GHCup itself?'
-, [System.Management.Automation.Host.ChoiceDescription[]] @('&Uninstall'
-    '&Abort'), 0)
-
-if ($decision -eq 1) {
-  Exit 0
-}
-
-Write-Host 'Removing ghcup toolchain' -ForegroundColor Green
-ghcup nuke
-
-Write-Host 'Unsetting GHCUP_INSTALL_BASE_PREFIX' -ForegroundColor Green
-[Environment]::SetEnvironmentVariable('GHCUP_INSTALL_BASE_PREFIX', $null, [System.EnvironmentVariableTarget]::User)
-
-$ghcupMsys2 = [System.Environment]::GetEnvironmentVariable('GHCUP_MSYS2', 'user')
-$GhcupBasePrefixEnv = [System.Environment]::GetEnvironmentVariable('GHCUP_INSTALL_BASE_PREFIX', 'user')
-
-if ($ghcupMsys2) {
-  $msys2Dir = [IO.Path]::GetFullPath($ghcupMsys2)
-  $baseDir = [IO.Path]::GetFullPath('{0}\ghcup' -f $GhcupBasePrefixEnv)
-
-  if ($msys2Dir.StartsWith($baseDir)) {
-    Write-Host 'Unsetting GHCUP_MSYS2' -ForegroundColor Green
-    [Environment]::SetEnvironmentVariable('GHCUP_MSYS2', $null, [System.EnvironmentVariableTarget]::User)
-  } else {
-    Write-Host ('GHCUP_MSYS2 env variable is set to a non-standard location {0}. Environment variable not unset. Uninstall manually.' -f $msys2Dir) -ForegroundColor Magenta
-  }
-} else {
-  Write-Host 'Unsetting GHCUP_MSYS2' -ForegroundColor Green
-  [Environment]::SetEnvironmentVariable('GHCUP_MSYS2', $null, [System.EnvironmentVariableTarget]::User)
-}
-
-Write-Host 'Removing ghcup from PATH env var' -ForegroundColor Green
-$path = [System.Environment]::GetEnvironmentVariable(
-    'PATH',
-    'user'
-)
-$path = ($path.Split(';') | Where-Object { $_ -ne ('{0}\bin' -f $baseDir) }) -join ';'
-[System.Environment]::SetEnvironmentVariable(
-    'PATH',
-    $path,
-    'user'
-)
-
-Write-Host 'Removing desktop files' -ForegroundColor Green
-$DesktopDir = [Environment]::GetFolderPath("Desktop")
-Remove-Item -LiteralPath ('{0}\Install GHC dev dependencies.lnk' -f $DesktopDir) -Force
-Remove-Item -LiteralPath ('{0}\Mingw haskell shell.lnk' -f $DesktopDir) -Force
-Remove-Item -LiteralPath ('{0}\Mingw package management docs.url' -f $DesktopDir) -Force
-
-Write-Host ('CABAL_DIR env variable is still set to {0} and will be used by cabal regardless of ghcup. You may want to uninstall this manually.' -f [System.Environment]::GetEnvironmentVariable('CABAL_DIR', 'user')) -ForegroundColor Magenta
-Write-Host 'You may remove this script now.' -ForegroundColor Magenta
-
-if ($Host.Name -eq "ConsoleHost")
-{
-    Write-Host "Press any key to continue..."
-    $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyUp") > $null
-}
-'@
-
-$DesktopDir = [Environment]::GetFolderPath("Desktop")
-$GhcInstArgs = '-mingw64 -mintty -c "pacman --noconfirm -S --needed base-devel gettext autoconf make libtool automake python p7zip patch unzip"'
-Create-Shortcut -SourceExe ('{0}\msys2_shell.cmd' -f $MsysDir) -ArgumentsToSourceExe $GhcInstArgs -DestinationPath ('{0}\Install GHC dev dependencies.lnk' -f $DesktopDir)
-Create-Shortcut -SourceExe ('{0}\msys2_shell.cmd' -f $MsysDir) -ArgumentsToSourceExe '-mingw64' -DestinationPath ('{0}\Mingw haskell shell.lnk' -f $DesktopDir)
-Create-Shortcut -SourceExe 'https://www.msys2.org/docs/package-management' -ArgumentsToSourceExe '' -DestinationPath ('{0}\Mingw package management docs.url' -f $DesktopDir)
-$null = New-Item -Path $DesktopDir -Name "Uninstall Haskell.ps1" -ItemType "file" -Force -Value $uninstallShortCut
-
-Print-Msg -msg ('Adding {0}\bin to Users Path...' -f $GhcupDir)
-Add-EnvPath -Path ('{0}\bin' -f ([System.IO.Path]::GetFullPath("$GhcupDir"))) -Container 'User'
-
-
-
-$CabalDirFull = [System.IO.Path]::GetFullPath("$CabDirEnv")
-Print-Msg -msg ('Setting CABAL_DIR to ''{0}''' -f $CabalDirFull)
-$null = [Environment]::SetEnvironmentVariable("CABAL_DIR", $CabalDirFull, [System.EnvironmentVariableTarget]::User)
-
-Print-Msg -msg 'Starting GHCup installer...'
-
-$Msys2Shell = ('{0}\msys2_shell.cmd' -f $MsysDir)
-
-# The bootstrap script is always silent, since we ask relevant questions here
-$SilentExport = 'export BOOTSTRAP_HASKELL_NONINTERACTIVE=1 ;'
-
-if ($InstallStack) {
-  $StackInstallExport = 'export BOOTSTRAP_HASKELL_INSTALL_STACK=1 ;'
-}
-
-if ($InstallHLS) {
-  $HLSInstallExport = 'export BOOTSTRAP_HASKELL_INSTALL_HLS=1 ;'
-}
-
-if (!($NoAdjustCabalConfig)) {
-  $AdjustCabalConfigExport = 'export BOOTSTRAP_HASKELL_ADJUST_CABAL_CONFIG=1 ;'
-}
-
-if ((Get-Process -ID $PID).ProcessName.StartsWith("bootstrap-haskell") -Or $InBash) {
-  Exec "$Bash" '-lc' ('{4} {6} {7} {8} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport)
-} else {
-  Exec "$Msys2Shell" '-mingw64' '-mintty' '-c' ('{4} {6} {7} {8} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; trap ''echo Press any key to exit && read -n 1 && exit'' 2 ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash ; echo ''Press any key to exit'' && read -n 1' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport)
-}
-
-
-# SIG # Begin signature block
-  # MIID4QYJKoZIhvcNAQcCoIID0jCCA84CAQExCzAJBgUrDgMCGgUAMGkGCisGAQQB
-  # gjcCAQSgWzBZMDQGCisGAQQBgjcCAR4wJgIDAQAABBAfzDtgWUsITrck0sYpfvNR
-  # AgEAAgEAAgEAAgEAAgEAMCEwCQYFKw4DAhoFAAQUVqKek181kF/Jx/P7z176herc
-  # ZyCgggH/MIIB+zCCAWSgAwIBAgIQGOezhGS1A5tHh9VubW0liDANBgkqhkiG9w0B
-  # AQUFADAYMRYwFAYDVQQDDA1KdWxpYW4gT3NwYWxkMB4XDTIxMDUzMDE4Mzk1OVoX
-  # DTI1MDUzMDAwMDAwMFowGDEWMBQGA1UEAwwNSnVsaWFuIE9zcGFsZDCBnzANBgkq
-  # hkiG9w0BAQEFAAOBjQAwgYkCgYEAs76XCXYPM14buR1RkVKhOB8pyM4Df6kPaz75
-  # nkbA0nq1VmMhBfCYFWyYHd7jniqTH0LoAKGGquN1bniREaCP9j2pFWpMIgLpQH3H
-  # +jpsfmxV2BTG8q+Jok88gTXS1FlAk72E85zO/Jhr6Fja1aFYAdibBRsRxcVMTVh7
-  # 4AGLNGUCAwEAAaNGMEQwEwYDVR0lBAwwCgYIKwYBBQUHAwMwHQYDVR0OBBYEFC+R
-  # hdhPo0Ty5HnzHyo1pN35IfZQMA4GA1UdDwEB/wQEAwIHgDANBgkqhkiG9w0BAQUF
-  # AAOBgQAl3IdBVIwbJJDp7BksMYPeM4ivB3UyNvlw8aVxGwAzNgdSaezYIdMFtKXV
-  # CSv5bd4VnFRAPDJW9dhW0h3SkeJUoklUxMjKXhR3qygQhSxPDjIatAuOCffGACba
-  # ZZ7Om40b+pKXc6i/HnlApk9DGbXJ59bFcLGGcZ9QjoUae6Ex1DGCAUwwggFIAgEB
-  # MCwwGDEWMBQGA1UEAwwNSnVsaWFuIE9zcGFsZAIQGOezhGS1A5tHh9VubW0liDAJ
-  # BgUrDgMCGgUAoHgwGAYKKwYBBAGCNwIBDDEKMAigAoAAoQKAADAZBgkqhkiG9w0B
-  # CQMxDAYKKwYBBAGCNwIBBDAcBgorBgEEAYI3AgELMQ4wDAYKKwYBBAGCNwIBFTAj
-  # BgkqhkiG9w0BCQQxFgQUosm9nN1JgajqSBa1cUwxxhLrAsYwDQYJKoZIhvcNAQEB
-  # BQAEgYCnKzfsH1aDjS6xkC/uymjaBowHSnh6nFu2AkjcKu8RgcBZzP5SLBXgU9wm
-  # aED5Ujwyq3Qre+TGVRUqwkEauDhQiX2A008G00fRO6+di6yJRCRn5eaRAbdU3Xww
-  # E5VhEwLBnwzWrvLKtdEclhgUCo5Tq87QMXVdgX4aRmunl4ZE+Q==
-# SIG # End signature block
-
-
-
-
-
-
-
--- a/cabal.ghc8104.project
+++ b/cabal.ghc8104.project
@@ -0,0 +1,20 @@
+packages: ./ghcup.cabal
+
+with-compiler: ghc-8.10.4
+
+optional-packages: ./3rdparty/*/*.cabal
+
+optimization: 2
+
+package streamly
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+package ghcup
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+constraints: http-io-streams -brotli
+
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell
--- a/cabal.ghc8104.project.freeze
+++ b/cabal.ghc8104.project.freeze
@@ -1,11 +1,12 @@
 active-repositories: hackage.haskell.org:merge
 constraints: any.Cabal ==3.2.1.0,
             any.HUnit ==1.6.2.0,
-             any.HsOpenSSL ==0.11.7,
-             HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
+             any.IfElse ==0.85,
             any.QuickCheck ==2.14.2,
             QuickCheck -old-random +templatehaskell,
-             any.StateVar ==1.2.2,
+             any.StateVar ==1.2.1,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
             any.aeson ==1.5.6.0,
             aeson -bytestring-builder -cffi -developer -fast,
             any.aeson-pretty ==0.8.8,
@@ -17,32 +18,31 @@ constraints: any.Cabal ==3.2.1.0,
             any.ansi-wl-pprint ==0.6.9,
             ansi-wl-pprint -example,
             any.array ==0.5.4.0,
+             any.ascii-string ==1.0.1.4,
             any.assoc ==1.0.2,
             any.async ==2.2.3,
             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
             any.attoparsec ==0.13.2.5,
             attoparsec -developer,
             any.auto-update ==0.1.6,
-             any.base ==4.14.2.0,
+             any.base ==4.14.1.0,
             any.base-compat ==0.11.2,
             any.base-compat-batteries ==0.11.2,
             any.base-orphans ==0.8.4,
             any.base16-bytestring ==1.0.1.0,
-             any.base64-bytestring ==1.1.0.0,
-             any.bifunctors ==5.5.11,
+             any.base64-bytestring ==1.2.0.1,
+             any.bifunctors ==5.5.10,
             bifunctors +semigroups +tagged,
             any.binary ==0.8.8.0,
-             any.bindings-DSL ==1.0.25,
             any.blaze-builder ==0.4.2.1,
-             any.brick ==0.63,
-             brick -demos,
             any.bytestring ==0.10.12.0,
             any.bz2 ==1.0.1.0,
             bz2 -cross +with-bzlib,
-             any.bzlib-conduit ==0.3.0.2,
-             any.c2hs ==0.28.8,
+             any.c2hs ==0.28.7,
             c2hs +base3 -regression,
-             any.call-stack ==0.4.0,
+             any.call-stack ==0.3.0,
             any.case-insensitive ==1.2.1.0,
             any.casing ==0.1.4.1,
             any.cereal ==0.5.8.1,
@@ -54,7 +54,7 @@ constraints: any.Cabal ==3.2.1.0,
             clock -llvm,
             any.cmdargs ==0.10.21,
             cmdargs +quotation -testprog,
-             any.colour ==2.3.6,
+             any.colour ==2.3.5,
             any.comonad ==5.0.8,
             comonad +containers +distributive +indexed-traversable,
             any.composition-prelude ==3.0.0.2,
@@ -62,25 +62,16 @@ constraints: any.Cabal ==3.2.1.0,
             any.concurrent-output ==1.10.12,
             any.conduit ==1.3.4.1,
             any.conduit-extra ==1.3.5,
-             any.conduit-zstd ==0.0.2.0,
-             any.config-ini ==0.2.4.0,
-             config-ini -enable-doctests,
-             any.containers ==0.6.4.1,
-             any.contravariant ==1.5.4,
+             any.containers ==0.6.2.1,
+             any.contravariant ==1.5.3,
             contravariant +semigroups +statevar +tagged,
-             any.cpphs ==1.20.9.1,
-             cpphs -old-locale,
-             any.cryptohash-sha1 ==0.11.100.1,
             any.cryptohash-sha256 ==0.11.102.0,
             cryptohash-sha256 -exe +use-cbits,
-             any.data-clist ==0.1.2.3,
             any.data-default-class ==0.1.2.0,
             any.data-fix ==0.3.1,
             any.deepseq ==1.4.4.0,
-             any.digest ==0.0.1.3,
-             digest -bytestring-in-base,
+             any.deferred-folds ==0.9.17,
             any.directory ==1.3.6.0,
-             any.disk-free-space ==0.1.0.1,
             any.distributive ==0.6.2.1,
             distributive +semigroups +tagged,
             any.dlist ==1.0,
@@ -88,68 +79,74 @@ constraints: any.Cabal ==3.2.1.0,
             any.easy-file ==0.2.2,
             any.errors ==2.3.0,
             any.exceptions ==0.10.4,
-             any.extra ==1.7.9,
-             any.fast-logger ==3.0.5,
+             any.fast-logger ==3.0.3,
             any.filepath ==1.4.2.1,
-             any.free ==5.1.7,
+             any.focus ==1.0.2,
+             any.foldl ==1.4.11,
+             any.free ==5.1.6,
+             any.fusion-plugin-types ==0.1.0,
             any.generic-arbitrary ==0.1.0,
             any.generics-sop ==0.5.1.1,
-             any.ghc-boot-th ==8.10.5,
-             any.ghc-byteorder ==4.11.0.0.10,
+             any.ghc-boot-th ==8.10.4,
             any.ghc-prim ==0.6.1,
+             ghcup -internal-downloader -tar -tui,
             any.happy ==1.20.0,
-             any.hashable ==1.3.2.0,
-             hashable +integer-gmp -random-initial-seed,
+             any.hashable ==1.3.1.0,
+             hashable +integer-gmp,
             any.haskell-src-exts ==1.23.1,
             any.haskell-src-meta ==0.8.7,
             any.haskus-utils-data ==1.4,
             any.haskus-utils-types ==1.5.1,
             any.haskus-utils-variant ==3.1,
+             any.heaps ==0.3.6.1,
+             any.hpath ==0.11.0,
+             any.hpath-directory ==0.14.1,
             any.hpath-filepath ==0.10.4,
-             any.hpath-posix ==0.13.3,
+             any.hpath-io ==0.14.1,
+             any.hpath-posix ==0.13.2,
             any.hsc2hs ==0.68.7,
             hsc2hs -in-ghc-tree,
-             any.hspec ==2.7.10,
-             any.hspec-core ==2.7.10,
-             any.hspec-discover ==2.7.10 || ==2.8.2,
+             any.hspec ==2.7.8,
+             any.hspec-core ==2.7.8,
+             any.hspec-discover ==2.7.8,
             any.hspec-expectations ==0.8.2,
-             any.hspec-golden-aeson ==0.9.0.0,
-             any.http-io-streams ==0.1.6.0,
-             http-io-streams -brotli +fast-xor,
-             any.indexed-profunctors ==0.1.1,
+             any.hspec-golden-aeson ==0.7.0.0,
+             any.indexed-profunctors ==0.1,
             any.indexed-traversable ==0.1.1,
             any.indexed-traversable-instances ==0.1,
             any.integer-gmp ==1.0.3.0,
             any.integer-logarithms ==1.0.3.1,
             integer-logarithms -check-bounds +integer-gmp,
-             any.io-streams ==1.5.2.1,
-             io-streams +network -nointeractivetests +zlib,
-             any.language-c ==0.9.0.1,
-             language-c -allwarnings +iecfpextension +usebytestrings,
-             any.libarchive ==3.0.2.2,
+             any.language-c ==0.8.3,
+             language-c -allwarnings +iecfpextension +separatesyb +usebytestrings,
+             any.libarchive ==3.0.2.1,
             libarchive -cross -low-memory -system-libarchive,
             any.libyaml ==0.1.2,
             libyaml -no-unicode -system-libyaml,
             any.lifted-base ==0.2.3.12,
-             any.lzma-static ==5.2.5.4,
+             any.list-t ==1.0.4,
+             any.lockfree-queue ==0.2.3.1,
+             lzma -static,
+             any.math-functions ==0.3.4.1,
+             math-functions +system-erf +system-expm1,
             any.megaparsec ==9.0.1,
             megaparsec -dev,
             any.microlens ==0.4.12.0,
             any.microlens-mtl ==0.2.0.1,
-             any.microlens-th ==0.4.3.10,
-             any.monad-control ==1.0.3,
+             any.microlens-th ==0.4.3.9,
+             any.mmorph ==1.1.5,
+             any.monad-control ==1.0.2.3,
             any.monad-logger ==0.3.36,
             monad-logger +template_haskell,
             any.monad-loops ==0.4.3,
             monad-loops +base4,
             any.mono-traversable ==1.0.15.1,
             any.mtl ==2.2.2,
-             any.network ==3.1.2.2,
+             any.mwc-random ==0.15.0.1,
+             any.network ==3.1.2.1,
             network -devel,
-             any.network-uri ==2.6.4.1,
             any.old-locale ==1.0.0.7,
             any.old-time ==1.1.0.3,
-             any.openssl-streams ==1.2.3.0,
             any.optics ==0.4,
             any.optics-core ==0.4,
             optics-core -explicit-generic-labels,
@@ -164,25 +161,25 @@ constraints: any.Cabal ==3.2.1.0,
             any.parsec ==3.1.14.0,
             any.parser-combinators ==1.3.0,
             parser-combinators -dev,
-             any.polyparse ==1.13,
             any.pretty ==1.1.3.6,
             any.pretty-terminal ==0.1.0.0,
             any.primitive ==0.7.1.0,
+             any.primitive-extras ==0.8.2,
+             any.primitive-unlifted ==0.1.3.0,
             any.process ==1.6.9.0,
             any.profunctors ==5.6.2,
             any.quickcheck-arbitrary-adt ==0.3.1.0,
             any.quickcheck-io ==0.2.0,
             any.random ==1.2.0,
-             any.recursion-schemes ==5.2.2.1,
+             any.recursion-schemes ==5.2.2,
             recursion-schemes +template-haskell,
-             any.regex-base ==0.94.0.1,
-             any.regex-posix ==0.96.0.1,
+             any.regex-posix ==0.96.0.0,
             regex-posix -_regex-posix-clib,
             any.resourcet ==1.2.4.2,
-             any.rts ==1.0.1,
+             any.rts ==1.0,
             any.safe ==0.3.19,
-             any.safe-exceptions ==0.1.7.2,
-             any.scientific ==0.3.7.0,
+             any.safe-exceptions ==0.1.7.1,
+             any.scientific ==0.3.6.2,
             scientific -bytestring-builder -integer-simple,
             any.semigroupoids ==5.3.5,
             semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
@@ -191,31 +188,36 @@ constraints: any.Cabal ==3.2.1.0,
             any.split ==0.2.3.4,
             any.splitmix ==0.1.0.3,
             splitmix -optimised-mixer,
-             any.stm ==2.5.0.1,
+             any.stm ==2.5.0.0,
             any.stm-chans ==3.0.0.4,
             any.streaming-commons ==0.2.2.1,
             streaming-commons -use-bytestring-builder,
+             any.streamly ==0.7.3,
+             streamly -debug -dev -examples -examples-sdl -fusion-plugin -has-llvm -inspection -no-fusion -streamk,
+             any.streamly-bytestring ==0.1.2,
+             any.streamly-posix ==0.1.0.1,
             any.strict ==0.4.0.1,
             strict +assoc,
             any.strict-base ==0.4.0.0,
-             any.string-interpolate ==0.3.1.1,
+             any.string-interpolate ==0.3.1.0,
             string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
             any.syb ==0.7.2.1,
             any.tagged ==0.8.6.1,
             tagged +deepseq +transformers,
-             any.tar ==0.6.0.0,
+             any.tasty ==1.3.1,
+             tasty +clock,
+             any.tasty-hunit ==0.10.0.3,
+             any.tasty-quickcheck ==0.10.1.2,
             any.template-haskell ==2.16.0.0,
-             any.temporary ==1.3,
-             any.terminal-progress-bar ==0.4.1,
             any.terminal-size ==0.3.2.1,
             any.terminfo ==0.4.1.4,
             any.text ==1.2.4.1,
             any.text-conversions ==0.3.1,
-             any.text-zipper ==0.11,
+             any.text-short ==0.1.3,
+             text-short -asserts,
             any.tf-random ==0.5,
             any.th-abstraction ==0.4.2.0,
-             any.th-compat ==0.1.2,
-             any.th-expand-syns ==0.4.8.0,
+             any.th-compat ==0.1.1,
             any.th-lift ==0.8.2,
             any.th-lift-instances ==0.1.18,
             any.th-orphans ==0.13.11,
@@ -223,42 +225,37 @@ constraints: any.Cabal ==3.2.1.0,
             any.these ==1.1.1.1,
             these +assoc,
             any.time ==1.9.3,
-             any.time-compat ==1.9.6,
+             any.time-compat ==1.9.5,
             time-compat -old-locale,
             any.transformers ==0.5.6.2,
             any.transformers-base ==0.4.5.2,
             transformers-base +orphaninstances,
-             any.transformers-compat ==0.7,
+             any.transformers-compat ==0.6.6,
             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
             any.typed-process ==0.2.6.0,
+             any.unbounded-delays ==0.1.1.1,
             any.unix ==2.7.2.2,
             any.unix-bytestring ==0.3.7.3,
             any.unix-compat ==0.5.3,
             unix-compat -old-time,
             any.unix-time ==0.4.7,
             any.unliftio-core ==0.2.0.1,
-             any.unordered-containers ==0.2.14.0,
+             any.unordered-containers ==0.2.13.0,
             unordered-containers -debug,
-             any.uri-bytestring ==0.3.3.1,
+             any.uri-bytestring ==0.3.3.0,
             uri-bytestring -lib-werror,
             any.utf8-string ==1.0.2,
-             any.uuid-types ==1.0.5,
-             any.vector ==0.12.3.0,
+             any.uuid-types ==1.0.4,
+             any.vector ==0.12.2.0,
             vector +boundschecks -internalchecks -unsafechecks -wall,
             any.vector-algorithms ==0.8.0.4,
             vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
-             any.versions ==5.0.0,
+             any.versions ==4.0.3,
             any.vty ==5.33,
-             any.word-wrap ==0.4.1,
+             any.wcwidth ==0.0.2,
+             wcwidth -cli +split-base,
             any.word8 ==0.1.3,
-             any.xor ==0.0.1.0,
             any.yaml ==0.11.5.0,
             yaml +no-examples +no-exe,
-             any.zip ==1.7.1,
-             zip -dev -disable-bzip2 -disable-zstd,
-             any.zlib ==0.6.2.3,
-             zlib -bundled-c-zlib -non-blocking-ffi -pkg-config,
-             any.zlib-bindings ==0.1.1.5,
-             any.zstd ==0.1.2.0,
-             zstd +standalone
-index-state: hackage.haskell.org 2021-07-27T07:59:57Z
+             zlib -non-blocking-ffi -pkg-config -static
+index-state: hackage.haskell.org 2021-03-07T18:36:25Z
--- a/cabal.ghc8105.project
+++ b/cabal.ghc8105.project
@@ -1,33 +0,0 @@
-packages: ./ghcup.cabal
-
-optional-packages: ./vendored/*/*.cabal
-
-optimization: 2
-
-package ghcup
-    tests: True
-    flags: +tui
-
-source-repository-package
-    type: git
-    location: https://github.com/jtdaugherty/brick.git
-    tag: b3b96cfe66dfd398d338e3feb2b6855e66a35190
-
-source-repository-package
-    type: git
-    location: https://github.com/Bodigrim/tar
-    tag: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
-
-source-repository-package
-    type: git
-    location: https://github.com/bgamari/terminal-size
-    tag: 34ea816bd63f75f800eedac12c6908c6f3736036
-
-constraints: http-io-streams -brotli
-
-package libarchive
-  flags: -system-libarchive
-
-allow-newer: base, ghc-prim, template-haskell, language-c
-
-with-compiler: ghc-8.10.5
--- a/cabal.ghc884.project
+++ b/cabal.ghc884.project
@@ -0,0 +1,20 @@
+packages: ./ghcup.cabal
+
+with-compiler: ghc-8.8.4
+
+optional-packages: ./3rdparty/*/*.cabal
+
+optimization: 2
+
+package streamly
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+package ghcup
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+constraints: http-io-streams -brotli
+
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell
--- a/cabal.ghc884.project.freeze
+++ b/cabal.ghc884.project.freeze
@@ -1,11 +1,12 @@
 active-repositories: hackage.haskell.org:merge
-constraints: any.Cabal ==3.4.0.0,
+constraints: any.Cabal ==3.0.1.0,
             any.HUnit ==1.6.2.0,
-             any.HsOpenSSL ==0.11.7,
-             HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
+             any.IfElse ==0.85,
             any.QuickCheck ==2.14.2,
             QuickCheck -old-random +templatehaskell,
-             any.StateVar ==1.2.2,
+             any.StateVar ==1.2.1,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
             any.aeson ==1.5.6.0,
             aeson -bytestring-builder -cffi -developer -fast,
             any.aeson-pretty ==0.8.8,
@@ -17,32 +18,31 @@ constraints: any.Cabal ==3.4.0.0,
             any.ansi-wl-pprint ==0.6.9,
             ansi-wl-pprint -example,
             any.array ==0.5.4.0,
+             any.ascii-string ==1.0.1.4,
             any.assoc ==1.0.2,
             any.async ==2.2.3,
             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
             any.attoparsec ==0.13.2.5,
             attoparsec -developer,
             any.auto-update ==0.1.6,
-             any.base ==4.15.0.0,
+             any.base ==4.13.0.0,
             any.base-compat ==0.11.2,
             any.base-compat-batteries ==0.11.2,
             any.base-orphans ==0.8.4,
             any.base16-bytestring ==1.0.1.0,
-             any.base64-bytestring ==1.1.0.0,
-             any.bifunctors ==5.5.11,
+             any.base64-bytestring ==1.2.0.1,
+             any.bifunctors ==5.5.10,
             bifunctors +semigroups +tagged,
-             any.binary ==0.8.8.0,
-             any.bindings-DSL ==1.0.25,
+             any.binary ==0.8.7.0,
             any.blaze-builder ==0.4.2.1,
-             any.brick ==0.63,
-             brick -demos,
-             any.bytestring ==0.10.12.1,
+             any.bytestring ==0.10.10.1,
             any.bz2 ==1.0.1.0,
             bz2 -cross +with-bzlib,
-             any.bzlib-conduit ==0.3.0.2,
-             any.c2hs ==0.28.8,
+             any.c2hs ==0.28.7,
             c2hs +base3 -regression,
-             any.call-stack ==0.4.0,
+             any.call-stack ==0.3.0,
             any.case-insensitive ==1.2.1.0,
             any.casing ==0.1.4.1,
             any.cereal ==0.5.8.1,
@@ -54,7 +54,7 @@ constraints: any.Cabal ==3.4.0.0,
             clock -llvm,
             any.cmdargs ==0.10.21,
             cmdargs +quotation -testprog,
-             any.colour ==2.3.6,
+             any.colour ==2.3.5,
             any.comonad ==5.0.8,
             comonad +containers +distributive +indexed-traversable,
             any.composition-prelude ==3.0.0.2,
@@ -62,25 +62,16 @@ constraints: any.Cabal ==3.4.0.0,
             any.concurrent-output ==1.10.12,
             any.conduit ==1.3.4.1,
             any.conduit-extra ==1.3.5,
-             any.conduit-zstd ==0.0.2.0,
-             any.config-ini ==0.2.4.0,
-             config-ini -enable-doctests,
-             any.containers ==0.6.4.1,
-             any.contravariant ==1.5.4,
+             any.containers ==0.6.2.1,
+             any.contravariant ==1.5.3,
             contravariant +semigroups +statevar +tagged,
-             any.cpphs ==1.20.9.1,
-             cpphs -old-locale,
-             any.cryptohash-sha1 ==0.11.100.1,
             any.cryptohash-sha256 ==0.11.102.0,
             cryptohash-sha256 -exe +use-cbits,
-             any.data-clist ==0.1.2.3,
             any.data-default-class ==0.1.2.0,
             any.data-fix ==0.3.1,
-             any.deepseq ==1.4.5.0,
-             any.digest ==0.0.1.3,
-             digest -bytestring-in-base,
-             any.directory ==1.3.6.1,
-             any.disk-free-space ==0.1.0.1,
+             any.deepseq ==1.4.4.0,
+             any.deferred-folds ==0.9.17,
+             any.directory ==1.3.6.0,
             any.distributive ==0.6.2.1,
             distributive +semigroups +tagged,
             any.dlist ==1.0,
@@ -88,68 +79,75 @@ constraints: any.Cabal ==3.4.0.0,
             any.easy-file ==0.2.2,
             any.errors ==2.3.0,
             any.exceptions ==0.10.4,
-             any.extra ==1.7.9,
-             any.fast-logger ==3.0.5,
+             exceptions +transformers-0-4,
+             any.fast-logger ==3.0.3,
             any.filepath ==1.4.2.1,
-             any.free ==5.1.7,
+             any.focus ==1.0.2,
+             any.foldl ==1.4.11,
+             any.free ==5.1.6,
+             any.fusion-plugin-types ==0.1.0,
             any.generic-arbitrary ==0.1.0,
             any.generics-sop ==0.5.1.1,
-             any.ghc-bignum ==1.0,
-             any.ghc-boot-th ==9.0.1,
-             any.ghc-byteorder ==4.11.0.0.10,
-             any.ghc-prim ==0.7.0,
+             any.ghc-boot-th ==8.8.4,
+             any.ghc-prim ==0.5.3,
+             ghcup -internal-downloader -tar -tui,
             any.happy ==1.20.0,
-             any.hashable ==1.3.2.0,
-             hashable +integer-gmp -random-initial-seed,
+             any.hashable ==1.3.1.0,
+             hashable +integer-gmp,
             any.haskell-src-exts ==1.23.1,
             any.haskell-src-meta ==0.8.7,
             any.haskus-utils-data ==1.4,
             any.haskus-utils-types ==1.5.1,
             any.haskus-utils-variant ==3.1,
+             any.heaps ==0.3.6.1,
+             any.hpath ==0.11.0,
+             any.hpath-directory ==0.14.1,
             any.hpath-filepath ==0.10.4,
-             any.hpath-posix ==0.13.3,
+             any.hpath-io ==0.14.1,
+             any.hpath-posix ==0.13.2,
             any.hsc2hs ==0.68.7,
             hsc2hs -in-ghc-tree,
-             any.hspec ==2.7.10,
-             any.hspec-core ==2.7.10,
-             any.hspec-discover ==2.7.10 || ==2.8.2,
+             any.hspec ==2.7.8,
+             any.hspec-core ==2.7.8,
+             any.hspec-discover ==2.7.8,
             any.hspec-expectations ==0.8.2,
-             any.hspec-golden-aeson ==0.9.0.0,
-             any.http-io-streams ==0.1.6.0,
-             http-io-streams -brotli +fast-xor,
-             any.indexed-profunctors ==0.1.1,
+             any.hspec-golden-aeson ==0.7.0.0,
+             any.indexed-profunctors ==0.1,
             any.indexed-traversable ==0.1.1,
             any.indexed-traversable-instances ==0.1,
+             any.integer-gmp ==1.0.2.0,
             any.integer-logarithms ==1.0.3.1,
             integer-logarithms -check-bounds +integer-gmp,
-             any.io-streams ==1.5.2.1,
-             io-streams +network -nointeractivetests +zlib,
-             any.language-c ==0.9.0.1,
-             language-c -allwarnings +iecfpextension +usebytestrings,
-             any.libarchive ==3.0.2.2,
+             any.language-c ==0.8.3,
+             language-c -allwarnings +iecfpextension +separatesyb +usebytestrings,
+             any.libarchive ==3.0.2.1,
             libarchive -cross -low-memory -system-libarchive,
             any.libyaml ==0.1.2,
             libyaml -no-unicode -system-libyaml,
             any.lifted-base ==0.2.3.12,
-             any.lzma-static ==5.2.5.4,
+             any.list-t ==1.0.4,
+             any.lockfree-queue ==0.2.3.1,
+             lzma -static,
+             any.math-functions ==0.3.4.1,
+             math-functions +system-erf +system-expm1,
             any.megaparsec ==9.0.1,
             megaparsec -dev,
             any.microlens ==0.4.12.0,
             any.microlens-mtl ==0.2.0.1,
-             any.microlens-th ==0.4.3.10,
-             any.monad-control ==1.0.3,
+             any.microlens-th ==0.4.3.9,
+             any.mmorph ==1.1.5,
+             any.monad-control ==1.0.2.3,
             any.monad-logger ==0.3.36,
             monad-logger +template_haskell,
             any.monad-loops ==0.4.3,
             monad-loops +base4,
             any.mono-traversable ==1.0.15.1,
             any.mtl ==2.2.2,
-             any.network ==3.1.2.2,
+             any.mwc-random ==0.15.0.1,
+             any.network ==3.1.2.1,
             network -devel,
-             any.network-uri ==2.6.4.1,
             any.old-locale ==1.0.0.7,
             any.old-time ==1.1.0.3,
-             any.openssl-streams ==1.2.3.0,
             any.optics ==0.4,
             any.optics-core ==0.4,
             optics-core -explicit-generic-labels,
@@ -164,25 +162,25 @@ constraints: any.Cabal ==3.4.0.0,
             any.parsec ==3.1.14.0,
             any.parser-combinators ==1.3.0,
             parser-combinators -dev,
-             any.polyparse ==1.13,
             any.pretty ==1.1.3.6,
             any.pretty-terminal ==0.1.0.0,
             any.primitive ==0.7.1.0,
-             any.process ==1.6.11.0,
+             any.primitive-extras ==0.8.2,
+             any.primitive-unlifted ==0.1.3.0,
+             any.process ==1.6.9.0,
             any.profunctors ==5.6.2,
             any.quickcheck-arbitrary-adt ==0.3.1.0,
             any.quickcheck-io ==0.2.0,
             any.random ==1.2.0,
-             any.recursion-schemes ==5.2.2.1,
+             any.recursion-schemes ==5.2.2,
             recursion-schemes +template-haskell,
-             any.regex-base ==0.94.0.1,
-             any.regex-posix ==0.96.0.1,
+             any.regex-posix ==0.96.0.0,
             regex-posix -_regex-posix-clib,
             any.resourcet ==1.2.4.2,
             any.rts ==1.0,
             any.safe ==0.3.19,
-             any.safe-exceptions ==0.1.7.2,
-             any.scientific ==0.3.7.0,
+             any.safe-exceptions ==0.1.7.1,
+             any.scientific ==0.3.6.2,
             scientific -bytestring-builder -integer-simple,
             any.semigroupoids ==5.3.5,
             semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
@@ -195,27 +193,32 @@ constraints: any.Cabal ==3.4.0.0,
             any.stm-chans ==3.0.0.4,
             any.streaming-commons ==0.2.2.1,
             streaming-commons -use-bytestring-builder,
+             any.streamly ==0.7.3,
+             streamly -debug -dev -examples -examples-sdl -fusion-plugin -has-llvm -inspection -no-fusion -streamk,
+             any.streamly-bytestring ==0.1.2,
+             any.streamly-posix ==0.1.0.1,
             any.strict ==0.4.0.1,
             strict +assoc,
             any.strict-base ==0.4.0.0,
-             any.string-interpolate ==0.3.1.1,
+             any.string-interpolate ==0.3.1.0,
             string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
             any.syb ==0.7.2.1,
             any.tagged ==0.8.6.1,
             tagged +deepseq +transformers,
-             any.tar ==0.6.0.0,
-             any.template-haskell ==2.17.0.0,
-             any.temporary ==1.3,
-             any.terminal-progress-bar ==0.4.1,
+             any.tasty ==1.3.1,
+             tasty +clock,
+             any.tasty-hunit ==0.10.0.3,
+             any.tasty-quickcheck ==0.10.1.2,
+             any.template-haskell ==2.15.0.0,
             any.terminal-size ==0.3.2.1,
             any.terminfo ==0.4.1.4,
-             any.text ==1.2.4.1,
+             any.text ==1.2.4.0,
             any.text-conversions ==0.3.1,
-             any.text-zipper ==0.11,
+             any.text-short ==0.1.3,
+             text-short -asserts,
             any.tf-random ==0.5,
             any.th-abstraction ==0.4.2.0,
-             any.th-compat ==0.1.2,
-             any.th-expand-syns ==0.4.8.0,
+             any.th-compat ==0.1.1,
             any.th-lift ==0.8.2,
             any.th-lift-instances ==0.1.18,
             any.th-orphans ==0.13.11,
@@ -223,42 +226,37 @@ constraints: any.Cabal ==3.4.0.0,
             any.these ==1.1.1.1,
             these +assoc,
             any.time ==1.9.3,
-             any.time-compat ==1.9.6,
+             any.time-compat ==1.9.5,
             time-compat -old-locale,
             any.transformers ==0.5.6.2,
             any.transformers-base ==0.4.5.2,
             transformers-base +orphaninstances,
-             any.transformers-compat ==0.7,
+             any.transformers-compat ==0.6.6,
             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
             any.typed-process ==0.2.6.0,
+             any.unbounded-delays ==0.1.1.1,
             any.unix ==2.7.2.2,
             any.unix-bytestring ==0.3.7.3,
             any.unix-compat ==0.5.3,
             unix-compat -old-time,
             any.unix-time ==0.4.7,
             any.unliftio-core ==0.2.0.1,
-             any.unordered-containers ==0.2.14.0,
+             any.unordered-containers ==0.2.13.0,
             unordered-containers -debug,
-             any.uri-bytestring ==0.3.3.1,
+             any.uri-bytestring ==0.3.3.0,
             uri-bytestring -lib-werror,
             any.utf8-string ==1.0.2,
-             any.uuid-types ==1.0.5,
-             any.vector ==0.12.3.0,
+             any.uuid-types ==1.0.4,
+             any.vector ==0.12.2.0,
             vector +boundschecks -internalchecks -unsafechecks -wall,
             any.vector-algorithms ==0.8.0.4,
             vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
-             any.versions ==5.0.0,
+             any.versions ==4.0.3,
             any.vty ==5.33,
-             any.word-wrap ==0.4.1,
+             any.wcwidth ==0.0.2,
+             wcwidth -cli +split-base,
             any.word8 ==0.1.3,
-             any.xor ==0.0.1.0,
             any.yaml ==0.11.5.0,
             yaml +no-examples +no-exe,
-             any.zip ==1.7.1,
-             zip -dev -disable-bzip2 -disable-zstd,
-             any.zlib ==0.6.2.3,
-             zlib -bundled-c-zlib -non-blocking-ffi -pkg-config,
-             any.zlib-bindings ==0.1.1.5,
-             any.zstd ==0.1.2.0,
-             zstd +standalone
-index-state: hackage.haskell.org 2021-07-27T07:59:57Z
+             zlib -non-blocking-ffi -pkg-config -static
+index-state: hackage.haskell.org 2021-03-07T18:36:25Z
--- a/cabal.ghc901.project
+++ b/cabal.ghc901.project
@@ -1,33 +0,0 @@
-packages: ./ghcup.cabal
-
-optional-packages: ./vendored/*/*.cabal
-
-optimization: 2
-
-package ghcup
-    tests: True
-    flags: +tui
-
-source-repository-package
-    type: git
-    location: https://github.com/jtdaugherty/brick.git
-    tag: b3b96cfe66dfd398d338e3feb2b6855e66a35190
-
-source-repository-package
-    type: git
-    location: https://github.com/Bodigrim/tar
-    tag: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
-
-source-repository-package
-    type: git
-    location: https://github.com/bgamari/terminal-size
-    tag: 34ea816bd63f75f800eedac12c6908c6f3736036
-
-constraints: http-io-streams -brotli
-
-package libarchive
-  flags: -system-libarchive
-
-allow-newer: base, ghc-prim, template-haskell, language-c
-
-with-compiler: ghc-9.0.1
--- a/cabal.project
+++ b/cabal.project
@@ -1,31 +1,18 @@
 packages: ./ghcup.cabal

-optional-packages: ./vendored/*/*.cabal
-
 optimization: 2

+package streamly
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
 package ghcup
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
    tests: True
    flags: +tui

-source-repository-package
-    type: git
-    location: https://github.com/jtdaugherty/brick.git
-    tag: b3b96cfe66dfd398d338e3feb2b6855e66a35190
-
-source-repository-package
-    type: git
-    location: https://github.com/Bodigrim/tar
-    tag: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
-
-source-repository-package
-    type: git
-    location: https://github.com/bgamari/terminal-size
-    tag: 34ea816bd63f75f800eedac12c6908c6f3736036
-
 constraints: http-io-streams -brotli

 package libarchive
  flags: -system-libarchive

-allow-newer: base, ghc-prim, template-haskell, language-c
+allow-newer: base, ghc-prim, template-haskell
--- a/cabal.project.freeze
+++ b/cabal.project.freeze
@@ -1,2 +0,0 @@
-- windows picks weird version
-constraints: any.hsc2hs ==0.68.7
--- a/config.yaml
+++ b/config.yaml
@@ -29,8 +29,6 @@ key-bindings:
    KChar: 'c'
  show-all:
    KChar: 'a'
-  show-all-tools:
-    KChar: 't'

 # Where to get GHC/cabal/hls download info/versions from. For more detailed explanation
 # check the 'URLSource' type in the code.
--- a/ghcup-0.0.1.json
+++ b/ghcup-0.0.1.json
--- a/ghcup-0.0.2.yaml
+++ b/ghcup-0.0.2.yaml
@@ -1384,7 +1384,7 @@ ghcupDownloads:
              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
              dlHash: 9705e16d03497b46be4ad477e6c64d10890af853eafa8a9adf6dba89aa9e05f7
  GHCup:
-    0.1.16:
+    0.1.14:
      viTags:
      - Recommended
      - Latest
@@ -1394,22 +1394,22 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/x86_64-linux-ghcup-0.1.16
-              dlHash: 70e5303e2174b3029cbf4c7e4234a2542542cd5dee84ff200897531ac58c0340
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-linux-ghcup-0.1.14
+              dlHash: e9b314d248f4d4604ce64cee1be7161c77c8940efd11986c9205779ec3b598dd
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/x86_64-apple-darwin-ghcup-0.1.16
-              dlHash: af5ef80192d9f6adf2224827e2a5b10793852e2048f12d7ea8b2055b4a42f746
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-apple-darwin-ghcup-0.1.14
+              dlHash: 69ede9db36c0ae631b679fceb87dd856d4753ee26f33610da37dd7a694809919
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/x86_64-portbld-freebsd-ghcup-0.1.16
-              dlHash: 5275bce9254323f1ee402a7357971bbffc8113693441b9aa116085ed632e981a
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-portbld-freebsd-ghcup-0.1.14
+              dlHash: 68b09404cf49061da539463f42f8ad67c9cef5c5d3f68a3c7c4f6760e8442bb9
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/i386-linux-ghcup-0.1.16
-              dlHash: 90735a34164af1a0808a3606cd9605dbdf0c64262055cb7c377336691a87a7ae
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/i386-linux-ghcup-0.1.14
+              dlHash: ecb1157f010d2421764c52ab0cdbbf9a5c3da555827172c7b904d5f3f96c80fa
          Linux_Alpine:
            unknown_versioning: *ghcup-32
--- a/ghcup-0.0.3.yaml
+++ b/ghcup-0.0.3.yaml
@@ -1451,7 +1451,7 @@ ghcupDownloads:
              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
              dlHash: 9705e16d03497b46be4ad477e6c64d10890af853eafa8a9adf6dba89aa9e05f7
  GHCup:
-    0.1.16:
+    0.1.14:
      viTags:
      - Recommended
      - Latest
@@ -1461,23 +1461,23 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/x86_64-linux-ghcup-0.1.16
-              dlHash: 70e5303e2174b3029cbf4c7e4234a2542542cd5dee84ff200897531ac58c0340
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-linux-ghcup-0.1.14
+              dlHash: e9b314d248f4d4604ce64cee1be7161c77c8940efd11986c9205779ec3b598dd
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/x86_64-apple-darwin-ghcup-0.1.16
-              dlHash: af5ef80192d9f6adf2224827e2a5b10793852e2048f12d7ea8b2055b4a42f746
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-apple-darwin-ghcup-0.1.14
+              dlHash: 69ede9db36c0ae631b679fceb87dd856d4753ee26f33610da37dd7a694809919
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/x86_64-portbld-freebsd-ghcup-0.1.16
-              dlHash: 5275bce9254323f1ee402a7357971bbffc8113693441b9aa116085ed632e981a
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-portbld-freebsd-ghcup-0.1.14
+              dlHash: 68b09404cf49061da539463f42f8ad67c9cef5c5d3f68a3c7c4f6760e8442bb9
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/i386-linux-ghcup-0.1.16
-              dlHash: 90735a34164af1a0808a3606cd9605dbdf0c64262055cb7c377336691a87a7ae
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/i386-linux-ghcup-0.1.14
+              dlHash: ecb1157f010d2421764c52ab0cdbbf9a5c3da555827172c7b904d5f3f96c80fa
          Linux_Alpine:
            unknown_versioning: *ghcup-32
  HLS:
--- a/ghcup-0.0.4.yaml
+++ b/ghcup-0.0.4.yaml
@@ -1286,7 +1286,6 @@ ghcupDownloads:
              dlHash: bb9c97826b1f4d7a8ef8bce0616b612f1ded10480ef10fcf7fb4e6d10a6681c8
    8.10.3:
      viTags:
-      - old
      - base-4.14.1.0
      viChangeLog: https://downloads.haskell.org/~ghc/8.10.3/docs/html/users_guide/8.10.3-notes.html
      viSourceDL:
@@ -1376,6 +1375,7 @@ ghcupDownloads:
              dlHash: b823b58cae36fbac0741680ca7605180fa4cf4c6ae439123d282184b94d32fd6
    8.10.4:
      viTags:
+      - Recommended
      - base-4.14.1.0
      viChangeLog: https://downloads.haskell.org/~ghc/8.10.4/docs/html/users_guide/8.10.4-notes.html
      viSourceDL:
@@ -1383,7 +1383,7 @@ ghcupDownloads:
        dlSubdir: ghc-8.10.4
        dlHash: 52af871b4e08550257d720c2944ac85727d0b948407cef1bebfe7508c224910e
      viPostRemove: *ghc-post-remove
-      viPreCompile: &ghc-pre-compile "If you have autoconf >= 2.70 you'll need this patch https://gitlab.haskell.org/ghc/ghc/-/snippets/2040 (see the --patchdir option)"
+      viPreCompile: "If you have autoconf >= 2.70 you'll need this patch https://gitlab.haskell.org/ghc/ghc/-/snippets/2040 (see the --patchdir option)"
      viArch:
        A_64:
          Linux_Debian:
@@ -1464,97 +1464,6 @@ ghcupDownloads:
              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-armv7-deb10-linux.tar.xz
              dlSubdir: ghc-8.10.4
              dlHash: 0d18ef83593272f6196a41cc3abdc48dfe5e14372db75d71ea19fe35320c4e81
-    8.10.5:
-      viTags:
-      - Recommended
-      - base-4.14.2.0
-      viChangeLog: https://downloads.haskell.org/~ghc/8.10.5/docs/html/users_guide/8.10.5-notes.html
-      viSourceDL:
-        dlUri: https://downloads.haskell.org/~ghc/8.10.5/ghc-8.10.5-src.tar.xz
-        dlSubdir: ghc-8.10.5
-        dlHash: f10941f16e4fbd98580ab5241b9271bb0851304560c4d5ca127e3b0e20e3076f
-      viPostRemove: *ghc-post-remove
-      viPreCompile: *ghc-pre-compile
-      viArch:
-        A_64:
-          Linux_Debian:
-            '( >= 9 && < 10 )': &ghc-8105-64-deb9
-              dlUri: https://downloads.haskell.org/~ghc/8.10.5/ghc-8.10.5-x86_64-deb9-linux.tar.xz
-              dlSubdir: ghc-8.10.5
-              dlHash: 15e71325c3bdfe3804be0f84c2fc5c913d811322d19b0f4d4cff20f29cdd804d
-            '( >= 10 && < 11 )': &ghc-8105-64-deb10
-              dlUri: https://downloads.haskell.org/~ghc/8.10.5/ghc-8.10.5-x86_64-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.5
-              dlHash: bc623c20ca4c5c18e952071ba14aa0cfc5c94d34219bffaa615f7b491f376787
-            unknown_versioning: *ghc-8105-64-deb9
-          Linux_Ubuntu:
-            unknown_versioning: &ghc-8105-64-fedora
-              dlUri: https://downloads.haskell.org/~ghc/8.10.5/ghc-8.10.5-x86_64-fedora27-linux.tar.xz
-              dlSubdir: ghc-8.10.5
-              dlHash: 73528ebfb219b50aa9042ee51a0a2bd764828d605f058404989d0b645752d210
-            '( >= 16 && < 19 )': *ghc-8105-64-deb9
-          Linux_Mint:
-            unknown_versioning: *ghc-8105-64-deb10
-          Linux_Fedora:
-            '( >= 27 && < 28 )': *ghc-8105-64-fedora
-            unknown_versioning: *ghc-8105-64-fedora
-          Linux_CentOS:
-            '( >= 7 && < 8 )': &ghc-8105-64-centos
-              dlUri: https://downloads.haskell.org/~ghc/8.10.5/ghc-8.10.5-x86_64-centos7-linux.tar.xz
-              dlSubdir: ghc-8.10.5
-              dlHash: 4cdb259ec74d1408dab45dab20dcedc21690f39921c2ea4546486fb3e81f4fbd
-            unknown_versioning: *ghc-8105-64-centos
-          Linux_RedHat:
-            unknown_versioning: *ghc-8105-64-centos
-          Linux_Alpine:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.5/ghc-8.10.5-x86_64-alpine3.10-linux-integer-simple.tar.xz
-              dlSubdir: ghc-8.10.5-x86_64-unknown-linux
-              dlHash: f4d7cd9ed12a4b8592219c9a63a86db1a256a09fa9e6ed755a60afc57dc782e2
-          Linux_AmazonLinux:
-            unknown_versioning: *ghc-8105-64-centos
-          Linux_UnknownLinux:
-            unknown_versioning: *ghc-8105-64-fedora
-          Darwin:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.5/ghc-8.10.5-x86_64-apple-darwin.tar.xz
-              dlSubdir: ghc-8.10.5
-              dlHash: ef0f47eff8962d58fa447123636cf8ef31c1e5b2d0ae90177d3388861ddf4a22
-          FreeBSD:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/ghc/8.10.5/ghc-8.10.5-x86_64-portbld-freebsd.tar.xz
-              dlSubdir: ghc-8.10.5
-              dlHash: 11a0b490bfb2f57b5bc87c69c197542eafce1b4991cc22f625179a6c6e567834
-        A_32:
-          Linux_Debian:
-            '( >= 9 && < 10 )': &ghc-8105-32-deb9
-              dlUri: https://downloads.haskell.org/~ghc/8.10.5/ghc-8.10.5-i386-deb9-linux.tar.xz
-              dlSubdir: ghc-8.10.5
-              dlHash: 0ccb5b2c1222374874795c35410754dd650f649b774872abbea2a4ef21ac9c9d
-            unknown_versioning: *ghc-8105-32-deb9
-          Linux_Ubuntu:
-            unknown_versioning: *ghc-8105-32-deb9
-          Linux_Mint:
-            unknown_versioning: *ghc-8105-32-deb9
-          Linux_UnknownLinux:
-            unknown_versioning: *ghc-8105-32-deb9
-          Linux_Alpine:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/ghc/8.10.5/ghc-8.10.5-i386-alpine-linux.tar.xz
-              dlSubdir: ghc-8.10.5
-              dlHash: 0e91abe61607f9375d4e252ee9c261e4856df396f60641bb1b880ab8a3a83ea7
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.5/ghc-8.10.5-aarch64-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.5
-              dlHash: 9a085cd8a7f8e0ace21ac67dbf659a56fcf41564b48817ba42cd8a1aac7f0ddc
-        A_ARM:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.5/ghc-8.10.5-armv7-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.5
-              dlHash: 56170d1a8450e18b7eb9c23c94723da352815b27ec250bb23742a62f16dcab6c
    9.0.1:
      viTags:
      - Latest
@@ -1868,7 +1777,7 @@ ghcupDownloads:
              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.4.0.0/cabal-install-3.4.0.0-armv7-linux-bootstrapped.tar.xz
              dlHash: 16c0d1eaba24bed14f3e152970179a45d9f9bb5cc839b2c210ad06eb7d4826ed
  GHCup:
-    0.1.16:
+    0.1.14.1:
      viTags:
      - Recommended
      - Latest
@@ -1878,39 +1787,35 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/x86_64-linux-ghcup-0.1.16
-              dlHash: 70e5303e2174b3029cbf4c7e4234a2542542cd5dee84ff200897531ac58c0340
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14.1/x86_64-linux-ghcup-0.1.14.1
+              dlHash: 59e31b2ede3ed20f79dce0f8ba0a68b6fb25e5f00ba2d7243f6a8af68d979ff5
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/x86_64-apple-darwin-ghcup-0.1.16
-              dlHash: af5ef80192d9f6adf2224827e2a5b10793852e2048f12d7ea8b2055b4a42f746
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14.1/x86_64-apple-darwin-ghcup-0.1.14.1
+              dlHash: 3e1dd173b3e7b5d90dcdece423c3ddd3efb4c83e964967b0fb574c9b7b2c44e1
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/x86_64-portbld-freebsd-ghcup-0.1.16
-              dlHash: 5275bce9254323f1ee402a7357971bbffc8113693441b9aa116085ed632e981a
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14.1/x86_64-portbld-freebsd-ghcup-0.1.14.1
+              dlHash: 89a70980d77888dae8b9fd0f05e7a7920f421bc3bb5192da8e73fd4e7b4cb86f
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/i386-linux-ghcup-0.1.16
-              dlHash: 90735a34164af1a0808a3606cd9605dbdf0c64262055cb7c377336691a87a7ae
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14.1/i386-linux-ghcup-0.1.14.1
+              dlHash: 610aac7c3be3ba3874c07b9cae5b2ca0da9a92bf381afc2597bd2dc9c70aae0c
          Linux_Alpine:
            unknown_versioning: *ghcup-32
        A_ARM64:
          Linux_UnknownLinux:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/aarch64-linux-ghcup-0.1.16
-              dlHash: d74456a1e9fe4e6a4c97c70b5434161d383266bb9256a4fca09c3506c2904378
-          Darwin:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/aarch64-apple-darwin-ghcup-0.1.16
-              dlHash: 526f663f1c0d751bf78190eff248c364846cd05e259d43960d5be7c93e1668c8
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14.1/aarch64-linux-ghcup-0.1.14.1
+              dlHash: e9ae07b7d41ea03e6af9c1f3587f61287827c4e29478b6a5d46ea1ce5af4cee5
        A_ARM:
          Linux_UnknownLinux:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16/armv7-linux-ghcup-0.1.16
-              dlHash: 45ee40965f800d49c2ca4a87a4a9333dbe12b96d529b94f769dd3dc925a6f529
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14.1/armv7-linux-ghcup-0.1.14.1
+              dlHash: 646832030efbc0a848df24c08b5eb7507bd15d1c2eb95fea6d9d03890f3662be
  HLS:
    1.1.0:
      viTags:
--- a/ghcup-0.0.5.yaml
+++ b/ghcup-0.0.5.yaml
--- a/ghcup-0.0.6.yaml
+++ b/ghcup-0.0.6.yaml
--- a/ghcup.cabal
+++ b/ghcup.cabal
@@ -1,6 +1,6 @@
 cabal-version:   3.0
 name:            ghcup
-version:         0.1.16.1
+version:         0.1.14.1
 license:         LGPL-3.0-only
 license-file:    LICENSE
 copyright:       Julian Ospald 2020
@@ -19,8 +19,6 @@ extra-doc-files:
  CHANGELOG.md
  config.yaml
  ghcup-0.0.4.yaml
-  ghcup-0.0.5.yaml
-  ghcup-0.0.6.yaml
  HACKING.md
  README.md
  RELEASING.md
@@ -30,21 +28,19 @@ source-repository head
  location: https://gitlab.haskell.org/haskell/ghcup-hs.git

 flag tui
-  description:
-    Build the brick powered tui (ghcup tui). This is disabled on windows.
-
+  description: Build the brick powered tui (ghcup tui)
  default:     False
  manual:      True

 flag internal-downloader
  description:
-    Compile the internal downloader, which links against OpenSSL. This is disabled on windows.
+    Compile the internal downloader, which links against OpenSSL

  default:     False
  manual:      True

 flag tar
-  description: Use tar-bytestring instead of libarchive.
+  description: Use tar-bytestring instead of libarchive
  default:     False
  manual:      True

@@ -62,7 +58,6 @@ library
    GHCup.Utils
    GHCup.Utils.Dirs
    GHCup.Utils.File
-    GHCup.Utils.File.Common
    GHCup.Utils.Logger
    GHCup.Utils.MegaParsec
    GHCup.Utils.Prelude
@@ -75,19 +70,14 @@ library
  autogen-modules:    Paths_ghcup
  default-language:   Haskell2010
  default-extensions:
-    DeriveGeneric
    LambdaCase
    MultiWayIf
-    NamedFieldPuns
    PackageImports
-    QuasiQuotes
    RecordWildCards
    ScopedTypeVariables
+    Strict
    StrictData
    TupleSections
-    TypeApplications
-    TypeFamilies
-    ViewPatterns

  ghc-options:
    -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns
@@ -95,29 +85,32 @@ library

  build-depends:
    , aeson                 >=1.4        && <1.6
+    , ascii-string          ^>=1.0
    , async                 >=0.8        && <2.3
    , base                  >=4.13       && <5
    , base16-bytestring     >=0.1.1.6    && <1.1
    , binary                ^>=0.8.6.0
    , bytestring            ^>=0.10
+    , bz2                   >=0.5.0.5    && <1.1
    , case-insensitive      ^>=1.2.1.0
    , casing                ^>=0.1.4.1
    , concurrent-output     ^>=1.10.11
    , containers            ^>=0.6
    , cryptohash-sha256     ^>=0.11.101.0
-    , deepseq               ^>=1.4.4.0
-    , directory             ^>=1.3.6.0
    , disk-free-space       ^>=0.1.0.1
-    , extra                 ^>=1.7.9
-    , filepath              ^>=1.4.2.1
    , generics-sop          ^>=0.5
    , haskus-utils-types    ^>=1.5
    , haskus-utils-variant  >=3.0        && <3.2
-    , lzma-static           ^>=5.2.5.3
+    , hpath                 >=0.11       && <0.13
+    , hpath-directory       ^>=0.14.1
+    , hpath-filepath        ^>=0.10.3
+    , hpath-io              ^>=0.14.1
+    , hpath-posix           ^>=0.13.2
+    , lzma-static           ^>=5.2.5.2
    , megaparsec            >=8.0.0      && <9.1
    , monad-logger          ^>=0.3.31
    , mtl                   ^>=2.2
-    , optics                ^>=0.4
+    , optics                >=0.2        && <0.5
    , optics-vl             ^>=0.2
    , os-release            ^>=1.0.0
    , parsec                ^>=3.1
@@ -128,62 +121,44 @@ library
    , safe                  ^>=0.3.18
    , safe-exceptions       ^>=0.1
    , split                 ^>=0.2.3.4
+    , streamly              ^>=0.7.3
+    , streamly-bytestring   ^>=0.1.2
+    , streamly-posix        ^>=0.1.0.0
    , strict-base           ^>=0.4
    , string-interpolate    >=0.2.0.0    && <0.4
-    , template-haskell      >=2.7        && <2.18
-    , temporary             ^>=1.3
+    , template-haskell      >=2.7        && <2.17
    , text                  ^>=1.2.4.0
    , time                  ^>=1.9.3
    , transformers          ^>=0.5
+    , unix                  ^>=2.7
+    , unix-bytestring       ^>=0.3
    , unliftio-core         ^>=0.2.0.1
    , unordered-containers  ^>=0.2.10.0
    , uri-bytestring        ^>=0.3.2.2
    , utf8-string           ^>=1.0
    , vector                ^>=0.12
-    , versions              >=4.0.1      && <5.1
+    , versions              ^>=4.0.1
+    , vty                   >=5.28.2     && <5.34
    , word8                 ^>=0.1.3
    , yaml                  ^>=0.11.4.0
-    , zip                   ^>=1.7.1
    , zlib                  ^>=0.6.2.2

-  if (flag(internal-downloader) && !os(windows))
+  if flag(internal-downloader)
    exposed-modules: GHCup.Download.IOStreams
    cpp-options:     -DINTERNAL_DOWNLOADER
    build-depends:
      , HsOpenSSL              >=0.11.4.18
      , http-io-streams        >=0.1.2.0
-      , io-streams             >=1.5.2.1
+      , io-streams             >=1.5
      , terminal-progress-bar  >=0.4.1

  if flag(tar)
    cpp-options:   -DTAR
-    build-depends: tar
+    build-depends: tar-bytestring ^>=0.6.3.1

  else
    build-depends: libarchive ^>=3.0.0.0

-  if os(windows)
-    cpp-options:   -DIS_WINDOWS
-    other-modules: GHCup.Utils.File.Windows
-    build-depends:
-      , bzlib
-      , process  ^>=1.6.11.0
-      , retry    ^>=0.8.1.2
-      , Win32    ^>=2.10
-
-  else
-    other-modules: GHCup.Utils.File.Posix
-    build-depends:
-      , bz2              >=0.5.0.5 && <1.1
-      , hpath-posix      ^>=0.13.3
-      , process          ^>=1.6.9
-      , unix             ^>=2.7
-      , unix-bytestring  ^>=0.3.7.3
-
-  if (flag(tui) && !os(windows))
-    cpp-options:   -DBRICK
-    build-depends: vty >=5.28.2 && <5.34
-
 executable ghcup
  main-is:            Main.hs
  hs-source-dirs:     app/ghcup
@@ -191,10 +166,10 @@ executable ghcup
  default-extensions:
    LambdaCase
    MultiWayIf
-    NamedFieldPuns
    PackageImports
    RecordWildCards
    ScopedTypeVariables
+    Strict
    StrictData
    TupleSections

@@ -203,14 +178,14 @@ executable ghcup
    -fwarn-incomplete-record-updates -threaded

  build-depends:
-    , async                 ^>=2.2.3
+    , aeson                 >=1.4      && <1.6
    , base                  >=4.13     && <5
    , bytestring            ^>=0.10
    , containers            ^>=0.6
-    , deepseq               ^>=1.4
-    , filepath              ^>=1.4.2.1
    , ghcup
    , haskus-utils-variant  >=3.0      && <3.2
+    , hpath                 >=0.11     && <0.13
+    , hpath-io              ^>=0.14.1
    , megaparsec            >=8.0.0    && <9.1
    , monad-logger          ^>=0.3.31
    , mtl                   ^>=2.2
@@ -221,26 +196,22 @@ executable ghcup
    , safe                  ^>=0.3.18
    , safe-exceptions       ^>=0.1
    , string-interpolate    >=0.2.0.0  && <0.4
-    , template-haskell      >=2.7      && <2.18
+    , template-haskell      >=2.7      && <2.17
    , text                  ^>=1.2.4.0
    , uri-bytestring        ^>=0.3.2.2
    , utf8-string           ^>=1.0
-    , versions              >=4.0.1    && <5.1
+    , versions              ^>=4.0.1

  if flag(internal-downloader)
    cpp-options: -DINTERNAL_DOWNLOADER

-  if (flag(tui) && !os(windows))
+  if flag(tui)
    cpp-options:   -DBRICK
    other-modules: BrickMain
    build-depends:
-      , brick         >=0.5    && <0.64
-      , transformers  ^>=0.5
-      , vector        ^>=0.12
-      , vty           >=5.28.2 && <5.34
-
-  if os(windows)
-    cpp-options: -DIS_WINDOWS
+      , brick   >=0.5    && <0.62
+      , vector  ^>=0.12
+      , vty     >=5.28.2 && <5.34

  if flag(tar)
    cpp-options: -DTAR
@@ -254,34 +225,30 @@ executable ghcup-gen
  other-modules:      Validate
  default-language:   Haskell2010
  default-extensions:
-    DeriveGeneric
    LambdaCase
    MultiWayIf
-    NamedFieldPuns
    PackageImports
-    QuasiQuotes
    RecordWildCards
    ScopedTypeVariables
-    StrictData
    TupleSections
-    TypeApplications
-    TypeFamilies
-    ViewPatterns

  ghc-options:
    -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns
    -fwarn-incomplete-record-updates -threaded

  build-depends:
+    , aeson                 >=1.4      && <1.6
+    , aeson-pretty          ^>=0.8.8
    , base                  >=4.13     && <5
    , bytestring            ^>=0.10
    , containers            ^>=0.6
-    , filepath              ^>=1.4.2.1
    , ghcup
    , haskus-utils-variant  >=3.0      && <3.2
+    , hpath                 >=0.11     && <0.13
+    , hpath-filepath        ^>=0.10.3
    , monad-logger          ^>=0.3.31
    , mtl                   ^>=2.2
-    , optics                ^>=0.4
+    , optics                >=0.2      && <0.5
    , optparse-applicative  >=0.15.1.0 && <0.17
    , pretty                ^>=1.1.3.1
    , pretty-terminal       ^>=0.1.0.0
@@ -292,12 +259,13 @@ executable ghcup-gen
    , text                  ^>=1.2.4.0
    , transformers          ^>=0.5
    , uri-bytestring        ^>=0.3.2.2
-    , versions              >=4.0.1    && <5.1
+    , utf8-string           ^>=1.0
+    , versions              ^>=4.0.1
    , yaml                  ^>=0.11.4.0

  if flag(tar)
    cpp-options:   -DTAR
-    build-depends: tar
+    build-depends: tar-bytestring ^>=0.6.3.1

  else
    build-depends: libarchive ^>=3.0.0.0
@@ -305,7 +273,6 @@ executable ghcup-gen
 test-suite ghcup-test
  type:               exitcode-stdio-1.0
  main-is:            Main.hs
-  build-tool-depends: hspec-discover:hspec-discover -any
  hs-source-dirs:     test
  other-modules:
    GHCup.ArbitraryTypes
@@ -331,10 +298,11 @@ test-suite ghcup-test
    , containers                ^>=0.6
    , generic-arbitrary         ^>=0.1.0
    , ghcup
-    , hspec                     ^>=2.7.10
-    , hspec-golden-aeson        ^>=0.9
+    , hpath                     >=0.11    && <0.13
+    , hspec                     ^>=2.7.4
+    , hspec-golden-aeson        >=0.7     && <0.10
    , QuickCheck                ^>=2.14.1
    , quickcheck-arbitrary-adt  ^>=0.3.1.0
    , text                      ^>=1.2.4.0
    , uri-bytestring            ^>=0.3.2.2
-    , versions                  >=4.0.1   && <5.1
+    , versions                  ^>=4.0.1
--- a/golden/GHCupInfo.json
+++ b/golden/GHCupInfo.json
--- a/lib/GHCup.hs
+++ b/lib/GHCup.hs
--- a/lib/GHCup/Download.hs
+++ b/lib/GHCup/Download.hs
@@ -16,7 +16,7 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX

 Module for handling all download related functions.

@@ -36,7 +36,7 @@ import           GHCup.Errors
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Types.Optics
-import           GHCup.Utils.Dirs
+import           GHCup.Utils
 import           GHCup.Utils.File
 import           GHCup.Utils.Prelude
 import           GHCup.Version
@@ -55,42 +55,45 @@ import           Data.Aeson
 import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
 #if defined(INTERNAL_DOWNLOADER)
-import           Data.CaseInsensitive           ( mk )
+import           Data.CaseInsensitive           ( CI )
 #endif
-import           Data.List.Extra
+import           Data.List                      ( find )
 import           Data.Maybe
 import           Data.String.Interpolate
 import           Data.Time.Clock
 import           Data.Time.Clock.POSIX
-import           Data.Versions
-import           Data.Word8              hiding ( isSpace )
-import           Haskus.Utils.Variant.Excepts
 #if defined(INTERNAL_DOWNLOADER)
-import           Network.Http.Client     hiding ( URL )
+import           Data.Time.Format
 #endif
+import           Data.Versions
+import           Data.Word8
+import           GHC.IO.Exception
+import           HPath
+import           HPath.IO                     as HIO hiding ( hideError )
+import           Haskus.Utils.Variant.Excepts
 import           Optics
 import           Prelude                 hiding ( abs
                                                , readFile
                                                , writeFile
                                                )
-import           System.Directory
-import           System.Environment
-import           System.Exit
-import           System.FilePath
 import           System.IO.Error
-import           System.IO.Temp
-import           Text.PrettyPrint.HughesPJClass ( prettyShow )
+import           System.Posix.Env.ByteString    ( getEnv )
 import           URI.ByteString

 import qualified Crypto.Hash.SHA256            as SHA256
-import qualified Data.ByteString               as B
+import qualified Data.ByteString               as BS
 import qualified Data.ByteString.Base16        as B16
 import qualified Data.ByteString.Lazy          as L
 import qualified Data.Map.Strict               as M
+#if defined(INTERNAL_DOWNLOADER)
+import qualified Data.CaseInsensitive          as CI
 import qualified Data.Text                     as T
-import qualified Data.Text.IO                  as T
+#endif
 import qualified Data.Text.Encoding            as E
 import qualified Data.Yaml                     as Y
+import qualified System.Posix.Files.ByteString as PF
+import qualified System.Posix.RawFilePath.Directory
+                                               as RD



@@ -107,32 +110,32 @@ import qualified Data.Yaml                     as Y
 getDownloadsF :: ( FromJSONKey Tool
                 , FromJSONKey Version
                 , FromJSON VersionInfo
-                 , MonadReader env m
-                 , HasSettings env
-                 , HasDirs env
                 , MonadIO m
                 , MonadCatch m
                 , MonadLogger m
                 , MonadThrow m
                 , MonadFail m
-                 , MonadMask m
+                 , MonadReader AppState m
                 )
-              => Excepts
+              => URLSource
+              -> Excepts
                   '[JSONError , DownloadFailed , FileDoesNotExistError]
                   m
                   GHCupInfo
-getDownloadsF = do
-  Settings { urlSource } <- lift getSettings
+getDownloadsF urlSource = do
  case urlSource of
-    GHCupURL -> liftE $ getBase ghcupURL
-    (OwnSource url) -> liftE $ getBase url
+    GHCupURL -> liftE getBase
+    (OwnSource url) -> do
+      bs <- reThrowAll DownloadFailed $ downloadBS url
+      lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)
    (OwnSpec av) -> pure av
    (AddSource (Left ext)) -> do
-      base <- liftE $ getBase ghcupURL
+      base <- liftE getBase
      pure (mergeGhcupInfo base ext)
    (AddSource (Right uri)) -> do
-      base <- liftE $ getBase ghcupURL
-      ext  <- liftE $ getBase uri
+      base <- liftE getBase
+      bsExt <- reThrowAll DownloadFailed $ downloadBS uri
+      ext <- lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bsExt)
      pure (mergeGhcupInfo base ext)

    where
@@ -140,151 +143,181 @@ getDownloadsF = do
  mergeGhcupInfo :: GHCupInfo -- ^ base to merge with
                 -> GHCupInfo -- ^ extension overwriting the base
                 -> GHCupInfo
-  mergeGhcupInfo (GHCupInfo tr base base2) (GHCupInfo _ ext ext2) =
-    let newDownloads = M.mapWithKey (\k a -> case M.lookup k ext of
+  mergeGhcupInfo (GHCupInfo tr base) (GHCupInfo _ ext) =
+    let new = M.mapWithKey (\k a -> case M.lookup k ext of
                                        Just a' -> M.union a' a
                                        Nothing -> a
-                                    ) base
-        newGlobalTools = M.union base2 ext2
-    in GHCupInfo tr newDownloads newGlobalTools
+                           ) base
+    in GHCupInfo tr new


-yamlFromCache :: (MonadReader env m, HasDirs env) => URI -> m FilePath
-yamlFromCache uri = do
-  Dirs{..} <- getDirs
-  pure (cacheDir </> (T.unpack . decUTF8Safe . urlBaseName . view pathL' $ uri))
+readFromCache :: (MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
+              => Excepts '[JSONError, FileDoesNotExistError] m GHCupInfo
+readFromCache = do
+  AppState {dirs = Dirs {..}} <- lift ask
+  lift $ $(logWarn)
+    [i|Could not get download info, trying cached version (this may not be recent!)|]
+  let path = view pathL' ghcupURL
+  yaml_file <- (cacheDir </>) <$> urlBaseName path
+  bs        <-
+    handleIO' NoSuchThing
+              (\_ -> throwE $ FileDoesNotExistError (toFilePath yaml_file))
+    $ liftIO
+    $ readFile yaml_file
+  lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)


-etagsFile :: FilePath -> FilePath
-etagsFile = (<.> "etags")
-
-
-getBase :: ( MonadReader env m
-           , HasDirs env
-           , HasSettings env
-           , MonadFail m
-           , MonadIO m
-           , MonadCatch m
-           , MonadLogger m
-           , MonadMask m
-           )
-        => URI
-        -> Excepts '[JSONError] m GHCupInfo
-getBase uri = do
-  Settings { noNetwork } <- lift getSettings
-  yaml <- lift $ yamlFromCache uri
-  unless noNetwork $
-    handleIO (\e -> warnCache (displayException e))
-      . catchE @_ @_ @'[] (\e@(DownloadFailed _) -> warnCache (prettyShow e))
-      . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed
-      . smartDl
-      $ uri
-  liftE
-    . onE_ (onError yaml)
-    . lEM' @_ @_ @'[JSONError] JSONDecodeError
-    . fmap (first (\e -> [i|#{displayException e}
-Consider removing "#{yaml}" manually.|]))
-    . liftIO
-    . Y.decodeFileEither
-    $ yaml
- where
-  -- On error, remove the etags file and set access time to 0. This should ensure the next invocation
-  -- may re-download and succeed.
-  onError :: (MonadLogger m, MonadMask m, MonadCatch m, MonadIO m) => FilePath -> m ()
-  onError fp = do
-    let efp = etagsFile fp
-    handleIO (\e -> $(logWarn) [i|Couldn't remove file #{efp}, error was: #{displayException e}|])
-      (hideError doesNotExistErrorType $ rmFile efp)
-    liftIO $ hideError doesNotExistErrorType $ setAccessTime fp (posixSecondsToUTCTime (fromIntegral @Int 0))
-  warnCache s = do
-    lift $ $(logWarn) [i|Could not get download info, trying cached version (this may not be recent!)|]
-    lift $ $(logDebug) [i|Error was: #{s}|]
-
+getBase :: (MonadFail m, MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
+        => Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
+getBase =
+  handleIO (\_ -> readFromCache)
+  $ catchE @_ @'[JSONError, FileDoesNotExistError]
+      (\(DownloadFailed _) -> readFromCache)
+  (reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed (smartDl ghcupURL)
+    >>= (liftE . lE' @_ @_ @'[JSONError] JSONDecodeError . first show . Y.decodeEither' . L.toStrict))
+    where
  -- First check if the json file is in the ~/.ghcup/cache dir
  -- and check it's access time. If it has been accessed within the
  -- last 5 minutes, just reuse it.
  --
+  -- If not, then send a HEAD request and check for modification time.
+  -- Only download the file if the modification time is newer
+  -- than the local file.
+  --
  -- Always save the local file with the mod time of the remote file.
-  smartDl :: forall m1 env1
-           . ( MonadReader env1 m1
-             , HasDirs env1
-             , HasSettings env1
-             , MonadCatch m1
+  smartDl :: forall m1
+           . ( MonadCatch m1
             , MonadIO m1
             , MonadFail m1
             , MonadLogger m1
-             , MonadMask m1
+             , MonadReader AppState m1
             )
          => URI
          -> Excepts
-               '[ DownloadFailed
-                , DigestError
+               '[ FileDoesNotExistError
+                , HTTPStatusError
+                , URIParseError
+                , UnsupportedScheme
+                , NoLocationHeader
+                , TooManyRedirs
+                , ProcessError
                ]
               m1
-               ()
+               L.ByteString
  smartDl uri' = do
-    json_file <- lift $ yamlFromCache uri'
-    e <- liftIO $ doesFileExist json_file
-    currentTime <- liftIO getCurrentTime
+    AppState {dirs = Dirs {..}} <- lift ask
+    let path = view pathL' uri'
+    json_file <- (cacheDir </>) <$> urlBaseName path
+    e         <- liftIO $ doesFileExist json_file
    if e
      then do
-        accessTime <- liftIO $ getAccessTime json_file
+        accessTime <-
+          PF.accessTimeHiRes
+            <$> liftIO (PF.getFileStatus (toFilePath json_file))
+        currentTime <- liftIO getPOSIXTime

        -- access time won't work on most linuxes, but we can try regardless
-        when ((utcTimeToPOSIXSeconds currentTime - utcTimeToPOSIXSeconds accessTime) > 300) $
-          -- no access in last 5 minutes, re-check upstream mod time
-          dlWithMod currentTime json_file
-      else
-        dlWithMod currentTime json_file
+        if (currentTime - accessTime) > 300
+          then do -- no access in last 5 minutes, re-check upstream mod time
+            getModTime >>= \case
+              Just modTime -> do
+                fileMod <- liftIO $ getModificationTime json_file
+                if modTime > fileMod
+                  then dlWithMod modTime json_file
+                  else liftIO $ readFile json_file
+              Nothing -> do
+                lift $ $(logDebug) [i|Unable to get/parse Last-Modified header|]
+                dlWithoutMod json_file
+          else -- access in less than 5 minutes, re-use file
+               liftIO $ readFile json_file
+      else do
+        liftIO $ createDirRecursive' cacheDir
+        getModTime >>= \case
+          Just modTime -> dlWithMod modTime json_file
+          Nothing -> do
+            -- although we don't know last-modified, we still save
+            -- it to a file, so we might use it in offline mode
+            lift $ $(logDebug) [i|Unable to get/parse Last-Modified header|]
+            dlWithoutMod json_file
+
   where
    dlWithMod modTime json_file = do
-      let (dir, fn) = splitFileName json_file
-      f <- liftE $ download uri' Nothing dir (Just fn) True
-      liftIO $ setModificationTime f modTime
-      liftIO $ setAccessTime f modTime
- 
+      bs <- liftE $ downloadBS uri'
+      liftIO $ writeFileWithModTime modTime json_file bs
+      pure bs
+    dlWithoutMod json_file = do
+      bs <- liftE $ downloadBS uri'
+      liftIO $ hideError doesNotExistErrorType $ deleteFile json_file
+      liftIO $ writeFileL json_file (Just newFilePerms) bs
+      liftIO $ setModificationTime json_file (fromIntegral @Int 0)
+      pure bs


-getDownloadInfo :: ( MonadReader env m
-                   , HasPlatformReq env
-                   , HasGHCupInfo env
-                   )
-                => Tool
+    getModTime = do
+#if !defined(INTERNAL_DOWNLOADER)
+      pure Nothing
+#else
+      headers <-
+        handleIO (\_ -> pure mempty)
+        $ liftE
+        $ ( catchAllE
+              (\_ ->
+                pure mempty :: Excepts '[] m1 (M.Map (CI ByteString) ByteString)
+              )
+          $ getHead uri'
+          )
+      pure $ parseModifiedHeader headers
+
+  parseModifiedHeader :: (M.Map (CI ByteString) ByteString) -> Maybe UTCTime
+  parseModifiedHeader headers =
+    (M.lookup (CI.mk "Last-Modified") headers) >>= \h -> parseTimeM
+      True
+      defaultTimeLocale
+      "%a, %d %b %Y %H:%M:%S %Z"
+      (T.unpack . decUTF8Safe $ h)
+
+#endif
+
+  writeFileWithModTime :: UTCTime -> Path Abs -> L.ByteString -> IO ()
+  writeFileWithModTime utctime path content = do
+    let mod_time = utcTimeToPOSIXSeconds utctime
+    writeFileL path (Just newFilePerms) content
+    setModificationTimeHiRes path mod_time
+
+
+getDownloadInfo :: Tool
                -> Version
                -- ^ tool version
-                -> Excepts
-                     '[NoDownload]
-                     m
-                     DownloadInfo
-getDownloadInfo t v = do
-  (PlatformRequest a p mv) <- lift getPlatformReq
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+                -> PlatformRequest
+                -> GHCupDownloads
+                -> Either NoDownload DownloadInfo
+getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
+  (Left NoDownload)
+  Right
+  (case p of
+    -- non-musl won't work on alpine
+    Linux Alpine -> with_distro <|> without_distro_ver
+    _            -> with_distro <|> without_distro_ver <|> without_distro
+  )

-  let distro_preview f g =
-        let platformVersionSpec =
-              preview (ix t % ix v % viArch % ix a % ix (f p)) dls
-            mv' = g mv
-        in  fmap snd
-              .   find
-                    (\(mverRange, _) -> maybe
-                      (isNothing mv')
-                      (\range -> maybe False (`versionRange` range) mv')
-                      mverRange
-                    )
-              .   M.toList
-              =<< platformVersionSpec
-      with_distro        = distro_preview id id
-      without_distro_ver = distro_preview id (const Nothing)
-      without_distro     = distro_preview (set _Linux UnknownLinux) (const Nothing)
+ where
+  with_distro        = distro_preview id id
+  without_distro_ver = distro_preview id (const Nothing)
+  without_distro     = distro_preview (set _Linux UnknownLinux) (const Nothing)

-  maybe
-    (throwE NoDownload)
-    pure
-    (case p of
-      -- non-musl won't work on alpine
-      Linux Alpine -> with_distro <|> without_distro_ver
-      _            -> with_distro <|> without_distro_ver <|> without_distro
-    )
+  distro_preview f g =
+    let platformVersionSpec =
+          preview (ix t % ix v % viArch % ix a % ix (f p)) dls
+        mv' = g mv
+    in  fmap snd
+          .   find
+                (\(mverRange, _) -> maybe
+                  (isNothing mv')
+                  (\range -> maybe False (`versionRange` range) mv')
+                  mverRange
+                )
+          .   M.toList
+          =<< platformVersionSpec


 -- | Tries to download from the given http or https url
@@ -294,232 +327,101 @@ getDownloadInfo t v = do
 --   2. otherwise create a random file
 --
 -- The file must not exist.
-download :: ( MonadReader env m
-            , HasSettings env
-            , HasDirs env
-            , MonadMask m
+download :: ( MonadMask m
+            , MonadReader AppState m
            , MonadThrow m
            , MonadLogger m
            , MonadIO m
            )
-         => URI
-         -> Maybe T.Text      -- ^ expected hash
-         -> FilePath          -- ^ destination dir
-         -> Maybe FilePath    -- ^ optional filename
-         -> Bool              -- ^ whether to read an write etags
-         -> Excepts '[DigestError , DownloadFailed] m FilePath
-download uri eDigest dest mfn etags
+         => DownloadInfo
+         -> Path Abs          -- ^ destination dir
+         -> Maybe (Path Rel)  -- ^ optional filename
+         -> Excepts '[DigestError , DownloadFailed] m (Path Abs)
+download dli dest mfn
  | scheme == "https" = dl
  | scheme == "http"  = dl
  | scheme == "file"  = cp
  | otherwise = throwE $ DownloadFailed (variantFromValue UnsupportedScheme)

 where
-  scheme = view (uriSchemeL' % schemeBSL') uri
+  scheme = view (dlUri % uriSchemeL' % schemeBSL') dli
  cp     = do
    -- destination dir must exist
    liftIO $ createDirRecursive' dest
-    let fromFile = T.unpack . decUTF8Safe $ path
-    liftIO $ copyFile fromFile destFile
+    destFile <- getDestFile
+    fromFile <- parseAbs path
+    liftIO $ copyFile fromFile destFile Strict
    pure destFile
  dl = do
-    let uri' = decUTF8Safe (serializeURIRef' uri)
+    let uri' = decUTF8Safe (serializeURIRef' (view dlUri dli))
    lift $ $(logInfo) [i|downloading: #{uri'}|]

    -- destination dir must exist
    liftIO $ createDirRecursive' dest
+    destFile <- getDestFile

    -- download
    flip onException
-         (lift $ hideError doesNotExistErrorType $ recycleFile destFile)
+         (liftIO $ hideError doesNotExistErrorType $ deleteFile destFile)
     $ catchAllE @_ @'[ProcessError, DownloadFailed, UnsupportedScheme]
          (\e ->
-            lift (hideError doesNotExistErrorType $ recycleFile destFile)
+            liftIO (hideError doesNotExistErrorType $ deleteFile destFile)
              >> (throwE . DownloadFailed $ e)
          ) $ do
-              Settings{ downloader, noNetwork } <- lift getSettings
-              when noNetwork $ throwE (DownloadFailed (V NoNetwork :: V '[NoNetwork]))
-              case downloader of
+              lift getDownloader >>= \case
                Curl -> do
                  o' <- liftIO getCurlOpts
-                  if etags
-                    then do
-                      dh <- liftIO $ emptySystemTempFile "curl-header"
-                      flip finally (try @_ @SomeException $ rmFile dh) $
-                        flip finally (try @_ @SomeException $ rmFile (destFile <.> "tmp")) $ do
-                          metag <- readETag destFile
-                          liftE $ lEM @_ @'[ProcessError] $ exec "curl"
-                              (o' ++ (if etags then ["--dump-header", dh] else [])
-                                  ++ maybe [] (\t -> ["-H", [i|If-None-Match: #{t}|]]) metag
-                                  ++ ["-fL", "-o", destFile <.> "tmp", T.unpack uri']) Nothing Nothing
-                          headers <- liftIO $ T.readFile dh
-
-                          -- this nonsense is necessary, because some older versions of curl would overwrite
-                          -- the destination file when 304 is returned
-                          case fmap T.words . listToMaybe . fmap T.strip . T.lines $ headers of
-                            Just (http':sc:_)
-                              | sc == "304"
-                              , T.pack "HTTP" `T.isPrefixOf` http' -> $logDebug [i|Status code was 304, not overwriting|]
-                              | T.pack "HTTP" `T.isPrefixOf` http' -> do
-                                  $logDebug [i|Status code was #{sc}, overwriting|]
-                                  liftIO $ copyFile (destFile <.> "tmp") destFile
-                            _ -> liftE $ throwE @_ @'[DownloadFailed] (DownloadFailed (toVariantAt @0 (MalformedHeaders headers)
-                              :: V '[MalformedHeaders]))
-
-                          writeEtags (parseEtags headers)
-                    else
-                      liftE $ lEM @_ @'[ProcessError] $ exec "curl" 
-                        (o' ++ ["-fL", "-o", destFile, T.unpack uri']) Nothing Nothing
+                  liftE $ lEM @_ @'[ProcessError] $ liftIO $ exec "curl" True
+                    (o' ++ ["-fL", "-o", toFilePath destFile, serializeURIRef' $ view dlUri dli]) Nothing Nothing
                Wget -> do
-                  destFileTemp <- liftIO $ emptySystemTempFile "wget-tmp"
-                  flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-                    o' <- liftIO getWgetOpts
-                    if etags
-                      then do
-                        metag <- readETag destFile
-                        let opts = o' ++ maybe [] (\t -> ["--header", [i|If-None-Match: #{t}|]]) metag
-                                      ++ ["-q", "-S", "-O", destFileTemp , T.unpack uri']
-                        CapturedProcess {_exitCode, _stdErr} <- lift $ executeOut "wget" opts Nothing
-                        case _exitCode of
-                          ExitSuccess -> do
-                            liftIO $ copyFile destFileTemp destFile
-                            writeEtags (parseEtags (decUTF8Safe' _stdErr))
-                          ExitFailure i'
-                            | i' == 8
-                            , Just _ <- find (T.pack "304 Not Modified" `T.isInfixOf`) . T.lines . decUTF8Safe' $ _stdErr
-                                     -> do
-                                          $logDebug "Not modified, skipping download"
-                                          writeEtags (parseEtags (decUTF8Safe' _stdErr))
-                            | otherwise -> throwE (NonZeroExit i' "wget" opts)
-                      else do
-                        let opts = o' ++ ["-O", destFileTemp , T.unpack uri']
-                        liftE $ lEM @_ @'[ProcessError] $ exec "wget" opts Nothing Nothing
-                        liftIO $ copyFile destFileTemp destFile
+                  o' <- liftIO getWgetOpts
+                  liftE $ lEM @_ @'[ProcessError] $ liftIO $ exec "wget" True
+                    (o' ++ ["-O", toFilePath destFile , serializeURIRef' $ view dlUri dli]) Nothing Nothing
 #if defined(INTERNAL_DOWNLOADER)
                Internal -> do
-                  (https, host, fullPath, port) <- liftE $ uriToQuadruple uri
-                  if etags
-                    then do
-                      metag <- readETag destFile
-                      let addHeaders = maybe mempty (\etag -> M.fromList [ (mk . E.encodeUtf8 . T.pack $ "If-None-Match"
-                                                                         , E.encodeUtf8 etag)]) metag
-                      liftE
-                        $ catchE @HTTPNotModified @'[DownloadFailed] @'[] (\(HTTPNotModified etag) -> lift $ writeEtags (pure $ Just etag))
-                        $ do
-                          r <- downloadToFile https host fullPath port destFile addHeaders
-                          writeEtags (pure $ decUTF8Safe <$> getHeader r "etag")
-                    else void $ liftE $ catchE @HTTPNotModified
-                                        @'[DownloadFailed]
-                                   (\e@(HTTPNotModified _) ->
-                                     throwE @_ @'[DownloadFailed] (DownloadFailed (toVariantAt @0 e :: V '[HTTPNotModified])))
-                               $ downloadToFile https host fullPath port destFile mempty
+                  (https, host, fullPath, port) <- liftE $ uriToQuadruple (view dlUri dli)
+                  liftE $ downloadToFile https host fullPath port destFile
 #endif

-    forM_ eDigest (liftE . flip checkDigest destFile)
+    liftE $ checkDigest dli destFile
    pure destFile

-
  -- Manage to find a file we can write the body into.
-  destFile :: FilePath
-  destFile = maybe (dest </> T.unpack (decUTF8Safe (urlBaseName path)))
-                  (dest </>)
-                  mfn
+  getDestFile :: MonadThrow m => m (Path Abs)
+  getDestFile = maybe (urlBaseName path <&> (dest </>)) (pure . (dest </>)) mfn

-  path = view pathL' uri
-
-  parseEtags :: (MonadLogger m, MonadIO m, MonadThrow m) => T.Text -> m (Maybe T.Text)
-  parseEtags stderr = do
-    let mEtag = find (\line -> T.pack "etag:" `T.isPrefixOf` T.toLower line) . fmap T.strip . T.lines $ stderr
-    case T.words <$> mEtag of
-      (Just []) -> do
-        $logDebug "Couldn't parse etags, no input: "
-        pure Nothing
-      (Just [_, etag']) -> do
-        $logDebug [i|Parsed etag: #{etag'}|]
-        pure (Just etag')
-      (Just xs) -> do
-        $logDebug ("Couldn't parse etags, unexpected input: " <> T.unwords xs)
-        pure Nothing
-      Nothing -> do
-        $logDebug "No etags header found"
-        pure Nothing
-
-  writeEtags :: (MonadLogger m, MonadIO m, MonadThrow m) => m (Maybe T.Text) -> m ()
-  writeEtags getTags = do
-    getTags >>= \case
-      Just t -> do
-        $logDebug [i|Writing etagsFile #{(etagsFile destFile)}|]
-        liftIO $ T.writeFile (etagsFile destFile) t
-      Nothing ->
-        $logDebug [i|No etags files written|]
-
-  readETag :: (MonadLogger m, MonadCatch m, MonadIO m) => FilePath -> m (Maybe T.Text)
-  readETag fp = do
-    e <- liftIO $ doesFileExist fp
-    if e
-    then do
-      rE <- try @_ @SomeException $ liftIO $ fmap stripNewline' $ T.readFile (etagsFile fp)
-      case rE of
-        (Right et) -> do
-          $logDebug [i|Read etag: #{et}|]
-          pure (Just et)
-        (Left _) -> do
-          $logDebug [i|Etag file doesn't exist (yet)|]
-          pure Nothing
-    else do
-      $logDebug [i|Skipping and deleting etags file because destination file #{fp} doesn't exist|]
-      liftIO $ hideError doesNotExistErrorType $ rmFile (etagsFile fp)
-      pure Nothing
+  path        = view (dlUri % pathL') dli


 -- | Download into tmpdir or use cached version, if it exists. If filename
 -- is omitted, infers the filename from the url.
-downloadCached :: ( MonadReader env m
-                  , HasDirs env
-                  , HasSettings env
-                  , MonadMask m
+downloadCached :: ( MonadMask m
                  , MonadResource m
                  , MonadThrow m
                  , MonadLogger m
                  , MonadIO m
                  , MonadUnliftIO m
+                  , MonadReader AppState m
                  )
               => DownloadInfo
-               -> Maybe FilePath  -- ^ optional filename
-               -> Excepts '[DigestError , DownloadFailed] m FilePath
+               -> Maybe (Path Rel)  -- ^ optional filename
+               -> Excepts '[DigestError , DownloadFailed] m (Path Abs)
 downloadCached dli mfn = do
-  Settings{ cache } <- lift getSettings
+  cache <- lift getCache
  case cache of
-    True -> downloadCached' dli mfn Nothing
+    True -> do
+      AppState {dirs = Dirs {..}} <- lift ask
+      fn       <- maybe (urlBaseName $ view (dlUri % pathL') dli) pure mfn
+      let cachfile = cacheDir </> fn
+      fileExists <- liftIO $ doesFileExist cachfile
+      if
+        | fileExists -> do
+          liftE $ checkDigest dli cachfile
+          pure cachfile
+        | otherwise -> liftE $ download dli cacheDir mfn
    False -> do
      tmp <- lift withGHCupTmpDir
-      liftE $ download (_dlUri dli) (Just (_dlHash dli)) tmp mfn False
-
-
-downloadCached' :: ( MonadReader env m
-                   , HasDirs env
-                   , HasSettings env
-                   , MonadMask m
-                   , MonadThrow m
-                   , MonadLogger m
-                   , MonadIO m
-                   , MonadUnliftIO m
-                   )
-                => DownloadInfo
-                -> Maybe FilePath  -- ^ optional filename
-                -> Maybe FilePath  -- ^ optional destination dir (default: cacheDir)
-                -> Excepts '[DigestError , DownloadFailed] m FilePath
-downloadCached' dli mfn mDestDir = do
-  Dirs { cacheDir } <- lift getDirs
-  let destDir = fromMaybe cacheDir mDestDir
-  let fn = fromMaybe ((T.unpack . decUTF8Safe) $ urlBaseName $ view (dlUri % pathL') dli) mfn
-  let cachfile = destDir </> fn
-  fileExists <- liftIO $ doesFileExist cachfile
-  if
-    | fileExists -> do
-      liftE $ checkDigest (view dlHash dli) cachfile
-      pure cachfile
-    | otherwise -> liftE $ download (_dlUri dli) (Just (_dlHash dli)) destDir mfn False
+      liftE $ download dli tmp mfn



@@ -530,44 +432,92 @@ downloadCached' dli mfn mDestDir = do



-checkDigest :: ( MonadReader env m
-               , HasDirs env
-               , HasSettings env
-               , MonadIO m
-               , MonadThrow m
-               , MonadLogger m
-               )
-            => T.Text     -- ^ the hash
-            -> FilePath
+
+-- | This is used for downloading the JSON.
+downloadBS :: (MonadReader AppState m, MonadCatch m, MonadIO m, MonadLogger m)
+           => URI
+           -> Excepts
+                '[ FileDoesNotExistError
+                 , HTTPStatusError
+                 , URIParseError
+                 , UnsupportedScheme
+                 , NoLocationHeader
+                 , TooManyRedirs
+                 , ProcessError
+                 ]
+                m
+                L.ByteString
+downloadBS uri'
+  | scheme == "https"
+  = dl True
+  | scheme == "http"
+  = dl False
+  | scheme == "file"
+  = liftIOException doesNotExistErrorType (FileDoesNotExistError path)
+    (liftIO $ RD.readFile path)
+  | otherwise
+  = throwE UnsupportedScheme
+
+ where
+  scheme = view (uriSchemeL' % schemeBSL') uri'
+  path   = view pathL' uri'
+#if defined(INTERNAL_DOWNLOADER)
+  dl https = do
+#else
+  dl _ = do
+#endif
+    lift $ $(logDebug) [i|downloading: #{serializeURIRef' uri'}|]
+    lift getDownloader >>= \case
+      Curl -> do
+        o' <- liftIO getCurlOpts
+        let exe = [rel|curl|]
+            args = o' ++ ["-sSfL", serializeURIRef' uri']
+        liftIO (executeOut exe args Nothing) >>= \case
+          CapturedProcess ExitSuccess stdout _ -> do
+            pure $ L.fromStrict stdout
+          CapturedProcess (ExitFailure i') _ _ -> throwE $ NonZeroExit i' (toFilePath exe) args
+      Wget -> do
+        o' <- liftIO getWgetOpts
+        let exe = [rel|wget|]
+            args = o' ++ ["-qO-", serializeURIRef' uri']
+        liftIO (executeOut exe args Nothing) >>= \case
+          CapturedProcess ExitSuccess stdout _ -> do
+            pure $ L.fromStrict stdout
+          CapturedProcess (ExitFailure i') _ _ -> throwE $ NonZeroExit i' (toFilePath exe) args
+#if defined(INTERNAL_DOWNLOADER)
+      Internal -> do
+        (_, host', fullPath', port') <- liftE $ uriToQuadruple uri'
+        liftE $ downloadBS' https host' fullPath' port'
+#endif
+
+
+checkDigest :: (MonadIO m, MonadThrow m, MonadLogger m, MonadReader AppState m)
+            => DownloadInfo
+            -> Path Abs
            -> Excepts '[DigestError] m ()
-checkDigest eDigest file = do
-  Settings{ noVerify } <- lift getSettings
-  let verify = not noVerify
+checkDigest dli file = do
+  verify <- lift ask <&> (not . noVerify . settings)
  when verify $ do
-    let p' = takeFileName file
+    p' <- toFilePath <$> basename file
    lift $ $(logInfo) [i|verifying digest of: #{p'}|]
-    c <- liftIO $ L.readFile file
+    c <- liftIO $ readFile file
    cDigest <- throwEither . E.decodeUtf8' . B16.encode . SHA256.hashlazy $ c
+    let eDigest = view dlHash dli
    when ((cDigest /= eDigest) && verify) $ throwE (DigestError cDigest eDigest)


 -- | Get additional curl args from env. This is an undocumented option.
-getCurlOpts :: IO [String]
+getCurlOpts :: IO [ByteString]
 getCurlOpts =
-  lookupEnv "GHCUP_CURL_OPTS" >>= \case
-    Just r  -> pure $ splitOn " " r
+  getEnv "GHCUP_CURL_OPTS" >>= \case
+    Just r  -> pure $ BS.split _space r
    Nothing -> pure []


 -- | Get additional wget args from env. This is an undocumented option.
-getWgetOpts :: IO [String]
+getWgetOpts :: IO [ByteString]
 getWgetOpts =
-  lookupEnv "GHCUP_WGET_OPTS" >>= \case
-    Just r  -> pure $ splitOn " " r
+  getEnv "GHCUP_WGET_OPTS" >>= \case
+    Just r  -> pure $ BS.split _space r
    Nothing -> pure []

-
-urlBaseName :: ByteString  -- ^ the url path (without scheme and host)
-            -> ByteString
-urlBaseName = snd . B.breakEnd (== _slash) . urlDecode False
-
--- a/lib/GHCup/Download/IOStreams.hs
+++ b/lib/GHCup/Download/IOStreams.hs
@@ -9,7 +9,9 @@ module GHCup.Download.IOStreams where

 import           GHCup.Download.Utils
 import           GHCup.Errors
+import           GHCup.Types.Optics
 import           GHCup.Types.JSON               ( )
+import           GHCup.Utils.File
 import           GHCup.Utils.Prelude

 import           Control.Applicative
@@ -18,10 +20,12 @@ import           Control.Monad
 import           Control.Monad.Reader
 import           Data.ByteString                ( ByteString )
 import           Data.ByteString.Builder
-import           Data.CaseInsensitive           ( CI, original, mk )
+import           Data.CaseInsensitive           ( CI )
 import           Data.IORef
 import           Data.Maybe
 import           Data.Text.Read
+import           HPath
+import           HPath.IO                      as HIO
 import           Haskus.Utils.Variant.Excepts
 import           Network.Http.Client     hiding ( URL )
 import           Optics
@@ -29,6 +33,10 @@ import           Prelude                 hiding ( abs
                                                , readFile
                                                , writeFile
                                                )
+import "unix"    System.Posix.IO.ByteString
+                                         hiding ( fdWrite )
+import "unix-bytestring" System.Posix.IO.ByteString
+                                                ( fdWrite )
 import           System.ProgressBar
 import           URI.ByteString

@@ -64,7 +72,7 @@ downloadBS' :: MonadIO m
 downloadBS' https host path port = do
  bref <- liftIO $ newIORef (mempty :: Builder)
  let stepper bs = modifyIORef bref (<> byteString bs)
-  void $ downloadInternal False https host path port stepper (pure ()) mempty
+  downloadInternal False https host path port stepper
  liftIO (readIORef bref <&> toLazyByteString)


@@ -73,18 +81,13 @@ downloadToFile :: (MonadMask m, MonadIO m)
               -> ByteString       -- ^ host (e.g. "www.example.com")
               -> ByteString       -- ^ path (e.g. "/my/file") including query
               -> Maybe Int        -- ^ optional port (e.g. 3000)
-               -> FilePath         -- ^ destination file to create and write to
-               -> M.Map (CI ByteString) ByteString -- ^ additional headers
-               -> Excepts '[DownloadFailed, HTTPNotModified] m Response
-downloadToFile https host fullPath port destFile addHeaders = do
-  let stepper = BS.appendFile destFile
-      setup = BS.writeFile destFile mempty
-  catchAllE (\case
-              (V (HTTPStatusError i headers))
-                | i == 304
-                , Just e <- M.lookup (mk "etag") headers -> throwE $ HTTPNotModified (decUTF8Safe e)
-              v -> throwE $ DownloadFailed v
-            ) $ downloadInternal True https host fullPath port stepper setup addHeaders
+               -> Path Abs         -- ^ destination file to create and write to
+               -> Excepts '[DownloadFailed] m ()
+downloadToFile https host fullPath port destFile = do
+  fd <- liftIO $ createRegularFileFd newFilePerms destFile
+  let stepper = fdWrite fd
+  flip finally (liftIO $ closeFd fd)
+    $ reThrowAll DownloadFailed $ downloadInternal True https host fullPath port stepper


 downloadInternal :: MonadIO m
@@ -94,8 +97,6 @@ downloadInternal :: MonadIO m
                 -> ByteString  -- ^ path with query
                 -> Maybe Int   -- ^ optional port
                 -> (ByteString -> IO a)   -- ^ the consuming step function
-                 -> IO a                   -- ^ setup action
-                 -> M.Map (CI ByteString) ByteString -- ^ additional headers
                 -> Excepts
                      '[ HTTPStatusError
                       , URIParseError
@@ -104,21 +105,19 @@ downloadInternal :: MonadIO m
                       , TooManyRedirs
                       ]
                      m
-                      Response
+                      ()
 downloadInternal = go (5 :: Int)

 where
-  go redirs progressBar https host path port consumer setup addHeaders = do
+  go redirs progressBar https host path port consumer = do
    r <- liftIO $ withConnection' https host port action
    veitherToExcepts r >>= \case
-      Right r' ->
+      Just r' ->
        if redirs > 0 then followRedirectURL r' else throwE TooManyRedirs
-      Left res -> pure res
+      Nothing -> pure ()
   where
    action c = do
-      let q = buildRequest1 $ do
-                http GET path
-                flip M.traverseWithKey addHeaders $ \key val -> setHeader (original key) val
+      let q = buildRequest1 $ http GET path

      sendRequest c q emptyBody

@@ -127,30 +126,28 @@ downloadInternal = go (5 :: Int)
        (\r i' -> runE $ do
          let scode = getStatusCode r
          if
-            | scode >= 200 && scode < 300 -> liftIO $ downloadStream r i' >> pure (Left r)
-            | scode == 304 -> throwE $ HTTPStatusError scode (getHeaderMap r)
+            | scode >= 200 && scode < 300 -> downloadStream r i' >> pure Nothing
            | scode >= 300 && scode < 400 -> case getHeader r "Location" of
-              Just r' -> pure $ Right r'
+              Just r' -> pure $ Just r'
              Nothing -> throwE NoLocationHeader
-            | otherwise -> throwE $ HTTPStatusError scode (getHeaderMap r)
+            | otherwise -> throwE $ HTTPStatusError scode
        )

    followRedirectURL bs = case parseURI strictURIParserOptions bs of
      Right uri' -> do
        (https', host', fullPath', port') <- liftE $ uriToQuadruple uri'
-        go (redirs - 1) progressBar https' host' fullPath' port' consumer setup addHeaders
+        go (redirs - 1) progressBar https' host' fullPath' port' consumer
      Left e -> throwE e

    downloadStream r i' = do
-      void setup
      let size = case getHeader r "Content-Length" of
            Just x' -> case decimal $ decUTF8Safe x' of
              Left  _       -> 0
              Right (r', _) -> r'
            Nothing -> 0

-      (mpb :: Maybe (ProgressBar ())) <- if progressBar
-        then Just <$> newProgressBar defStyle 10 (Progress 0 size ())
+      mpb <- if progressBar
+        then Just <$> liftIO (newProgressBar defStyle 10 (Progress 0 size ()))
        else pure Nothing

      outStream <- liftIO $ Streams.makeOutputStream
@@ -163,6 +160,79 @@ downloadInternal = go (5 :: Int)
      liftIO $ Streams.connect i' outStream


+getHead :: (MonadCatch m, MonadIO m)
+        => URI
+        -> Excepts
+             '[ HTTPStatusError
+              , URIParseError
+              , UnsupportedScheme
+              , NoLocationHeader
+              , TooManyRedirs
+              , ProcessError
+              ]
+             m
+             (M.Map (CI ByteString) ByteString)
+getHead uri' | scheme == "https" = head' True
+             | scheme == "http"  = head' False
+             | otherwise         = throwE UnsupportedScheme
+
+ where
+  scheme = view (uriSchemeL' % schemeBSL') uri'
+  head' https = do
+    (_, host', fullPath', port') <- liftE $ uriToQuadruple uri'
+    liftE $ headInternal https host' fullPath' port'
+
+
+headInternal :: MonadIO m
+             => Bool        -- ^ https?
+             -> ByteString  -- ^ host
+             -> ByteString  -- ^ path with query
+             -> Maybe Int   -- ^ optional port
+             -> Excepts
+                  '[ HTTPStatusError
+                   , URIParseError
+                   , UnsupportedScheme
+                   , TooManyRedirs
+                   , NoLocationHeader
+                   ]
+                  m
+                  (M.Map (CI ByteString) ByteString)
+headInternal = go (5 :: Int)
+
+ where
+  go redirs https host path port = do
+    r <- liftIO $ withConnection' https host port action
+    veitherToExcepts r >>= \case
+      Left r' ->
+        if redirs > 0 then followRedirectURL r' else throwE TooManyRedirs
+      Right hs -> pure hs
+   where
+
+    action c = do
+      let q = buildRequest1 $ http HEAD path
+
+      sendRequest c q emptyBody
+
+      unsafeReceiveResponse
+        c
+        (\r _ -> runE $ do
+          let scode = getStatusCode r
+          if
+            | scode >= 200 && scode < 300 -> do
+              let headers = getHeaderMap r
+              pure $ Right headers
+            | scode >= 300 && scode < 400 -> case getHeader r "Location" of
+              Just r' -> pure $ Left r'
+              Nothing -> throwE NoLocationHeader
+            | otherwise -> throwE $ HTTPStatusError scode
+        )
+
+    followRedirectURL bs = case parseURI strictURIParserOptions bs of
+      Right uri' -> do
+        (https', host', fullPath', port') <- liftE $ uriToQuadruple uri'
+        go (redirs - 1) https' host' fullPath' port'
+      Left e -> throwE e
+

 withConnection' :: Bool
                -> ByteString
--- a/lib/GHCup/Errors.hs
+++ b/lib/GHCup/Errors.hs
@@ -15,11 +15,12 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX
 -}
 module GHCup.Errors where

 import           GHCup.Types
+import           GHCup.Utils.Prelude

 #if !defined(TAR)
 import           Codec.Archive
@@ -28,17 +29,15 @@ import qualified Codec.Archive.Tar             as Tar
 #endif
 import           Control.Exception.Safe
 import           Data.ByteString                ( ByteString )
-import           Data.CaseInsensitive           ( CI )
 import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
+import           HPath
 import           Haskus.Utils.Variant
-import           Text.PrettyPrint               hiding ( (<>) )
-import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
+import           Text.PrettyPrint
+import           Text.PrettyPrint.HughesPJClass
 import           URI.ByteString

-import qualified Data.Map.Strict               as M
-


    ------------------------
@@ -87,12 +86,12 @@ instance Pretty DistroNotFound where
    text "Unable to figure out the distribution of the host."

 -- | The archive format is unknown. We don't know how to extract it.
-data UnknownArchive = UnknownArchive FilePath
+data UnknownArchive = UnknownArchive ByteString
  deriving Show

 instance Pretty UnknownArchive where
  pPrint (UnknownArchive file) =
-    text [i|The archive format is unknown. We don't know how to extract the file "#{file}"|]
+    text [i|The archive format is unknown. We don't know how to extract the file "#{decUTF8Safe file}"|]

 -- | The scheme is not supported (such as ftp).
 data UnsupportedScheme = UnsupportedScheme
@@ -144,12 +143,12 @@ instance Pretty NotInstalled where
    text [i|The version "#{prettyShow ver}" of the tool "#{tool}" is not installed.|]

 -- | An executable was expected to be in PATH, but was not found.
-data NotFoundInPATH = NotFoundInPATH FilePath
+data NotFoundInPATH = NotFoundInPATH (Path Rel)
  deriving Show

 instance Pretty NotFoundInPATH where
  pPrint (NotFoundInPATH exe) =
-    text [i|The exe "#{exe}" was not found in PATH.|]
+    text [i|The exe "#{decUTF8Safe . toFilePath $ exe}" was not found in PATH.|]

 -- | JSON decoding failed.
 data JSONError = JSONDecodeError String
@@ -161,12 +160,12 @@ instance Pretty JSONError where

 -- | A file that is supposed to exist does not exist
 -- (e.g. when we use file scheme to "download" something).
-data FileDoesNotExistError = FileDoesNotExistError FilePath
+data FileDoesNotExistError = FileDoesNotExistError ByteString
  deriving Show

 instance Pretty FileDoesNotExistError where
  pPrint (FileDoesNotExistError file) =
-    text [i|File "#{file}" does not exist.|]
+    text [i|File "#{decUTF8Safe file}" does not exist.|]

 data TarDirDoesNotExist = TarDirDoesNotExist TarDir
  deriving Show
@@ -184,29 +183,13 @@ instance Pretty DigestError where
    text [i|Digest error: expected "#{expectedDigest}", but got "#{currentDigest}"|]

 -- | Unexpected HTTP status.
-data HTTPStatusError = HTTPStatusError Int (M.Map (CI ByteString) ByteString)
+data HTTPStatusError = HTTPStatusError Int
  deriving Show

 instance Pretty HTTPStatusError where
-  pPrint (HTTPStatusError status _) =
+  pPrint (HTTPStatusError status) =
    text [i|Unexpected HTTP status: #{status}|]

-- | Malformed headers.
-data MalformedHeaders = MalformedHeaders Text
-  deriving Show
-
-instance Pretty MalformedHeaders where
-  pPrint (MalformedHeaders h) =
-    text [i|Headers are malformed: #{h}|]
-
-- | Unexpected HTTP status.
-data HTTPNotModified = HTTPNotModified Text
-  deriving Show
-
-instance Pretty HTTPNotModified where
-  pPrint (HTTPNotModified etag) =
-    text [i|Remote resource not modifed, etag was: #{etag}|]
-
 -- | The 'Location' header was expected during a 3xx redirect, but not found.
 data NoLocationHeader = NoLocationHeader
  deriving Show
@@ -253,20 +236,6 @@ instance Pretty NoToolVersionSet where
  pPrint (NoToolVersionSet tool) =
    text [i|No version is set for tool "#{tool}".|]

-data NoNetwork = NoNetwork
-  deriving Show
-
-instance Pretty NoNetwork where
-  pPrint NoNetwork =
-    text [i|A download was required or requested, but '--offline' was specified.|]
-
-data HadrianNotFound = HadrianNotFound
-  deriving Show
-
-instance Pretty HadrianNotFound where
-  pPrint HadrianNotFound =
-    text [i|Could not find Hadrian build files. Does this GHC version support Hadrian builds?|]
-

    -------------------------
    --[ High-level errors ]--
@@ -283,11 +252,11 @@ deriving instance Show DownloadFailed


 -- | A build failed.
-data BuildFailed = forall es . (Pretty (V es), Show (V es)) => BuildFailed FilePath (V es)
+data BuildFailed = forall es . Show (V es) => BuildFailed (Path Abs) (V es)

 instance Pretty BuildFailed where
  pPrint (BuildFailed path reason) =
-    text [i|BuildFailed failed in dir "#{path}": |] <> pPrint reason
+    text [i|BuildFailed failed in dir "#{decUTF8Safe . toFilePath $ path}": #{reason}|]

 deriving instance Show BuildFailed

--- a/lib/GHCup/Platform.hs
+++ b/lib/GHCup/Platform.hs
@@ -13,7 +13,7 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX
 -}
 module GHCup.Platform where

@@ -36,21 +36,18 @@ import           Data.Maybe
 import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
+import           HPath
+import           HPath.IO
 import           Haskus.Utils.Variant.Excepts
 import           Prelude                 hiding ( abs
                                                , readFile
                                                , writeFile
                                                )
 import           System.Info
-import           System.Directory
 import           System.OsRelease
-import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           Text.Regex.Posix

 import qualified Data.Text                     as T
-import qualified Data.Text.IO                  as T
-
-

    --------------------------
    --[ Platform detection ]--
@@ -58,7 +55,7 @@ import qualified Data.Text.IO                  as T


 -- | Get the full platform request, consisting of architecture, distro, ...
-platformRequest :: (Alternative m, MonadFail m, MonadLogger m, MonadCatch m, MonadIO m)
+platformRequest :: (MonadLogger m, MonadCatch m, MonadIO m)
                => Excepts
                     '[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound]
                     m
@@ -83,7 +80,7 @@ getArchitecture = case arch of
  what          -> Left (NoCompatibleArch what)


-getPlatform :: (Alternative m, MonadLogger m, MonadCatch m, MonadIO m, MonadFail m)
+getPlatform :: (MonadLogger m, MonadCatch m, MonadIO m)
            => Excepts
                 '[NoCompatiblePlatform, DistroNotFound]
                 m
@@ -98,34 +95,36 @@ getPlatform = do
        either (const Nothing) Just
          . versioning
          -- TODO: maybe do this somewhere else
-          . decUTF8Safe'
+          . getMajorVersion
+          . decUTF8Safe
        <$> getDarwinVersion
      pure $ PlatformResult { _platform = Darwin, _distroVersion = ver }
    "freebsd" -> do
      ver <-
-        either (const Nothing) Just . versioning . decUTF8Safe'
+        either (const Nothing) Just . versioning . decUTF8Safe
          <$> getFreeBSDVersion
      pure $ PlatformResult { _platform = FreeBSD, _distroVersion = ver }
-    "mingw32" -> pure PlatformResult { _platform = Windows, _distroVersion = Nothing }
    what -> throwE $ NoCompatiblePlatform what
-  lift $ $(logDebug) [i|Identified Platform as: #{prettyShow pfr}|]
+  lift $ $(logDebug) [i|Identified Platform as: #{pfr}|]
  pure pfr
 where
-  getFreeBSDVersion = lift $ fmap _stdOut $ executeOut "freebsd-version" [] Nothing
-  getDarwinVersion = lift $ fmap _stdOut $ executeOut "sw_vers"
+  getMajorVersion = T.intercalate "." . take 2 . T.split (== '.')
+  getFreeBSDVersion =
+    liftIO $ fmap _stdOut $ executeOut [rel|freebsd-version|] [] Nothing
+  getDarwinVersion = liftIO $ fmap _stdOut $ executeOut [rel|sw_vers|]
                                                        ["-productVersion"]
                                                        Nothing


-getLinuxDistro :: (Alternative m, MonadCatch m, MonadIO m, MonadFail m)
+getLinuxDistro :: (MonadCatch m, MonadIO m)
               => Excepts '[DistroNotFound] m (LinuxDistro, Maybe Versioning)
 getLinuxDistro = do
  -- TODO: don't do alternative on IO, because it hides bugs
-  (name, ver) <- handleIO (\_ -> throwE DistroNotFound) $ lift $ asum
-    [ liftIO try_os_release
+  (name, ver) <- handleIO (\_ -> throwE DistroNotFound) $ liftIO $ asum
+    [ try_os_release
    , try_lsb_release_cmd
-    , liftIO try_redhat_release
-    , liftIO try_debian_version
+    , try_redhat_release
+    , try_debian_version
    ]
  let parsedVer = ver >>= either (const Nothing) Just . versioning
      distro    = if
@@ -148,12 +147,12 @@ getLinuxDistro = do
   where
    regex x = makeRegexOpts compIgnoreCase execBlank ([s|\<|] ++ x ++ [s|\>|])

-  lsb_release_cmd :: FilePath
-  lsb_release_cmd = "lsb-release"
-  redhat_release :: FilePath
-  redhat_release = "/etc/redhat-release"
-  debian_version :: FilePath
-  debian_version = "/etc/debian_version"
+  lsb_release_cmd :: Path Rel
+  lsb_release_cmd = [rel|lsb-release|]
+  redhat_release :: Path Abs
+  redhat_release = [abs|/etc/redhat-release|]
+  debian_version :: Path Abs
+  debian_version = [abs|/etc/debian_version|]

  try_os_release :: IO (Text, Maybe Text)
  try_os_release = do
@@ -161,17 +160,16 @@ getLinuxDistro = do
      fmap osRelease <$> parseOsRelease
    pure (T.pack name, fmap T.pack version_id)

-  try_lsb_release_cmd :: (MonadFail m, MonadIO m)
-                      => m (Text, Maybe Text)
+  try_lsb_release_cmd :: IO (Text, Maybe Text)
  try_lsb_release_cmd = do
-    (Just _) <- liftIO $ findExecutable lsb_release_cmd
+    (Just _) <- findExecutable lsb_release_cmd
    name     <- fmap _stdOut $ executeOut lsb_release_cmd ["-si"] Nothing
    ver      <- fmap _stdOut $ executeOut lsb_release_cmd ["-sr"] Nothing
-    pure (decUTF8Safe' name, Just $ decUTF8Safe' ver)
+    pure (decUTF8Safe name, Just $ decUTF8Safe ver)

  try_redhat_release :: IO (Text, Maybe Text)
  try_redhat_release = do
-    t <- T.readFile redhat_release
+    t <- fmap decUTF8Safe' $ readFile redhat_release
    let nameRegex n =
          makeRegexOpts compIgnoreCase
                        execBlank
@@ -193,5 +191,5 @@ getLinuxDistro = do

  try_debian_version :: IO (Text, Maybe Text)
  try_debian_version = do
-    ver <- T.readFile debian_version
-    pure (T.pack "debian", Just ver)
+    ver <- readFile debian_version
+    pure (T.pack "debian", Just . decUTF8Safe' $ ver)
--- a/lib/GHCup/Requirements.hs
+++ b/lib/GHCup/Requirements.hs
@@ -7,7 +7,7 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX
 -}
 module GHCup.Requirements where

--- a/lib/GHCup/Types.hs
+++ b/lib/GHCup/Types.hs
@@ -1,12 +1,11 @@
 {-# OPTIONS_GHC -Wno-orphans #-}
 {-# LANGUAGE CPP               #-}
-{-# LANGUAGE BangPatterns      #-}
-{-# LANGUAGE DataKinds         #-}
 {-# LANGUAGE DeriveGeneric     #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE FlexibleContexts  #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE FlexibleInstances           #-}
+{-# LANGUAGE MultiParamTypeClasses           #-}
+{-# LANGUAGE UndecidableInstances           #-}

 {-|
 Module      : GHCup.Types
@@ -15,44 +14,28 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX
 -}
-module GHCup.Types
-  ( module GHCup.Types
-#if defined(BRICK)
-  , Key(..)
-#endif
-  )
-  where
+module GHCup.Types where

-import           Control.Applicative
-import           Control.DeepSeq                ( NFData, rnf )
-import           Control.Monad.Logger
 import           Data.Map.Strict                ( Map )
 import           Data.List.NonEmpty             ( NonEmpty (..) )
+import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
-import           Haskus.Utils.Variant.Excepts
+import           HPath
 import           Text.PrettyPrint.HughesPJClass (Pretty, pPrint, text)
 import           URI.ByteString
-#if defined(BRICK)
-import           Graphics.Vty                   ( Key(..) )
-#endif

-import qualified Control.Monad.Trans.Class     as Trans
 import qualified Data.Text                     as T
+import qualified Data.Text.Encoding            as E
+import qualified Data.Text.Encoding.Error      as E
 import qualified GHC.Generics                  as GHC
+import qualified Graphics.Vty                  as Vty
+import Haskus.Utils.Variant.Excepts
+import Control.Monad.Reader


-#if !defined(BRICK)
-data Key = KEsc  | KChar Char | KBS | KEnter
-         | KLeft | KRight | KUp | KDown
-         | KUpLeft | KUpRight | KDownLeft | KDownRight | KCenter
-         | KFun Int | KBackTab | KPrtScr | KPause | KIns
-         | KHome | KPageUp | KDel | KEnd | KPageDown | KBegin | KMenu
-    deriving (Eq,Show,Read,Ord,GHC.Generic)
-#endif
-

    --------------------
    --[ GHCInfo Tree ]--
@@ -62,12 +45,9 @@ data Key = KEsc  | KChar Char | KBS | KEnter
 data GHCupInfo = GHCupInfo
  { _toolRequirements :: ToolRequirements
  , _ghcupDownloads   :: GHCupDownloads
-  , _globalTools      :: Map GlobalTool DownloadInfo
  }
  deriving (Show, GHC.Generic)

-instance NFData GHCupInfo
-


    -------------------------
@@ -87,8 +67,6 @@ data Requirements = Requirements
  }
  deriving (Show, GHC.Generic)

-instance NFData Requirements
-



@@ -112,16 +90,8 @@ data Tool = GHC
          | Cabal
          | GHCup
          | HLS
-          | Stack
  deriving (Eq, GHC.Generic, Ord, Show, Enum, Bounded)

-instance NFData Tool
-
-data GlobalTool = ShimGen
-  deriving (Eq, GHC.Generic, Ord, Show, Enum, Bounded)
-
-instance NFData GlobalTool
-

 -- | All necessary information of a tool version, including
 -- source download and per-architecture downloads.
@@ -137,8 +107,6 @@ data VersionInfo = VersionInfo
  }
  deriving (Eq, GHC.Generic, Show)

-instance NFData VersionInfo
-

 -- | A tag. These are currently attached to a version of a tool.
 data Tag = Latest
@@ -149,8 +117,6 @@ data Tag = Latest
         | UnknownTag String  -- ^ used for upwardscompat
         deriving (Ord, Eq, GHC.Generic, Show) -- FIXME: manual JSON instance

-instance NFData Tag
-
 tagToString :: Tag -> String
 tagToString Recommended        = "recommended"
 tagToString Latest             = "latest"
@@ -177,8 +143,6 @@ data Architecture = A_64
                  | A_ARM64
  deriving (Eq, GHC.Generic, Ord, Show)

-instance NFData Architecture
-
 archToString :: Architecture -> String
 archToString A_64 = "x86_64"
 archToString A_32 = "i386"
@@ -197,17 +161,12 @@ data Platform = Linux LinuxDistro
              | Darwin
              -- ^ must exit
              | FreeBSD
-              | Windows
-              -- ^ must exit
  deriving (Eq, GHC.Generic, Ord, Show)

-instance NFData Platform
-
 platformToString :: Platform -> String
 platformToString (Linux distro) = "linux-" ++ distroToString distro
 platformToString Darwin = "darwin"
 platformToString FreeBSD = "freebsd"
-platformToString Windows = "windows"

 instance Pretty Platform where
  pPrint = text . platformToString
@@ -228,8 +187,6 @@ data LinuxDistro = Debian
                 -- ^ must exit
  deriving (Eq, GHC.Generic, Ord, Show)

-instance NFData LinuxDistro
-
 distroToString :: LinuxDistro -> String
 distroToString Debian = "debian"
 distroToString Ubuntu = "ubuntu"
@@ -256,7 +213,6 @@ data DownloadInfo = DownloadInfo
  }
  deriving (Eq, Ord, GHC.Generic, Show)

-instance NFData DownloadInfo



@@ -266,14 +222,12 @@ instance NFData DownloadInfo


 -- | How to descend into a tar archive.
-data TarDir = RealDir FilePath
+data TarDir = RealDir (Path Rel)
            | RegexDir String     -- ^ will be compiled to regex, the first match will "win"
            deriving (Eq, Ord, GHC.Generic, Show)

-instance NFData TarDir
-
 instance Pretty TarDir where
-  pPrint (RealDir path) = text path
+  pPrint (RealDir path) = text [i|#{E.decodeUtf8With E.lenientDecode . toFilePath $ path}|]
  pPrint (RegexDir regex) = text regex


@@ -284,10 +238,6 @@ data URLSource = GHCupURL
               | AddSource (Either GHCupInfo URI) -- ^ merge with GHCupURL
               deriving (GHC.Generic, Show)

-instance NFData URLSource
-instance NFData (URIRef Absolute) where
-  rnf (URI !_ !_ !_ !_ !_) = ()
-

 data UserSettings = UserSettings
  { uCache       :: Maybe Bool
@@ -297,73 +247,53 @@ data UserSettings = UserSettings
  , uDownloader  :: Maybe Downloader
  , uKeyBindings :: Maybe UserKeyBindings
  , uUrlSource   :: Maybe URLSource
-  , uNoNetwork   :: Maybe Bool
  }
  deriving (Show, GHC.Generic)

 defaultUserSettings :: UserSettings
-defaultUserSettings = UserSettings Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing
+defaultUserSettings = UserSettings Nothing Nothing Nothing Nothing Nothing Nothing Nothing

 data UserKeyBindings = UserKeyBindings
-  { kUp        :: Maybe Key
-  , kDown      :: Maybe Key
-  , kQuit      :: Maybe Key
-  , kInstall   :: Maybe Key
-  , kUninstall :: Maybe Key
-  , kSet       :: Maybe Key
-  , kChangelog :: Maybe Key
-  , kShowAll   :: Maybe Key
-  , kShowAllTools :: Maybe Key
+  { kUp        :: Maybe Vty.Key
+  , kDown      :: Maybe Vty.Key
+  , kQuit      :: Maybe Vty.Key
+  , kInstall   :: Maybe Vty.Key
+  , kUninstall :: Maybe Vty.Key
+  , kSet       :: Maybe Vty.Key
+  , kChangelog :: Maybe Vty.Key
+  , kShowAll   :: Maybe Vty.Key
  }
  deriving (Show, GHC.Generic)

 data KeyBindings = KeyBindings
-  { bUp        :: Key
-  , bDown      :: Key
-  , bQuit      :: Key
-  , bInstall   :: Key
-  , bUninstall :: Key
-  , bSet       :: Key
-  , bChangelog :: Key
-  , bShowAllVersions :: Key
-  , bShowAllTools :: Key
+  { bUp        :: Vty.Key
+  , bDown      :: Vty.Key
+  , bQuit      :: Vty.Key
+  , bInstall   :: Vty.Key
+  , bUninstall :: Vty.Key
+  , bSet       :: Vty.Key
+  , bChangelog :: Vty.Key
+  , bShowAll   :: Vty.Key
  }
  deriving (Show, GHC.Generic)

-instance NFData KeyBindings
-instance NFData Key
-
 defaultKeyBindings :: KeyBindings
 defaultKeyBindings = KeyBindings
-  { bUp = KUp
-  , bDown = KDown
-  , bQuit = KChar 'q'
-  , bInstall = KChar 'i'
-  , bUninstall = KChar 'u'
-  , bSet = KChar 's'
-  , bChangelog = KChar 'c'
-  , bShowAllVersions = KChar 'a'
-  , bShowAllTools = KChar 't'
+  { bUp = Vty.KUp
+  , bDown = Vty.KDown
+  , bQuit = Vty.KChar 'q'
+  , bInstall = Vty.KChar 'i'
+  , bUninstall = Vty.KChar 'u'
+  , bSet = Vty.KChar 's'
+  , bChangelog = Vty.KChar 'c'
+  , bShowAll = Vty.KChar 'a'
  }

 data AppState = AppState
  { settings :: Settings
  , dirs :: Dirs
  , keyBindings :: KeyBindings
-  , ghcupInfo :: GHCupInfo
-  , pfreq :: PlatformRequest
-  } deriving (Show, GHC.Generic)
-
-instance NFData AppState
-
-data LeanAppState = LeanAppState
-  { settings :: Settings
-  , dirs :: Dirs
-  , keyBindings :: KeyBindings
-  } deriving (Show, GHC.Generic)
-
-instance NFData LeanAppState
-
+  } deriving (Show)

 data Settings = Settings
  { cache      :: Bool
@@ -372,45 +302,35 @@ data Settings = Settings
  , downloader :: Downloader
  , verbose    :: Bool
  , urlSource  :: URLSource
-  , noNetwork  :: Bool
  }
  deriving (Show, GHC.Generic)

-instance NFData Settings
-
 data Dirs = Dirs
-  { baseDir  :: FilePath
-  , binDir   :: FilePath
-  , cacheDir :: FilePath
-  , logsDir  :: FilePath
-  , confDir  :: FilePath
-  , recycleDir :: FilePath -- mainly used on windows
+  { baseDir  :: Path Abs
+  , binDir   :: Path Abs
+  , cacheDir :: Path Abs
+  , logsDir  :: Path Abs
+  , confDir  :: Path Abs
  }
-  deriving (Show, GHC.Generic)
-
-instance NFData Dirs
+  deriving Show

 data KeepDirs = Always
              | Errors
              | Never
-  deriving (Eq, Show, Ord, GHC.Generic)
-
-instance NFData KeepDirs
+  deriving (Eq, Show, Ord)

 data Downloader = Curl
                | Wget
 #if defined(INTERNAL_DOWNLOADER)
                | Internal
 #endif
-  deriving (Eq, Show, Ord, GHC.Generic)
-
-instance NFData Downloader
+  deriving (Eq, Show, Ord)

 data DebugInfo = DebugInfo
-  { diBaseDir  :: FilePath
-  , diBinDir   :: FilePath
-  , diGHCDir   :: FilePath
-  , diCacheDir :: FilePath
+  { diBaseDir  :: Path Abs
+  , diBinDir   :: Path Abs
+  , diGHCDir   :: Path Abs
+  , diCacheDir :: Path Abs
  , diArch     :: Architecture
  , diPlatform :: PlatformResult
  }
@@ -427,9 +347,7 @@ data PlatformResult = PlatformResult
  { _platform      :: Platform
  , _distroVersion :: Maybe Versioning
  }
-  deriving (Eq, Show, GHC.Generic)
-
-instance NFData PlatformResult
+  deriving (Eq, Show)

 platResToString :: PlatformResult -> String
 platResToString PlatformResult { _platform = plat, _distroVersion = Just v' }
@@ -445,9 +363,7 @@ data PlatformRequest = PlatformRequest
  , _rPlatform :: Platform
  , _rVersion  :: Maybe Versioning
  }
-  deriving (Eq, Show, GHC.Generic)
-
-instance NFData PlatformRequest
+  deriving (Eq, Show)

 pfReqToString :: PlatformRequest -> String
 pfReqToString (PlatformRequest arch plat ver) =
@@ -494,8 +410,6 @@ data VersionCmp = VR_gt Versioning
                | VR_eq Versioning
  deriving (Eq, GHC.Generic, Ord, Show)

-instance NFData VersionCmp
-

 -- | A version range. Supports && and ||, but not  arbitrary
 -- combinations. This is a little simplified.
@@ -503,7 +417,6 @@ data VersionRange = SimpleRange (NonEmpty VersionCmp) -- And
                  | OrRange (NonEmpty VersionCmp) VersionRange
  deriving (Eq, GHC.Generic, Ord, Show)

-instance NFData VersionRange

 instance Pretty Versioning where
  pPrint = text . T.unpack . prettyV
@@ -512,13 +425,11 @@ instance Pretty Version where
  pPrint = text . T.unpack . prettyVer


-instance (Monad m, Alternative m) => Alternative (LoggingT m) where
-    empty   = Trans.lift empty
-    {-# INLINE empty #-}
-    m <|> n = LoggingT $ \ r -> runLoggingT m r <|> runLoggingT n r
-    {-# INLINE (<|>) #-}
-
-
-instance MonadLogger m => MonadLogger (Excepts e m) where
-  monadLoggerLog a b c d = Trans.lift $ monadLoggerLog a b c d
+    -----------------
+    --[ Instances ]--
+    -----------------

+instance MonadReader r' m => MonadReader r' (Excepts es m) where
+    ask   = lift ask
+    local = mapExcepts . local
+    reader = lift . reader
--- a/lib/GHCup/Types/JSON.hs
+++ b/lib/GHCup/Types/JSON.hs
@@ -17,7 +17,7 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX
 -}
 module GHCup.Types.JSON where

@@ -33,27 +33,38 @@ import           Data.List.NonEmpty             ( NonEmpty(..) )
 import           Data.Text.Encoding            as E
 import           Data.Versions
 import           Data.Void
+import           Data.Word8
+import           HPath
 import           URI.ByteString
 import           Text.Casing

+import qualified Data.ByteString               as BS
 import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T
+import qualified Graphics.Vty                  as Vty
 import qualified Text.Megaparsec               as MP
 import qualified Text.Megaparsec.Char          as MPC


 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } { fieldLabelModifier = removeLensFieldLabel } ''Architecture
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''LinuxDistro
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VSep
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VUnit
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Mess
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''MChunk
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Platform
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Mess
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''SemVer
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GlobalTool
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VSep
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VUnit
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VersionInfo
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''DownloadInfo
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GHCupInfo
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Requirements
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''KeepDirs
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Downloader
+deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''URLSource
+deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "u-") . T.pack . kebab $ str' } ''UserSettings
+deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "k-") . T.pack . kebab $ str' } ''UserKeyBindings
+deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''Vty.Key

 instance ToJSON Tag where
  toJSON Latest             = String "Latest"
@@ -117,13 +128,11 @@ instance ToJSONKey Platform where
    Darwin  -> T.pack "Darwin"
    FreeBSD -> T.pack "FreeBSD"
    Linux d -> T.pack ("Linux_" <> show d)
-    Windows -> T.pack "Windows"

 instance FromJSONKey Platform where
  fromJSONKey = FromJSONKeyTextParser $ \t -> if
    | T.pack "Darwin" == t -> pure Darwin
    | T.pack "FreeBSD" == t -> pure FreeBSD
-    | T.pack "Windows" == t -> pure Windows
    | T.pack "Linux_" `T.isPrefixOf` t -> case
        T.stripPrefix (T.pack "Linux_") t
      of
@@ -190,11 +199,19 @@ instance ToJSONKey Tool where
 instance FromJSONKey Tool where
  fromJSONKey = genericFromJSONKey defaultJSONKeyOptions

-instance ToJSONKey GlobalTool where
-  toJSONKey = genericToJSONKey defaultJSONKeyOptions
+instance ToJSON (Path Rel) where
+  toJSON p = case and . fmap isAscii . BS.unpack $ fp of
+    True  -> toJSON . decUTF8Safe $ fp
+    False -> String "/not/a/valid/path"
+    where fp = toFilePath p
+
+instance FromJSON (Path Rel) where
+  parseJSON = withText "HPath Rel" $ \t -> do
+    let d = encodeUtf8 t
+    case parseRel d of
+      Right x -> pure x
+      Left  e -> fail $ "Failure in HPath Rel (FromJSON)" <> show e

-instance FromJSONKey GlobalTool where
-  fromJSONKey = genericFromJSONKey defaultJSONKeyOptions

 instance ToJSON TarDir where
  toJSON (RealDir  p) = toJSON p
@@ -305,14 +322,3 @@ instance FromJSONKey (Maybe VersionRange)  where
    just t = case MP.parse versionRangeP "" t of
      Right x -> pure $ Just x
      Left  e -> fail $ "Failure in (Maybe VersionRange) (FromJSONKey)" <> MP.errorBundlePretty e
-
-
-
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Requirements
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''DownloadInfo
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VersionInfo
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GHCupInfo
-deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''URLSource
-deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''Key
-deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "k-") . T.pack . kebab $ str' } ''UserKeyBindings
-deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "u-") . T.pack . kebab $ str' } ''UserSettings
--- a/lib/GHCup/Types/Optics.hs
+++ b/lib/GHCup/Types/Optics.hs
@@ -1,11 +1,4 @@
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# LANGUAGE TemplateHaskell       #-}
-{-# LANGUAGE ConstraintKinds       #-}
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE AllowAmbiguousTypes   #-}
-{-# LANGUAGE MultiParamTypeClasses   #-}
+{-# LANGUAGE TemplateHaskell #-}

 {-|
 Module      : GHCup.Types.Optics
@@ -14,13 +7,12 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX
 -}
 module GHCup.Types.Optics where

 import           GHCup.Types

-import           Control.Monad.Reader
 import           Data.ByteString                ( ByteString )
 import           Optics
 import           URI.ByteString
@@ -66,85 +58,3 @@ pathL' = lensVL pathL

 queryL' :: Lens' (URIRef a) Query
 queryL' = lensVL queryL
-
-
-
-    ----------------------
-    --[ Lens utilities ]--
-    ----------------------
-
-
-gets :: forall f a env m . (MonadReader env m, LabelOptic' f A_Lens env a)
-     => m a
-gets = asks (^. labelOptic @f)
-
-
-getAppState :: MonadReader AppState m => m AppState
-getAppState = ask
-
-
-getLeanAppState :: ( MonadReader env m
-                   , LabelOptic' "settings"    A_Lens env Settings
-                   , LabelOptic' "dirs"        A_Lens env Dirs
-                   , LabelOptic' "keyBindings" A_Lens env KeyBindings
-                   )
-                => m LeanAppState
-getLeanAppState = do
-  s <- gets @"settings"
-  d <- gets @"dirs"
-  k <- gets @"keyBindings"
-  pure (LeanAppState s d k)
-
-
-getSettings :: ( MonadReader env m
-               , LabelOptic' "settings" A_Lens env Settings
-               )
-            => m Settings
-getSettings = gets @"settings"
-
-
-getDirs :: ( MonadReader env m
-           , LabelOptic' "dirs" A_Lens env Dirs
-           )
-        => m Dirs
-getDirs = gets @"dirs"
-
-
-getKeyBindings :: ( MonadReader env m
-                  , LabelOptic' "keyBindings" A_Lens env KeyBindings
-                  )
-               => m KeyBindings
-getKeyBindings = gets @"keyBindings"
-
-
-getGHCupInfo :: ( MonadReader env m
-                , LabelOptic' "ghcupInfo" A_Lens env GHCupInfo
-                )
-             => m GHCupInfo
-getGHCupInfo = gets @"ghcupInfo"
-
-
-getPlatformReq :: ( MonadReader env m
-                  , LabelOptic' "pfreq" A_Lens env PlatformRequest
-                  )
-               => m PlatformRequest
-getPlatformReq = gets @"pfreq"
-
-
-type HasSettings env = (LabelOptic' "settings" A_Lens env Settings)
-type HasDirs env = (LabelOptic' "dirs" A_Lens env Dirs)
-type HasKeyBindings env = (LabelOptic' "keyBindings" A_Lens env KeyBindings)
-type HasGHCupInfo env = (LabelOptic' "ghcupInfo" A_Lens env GHCupInfo)
-type HasPlatformReq env = (LabelOptic' "pfreq" A_Lens env PlatformRequest)
-
-
-getCache :: (MonadReader env m, HasSettings env) => m Bool
-getCache = getSettings <&> cache
-
-
-getDownloader :: (MonadReader env m, HasSettings env) => m Downloader
-getDownloader = getSettings <&> downloader
-
-
-instance LabelOptic "dirs" A_Lens Dirs Dirs Dirs Dirs where
-  labelOptic = lens id (\_ d -> d)
--- a/lib/GHCup/Utils.hs
+++ b/lib/GHCup/Utils.hs
--- a/lib/GHCup/Utils.hs-boot
+++ b/lib/GHCup/Utils.hs-boot
@@ -1,4 +0,0 @@
-module GHCup.Utils where
-
-getLinkTarget :: FilePath -> IO FilePath
-pathIsLink :: FilePath -> IO Bool
--- a/lib/GHCup/Utils/Dirs.hs
+++ b/lib/GHCup/Utils/Dirs.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE CPP                   #-}
 {-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE FlexibleContexts      #-}
@@ -13,11 +12,10 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX
 -}
 module GHCup.Utils.Dirs
-  ( getAllDirs
-  , ghcupBaseDir
+  ( getDirs
  , ghcupConfigFile
  , ghcupCacheDir
  , ghcupGHCBaseDir
@@ -26,11 +24,6 @@ module GHCup.Utils.Dirs
  , parseGHCupGHCDir
  , relativeSymlink
  , withGHCupTmpDir
-  , getConfigFilePath
-#if !defined(IS_WINDOWS)
-  , useXDG
-#endif
-  , cleanupTrash
  )
 where

@@ -38,10 +31,10 @@ where
 import           GHCup.Errors
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
-import           GHCup.Types.Optics
 import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude

+import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Unlift
@@ -49,20 +42,32 @@ import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource hiding (throwM)
 import           Data.Bifunctor
+import           Data.ByteString                ( ByteString )
 import           Data.Maybe
 import           Data.String.Interpolate
 import           GHC.IO.Exception               ( IOErrorType(NoSuchThing) )
 import           Haskus.Utils.Variant.Excepts
+import           HPath
+import           HPath.IO
 import           Optics
-import           System.Directory                                                
+import           Prelude                 hiding ( abs
+                                                , readFile
+                                                , writeFile
+                                                )
 import           System.DiskSpace                                                
-import           System.Environment
-import           System.FilePath
-import           System.IO.Temp
+import           System.Posix.Env.ByteString    ( getEnv
+                                                , getEnvDefault
+                                                )
+import           System.Posix.FilePath   hiding ( (</>) )
+import           System.Posix.Temp.ByteString   ( mkdtemp )

-import qualified Data.ByteString               as BS
+import qualified Data.ByteString.Lazy          as L
+import qualified Data.ByteString.UTF8          as UTF8
 import qualified Data.Text                     as T
+import qualified Data.Text.Encoding            as E
 import qualified Data.Yaml                     as Y
+import qualified System.Posix.FilePath         as FP
+import qualified System.Posix.User             as PU
 import qualified Text.Megaparsec               as MP
 import Control.Concurrent (threadDelay)

@@ -77,134 +82,105 @@ import Control.Concurrent (threadDelay)
 --
 -- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
 -- then uses 'XDG_DATA_HOME/ghcup' as per xdg spec.
-ghcupBaseDir :: IO FilePath
+ghcupBaseDir :: IO (Path Abs)
 ghcupBaseDir = do
-#if defined(IS_WINDOWS)
-  bdir <- fromMaybe "C:\\" <$> lookupEnv "GHCUP_INSTALL_BASE_PREFIX"
-  pure (bdir </> "ghcup")
-#else
  xdg <- useXDG
  if xdg
    then do
-      bdir <- lookupEnv "XDG_DATA_HOME" >>= \case
-        Just r  -> pure r
+      bdir <- getEnv "XDG_DATA_HOME" >>= \case
+        Just r  -> parseAbs r
        Nothing -> do
          home <- liftIO getHomeDirectory
-          pure (home </> ".local" </> "share")
-      pure (bdir </> "ghcup")
+          pure (home </> [rel|.local/share|])
+      pure (bdir </> [rel|ghcup|])
    else do
-      bdir <- lookupEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
-        Just r  -> pure r
+      bdir <- getEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
+        Just r  -> parseAbs r
        Nothing -> liftIO getHomeDirectory
-      pure (bdir </> ".ghcup")
-#endif
+      pure (bdir </> [rel|.ghcup|])


 -- | ~/.ghcup by default
 --
 -- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
 -- then uses 'XDG_CONFIG_HOME/ghcup' as per xdg spec.
-ghcupConfigDir :: IO FilePath
+ghcupConfigDir :: IO (Path Abs)
 ghcupConfigDir = do
-#if defined(IS_WINDOWS)
-  ghcupBaseDir
-#else
  xdg <- useXDG
  if xdg
    then do
-      bdir <- lookupEnv "XDG_CONFIG_HOME" >>= \case
-        Just r  -> pure r
+      bdir <- getEnv "XDG_CONFIG_HOME" >>= \case
+        Just r  -> parseAbs r
        Nothing -> do
          home <- liftIO getHomeDirectory
-          pure (home </> ".config")
-      pure (bdir </> "ghcup")
+          pure (home </> [rel|.config|])
+      pure (bdir </> [rel|ghcup|])
    else do
-      bdir <- lookupEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
-        Just r  -> pure r
+      bdir <- getEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
+        Just r  -> parseAbs r
        Nothing -> liftIO getHomeDirectory
-      pure (bdir </> ".ghcup")
-#endif
+      pure (bdir </> [rel|.ghcup|])


 -- | If 'GHCUP_USE_XDG_DIRS' is set (to anything),
 -- then uses 'XDG_BIN_HOME' env var or defaults to '~/.local/bin'
 -- (which, sadly is not strictly xdg spec).
-ghcupBinDir :: IO FilePath
+ghcupBinDir :: IO (Path Abs)
 ghcupBinDir = do
-#if defined(IS_WINDOWS)
-  ghcupBaseDir <&> (</> "bin")
-#else
  xdg <- useXDG
  if xdg
    then do
-      lookupEnv "XDG_BIN_HOME" >>= \case
-        Just r  -> pure r
+      getEnv "XDG_BIN_HOME" >>= \case
+        Just r  -> parseAbs r
        Nothing -> do
          home <- liftIO getHomeDirectory
-          pure (home </> ".local" </> "bin")
-    else ghcupBaseDir <&> (</> "bin")
-#endif
+          pure (home </> [rel|.local/bin|])
+    else ghcupBaseDir <&> (</> [rel|bin|])


 -- | Defaults to '~/.ghcup/cache'.
 --
 -- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
 -- then uses 'XDG_CACHE_HOME/ghcup' as per xdg spec.
-ghcupCacheDir :: IO FilePath
+ghcupCacheDir :: IO (Path Abs)
 ghcupCacheDir = do
-#if defined(IS_WINDOWS)
-  ghcupBaseDir <&> (</> "cache")
-#else
  xdg <- useXDG
  if xdg
    then do
-      bdir <- lookupEnv "XDG_CACHE_HOME" >>= \case
-        Just r  -> pure r
+      bdir <- getEnv "XDG_CACHE_HOME" >>= \case
+        Just r  -> parseAbs r
        Nothing -> do
          home <- liftIO getHomeDirectory
-          pure (home </> ".cache")
-      pure (bdir </> "ghcup")
-    else ghcupBaseDir <&> (</> "cache")
-#endif
+          pure (home </> [rel|.cache|])
+      pure (bdir </> [rel|ghcup|])
+    else ghcupBaseDir <&> (</> [rel|cache|])


 -- | Defaults to '~/.ghcup/logs'.
 --
 -- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
 -- then uses 'XDG_CACHE_HOME/ghcup/logs' as per xdg spec.
-ghcupLogsDir :: IO FilePath
+ghcupLogsDir :: IO (Path Abs)
 ghcupLogsDir = do
-#if defined(IS_WINDOWS)
-  ghcupBaseDir <&> (</> "logs")
-#else
  xdg <- useXDG
  if xdg
    then do
-      bdir <- lookupEnv "XDG_CACHE_HOME" >>= \case
-        Just r  -> pure r
+      bdir <- getEnv "XDG_CACHE_HOME" >>= \case
+        Just r  -> parseAbs r
        Nothing -> do
          home <- liftIO getHomeDirectory
-          pure (home </> ".cache")
-      pure (bdir </> "ghcup" </> "logs")
-    else ghcupBaseDir <&> (</> "logs")
-#endif
+          pure (home </> [rel|.cache|])
+      pure (bdir </> [rel|ghcup/logs|])
+    else ghcupBaseDir <&> (</> [rel|logs|])


-- | '~/.ghcup/trash'.
-- Mainly used on windows to improve file removal operations
-ghcupRecycleDir :: IO FilePath
-ghcupRecycleDir = ghcupBaseDir <&> (</> "trash")
-
-
-
-getAllDirs :: IO Dirs
-getAllDirs = do
-  baseDir    <- ghcupBaseDir
-  binDir     <- ghcupBinDir
-  cacheDir   <- ghcupCacheDir
-  logsDir    <- ghcupLogsDir
-  confDir    <- ghcupConfigDir
-  recycleDir <- ghcupRecycleDir
+getDirs :: IO Dirs
+getDirs = do
+  baseDir  <- ghcupBaseDir
+  binDir   <- ghcupBinDir
+  cacheDir <- ghcupCacheDir
+  logsDir  <- ghcupLogsDir
+  confDir  <- ghcupConfigDir
  pure Dirs { .. }


@@ -213,19 +189,16 @@ getAllDirs = do
    --[ GHCup files ]--
    -------------------

-getConfigFilePath :: (MonadIO m) => m FilePath
-getConfigFilePath = do
-  confDir <- liftIO ghcupConfigDir
-  pure $ confDir </> "config.yaml"

 ghcupConfigFile :: (MonadIO m)
                => Excepts '[JSONError] m UserSettings
 ghcupConfigFile = do
-  filepath <- getConfigFilePath
-  contents <- liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ Just <$> BS.readFile filepath
-  case contents of
+  confDir <- liftIO ghcupConfigDir
+  let file = confDir </> [rel|config.yaml|]
+  bs <- liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ Just <$> readFile file
+  case bs of
      Nothing -> pure defaultUserSettings
-      Just contents' -> lE' JSONDecodeError . first show . Y.decodeEither' $ contents'
+      Just bs' -> lE' JSONDecodeError . first show . Y.decodeEither' . L.toStrict $ bs'


    -------------------------
@@ -234,52 +207,47 @@ ghcupConfigFile = do


 -- | ~/.ghcup/ghc by default.
-ghcupGHCBaseDir :: (MonadReader env m, HasDirs env) => m FilePath
+ghcupGHCBaseDir :: (MonadReader AppState m) => m (Path Abs)
 ghcupGHCBaseDir = do
-  Dirs {..}  <- getDirs
-  pure (baseDir </> "ghc")
+  AppState { dirs = Dirs {..} } <- ask
+  pure (baseDir </> [rel|ghc|])


 -- | Gets '~/.ghcup/ghc/<ghcupGHCDir>'.
 -- The dir may be of the form
 --   * armv7-unknown-linux-gnueabihf-8.8.3
 --   * 8.8.4
-ghcupGHCDir :: (MonadReader env m, HasDirs env, MonadThrow m)
+ghcupGHCDir :: (MonadReader AppState m, MonadThrow m)
            => GHCTargetVersion
-            -> m FilePath
+            -> m (Path Abs)
 ghcupGHCDir ver = do
-  ghcbasedir <- ghcupGHCBaseDir
-  let verdir = T.unpack $ tVerToText ver
+  ghcbasedir    <- ghcupGHCBaseDir
+  verdir        <- parseRel $ E.encodeUtf8 (tVerToText ver)
  pure (ghcbasedir </> verdir)


 -- | See 'ghcupToolParser'.
-parseGHCupGHCDir :: MonadThrow m => FilePath -> m GHCTargetVersion
-parseGHCupGHCDir (T.pack -> fp) =
+parseGHCupGHCDir :: MonadThrow m => Path Rel -> m GHCTargetVersion
+parseGHCupGHCDir (toFilePath -> f) = do
+  fp <- throwEither $ E.decodeUtf8' f
  throwEither $ MP.parse ghcTargetVerP "" fp


-mkGhcupTmpDir :: ( MonadReader env m
-                 , HasDirs env
-                 , MonadUnliftIO m
-                 , MonadLogger m
-                 , MonadCatch m
-                 , MonadThrow m
-                 , MonadMask m
-                 , MonadIO m)
-              => m FilePath
+mkGhcupTmpDir :: (MonadUnliftIO m, MonadLogger m, MonadCatch m, MonadThrow m, MonadIO m) => m (Path Abs)
 mkGhcupTmpDir = do
-  tmpdir <- liftIO getCanonicalTemporaryDirectory
+  tmpdir <- liftIO $ getEnvDefault "TMPDIR" "/tmp"
+  let fp = T.unpack $ decUTF8Safe tmpdir

  let minSpace = 5000 -- a rough guess, aight?
-  space <- handleIO (\_ -> pure Nothing) $ fmap Just $ liftIO $ getAvailSpace tmpdir
+  space <- handleIO (\_ -> pure Nothing) $ fmap Just $ liftIO $ getAvailSpace fp
  when (maybe False (toBytes minSpace >) space) $ do
-    $(logWarn) [i|Possibly insufficient disk space on #{tmpdir}. At least #{minSpace} MB are recommended, but only #{toMB (fromJust space)} are free. Consider freeing up disk space or setting TMPDIR env variable.|]
+    $(logWarn) [i|Possibly insufficient disk space on #{fp}. At least #{minSpace} MB are recommended, but only #{toMB (fromJust space)} are free. Consider freeing up disk space or setting TMPDIR env variable.|]
    $(logWarn)
      "...waiting for 10 seconds before continuing anyway, you can still abort..."
    liftIO $ threadDelay 10000000 -- give the user a sec to intervene

-  liftIO $ createTempDirectory tmpdir "ghcup"
+  tmp <- liftIO $ mkdtemp (tmpdir FP.</> "ghcup-")
+  parseAbs tmp
 where
  toBytes mb = mb * 1024 * 1024
  toMB b = show (truncate' (fromIntegral b / (1024 * 1024) :: Double) 2)
@@ -288,25 +256,8 @@ mkGhcupTmpDir = do
      where t = 10^n


-withGHCupTmpDir :: ( MonadReader env m
-                   , HasDirs env
-                   , MonadUnliftIO m
-                   , MonadLogger m
-                   , MonadCatch m
-                   , MonadResource m
-                   , MonadThrow m
-                   , MonadMask m
-                   , MonadIO m)
-                => m FilePath
-withGHCupTmpDir = snd <$> withRunInIO (\run ->
-  run
-    $ allocate
-        (run mkGhcupTmpDir)
-        (\fp ->
-            handleIO (\e -> run
-                $ $(logDebug) [i|Resource cleanup failed for "#{fp}", error was: #{displayException e}|])
-            . rmPathForcibly
-            $ fp))
+withGHCupTmpDir :: (MonadUnliftIO m, MonadLogger m, MonadCatch m, MonadResource m, MonadThrow m, MonadIO m) => m (Path Abs)
+withGHCupTmpDir = snd <$> withRunInIO (\run -> run $ allocate (run mkGhcupTmpDir) deleteDirRecursive)



@@ -316,39 +267,29 @@ withGHCupTmpDir = snd <$> withRunInIO (\run ->
    --------------


-#if !defined(IS_WINDOWS)
+getHomeDirectory :: IO (Path Abs)
+getHomeDirectory = do
+  e <- getEnv "HOME"
+  case e of
+    Just fp -> parseAbs fp
+    Nothing -> do
+      h <- PU.homeDirectory <$> (PU.getEffectiveUserID >>= PU.getUserEntryForID)
+      parseAbs $ UTF8.fromString h -- this is a guess
+
+
 useXDG :: IO Bool
-useXDG = isJust <$> lookupEnv "GHCUP_USE_XDG_DIRS"
-#endif
+useXDG = isJust <$> getEnv "GHCUP_USE_XDG_DIRS"


-relativeSymlink :: FilePath  -- ^ the path in which to create the symlink
-                -> FilePath  -- ^ the symlink destination
-                -> FilePath
-relativeSymlink p1 p2 =
+relativeSymlink :: Path Abs  -- ^ the path in which to create the symlink
+                -> Path Abs  -- ^ the symlink destination
+                -> ByteString
+relativeSymlink (toFilePath -> p1) (toFilePath -> p2) =
  let d1      = splitDirectories p1
      d2      = splitDirectories p2
      common  = takeWhile (\(x, y) -> x == y) $ zip d1 d2
      cPrefix = drop (length common) d1
  in  joinPath (replicate (length cPrefix) "..")
-        <> joinPath ([pathSeparator] : drop (length common) d2)
+        <> joinPath ("/" : drop (length common) d2)


-cleanupTrash :: ( MonadIO m
-                , MonadMask m
-                , MonadLogger m
-                , MonadReader env m
-                , HasDirs env
-                )
-             => m ()
-cleanupTrash = do
-  Dirs { recycleDir } <- getDirs
-  contents <- liftIO $ listDirectory recycleDir
-  if null contents
-  then pure ()
-  else do
-    $(logWarn) [i|Removing leftover files in #{recycleDir}|]
-    forM_ contents (\fp -> handleIO (\e ->
-        $(logDebug) [i|Resource cleanup failed for "#{fp}", error was: #{displayException e}|]
-      ) $ liftIO $ removePathForcibly (recycleDir </> fp))
-
--- a/lib/GHCup/Utils/File.hs
+++ b/lib/GHCup/Utils/File.hs
@@ -1,17 +1,482 @@
-{-# LANGUAGE CPP #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE ViewPatterns      #-}

-module GHCup.Utils.File (
-  module GHCup.Utils.File.Common,
-#if IS_WINDOWS
-  module GHCup.Utils.File.Windows
-#else
-  module GHCup.Utils.File.Posix
-#endif
-) where
+{-|
+Module      : GHCup.Utils.File
+Description : File and unix APIs
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : POSIX

-import GHCup.Utils.File.Common
-#if IS_WINDOWS
-import GHCup.Utils.File.Windows
-#else
-import GHCup.Utils.File.Posix
-#endif
+This module handles file and executable handling.
+Some of these functions use sophisticated logging.
+-}
+module GHCup.Utils.File where
+
+import           GHCup.Utils.Prelude
+import           GHCup.Types
+
+import           Control.Concurrent
+import           Control.Concurrent.Async
+import           Control.Exception              ( evaluate )
+import           Control.Exception.Safe
+import           Control.Monad
+import           Control.Monad.Logger
+import           Control.Monad.Reader
+import           Control.Monad.Trans.State.Strict
+import           Data.ByteString                ( ByteString )
+import           Data.Foldable
+import           Data.Functor
+import           Data.IORef
+import           Data.Maybe
+import           Data.Sequence                  ( Seq, (|>) )
+import           Data.String.Interpolate
+import           Data.Text                      ( Text )
+import           Data.Void
+import           Data.Word8
+import           GHC.IO.Exception
+import           HPath
+import           HPath.IO                hiding ( hideError )
+import           Optics                  hiding ((<|), (|>))
+import           System.Console.Pretty   hiding ( Pretty )
+import           System.Console.Regions
+import           System.IO.Error
+import           System.Posix.Directory.ByteString
+import           System.Posix.FD               as FD
+import           System.Posix.FilePath   hiding ( (</>) )
+import           System.Posix.Files.ByteString
+import           System.Posix.Foreign           ( oExcl, oAppend )
+import "unix"    System.Posix.IO.ByteString
+                                         hiding ( openFd )
+import           System.Posix.Process           ( ProcessStatus(..) )
+import           System.Posix.Types
+import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
+import           Text.Regex.Posix
+
+
+import qualified Control.Exception             as EX
+import qualified Data.Sequence                 as Sq
+import qualified Data.Text                     as T
+import qualified Data.Text.Encoding            as E
+import qualified System.Posix.Process.ByteString
+                                               as SPPB
+import           Streamly.External.Posix.DirStream
+import qualified Streamly.Prelude              as S
+import qualified Text.Megaparsec               as MP
+import qualified Data.ByteString               as BS
+import qualified "unix-bytestring" System.Posix.IO.ByteString
+                                               as SPIB
+
+
+
+data ProcessError = NonZeroExit Int ByteString [ByteString]
+                  | PTerminated ByteString [ByteString]
+                  | PStopped ByteString [ByteString]
+                  | NoSuchPid ByteString [ByteString]
+                  deriving Show
+
+instance Pretty ProcessError where
+  pPrint (NonZeroExit e exe args) =
+    text [i|Process "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args} failed with exit code #{e}.|]
+  pPrint (PTerminated exe args) =
+    text [i|Process "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args} terminated.|]
+  pPrint (PStopped exe args) =
+    text [i|Process "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args} stopped.|]
+  pPrint (NoSuchPid exe args) =
+    text [i|Could not find PID for process running "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args}.|]
+
+data CapturedProcess = CapturedProcess
+  { _exitCode :: ExitCode
+  , _stdOut   :: ByteString
+  , _stdErr   :: ByteString
+  }
+  deriving (Eq, Show)
+
+makeLenses ''CapturedProcess
+
+
+-- | Find the given executable by searching all *absolute* PATH components.
+-- Relative paths in PATH are ignored.
+--
+-- This shouldn't throw IO exceptions, unless getting the environment variable
+-- PATH does.
+findExecutable :: Path Rel -> IO (Maybe (Path Abs))
+findExecutable ex = do
+  sPaths <- fmap (catMaybes . fmap parseAbs) getSearchPath
+  -- We don't want exceptions to mess up our result. If we can't
+  -- figure out if a file exists, then treat it as a negative result.
+  asum $ fmap
+    (handleIO (\_ -> pure Nothing)
+      -- asum for short-circuiting behavior
+      . (\s' -> (isExecutable (s' </> ex) >>= guard) $> Just (s' </> ex))
+    )
+    sPaths
+
+
+-- | Execute the given command and collect the stdout, stderr and the exit code.
+-- The command is run in a subprocess.
+executeOut :: Path b            -- ^ command as filename, e.g. 'ls'
+           -> [ByteString]      -- ^ arguments to the command
+           -> Maybe (Path Abs)  -- ^ chdir to this path
+           -> IO CapturedProcess
+executeOut path args chdir = captureOutStreams $ do
+  maybe (pure ()) (changeWorkingDirectory . toFilePath) chdir
+  SPPB.executeFile (toFilePath path) True args Nothing
+
+
+execLogged :: (MonadReader AppState m, MonadIO m, MonadThrow m)
+           => ByteString       -- ^ thing to execute
+           -> Bool             -- ^ whether to search PATH for the thing
+           -> [ByteString]     -- ^ args for the thing
+           -> Path Rel         -- ^ log filename (opened in append mode)
+           -> Maybe (Path Abs) -- ^ optionally chdir into this
+           -> Maybe [(ByteString, ByteString)] -- ^ optional environment
+           -> MVar Bool
+           -> Seq ConsoleRegion
+           -> m (Either ProcessError ())
+execLogged exe spath args lfile chdir env pState rs = do
+  AppState { settings = Settings {..}, dirs = Dirs {..} } <- ask
+  logfile       <- (logsDir </>) <$> parseRel (toFilePath lfile <> ".log")
+  liftIO $ bracket (openFd (toFilePath logfile) WriteOnly [oAppend] (Just newFilePerms))
+                   closeFd
+                   (action verbose)
+ where
+  action verbose fd = do
+    actionWithPipes $ \(stdoutRead, stdoutWrite) -> do
+      -- start the thread that logs to stdout
+      void $ tryTakeMVar pState
+      done   <- newEmptyMVar
+      void
+        $ forkIO
+        $ EX.handle (\(_ :: IOException) -> pure ())
+        $ EX.finally
+            (if verbose
+              then tee fd stdoutRead
+              else printToRegion fd stdoutRead 6
+            )
+            (putMVar done ())
+
+      -- fork the subprocess
+      pid <- SPPB.forkProcess $ do
+        void $ dupTo stdoutWrite stdOutput
+        void $ dupTo stdoutWrite stdError
+        closeFd stdoutRead
+        closeFd stdoutWrite
+
+        -- execute the action
+        maybe (pure ()) (changeWorkingDirectory . toFilePath) chdir
+        void $ SPPB.executeFile exe spath args env
+
+      closeFd stdoutWrite
+
+      -- wait for the subprocess to finish
+      e <- toProcessError exe args <$!> SPPB.getProcessStatus True True pid
+      putMVar pState (either (const False) (const True) e)
+
+      void $ race (takeMVar done) (threadDelay (1000000 * 3))
+      closeFd stdoutRead
+
+      pure e
+
+  tee :: Fd -> Fd -> IO ()
+  tee fileFd fdIn = readTilEOF lineAction fdIn
+
+   where
+    lineAction :: ByteString -> IO ()
+    lineAction bs' = do
+      void $ SPIB.fdWrite fileFd (bs' <> "\n")
+      void $ SPIB.fdWrite stdOutput (bs' <> "\n")
+
+  -- Reads fdIn and logs the output in a continous scrolling area
+  -- of 'size' terminal lines. Also writes to a log file.
+  printToRegion :: Fd -> Fd -> Int -> IO ()
+  printToRegion fileFd fdIn size = do
+    void $
+      flip runStateT mempty $ readTilEOF (lineAction rs) fdIn
+
+   where
+    -- action to perform line by line
+    -- TODO: do this with vty for efficiency
+    lineAction :: (MonadMask m, MonadIO m)
+               => Seq ConsoleRegion
+               -> ByteString
+               -> StateT (Seq ByteString) m ()
+    lineAction rs' = \bs' -> do
+      void $ liftIO $ SPIB.fdWrite fileFd (bs' <> "\n")
+      modify (swapRegs bs')
+      regs <- get
+      liftIO $ forM_ (Sq.zip regs rs') $ \(bs, r) -> setConsoleRegion r $ do
+        w <- consoleWidth
+        return
+          . T.pack
+          . color Blue
+          . T.unpack
+          . decUTF8Safe
+          . trim w
+          . (\b -> "[ " <> toFilePath lfile <> " ] " <> b)
+          $ bs
+
+    swapRegs :: a -> Seq a -> Seq a
+    swapRegs bs = \regs -> if
+      | Sq.length regs < size -> regs |> bs
+      | otherwise             -> Sq.drop 1 regs |> bs
+
+    -- trim output line to terminal width
+    trim :: Int -> ByteString -> ByteString
+    trim w = \bs -> if
+      | BS.length bs > w && w > 5 -> BS.take (w - 4) bs <> "..."
+      | otherwise                 -> bs
+
+  -- Consecutively read from Fd in 512 chunks until we hit
+  -- newline or EOF.
+  readLine :: MonadIO m
+           => Fd          -- ^ input file descriptor
+           -> ByteString  -- ^ rest buffer (read across newline)
+           -> m (ByteString, ByteString, Bool) -- ^ (full line, rest, eof)
+  readLine fd = go
+   where
+    go inBs = do
+      -- if buffer is not empty, process it first
+      mbs <- if BS.length inBs == 0
+               -- otherwise attempt read
+               then liftIO
+                    $ handleIO (\e -> if isEOFError e then pure Nothing else ioError e)
+                    $ fmap Just
+                    $ SPIB.fdRead fd 512
+               else pure $ Just inBs
+      case mbs of
+        Nothing -> pure ("", "", True)
+        Just bs -> do
+          -- split on newline
+          let (line, rest) = BS.span (/= _lf) bs
+          if
+            | BS.length rest /= 0 -> pure (line, BS.tail rest, False)
+            -- if rest is empty, then there was no newline, process further
+            | otherwise           -> (\(l, r, b) -> (line <> l, r, b)) <$!> go mempty
+
+  readTilEOF :: MonadIO m => (ByteString -> m a) -> Fd -> m ()
+  readTilEOF ~action' fd' = go mempty
+   where
+    go bs' = do
+      (bs, rest, eof) <- readLine fd' bs'
+      if eof
+         then liftIO $ ioError (mkIOError eofErrorType "" Nothing Nothing)
+         else void (action' bs) >> go rest
+
+
+-- | Capture the stdout and stderr of the given action, which
+-- is run in a subprocess. Stdin is closed. You might want to
+-- 'race' this to make sure it terminates.
+captureOutStreams :: IO a
+                     -- ^ the action to execute in a subprocess
+                  -> IO CapturedProcess
+captureOutStreams action = do
+  actionWithPipes $ \(parentStdoutRead, childStdoutWrite) ->
+    actionWithPipes $ \(parentStderrRead, childStderrWrite) -> do
+      pid <- SPPB.forkProcess $ do
+        -- dup stdout
+        void $ dupTo childStdoutWrite stdOutput
+        closeFd childStdoutWrite
+        closeFd parentStdoutRead
+
+        -- dup stderr
+        void $ dupTo childStderrWrite stdError
+        closeFd childStderrWrite
+        closeFd parentStderrRead
+
+        -- execute the action
+        a <- action
+        void $ evaluate a
+
+      -- close everything we don't need
+      closeFd childStdoutWrite
+      closeFd childStderrWrite
+
+      -- start thread that writes the output
+      refOut <- newIORef BS.empty
+      refErr <- newIORef BS.empty
+      done   <- newEmptyMVar
+      _      <-
+        forkIO
+        $ EX.handle (\(_ :: IOException) -> pure ())
+        $ flip EX.finally (putMVar done ())
+        $ writeStds parentStdoutRead parentStderrRead refOut refErr
+
+      status <- SPPB.getProcessStatus True True pid
+      void $ race (takeMVar done) (threadDelay (1000000 * 3))
+
+      case status of
+        -- readFd will take care of closing the fd
+        Just (SPPB.Exited es) -> do
+          stdout' <- readIORef refOut
+          stderr' <- readIORef refErr
+          pure $ CapturedProcess { _exitCode = es
+                                 , _stdOut   = stdout'
+                                 , _stdErr   = stderr'
+                                 }
+
+        _ -> throwIO $ userError ("No such PID " ++ show pid)
+
+ where
+  writeStds pout perr rout rerr = do
+    doneOut <- newEmptyMVar
+    void
+      $ forkIO
+      $ hideError eofErrorType
+      $ flip EX.finally (putMVar doneOut ())
+      $ readTilEOF (\x -> modifyIORef' rout (<> x)) pout
+    doneErr <- newEmptyMVar
+    void
+      $ forkIO
+      $ hideError eofErrorType
+      $ flip EX.finally (putMVar doneErr ())
+      $ readTilEOF (\x -> modifyIORef' rerr (<> x)) perr
+    takeMVar doneOut
+    takeMVar doneErr
+
+  readTilEOF ~action' fd' = do
+    bs <- SPIB.fdRead fd' 512
+    void $ action' bs
+    readTilEOF action' fd'
+
+
+actionWithPipes :: ((Fd, Fd) -> IO b) -> IO b
+actionWithPipes a =
+  createPipe >>= \(p1, p2) -> flip finally (cleanup [p1, p2]) $ a (p1, p2)
+
+cleanup :: [Fd] -> IO ()
+cleanup fds = for_ fds $ \fd -> handleIO (\_ -> pure ()) $ closeFd fd
+
+
+
+-- | Create a new regular file in write-only mode. The file must not exist.
+createRegularFileFd :: FileMode -> Path b -> IO Fd
+createRegularFileFd fm dest =
+  FD.openFd (toFilePath dest) WriteOnly [oExcl] (Just fm)
+
+
+-- | Thin wrapper around `executeFile`.
+exec :: ByteString       -- ^ thing to execute
+     -> Bool             -- ^ whether to search PATH for the thing
+     -> [ByteString]     -- ^ args for the thing
+     -> Maybe (Path Abs) -- ^ optionally chdir into this
+     -> Maybe [(ByteString, ByteString)] -- ^ optional environment
+     -> IO (Either ProcessError ())
+exec exe spath args chdir env = do
+  pid <- SPPB.forkProcess $ do
+    maybe (pure ()) (changeWorkingDirectory . toFilePath) chdir
+    SPPB.executeFile exe spath args env
+
+  fmap (toProcessError exe args) $ SPPB.getProcessStatus True True pid
+
+
+toProcessError :: ByteString
+               -> [ByteString]
+               -> Maybe ProcessStatus
+               -> Either ProcessError ()
+toProcessError exe args mps = case mps of
+  Just (SPPB.Exited (ExitFailure xi)) -> Left $ NonZeroExit xi exe args
+  Just (SPPB.Exited ExitSuccess    ) -> Right ()
+  Just (Terminated _ _             ) -> Left $ PTerminated exe args
+  Just (Stopped _                  ) -> Left $ PStopped exe args
+  Nothing                            -> Left $ NoSuchPid exe args
+
+
+-- | Search for a file in the search paths.
+--
+-- Catches `PermissionDenied` and `NoSuchThing` and returns `Nothing`.
+searchPath :: [Path Abs] -> Path Rel -> IO (Maybe (Path Abs))
+searchPath paths needle = go paths
+ where
+  go [] = pure Nothing
+  go (x : xs) =
+    hideErrorDefM [InappropriateType, PermissionDenied, NoSuchThing] (go xs)
+      $ do
+          dirStream <- openDirStream (toFilePath x)
+          S.findM (\(_, p) -> isMatch x p) (dirContentsStream dirStream)
+            >>= \case
+                  Just _  -> pure $ Just (x </> needle)
+                  Nothing -> go xs
+  isMatch basedir p = do
+    if p == toFilePath needle
+      then isExecutable (basedir </> needle)
+      else pure False
+
+
+-- | Check wether a binary is shadowed by another one that comes before
+-- it in PATH. Returns the path to said binary, if any.
+isShadowed :: Path Abs -> IO (Maybe (Path Abs))
+isShadowed p = do
+  let dir = dirname p
+  fn <- basename p
+  spaths <- catMaybes . fmap parseAbs <$> liftIO getSearchPath
+  if dir `elem` spaths
+  then do
+    let shadowPaths = takeWhile (/= dir) spaths
+    searchPath shadowPaths fn
+  else pure Nothing
+
+
+-- | Check whether the binary is in PATH. This returns only `True`
+-- if the directory containing the binary is part of PATH.
+isInPath :: Path Abs -> IO Bool
+isInPath p = do
+  let dir = dirname p
+  fn <- basename p
+  spaths <- catMaybes . fmap parseAbs <$> liftIO getSearchPath
+  if dir `elem` spaths
+  then isJust <$> searchPath [dir] fn
+  else pure False
+
+
+findFiles :: Path Abs -> Regex -> IO [Path Rel]
+findFiles path regex = do
+  dirStream <- openDirStream (toFilePath path)
+  f         <-
+    (fmap . fmap) snd
+    . S.toList
+    . S.filter (\(_, p) -> match regex p)
+    $ dirContentsStream dirStream
+  pure $ parseRel =<< f
+
+
+findFiles' :: Path Abs -> MP.Parsec Void Text () -> IO [Path Rel]
+findFiles' path parser = do
+  dirStream <- openDirStream (toFilePath path)
+  f         <-
+    (fmap . fmap) snd
+    . S.toList
+    . S.filter (\(_, p) -> case E.decodeUtf8' p of
+                             Left _ -> False
+                             Right p' -> isJust $ MP.parseMaybe parser p')
+    $ dirContentsStream dirStream
+  pure $ parseRel =<< f
+
+
+isBrokenSymlink :: Path Abs -> IO Bool
+isBrokenSymlink p =
+  handleIO
+      (\e -> if ioeGetErrorType e == NoSuchThing then pure True else throwIO e)
+    $ do
+        _ <- canonicalizePath p
+        pure False
+
+
+chmod_755 :: (MonadLogger m, MonadIO m) => Path a -> m ()
+chmod_755 (toFilePath -> fp) = do
+  let exe_mode =
+          nullFileMode
+            `unionFileModes` ownerExecuteMode
+            `unionFileModes` ownerReadMode
+            `unionFileModes` ownerWriteMode
+            `unionFileModes` groupExecuteMode
+            `unionFileModes` groupReadMode
+            `unionFileModes` otherExecuteMode
+            `unionFileModes` otherReadMode
+  $(logDebug) [i|chmod 755 #{fp}|]
+  liftIO $ setFileMode fp exe_mode
--- a/lib/GHCup/Utils/File/Common.hs
+++ b/lib/GHCup/Utils/File/Common.hs
@@ -1,106 +0,0 @@
-{-# LANGUAGE QuasiQuotes       #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE FlexibleContexts  #-}
-{-# LANGUAGE TemplateHaskell   #-}
-{-# LANGUAGE ViewPatterns      #-}
-
-module GHCup.Utils.File.Common where
-
-import           GHCup.Utils.Prelude
-
-import           Control.Monad.Extra
-import           Control.Monad.Reader
-import           Data.Maybe
-import           Data.String.Interpolate
-import           GHC.IO.Exception
-import           Optics                  hiding ((<|), (|>))
-import           System.Directory
-import           System.FilePath
-import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
-import           Text.Regex.Posix
-
-import qualified Data.ByteString.Lazy          as BL
-
-
-
-data ProcessError = NonZeroExit Int FilePath [String]
-                  | PTerminated FilePath [String]
-                  | PStopped FilePath [String]
-                  | NoSuchPid FilePath [String]
-                  deriving Show
-
-instance Pretty ProcessError where
-  pPrint (NonZeroExit e exe args) =
-    text [i|Process "#{exe}" with arguments #{args} failed with exit code #{e}.|]
-  pPrint (PTerminated exe args) =
-    text [i|Process "#{exe}" with arguments #{args} terminated.|]
-  pPrint (PStopped exe args) =
-    text [i|Process "#{exe}" with arguments #{args} stopped.|]
-  pPrint (NoSuchPid exe args) =
-    text [i|Could not find PID for process running "#{exe}" with arguments #{args}.|]
-
-data CapturedProcess = CapturedProcess
-  { _exitCode :: ExitCode
-  , _stdOut   :: BL.ByteString
-  , _stdErr   :: BL.ByteString
-  }
-  deriving (Eq, Show)
-
-makeLenses ''CapturedProcess
-
-
-
-- | Search for a file in the search paths.
--
-- Catches `PermissionDenied` and `NoSuchThing` and returns `Nothing`.
-searchPath :: [FilePath] -> FilePath -> IO (Maybe FilePath)
-searchPath paths needle = go paths
- where
-  go [] = pure Nothing
-  go (x : xs) =
-    hideErrorDefM [InappropriateType, PermissionDenied, NoSuchThing] (go xs)
-      $ do
-          contents <- listDirectory x
-          findM (isMatch x) contents >>= \case
-            Just _ -> pure $ Just (x </> needle)
-            Nothing -> go xs
-  isMatch basedir p = do
-    if p == needle
-      then isExecutable (basedir </> needle)
-      else pure False
-
-  isExecutable :: FilePath -> IO Bool
-  isExecutable file = executable <$> getPermissions file
-
-
-- | Check wether a binary is shadowed by another one that comes before
-- it in PATH. Returns the path to said binary, if any.
-isShadowed :: FilePath -> IO (Maybe FilePath)
-isShadowed p = do
-  let dir = takeDirectory p
-  let fn = takeFileName p
-  spaths <- liftIO getSearchPath
-  if dir `elem` spaths
-  then do
-    let shadowPaths = takeWhile (/= dir) spaths
-    searchPath shadowPaths fn
-  else pure Nothing
-
-
-- | Check whether the binary is in PATH. This returns only `True`
-- if the directory containing the binary is part of PATH.
-isInPath :: FilePath -> IO Bool
-isInPath p = do
-  let dir = takeDirectory p
-  let fn = takeFileName p
-  spaths <- liftIO getSearchPath
-  if dir `elem` spaths
-  then isJust <$> searchPath [dir] fn
-  else pure False
-
-
-findFiles :: FilePath -> Regex -> IO [FilePath]
-findFiles path regex = do
-  contents <- listDirectory path
-  pure $ filter (match regex) contents
-
--- a/lib/GHCup/Utils/File/Posix.hs
+++ b/lib/GHCup/Utils/File/Posix.hs
@@ -1,392 +0,0 @@
-{-# LANGUAGE QuasiQuotes       #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE FlexibleContexts  #-}
-{-# LANGUAGE TemplateHaskell   #-}
-{-# LANGUAGE ViewPatterns      #-}
-
-{-|
-Module      : GHCup.Utils.File.Posix
-Description : File and unix APIs
-Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
-Maintainer  : hasufell@hasufell.de
-Stability   : experimental
-Portability : POSIX
-
-This module handles file and executable handling.
-Some of these functions use sophisticated logging.
-}
-module GHCup.Utils.File.Posix where
-
-import           GHCup.Utils.File.Common
-import           GHCup.Utils.Prelude
-import           GHCup.Types
-import           GHCup.Types.Optics
-
-import           Control.Concurrent
-import           Control.Concurrent.Async
-import           Control.Exception              ( evaluate )
-import           Control.Exception.Safe
-import           Control.Monad
-import           Control.Monad.Logger
-import           Control.Monad.Reader
-import           Control.Monad.Trans.State.Strict
-import           Data.ByteString                ( ByteString )
-import           Data.Foldable
-import           Data.IORef
-import           Data.Sequence                  ( Seq, (|>) )
-import           Data.String.Interpolate
-import           Data.List
-import           Data.Word8
-import           GHC.IO.Exception
-import           System.Console.Pretty   hiding ( Pretty )
-import           System.Console.Regions
-import           System.IO.Error
-import           System.FilePath
-import           System.Directory
-import           System.Posix.Directory
-import           System.Posix.Files
-import           System.Posix.IO
-import           System.Posix.Process           ( ProcessStatus(..) )
-import           System.Posix.Types
-
-
-import qualified Control.Exception             as EX
-import qualified Data.Sequence                 as Sq
-import qualified Data.Text                     as T
-import qualified Data.Text.Encoding            as E
-import qualified System.Posix.Process          as SPP
-import qualified Data.ByteString               as BS
-import qualified Data.ByteString.Lazy          as BL
-import qualified "unix-bytestring" System.Posix.IO.ByteString
-                                               as SPIB
-
-
-
-- | Execute the given command and collect the stdout, stderr and the exit code.
-- The command is run in a subprocess.
-executeOut :: MonadIO m
-           => FilePath          -- ^ command as filename, e.g. 'ls'
-           -> [String]          -- ^ arguments to the command
-           -> Maybe FilePath    -- ^ chdir to this path
-           -> m CapturedProcess
-executeOut path args chdir = liftIO $ captureOutStreams $ do
-  maybe (pure ()) changeWorkingDirectory chdir
-  SPP.executeFile path True args Nothing
-
-
-execLogged :: ( MonadReader env m
-              , HasSettings env
-              , HasDirs env
-              , MonadIO m
-              , MonadThrow m)
-           => FilePath         -- ^ thing to execute
-           -> [String]         -- ^ args for the thing
-           -> Maybe FilePath   -- ^ optionally chdir into this
-           -> FilePath         -- ^ log filename (opened in append mode)
-           -> Maybe [(String, String)] -- ^ optional environment
-           -> m (Either ProcessError ())
-execLogged exe args chdir lfile env = do
-  Settings {..} <- getSettings
-  Dirs {..} <- getDirs
-  let logfile = logsDir </> lfile <> ".log"
-  liftIO $ bracket (openFd logfile WriteOnly (Just newFilePerms) defaultFileFlags{ append = True })
-                   closeFd
-                   (action verbose)
- where
-  action verbose fd = do
-    actionWithPipes $ \(stdoutRead, stdoutWrite) -> do
-      -- start the thread that logs to stdout
-      pState <- newEmptyMVar
-      done   <- newEmptyMVar
-      void
-        $ forkIO
-        $ EX.handle (\(_ :: IOException) -> pure ())
-        $ EX.finally
-            (if verbose
-              then tee fd stdoutRead
-              else printToRegion fd stdoutRead 6 pState
-            )
-            (putMVar done ())
-
-      -- fork the subprocess
-      pid <- SPP.forkProcess $ do
-        void $ dupTo stdoutWrite stdOutput
-        void $ dupTo stdoutWrite stdError
-        closeFd stdoutRead
-        closeFd stdoutWrite
-
-        -- execute the action
-        maybe (pure ()) changeWorkingDirectory chdir
-        void $ SPP.executeFile exe (not ("./" `isPrefixOf` exe)) args env
-
-      closeFd stdoutWrite
-
-      -- wait for the subprocess to finish
-      e <- toProcessError exe args <$!> SPP.getProcessStatus True True pid
-      putMVar pState (either (const False) (const True) e)
-
-      void $ race (takeMVar done) (threadDelay (1000000 * 3))
-      closeFd stdoutRead
-
-      pure e
-
-  tee :: Fd -> Fd -> IO ()
-  tee fileFd fdIn = readTilEOF lineAction fdIn
-
-   where
-    lineAction :: ByteString -> IO ()
-    lineAction bs' = do
-      void $ SPIB.fdWrite fileFd (bs' <> "\n")
-      void $ SPIB.fdWrite stdOutput (bs' <> "\n")
-
-  -- Reads fdIn and logs the output in a continous scrolling area
-  -- of 'size' terminal lines. Also writes to a log file.
-  printToRegion :: Fd -> Fd -> Int -> MVar Bool -> IO ()
-  printToRegion fileFd fdIn size pState = do
-    void $ displayConsoleRegions $ do
-      rs <-
-        liftIO
-        . fmap Sq.fromList
-        . sequence
-        . replicate size
-        . openConsoleRegion
-        $ Linear
-      flip runStateT mempty
-        $ handle
-            (\(ex :: SomeException) -> do
-              ps <- liftIO $ takeMVar pState
-              when ps (forM_ rs (liftIO . closeConsoleRegion))
-              throw ex
-            )
-        $ readTilEOF (lineAction rs) fdIn
-
-   where
-    -- action to perform line by line
-    -- TODO: do this with vty for efficiency
-    lineAction :: (MonadMask m, MonadIO m)
-               => Seq ConsoleRegion
-               -> ByteString
-               -> StateT (Seq ByteString) m ()
-    lineAction rs = \bs' -> do
-      void $ liftIO $ SPIB.fdWrite fileFd (bs' <> "\n")
-      modify (swapRegs bs')
-      regs <- get
-      liftIO $ forM_ (Sq.zip regs rs) $ \(bs, r) -> setConsoleRegion r $ do
-        w <- consoleWidth
-        return
-          . T.pack
-          . color Blue
-          . T.unpack
-          . decUTF8Safe
-          . trim w
-          . (\b -> "[ " <> E.encodeUtf8 (T.pack lfile) <> " ] " <> b)
-          $ bs
-
-    swapRegs :: a -> Seq a -> Seq a
-    swapRegs bs = \regs -> if
-      | Sq.length regs < size -> regs |> bs
-      | otherwise             -> Sq.drop 1 regs |> bs
-
-    -- trim output line to terminal width
-    trim :: Int -> ByteString -> ByteString
-    trim w = \bs -> if
-      | BS.length bs > w && w > 5 -> BS.take (w - 4) bs <> "..."
-      | otherwise                 -> bs
-
-  -- Consecutively read from Fd in 512 chunks until we hit
-  -- newline or EOF.
-  readLine :: MonadIO m
-           => Fd          -- ^ input file descriptor
-           -> ByteString  -- ^ rest buffer (read across newline)
-           -> m (ByteString, ByteString, Bool) -- ^ (full line, rest, eof)
-  readLine fd = go
-   where
-    go inBs = do
-      -- if buffer is not empty, process it first
-      mbs <- if BS.length inBs == 0
-               -- otherwise attempt read
-               then liftIO
-                    $ handleIO (\e -> if isEOFError e then pure Nothing else ioError e)
-                    $ fmap Just
-                    $ SPIB.fdRead fd 512
-               else pure $ Just inBs
-      case mbs of
-        Nothing -> pure ("", "", True)
-        Just bs -> do
-          -- split on newline
-          let (line, rest) = BS.span (/= _lf) bs
-          if
-            | BS.length rest /= 0 -> pure (line, BS.tail rest, False)
-            -- if rest is empty, then there was no newline, process further
-            | otherwise           -> (\(l, r, b) -> (line <> l, r, b)) <$!> go mempty
-
-  readTilEOF :: MonadIO m => (ByteString -> m a) -> Fd -> m ()
-  readTilEOF ~action' fd' = go mempty
-   where
-    go bs' = do
-      (bs, rest, eof) <- readLine fd' bs'
-      if eof
-         then liftIO $ ioError (mkIOError eofErrorType "" Nothing Nothing)
-         else void (action' bs) >> go rest
-
-
-- | Capture the stdout and stderr of the given action, which
-- is run in a subprocess. Stdin is closed. You might want to
-- 'race' this to make sure it terminates.
-captureOutStreams :: IO a
-                     -- ^ the action to execute in a subprocess
-                  -> IO CapturedProcess
-captureOutStreams action = do
-  actionWithPipes $ \(parentStdoutRead, childStdoutWrite) ->
-    actionWithPipes $ \(parentStderrRead, childStderrWrite) -> do
-      pid <- SPP.forkProcess $ do
-        -- dup stdout
-        void $ dupTo childStdoutWrite stdOutput
-        closeFd childStdoutWrite
-        closeFd parentStdoutRead
-
-        -- dup stderr
-        void $ dupTo childStderrWrite stdError
-        closeFd childStderrWrite
-        closeFd parentStderrRead
-
-        -- execute the action
-        a <- action
-        void $ evaluate a
-
-      -- close everything we don't need
-      closeFd childStdoutWrite
-      closeFd childStderrWrite
-
-      -- start thread that writes the output
-      refOut <- newIORef BL.empty
-      refErr <- newIORef BL.empty
-      done   <- newEmptyMVar
-      _      <-
-        forkIO
-        $ EX.handle (\(_ :: IOException) -> pure ())
-        $ flip EX.finally (putMVar done ())
-        $ writeStds parentStdoutRead parentStderrRead refOut refErr
-
-      status <- SPP.getProcessStatus True True pid
-      void $ race (takeMVar done) (threadDelay (1000000 * 3))
-
-      case status of
-        -- readFd will take care of closing the fd
-        Just (SPP.Exited es) -> do
-          stdout' <- readIORef refOut
-          stderr' <- readIORef refErr
-          pure $ CapturedProcess { _exitCode = es
-                                 , _stdOut   = stdout'
-                                 , _stdErr   = stderr'
-                                 }
-
-        _ -> throwIO $ userError ("No such PID " ++ show pid)
-
- where
-  writeStds :: Fd -> Fd -> IORef BL.ByteString -> IORef BL.ByteString -> IO ()
-  writeStds pout perr rout rerr = do
-    doneOut <- newEmptyMVar
-    void
-      $ forkIO
-      $ hideError eofErrorType
-      $ flip EX.finally (putMVar doneOut ())
-      $ readTilEOF (\x -> modifyIORef' rout (<> BL.fromStrict x)) pout
-    doneErr <- newEmptyMVar
-    void
-      $ forkIO
-      $ hideError eofErrorType
-      $ flip EX.finally (putMVar doneErr ())
-      $ readTilEOF (\x -> modifyIORef' rerr (<> BL.fromStrict x)) perr
-    takeMVar doneOut
-    takeMVar doneErr
-
-  readTilEOF ~action' fd' = do
-    bs <- SPIB.fdRead fd' 512
-    void $ action' bs
-    readTilEOF action' fd'
-
-
-actionWithPipes :: ((Fd, Fd) -> IO b) -> IO b
-actionWithPipes a =
-  createPipe >>= \(p1, p2) -> flip finally (cleanup [p1, p2]) $ a (p1, p2)
-
-cleanup :: [Fd] -> IO ()
-cleanup fds = for_ fds $ \fd -> handleIO (\_ -> pure ()) $ closeFd fd
-
-
-
-- | Create a new regular file in write-only mode. The file must not exist.
-createRegularFileFd :: FileMode -> FilePath -> IO Fd
-createRegularFileFd fm dest =
-  openFd dest WriteOnly (Just fm) defaultFileFlags{ exclusive = True }
-
-
-- | Thin wrapper around `executeFile`.
-exec :: MonadIO m
-     => String           -- ^ thing to execute
-     -> [String]         -- ^ args for the thing
-     -> Maybe FilePath   -- ^ optionally chdir into this
-     -> Maybe [(String, String)] -- ^ optional environment
-     -> m (Either ProcessError ())
-exec exe args chdir env = liftIO $ do
-  pid <- SPP.forkProcess $ do
-    maybe (pure ()) changeWorkingDirectory chdir
-    SPP.executeFile exe (not ("./" `isPrefixOf` exe)) args env
-
-  fmap (toProcessError exe args) $ SPP.getProcessStatus True True pid
-
-
-toProcessError :: FilePath
-               -> [String]
-               -> Maybe ProcessStatus
-               -> Either ProcessError ()
-toProcessError exe args mps = case mps of
-  Just (SPP.Exited (ExitFailure xi)) -> Left $ NonZeroExit xi exe args
-  Just (SPP.Exited ExitSuccess    ) -> Right ()
-  Just (Terminated _ _             ) -> Left $ PTerminated exe args
-  Just (Stopped _                  ) -> Left $ PStopped exe args
-  Nothing                            -> Left $ NoSuchPid exe args
-
-
-
-chmod_755 :: (MonadLogger m, MonadIO m) => FilePath -> m ()
-chmod_755 fp = do
-  let exe_mode =
-          nullFileMode
-            `unionFileModes` ownerExecuteMode
-            `unionFileModes` ownerReadMode
-            `unionFileModes` ownerWriteMode
-            `unionFileModes` groupExecuteMode
-            `unionFileModes` groupReadMode
-            `unionFileModes` otherExecuteMode
-            `unionFileModes` otherReadMode
-  $(logDebug) [i|chmod 755 #{fp}|]
-  liftIO $ setFileMode fp exe_mode
-
-
-- |Default permissions for a new file.
-newFilePerms :: FileMode
-newFilePerms =
-  ownerWriteMode
-    `unionFileModes` ownerReadMode
-    `unionFileModes` groupWriteMode
-    `unionFileModes` groupReadMode
-    `unionFileModes` otherWriteMode
-    `unionFileModes` otherReadMode
-
-
-- | Checks whether the binary is a broken link.
-isBrokenSymlink :: FilePath -> IO Bool
-isBrokenSymlink fp = do
-  try (pathIsSymbolicLink fp) >>= \case
-    Right True -> do
-      let symDir = takeDirectory fp
-      tfp <- getSymbolicLinkTarget fp
-      not <$> doesPathExist
-        -- this drops 'symDir' if 'tfp' is absolute
-        (symDir </> tfp)
-    Right b -> pure b
-    Left e | isDoesNotExistError e -> pure False
-           | otherwise -> throwIO e
--- a/lib/GHCup/Utils/File/Windows.hs
+++ b/lib/GHCup/Utils/File/Windows.hs
@@ -1,266 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE FlexibleContexts  #-}
-
-{-|
-Module      : GHCup.Utils.File.Windows
-Description : File and windows APIs
-Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
-Maintainer  : hasufell@hasufell.de
-Stability   : experimental
-Portability : Windows
-
-This module handles file and executable handling.
-Some of these functions use sophisticated logging.
-}
-module GHCup.Utils.File.Windows where
-
-import {-# SOURCE #-} GHCup.Utils ( getLinkTarget, pathIsLink )
-import           GHCup.Utils.Dirs
-import           GHCup.Utils.File.Common
-import           GHCup.Types
-import           GHCup.Types.Optics
-
-import           Control.Concurrent
-import           Control.DeepSeq
-import           Control.Exception.Safe
-import           Control.Monad
-import           Control.Monad.Reader
-import           Data.List
-import           Foreign.C.Error
-import           GHC.IO.Exception
-import           GHC.IO.Handle
-import           System.Directory
-import           System.Environment
-import           System.FilePath
-import           System.IO
-import           System.Process
- 
-import qualified Control.Exception             as EX
-import qualified Data.ByteString               as BS
-import qualified Data.ByteString.Lazy          as BL
-import qualified Data.Map.Strict               as Map
-
-
-
-toProcessError :: FilePath
-               -> [FilePath]
-               -> ExitCode
-               -> Either ProcessError ()
-toProcessError exe args exitcode = case exitcode of
-  (ExitFailure xi) -> Left $ NonZeroExit xi exe args
-  ExitSuccess -> Right ()
-
-
-- | @readCreateProcessWithExitCode@ works exactly like 'readProcessWithExitCode' except that it
-- lets you pass 'CreateProcess' giving better flexibility.
--
-- Note that @Handle@s provided for @std_in@, @std_out@, or @std_err@ via the CreateProcess
-- record will be ignored.
--
-- @since 1.2.3.0
-readCreateProcessWithExitCodeBS
-    :: CreateProcess
-    -> BL.ByteString
-    -> IO (ExitCode, BL.ByteString, BL.ByteString) -- ^ exitcode, stdout, stderr
-readCreateProcessWithExitCodeBS cp input = do
-    let cp_opts = cp {
-                    std_in  = CreatePipe,
-                    std_out = CreatePipe,
-                    std_err = CreatePipe
-                  }
-    withCreateProcess_ "readCreateProcessWithExitCodeBS" cp_opts $
-      \mb_inh mb_outh mb_errh ph ->
-        case (mb_inh, mb_outh, mb_errh) of
-          (Just inh, Just outh, Just errh) -> do
-
-            out <- BS.hGetContents outh
-            err <- BS.hGetContents errh
-
-            -- fork off threads to start consuming stdout & stderr
-            withForkWait  (EX.evaluate $ rnf out) $ \waitOut ->
-             withForkWait (EX.evaluate $ rnf err) $ \waitErr -> do
-
-              -- now write any input
-              unless (BL.null input) $
-                ignoreSigPipe $ BL.hPut inh input
-              -- hClose performs implicit hFlush, and thus may trigger a SIGPIPE
-              ignoreSigPipe $ hClose inh
-
-              -- wait on the output
-              waitOut
-              waitErr
-
-              hClose outh
-              hClose errh
-
-            -- wait on the process
-            ex <- waitForProcess ph
-            return (ex, BL.fromStrict out, BL.fromStrict err)
-
-          (Nothing,_,_) -> error "readCreateProcessWithExitCodeBS: Failed to get a stdin handle."
-          (_,Nothing,_) -> error "readCreateProcessWithExitCodeBS: Failed to get a stdout handle."
-          (_,_,Nothing) -> error "readCreateProcessWithExitCodeBS: Failed to get a stderr handle."
- where
-  ignoreSigPipe :: IO () -> IO ()
-  ignoreSigPipe = EX.handle $ \e -> case e of
-                                     IOError { ioe_type  = ResourceVanished
-                                             , ioe_errno = Just ioe }
-                                       | Errno ioe == ePIPE -> return ()
-                                     _ -> throwIO e
-  -- wrapper so we can get exceptions with the appropriate function name.
-  withCreateProcess_
-    :: String
-    -> CreateProcess
-    -> (Maybe Handle -> Maybe Handle -> Maybe Handle -> ProcessHandle -> IO a)
-    -> IO a
-  withCreateProcess_ fun c action =
-      EX.bracketOnError (createProcess_ fun c) cleanupProcess
-                       (\(m_in, m_out, m_err, ph) -> action m_in m_out m_err ph)
-
-- | Fork a thread while doing something else, but kill it if there's an
-- exception.
--
-- This is important in the cases above because we want to kill the thread
-- that is holding the Handle lock, because when we clean up the process we
-- try to close that handle, which could otherwise deadlock.
--
-withForkWait :: IO () -> (IO () ->  IO a) -> IO a
-withForkWait async' body = do
-  waitVar <- newEmptyMVar :: IO (MVar (Either SomeException ()))
-  mask $ \restore -> do
-    tid <- forkIO $ try (restore async') >>= putMVar waitVar
-    let wait' = takeMVar waitVar >>= either throwIO return
-    restore (body wait') `EX.onException` killThread tid
-
-
-- | Execute the given command and collect the stdout, stderr and the exit code.
-- The command is run in a subprocess.
-executeOut :: MonadIO m
-           => FilePath          -- ^ command as filename, e.g. 'ls'
-           -> [String]          -- ^ arguments to the command
-           -> Maybe FilePath    -- ^ chdir to this path
-           -> m CapturedProcess
-executeOut path args chdir = do
-  cp <- createProcessWithMingwPath ((proc path args){ cwd = chdir })
-  (exit, out, err) <- liftIO $ readCreateProcessWithExitCodeBS cp ""
-  pure $ CapturedProcess exit out err
-
-
-execLogged :: ( MonadReader env m
-              , HasDirs env
-              , HasSettings env
-              , MonadIO m
-              , MonadThrow m)
-           => FilePath         -- ^ thing to execute
-           -> [String]         -- ^ args for the thing
-           -> Maybe FilePath   -- ^ optionally chdir into this
-           -> FilePath         -- ^ log filename (opened in append mode)
-           -> Maybe [(String, String)] -- ^ optional environment
-           -> m (Either ProcessError ())
-execLogged exe args chdir lfile env = do
-  Dirs {..} <- getDirs
-  let stdoutLogfile = logsDir </> lfile <> ".stdout.log"
-      stderrLogfile = logsDir </> lfile <> ".stderr.log"
-  cp <- createProcessWithMingwPath ((proc exe args)
-    { cwd = chdir
-    , env = env
-    , std_in = CreatePipe
-    , std_out = CreatePipe
-    , std_err = CreatePipe
-    })
-  fmap (toProcessError exe args)
-    $ liftIO
-    $ withCreateProcess cp
-    $ \_ mout merr ph ->
-        case (mout, merr) of
-          (Just cStdout, Just cStderr) -> do
-            withForkWait (tee stdoutLogfile cStdout) $ \waitOut ->
-              withForkWait (tee stderrLogfile cStderr) $ \waitErr -> do
-                waitOut
-                waitErr
-            waitForProcess ph
-          _ -> fail "Could not acquire out/err handle"
-
- where
-  tee :: FilePath -> Handle -> IO ()
-  tee logFile handle' = go
-    where
-      go = do
-        some <- BS.hGetSome handle' 512
-        if BS.null some
-          then pure ()
-          else do
-            void $ BS.appendFile logFile some
-            void $ BS.hPut stdout some
-            go
-        
-
-- | Thin wrapper around `executeFile`.
-exec :: MonadIO m
-     => FilePath       -- ^ thing to execute
-     -> [FilePath]     -- ^ args for the thing
-     -> Maybe FilePath   -- ^ optionally chdir into this
-     -> Maybe [(String, String)] -- ^ optional environment
-     -> m (Either ProcessError ())
-exec exe args chdir env = do
-  cp <- createProcessWithMingwPath ((proc exe args) { cwd = chdir, env = env })
-  exit_code <- liftIO $ withCreateProcess cp $ \_ _ _ p -> waitForProcess p
-  pure $ toProcessError exe args exit_code
-
-
-- | Thin wrapper around `executeFile`.
-execShell :: MonadIO m
-          => FilePath       -- ^ thing to execute
-          -> [FilePath]     -- ^ args for the thing
-          -> Maybe FilePath   -- ^ optionally chdir into this
-          -> Maybe [(String, String)] -- ^ optional environment
-          -> m (Either ProcessError ())
-execShell exe args chdir env = do
-  let cmd = exe <> " " <> concatMap (' ':) args
-  cp <- createProcessWithMingwPath ((shell cmd) { cwd = chdir, env = env })
-  exit_code <- liftIO $ withCreateProcess cp $ \_ _ _ p -> waitForProcess p
-  pure $ toProcessError cmd [] exit_code
-
-
-chmod_755 :: MonadIO m => FilePath -> m ()
-chmod_755 fp =
-  let perm = setOwnerWritable True emptyPermissions
-  in liftIO $ setPermissions fp perm
-
-
-createProcessWithMingwPath :: MonadIO m
-                          => CreateProcess
-                          -> m CreateProcess
-createProcessWithMingwPath cp = do
-  msys2Dir <- liftIO ghcupMsys2Dir
-  cEnv <- Map.fromList <$> maybe (liftIO getEnvironment) pure (env cp)
-  let mingWPaths = [msys2Dir </> "usr" </> "bin"
-                   ,msys2Dir </> "mingw64" </> "bin"]
-      paths = ["PATH", "Path"]
-      curPaths = (\x -> maybe [] splitSearchPath (Map.lookup x cEnv)) =<< paths
-      newPath = intercalate [searchPathSeparator] (mingWPaths ++ curPaths)
-      envWithoutPath = foldr (\x y -> Map.delete x y) cEnv paths
-      envWithNewPath = Map.insert "Path" newPath envWithoutPath
-  liftIO $ setEnv "Path" newPath
-  pure $ cp { env = Just $ Map.toList envWithNewPath }
-
-ghcupMsys2Dir :: IO FilePath
-ghcupMsys2Dir =
-  lookupEnv "GHCUP_MSYS2" >>= \case
-    Just fp -> pure fp
-    Nothing -> do
-      baseDir <- liftIO ghcupBaseDir
-      pure (baseDir </> "msys64")
-
-- | Checks whether the binary is a broken link.
-isBrokenSymlink :: FilePath -> IO Bool
-isBrokenSymlink fp = do
-  b <- pathIsLink fp
-  if b
-  then do
-    tfp <- getLinkTarget fp
-    not <$> doesPathExist
-      -- this drops 'symDir' if 'tfp' is absolute
-      (takeDirectory fp </> tfp)
-  else pure False
--- a/lib/GHCup/Utils/Logger.hs
+++ b/lib/GHCup/Utils/Logger.hs
@@ -8,31 +8,29 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX

 Here we define our main logger.
 -}
 module GHCup.Utils.Logger where

 import           GHCup.Types
-import           GHCup.Types.Optics
+import           GHCup.Utils
 import           GHCup.Utils.File
 import           GHCup.Utils.String.QQ

-import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Class
-import           Control.Monad.Logger
 import           Control.Monad.Reader
-import           Data.Char               ( ord )
+import           Control.Monad.Logger
+import           HPath
+import           HPath.IO
 import           Prelude                 hiding ( appendFile )
 import           System.Console.Pretty
-import           System.FilePath
 import           System.IO.Error
 import           Text.Regex.Posix

 import qualified Data.ByteString               as B
-import GHCup.Utils.Prelude


 data LoggerConfig = LoggerConfig
@@ -48,33 +46,20 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
  mylogger :: Loc -> LogSource -> LogLevel -> LogStr -> IO ()
  mylogger _ _ level str' = do
    -- color output
-    let style' = case level of
-          LevelDebug   -> style Bold . color Blue
-          LevelInfo    -> style Bold . color Green
-          LevelWarn    -> style Bold . color Yellow
-          LevelError   -> style Bold . color Red
-          LevelOther _ -> id
    let l = case level of
-          LevelDebug   -> toLogStr (style' "[ Debug ]")
-          LevelInfo    -> toLogStr (style' "[ Info  ]")
-          LevelWarn    -> toLogStr (style' "[ Warn  ]")
-          LevelError   -> toLogStr (style' "[ Error ]")
+          LevelDebug   -> toLogStr (style Bold $ color Blue "[ Debug ]")
+          LevelInfo    -> toLogStr (style Bold $ color Green "[ Info  ]")
+          LevelWarn    -> toLogStr (style Bold $ color Yellow "[ Warn  ]")
+          LevelError   -> toLogStr (style Bold $ color Red "[ Error ]")
          LevelOther t -> toLogStr "[ " <> toLogStr t <> toLogStr " ]"
-    let strs = fmap toLogStr . B.split (fromIntegral $ ord '\n') . fromLogStr $ str'
-    let out = case strs of
-                [] -> B.empty
-                (x:xs) -> fromLogStr
-                  . foldr (\a b -> a <> toLogStr "\n" <> b) mempty
-                  . ((l <> toLogStr " " <> x) :)
-                  . fmap (\line' -> toLogStr (style' "[ ...   ] ") <> line' )
-                  $ xs
+    let out = fromLogStr (l <> toLogStr " " <> str' <> toLogStr "\n")

    when (lcPrintDebug || (not lcPrintDebug && (level /= LevelDebug)))
      $ colorOutter out

    -- raw output
    let lr = case level of
-          LevelDebug   -> toLogStr "Debug:"
+          LevelDebug   -> toLogStr "Debug: "
          LevelInfo    -> toLogStr "Info:"
          LevelWarn    -> toLogStr "Warn:"
          LevelError   -> toLogStr "Error:"
@@ -83,21 +68,20 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
    rawOutter outr


-initGHCupFileLogging :: ( MonadReader env m
-                        , HasDirs env
-                        , MonadIO m
-                        , MonadMask m
-                        ) => m FilePath
+initGHCupFileLogging :: (MonadIO m, MonadReader AppState m) => m (Path Abs)
 initGHCupFileLogging = do
-  Dirs { logsDir } <- getDirs
-  let logfile = logsDir </> "ghcup.log"
-  logFiles <- liftIO $ findFiles
-    logsDir
-    (makeRegexOpts compExtended
-                   execBlank
-                   ([s|^.*\.log$|] :: B.ByteString)
-    )
-  forM_ logFiles $ hideError doesNotExistErrorType . recycleFile . (logsDir </>)
+  AppState {dirs = Dirs {..}} <- ask
+  let logfile = logsDir </> [rel|ghcup.log|]
+  liftIO $ do
+    createDirRecursive' logsDir
+    logFiles <- findFiles
+      logsDir
+      (makeRegexOpts compExtended
+                     execBlank
+                     ([s|^.*\.log$|] :: B.ByteString)
+      )
+    forM_ logFiles $ hideError doesNotExistErrorType . deleteFile . (logsDir </>)
+
+    createRegularFile newFilePerms logfile
+    pure logfile

-  liftIO $ writeFile logfile ""
-  pure logfile
--- a/lib/GHCup/Utils/MegaParsec.hs
+++ b/lib/GHCup/Utils/MegaParsec.hs
@@ -8,7 +8,7 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX
 -}
 module GHCup.Utils.MegaParsec where

@@ -23,7 +23,6 @@ import           Data.Maybe
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           Data.Void
-import           System.FilePath

 import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T
@@ -118,7 +117,3 @@ verP suffix = do
      v <- versioning'
      MP.setInput rest
      pure v
-
-
-pathSep :: MP.Parsec Void Text Char
-pathSep = MP.oneOf pathSeparators
--- a/lib/GHCup/Utils/Prelude.hs
+++ b/lib/GHCup/Utils/Prelude.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE CPP                 #-}
 {-# LANGUAGE DataKinds           #-}
 {-# LANGUAGE FlexibleContexts    #-}
 {-# LANGUAGE FlexibleInstances   #-}
@@ -13,26 +12,19 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX

 GHCup specific prelude. Lots of Excepts functionality.
 -}
 module GHCup.Utils.Prelude where

-#if defined(IS_WINDOWS)
-import           GHCup.Types
-#endif
-import           GHCup.Types.Optics
-
 import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Class
-import           Control.Monad.Reader
+import           Control.Monad.Trans.Class      ( lift )
 import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
-import           Data.List                      ( nub, intercalate )
-import           Data.Foldable
 import           Data.String
 import           Data.Text                      ( Text )
 import           Data.Versions
@@ -40,22 +32,11 @@ import           Data.Word8
 import           Haskus.Utils.Types.List
 import           Haskus.Utils.Variant.Excepts
 import           System.IO.Error
-#if defined(IS_WINDOWS)
-import           System.IO.Temp
-#endif
-import           System.IO.Unsafe
-import           System.Directory
-import           System.FilePath
-
-#if defined(IS_WINDOWS)
-import           Control.Retry
-import           GHC.IO.Exception
-#endif
+import           System.Posix.Env.ByteString    ( getEnvironment )

 import qualified Data.ByteString               as B
 import qualified Data.ByteString.Lazy          as L
 import qualified Data.Strict.Maybe             as S
-import qualified Data.List.Split               as Split
 import qualified Data.Text                     as T
 import qualified Data.Text.Encoding            as E
 import qualified Data.Text.Encoding.Error      as E
@@ -63,9 +44,6 @@ import qualified Data.Text.Lazy                as TL
 import qualified Data.Text.Lazy.Builder        as B
 import qualified Data.Text.Lazy.Builder.Int    as B
 import qualified Data.Text.Lazy.Encoding       as TLE
-#if defined(IS_WINDOWS)
-import qualified System.Win32.File             as Win32
-#endif



@@ -202,14 +180,14 @@ hideError :: (MonadIO m, MonadCatch m) => IOErrorType -> m () -> m ()
 hideError err = handleIO (\e -> if err == ioeGetErrorType e then pure () else liftIO . ioError $ e)


-hideErrorDef :: (MonadIO m, MonadCatch m) => [IOErrorType] -> a -> m a -> m a
+hideErrorDef :: [IOErrorType] -> a -> IO a -> IO a
 hideErrorDef errs def =
-  handleIO (\e -> if ioeGetErrorType e `elem` errs then pure def else liftIO $ ioError e)
+  handleIO (\e -> if ioeGetErrorType e `elem` errs then pure def else ioError e)


-hideErrorDefM :: (MonadIO m, MonadCatch m) => [IOErrorType] -> m a -> m a -> m a
+hideErrorDefM :: [IOErrorType] -> IO a -> IO a -> IO a
 hideErrorDefM errs def =
-  handleIO (\e -> if ioeGetErrorType e `elem` errs then def else liftIO $ ioError e)
+  handleIO (\e -> if ioeGetErrorType e `elem` errs then def else ioError e)


 -- TODO: does this work?
@@ -264,8 +242,6 @@ throwEither' e eth = case eth of
 verToBS :: Version -> ByteString
 verToBS = E.encodeUtf8 . prettyVer

-verToS :: Version -> String
-verToS = T.unpack . prettyVer

 intToText :: Integral a => a -> T.Text
 intToText = TL.toStrict . B.toLazyText . B.decimal
@@ -276,6 +252,14 @@ removeLensFieldLabel str' =
  maybe str' T.unpack . T.stripPrefix (T.pack "_") . T.pack $ str'


+addToCurrentEnv :: MonadIO m
+                => [(ByteString, ByteString)]
+                -> m [(ByteString, ByteString)]
+addToCurrentEnv adds = do
+  cEnv <- liftIO getEnvironment
+  pure (adds ++ cEnv)
+
+
 pvpToVersion :: PVP -> Version
 pvpToVersion =
  either (\_ -> error "Couldn't convert PVP to Version") id
@@ -300,238 +284,3 @@ escapeVerRex = B.pack . go . B.unpack . verToBS
  go (x : xs) | x == _period = [_backslash, _period] ++ go xs
              | otherwise    = x : go xs

-- | More permissive version of 'createDirRecursive'. This doesn't
-- error when the destination is a symlink to a directory.
-createDirRecursive' :: FilePath -> IO ()
-createDirRecursive' p =
-  handleIO (\e -> if isAlreadyExistsError e then isSymlinkDir e else throwIO e)
-    . createDirectoryIfMissing True
-    $ p
-
- where
-  isSymlinkDir e = do
-    ft <- pathIsSymbolicLink p
-    case ft of
-      True -> do
-        rp <- canonicalizePath p
-        rft <- doesDirectoryExist rp
-        case rft of
-          True -> pure ()
-          _ -> throwIO e
-      _ -> throwIO e
-
-
-- | Recursively copy the contents of one directory to another path.
--
-- This is a rip-off of Cabal library.
-copyDirectoryRecursive :: FilePath -> FilePath -> (FilePath -> FilePath -> IO ()) -> IO ()
-copyDirectoryRecursive srcDir destDir doCopy = do
-  srcFiles <- getDirectoryContentsRecursive srcDir
-  copyFilesWith destDir [ (srcDir, f)
-                          | f <- srcFiles ]
-  where
-    -- | Common implementation of 'copyFiles', 'installOrdinaryFiles',
-    -- 'installExecutableFiles' and 'installMaybeExecutableFiles'.
-    copyFilesWith :: FilePath -> [(FilePath, FilePath)] -> IO ()
-    copyFilesWith targetDir srcFiles = do
-
-      -- Create parent directories for everything
-      let dirs = map (targetDir </>) . nub . map (takeDirectory . snd) $ srcFiles
-      traverse_ (createDirectoryIfMissing True) dirs
-
-      -- Copy all the files
-      sequence_ [ let src  = srcBase   </> srcFile
-                      dest = targetDir </> srcFile
-                   in doCopy src dest
-                | (srcBase, srcFile) <- srcFiles ]
-
-
-- | List all the files in a directory and all subdirectories.
--
-- The order places files in sub-directories after all the files in their
-- parent directories. The list is generated lazily so is not well defined if
-- the source directory structure changes before the list is used.
--
-getDirectoryContentsRecursive :: FilePath -> IO [FilePath]
-getDirectoryContentsRecursive topdir = recurseDirectories [""]
-  where
-    recurseDirectories :: [FilePath] -> IO [FilePath]
-    recurseDirectories []         = return []
-    recurseDirectories (dir:dirs) = unsafeInterleaveIO $ do
-      (files, dirs') <- collect [] [] =<< getDirectoryContents (topdir </> dir)
-      files' <- recurseDirectories (dirs' ++ dirs)
-      return (files ++ files')
-
-      where
-        collect files dirs' []              = return (reverse files
-                                                     ,reverse dirs')
-        collect files dirs' (entry:entries) | ignore entry
-                                            = collect files dirs' entries
-        collect files dirs' (entry:entries) = do
-          let dirEntry = dir </> entry
-          isDirectory <- doesDirectoryExist (topdir </> dirEntry)
-          if isDirectory
-            then collect files (dirEntry:dirs') entries
-            else collect (dirEntry:files) dirs' entries
-
-        ignore ['.']      = True
-        ignore ['.', '.'] = True
-        ignore _          = False
-
-
-- https://github.com/haskell/directory/issues/110
-- https://github.com/haskell/directory/issues/96
-- https://www.sqlite.org/src/info/89f1848d7f
-recyclePathForcibly :: ( MonadIO m
-                       , MonadReader env m
-                       , HasDirs env
-                       , MonadMask m
-                       )
-                    => FilePath
-                    -> m ()
-recyclePathForcibly fp = do
-#if defined(IS_WINDOWS)
-  Dirs { recycleDir } <- getDirs
-  tmp <- liftIO $ createTempDirectory recycleDir "recyclePathForcibly"
-  let dest = tmp </> takeFileName fp
-  liftIO (Win32.moveFileEx fp (Just dest) 0)
-      `catch`
-      (\e -> if isPermissionError e {- EXDEV on windows -} then recover (liftIO $ removePathForcibly fp) else throwIO e)
-      `finally`
-        (liftIO $ handleIO (\_ -> pure ()) $ removePathForcibly tmp)
-#else
-  liftIO $ removePathForcibly fp
-#endif
-
-
-rmPathForcibly :: ( MonadIO m
-                  , MonadMask m
-                  )
-               => FilePath
-               -> m ()
-rmPathForcibly fp =
-#if defined(IS_WINDOWS)
-  recover (liftIO $ removePathForcibly fp)
-#else
-  liftIO $ removePathForcibly fp
-#endif
-
-
-rmDirectory :: (MonadIO m, MonadMask m)
-            => FilePath
-            -> m ()
-rmDirectory fp =
-#if defined(IS_WINDOWS)
-  recover (liftIO $ removeDirectory fp)
-#else
-  liftIO $ removeDirectory fp
-#endif
-
-
-- https://www.sqlite.org/src/info/89f1848d7f
-- https://github.com/haskell/directory/issues/96
-recycleFile :: ( MonadIO m
-               , MonadMask m
-               , MonadReader env m
-               , HasDirs env
-               )
-            => FilePath
-            -> m ()
-recycleFile fp = do
-#if defined(IS_WINDOWS)
-  Dirs { recycleDir } <- getDirs
-  liftIO $ whenM (doesDirectoryExist fp) $ ioError (IOError Nothing InappropriateType "recycleFile" "" Nothing (Just fp))
-  tmp <- liftIO $ createTempDirectory recycleDir "recycleFile"
-  let dest = tmp </> takeFileName fp
-  liftIO (Win32.moveFileEx fp (Just dest) 0)
-    `catch`
-      (\e -> if isPermissionError e {- EXDEV on windows -} then recover (liftIO $ removePathForcibly fp) else throwIO e)
-    `finally`
-      (liftIO $ handleIO (\_ -> pure ()) $ removePathForcibly tmp)
-#else
-  liftIO $ removeFile fp
-#endif
-
-
-rmFile :: ( MonadIO m
-          , MonadMask m
-          )
-      => FilePath
-      -> m ()
-rmFile fp =
-#if defined(IS_WINDOWS)
-  recover (liftIO $ removeFile fp)
-#else
-  liftIO $ removeFile fp
-#endif
-
-
-rmDirectoryLink :: (MonadIO m, MonadMask m, MonadReader env m, HasDirs env)
-                => FilePath
-                -> m ()
-rmDirectoryLink fp = 
-#if defined(IS_WINDOWS)
-  recover (liftIO $ removeDirectoryLink fp)
-#else
-  liftIO $ removeDirectoryLink fp
-#endif
-
-
-#if defined(IS_WINDOWS)
-recover :: (MonadIO m, MonadMask m) => m a -> m a
-recover action = 
-  recovering (fullJitterBackoff 25000 <> limitRetries 10)
-    [\_ -> Handler (\e -> pure $ isPermissionError e)
-    ,\_ -> Handler (\e -> pure (ioeGetErrorType e == InappropriateType))
-    ,\_ -> Handler (\e -> pure (ioeGetErrorType e == UnsatisfiedConstraints))
-    ]
-    (\_ -> action)
-#endif
-
-
-- Gathering monoidal values
-traverseFold :: (Foldable t, Applicative m, Monoid b) => (a -> m b) -> t a -> m b
-traverseFold f = foldl (\mb a -> (<>) <$> mb <*> f a) (pure mempty)
-
-- | Gathering monoidal values
-forFold :: (Foldable t, Applicative m, Monoid b) => t a -> (a -> m b) -> m b
-forFold = \t -> (`traverseFold` t)
-
-
-- | Strip @\\r@ and @\\n@ from 'ByteString's
-stripNewline :: String -> String
-stripNewline s
-  | null s               = []
-  | head s `elem` "\n\r" = stripNewline (tail s)
-  | otherwise            = head s : stripNewline (tail s)
-
-
-- | Strip @\\r@ and @\\n@ from 'ByteString's
-stripNewline' :: T.Text -> T.Text
-stripNewline' s
-  | T.null s               = mempty
-  | T.head s `elem` "\n\r" = stripNewline' (T.tail s)
-  | otherwise              = T.singleton (T.head s) <> stripNewline' (T.tail s)
-
-
-isNewLine :: Word8 -> Bool
-isNewLine w
-  | w == _lf = True
-  | w == _cr = True
-  | otherwise = False
-
-
-- | Split on a PVP suffix.
--
-- >>> splitOnPVP "-" "ghc-iserv-dyn-9.3.20210706" == ("ghc-iserv-dyn", "9.3.20210706")
-- >>> splitOnPVP "-" "ghc-iserv-dyn"              == ("ghc-iserv-dyn", "")
-splitOnPVP :: String -> String -> (String, String)
-splitOnPVP c s = case Split.splitOn c s of
-  []  -> def
-  [_] -> def
-  xs
-    | let l = last xs
-    , (Right _) <- pvp (T.pack l) -> (intercalate c (init xs), l)
-    | otherwise -> def
- where
-  def = (s, "")
--- a/lib/GHCup/Utils/String/QQ.hs
+++ b/lib/GHCup/Utils/String/QQ.hs
@@ -7,7 +7,7 @@ Copyright   : (c) Audrey Tang <audreyt@audreyt.org> 2019, Julian Ospald <hasufel
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX

 QuasiQuoter for non-interpolated strings, texts and bytestrings.

--- a/lib/GHCup/Utils/Version/QQ.hs
+++ b/lib/GHCup/Utils/Version/QQ.hs
@@ -14,7 +14,7 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX
 -}
 module GHCup.Utils.Version.QQ where

--- a/lib/GHCup/Version.hs
+++ b/lib/GHCup/Version.hs
@@ -8,7 +8,7 @@ Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
-Portability : portable
+Portability : POSIX
 -}
 module GHCup.Version where

@@ -25,7 +25,7 @@ import qualified Data.Text                     as T

 -- | This reflects the API version of the YAML.
 ghcupURL :: URI
-ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.6.yaml|]
+ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.4.yaml|]

 -- | The current ghcup version.
 ghcUpVer :: PVP
--- a/refreeze.sh
+++ b/refreeze.sh
@@ -1,27 +0,0 @@
-#!/bin/sh
-
-set -xue
-
-rm -f cabal.*.project
-rm -f cabal.*.project.freeze
-
-for ghc_ver in "$@" ; do
-	# shellcheck disable=SC3060
-	project_file=cabal.ghc${ghc_ver//./}.project
-
-	cp cabal.project "${project_file}"
-	case "$(uname -s)" in
-        MSYS*|MINGW*)
-			cabal freeze --project-file="${project_file}" -w "ghc-${ghc_ver}"
-			;;
-		*)
-			cabal freeze --project-file="${project_file}" -w "ghc-${ghc_ver}" -ftui -finternal-downloader
-			;;
-	esac
-
-
-	echo "" >> "${project_file}"
-	echo "with-compiler: ghc-${ghc_ver}" >> "${project_file}"
-
-	sed -i -e '/ghcup/d' "${project_file}".freeze
-done
--- a/scoop-better-shimexe/LICENSE-MIT
+++ b/scoop-better-shimexe/LICENSE-MIT
@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2019 Grégoire Geis
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/scoop-better-shimexe/LICENSE-UNLICENSE
+++ b/scoop-better-shimexe/LICENSE-UNLICENSE
@@ -1,10 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.
-
-In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and 
-successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS 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.
-
-For more information, please refer to <http://unlicense.org/>
--- a/scoop-better-shimexe/README.md
+++ b/scoop-better-shimexe/README.md
@@ -1,71 +0,0 @@
-# `shim.c`
-
-[`shim.c`](./shim.c) is a simple Windows program that, when started:
-1. Looks for a file with the exact same name as the running program, but with
-   the extension `shim` (e.g. `C:\bin\foo.exe` will read the file `C:\bin\foo.shim`).
-2. Reads and [parses](#shim-format) the files into a
-   [Scoop](https://github.com/lukesampson/scoop) shim format.
-3. Executes the target executable with the given arguments.
-
-`shim.c` was originally made to replace [Scoop](https://github.com/lukesampson/scoop)'s
-[`shim.cs`](https://github.com/lukesampson/scoop/blob/96de9c14bb483f9278e4b0a9e22b1923ee752901/supporting/shimexe/shim.cs)
-since it had several important flaws:
-1. [It was made in C#](https://github.com/lukesampson/scoop/tree/96de9c14bb483f9278e4b0a9e22b1923ee752901/supporting/shimexe),
-   and thus required an instantiation of a .NET command line app everytime it was started,
-   which can make a command run much slower than if it had been ran directly;
-2. [It](https://github.com/lukesampson/scoop/issues/2339) [did](https://github.com/lukesampson/scoop/issues/1896)
-   [not](https://github.com/felixse/FluentTerminal/issues/221) handle Ctrl+C and other
-   signals correctly, which could be quite infuriating (and essentially killing REPLs and long-running apps).
-
-[`shim.c`](./shim.c) is:
- **Faster**, because it does not use the .NET Framework, and parses the `.shim` file in a simpler way.
- **More efficient**, because by the time the target of the shim is started, all allocated memory will have been freed.
- And more importantly, it **works better**:
-  - Signals originating from pressing `Ctrl+C` are ignored, and therefore handled directly by the spawned child.
-    Your processes and REPLs will no longer close when pressing `Ctrl+C`.
-  - Children are automatically killed when the shim process is killed. No more orphaned processes and weird behaviors.
-
-> **Note**: This project is not affiliated with [Scoop](https://github.com/lukesampson/scoop).
-
-
-## Installation for Scoop
-
- In a Visual Studio command prompt, run `cl /O1 shim.c`.
- Replace any `.exe` in `scoop\shims` by `shim.exe`.
-
-An additional script, `repshims.bat`, is provided. It will replace all `.exe`s in the user's Scoop directory
-by `shim.exe`.
-
-
-## Example
-
-Given the following shim `gs.shim`:
-```
-path = C:\Program Files\Git\git.exe
-args = status -u
-```
-
-In this directory, where `gs.exe` is the compiled `shim.c`:
-```
-C:\Bin\
-   gs.exe
-   gs.shim
-```
-
-Then calling `gs -s` will run the program `C:\Program Files\Git\git.exe status -u -s`.
-
-
-## Shim format
-
-Shims follow the same format as Scoop's shims: line-separated `key = value` pairs.
-```
-path = C:\Program Files\Git\git.exe
-args = status -uno
-```
-
-`path` is a required value, but `args` can be omitted. Also, do note that lines **must** end with a line feed.
-
-
-## License
-
-`SPDX-License-Identifier: MIT OR Unlicense`
--- a/scoop-better-shimexe/repshims.bat
+++ b/scoop-better-shimexe/repshims.bat
@@ -1,15 +0,0 @@
-@echo off
-
-if not defined SCOOP set SCOOP=%USERPROFILE%\scoop
-
-for %%x in ("%SCOOP%\shims\*.exe") do (
-  echo Replacing %%x by new shim.
-  copy /B /Y shim.exe "%%~x" >NUL
-)
-
-if not defined SCOOP_GLOBAL set SCOOP_GLOBAL=%ProgramData%\scoop
-
-for %%x in ("%SCOOP_GLOBAL%\shims\*.exe") do (
-  echo Replacing %%x by new shim.
-  copy /B /Y shim.exe "%%~x" >NUL
-)
--- a/scoop-better-shimexe/shim.c
+++ b/scoop-better-shimexe/shim.c
@@ -1,256 +0,0 @@
-#pragma comment(lib, "SHELL32.LIB")
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <wchar.h>
-#include <Windows.h>
-
-#ifndef ERROR_ELEVATION_REQUIRED
-#  define ERROR_ELEVATION_REQUIRED 740
-#endif
-
-#define MAX_FILENAME_SIZE 512
-
-BOOL WINAPI ctrlhandler(DWORD fdwCtrlType)
-{
-  switch (fdwCtrlType) {
-    // Ignore all events, and let the child process
-    // handle them.
-    case CTRL_C_EVENT:
-    case CTRL_CLOSE_EVENT:
-    case CTRL_LOGOFF_EVENT:
-    case CTRL_BREAK_EVENT:
-    case CTRL_SHUTDOWN_EVENT:
-      return TRUE;
-
-    default:
-      return FALSE;
-  }
-}
-
-int compute_program_length(const wchar_t* commandline)
-{
-  int i = 0;
-
-  if (commandline[0] == L'"') {
-    // Wait till end of string
-    i++;
-
-    for (;;) {
-      wchar_t c = commandline[i++];
-
-      if (c == 0)
-        return i - 1;
-      else if (c == L'\\')
-        i++;
-      else if (c == L'"')
-        return i;
-    }
-  } else {
-    for (;;) {
-      wchar_t c = commandline[i++];
-
-      if (c == 0)
-        return i - 1;
-      else if (c == L'\\')
-        i++;
-      else if (c == L' ')
-        return i;
-    }
-  }
-}
-
-int main()
-{
-  DWORD exit_code = 0;
-
-  wchar_t* path = NULL;
-  wchar_t* args = NULL;
-  wchar_t* cmd = NULL;
-
-  // Find filename of current executable.
-  wchar_t filename[MAX_FILENAME_SIZE + 2];
-  const unsigned int filename_size = GetModuleFileNameW(NULL, filename, MAX_FILENAME_SIZE);
-
-  if (filename_size >= MAX_FILENAME_SIZE) {
-    fprintf(stderr, "The filename of the program is too long to handle.\n");
-
-    exit_code = 1;
-    goto cleanup;
-  }
-
-  // Use filename of current executable to find .shim
-  filename[filename_size - 3] = L's';
-  filename[filename_size - 2] = L'h';
-  filename[filename_size - 1] = L'i';
-  filename[filename_size - 0] = L'm';
-  filename[filename_size + 1] =  0 ;
-
-  FILE* shim_file;
-
-  if ((shim_file = _wfsopen(filename, L"r,ccs=UTF-8", _SH_DENYNO)) == NULL) {
-    fprintf(stderr, "Cannot open shim file for read.\n");
-
-    exit_code = 1;
-    goto cleanup;
-  }
-
-  size_t command_length = 256;
-  size_t path_length;
-  size_t args_length;
-
-  // Read shim
-  wchar_t linebuf[8192];
-
-  for (;;) {
-    const wchar_t* line = fgetws(linebuf, 8192, shim_file);
-
-    if (line == NULL)
-      break;
-
-    if (line[4] != L' ' || line[5] != L'=' || line[6] != L' ')
-      continue;
-
-    const int linelen = wcslen(line);
-    const int len = linelen - 8 + (line[linelen - 1] != '\n');
-
-    if (line[0] == L'p' && line[1] == L'a' && line[2] == L't' && line[3] == L'h') {
-      // Reading path
-      path = calloc(len + 1, sizeof(wchar_t));
-      wmemcpy(path, line + 7, len);
-
-      command_length += len;
-      path_length = len;
-
-      continue;
-    }
-
-    if (line[0] == L'a' && line[1] == L'r' && line[2] == L'g' && line[3] == L's') {
-      // Reading args
-      args = calloc(len + 1, sizeof(wchar_t));
-      wmemcpy(args, line + 7, len);
-
-      command_length += len + 1;
-      args_length = len;
-
-      continue;
-    }
-
-    continue;
-  }
-
-  fclose(shim_file);
-
-  if (path == NULL) {
-    fprintf(stderr, "Could not read shim file.\n");
-
-    exit_code = 1;
-    goto cleanup;
-  }
-
-  // Find length of command to run
-  wchar_t* given_cmd = GetCommandLineW();
-  const int program_length = compute_program_length(given_cmd);
-
-  given_cmd += program_length;
-
-  const int given_length = wcslen(given_cmd);
-
-  command_length += given_length;
-
-  // Start building command to run, using '[path] [args]', as given by shim.
-  cmd = calloc(command_length, sizeof(wchar_t));
-  int cmd_i = 0;
-
-  wmemcpy(cmd, path, path_length);
-  cmd[path_length] = ' ';
-  cmd_i += path_length + 1;
-
-  if (args != NULL) {
-    wmemcpy(cmd + path_length + 1, args, args_length);
-    cmd[path_length + args_length + 1] = ' ';
-    cmd_i += args_length + 1;
-  }
-
-  // Copy all given arguments to command
-  wmemcpy(cmd + cmd_i, given_cmd, given_length);
-
-  // Find out if the target program is a console app
-  SHFILEINFOW sfi = {0};
-  const BOOL is_windows_app = HIWORD(SHGetFileInfoW(path, -1, &sfi, sizeof(sfi), SHGFI_EXETYPE));
-
-  if (is_windows_app)
-    // Unfortunately, this technique will still show a window for a fraction of time,
-    // but there's just no workaround.
-    FreeConsole();
-
-  // Create job object, which can be attached to child processes
-  // to make sure they terminate when the parent terminates as well.
-  JOBOBJECT_EXTENDED_LIMIT_INFORMATION jeli = {0};
-  HANDLE jobHandle = CreateJobObject(NULL, NULL);
-
-  jeli.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK;
-  SetInformationJobObject(jobHandle, JobObjectExtendedLimitInformation, &jeli, sizeof(jeli));
-
-  // Start subprocess
-  STARTUPINFOW si = {0};
-  PROCESS_INFORMATION pi = {0};
-
-  if (CreateProcessW(NULL, cmd, NULL, NULL, TRUE, CREATE_SUSPENDED, NULL, NULL, &si, &pi)) {
-    AssignProcessToJobObject(jobHandle, pi.hProcess);
-    ResumeThread(pi.hThread);
-  } else {
-    if (GetLastError() == ERROR_ELEVATION_REQUIRED) {
-      // We must elevate the process, which is (basically) impossible with
-      // CreateProcess, and therefore we fallback to ShellExecuteEx,
-      // which CAN create elevated processes, at the cost of opening a new separate
-      // window.
-      // Theorically, this could be fixed (or rather, worked around) using pipes
-      // and IPC, but... this is a question for another day.
-      SHELLEXECUTEINFOW sei = {0};
-
-      sei.cbSize       = sizeof(SHELLEXECUTEINFOW);
-      sei.fMask        = SEE_MASK_NOCLOSEPROCESS;
-      sei.lpFile       = path;
-      sei.lpParameters = cmd + path_length + 1;
-      sei.nShow        = SW_SHOW;
-
-      if (!ShellExecuteExW(&sei)) {
-        fprintf(stderr, "Unable to create elevated process: error %li.", GetLastError());
-
-        exit_code = 1;
-        goto cleanup;
-      }
-
-      pi.hProcess = sei.hProcess;
-    } else {
-      fprintf(stderr, "Could not create process with command '%ls'.\n", cmd);
-
-      exit_code = 1;
-      goto cleanup;
-    }
-  }
-
-  // Ignore Ctrl-C and other signals
-  if (!SetConsoleCtrlHandler(ctrlhandler, TRUE))
-    fprintf(stderr, "Could not set control handler; Ctrl-C behavior may be invalid.\n");
-
-  // Wait till end of process
-  WaitForSingleObject(pi.hProcess, INFINITE);
-
-  GetExitCodeProcess(pi.hProcess, &exit_code);
-
-  // Dispose of everything
-  CloseHandle(pi.hThread);
-  CloseHandle(pi.hProcess);
-  CloseHandle(jobHandle);
-
-cleanup:
-
-  // Free obsolete buffers
-  free(path);
-  free(args);
-  free(cmd);
-
-  return (int)exit_code;
-}
--- a/stack.yaml
+++ b/stack.yaml
@@ -1,4 +1,4 @@
-resolver: lts-18.2
+resolver: lts-17.4

 packages:
  - .
@@ -7,15 +7,8 @@ extra-deps:
  - git: https://github.com/hasufell/text-conversions.git
    commit: 9abf0e5e5664a3178367597c32db19880477a53c

-  - git: https://github.com/Bodigrim/tar
-    commit: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
-
-  - git: https://github.com/jtdaugherty/brick.git
-    commit: b3b96cfe66dfd398d338e3feb2b6855e66a35190
-
  - IfElse-0.85@sha256:6939b94acc6a55f545f63a168a349dd2fbe4b9a7cca73bf60282db5cc6aa47d2,445
  - ascii-string-1.0.1.4@sha256:fa34f1d9ba57e8e89c0d4c9cef5e01ba32cb2d4373d13f92dcc0b531a6c6749b,2582
-  - base16-bytestring-0.1.1.7@sha256:0021256a9628971c08da95cb8f4d0d72192f3bb8a7b30b55c080562d17c43dd3,2231
  - brotli-0.0.0.0@sha256:2bf383a4cd308745740986be0b18381c5a0784393fe69b91456aacb2d603de46,2964
  - brotli-streams-0.0.0.0@sha256:1af1e22f67b8bfd6ad0d05e61825e7a178d738f689ebbb21c1aab5f1bbcae176,2331
  - chs-cabal-0.1.1.0@sha256:20ec6a9fb5ab6991f1a4adf157c537bd5d3b98d08d3c09c387c954c7c50bd011,1153
@@ -24,28 +17,21 @@ extra-deps:
  - haskus-utils-data-1.3@sha256:f62c4e49021b463185d043f7b69c727b63af641a71d7edd582d9f4f98e80e500,1466
  - haskus-utils-types-1.5.1@sha256:991c472f4e751e2f0d7aab6ad4220ef151d6160876dcf0511bbf876bbd432020,1298
  - haskus-utils-variant-3.0@sha256:8d51e45d3b664e61ccc25a58b37c0ccc4ee7537138b9fee21cd15c356906dd34,2159
+  - hpath-0.11.0@sha256:12b8405bee13d0007d644a888ef8407069ce7bbbd76970f8746b801447124ade,1440
+  - hpath-directory-0.14.1@sha256:548ac1321222c34caa843a41a2379a77d961141082a4695bb37cc4731e91b2c7,5312
  - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
-  - hpath-posix-0.13.3@sha256:abe472cf16bccd3a8b8814865ed3551a728fde0f3a2baea2acc03023bec6c565,1615
-  - hspec-2.7.10@sha256:c9e82c90086acebac576552a06f3cabd249bba048edd1667c7fae0b1313d5bce,1712
-  - hspec-core-2.7.10@sha256:2aba6ea126442b29e8183ab27f1c811706b19b1d83b02f193a896f6fc1589d13,4621
-  - hspec-discover-2.7.10@sha256:d08bf5dd785629f589571477d9beb7cd91529471bd89f39517c1cb4b9b38160f,2184
-  - hspec-golden-aeson-0.9.0.0@sha256:aa17274114026661ba4dfc9c60c230673c8f408bd86482fd611d2d5cb6aff996,2179
+  - hpath-io-0.14.1@sha256:d91373cd81483eb370a1c683e4add6182250dccce32f9b682bb1104f7765c750,1522
+  - hpath-posix-0.13.2@sha256:eec4ff2b00dc86be847aca0f409fc8f6212ffd2170ec36a17dc9a52b46562392,1615
  - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
+  - lzma-static-5.2.5.2@sha256:ac38dcad9ab423342a72ba48415bd75f62234e9c9e11831495b75603b5a060f6,7184
  - libarchive-3.0.2.1@sha256:40ebf2a278e585802427bc58826867208bb33822f63d56107a1fcc3ca04d691d,10990
-  - lzma-static-5.2.5.3@sha256:2758ee58c35992fcf7db78e98684c357a16a82fa2a4e7c352a6c210c08c555d8,7308
  - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
-  - optics-0.4@sha256:9fb69bf0195b8d8f1f8cd0098000946868b8a3c3ffb51e5b64f79fc600c3eb4c,6568
-  - optics-core-0.4@sha256:59e04aebca536bd011ae50c781937f45af4c1456af1eb9fb578f9a69eee293cd,4995
-  - optics-extra-0.4@sha256:b9914f38aa7d5c92f231060d9168447f9f5a367c07df9bf47a003e3e786d5e05,3432
-  - optics-th-0.4@sha256:7c838b5b1d6998133bf8f0641c36197ed6cb468dc69515e1952f33f0bbe8e11d,2009
-  - primitive-0.7.1.0@sha256:29de6bfd0cf8ba023ceb806203dfbec0e51e3524e75ffe41056f70b4229c6f0f,2728
-  - regex-posix-clib-2.7
+  - primitive-0.7.0.1@sha256:a381571c36edc7dca28b77fe8159b43c14c640087ec5946adacf949feec64231,3433
  - streamly-0.7.3@sha256:ad2a488fe802692ed47cab9fd0416c2904aac9e51cf2d8aafd1c3a40064c42f5,27421
  - streamly-bytestring-0.1.2@sha256:cc828f41d1c714c711d38fb213b4ed186febabba598ab080e13255f69c20b13c,2469
  - streamly-posix-0.1.0.1@sha256:5d89b806281035d34020387ed99dde1ddab282c7ed66df3b7cd010b38fd3517b,2138
  - strict-base-0.4.0.0@sha256:2ff4e43cb95eedf2995558d7fc34d19362846413dd39e6aa6a5b3ea8228fef9f,1248
  - xor-0.0.1.0@sha256:f8362b4a68562b9afbcd727ff64c1a303970df3a032e0033d2f4c094c3501df3,2243
-  - zip-1.7.1@sha256:0ce03d0fbffba47c1ab6fbb9166f8ba5373d828d78587df21b7e9d7bb150f929,3918

 flags:
  http-io-streams:
@@ -54,8 +40,13 @@ flags:
  libarchive:
    system-libarchive: false

-  regex-posix:
-    _regex-posix-clib: true
+  ghcup:
+    tui: true
+    internal-downloader: true
+
+system-ghc: true
+compiler: ghc-8.10.4
+compiler-check: match-exact

 ghc-options:
  "$locals": -O2
--- a/test/GHCup/ArbitraryTypes.hs
+++ b/test/GHCup/ArbitraryTypes.hs
@@ -11,6 +11,7 @@ import           GHCup.Types
 import           Data.ByteString                ( ByteString )
 import           Data.Versions
 import           Data.List.NonEmpty
+import           HPath
 import           Test.QuickCheck
 import           Test.QuickCheck.Arbitrary.ADT  ( ToADTArbitrary )
 import           Test.QuickCheck.Arbitrary.Generic
@@ -163,6 +164,11 @@ instance Arbitrary VersionCmp where
  arbitrary = genericArbitrary
  shrink    = genericShrink

+instance Arbitrary (Path Rel) where
+  arbitrary =
+    either (error . show) id . parseRel . E.encodeUtf8 . T.pack
+      <$> listOf1 (elements ['a' .. 'z'])
+
 instance Arbitrary TarDir where
  arbitrary = genericArbitrary
  shrink    = genericShrink
@@ -171,10 +177,6 @@ instance Arbitrary Tool where
  arbitrary = genericArbitrary
  shrink    = genericShrink

-instance Arbitrary GlobalTool where
-  arbitrary = genericArbitrary
-  shrink    = genericShrink
-
 instance Arbitrary GHCupInfo where
  arbitrary = genericArbitrary
  shrink    = genericShrink
--- a/www/ghcup.css
+++ b/www/ghcup.css
@@ -132,17 +132,13 @@ hr {
    margin-bottom: 2em;
 }

-span.code {
-	font-family: 'Lucida Console', monospace;
-}
-
-#platform-instructions-linux div > pre,
-#platform-instructions-mac div > pre,
-#platform-instructions-freebsd div > pre,
-#platform-instructions-win32 div > pre,
-#platform-instructions-win64 div > pre,
-#platform-instructions-default div > div > pre,
-#platform-instructions-unknown div > div > pre {
+#platform-instructions-linux > div > pre,
+#platform-instructions-mac > div > pre,
+#platform-instructions-freebsd > div > pre,
+#platform-instructions-win32 > div > pre,
+#platform-instructions-win64 > div > pre,
+#platform-instructions-default > div > div > pre,
+#platform-instructions-unknown > div > div > pre {
    background-color: #515151;
    color: white;
    margin-left: auto;
--- a/www/ghcup.js
+++ b/www/ghcup.js
@@ -158,8 +158,8 @@ function copyToClipboard() {
  document.body.removeChild(el);
 }

-function copyToClipboardPowershell() {
-  const text = document.getElementById("ghcup-command-powershell").innerText;
+function copyToClipboardSilicon() {
+  const text = document.getElementById("ghcup-command-silicon").innerText;
  const el = document.createElement('textarea');
  el.value = text;
  document.body.appendChild(el);
--- a/www/index.html
+++ b/www/index.html
@@ -14,6 +14,7 @@

  <body id="idx">

+    <script id='html-content' type="text/html">
      <a id="platform-button" style="display: none;" href="#">
        click or press "n" to cycle platforms
      </a>
@@ -31,7 +32,10 @@

      <div id="platform-instructions-mac" class="instructions" style="display: none;">
        <p>Run the following in your terminal (as a user other than root), then follow the onscreen instructions.</p>
+		<p>On Intel:</p>
 		<div class="command-button"><pre><span class='ghcup-command' id="ghcup-command-normal">curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+        <p>On Apple Silicon:</p>
+		<div class="command-button"><pre><span class='ghcup-command' id="ghcup-command-silicon">curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | arch -x86_64 /bin/bash</span></pre><button class="tooltip" onclick="copyToClipboardSilicon()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
        <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.<br/>You appear to be running macOS. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
      </div>

@@ -43,41 +47,24 @@

      <div id="platform-instructions-win32" class="instructions">
        <p>
-            To install Haskell,<br/>run the following in a powershell session (as a non-admin user).
-			<div>
-			<div class="command-button"><pre><span class='ghcup-command' id="ghcup-command-powershell">Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $true</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
-			</div>
-				<p class="other-help">If you want to run a non-interactive installation, change <span class='code'>$true</span> to <span class='code'>$false</span> at the end of the script.</p>
-			</div>
-		<p>If you're a Windows Subsystem 2 for Linux user run the following in your terminal, then follow the onscreen instructions to install Haskell.
+          To install Haskell, follow the instructions on
+          <a class="windows-download" href="https://www.haskell.org/platform/#windows">Haskell Platform</a>
+		<p>If you're a Windows Subsystem for Linux user run the following in your terminal, then follow the onscreen instructions to install Haskell.
 		</p>
-		<div>
-		<div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
-		</div>
-		<p class="other-help">WSL1 does not work with ghcup, follow  <a href="https://docs.microsoft.com/en-us/windows/wsl/install-win10">the instructions here</a> to upgrade to WSL2 if needed.</p>
-		</div>
+		<div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
        </p>
-        <hr/>
-		<p class="other-help">You appear to be running Windows 32-bit. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
+        <p class="other-help">You appear to be running Windows 32-bit. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
      </div>

      <div id="platform-instructions-win64" class="instructions" style="display: none;">
        <p>
-            To install Haskell,<br/>run the following in a powershell session (as a non-admin user).
-			<div>
-			<div class="command-button"><pre><span class='ghcup-command'>Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $true</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
-			</div>
-				<p class="other-help">If you want to run an non-interactive installation, change <span class='code'>$true</span> to <span class='code'>$false</span> at the end of the script.</p>
-			</div>
+          To install Haskell, follow the instructions on
+          <a class="windows-download" href="https://www.haskell.org/platform/#windows">Haskell Platform</a>
        </p>
-		<p>If you're a Windows Subsystem 2 for Linux user run the following in your terminal, then follow the onscreen instructions to install Haskell.
+		<p>If you're a Windows Subsystem for Linux user run the following in your terminal, then follow the onscreen instructions to install Haskell.
 		</p>
-		<div>
-		<div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
-		</div>
-		<p class="other-help">WSL1 does not work with ghcup, follow  <a href="https://docs.microsoft.com/en-us/windows/wsl/install-win10">the instructions here</a> to upgrade to WSL2 if needed.</p>
-		</div>
-		<p class="other-help">You appear to be running Windows 64-bit. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
+		<div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+        <p class="other-help">You appear to be running Windows 64-bit. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
      </div>

      <div id="platform-instructions-unknown" class="instructions" style="display: none;">
@@ -99,7 +86,7 @@

        <!-- duplicate the default cross-platform instructions -->
        <div>
-          <p>If you are running Linux, macOS, FreeBSD or Windows Subsystem 2 for Linux, run the following in your terminal (as a user other than root), then follow the onscreen instructions.</p>
+          <p>If you are running Linux, macOS, FreeBSD or Windows Subsystem for Linux, run the following in your terminal (as a user other than root), then follow the onscreen instructions.</p>
 		  <div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
          <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.</p>
        </div>
@@ -108,8 +95,8 @@

        <div>
          <p>
-            If you are running Windows,<br/>run the following in a powershell session (as a non-admin user).
-			<div class="command-button"><pre><span class='ghcup-command'>Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $false</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+            If you are running Windows,<br/>follow the instructions on
+            <a class="windows-download" href="https://www.haskell.org/platform/#windows">Haskell Platform</a>
          </p>
        </div>

@@ -117,9 +104,11 @@

      <div id="platform-instructions-default" class="instructions">
        <div>
-          <p>To install Haskell, if you are running Linux, macOS, FreeBSD or Windows Subsystem 2 for Linux, run the following
+          <p>To install Haskell, if you are running Linux, macOS (on Intel), FreeBSD or Windows Subsystem for Linux, run the following
          in your terminal (as a user other than root), then follow the onscreen instructions.</p>
 		  <div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+          <p>For macOS on Apple Silicon, run this instead:</p>
+          <div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | arch -x86_64 /bin/bash</span></pre><button class="tooltip" onclick="copyToClipboardSilicon()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
          <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.</p>
        </div>

@@ -127,18 +116,15 @@

        <div>
          <p>
-            If you are running Windows,<br/>run the following in a powershell session (as a non-admin user).
-			<div class="command-button"><pre><span class='ghcup-command'>Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $true</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
-			</div>
-				<p class="other-help">If you want to run a non-interactive installation, change <span class='code'>$true</span> to <span class='code'>$false</span> at the end of the script.</p>
-			</div>
+            If you are running Windows,<br/>follow the instructions on
+            <a class="windows-download" href="https://www.haskell.org/platform/#windows">Haskell Platform</a>
          </p>
        </div>

      </div>

      <p>
-        Need help? Ask on <a href="https://kiwiirc.com/nextclient/irc.libera.chat/#haskell-ghcup">#haskell-ghcup</a>, <a href="https://kiwiirc.com/nextclient/irc.libera.chat/#haskell">#haskell</a> or <a href="https://gitlab.haskell.org/haskell/ghcup-hs/issues">report a bug</a>.
+        Need help? <a href="http://webchat.freenode.net/?randomnick=1&channels=%23haskell&uio=d4">Ask on #haskell</a> or <a href="https://gitlab.haskell.org/haskell/ghcup-hs/issues">report a bug</a>.
      </p>

      <p id="about">
@@ -151,7 +137,54 @@
        &nbsp;&middot;&nbsp;
        <a href="https://github.com/rust-lang/rustup.rs/tree/master/www">web design from rustup</a>
      </p>
+    </script>
+    <script>
+      document.write(document.getElementById("html-content").innerHTML);
+    </script>
    <script type="text/javascript" src="ghcup.js"></script>

+    <noscript>
+      <p id="pitch">
+        <em>ghcup</em> is an installer for<br/>
+        the general purpose language <a href="https://www.haskell.org/">Haskell</a>
+      </p>
+
+      <div id="platform-instructions-default" class="instructions">
+        <div>
+          <p>To install Haskell, if you are running Linux, macOS (on Intel), FreeBSD or Windows Subsystem for Linux, run the following
+          in your terminal (as a user other than root), then follow the onscreen instructions.</p>
+		  <pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre>
+          <p>For macOS on Apple Silicon, run this instead:</p>
+          <div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | arch -x86_64 /bin/bash</span></pre><button class="tooltip" onclick="copyToClipboardSilicon()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+          <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.</p>
+        </div>
+
+        <hr/>
+
+        <div>
+          <p>
+            If you are running Windows,<br/>follow the instructions on
+            <a class="windows-download" href="https://www.haskell.org/platform/#windows">Haskell Platform</a>
+          </p>
+        </div>
+
+      </div>
+
+      <p>
+        Need help? <a href="http://webchat.freenode.net/?randomnick=1&amp;channels=%23haskell&amp;uio=d4">Ask on #haskell</a>.
+      </p>
+
+      <p id="about">
+        <img src="haskell-logo.svg" alt="" />
+        ghcup is a haskell.org hosted project.
+        <br/>
+        <a href="https://www.haskell.org/downloads/">other installation options</a>
+        &nbsp;&middot;&nbsp;
+        <a href="https://gitlab.haskell.org/haskell/ghcup-hs">about ghcup</a>
+        &nbsp;&middot;&nbsp;
+        <a href="https://github.com/rust-lang/rustup.rs/tree/master/www">web design from rustup</a>
+      </p>
+
+    </noscript>
  </body>
 </html>