Remove zip dependency

Merge branch 'remove-string-interpolate'
2021-08-25 20:13:17 +02:00 · 2021-08-25 20:12:56 +02:00
78 changed files with 12898 additions and 12771 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -14,7 +14,7 @@ variables:
 ############################################################

 .debian:
-  image: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb10:$DOCKER_REV"
+  image: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb9:$DOCKER_REV"
  tags:
    - x86_64-linux
  variables:
@@ -49,7 +49,6 @@ variables:
    OS: "LINUX"
    ARCH: "ARM"
    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
-  retry: 2

 .linux:aarch64:
  image: "registry.gitlab.haskell.org/ghc/ci-images/aarch64-linux-deb10:$DOCKER_REV"
@@ -76,17 +75,9 @@ variables:
    ARCH: "ARM64"
    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

-.freebsd13:
+.freebsd:
  tags:
-    - x86_64-freebsd13
-  variables:
-    OS: "FREEBSD"
-    ARCH: "64"
-    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
-
-.freebsd12:
-  tags:
-    - x86_64-freebsd12
+    - x86_64-freebsd
  variables:
    OS: "FREEBSD"
    ARCH: "64"
@@ -99,7 +90,6 @@ variables:
    OS: "WINDOWS"
    ARCH: "64"
    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
-  retry: 2

 .root_cleanup:
  after_script:
@@ -109,11 +99,11 @@ variables:
  script:
    - bash ./.gitlab/script/ghcup_version.sh
  variables:
-    JSON_VERSION: "0.0.6"
+    JSON_VERSION: "0.0.7"
  artifacts:
    expire_in: 2 week
    paths:
-      - test/golden
+      - golden
      - dist-newstyle/cache/
    when: on_failure

@@ -183,18 +173,10 @@ variables:
    runInNixShell ./.gitlab/before_script/darwin/install_deps.sh 2>&1
    runInNixShell ./.gitlab/script/ghcup_version.sh 2>&1

-.test_ghcup_version:freebsd12:
+.test_ghcup_version:freebsd:
  extends:
    - .test_ghcup_version
-    - .freebsd12
-    - .root_cleanup
-  before_script:
-    - ./.gitlab/before_script/freebsd/install_deps.sh
-
-.test_ghcup_version:freebsd13:
-  extends:
-    - .test_ghcup_version
-    - .freebsd13
+    - .freebsd
    - .root_cleanup
  before_script:
    - ./.gitlab/before_script/freebsd/install_deps.sh
@@ -225,7 +207,7 @@ variables:
  only:
    - tags
  variables:
-    JSON_VERSION: "0.0.6"
+    JSON_VERSION: "0.0.7"

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

@@ -258,7 +240,7 @@ test:linux:bootstrap_script:
 test:windows:bootstrap_powershell_script:
  stage: test
  script:
-    - ./scripts/bootstrap/bootstrap-haskell.ps1 -InstallDir $CI_PROJECT_DIR -BootstrapUrl $CI_PROJECT_DIR/bootstrap-haskell -InBash
+    - ./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)"
@@ -281,23 +263,6 @@ test:linux:
    CABAL_VERSION: "3.4.0.0"
  needs: []

-test:linux:hls:
-  stage: test
-  extends:
-    - .test_ghcup_version
-    - .debian
-  variables:
-    GHC_VERSION: "8.10.7"
-    HLS_TARGET_VERSION: "1.4.0"
-    CABAL_VERSION: "3.6.0.0"
-  needs: []
-  when: manual
-  allow_failure: true
-  before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
-  script:
-    - ./.gitlab/script/ghcup_hls.sh
-
 test:linux:cross-armv7:
  stage: test
  extends:
@@ -390,19 +355,9 @@ test:mac:aarch64:

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

-test:freebsd12:
+test:freebsd:
  stage: test
-  extends: .test_ghcup_version:freebsd12
-  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
-  allow_failure: true # freebsd runners are unreliable
-  when: manual
-  needs: []
-
-test:freebsd13:
-  stage: test
-  extends: .test_ghcup_version:freebsd13
+  extends: .test_ghcup_version:freebsd
  variables:
    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
@@ -536,26 +491,11 @@ release:darwin:aarch64:

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

-release:freebsd12:
+release:freebsd:
  stage: release
-  needs: ["test:freebsd12"]
+  needs: ["test:freebsd"]
  extends:
-    - .freebsd12
-    - .release_ghcup
-    - .root_cleanup
-  before_script:
-    - ./.gitlab/before_script/freebsd/install_deps.sh
-  variables:
-    ARTIFACT: "x86_64-portbld-freebsd-ghcup"
-    GHC_VERSION: "8.10.6"
-    CABAL_VERSION: "3.4.0.0"
-  allow_failure: true
-
-release:freebsd13:
-  stage: release
-  needs: ["test:freebsd13"]
-  extends:
-    - .freebsd13
+    - .freebsd
    - .release_ghcup
    - .root_cleanup
  before_script:
@@ -587,9 +527,15 @@ release:windows:
 hlint:
  stage: hlint
  extends:
-    - .debian
+    - .alpine:64bit
+  before_script:
+    - ./.gitlab/before_script/linux/alpine/install_deps.sh
  script:
-    - curl -sSL https://raw.github.com/ndmitchell/hlint/master/misc/run.sh | sh -s -- -r lib/ test/
+    - ./.gitlab/script/hlint.sh
+  variables:
+    GHC_VERSION: "8.10.6"
+    CABAL_VERSION: "3.4.0.0"
+    JSON_VERSION: "0.0.4"
  allow_failure: true
  artifacts:
    expire_in: 2 week
--- a/.gitlab/before_script/freebsd/install_deps.sh
+++ b/.gitlab/before_script/freebsd/install_deps.sh
@@ -11,9 +11,9 @@ mkdir -p "${TMPDIR}"
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-portbld-freebsd-ghcup > ./ghcup-bin
 chmod +x ghcup-bin

-./ghcup-bin -v upgrade -i -f
-./ghcup-bin -v install ${GHC_VERSION}
-./ghcup-bin -v set ${GHC_VERSION}
-./ghcup-bin -v install-cabal ${CABAL_VERSION}
+./ghcup-bin upgrade -i -f
+./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}

 exit 0
--- a/.gitlab/before_script/linux/install_deps.sh
+++ b/.gitlab/before_script/linux/install_deps.sh
@@ -7,21 +7,67 @@ 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 gcc autoconf automake build-essential
+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

 if [ "${CROSS}" = "arm-linux-gnueabihf" ] ; then
-	sudo apt-get install -y gcc-arm-linux-gnueabihf
+	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

-export BOOTSTRAP_HASKELL_NONINTERACTIVE=1
-export BOOTSTRAP_HASKELL_GHC_VERSION=$GHC_VERSION
-export BOOTSTRAP_HASKELL_CABAL_VERSION=$CABAL_VERSION
-export BOOTSTRAP_HASKELL_VERBOSE=1
+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

-curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh
+		mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin

-rm "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/ghcup
+		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

--- a/.gitlab/ghc-8.10.3-linux.files
+++ b/.gitlab/ghc-8.10.3-linux.files
--- a/.gitlab/ghcup_env
+++ b/.gitlab/ghcup_env
@@ -1,11 +1,9 @@
 if [ "${OS}" = "WINDOWS" ] ; then
 	export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
-	export GHCUP_BIN="$CI_PROJECT_DIR/ghcup/bin"
-	export PATH="$GHCUP_BIN:$CI_PROJECT_DIR/.local/bin:$PATH"
+	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 GHCUP_BIN="$CI_PROJECT_DIR/.ghcup/bin"
-	export PATH="$GHCUP_BIN:$CI_PROJECT_DIR/.local/bin:/opt/llvm/bin:$PATH"
+	export PATH="$CI_PROJECT_DIR/.ghcup/bin:$CI_PROJECT_DIR/.local/bin:/opt/llvm/bin:$PATH"
 	export TMPDIR="$CI_PROJECT_DIR/tmp"
 fi
--- a/.gitlab/script/ghcup_bootstrap.sh
+++ b/.gitlab/script/ghcup_bootstrap.sh
@@ -24,7 +24,7 @@ export BOOTSTRAP_HASKELL_NONINTERACTIVE=yes
 export BOOTSTRAP_HASKELL_GHC_VERSION=$GHC_VERSION
 export BOOTSTRAP_HASKELL_CABAL_VERSION=$CABAL_VERSION

-./scripts/bootstrap/bootstrap-haskell
+./bootstrap-haskell

 [ "$(ghc --numeric-version)" = "${GHC_VERSION}" ]

--- a/.gitlab/script/ghcup_cross.sh
+++ b/.gitlab/script/ghcup_cross.sh
@@ -13,7 +13,7 @@ ecabal() {
 }

 eghcup() {
-	ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
+	ghcup -v -c -s file://$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
 }

 git describe --always
--- a/.gitlab/script/ghcup_git.sh
+++ b/.gitlab/script/ghcup_git.sh
@@ -13,7 +13,7 @@ ecabal() {
 }

 eghcup() {
-	ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
+	ghcup -v -c -s file://$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
 }

 git describe --always
--- a/.gitlab/script/ghcup_hls.sh
+++ b/.gitlab/script/ghcup_hls.sh
@@ -1,51 +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/data/metadata/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 hls -j $(nproc) -v ${HLS_TARGET_VERSION} ${GHC_VERSION}
-
-[ `$(eghcup whereis hls ${HLS_TARGET_VERSION}) --numeric-version` = "${HLS_TARGET_VERSION}" ] || [ `$(eghcup whereis hls ${HLS_TARGET_VERSION}) --numeric-version | sed 's/.0$//'` = "${HLS_TARGET_VERSION}" ]
-
-# nuke
-eghcup nuke
-[ ! -e "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup" ]
-
--- a/.gitlab/script/ghcup_version.sh
+++ b/.gitlab/script/ghcup_version.sh
@@ -18,9 +18,9 @@ raw_eghcup() {

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

@@ -92,7 +92,7 @@ rm -rf "${GHCUP_DIR}"
 ### manual cli based testing


-ghcup-gen check -f data/metadata/ghcup-${JSON_VERSION}.yaml
+ghcup-gen check -f ghcup-${JSON_VERSION}.yaml

 eghcup --numeric-version

@@ -101,10 +101,6 @@ eghcup install ghc ${GHC_VERSION}
 eghcup set ghc ${GHC_VERSION}
 eghcup install cabal ${CABAL_VERSION}
 [ `$(eghcup whereis cabal ${CABAL_VERSION}) --numeric-version` = "${CABAL_VERSION}" ]
-eghcup unset cabal
-"$GHCUP_BIN"/cabal --version && exit || echo yes
-eghcup set cabal ${CABAL_VERSION}
-[ `$(eghcup whereis cabal ${CABAL_VERSION}) --numeric-version` = "${CABAL_VERSION}" ]

 cabal --version

@@ -155,13 +151,9 @@ else
 	[ "$(ghc --numeric-version)" = "8.10.3" ]
 	eghcup set ${GHC_VERSION}
 	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-	eghcup unset ghc
-    "$GHCUP_BIN"/ghc --numeric-version && exit || echo yes
-	eghcup set ${GHC_VERSION}
 	eghcup --offline rm 8.10.3
 	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]

-
 	if [ "${OS}" = "DARWIN" ] ; then
 		eghcup install hls
 		$(eghcup whereis hls) --version
@@ -172,22 +164,18 @@ else
 		if [ "${ARCH}" = "64" ] ; then
 			eghcup install hls
 			haskell-language-server-wrapper --version
-			eghcup unset hls
-			"$GHCUP_BIN"/haskell-language-server-wrapper --version && exit || echo yes

 			eghcup install stack
 			stack --version
-			eghcup unset hls
-			"$GHCUP_BIN"/stack --version && exit || echo yes
 		fi
 	fi
 fi

 # check that lazy loading works for 'whereis'
-cp "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml" "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml.bak"
-echo '**' > "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml"
+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/data/metadata/ghcup-${JSON_VERSION}.yaml.bak" "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml"
+mv -f "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml.bak" "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml"

 eghcup rm $(ghc --numeric-version)

--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,35 +1,5 @@
 # Revision history for ghcup

-## 0.1.17.2 -- 2021-09-30
-
-* Honour GHC bootstrap compiler during git clone stages wrt [#250](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/250)
-* Speed up `unset` command
-* Fix `--overwrite-version` for `ghcup compile ghc` wrt [#253](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/253)
-* Apply patches before bootstrap
-
-## 0.1.17.1 -- 2021-09-26
-
-* Fix `NO_COLOR`
-* Fix `ghcup list -t` for hls/stack, wrt [#244](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/244)
-* Get rid of concurrent-output
-* Improve cli interface with partial versions (e.g. `ghcup install ghc 8`)
-* Fix HLS compilation builds
-* Implement `ghcup gc` (garbage collection) command
-
-## 0.1.17 -- 2021-09-20
-
-* Add `--force` option to install/compile wrt [#210](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/210) by Arjun Kathuria
-* Implement compiling HLS from source wrt [#201](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/201)
-* Implement experimental GPG verification of the metadata file (see README) wrt [#263](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/236)
-* Add `ghcup unset` command wrt [#145](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/145)
-* Add `ghcup whereis bindir` etc wrt [#221](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/221)
-* Greatly reduce dependency footprint wrt [#212](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/212)
-* Add `ghcup --plan-json`
-* Improve `--patchdir` option for GHC compilation wrt [#226](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/226)
-* Try to improve logging and failure modes, especially during downloads
-* Add descriptive warnings when HLS and GHC versions are incompatible
-* Improve curl header parsing wrt [#213](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/213)
-
 ## 0.1.16.2 -- 2021-08-12

 * Add isolated installations wrt [#141](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/141) by Arjun Kathuria
--- a/docs/dev.md
+++ b/docs/dev.md
@@ -1,18 +1,16 @@
-# Development
-
-All you wanted to know about development.
+# HACKING

 ## Design decisions

-#### Using [Excepts](https://hackage.haskell.org/package/haskus-utils-variant-3.0/docs/Haskus-Utils-Variant-Excepts.html) as a beefed up ExceptT
+### Using [Excepts](https://hackage.haskell.org/package/haskus-utils-variant-3.0/docs/Haskus-Utils-Variant-Excepts.html) as a beefed up ExceptT

 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 haskell-TLS
+### 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.

-#### Optics instead of lens
+### Optics instead of lens

 They're a little safer (less Monoid weirdness with view) and have better error messages. Consider the following wit lens

@@ -32,7 +30,7 @@ vs optics
      In an equation for ‘it’: it = view (_Just % to (++ "abc")) Nothing
 ```

-#### Strict and StrictData on by default
+### Strict and StrictData on by default

 Kazu Yamamoto [explained it in his PR](https://github.com/yesodweb/wai/pull/752#issuecomment-501531386) very well. I like to agree with him. The instances where we need non-strict behavior, we annotate it.

@@ -42,7 +40,7 @@ Kazu Yamamoto [explained it in his PR](https://github.com/yesodweb/wai/pull/752#
 2. mtl-style preferred
 3. no overly pointfree style

-#### Code structure
+## Code structure

 Main functionality is in `GHCup` module. Utility functions are
 organised tree-ish in `GHCup.Utils` and `GHCup.Utils.*`.
@@ -55,7 +53,7 @@ yaml files: `ghcup-<yaml-ver>.yaml`.

 ## Common Tasks

-#### Adding a new GHC version
+### Adding a new GHC version

 1. open the latest `ghcup-<yaml-ver>.yaml`
 2. find the latest ghc version (in yaml tree e.g. `ghcupDownloads -> GHC -> 8.10.3`)
@@ -75,26 +73,3 @@ yaml files: `ghcup-<yaml-ver>.yaml`.
   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.
-
-# Releasing
-
-1. Update version in `ghcup.cabal` and `boostrap-haskell` (`ghver` variable at the top of the script)
-
-2. Update `GHCup.Version` module. `ghcupURL` must only be updated if we change the `GHCupInfo` type or the YAML representation of it. The version of the YAML represents the change increments. `ghcUpVer` is the current application version, read from `ghcup.cabal`.
-
-3. Add ChangeLog entry
-
-4. Add/fix downloads in `ghcup-<ver>.yaml` (under `data/metadata`), then verify with `ghcup-gen check -f ghcup-<ver>.yaml` and possibly (example only) `ghcup-gen check-tarballs -f ghcup-<ver>.yaml -u 'ghc-8.10.7'`. Generally, new GHC/cabal/stack/hls versions are only added to the latest yaml file. New GHCup versions are added to all (great care must be taken here to not break the parser... e.g. ARM platforms don't parse in all older formats).
-
-5. Commit and git push with tag. Wait for tests to succeed and release artifacts to build.
-
-6. Download release artifacts and upload them `downloads.haskell.org/ghcup` along with checksum files (`sha256sum --tag * > SHA256SUMS && gpg --detach-sign -u <your-email> SHA256SUMS`)
-
-7. Add ghcup release artifacts to ALL yaml files (see point 4.)
-
-8. Upload the final `ghcup-<ver>.yaml` to `webhost.haskell.org/ghcup/data/`.
-
-9. Update `bootstrap-haskell` and `bootstrap-haskell.ps1` to `webhost.haskell.org/ghcup/sh/`
-
-10. Update the ghcup symlinks at `downloads.haskell.org/ghcup`
-
--- a/README.md
+++ b/README.md
@@ -1,11 +1,423 @@
-## The GHCup Haskell installer
+`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.
+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).
+
+## Table of Contents

 [![Join the chat at Libera.chat](https://img.shields.io/badge/chat-on%20libera%20IRC-brightgreen.svg)](https://kiwiirc.com/nextclient/irc.libera.chat/?nick=Guest%7C?#haskell,#haskell-ghcup)
 [![Join the chat at Matrix.org](https://img.shields.io/matrix/haskell-tooling:matrix.org?label=chat%20on%20matrix.org)](https://app.element.io/#/room/#haskell-tooling:matrix.org)
 [![Join the chat at Discord](https://img.shields.io/discord/280033776820813825?label=chat%20on%20discord)](https://discord.gg/pKYf3zDQU7)
 [![Join the chat at https://gitter.im/haskell/ghcup](https://badges.gitter.im/haskell/ghcup.svg)](https://gitter.im/haskell/ghcup?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-<a href="https://opencollective.com/ghcup#category-CONTRIBUTE"><img src="https://opencollective.com/webpack/donate/button@2x.png?color=blue" alt="Donate" width="150"></a>

-GHCup is an installer for the general purpose language [Haskell](https://www.haskell.org/).
+   * [Installation](#installation)
+     * [Simple bootstrap](#simple-bootstrap)
+     * [Manual install](#manual-install)
+     * [Vim integration](#vim-integration)
+   * [Usage](#usage)
+     * [Configuration](#configuration)
+     * [Manpages](#manpages)
+     * [Shell-completion](#shell-completion)
+     * [Cross support](#cross-support)
+     * [XDG support](#xdg-support)
+     * [Env variables](#env-variables)
+     * [Installing custom bindists](#installing-custom-bindists)
+     * [Isolated Installs](#isolated-installs)
+     * [Tips and tricks](#tips-and-tricks)
+   * [Design goals](#design-goals)
+   * [How](#how)
+   * [Known users](#known-users)
+   * [Known problems](#known-problems)
+   * [FAQ](#faq)

-See the [quick installation](https://www.haskell.org/ghcup/) or browse the [documentation](https://ghcup.readthedocs.io/en/latest/).
+## Installation
+
+### Simple bootstrap
+
+Follow the instructions at [https://www.haskell.org/ghcup/](https://www.haskell.org/ghcup/)
+
+### Manual install
+
+Download the binary for your platform at [https://downloads.haskell.org/~ghcup/](https://downloads.haskell.org/~ghcup/)
+and place it into your `PATH` anywhere.
+
+Then adjust your `PATH` in `~/.bashrc` (or similar, depending on your shell) like so:
+
+```sh
+export PATH="$HOME/.cabal/bin:$HOME/.ghcup/bin:$PATH"
+```
+
+### Vim integration
+
+See [ghcup.vim](https://github.com/hasufell/ghcup.vim).
+
+## Usage
+
+See `ghcup --help`.
+
+For the simple interactive TUI, run:
+
+```sh
+ghcup tui
+```
+
+For the full functionality via cli:
+
+```sh
+# list available ghc/cabal versions
+ghcup list
+
+# install the recommended GHC version
+ghcup install ghc
+
+# install a specific GHC version
+ghcup install ghc 8.2.2
+
+# set the currently "active" GHC version
+ghcup set ghc 8.4.4
+
+# install cabal-install
+ghcup install cabal
+
+# update ghcup itself
+ghcup upgrade
+```
+
+GHCup works very well 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
+
+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.
+
+### Manpages
+
+For man pages to work you need [man-db](http://man-db.nongnu.org/) as your `man` provider, then issue `man ghc`. Manpages only work for the currently set ghc.
+`MANPATH` may be required to be unset.
+
+### Shell-completion
+
+Shell completions are in `shell-completions`.
+
+For bash: install `shell-completions/bash`
+as e.g. `/etc/bash_completion.d/ghcup` (depending on distro)
+and make sure your bashrc sources the startup script
+(`/usr/share/bash-completion/bash_completion` on some distros).
+
+### Cross support
+
+ghcup can compile and install a cross GHC for any target. However, this
+requires that the build host has a complete cross toolchain and various
+libraries installed for the target platform.
+
+Consult the GHC documentation on the [prerequisites](https://gitlab.haskell.org/ghc/ghc/-/wikis/building/cross-compiling#tools-to-install).
+For distributions with non-standard locations of cross toolchain and
+libraries, this may need some tweaking of `build.mk` or configure args.
+See `ghcup compile ghc --help` for further information.
+
+### XDG support
+
+To enable XDG style directories, set the environment variable `GHCUP_USE_XDG_DIRS` to anything.
+
+Then you can control the locations via XDG environment variables as such:
+
+* `XDG_DATA_HOME`: GHCs will be unpacked in `ghcup/ghc` subdir (default: `~/.local/share`)
+* `XDG_CACHE_HOME`: logs and download files will be stored in `ghcup` subdir (default: `~/.cache`)
+* `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:
+
+* `GHCUP_USE_XDG_DIRS`: see [XDG support](#xdg-support) above
+* `TMPDIR`: where ghcup does the work (unpacking, building, ...)
+* `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
+
+There are a couple of good use cases to install custom bindists:
+
+1. manually built bindists (e.g. with patches)
+  - example: `ghcup install ghc -u 'file:///home/mearwald/tmp/ghc-eff-patches/ghc-8.10.2-x86_64-deb10-linux.tar.xz' 8.10.2-eff`
+2. GHC head CI bindists
+  - example: `ghcup install ghc -u 'https://gitlab.haskell.org/api/v4/projects/1/jobs/artifacts/master/raw/ghc-x86_64-fedora27-linux.tar.xz?job=validate-x86_64-linux-fedora27' head`
+3. DWARF bindists
+  - example: `ghcup install ghc -u 'https://downloads.haskell.org/~ghc/8.10.2/ghc-8.10.2-x86_64-deb10-linux-dwarf.tar.xz' 8.10.2-dwarf`
+
+Since the version parser is pretty lax, `8.10.2-eff` and `head` are both valid versions
+and produce the binaries `ghc-8.10.2-eff` and `ghc-head` respectively.
+GHCup always needs to know which version the bindist corresponds to (this is not automatically
+detected).
+
+### Isolated installs
+
+Ghcup also enables you to install a tool (GHC, Cabal, HLS, Stack) at an isolated location of your choosing.
+These installs, as the name suggests, are separate from your main installs and DO NOT conflict with them.
+
+
+- No symlinks are made to these isolated installed tools, you'd have to manually point to them wherever you intend to use them.
+
+- These installs, can also NOT be deleted from ghcup, you'd have to go and manually delete these.
+
+You need to use the `--isolate` or `-i` flag followed by the directory path.
+
+Examples:-
+
+1. install an isolated GHC version at location /home/user/isolated_dir/ghc/  
+   - `ghcup install ghc 8.10.5 --isolate /home/user/isolated_dir/ghc`
+
+2. isolated install Cabal at a location you desire  
+   - `ghcup install cabal --isolate /home/username/my_isolated_dir/`
+
+3. do an isolated install with a custom bindist  
+   - `ghcup install ghc --isolate /home/username/my_isolated_dir/ -u 'https://gitlab.haskell.org/api/v4/projects/1/jobs/artifacts/master/raw/ghc-x86_64-fedora27-linux.tar.xz?job=validate-x86_64-linux-fedora27' head`
+
+4. isolated install HLS  
+   - `ghcup install hls --isolate /home/username/dir/hls/`
+
+5. you can even compile ghc to an isolated location.  
+   - `ghcup compile ghc -j 4 -v 9.0.1 -b 8.10.5 -i /home/username/my/dir/ghc` 
+   ---  
+   
+### Tips and tricks
+
+#### with_ghc wrapper (e.g. for HLS)
+
+Due to some HLS [bugs](https://github.com/mpickering/hie-bios/issues/194) it's necessary that the `ghc` in PATH
+is the one defined in `cabal.project`. With some simple shell functions, we can start our editor with the appropriate
+path prepended.
+
+For bash, in e.g. `~/.bashrc` define:
+
+```sh
+with_ghc() {
+  local np=$(ghcup --offline whereis -d ghc $1 || { ghcup --cache install ghc $1 && ghcup whereis -d ghc $1 ;})
+  if [ -e "${np}" ] ; then
+    shift
+    PATH="$np:$PATH" "$@"
+  else
+    >&2 echo "Cannot find or install GHC version $1"
+    return 1
+  fi
+}
+```
+
+For fish shell, in e.g. `~/.config/fish/config.fish` define:
+
+```fish
+function with_ghc
+  set --local np (ghcup --offline whereis -d ghc $argv[1] ; or begin ghcup --cache install ghc $argv[1] ; and ghcup whereis -d ghc $argv[1] ; end)
+  if test -e "$np"
+    PATH="$np:$PATH" $argv[2..-1]
+  else
+    echo "Cannot find or install GHC version $argv[1]" 1>&2
+    return 1
+  end
+end
+```
+
+Then start a new shell and issue:
+
+```sh
+# replace 'code' with your editor
+with_ghc 8.10.5 code path/to/haskell/source
+```
+
+Cabal and HLS will now see `8.10.5` as the primary GHC, without the need to
+run `ghcup set` all the time when switching between projects.
+
+## Design goals
+
+1. simplicity
+2. non-interactive
+3. portable (eh)
+4. do one thing and do it well (UNIX philosophy)
+
+### Non-goals
+
+1. invoking `sudo`, `apt-get` or *any* package manager
+2. handling system packages
+3. handling cabal projects
+4. being a stack alternative
+
+## How
+
+Installs a specified GHC version into `~/.ghcup/ghc/<ver>`, and places `ghc-<ver>` symlinks in `~/.ghcup/bin/`.
+
+Optionally, an unversioned `ghc` link can point to a default version of your choice.
+
+This uses precompiled GHC binaries that have been compiled on fedora/debian by [upstream GHC](https://www.haskell.org/ghc/download_ghc_8_6_1.html#binaries).
+
+Alternatively, you can also tell it to compile from source (note that this might fail due to missing requirements).
+
+In addition this script can also install `cabal-install`.
+
+## Known users
+
+* Github action [haskell/actions/setup](https://github.com/haskell/actions/tree/main/setup)
+* [vabal](https://github.com/Franciman/vabal)
+
+## Known problems
+
+### Custom ghc version names
+
+When installing ghc bindists with custom version names as outlined in
+[installing custom bindists](#installing-custom-bindists), then cabal might
+be unable to find the correct `ghc-pkg` (also see [#73](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/73))
+if you use `cabal build --with-compiler=ghc-foo`. Instead, point it to the full path, such as:
+`cabal build --with-compiler=$HOME/.ghcup/ghc/<version-name>/bin/ghc` or set that GHC version
+as the current one via: `ghcup set ghc <version-name>`.
+
+This problem doesn't exist for regularly installed GHC versions.
+
+### Limited distributions supported
+
+Currently only GNU/Linux distributions compatible with the [upstream GHC](https://www.haskell.org/ghc/download_ghc_8_6_1.html#binaries) binaries are supported.
+
+### Precompiled binaries
+
+Since this uses precompiled binaries you may run into
+several problems.
+
+#### Missing libtinfo (ncurses)
+
+You may run into problems with *ncurses* and **missing libtinfo**, in case
+your distribution doesn't use the legacy way of building
+ncurses and has no compatibility symlinks in place.
+
+Ask your distributor on how to solve this or
+try to compile from source via `ghcup compile <version>`.
+
+#### Libnuma required
+
+This was a [bug](https://ghc.haskell.org/trac/ghc/ticket/15688) in the build system of some GHC versions that lead to
+unconditionally enabled libnuma support. To mitigate this you might have to install the libnuma
+package of your distribution. See [here](https://gitlab.haskell.org/haskell/ghcup/issues/58) for a discussion.
+
+### Compilation
+
+Although this script can compile GHC for you, it's just a very thin
+wrapper around the build system. It makes no effort in trying
+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
+
+### Why reimplement stack?
+
+GHCup is not a reimplementation of stack. The only common part is automatic installation of GHC,
+but even that differs in scope and design.
+
+### Why should I use ghcup over stack?
+
+GHCup is not a replacement for stack. Instead, it supports installing and managing stack versions.
+It does the same for cabal, GHC and HLS. As such, It doesn't make a workflow choice for you.
+
+### Why should I let ghcup manage stack?
+
+You don't need to. However, some users seem to prefer to have a central tool that manages cabal and stack
+at the same time. Additionally, it can allow better sharing of GHC installation across these tools.
+Also see:
+
+* https://docs.haskellstack.org/en/stable/yaml_configuration/#system-ghc
+* https://github.com/commercialhaskell/stack/pull/5585
+
+### Why does ghcup not use stack code?
+
+Oddly, this question has been asked a couple of times. For the curious, here are a few reasons:
+
+1. GHCup started as a shell script. At the time of rewriting it in Haskell, the authors didn't even know that stack exposes *some* of its [installation API](https://hackage.haskell.org/package/stack-2.5.1.1/docs/Stack-Setup.html)
+2. Even if they did, it doesn't seem it would have satisfied their needs
+	  - it didn't support cabal installation, which was the main motivation behind GHCup back then
+	  - depending on a codebase as big as stack for a central part of one's application without having a short contribution pipeline would likely have caused stagnation or resulted in simply copy-pasting the relevant code in order to adjust it
+	  - it's not clear how GHCup would have been implemented with the provided API. It seems the codebases are fairly different. GHCup does a lot of symlink handling to expose a central `bin/` directory that users can easily put in PATH, without having to worry about anything more. It also provides explicit removal functionality, GHC cross-compilation, a TUI, etc etc.
+3. GHCup is built around unix principles and supposed to be simple.
+
+### Why not unify...
+
+#### ...stack and Cabal and do away with standalone installers
+
+GHCup is not involved in such decisions. cabal-install and stack might have a
+sufficiently different user experience to warrant having a choice.
+
+#### ...installer implementations and have a common library
+
+This sounds like an interesting goal. However, GHC installation isn't a hard engineering problem
+and the shared code wouldn't be too exciting. For such an effort to make sense, all involved
+parties would need to collaborate and have a short pipeline to get patches in.
+
+It's true this would solve the integration problem, but following unix principles, we can
+do similar via **hooks**. Both cabal and stack can support installation hooks. These hooks
+can then call into ghcup or anything else, also see:
+
+* https://github.com/haskell/cabal/issues/7394
+* https://github.com/commercialhaskell/stack/pull/5585
+
+#### ...installers (like, all of it)
+
+So far, there hasn't been an **open** discussion about this. Is this even a good idea?
+Sometimes projects converge eventually if their overlap is big enough, sometimes they don't.
+
+While unification sounds like a simplification of the ecosystem, it also takes away choice.
+Take `curl` and `wget` as an example.
+
+How bad do we need this?
+
+### Why not support windows?
+
+Windows is supported since GHCup version 0.1.15.1.
+
+### 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.
+
+### Is GHCup affiliated with the Haskell Foundation?
+
+There has been some collaboration: Windows and Stack support were mainly requested by the Haskell Foundation
+and those seemed interesting features to add.
+
+Other than that, GHCup is dedicated only to its users and is supported by haskell.org through hosting and CI
+infrastructure.
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -0,0 +1,19 @@
+# RELEASING
+
+1. update `GHCup.Version` module. `ghcupURL` must only be updated if we change the `_toolRequirements` type or the YAML representation of it. The version of the YAML represents the change increments. `ghcUpVer` is the current application version.
+
+2. Update version in ghcup.cabal
+
+3. Add ChangeLog entry
+
+4. Add/fix downloads in `ghcup-<ver>.yaml`, then verify with `ghcup-gen check -f ghcup-<ver>.yaml`
+
+5. Commit and git push with tag. Wait for tests to succeed and release artifacts to build.
+
+6. Download release artifacts and upload them `downloads.haskell.org/ghcup`
+
+7. Add release artifacts to yaml file (see point 4.)
+
+8. Upload the final `ghcup-<ver>.yaml` to `webhost.haskell.org/ghcup/data/`.
+
+9. Update bootstrap-haskell and symlinks on `downloads.haskell.org/ghcup`
--- a/docs/TODO.md
+++ b/docs/TODO.md
--- a/app/ghcup-gen/Main.hs
+++ b/app/ghcup-gen/Main.hs
@@ -11,33 +11,22 @@
 module Main where

 import           GHCup.Types
-import           GHCup.Errors
-import           GHCup.Platform
-import           GHCup.Utils.Dirs
-import           GHCup.Utils.Logger
 import           GHCup.Types.JSON               ( )
+import           GHCup.Utils.Logger

-import           Control.Monad.Trans.Reader     ( runReaderT )
-import           Control.Monad.IO.Class
 import           Data.Char                      ( toLower )
-import           Data.Maybe
 #if !MIN_VERSION_base(4,13,0)
 import           Data.Semigroup                 ( (<>) )
 #endif
 import           Options.Applicative     hiding ( style )
-import           Haskus.Utils.Variant.Excepts
 import           System.Console.Pretty
-import           System.Environment
 import           System.Exit
-import           System.IO                      ( stderr )
+import           System.IO                      ( stdout )
 import           Text.Regex.Posix
 import           Validate
-import           Text.PrettyPrint.HughesPJClass ( prettyShow )

-import qualified Data.Text.IO                  as T
-import qualified Data.Text                     as T
 import qualified Data.ByteString               as B
-import qualified Data.YAML.Aeson               as Y
+import qualified Data.Yaml                     as Y


 data Options = Options
@@ -116,29 +105,10 @@ com = subparser

 main :: IO ()
 main = do
-  no_color <- isJust <$> lookupEnv "NO_COLOR"
-  let loggerConfig = LoggerConfig { lcPrintDebug  = True
-                                  , consoleOutter = T.hPutStr stderr
-                                  , fileOutter    = \_ -> pure ()
-                                  , fancyColors   = not no_color
-                                  }
-  dirs <- liftIO getAllDirs
-  let leanAppstate = LeanAppState (Settings True False Never Curl True GHCupURL False GPGNone False) dirs defaultKeyBindings loggerConfig
-
-  pfreq <- (
-    flip runReaderT leanAppstate . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound] $ platformRequest
-    ) >>= \case
-            VRight r -> pure r
-            VLeft e -> do
-              flip runReaderT leanAppstate $ logError $ T.pack $ prettyShow e
-              liftIO $ exitWith (ExitFailure 2)
-
-  let appstate = AppState (Settings True False Never Curl True GHCupURL False GPGNone False) dirs defaultKeyBindings (GHCupInfo mempty mempty mempty) pfreq loggerConfig
-
  _ <- customExecParser (prefs showHelpOnError) (info (opts <**> helper) idm)
    >>= \Options {..} -> case optCommand of
-          ValidateYAML vopts -> withValidateYamlOpts vopts (\dl m -> flip runReaderT appstate $ validate dl m)
-          ValidateTarballs vopts tarballFilter -> withValidateYamlOpts vopts (\dl m -> flip runReaderT appstate $ validateTarballs tarballFilter dl m)
+          ValidateYAML vopts -> withValidateYamlOpts vopts validate
+          ValidateTarballs vopts tarballFilter -> withValidateYamlOpts vopts (validateTarballs tarballFilter)
  pure ()

 where
@@ -150,8 +120,8 @@ main = do
    ValidateYAMLOpts { vInput = Just (FileInput file) } ->
      B.readFile file >>= valAndExit f
  valAndExit f contents = do
-    (GHCupInfo _ av gt) <- case Y.decode1Strict contents of
+    (GHCupInfo _ av gt) <- case Y.decodeEither' contents of
      Right r -> pure r
-      Left  (_, e) -> die (color Red $ show e)
-    f av gt
+      Left  e -> die (color Red $ show e)
+    myLoggerT (LoggerConfig True (B.hPut stdout) (\_ -> pure ())) (f av gt)
      >>= exitWith
--- a/app/ghcup-gen/Validate.hs
+++ b/app/ghcup-gen/Validate.hs
@@ -12,7 +12,8 @@ module Validate where
 import           GHCup
 import           GHCup.Download
 import           GHCup.Errors
-import           GHCup.Types
+import           GHCup.Platform
+import           GHCup.Types                  hiding ( LeanAppState (..) )
 import           GHCup.Types.Optics
 import           GHCup.Utils
 import           GHCup.Utils.Logger
@@ -23,6 +24,7 @@ import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Class
+import           Control.Monad.Logger
 import           Control.Monad.Reader.Class
 import           Control.Monad.Trans.Class      ( lift )
 import           Control.Monad.Trans.Reader     ( runReaderT )
@@ -37,10 +39,12 @@ import           Haskus.Utils.Variant.Excepts
 import           Optics
 import           System.FilePath
 import           System.Exit
+import           System.IO
 import           Text.ParserCombinators.ReadP
 import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           Text.Regex.Posix

+import qualified Data.ByteString               as B
 import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 import qualified Data.Version                  as V
@@ -58,7 +62,7 @@ addError = do
  liftIO $ modifyIORef ref (+ 1)


-validate :: (Monad m, MonadReader env m, HasLog env, MonadThrow m, MonadIO m, MonadUnliftIO m)
+validate :: (Monad m, MonadLogger m, MonadThrow m, MonadIO m, MonadUnliftIO m)
         => GHCupDownloads
         -> M.Map GlobalTool DownloadInfo
         -> m ExitCode
@@ -85,23 +89,23 @@ validate dls _ = do
    if e > 0
      then pure $ ExitFailure e
      else do
-        lift $ logInfo "All good"
+        lift $ $(logInfo) "All good"
        pure ExitSuccess
 where
  checkHasRequiredPlatforms t v tags arch pspecs = do
    let v' = prettyVer v
        arch' = prettyShow arch
    when (notElem (Linux UnknownLinux) pspecs) $ do
-      lift $ logError $
+      lift $ $(logError) $
        "Linux UnknownLinux missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
      addError
    when ((notElem Darwin pspecs) && arch == A_64) $ do
-      lift $ logError $ "Darwin missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
+      lift $ $(logError) $ "Darwin missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
      addError
-    when ((notElem FreeBSD pspecs) && arch == A_64) $ lift $ logWarn $
+    when ((notElem FreeBSD pspecs) && arch == A_64) $ lift $ $(logWarn) $
      "FreeBSD missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
    when (notElem Windows pspecs && arch == A_64) $ do
-      lift $ logError $ "Windows missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
+      lift $ $(logError) $ "Windows missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
      addError

    -- alpine needs to be set explicitly, because
@@ -109,12 +113,12 @@ validate dls _ = do
    -- (although it could be static)
    when (notElem (Linux Alpine) pspecs) $
      case t of
-        GHCup | arch `elem` [A_64, A_32] -> lift (logError $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch)) >> addError
+        GHCup | arch `elem` [A_64, A_32] -> lift ($(logError) $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch)) >> addError
        Cabal | v > [vver|2.4.1.0|]
-              , arch `elem` [A_64, A_32] -> lift (logError $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch)) >> addError
+              , arch `elem` [A_64, A_32] -> lift ($(logError) $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch)) >> addError
        GHC | Latest `elem` tags || Recommended `elem` tags
-            , arch `elem` [A_64, A_32] -> lift (logError $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch))
-        _ -> lift $ logWarn $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch)
+            , arch `elem` [A_64, A_32] -> lift ($(logError) $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch))
+        _ -> lift $ $(logWarn) $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch)

  checkUniqueTags tool = do
    let allTags = join $ fmap _viTags $ M.elems $ availableToolVersions dls tool
@@ -134,7 +138,7 @@ validate dls _ = do
    case join nonUnique of
      [] -> pure ()
      xs -> do
-        lift $ logError $ "Tags not unique for " <> T.pack (prettyShow tool) <> ": " <> T.pack (prettyShow xs)
+        lift $ $(logError) $ "Tags not unique for " <> T.pack (prettyShow tool) <> ": " <> T.pack (prettyShow xs)
        addError
   where
    isUniqueTag Latest         = True
@@ -150,7 +154,7 @@ validate dls _ = do
      case [ x | (x,"") <- readP_to_S V.parseVersion (T.unpack . prettyVer $ v) ] of
        [_] -> pure ()
        _   -> do
-          lift $ logError $ "GHC version " <> prettyVer v <> " is not valid"
+          lift $ $(logError) $ "GHC version " <> prettyVer v <> " is not valid"
          addError

  -- a tool must have at least one of each mandatory tags
@@ -158,7 +162,7 @@ validate dls _ = do
    let allTags = join $ fmap _viTags $ M.elems $ availableToolVersions dls tool
    forM_ [Latest, Recommended] $ \t -> case elem t allTags of
      False -> do
-        lift $ logError $ "Tag " <> T.pack (prettyShow t) <> " missing from " <> T.pack (prettyShow tool)
+        lift $ $(logError) $ "Tag " <> T.pack (prettyShow t) <> " missing from " <> T.pack (prettyShow tool)
        addError
      True -> pure ()

@@ -167,7 +171,7 @@ validate dls _ = do
    let allTags = M.toList $ availableToolVersions dls GHC
    forM allTags $ \(ver, _viTags -> tags) -> case any isBase tags of
      False -> do
-        lift $ logError $ "Base tag missing from GHC ver " <> prettyVer ver
+        lift $ $(logError) $ "Base tag missing from GHC ver " <> prettyVer ver
        addError
      True -> pure ()

@@ -180,10 +184,7 @@ data TarballFilter = TarballFilter
  }

 validateTarballs :: ( Monad m
-                    , MonadReader env m
-                    , HasLog env
-                    , HasDirs env
-                    , HasSettings env
+                    , MonadLogger m
                    , MonadThrow m
                    , MonadIO m
                    , MonadUnliftIO m
@@ -198,39 +199,46 @@ validateTarballs :: ( Monad m
 validateTarballs (TarballFilter etool versionRegex) dls gt = do
  ref <- liftIO $ newIORef 0

-   -- 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 "no tarballs selected by filter" *> (flip runReaderT ref addError)
-  forM_ allDls (downloadAll ref)
+  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) "no tarballs selected by filter" *> addError
+    forM_ allDls downloadAll

-  -- exit
-  e <- liftIO $ readIORef ref
-  if e > 0
-    then pure $ ExitFailure e
-    else do
-      logInfo "All good"
-      pure ExitSuccess
+    -- exit
+    e <- liftIO $ readIORef ref
+    if e > 0
+      then pure $ ExitFailure e
+      else do
+        lift $ $(logInfo) "All good"
+        pure ExitSuccess

 where
-  downloadAll :: ( MonadUnliftIO m
-                 , MonadIO m
-                 , MonadReader env m
-                 , HasLog env
-                 , HasDirs env
-                 , HasSettings env
-                 , MonadCatch m
-                 , MonadMask m
-                 , MonadThrow m
-                 )
-              => IORef Int
-              -> DownloadInfo
-              -> m ()
-  downloadAll ref dli = do
-    r <- runResourceT
+  runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
+                                     , colorOutter  = B.hPut stderr
+                                     , 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 True GHCupURL False) dirs defaultKeyBindings (GHCupInfo mempty mempty mempty) pfreq
+
+    r <-
+      runLogger
+      . flip runReaderT appstate
+      . runResourceT
      . runE @'[DigestError
-               , GPGError
               , DownloadFailed
               , UnknownArchive
               , ArchiveResult
@@ -239,7 +247,7 @@ validateTarballs (TarballFilter etool versionRegex) dls gt = do
        case etool of
          Right (Just GHCup) -> do
            tmpUnpack <- lift mkGhcupTmpDir
-            _ <- liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) tmpUnpack Nothing False
+            _ <- liftE $ download (_dlUri dli) (Just (_dlHash dli)) tmpUnpack Nothing False
            pure Nothing
          Right _ -> do
            p <- liftE $ downloadCached dli Nothing
@@ -249,32 +257,32 @@ validateTarballs (TarballFilter etool versionRegex) dls gt = do
              $ p
          Left ShimGen -> do
            tmpUnpack <- lift mkGhcupTmpDir
-            _ <- liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) tmpUnpack Nothing False
+            _ <- 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
-            logInfo
+            lift $ $(logInfo)
              $ " verifying subdir: " <> T.pack prel
            when (basePath /= prel) $ do
-              logError $
+              lift $ $(logError) $
                "Subdir doesn't match: expected " <> T.pack prel <> ", got " <> T.pack basePath
-              (flip runReaderT ref addError)
+              addError
          Just (RegexDir regexString) -> do
-            logInfo $
+            lift $ $(logInfo) $
              "verifying subdir (regex): " <> T.pack regexString
            let regex = makeRegexOpts
                  compIgnoreCase
                  execBlank
                  regexString
            when (not (match regex basePath)) $ do
-              logError $
+              lift $ $(logError) $
                "Subdir doesn't match: expected regex " <> T.pack regexString <> ", got " <> T.pack basePath
-              (flip runReaderT ref addError)
+              addError
          Nothing -> pure ()
      VRight Nothing -> pure ()
      VLeft  e -> do
-        logError $
+        lift $ $(logError) $
          "Could not download (or verify hash) of " <> T.pack (show dli) <> ", Error was: " <> T.pack (prettyShow e)
-        (flip runReaderT ref addError)
+        addError
--- a/app/ghcup/BrickMain.hs
+++ b/app/ghcup/BrickMain.hs
@@ -15,9 +15,9 @@ import           GHCup.Download
 import           GHCup.Errors
 import           GHCup.Types         hiding ( LeanAppState(..) )
 import           GHCup.Utils
-import           GHCup.Utils.Logger
 import           GHCup.Utils.Prelude ( decUTF8Safe )
 import           GHCup.Utils.File
+import           GHCup.Utils.Logger

 import           Brick
 import           Brick.Widgets.Border
@@ -29,6 +29,7 @@ import           Brick.Widgets.List             ( listSelectedFocusedAttr
                                                )
 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
@@ -43,6 +44,7 @@ import           Data.Vector                    ( Vector
 import           Data.Versions           hiding ( str )
 import           Haskus.Utils.Variant.Excepts
 import           Prelude                 hiding ( appendFile )
+import           System.Environment
 import           System.Exit
 import           System.IO.Unsafe
 import           Text.PrettyPrint.HughesPJClass ( prettyShow )
@@ -415,8 +417,12 @@ install' :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadFail m, Monad
 install' _ (_, ListResult {..}) = do
  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask

+  l        <- liftIO $ readIORef logger'
+  let runLogger = myLoggerT l
+
  let run =
-        runResourceT
+        runLogger
+          . runResourceT
          . runE
            @'[ AlreadyInstalled
              , ArchiveResult
@@ -428,7 +434,6 @@ install' _ (_, ListResult {..}) = do
              , BuildFailed
              , TagNotFound
              , DigestError
-              , GPGError
              , DownloadFailed
              , DirNotEmpty
              , NoUpdate
@@ -440,24 +445,24 @@ install' _ (_, ListResult {..}) = do
      case lTool of
        GHC   -> do
          let vi = getVersionInfo lVer GHC dls
-          liftE $ installGHCBin lVer Nothing False $> vi
+          liftE $ installGHCBin lVer Nothing $> vi
        Cabal -> do
          let vi = getVersionInfo lVer Cabal dls
-          liftE $ installCabalBin lVer Nothing False $> vi
+          liftE $ installCabalBin lVer Nothing $> vi
        GHCup -> do
          let vi = snd <$> getLatest dls GHCup
          liftE $ upgradeGHCup Nothing False $> vi
        HLS   -> do
          let vi = getVersionInfo lVer HLS dls
-          liftE $ installHLSBin lVer Nothing False $> vi
+          liftE $ installHLSBin lVer Nothing $> vi
        Stack -> do
          let vi = getVersionInfo lVer Stack dls
-          liftE $ installStackBin lVer Nothing False $> vi
+          liftE $ installStackBin lVer Nothing $> vi
    )
    >>= \case
          VRight vi                         -> do
            forM_ (_viPostInstall =<< vi) $ \msg ->
-              logInfo msg
+              myLoggerT l $ $(logInfo) msg
            pure $ Right ()
          VLeft  (V (AlreadyInstalled _ _)) -> pure $ Right ()
          VLeft (V NoUpdate) -> pure $ Right ()
@@ -468,9 +473,12 @@ install' _ (_, ListResult {..}) = do
 set' :: BrickState -> (Int, ListResult) -> IO (Either String ())
 set' _ (_, ListResult {..}) = do
  settings <- readIORef settings'
+  l        <- readIORef logger'
+  let runLogger = myLoggerT l

  let run =
-        flip runReaderT settings
+        runLogger
+          . flip runReaderT settings
          . runE @'[FileDoesNotExistError , NotInstalled , TagNotFound]

  run (do
@@ -493,7 +501,9 @@ del' :: (MonadReader AppState m, MonadIO m, MonadFail m, MonadMask m, MonadUnlif
 del' _ (_, ListResult {..}) = do
  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask

-  let run = runE @'[NotInstalled]
+  l <- liftIO $ readIORef logger'
+  let runLogger = myLoggerT l
+  let run = myLoggerT l . runE @'[NotInstalled]

  run (do
      let vi = getVersionInfo lVer lTool dls
@@ -507,7 +517,7 @@ del' _ (_, ListResult {..}) = do
    >>= \case
          VRight vi -> do
            forM_ (join $ fmap _viPostRemove vi) $ \msg ->
-              logInfo msg
+              runLogger $ $(logInfo) msg
            pure $ Right ()
          VLeft  e -> pure $ Left (prettyShow e)

@@ -536,11 +546,6 @@ settings' :: IORef AppState
 {-# NOINLINE settings' #-}
 settings' = unsafePerformIO $ do
  dirs <- getAllDirs
-  let loggerConfig = LoggerConfig { lcPrintDebug  = False
-                                  , consoleOutter = \_ -> pure ()
-                                  , fileOutter    = \_ -> pure ()
-                                  , fancyColors   = True
-                                  }
  newIORef $ AppState (Settings { cache      = True
                                , noVerify   = False
                                , keepDirs   = Never
@@ -548,28 +553,41 @@ settings' = unsafePerformIO $ do
                                , verbose    = False
                                , urlSource  = GHCupURL
                                , noNetwork  = False
-                                , gpgSetting = GPGNone
-                                , noColor    = False
                                , ..
                                })
                      dirs
                      defaultKeyBindings
                      (GHCupInfo mempty mempty mempty)
                      (PlatformRequest A_64 Darwin Nothing)
-                      loggerConfig



+logger' :: IORef LoggerConfig
+{-# NOINLINE logger' #-}
+logger' = unsafePerformIO
+  (newIORef $ LoggerConfig { lcPrintDebug = False
+                           , colorOutter  = \_ -> pure ()
+                           , rawOutter    = \_ -> pure ()
+                           }
+  )
+
+
 brickMain :: AppState
+          -> LoggerConfig
          -> IO ()
-brickMain s = do
+brickMain s l = do
  writeIORef settings' s
+  -- logger interpreter
+  writeIORef logger'   l
+  let runLogger = myLoggerT l
+
+  no_color <- isJust <$> lookupEnv "NO_COLOR"

  eAppData <- getAppData (Just $ ghcupInfo s)
  case eAppData of
    Right ad ->
      defaultMain
-          (app (defaultAttributes (noColor $ settings s)) (dimAttributes (noColor $ settings s)))
+          (app (defaultAttributes no_color) (dimAttributes no_color))
          (BrickState ad
                    defaultAppSettings
                    (constructList ad defaultAppSettings Nothing)
@@ -578,7 +596,7 @@ brickMain s = do
          )
        $> ()
    Left e -> do
-      flip runReaderT s $ logError $ "Error building app state: " <> T.pack (show e)
+      runLogger ($(logError) $ "Error building app state: " <> T.pack (show e))
      exitWith $ ExitFailure 2


@@ -589,10 +607,13 @@ defaultAppSettings = BrickSettings { showAllVersions = False, showAllTools = Fal
 getGHCupInfo :: IO (Either String GHCupInfo)
 getGHCupInfo = do
  settings <- readIORef settings'
+  l        <- readIORef logger'
+  let runLogger = myLoggerT l

  r <-
-    flip runReaderT settings
-    . runE @'[DigestError, GPGError, JSONError , DownloadFailed , FileDoesNotExistError]
+    runLogger
+    . flip runReaderT settings
+    . runE @'[JSONError , DownloadFailed , FileDoesNotExistError]
    $ liftE
    $ getDownloadsF

@@ -604,11 +625,14 @@ getGHCupInfo = do
 getAppData :: Maybe GHCupInfo
           -> IO (Either String BrickData)
 getAppData mgi = runExceptT $ do
+  l        <- liftIO $ readIORef logger'
+  let runLogger = myLoggerT l
+
  r <- ExceptT $ maybe getGHCupInfo (pure . Right) mgi
  liftIO $ modifyIORef settings' (\s -> s { ghcupInfo = r })
  settings <- liftIO $ readIORef settings'

-  flip runReaderT settings $ do
+  runLogger . flip runReaderT settings $ do
    lV <- listVersions Nothing Nothing
    pure $ BrickData (reverse lV)

--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
--- a/scripts/bootstrap/bootstrap-haskell
+++ b/scripts/bootstrap/bootstrap-haskell
@@ -1,13 +1,8 @@
 #!/bin/sh

-# This script downloads the 'ghcup' binary into '~/.ghcup/bin/' and then runs an interactive
-# installation that lets you choose various options. Below is a list of environment variables
-# that affect the installation procedure.
-
 # Main settings:
 #   * BOOTSTRAP_HASKELL_NONINTERACTIVE - any nonzero value for noninteractive installation
 #   * BOOTSTRAP_HASKELL_NO_UPGRADE - any nonzero value to not trigger the upgrade
-#   * BOOTSTRAP_HASKELL_MINIMAL - any nonzero value to only install ghcup
 #   * 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
@@ -25,7 +20,7 @@

 plat="$(uname -s)"
 arch=$(uname -m)
-ghver="0.1.17.2"
+ghver="0.1.16.2"
 base_url="https://downloads.haskell.org/~ghcup"

 export GHCUP_SKIP_UPDATE_CHECK=yes
@@ -56,57 +51,41 @@ esac


 die() {
-    if [ -n "${NO_COLOR}" ] ; then
-        (>&2 printf "%s\\n" "$1")
-    else
-        (>&2 printf "\\033[0;31m%s\\033[0m\\n" "$1")
-    fi
+    (>&2 printf "\\033[0;31m%s\\033[0m\\n" "$1")
    exit 2
 }

 warn() {
-    if [ -n "${NO_COLOR}" ] ; then
-        printf "%s\\n" "$1"
-    else
-        case "${plat}" in
-                MSYS*|MINGW*)
-                    echo -e "\\033[0;35m$1\\033[0m"
-                    ;;
-                *)
-                    printf "\\033[0;35m%s\\033[0m\\n" "$1"
-                    ;;
-        esac
-    fi
+	case "${plat}" in
+			MSYS*|MINGW*)
+				echo -e "\\033[0;35m$1\\033[0m"
+				;;
+			*)
+				printf "\\033[0;35m%s\\033[0m\\n" "$1"
+				;;
+	esac
 }

 yellow() {
-    if [ -n "${NO_COLOR}" ] ; then
-        printf "%s\\n" "$1"
-    else
-        case "${plat}" in
-                MSYS*|MINGW*)
-                    echo -e "\\033[0;33m$1\\033[0m"
-                    ;;
-                *)
-                    printf "\\033[0;33m%s\\033[0m\\n" "$1"
-                    ;;
-        esac
-    fi
+	case "${plat}" in
+			MSYS*|MINGW*)
+				echo -e "\\033[0;33m$1\\033[0m"
+				;;
+			*)
+				printf "\\033[0;33m%s\\033[0m\\n" "$1"
+				;;
+	esac
 }

 green() {
-    if [ -n "${NO_COLOR}" ] ; then
-        printf "%s\\n" "$1"
-    else
-        case "${plat}" in
-                MSYS*|MINGW*)
-                    echo -e "\\033[0;32m$1\\033[0m"
-                    ;;
-                *)
-                    printf "\\033[0;32m%s\\033[0m\\n" "$1"
-                    ;;
-        esac
-    fi
+	case "${plat}" in
+			MSYS*|MINGW*)
+				echo -e "\\033[0;32m$1\\033[0m"
+				;;
+			*)
+				printf "\\033[0;32m%s\\033[0m\\n" "$1"
+				;;
+	esac
 }

 edo() {
@@ -120,7 +99,7 @@ eghcup() {
 _eghcup() {
 	if [ -n "${BOOTSTRAP_HASKELL_YAML}" ] ; then
 		args="-s ${BOOTSTRAP_HASKELL_YAML}"
-	fi
+	fi 
    if [ -z "${BOOTSTRAP_HASKELL_VERBOSE}" ] ; then
        "${GHCUP_BIN}/ghcup" ${args} "$@"
    else
@@ -196,29 +175,13 @@ download_ghcup() {
 					_url=${base_url}/${ghver}/armv7-linux-ghcup-${ghver}
 					;;
 				aarch64|arm64|armv8l)
-					# 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}/armv7-linux-ghcup-${ghver}
-					elif [ "$(getconf LONG_BIT)" = "64" ] ; then
-						_url=${base_url}/${ghver}/aarch64-linux-ghcup-${ghver}
-					else
-						die "Unknown long bit size: $(getconf LONG_BIT)"
-					fi
+					_url=${base_url}/${ghver}/aarch64-linux-ghcup-${ghver}
 					;;
 				*) die "Unknown architecture: ${arch}"
 					;;
 			esac
 			;;
        "FreeBSD"|"freebsd")
-            if freebsd-version | grep -E '^12.*' ; then
-                freebsd_ver=12
-            elif freebsd-version | grep -E '^13.*' ; then
-                freebsd_ver=13
-            else
-                die "Unsupported FreeBSD version! Please report a bug at https://gitlab.haskell.org/haskell/ghcup-hs/-/issues"
-            fi
-
 			case "${arch}" in
 				x86_64|amd64)
 					;;
@@ -228,7 +191,7 @@ download_ghcup() {
 				*) die "Unknown architecture: ${arch}"
 					;;
 			esac
-			_url=${base_url}/${ghver}/x86_64-portbld-freebsd${freebsd_ver}-ghcup-${ghver}
+			_url=${base_url}/${ghver}/x86_64-portbld-freebsd-ghcup-${ghver}
            ;;
        "Darwin"|"darwin")
 			case "${arch}" in
@@ -329,7 +292,16 @@ ask_bashrc() {

 			read -r bashrc_answer </dev/tty
 		else
-			return 0
+			# 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]* | "")
@@ -399,13 +371,6 @@ adjust_bashrc() {
 								echo "[[ -f ~/.bashrc ]] && source ~/.bashrc # ghcup-env" >> "${HOME}/.bash_profile"
 							fi
 							;;
-						MSYS*|MINGW*)
-							if [ ! -e "${HOME}/.bash_profile" ] ; then
-								echo '# generated by ghcup' > "${HOME}/.bash_profile"
-								echo 'test -f ~/.profile && . ~/.profile' >> "${HOME}/.bash_profile"
-								echo 'test -f ~/.bashrc && . ~/.bashrc' >> "${HOME}/.bash_profile"
-							fi
-							;;
 					esac
 					break ;;

@@ -433,7 +398,7 @@ warn_path() {
 	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 to run 'source $GHCUP_DIR/env' in your current terminal"
+	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)."

 }
@@ -626,12 +591,10 @@ ask_bashrc
 ask_bashrc_answer=$?
 ask_cabal_config_init
 ask_cabal_config_init_answer=$?
-if [ -z "${BOOTSTRAP_HASKELL_MINIMAL}" ] ; then
-	ask_hls
-	ask_hls_answer=$?
-	ask_stack
-	ask_stack_answer=$?
-fi
+ask_hls
+ask_hls_answer=$?
+ask_stack
+ask_stack_answer=$?

 edo mkdir -p "${GHCUP_BIN}"

@@ -657,30 +620,14 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
    read -r answer </dev/tty
 fi

-if [ -z "${BOOTSTRAP_HASKELL_MINIMAL}" ] ; then
-	eghcup --cache install ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
+eghcup --cache install ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"

-	eghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
-	eghcup --cache install cabal "${BOOTSTRAP_HASKELL_CABAL_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
+do_cabal_config_init $ask_cabal_config_init_answer

-	edo cabal new-update
-else # don't install ghc and cabal
-	case "${plat}" in
-			MSYS*|MINGW*)
-				# need to bootstrap cabal to initialize config on windows
-				# we'll remove it afterwards
-				tmp_dir="$(mktemp -d)"
-				eghcup --cache install cabal -i "${tmp_dir}" "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
-				PATH="${tmp_dir}:$PATH" do_cabal_config_init $ask_cabal_config_init_answer
-				rm "${tmp_dir}/cabal"
-				unset tmp_dir
-				;;
-			*)
-				;;
-	esac
-fi
+edo cabal new-update

 case $ask_hls_answer in
 	1)
@@ -705,3 +652,4 @@ _done
 )

 # vim: tabstop=4 shiftwidth=4 expandtab
+
--- a/scripts/bootstrap/bootstrap-haskell.ps1
+++ b/scripts/bootstrap/bootstrap-haskell.ps1
@@ -11,32 +11,28 @@
    * 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"
-    
-	By default, the installation is non-interactive, unless you run it with 'Interactive $true'.
 #>
 param (
    # Run an interactive installation
    [switch]$Interactive,
-    # Do minimal installation of ghcup and msys2 only
-    [switch]$Minimal,
-    # Run the final bootstrap script via 'bash' instead of a full newly spawned msys2 shell
-    [switch]$InBash,
+    # 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,
-    # Skip adjusting cabal.config with mingw paths
-    [switch]$NoAdjustCabalConfig,
+    # 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,
-    # Specify the bootstrap url (default: 'https://www.haskell.org/ghcup/sh/bootstrap-haskell')
-    [string]$InstallDir,
-    # Instead of installing a new MSys2, use an existing installation
-    [string]$BootstrapUrl,
-    # Specify the install root (default: 'C:\')
-    [string]$ExistingMsys2Dir,
-    # Specify the cabal root directory (default: '$InstallDir\cabal')
-    [string]$CabalDir
+    # Skip adjusting cabal.config with mingw paths
+    [switch]$NoAdjustCabalConfig
 )

 $Silent = !$Interactive
@@ -184,7 +180,7 @@ elevated command prompt:

 if ($GhcupBasePrefixEnv) {
  $defaultGhcupBasePrefix = $GhcupBasePrefixEnv
-} elseif (!($InstallDir)) {
+} else {
  $partitions = Get-CimInstance win32_logicaldisk
  $defaultGhcupBasePrefix = $null
  foreach ($p in $partitions){
@@ -213,10 +209,10 @@ 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! (InstallDir)"
+    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! (InstallDir)"
+    Print-Msg -color Red -msg "Non-absolute Path specified!"
    Exit 1
  } else {
    $GhcupBasePrefix = $InstallDir
@@ -247,20 +243,7 @@ $null = [Environment]::SetEnvironmentVariable("GHCUP_INSTALL_BASE_PREFIX", $Ghcu


 $GhcupDir = ('{0}\ghcup' -f $GhcupBasePrefix)
-if ($ExistingMsys2Dir) {
-  if (!(Test-Path -LiteralPath ('{0}' -f $ExistingMsys2Dir) -IsValid)) {
-    Print-Msg -color Red -msg "Not a valid directory! (ExistingMsys2Dir)"
-    Exit 1
-  } elseif (!(Split-Path -IsAbsolute -Path "$ExistingMsys2Dir")) {
-    Print-Msg -color Red -msg "Non-absolute Path specified! (ExistingMsys2Dir)"
-    Exit 1
-  } else {
-	$MsysDir = $ExistingMsys2Dir
-  }
-} else {
-	$MsysDir = ('{0}\msys64' -f $GhcupDir)
-}
-
+$MsysDir = ('{0}\msys64' -f $GhcupDir)
 $Bash = ('{0}\usr\bin\bash' -f $MsysDir)
 if (!($BootstrapUrl)) {
  $BootstrapUrl = 'https://www.haskell.org/ghcup/sh/bootstrap-haskell'
@@ -415,7 +398,6 @@ if (!(Test-Path -Path ('{0}' -f $MsysDir))) {

    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) {
@@ -547,14 +529,10 @@ if (!($NoAdjustCabalConfig)) {
  $AdjustCabalConfigExport = 'export BOOTSTRAP_HASKELL_ADJUST_CABAL_CONFIG=1 ;'
 }

-if ($Minimal) {
-  $MinimalExport = 'export BOOTSTRAP_HASKELL_MINIMAL=1 ;'
-}
-
 if ((Get-Process -ID $PID).ProcessName.StartsWith("bootstrap-haskell") -Or $InBash) {
-  Exec "$Bash" '-lc' ('{4} {6} {7} {8} {9} [ -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, $MinimalExport)
+  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} {9} [ -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, $MinimalExport)
+  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)
 }


--- a/cabal.ghc8105.project
+++ b/cabal.ghc8105.project
@@ -0,0 +1,33 @@
+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.ghc8105.project.freeze
+++ b/cabal.ghc8105.project.freeze
@@ -1,19 +1,15 @@
 active-repositories: hackage.haskell.org:merge
-constraints: any.Cabal ==3.2.1.0 || ==3.6.1.0,
-             Cabal -bundled-binary-generic,
+constraints: any.Cabal ==3.2.1.0,
             any.HUnit ==1.6.2.0,
-             any.HsOpenSSL ==0.11.7.2,
+             any.HsOpenSSL ==0.11.7,
             HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
-             any.HsYAML ==0.2.1.0,
-             HsYAML -exe,
-             any.HsYAML-aeson ==0.2.0.0,
             any.QuickCheck ==2.14.2,
             QuickCheck -old-random +templatehaskell,
             any.StateVar ==1.2.2,
             any.aeson ==1.5.6.0,
             aeson -bytestring-builder -cffi -developer -fast,
             any.aeson-pretty ==0.8.8,
-             aeson-pretty +lib-only,
+             aeson-pretty -lib-only,
             any.alex ==3.2.6,
             alex +small_base,
             any.ansi-terminal ==0.11,
@@ -26,42 +22,51 @@ constraints: any.Cabal ==3.2.1.0 || ==3.6.1.0,
             async -bench,
             any.attoparsec ==0.13.2.5,
             attoparsec -developer,
-             any.base ==4.14.3.0,
-             any.base-compat ==0.12.0,
-             any.base-compat-batteries ==0.12.0,
-             any.base-orphans ==0.8.5,
+             any.auto-update ==0.1.6,
+             any.base ==4.14.2.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,
             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.64.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,
             c2hs +base3 -regression,
-             any.cabal-plan ==0.7.2.0,
-             cabal-plan -_ -exe -license-report,
             any.call-stack ==0.4.0,
             any.case-insensitive ==1.2.1.0,
             any.casing ==0.1.4.1,
-             any.chs-cabal ==0.1.1.1,
+             any.cereal ==0.5.8.1,
+             cereal -bytestring-builder,
+             any.chs-cabal ==0.1.1.0,
             any.chs-deps ==0.1.0.0,
             chs-deps -cross,
             any.clock ==0.8.2,
             clock -llvm,
+             any.cmdargs ==0.10.21,
+             cmdargs +quotation -testprog,
             any.colour ==2.3.6,
             any.comonad ==5.0.8,
             comonad +containers +distributive +indexed-traversable,
             any.composition-prelude ==3.0.0.2,
             composition-prelude -development,
+             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.5.1,
-             any.contravariant ==1.5.5,
+             any.containers ==0.6.4.1,
+             any.contravariant ==1.5.4,
             contravariant +semigroups +statevar +tagged,
             any.cpphs ==1.20.9.1,
             cpphs -old-locale,
@@ -69,32 +74,44 @@ constraints: any.Cabal ==3.2.1.0 || ==3.6.1.0,
             any.cryptohash-sha256 ==0.11.102.0,
             cryptohash-sha256 -exe +use-cbits,
             any.data-clist ==0.1.2.3,
-             any.data-fix ==0.3.2,
+             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.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,
             dlist -werror,
+             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.filepath ==1.4.2.1,
             any.free ==5.1.7,
             any.generic-arbitrary ==0.1.0,
-             any.ghc-boot-th ==8.10.7,
+             any.generics-sop ==0.5.1.1,
+             any.ghc-boot-th ==8.10.5,
             any.ghc-byteorder ==4.11.0.0.10,
             any.ghc-prim ==0.6.1,
             any.happy ==1.20.0,
-             any.hashable ==1.3.3.0,
+             any.hashable ==1.3.2.0,
             hashable +integer-gmp -random-initial-seed,
+             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.hpath-filepath ==0.10.4,
+             any.hpath-posix ==0.13.3,
             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,
+             any.hspec-discover ==2.7.10 || ==2.8.2,
             any.hspec-expectations ==0.8.2,
             any.hspec-golden-aeson ==0.9.0.0,
             any.http-io-streams ==0.1.6.0,
@@ -109,24 +126,36 @@ constraints: any.Cabal ==3.2.1.0 || ==3.6.1.0,
             io-streams +network -nointeractivetests +zlib,
             any.language-c ==0.9.0.1,
             language-c -allwarnings +iecfpextension +usebytestrings,
-             any.libarchive ==3.0.3.0,
+             any.libarchive ==3.0.2.2,
             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.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.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,
             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,
             any.optics-extra ==0.4,
             any.optics-th ==0.4,
+             any.optics-vl ==0.2.1,
             any.optparse-applicative ==0.16.1.0,
             optparse-applicative +process,
             any.os-release ==1.0.2,
@@ -138,18 +167,18 @@ constraints: any.Cabal ==3.2.1.0 || ==3.6.1.0,
             any.polyparse ==1.13,
             any.pretty ==1.1.3.6,
             any.pretty-terminal ==0.1.0.0,
-             any.primitive ==0.7.2.0,
-             any.process ==1.6.13.2,
+             any.primitive ==0.7.1.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.1,
+             any.random ==1.2.0,
             any.recursion-schemes ==5.2.2.1,
             recursion-schemes +template-haskell,
             any.regex-base ==0.94.0.1,
             any.regex-posix ==0.96.0.1,
             regex-posix -_regex-posix-clib,
-             any.resourcet ==1.2.4.3,
+             any.resourcet ==1.2.4.2,
             any.rts ==1.0.1,
             any.safe ==0.3.19,
             any.safe-exceptions ==0.1.7.2,
@@ -158,41 +187,55 @@ constraints: any.Cabal ==3.2.1.0 || ==3.6.1.0,
             any.semigroupoids ==5.3.5,
             semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
             any.setenv ==0.1.1.3,
+             any.sop-core ==0.5.0.1,
             any.split ==0.2.3.4,
             any.splitmix ==0.1.0.3,
             splitmix -optimised-mixer,
             any.stm ==2.5.0.1,
+             any.stm-chans ==3.0.0.4,
+             any.streaming-commons ==0.2.2.1,
+             streaming-commons -use-bytestring-builder,
             any.strict ==0.4.0.1,
             strict +assoc,
             any.strict-base ==0.4.0.0,
+             any.string-interpolate ==0.3.1.1,
+             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.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.tf-random ==0.5,
-             any.th-abstraction ==0.4.3.0,
-             any.th-compat ==0.1.3,
+             any.th-abstraction ==0.4.2.0,
+             any.th-compat ==0.1.2,
+             any.th-expand-syns ==0.4.8.0,
             any.th-lift ==0.8.2,
             any.th-lift-instances ==0.1.18,
+             any.th-orphans ==0.13.11,
+             any.th-reify-many ==0.1.9,
             any.these ==1.1.1.1,
             these +assoc,
             any.time ==1.9.3,
-             any.time-compat ==1.9.6.1,
+             any.time-compat ==1.9.6,
             time-compat -old-locale,
             any.transformers ==0.5.6.2,
-             any.transformers-base ==0.4.6,
+             any.transformers-base ==0.4.5.2,
             transformers-base +orphaninstances,
             any.transformers-compat ==0.7,
             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
+             any.typed-process ==0.2.6.0,
             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,
             unordered-containers -debug,
@@ -200,14 +243,22 @@ constraints: any.Cabal ==3.2.1.0 || ==3.6.1.0,
             uri-bytestring -lib-werror,
             any.utf8-string ==1.0.2,
             any.uuid-types ==1.0.5,
-             any.vector ==0.12.3.1,
+             any.vector ==0.12.3.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.vty ==5.33,
-             any.word-wrap ==0.5,
+             any.word-wrap ==0.4.1,
             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
-index-state: hackage.haskell.org 2021-10-01T15:16:26Z
+             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
--- a/cabal.ghc8107.project
+++ b/cabal.ghc8107.project
@@ -1,24 +0,0 @@
-packages: ./ghcup.cabal
-
-optional-packages: ./vendored/*/*.cabal
-
-optimization: 2
-
-package ghcup
-    tests: True
-    flags: +tui
-
-constraints: http-io-streams -brotli
-
-package libarchive
-  flags: -system-libarchive
-
-package aeson-pretty
-  flags: +lib-only
-
-package cabal-plan
-  flags: -exe
-
-allow-newer: base, ghc-prim, template-haskell, language-c
-
-with-compiler: ghc-8.10.7
--- a/cabal.ghc901.project
+++ b/cabal.ghc901.project
@@ -8,17 +8,26 @@ 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

-package aeson-pretty
-  flags: +lib-only
-
-package cabal-plan
-  flags: -exe
-
 allow-newer: base, ghc-prim, template-haskell, language-c

 with-compiler: ghc-9.0.1
--- a/cabal.ghc901.project.freeze
+++ b/cabal.ghc901.project.freeze
@@ -1,19 +1,15 @@
 active-repositories: hackage.haskell.org:merge
-constraints: any.Cabal ==3.4.0.0 || ==3.6.1.0,
-             Cabal -bundled-binary-generic,
+constraints: any.Cabal ==3.4.0.0,
             any.HUnit ==1.6.2.0,
-             any.HsOpenSSL ==0.11.7.2,
+             any.HsOpenSSL ==0.11.7,
             HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
-             any.HsYAML ==0.2.1.0,
-             HsYAML -exe,
-             any.HsYAML-aeson ==0.2.0.0,
             any.QuickCheck ==2.14.2,
             QuickCheck -old-random +templatehaskell,
             any.StateVar ==1.2.2,
             any.aeson ==1.5.6.0,
             aeson -bytestring-builder -cffi -developer -fast,
             any.aeson-pretty ==0.8.8,
-             aeson-pretty +lib-only,
+             aeson-pretty -lib-only,
             any.alex ==3.2.6,
             alex +small_base,
             any.ansi-terminal ==0.11,
@@ -26,42 +22,51 @@ constraints: any.Cabal ==3.4.0.0 || ==3.6.1.0,
             async -bench,
             any.attoparsec ==0.13.2.5,
             attoparsec -developer,
+             any.auto-update ==0.1.6,
             any.base ==4.15.0.0,
-             any.base-compat ==0.12.0,
-             any.base-compat-batteries ==0.12.0,
-             any.base-orphans ==0.8.5,
+             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,
             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.64.1,
+             any.brick ==0.63,
             brick -demos,
             any.bytestring ==0.10.12.1,
             any.bz2 ==1.0.1.0,
             bz2 -cross +with-bzlib,
+             any.bzlib-conduit ==0.3.0.2,
             any.c2hs ==0.28.8,
             c2hs +base3 -regression,
-             any.cabal-plan ==0.7.2.0,
-             cabal-plan -_ -exe -license-report,
             any.call-stack ==0.4.0,
             any.case-insensitive ==1.2.1.0,
             any.casing ==0.1.4.1,
-             any.chs-cabal ==0.1.1.1,
+             any.cereal ==0.5.8.1,
+             cereal -bytestring-builder,
+             any.chs-cabal ==0.1.1.0,
             any.chs-deps ==0.1.0.0,
             chs-deps -cross,
             any.clock ==0.8.2,
             clock -llvm,
+             any.cmdargs ==0.10.21,
+             cmdargs +quotation -testprog,
             any.colour ==2.3.6,
             any.comonad ==5.0.8,
             comonad +containers +distributive +indexed-traversable,
             any.composition-prelude ==3.0.0.2,
             composition-prelude -development,
+             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.5,
+             any.contravariant ==1.5.4,
             contravariant +semigroups +statevar +tagged,
             any.cpphs ==1.20.9.1,
             cpphs -old-locale,
@@ -69,33 +74,45 @@ constraints: any.Cabal ==3.4.0.0 || ==3.6.1.0,
             any.cryptohash-sha256 ==0.11.102.0,
             cryptohash-sha256 -exe +use-cbits,
             any.data-clist ==0.1.2.3,
-             any.data-fix ==0.3.2,
+             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.distributive ==0.6.2.1,
             distributive +semigroups +tagged,
             any.dlist ==1.0,
             dlist -werror,
+             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.filepath ==1.4.2.1,
             any.free ==5.1.7,
             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.happy ==1.20.0,
-             any.hashable ==1.3.3.0,
+             any.hashable ==1.3.2.0,
             hashable +integer-gmp -random-initial-seed,
+             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.hpath-filepath ==0.10.4,
+             any.hpath-posix ==0.13.3,
             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,
+             any.hspec-discover ==2.7.10 || ==2.8.2,
             any.hspec-expectations ==0.8.2,
             any.hspec-golden-aeson ==0.9.0.0,
             any.http-io-streams ==0.1.6.0,
@@ -109,24 +126,36 @@ constraints: any.Cabal ==3.4.0.0 || ==3.6.1.0,
             io-streams +network -nointeractivetests +zlib,
             any.language-c ==0.9.0.1,
             language-c -allwarnings +iecfpextension +usebytestrings,
-             any.libarchive ==3.0.3.0,
+             any.libarchive ==3.0.2.2,
             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.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.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,
             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,
             any.optics-extra ==0.4,
             any.optics-th ==0.4,
+             any.optics-vl ==0.2.1,
             any.optparse-applicative ==0.16.1.0,
             optparse-applicative +process,
             any.os-release ==1.0.2,
@@ -138,18 +167,18 @@ constraints: any.Cabal ==3.4.0.0 || ==3.6.1.0,
             any.polyparse ==1.13,
             any.pretty ==1.1.3.6,
             any.pretty-terminal ==0.1.0.0,
-             any.primitive ==0.7.2.0,
+             any.primitive ==0.7.1.0,
             any.process ==1.6.11.0,
             any.profunctors ==5.6.2,
             any.quickcheck-arbitrary-adt ==0.3.1.0,
             any.quickcheck-io ==0.2.0,
-             any.random ==1.2.1,
+             any.random ==1.2.0,
             any.recursion-schemes ==5.2.2.1,
             recursion-schemes +template-haskell,
             any.regex-base ==0.94.0.1,
             any.regex-posix ==0.96.0.1,
             regex-posix -_regex-posix-clib,
-             any.resourcet ==1.2.4.3,
+             any.resourcet ==1.2.4.2,
             any.rts ==1.0,
             any.safe ==0.3.19,
             any.safe-exceptions ==0.1.7.2,
@@ -158,41 +187,55 @@ constraints: any.Cabal ==3.4.0.0 || ==3.6.1.0,
             any.semigroupoids ==5.3.5,
             semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
             any.setenv ==0.1.1.3,
+             any.sop-core ==0.5.0.1,
             any.split ==0.2.3.4,
             any.splitmix ==0.1.0.3,
             splitmix -optimised-mixer,
             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.strict ==0.4.0.1,
             strict +assoc,
             any.strict-base ==0.4.0.0,
+             any.string-interpolate ==0.3.1.1,
+             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.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.tf-random ==0.5,
-             any.th-abstraction ==0.4.3.0,
-             any.th-compat ==0.1.3,
+             any.th-abstraction ==0.4.2.0,
+             any.th-compat ==0.1.2,
+             any.th-expand-syns ==0.4.8.0,
             any.th-lift ==0.8.2,
             any.th-lift-instances ==0.1.18,
+             any.th-orphans ==0.13.11,
+             any.th-reify-many ==0.1.9,
             any.these ==1.1.1.1,
             these +assoc,
             any.time ==1.9.3,
-             any.time-compat ==1.9.6.1,
+             any.time-compat ==1.9.6,
             time-compat -old-locale,
             any.transformers ==0.5.6.2,
-             any.transformers-base ==0.4.6,
+             any.transformers-base ==0.4.5.2,
             transformers-base +orphaninstances,
             any.transformers-compat ==0.7,
             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
+             any.typed-process ==0.2.6.0,
             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,
             unordered-containers -debug,
@@ -200,14 +243,22 @@ constraints: any.Cabal ==3.4.0.0 || ==3.6.1.0,
             uri-bytestring -lib-werror,
             any.utf8-string ==1.0.2,
             any.uuid-types ==1.0.5,
-             any.vector ==0.12.3.1,
+             any.vector ==0.12.3.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.vty ==5.33,
-             any.word-wrap ==0.5,
+             any.word-wrap ==0.4.1,
             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
-index-state: hackage.haskell.org 2021-10-01T15:16:26Z
+             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
--- a/cabal.project
+++ b/cabal.project
@@ -8,15 +8,19 @@ package ghcup
    tests: True
    flags: +tui

+source-repository-package
+    type: git
+    location: https://github.com/bgamari/terminal-size
+    tag: 34ea816bd63f75f800eedac12c6908c6f3736036
+
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/libarchive
+    tag: 024a7e8ab7b4d3848dc64dca1e70a04831eedc99
+
 constraints: http-io-streams -brotli

 package libarchive
  flags: -system-libarchive

-package aeson-pretty
-  flags: +lib-only
-
-package cabal-plan
-  flags: -exe
-
 allow-newer: base, ghc-prim, template-haskell, language-c
--- a/data/config.yaml
+++ b/data/config.yaml
@@ -8,10 +8,6 @@ verbose: False
 keep-dirs: Errors  # Always | Never | Errors
 # Which downloader to use
 downloader: Curl   # Curl | Wget | Internal
-# whether to run in offline mode
-no-network: False
-# whether/how to do gpg verification
-gpg-setting: GPGNone # GPGStrict | GPGLax | GPGNone

 # TUI key bindings,
 # see https://hackage.haskell.org/package/vty-5.31/docs/Graphics-Vty-Input-Events.html#t:Key
--- a/data/build_mk/cross
+++ b/data/build_mk/cross
@@ -1,9 +0,0 @@
-V=0
-BUILD_MAN = NO
-BUILD_SPHINX_HTML = NO
-BUILD_SPHINX_PDF = NO
-HADDOCK_DOCS = NO
-ifneq "$(BuildFlavour)" ""
-include mk/flavours/$(BuildFlavour).mk
-endif
-Stage1Only = YES
--- a/data/build_mk/default
+++ b/data/build_mk/default
@@ -1,8 +0,0 @@
-V=0
-BUILD_MAN = NO
-BUILD_SPHINX_HTML = NO
-BUILD_SPHINX_PDF = NO
-HADDOCK_DOCS = YES
-ifneq "$(BuildFlavour)" ""
-include mk/flavours/$(BuildFlavour).mk
-endif
--- a/docs/BUGS.md
+++ b/docs/BUGS.md
@@ -1 +0,0 @@
-# Known BUGS
--- a/docs/about.md
+++ b/docs/about.md
@@ -1,193 +0,0 @@
-# About
-
-All you wanted to know about GHCup.
-
-## Design goals
-
-1. simplicity
-2. non-interactive
-3. portable
-4. do one thing and do it well (UNIX philosophy)
-
-## Non-goals
-
-1. invoking `sudo`, `apt-get` or *any* package manager
-2. handling system packages
-3. handling cabal projects
-4. being a stack alternative
-
-## How
-
-Installs a specified GHC version into `~/.ghcup/ghc/<ver>`, and places `ghc-<ver>` symlinks in `~/.ghcup/bin/`.
-
-Optionally, an unversioned `ghc` link can point to a default version of your choice.
-
-This uses precompiled GHC binaries that have been compiled on fedora/debian by [upstream GHC](https://www.haskell.org/ghc/download_ghc_8_6_1.html#binaries).
-
-Alternatively, you can also tell it to compile from source (note that this might fail due to missing requirements).
-
-cabal-install/HLS/stack are installed in `~/.ghcup/bin/<tool>-<ver>` and have unversioned symlinks to the latest version by default (`~/.ghcup/bin/<tool>-<ver>`).
-
-## Known users
-
-* Github actions:
-	- [actions/virtual-environments](https://github.com/actions/virtual-environments)
-	- [haskell/actions/setup](https://github.com/haskell/actions/tree/main/setup)
-* mirrors:
-	- [sjtug](https://mirror.sjtu.edu.cn/docs/ghcup)
-* tools:
-	- [vabal](https://github.com/Franciman/vabal)
-
-## Known problems
-
-#### Custom ghc version names
-
-When installing ghc bindists with custom version names as outlined in
-[installing custom bindists](#installing-custom-bindists), then cabal might
-be unable to find the correct `ghc-pkg` (also see [#73](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/73))
-if you use `cabal build --with-compiler=ghc-foo`. Instead, point it to the full path, such as:
-`cabal build --with-compiler=$HOME/.ghcup/ghc/<version-name>/bin/ghc` or set that GHC version
-as the current one via: `ghcup set ghc <version-name>`.
-
-This problem doesn't exist for regularly installed GHC versions.
-
-#### Limited distributions supported
-
-Currently only GNU/Linux distributions compatible with the [upstream GHC](https://www.haskell.org/ghc/download_ghc_8_6_1.html#binaries) binaries are supported.
-
-#### Precompiled binaries
-
-Since this uses precompiled binaries you may run into
-several problems.
-
-##### Missing libtinfo (ncurses)
-
-You may run into problems with *ncurses* and **missing libtinfo**, in case
-your distribution doesn't use the legacy way of building
-ncurses and has no compatibility symlinks in place.
-
-Ask your distributor on how to solve this or
-try to compile from source via `ghcup compile <version>`.
-
-##### Libnuma required
-
-This was a [bug](https://ghc.haskell.org/trac/ghc/ticket/15688) in the build system of some GHC versions that lead to
-unconditionally enabled libnuma support. To mitigate this you might have to install the libnuma
-package of your distribution. See [here](https://gitlab.haskell.org/haskell/ghcup/issues/58) for a discussion.
-
-#### Compilation
-
-Although this script can compile GHC for you, it's just a very thin
-wrapper around the build system. It makes no effort in trying
-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
-
-#### Why reimplement stack?
-
-GHCup is not a reimplementation of stack. The only common part is automatic installation of GHC,
-but even that differs in scope and design.
-
-#### Why should I use ghcup over stack?
-
-GHCup is not a replacement for stack. Instead, it supports installing and managing stack versions.
-It does the same for cabal, GHC and HLS. As such, It doesn't make a workflow choice for you.
-
-#### Why should I let ghcup manage stack?
-
-You don't need to. However, some users seem to prefer to have a central tool that manages cabal and stack
-at the same time. Additionally, it can allow better sharing of GHC installation across these tools.
-Also see:
-
-* https://docs.haskellstack.org/en/stable/yaml_configuration/#system-ghc
-* https://github.com/commercialhaskell/stack/pull/5585
-
-#### Why does ghcup not use stack code?
-
-Oddly, this question has been asked a couple of times. For the curious, here are a few reasons:
-
-1. GHCup started as a shell script. At the time of rewriting it in Haskell, the authors didn't even know that stack exposes *some* of its [installation API](https://hackage.haskell.org/package/stack-2.5.1.1/docs/Stack-Setup.html)
-2. Even if they did, it doesn't seem it would have satisfied their needs
-	  - it didn't support cabal installation, which was the main motivation behind GHCup back then
-	  - depending on a codebase as big as stack for a central part of one's application without having a short contribution pipeline would likely have caused stagnation or resulted in simply copy-pasting the relevant code in order to adjust it
-	  - it's not clear how GHCup would have been implemented with the provided API. It seems the codebases are fairly different. GHCup does a lot of symlink handling to expose a central `bin/` directory that users can easily put in PATH, without having to worry about anything more. It also provides explicit removal functionality, GHC cross-compilation, a TUI, etc etc.
-3. GHCup is built around unix principles and supposed to be simple.
-
-#### Why not unify...
-
-##### ...stack and Cabal and do away with standalone installers
-
-GHCup is not involved in such decisions. cabal-install and stack might have a
-sufficiently different user experience to warrant having a choice.
-
-##### ...installer implementations and have a common library
-
-This sounds like an interesting goal. However, GHC installation isn't a hard engineering problem
-and the shared code wouldn't be too exciting. For such an effort to make sense, all involved
-parties would need to collaborate and have a short pipeline to get patches in.
-
-It's true this would solve the integration problem, but following unix principles, we can
-do similar via **hooks**. Both cabal and stack can support installation hooks. These hooks
-can then call into ghcup or anything else, also see:
-
-* https://github.com/haskell/cabal/issues/7394
-* https://github.com/commercialhaskell/stack/pull/5585
-
-##### ...installers (like, all of it)
-
-So far, there hasn't been an **open** discussion about this. Is this even a good idea?
-Sometimes projects converge eventually if their overlap is big enough, sometimes they don't.
-
-While unification sounds like a simplification of the ecosystem, it also takes away choice.
-Take `curl` and `wget` as an example.
-
-How bad do we need this?
-
-#### Why not support windows?
-
-Windows is supported since GHCup version 0.1.15.1.
-
-#### 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.
-
-#### Is GHCup affiliated with the Haskell Foundation?
-
-There has been some collaboration: Windows and Stack support were mainly requested by the Haskell Foundation
-and those seemed interesting features to add.
-
-Other than that, GHCup is dedicated only to its users and is supported by haskell.org through hosting and CI
-infrastructure.
-
--- a/docs/css/extra.css
+++ b/docs/css/extra.css
@@ -1,122 +0,0 @@
-div.col-md-9 h1:first-of-type {
-    text-align: center;
-    font-size: 60px;
-    font-weight: 300;
-}
-
-div.col-md-9>p:first-of-type {
-    text-align: center;
-}
-
-div.col-md-9 p.admonition-title:first-of-type {
-    text-align: left;
-}
-
-div.col-md-9 h1:first-of-type .headerlink {
-    display: none;
-}
-
-code.no-highlight {
-    color: black;
-}
-
-div.gh-badge img {
-	margin: 0;
-	padding: 0;
-	height: 25px;
-}
-
-a.donate-badge img {
-	margin-top: 10;
-	margin-bottom: 0;
-	padding: 0;
-	height: 35px;
-}
-
-/* Definition List styles */
-
-dd {
-    padding-left: 20px;
-}
-
-/* Homepage */
-
-body.homepage div.jumbotron {
-    margin-top: 1.5rem;
-    padding-top: 1rem;
-    padding-bottom: 0;
-}
-
-body.homepage div.jumbotron div.card {
-    margin-bottom: 2rem;
-}
-
-body.homepage>div.container div.col-md-3 {
-    display: none;
-}
-
-body.homepage>div.container div.col-md-9 {
-    margin-left: 0;
-    padding-left: 0;
-    flex: 0 0 100%;
-    max-width: 100%;
-}
-
-.center {
-    display: block !important;
-}
-
-.bg-primary {
-    background-image: -webkit-gradient(linear, left top, left bottom, from(#996FC2), color-stop(60%, #6A478D), to(#5E5086)) !important;
-    background-image: linear-gradient(#996FC2, #6A478D 60%, #5E5086) !important;
-    background-repeat: no-repeat !important;
-}
-
-.btn-primary {
-    background-image: -webkit-gradient(linear, left top, left bottom, from(#996FC2), color-stop(60%, #6A478D), to(#5E5086)) !important;
-    background-image: linear-gradient(#996FC2, #6A478D 60%, #5E5086) !important;
-    background-repeat: no-repeat !important;
-
-    color: #fff;
-    background-color: #996FC1;
-    border-color: #996FC1;
-
-	border-bottom: 1px solid #453A62;
-}
-
-.navbar {
-    background-image: -webkit-gradient(linear, left top, left bottom, from(#996FC2), color-stop(60%, #6A478D), to(#5E5086)) !important;
-    background-image: linear-gradient(#996FC2, #6A478D 60%, #5E5086) !important;
-    background-repeat: no-repeat !important;
-
-    color: #fff;
-    background-color: #996FC1;
-    border-color: #996FC1;
-
-	border-bottom: 1px solid #453A62;
-}
-
-a {
-	color: #996FC2;
-}
-
-a:hover {
-	color: #674489;
-}
-
-.col-md-9 img.main-logo {
-    border: 0px; 
-	padding: 0px;
-	margin: 0px;
-}
-
-.navbar-default .navbar-nav>.active>a, .navbar-default .navbar-nav>.active>a:hover, .navbar-default .navbar-nav>.active>a:focus {
-    color: #fff;
-    background-color: #453A62;
-    border-color: #996FC1;
-}
-
-.navbar-default .navbar-nav>li>a:hover, .navbar-default .navbar-nav>li>a:focus {
-    color: #fff;
-    background-color: #453A62;
-}
--- a/docs/ghcup.gif
+++ b/docs/ghcup.gif
--- a/docs/guide.md
+++ b/docs/guide.md
@@ -1,302 +0,0 @@
-# User Guide
-
-`ghcup --help` is your friend.
-
-## Basic usage
-
-For the simple interactive TUI (not available on windows), run:
-
-```sh
-ghcup tui
-```
-
-For the full functionality via cli:
-
-```sh
-# list available ghc/cabal versions
-ghcup list
-
-# install the recommended GHC version
-ghcup install ghc
-
-# install a specific GHC version
-ghcup install ghc 8.2.2
-
-# set the currently "active" GHC version
-ghcup set ghc 8.4.4
-
-# install cabal-install
-ghcup install cabal
-
-# update ghcup itself
-ghcup upgrade
-```
-
-## Configuration
-
-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](https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/data/config.yaml).
-
-Partial configuration is fine. Command line options always override the config file settings.
-
-## GPG verification
-
-GHCup supports verifying the GPG signature of the metadata file. The metadata file then contains SHA256 hashes of all downloads, so
-this is cryptographically secure.
-
-First, obtain the gpg key:
-
-```sh
-gpg --batch --keyserver keys.openpgp.org --recv-keys 7784930957807690A66EBDBE3786C5262ECB4A3F
-```
-
-Then verify the gpg key in one of these ways:
-
-1. find out where I live and visit me to do offline key signing
-2. figure out my mobile phone number and call me to verify the fingerprint
-3. more boring: contact me on Libera IRC (`maerwald`) and verify the fingerprint
-
-Once you've verified the key, you have to figure out if you trust me.
-
-If you trust me, then you can configure gpg in `~/.ghcup/config.yaml`:
-
-```yml
-gpg-setting: GPGLax # GPGStrict | GPGLax | GPGNone
-```
-
-In `GPGStrict` mode, ghcup will fail if verification fails. In `GPGLax` mode it will just print a warning.
-You can also pass the mode via `ghcup --gpg <strict|lax|none>`.
-
-## Manpages
-
-For man pages to work you need [man-db](http://man-db.nongnu.org/) as your `man` provider, then issue `man ghc`. Manpages only work for the currently set ghc.
-`MANPATH` may be required to be unset.
-
-## Shell-completion
-
-Shell completions are in [scripts/shell-completions](https://gitlab.haskell.org/haskell/ghcup-hs/-/tree/master/scripts/shell-completions) directory of this repository.
-
-For bash: install `shell-completions/bash`
-as e.g. `/etc/bash_completion.d/ghcup` (depending on distro)
-and make sure your bashrc sources the startup script
-(`/usr/share/bash-completion/bash_completion` on some distros).
-
-## Compiling GHC from source
-
-Compiling from source is supported for both source tarballs and arbitrary git refs. See `ghcup compile ghc --help`
-for a list of all available options.
-
-If you need to overwrite the existing `build.mk`, check the default files
-in [data/build_mk](https://gitlab.haskell.org/haskell/ghcup-hs/-/tree/master/data/build_mk), copy them somewhere, adjust them and
-pass `--config path/to/build.mk` to `ghcup compile ghc`.
-Common `build.mk` options are explained [here](https://gitlab.haskell.org/ghc/ghc/-/wikis/building/using#build-configuration).
-
-Make sure your system meets all the [prerequisites](https://gitlab.haskell.org/ghc/ghc/-/wikis/building/preparation).
-
-### Cross support
-
-ghcup can compile and install a cross GHC for any target. However, this
-requires that the build host has a complete cross toolchain and various
-libraries installed for the target platform.
-
-Consult the GHC documentation on the [prerequisites](https://gitlab.haskell.org/ghc/ghc/-/wikis/building/cross-compiling#tools-to-install).
-For distributions with non-standard locations of cross toolchain and
-libraries, this may need some tweaking of `build.mk` or configure args.
-See `ghcup compile ghc --help` for further information.
-
-## XDG support
-
-To enable XDG style directories, set the environment variable `GHCUP_USE_XDG_DIRS` to anything.
-
-Then you can control the locations via XDG environment variables as such:
-
-* `XDG_DATA_HOME`: GHCs will be unpacked in `ghcup/ghc` subdir (default: `~/.local/share`)
-* `XDG_CACHE_HOME`: logs and download files will be stored in `ghcup` subdir (default: `~/.cache`)
-* `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:
-
-* `GHCUP_USE_XDG_DIRS`: see [XDG support](#xdg-support) above
-* `TMPDIR`: where ghcup does the work (unpacking, building, ...)
-* `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_GPG_OPTS`: additional options that can be passed to gpg
-* `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
-
-There are a couple of good use cases to install custom bindists:
-
-1. manually built bindists (e.g. with patches)
-    - example: `ghcup install ghc -u 'file:///home/mearwald/tmp/ghc-eff-patches/ghc-8.10.2-x86_64-deb10-linux.tar.xz' 8.10.2-eff`
-2. GHC head CI bindists
-    - example: `ghcup install ghc -u 'https://gitlab.haskell.org/api/v4/projects/1/jobs/artifacts/master/raw/ghc-x86_64-fedora27-linux.tar.xz?job=validate-x86_64-linux-fedora27' head`
-3. DWARF bindists
-    - example: `ghcup install ghc -u 'https://downloads.haskell.org/~ghc/8.10.2/ghc-8.10.2-x86_64-deb10-linux-dwarf.tar.xz' 8.10.2-dwarf`
-
-Since the version parser is pretty lax, `8.10.2-eff` and `head` are both valid versions
-and produce the binaries `ghc-8.10.2-eff` and `ghc-head` respectively.
-GHCup always needs to know which version the bindist corresponds to (this is not automatically
-detected).
-
-## Isolated installs
-
-Ghcup also enables you to install a tool (GHC, Cabal, HLS, Stack) at an isolated location of your choosing.
-These installs, as the name suggests, are separate from your main installs and DO NOT conflict with them.
-
-
- No symlinks are made to these isolated installed tools, you'd have to manually point to them wherever you intend to use them.
-
- These installs, can also NOT be deleted from ghcup, you'd have to go and manually delete these.
-
-You need to use the `--isolate` or `-i` flag followed by the directory path.
-
-Examples:
-
-1. install an isolated GHC version at location /home/user/isolated_dir/ghc/  
-    - `ghcup install ghc 8.10.5 --isolate /home/user/isolated_dir/ghc`
-
-2. isolated install Cabal at a location you desire  
-    - `ghcup install cabal --isolate /home/username/my_isolated_dir/`
-
-3. do an isolated install with a custom bindist  
-    - `ghcup install ghc --isolate /home/username/my_isolated_dir/ -u 'https://gitlab.haskell.org/api/v4/projects/1/jobs/artifacts/master/raw/ghc-x86_64-fedora27-linux.tar.xz?job=validate-x86_64-linux-fedora27' head`
-
-4. isolated install HLS  
-    - `ghcup install hls --isolate /home/username/dir/hls/`
-
-5. you can even compile ghc to an isolated location.  
-    - `ghcup compile ghc -j 4 -v 9.0.1 -b 8.10.5 -i /home/username/my/dir/ghc` 
-
-## CI
-
-On windows, ghcup can be installed automatically on a CI runner like so:
-
-```ps
-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,$true,$true,$false,$false,$false,$false,"C:\"
-```
-
-On linux/darwin/freebsd, run the following on your runner:
-
-```sh
-curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 BOOTSTRAP_HASKELL_MINIMAL=1 sh
-```
-
-This will just install `ghcup` and on windows additionally `msys2`.
-
-### Example github workflow
-
-On github workflows you can use https://github.com/haskell/actions/
-
-If you want to install ghcup manually though, here's an example config:
-
-```yml
-name: Haskell CI
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build-cabal:
-
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macOS-latest, windows-latest]
-        ghc: ['8.10.7', '9.0.1']
-        cabal: ['3.4.0.0']
-
-    steps:
-    - uses: actions/checkout@v2
-
-    - if: matrix.os == 'windows-latest'
-      name: Install ghcup on windows
-      run: 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,$true,$true,$false,$false,$false,$false,"C:\"
-
-    - if: matrix.os == 'windows-latest'
-      name: Add ghcup to PATH
-      run: echo "/c/ghcup/bin" >> $GITHUB_PATH
-      shell: bash
-
-    - if: matrix.os != 'windows-latest'
-      name: Install ghcup on non-windows
-      run: curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 BOOTSTRAP_HASKELL_MINIMAL=1 sh
-
-    - name: Install ghc/cabal
-      run: |
-        ghcup install ghc ${{ matrix.ghc }}
-        ghcup install cabal ${{ matrix.cabal }}
-      shell: bash
-
-    - name: Update cabal index
-      run: cabal update
-      shell: bash
-
-    - name: Build
-      run: cabal build --enable-tests --enable-benchmarks
-      shell: bash
-
-    - name: Run tests
-      run: cabal test
-      shell: bash
-```
-   
-## Tips and tricks
-
-### with_ghc wrapper (e.g. for HLS)
-
-Due to some HLS [bugs](https://github.com/mpickering/hie-bios/issues/194) it's necessary that the `ghc` in PATH
-is the one defined in `cabal.project`. With some simple shell functions, we can start our editor with the appropriate
-path prepended.
-
-For bash, in e.g. `~/.bashrc` define:
-
-```sh
-with_ghc() {
-  local np=$(ghcup --offline whereis -d ghc $1 || { ghcup --cache install ghc $1 && ghcup whereis -d ghc $1 ;})
-  if [ -e "${np}" ] ; then
-    shift
-    PATH="$np:$PATH" "$@"
-  else
-    >&2 echo "Cannot find or install GHC version $1"
-    return 1
-  fi
-}
-```
-
-For fish shell, in e.g. `~/.config/fish/config.fish` define:
-
-```fish
-function with_ghc
-  set --local np (ghcup --offline whereis -d ghc $argv[1] ; or begin ghcup --cache install ghc $argv[1] ; and ghcup whereis -d ghc $argv[1] ; end)
-  if test -e "$np"
-    PATH="$np:$PATH" $argv[2..-1]
-  else
-    echo "Cannot find or install GHC version $argv[1]" 1>&2
-    return 1
-  end
-end
-```
-
-Then start a new shell and issue:
-
-```sh
-# replace 'code' with your editor
-with_ghc 8.10.5 code path/to/haskell/source
-```
-
-Cabal and HLS will now see `8.10.5` as the primary GHC, without the need to
-run `ghcup set` all the time when switching between projects.
-
--- a/docs/haskell_logo.png
+++ b/docs/haskell_logo.png
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,36 +0,0 @@
---
-hide:
-  - navigation
-  - toc
---
-
-# ![](./haskell_logo.png){: .main-logo style="width:100px"} GHCup
-
-GHCup is an installer for the general purpose language [Haskell](https://www.haskell.org/).
-
-<div class="text-center gh-badge">
-<a href="https://kiwiirc.com/nextclient/irc.libera.chat/?nick=Guest%7C?#haskell,#haskell-ghcup"><img src="https://img.shields.io/badge/chat-on%20libera%20IRC-brightgreen.svg" alt="Join the chat at Libera.chat"></a>
-<a href="https://app.element.io/#/room/#haskell-tooling:matrix.org"><img src="https://img.shields.io/matrix/haskell-tooling:matrix.org?label=chat%20on%20matrix.org" alt="Join the chat at Matrix.org"></a>
-<a href="https://discord.gg/pKYf3zDQU7"><img src="https://img.shields.io/discord/280033776820813825?label=chat%20on%20discord" alt="Join the chat at Discord"></a>
-<a href="https://gitter.im/haskell/ghcup?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"><img src="https://badges.gitter.im/haskell/ghcup.svg" alt="Join the chat at https://gitter.im/haskell/ghcup"></a>
-<a href="https://opencollective.com/ghcup#category-CONTRIBUTE" class="donate-badge"><img src="https://opencollective.com/webpack/donate/button@2x.png?color=blue" alt="Donate"></a>
-</div>
-
----
-
-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](./install/#supported-tools) 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).
-
-<div class="text-center">
-<a href="https://www.haskell.org/ghcup/" class="btn btn-primary" role="button">Quick Install</a>
-<a href="install/" class="btn btn-primary" role="button">Getting Started</a>
-<a href="guide/" class="btn btn-primary" role="button">User Guide</a>
-<a href="https://gitlab.haskell.org/haskell/ghcup-hs/-/issues" class="btn btn-primary" role="button">Issue tracker</a>
-</div>
-
-
----
-
-![GHCup](./ghcup.gif){: .center style="width:700px"}
-
--- a/docs/install.md
+++ b/docs/install.md
@@ -1,95 +0,0 @@
-# Getting started
-
-Let's get started....
-
-## Installation
-
-On 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:
-
-```sh
-curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh
-```
-
-If you are running Windows, run the following in a powershell session (as a non-admin user).
-
-```psh
-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
-```
-
-Advanced users may want to perform a [manual installation](#manual-install).
-
-## Supported tools
-
-GHCup supports the following tools:
-
-1. [GHC](https://www.haskell.org/ghc/)
-2. [cabal-install](https://cabal.readthedocs.io/en/latest/)
-3. [haskell-language-server](https://haskell-language-server.readthedocs.io/en/latest/)
-4. [stack](https://docs.haskellstack.org/en/latest/README/)
-
-## Supported platforms
-
-This list may not be exhaustive and specifies support for bindists only.
-
-| Platform | Architecture | ghcup | GHC | cabal | HLS | stack | 
-| ------ | ------ | ------ | ------ | ------ | ------ | ------ |
-| Windows 7 | amd64 | ❔ | ✅ | ✅ | ✅ | ✅ |
-| Windows 10 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Windows Server 2016 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Windows Server 2019 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Windows Server 2022 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Windows WSL1 | amd64 | ❌ | ❔ | ❔ | ❔ | ❔ |
-| Windows WSL2 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| MacOS >=13 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| MacOS <13 | amd64 | ❌ | ❔ | ❔ | ❔ | ❔ |
-| MacOS | aarch64 | ✅ | ✅ | ✅ | ⚠️ | ❌ |
-| FreeBSD | amd64 | ✅ | ⚠️ | ✅ | ⚠️ | ❌ |
-| Linux generic | x86 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Linux generic | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Linux generic | aarch64 | ✅ | ⚠️ | ✅ | ⚠️ | ❌ |
-| Linux generic | armv7 | ✅ | ⚠️ | ✅ | ⚠️ | ❌ |
-
-#### Windows 7
-
-May or may not work, several issues:
-
-* https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/140
-* https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/197
-
-#### WSL1
-
-Unsupported. GHC may or may not work. Upgrade to WSL2.
-
-#### MacOS <13
-
-Not supported. Would require separate binaries, since >=13 binaries are incompatible.
-Please upgrade.
-
-#### MacOS aarch64
-
-HLS bindists are still experimental. Stack is theoretically supported, but has no binaries yet.
-
-#### FreeBSD
-
-Lacks some upstream bindists and may need compat libs, since most bindists are built on FreeBSD-12.
-HLS bindists are experimental.
-
-#### Linux ARMv7/AARCH64
-
-Lower availability of bindists. HLS only has experimental ones. Stack not supported currently.
-
-## Manual install
-
-Download the binary for your platform at [https://downloads.haskell.org/~ghcup/](https://downloads.haskell.org/~ghcup/)
-and place it into your `PATH` anywhere.
-
-Then adjust your `PATH` in `~/.bashrc` (or similar, depending on your shell) like so:
-
-```sh
-export PATH="$HOME/.cabal/bin:$HOME/.ghcup/bin:$PATH"
-```
-
-## Vim integration
-
-See [ghcup.vim](https://github.com/hasufell/ghcup.vim).
-
--- a/data/metadata/ghcup-0.0.1.json
+++ b/data/metadata/ghcup-0.0.1.json
--- a/data/metadata/ghcup-0.0.2.json
+++ b/data/metadata/ghcup-0.0.2.json
--- a/data/metadata/ghcup-0.0.2.yaml
+++ b/data/metadata/ghcup-0.0.2.yaml
--- a/data/metadata/ghcup-0.0.3.yaml
+++ b/data/metadata/ghcup-0.0.3.yaml
--- a/data/metadata/ghcup-0.0.4.yaml
+++ b/data/metadata/ghcup-0.0.4.yaml
--- a/data/metadata/ghcup-0.0.5.yaml
+++ b/data/metadata/ghcup-0.0.5.yaml
--- a/data/metadata/ghcup-0.0.6.yaml
+++ b/data/metadata/ghcup-0.0.6.yaml
@@ -72,6 +72,7 @@ toolRequirements:
        '( >= 7 && < 8 )':
          distroPKGs:
          - gcc
+          - gcc-c++
          - gmp
          - gmp-devel
          - make
@@ -82,6 +83,7 @@ toolRequirements:
        unknown_versioning:
          distroPKGs:
          - gcc
+          - gcc-c++
          - gmp
          - gmp-devel
          - make
@@ -94,6 +96,7 @@ toolRequirements:
        unknown_versioning:
          distroPKGs:
          - gcc
+          - gcc-c++
          - gmp
          - gmp-devel
          - make
@@ -108,15 +111,14 @@ toolRequirements:
          - binutils-gold
          - curl
          - gcc
+          - g++
          - gmp-dev
-          - libc-dev
+          - ncurses-dev
          - libffi-dev
          - make
-          - musl-dev
-          - ncurses-dev
-          - perl
-          - tar
          - xz
+          - tar
+          - perl
          notes: ''
      Linux_UnknownLinux:
        unknown_versioning:
@@ -1493,7 +1495,6 @@ ghcupDownloads:
              dlHash: b823b58cae36fbac0741680ca7605180fa4cf4c6ae439123d282184b94d32fd6
    8.10.4:
      viTags:
-      - old
      - base-4.14.1.0
      viChangeLog: https://downloads.haskell.org/~ghc/8.10.4/docs/html/users_guide/8.10.4-notes.html
      viSourceDL:
@@ -1589,7 +1590,6 @@ ghcupDownloads:
              dlHash: 0d18ef83593272f6196a41cc3abdc48dfe5e14372db75d71ea19fe35320c4e81
    8.10.5:
      viTags:
-      - old
      - base-4.14.2.0
      viChangeLog: https://downloads.haskell.org/~ghc/8.10.5/docs/html/users_guide/8.10.5-notes.html
      viSourceDL:
@@ -1598,11 +1598,6 @@ ghcupDownloads:
        dlHash: f10941f16e4fbd98580ab5241b9271bb0851304560c4d5ca127e3b0e20e3076f
      viPostRemove: *ghc-post-remove
      viPreCompile: *ghc-pre-compile
-      viPostInstall: &ghc-8105-post-install |
-        GHC 8.10.5 and 8.10.6 have several issues on Darwin, e.g.
-          https://gitlab.haskell.org/ghc/ghc/-/issues/19950
-        Consider upgrading to 8.10.7 via
-          ghcup install ghc --set 8.10.7
      viArch:
        A_64:
          Linux_Debian:
@@ -1695,7 +1690,7 @@ ghcupDownloads:
              dlHash: 56170d1a8450e18b7eb9c23c94723da352815b27ec250bb23742a62f16dcab6c
    8.10.6:
      viTags:
-      - old
+      - Recommended
      - base-4.14.3.0
      viChangeLog: https://downloads.haskell.org/~ghc/8.10.6/docs/html/users_guide/8.10.6-notes.html
      viSourceDL:
@@ -1704,7 +1699,6 @@ ghcupDownloads:
        dlHash: 43afba72a533408b42c1492bd047b5e37e5f7204e41a5cedd3182cc841610ce9
      viPostRemove: *ghc-post-remove
      viPreCompile: *ghc-pre-compile
-      viPostInstall: *ghc-8105-post-install
      viArch:
        A_64:
          Linux_Debian:
@@ -1795,107 +1789,6 @@ ghcupDownloads:
              dlUri: https://downloads.haskell.org/~ghc/8.10.6/ghc-8.10.6-armv7-deb10-linux.tar.xz
              dlSubdir: ghc-8.10.6
              dlHash: d54de8306aa8b33afabf2ac94408e1f82c8e982a2a3346168c071b92bdb464c0
-    8.10.7:
-      viTags:
-      - Recommended
-      - base-4.14.3.0
-      viChangeLog: https://downloads.haskell.org/~ghc/8.10.7/docs/html/users_guide/8.10.7-notes.html
-      viSourceDL:
-        dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-src.tar.xz
-        dlSubdir: ghc-8.10.7
-        dlHash: e3eef6229ce9908dfe1ea41436befb0455fefb1932559e860ad4c606b0d03c9d
-      viPostRemove: *ghc-post-remove
-      viPreCompile: *ghc-pre-compile
-      viArch:
-        A_64:
-          Linux_Debian:
-            '( >= 9 && < 10 )': &ghc-8107-64-deb9
-              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-deb9-linux.tar.xz
-              dlSubdir: ghc-8.10.7
-              dlHash: ced9870ea351af64fb48274b81a664cdb6a9266775f1598a79cbb6fdd5770a23
-            '( >= 10 && < 11 )': &ghc-8107-64-deb10
-              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.7
-              dlHash: a13719bca87a0d3ac0c7d4157a4e60887009a7f1a8dbe95c4759ec413e086d30
-            unknown_versioning: *ghc-8107-64-deb9
-          Linux_Ubuntu:
-            unknown_versioning: &ghc-8107-64-fedora
-              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-fedora27-linux.tar.xz
-              dlSubdir: ghc-8.10.7
-              dlHash: b6ed67049a23054a8042e65c9976d5e196e5ee4e83b29b2ee35c8a22ab1e5b73
-            '( >= 16 && < 19 )': *ghc-8107-64-deb9
-          Linux_Mint:
-            unknown_versioning: *ghc-8107-64-deb10
-          Linux_Fedora:
-            '( >= 27 && < 28 )': *ghc-8107-64-fedora
-            unknown_versioning: *ghc-8107-64-fedora
-          Linux_CentOS:
-            '( >= 7 && < 8 )': &ghc-8107-64-centos
-              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-centos7-linux.tar.xz
-              dlSubdir: ghc-8.10.7
-              dlHash: 262a50bfb5b7c8770e0d99f54d42e5876968da7bf93e2e4d6cfe397891a36d05
-            unknown_versioning: *ghc-8107-64-centos
-          Linux_RedHat:
-            unknown_versioning: *ghc-8107-64-centos
-          Linux_Alpine:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-alpine3.10-linux-integer-simple.tar.xz
-              dlSubdir: ghc-8.10.7-x86_64-unknown-linux
-              dlHash: 16903df850ef73d5246f2ff169cbf57ecab76c2ac5acfa9928934282cfad575c
-          Linux_AmazonLinux:
-            unknown_versioning: *ghc-8107-64-centos
-          Linux_UnknownLinux:
-            unknown_versioning: *ghc-8107-64-fedora
-          Darwin:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-apple-darwin.tar.xz
-              dlSubdir: ghc-8.10.7
-              dlHash: 287db0f9c338c9f53123bfa8731b0996803ee50f6ee847fe388092e5e5132047
-          FreeBSD:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-unknown-freebsd.tar.xz
-              dlSubdir: ghc-8.10.7
-              dlHash: 45e35d24bc700e1093efa39189e9fa01498069881aed2fa8779c011941a80da1
-          Windows:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-unknown-mingw32.tar.xz
-              dlSubdir: ghc-8.10.7
-              dlHash: b6515b0ea3f7a6e34d92e7fcd0c1fef50d6030fe8f46883000185289a4b8ea9a
-        A_32:
-          Linux_Debian:
-            '( >= 9 && < 10 )': &ghc-8107-32-deb9
-              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-i386-deb9-linux.tar.xz
-              dlSubdir: ghc-8.10.7
-              dlHash: fbfc1ef194f4e7a4c0da8c11cc69b17458a4b928b609b3622c97acc4acd5c5ab
-            unknown_versioning: *ghc-8107-32-deb9
-          Linux_Ubuntu:
-            unknown_versioning: *ghc-8107-32-deb9
-          Linux_Mint:
-            unknown_versioning: *ghc-8107-32-deb9
-          Linux_UnknownLinux:
-            unknown_versioning: *ghc-8107-32-deb9
-          Linux_Alpine:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/ghc/8.10.7/ghc-8.10.7-i386-alpine-linux.tar.xz
-              dlSubdir: ghc-8.10.7
-              dlHash: 3110e6ee029d9d8062158b54b06f71a21b0fac87bf0e085f9be5bbcf73f99e6d
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-aarch64-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.7
-              dlHash: fad2417f9b295233bf8ade79c0e6140896359e87be46cb61cd1d35863d9d0e55
-          Darwin:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-aarch64-apple-darwin.tar.xz
-              dlSubdir: ghc-8.10.7
-              dlHash: dc469fc3c35fd2a33a5a575ffce87f13de7b98c2d349a41002e200a56d9bba1c
-        A_ARM:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-armv7-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.7
-              dlHash: 3949c31bdf7d3b4afb765ea8246bca4ca9707c5d988d9961a244f0da100956a2
    9.0.1:
      viTags:
      - Latest
@@ -2060,11 +1953,6 @@ ghcupDownloads:
              dlUri: https://downloads.haskell.org/~ghc/9.2.1-rc1/ghc-9.2.0.20210821-aarch64-deb10-linux.tar.xz
              dlSubdir: ghc-9.2.0.20210821
              dlHash: 289fc361be4a3199ac15449e30405a9831454811dd454e81eab73bfcdd2c4088
-          Darwin:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/9.2.1-rc1/ghc-9.2.0.20210821-aarch64-apple-darwin.tar.xz
-              dlSubdir: ghc-9.2.0.20210821-aarch64-apple-darwin
-              dlHash: 0d763fb619cfa32fa37c113c446e13bebc2215db5946e5fa8fd8400559cf4152
        A_ARM:
          Linux_UnknownLinux:
            unknown_versioning:
@@ -2182,7 +2070,9 @@ ghcupDownloads:
              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.2.0.0/cabal-install-3.2.0.0-i386-unknown-linux.tar.xz
              dlHash: 2b3ac28549916de5f3379241797eaf60e84b6c001f2abbe73d9fadbbaf768e93
    3.4.0.0:
-      viTags: []
+      viTags:
+      - Recommended
+      - Latest
      viChangeLog: https://github.com/haskell/cabal/blob/master/release-notes/cabal-install-3.4.0.0.md
      viArch:
        A_64:
@@ -2231,53 +2121,8 @@ ghcupDownloads:
            unknown_versioning:
              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
-    3.6.0.0:
-      viTags:
-      - Recommended
-      - Latest
-      viChangeLog: https://github.com/haskell/cabal/blob/master/release-notes/cabal-install-3.6.0.0.md
-      viArch:
-        A_64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.6.0.0/cabal-install-3.6.0.0-x86_64-linux.tar.xz
-              dlHash: bfcb7350966dafe95051b5fc9fcb989c5708ab9e78191e71fc04647061668a11
-          Linux_Alpine:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.6.0.0/cabal-install-3.6.0.0-x86_64-linux-alpine.tar.xz
-              dlHash: 3203d71b7ee87fc9dce74b452ae07f420afe8817b5e6f84e54798442f4ccdda8
-          Darwin:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.6.0.0/cabal-install-3.6.0.0-x86_64-darwin.tar.xz
-              dlHash: 8e1367a4a1fc86ff0fd82ee057320a7b974595ba7999457b42035467ba06190c
-          FreeBSD:
-            '( >= 12 && < 13 )':
-              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.6.0.0/cabal-install-3.6.0.0-x86_64-freebsd.tar.xz
-              dlHash: 56b5b37396c16a29f164a6963f24bd88f09e1d37448542ed61a683325f0a868b
-            '( >= 13 )':
-              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.6.0.0/cabal-install-3.6.0.0-x86_64-freebsd13.tar.xz
-              dlHash: a283aa498702a3e286aa08e004c2a389538cbb47ec7096a25682fb7d57f6bb7f
-          Windows:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.6.0.0/cabal-install-3.6.0.0-x86_64-windows.zip
-              dlSubdir:
-              dlHash: 8222b49b6eac3d06aaa390bc688f467e8f949a38943567f46246f8320fd72ded
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.6.0.0/cabal-install-3.6.0.0-aarch64-linux-deb10.tar.xz
-              dlHash: 534f71cd4e1d9758dc73066cc5733c5838874710aeb3aa88541de6c6d042d9ec
-          Darwin:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.6.0.0/cabal-install-3.6.0.0-aarch64-darwin-big-sur.tar.xz
-              dlHash: 7acf740946d996ede835edf68887e6b2f1e16d1b95e94054d266463f38d136d9
-        A_ARM:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.6.0.0/cabal-install-3.6.0.0-armv7-linux.tar.xz
-              dlHash: 11b5ca042a8bf45971224f2127a3e9d6b803f09210042ca80a254bea06f01a2e
  GHCup:
-    0.1.17.2:
+    0.1.16.2:
      viTags:
      - Recommended
      - Latest
@@ -2287,50 +2132,46 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.17.2/x86_64-linux-ghcup-0.1.17.2
-              dlHash: e9adb022b9bcfe501caca39e76ae7241af0f30fbb466a2202837a7a578607daf
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-linux-ghcup-0.1.16.2
+              dlHash: d5e43b95ce1d42263376e414f7eb7c5dd440271c7c6cd9bad446fdeff3823893
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.17.2/x86_64-apple-darwin-ghcup-0.1.17.2
-              dlHash: 9418dab0f603b25f925739d66ca2328e876ce5197c131d7e75060f8edf7c57c9
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-apple-darwin-ghcup-0.1.16.2
+              dlHash: a334620ccce7705211b2142882dde544003e6030af4b91a44c890542a90f879f
          FreeBSD:
-            '( >= 12 && < 13 )':
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.17.2/x86_64-portbld-freebsd12-ghcup-0.1.17.2
-              dlHash: b6f0558e66f95a0772a60902c2c96202d0271d8d963db436a1359f1c4e1d2947
-            '( >= 13 )':
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.17.2/x86_64-portbld-freebsd13-ghcup-0.1.17.2
-              dlHash: 5bd5760dd29117ca2797a87b79f99b804743e7e64fcdcfe6ad6436314423ef84
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-portbld-freebsd-ghcup-0.1.16.2
+              dlHash: 92359592a5694375e53b22628920086bf4bbf0faff5be018a0ed3e745a6426a9
          Windows:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.17.2/x86_64-mingw64-ghcup-0.1.17.2.exe
-              dlHash: 17ab704551c691067d590760c513891d0d0d375efb59dc3c99219fdf352fed71
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-mingw64-ghcup-0.1.16.2.exe
+              dlHash: ec78872a84213968c490675127b9aad2285980b747c68207801ae824b98c7948
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.17.2/i386-linux-ghcup-0.1.17.2
-              dlHash: eb29a33ed9798c94ed05b10c66c2cd6690a4d5aa79ed7ce6a9b8564e0c095ff4
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/i386-linux-ghcup-0.1.16.2
+              dlHash: 01968ca6decac7b6e8ba6e2c817870d3fa47289a6507e0c1ab563f7b6eec0e38
          Linux_Alpine:
            unknown_versioning: *ghcup-32
        A_ARM64:
          Linux_UnknownLinux:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.17.2/aarch64-linux-ghcup-0.1.17.2
-              dlHash: ad72641877f91f1cc5142151dafad68566f439114f96a738837ed549430173a5
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/aarch64-linux-ghcup-0.1.16.2
+              dlHash: 0bdbfc724e0ddabb266156eea83c2c4e19c6ed79dd06db0c29b7d69df8d9fa8c
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.17.2/aarch64-apple-darwin-ghcup-0.1.17.2
-              dlHash: bf8691a88627b02253c2068537dc16e7eb1d3dbb22bcb1342cb7f0d00df08fd5
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/aarch64-apple-darwin-ghcup-0.1.16.2
+              dlHash: 8854e991a2ba1350abda59dab96ce50ae7729d1ce99399d67929ef31e90f1da5
        A_ARM:
          Linux_UnknownLinux:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.17.2/armv7-linux-ghcup-0.1.17.2
-              dlHash: 03f2f8aaa8393372e9f7e16061703eda3f497b9604171825995389f3d5cc8f8f
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/armv7-linux-ghcup-0.1.16.2
+              dlHash: 983ebb5b584bfa600704216a63f94b40d36a02573834e90ef1042c8472d9ad57
  HLS:
    1.1.0:
-      viTags:
-        - old
+      viTags: []
      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#110
      viPostInstall: &hls-post-install |
        This is just the server part of your LSP configuration. Consult the README on how to
@@ -2353,8 +2194,7 @@ ghcupDownloads:
          Linux_Alpine:
            unknown_versioning: *hls-110-64
    1.2.0:
-      viTags:
-        - old
+      viTags: []
      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#120
      viPostInstall: *hls-post-install
      viArch:
@@ -2374,7 +2214,9 @@ ghcupDownloads:
          Linux_Alpine:
            unknown_versioning: *hls-120-64
    1.3.0:
-      viTags: []
+      viTags:
+        - Recommended
+        - Latest
      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#130
      viPostInstall: *hls-post-install
      viArch:
@@ -2393,50 +2235,6 @@ ghcupDownloads:
              dlHash: 46aac7be888e29a9907cf56698c1ce1475c148b5e6cc099513e9ef74a0520dcf
          Linux_Alpine:
            unknown_versioning: *hls-130-64
-    1.4.0:
-      viTags:
-        - Recommended
-        - Latest
-      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#140
-      viPostInstall: *hls-post-install
-      viSourceDL:
-        dlUri: https://downloads.haskell.org/ghcup/src/haskell-language-server/1.4.0/haskell-language-server-1.4.0.tar.gz
-        dlSubdir: haskell-language-server-1.4.0
-        dlHash: c5d7dbf7fae9aa3ed2c1184b49e82d8ac623ca786494ef6602cfe11735d28db0
-      viArch:
-        A_64:
-          Linux_UnknownLinux:
-            unknown_versioning: &hls-140-64
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.4.0/haskell-language-server-Linux-1.4.0.tar.gz
-              dlHash: f93c114441911ccce55649702adc9553cb4c9f953c37878321d2806a3525fee8
-          Darwin:
-            unknown_versioning:
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.4.0/haskell-language-server-macOS-1.4.0.tar.gz
-              dlHash: a7f0ac6be93ffb08cc239e5f5fead99b061061825f99566c1be33ee60cab62a4
-          FreeBSD:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/haskell-language-server/1.4.0/haskell-language-server-freebsd-1.4.0.tar.gz
-              dlHash: 6b2ad2398ed8c3964dea017e3d5e553b54c10ba1373d7653d2edd019854f4da2
-          Windows:
-            unknown_versioning:
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.4.0/haskell-language-server-Windows-1.4.0.tar.gz
-              dlHash: 0ec77cee750037b7a0ede817b46a913a702821f4098c6a858bcb686cb30f7efd
-          Linux_Alpine:
-            unknown_versioning: *hls-140-64
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/haskell-language-server/1.4.0/haskell-language-server-linux-aarch64-1.4.0.tar.gz
-              dlHash: 8ad97e2bf1c538e637edec194e1cd9939019955bb749cb470f34bbe5a067b001
-          Darwin:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/haskell-language-server/1.4.0/haskell-language-server-macOS-aarch64-1.4.0.tar.gz
-              dlHash: 70c6fe38e987ba44c1e19173486c01f666ffb30a74cd5a7968296a5aba4c2dd0
-        A_ARM:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/haskell-language-server/1.4.0/haskell-language-server-linux-armv7-1.4.0.tar.gz
-              dlHash: 4a921fbca06b02f3b1c0930cec5e65e9362b603e7715680ec7b150f18bd703d6
  Stack:
    2.5.1:
      viTags:
--- a/ghcup-0.0.7.yaml
+++ b/ghcup-0.0.7.yaml
--- a/ghcup.cabal
+++ b/ghcup.cabal
@@ -1,32 +1,30 @@
-cabal-version:      3.0
-name:               ghcup
-version:            0.1.17.2
-license:            LGPL-3.0-only
-license-file:       LICENSE
-copyright:          Julian Ospald 2020
-maintainer:         hasufell@posteo.de
-author:             Julian Ospald
-homepage:           https://gitlab.haskell.org/haskell/ghcup-hs
-bug-reports:        https://gitlab.haskell.org/haskell/ghcup-hs/issues
-synopsis:           ghc toolchain installer
+cabal-version:   3.0
+name:            ghcup
+version:         0.1.16.2
+license:         LGPL-3.0-only
+license-file:    LICENSE
+copyright:       Julian Ospald 2020
+maintainer:      hasufell@posteo.de
+author:          Julian Ospald
+homepage:        https://gitlab.haskell.org/haskell/ghcup-hs
+bug-reports:     https://gitlab.haskell.org/haskell/ghcup-hs/issues
+synopsis:        ghc toolchain installer
 description:
  A rewrite of the shell script ghcup, for providing
  a more stable user experience and exposing an API.

-category:           System
-build-type:         Simple
+category:        System
+build-type:      Simple
 extra-doc-files:
-  data/config.yaml
-  data/metadata/ghcup-0.0.4.yaml
-  data/metadata/ghcup-0.0.5.yaml
-  data/metadata/ghcup-0.0.6.yaml
  CHANGELOG.md
+  config.yaml
+  ghcup-0.0.4.yaml
+  ghcup-0.0.5.yaml
+  ghcup-0.0.6.yaml
+  ghcup-0.0.7.yaml
+  HACKING.md
  README.md
-
-extra-source-files:
-  data/build_mk/cross
-  data/build_mk/default
-  test/golden/GHCupInfo.json
+  RELEASING.md

 source-repository head
  type:     git
@@ -98,21 +96,22 @@ library
    , base16-bytestring     >=0.1.1.6    && <1.1
    , binary                ^>=0.8.6.0
    , bytestring            ^>=0.10
-    , Cabal
    , 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
    , haskus-utils-types    ^>=1.5
    , haskus-utils-variant  >=3.0        && <3.2
-    , HsYAML-aeson          ^>=0.2.0.0
-    , libarchive            ^>=3.0.3.0
+    , libarchive            ^>=3.0.0.0
    , lzma-static           ^>=5.2.5.3
    , megaparsec            >=8.0.0      && <9.1
+    , monad-logger          ^>=0.3.31
    , mtl                   ^>=2.2
    , optics                ^>=0.4
    , os-release            ^>=1.0.0
@@ -135,6 +134,7 @@ library
    , vector                ^>=0.12
    , versions              >=4.0.1      && <5.1
    , word8                 ^>=0.1.3
+    , yaml                  ^>=0.11.4.0
    , zlib                  ^>=0.6.2.2

  if (flag(internal-downloader) && !os(windows))
@@ -156,11 +156,7 @@ library
      , Win32    ^>=2.10

  else
-    other-modules:
-      GHCup.Utils.File.Posix
-      System.Console.Terminal.Common
-      System.Console.Terminal.Posix
-
+    other-modules: GHCup.Utils.File.Posix
    build-depends:
      , bz2              >=0.5.0.5 && <1.1
      , unix             ^>=2.7
@@ -189,20 +185,17 @@ executable ghcup
    -fwarn-incomplete-record-updates -threaded

  build-depends:
-    , aeson                 >=1.4      && <1.6
-    , aeson-pretty          ^>=0.8.8
    , async                 ^>=2.2.3
    , base                  >=4.13     && <5
    , bytestring            ^>=0.10
-    , cabal-plan            ^>=0.7.2
    , containers            ^>=0.6
    , deepseq               ^>=1.4
    , filepath              ^>=1.4.2.1
    , ghcup
    , haskus-utils-variant  >=3.0      && <3.2
-    , HsYAML-aeson          ^>=0.2.0.0
-    , libarchive            ^>=3.0.3.0
+    , libarchive            ^>=3.0.0.0
    , megaparsec            >=8.0.0    && <9.1
+    , monad-logger          ^>=0.3.31
    , mtl                   ^>=2.2
    , optparse-applicative  >=0.15.1.0 && <0.17
    , pretty                ^>=1.1.3.1
@@ -215,6 +208,7 @@ executable ghcup
    , uri-bytestring        ^>=0.3.2.2
    , utf8-string           ^>=1.0
    , versions              >=4.0.1    && <5.1
+    , yaml                  ^>=0.11.4.0

  if flag(internal-downloader)
    cpp-options: -DINTERNAL_DOWNLOADER
@@ -262,8 +256,8 @@ executable ghcup-gen
    , filepath              ^>=1.4.2.1
    , ghcup
    , haskus-utils-variant  >=3.0      && <3.2
-    , HsYAML-aeson          ^>=0.2.0.0
-    , libarchive            ^>=3.0.3.0
+    , libarchive            ^>=3.0.0.0
+    , monad-logger          ^>=0.3.31
    , mtl                   ^>=2.2
    , optics                ^>=0.4
    , optparse-applicative  >=0.15.1.0 && <0.17
@@ -275,6 +269,7 @@ executable ghcup-gen
    , text                  ^>=1.2.4.0
    , transformers          ^>=0.5
    , versions              >=4.0.1    && <5.1
+    , yaml                  ^>=0.11.4.0

 test-suite ghcup-test
  type:               exitcode-stdio-1.0
--- a/test/golden/GHCupInfo.json
+++ b/test/golden/GHCupInfo.json
--- a/lib/GHCup.hs
+++ b/lib/GHCup.hs
--- a/lib/GHCup/Download.hs
+++ b/lib/GHCup/Download.hs
@@ -1,7 +1,10 @@
 {-# LANGUAGE CPP                   #-}
 {-# LANGUAGE DataKinds             #-}
+{-# LANGUAGE DeriveGeneric         #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE TemplateHaskell       #-}
 {-# LANGUAGE TypeApplications      #-}
 {-# LANGUAGE TypeFamilies          #-}

@@ -31,11 +34,10 @@ import           GHCup.Download.Utils
 #endif
 import           GHCup.Errors
 import           GHCup.Types
-import           GHCup.Types.Optics
 import           GHCup.Types.JSON               ( )
+import           GHCup.Types.Optics
 import           GHCup.Utils.Dirs
 import           GHCup.Utils.File
-import           GHCup.Utils.Logger
 import           GHCup.Utils.Prelude
 import           GHCup.Version

@@ -45,6 +47,7 @@ import           Control.Monad
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
 #endif
+import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
                                         hiding ( throwM )
@@ -54,8 +57,8 @@ import           Data.ByteString                ( ByteString )
 #if defined(INTERNAL_DOWNLOADER)
 import           Data.CaseInsensitive           ( mk )
 #endif
+import           Data.List.Extra
 import           Data.Maybe
-import           Data.List
 import           Data.Time.Clock
 import           Data.Time.Clock.POSIX
 import           Data.Versions
@@ -69,7 +72,6 @@ import           Prelude                 hiding ( abs
                                                , readFile
                                                , writeFile
                                                )
-import           Safe
 import           System.Directory
 import           System.Environment
 import           System.Exit
@@ -87,7 +89,7 @@ import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 import qualified Data.Text.IO                  as T
 import qualified Data.Text.Encoding            as E
-import qualified Data.YAML.Aeson               as Y
+import qualified Data.Yaml                     as Y



@@ -109,13 +111,13 @@ getDownloadsF :: ( FromJSONKey Tool
                 , HasDirs env
                 , MonadIO m
                 , MonadCatch m
-                 , HasLog env
+                 , MonadLogger m
                 , MonadThrow m
                 , MonadFail m
                 , MonadMask m
                 )
              => Excepts
-                   '[DigestError, GPGError, JSONError , DownloadFailed , FileDoesNotExistError]
+                   '[JSONError , DownloadFailed , FileDoesNotExistError]
                   m
                   GHCupInfo
 getDownloadsF = do
@@ -162,58 +164,50 @@ getBase :: ( MonadReader env m
           , MonadFail m
           , MonadIO m
           , MonadCatch m
-           , HasLog env
+           , MonadLogger m
           , MonadMask m
           )
        => URI
-        -> Excepts '[GPGError, DigestError, JSONError, FileDoesNotExistError] m GHCupInfo
+        -> Excepts '[JSONError] m GHCupInfo
 getBase uri = do
-  Settings { noNetwork, downloader } <- lift getSettings
+  Settings { noNetwork } <- lift getSettings

  -- try to download yaml... usually this writes it into cache dir,
  -- but in some cases not (e.g. when using file://), so we honour
  -- the return filepath, if any
  mYaml <- if noNetwork && view (uriSchemeL' % schemeBSL') uri /= "file" -- for file://, let it fall through
           then pure Nothing
-           else handleIO (\e -> lift (warnCache (displayException e) downloader) >> pure Nothing)
-               . catchE @_ @_ @'[] (\e@(DownloadFailed _) -> lift (warnCache (prettyShow e) downloader) >> pure Nothing)
+           else handleIO (\e -> warnCache (displayException e) >> pure Nothing)
+               . catchE @_ @_ @'[] (\e@(DownloadFailed _) -> warnCache (prettyShow e) >> pure Nothing)
+               . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed
               . fmap Just
               . smartDl
               $ uri

  -- if we didn't get a filepath from the download, use the cached yaml
  actualYaml <- maybe (lift $ yamlFromCache uri) pure mYaml
-  yamlContents <- liftIOException doesNotExistErrorType (FileDoesNotExistError actualYaml) $ liftIO $ L.readFile actualYaml
-  lift $ logDebug $ "Decoding yaml at: " <> T.pack actualYaml
+  lift $ $(logDebug) $ "Decoding yaml at: " <> T.pack actualYaml

  liftE
    . onE_ (onError actualYaml)
-    . lE' @_ @_ @'[JSONError] JSONDecodeError
-    . first (\(_, e) -> unlines [e, "Consider removing " <> actualYaml <> " manually."])
-    . Y.decode1
-    $ yamlContents
+    . lEM' @_ @_ @'[JSONError] JSONDecodeError
+    . fmap (first (\e -> unlines [displayException e
+                                 ,"Consider removing " <> actualYaml <> " manually."]))
+    . liftIO
+    . Y.decodeFileEither
+    $ actualYaml
 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 :: (MonadReader env m, HasLog env, MonadMask m, MonadCatch m, MonadIO m) => FilePath -> m ()
+  onError :: (MonadLogger m, MonadMask m, MonadCatch m, MonadIO m) => FilePath -> m ()
  onError fp = do
    let efp = etagsFile fp
-    handleIO (\e -> logWarn $ "Couldn't remove file " <> T.pack efp <> ", error was: " <> T.pack (displayException e))
+    handleIO (\e -> $(logWarn) $ "Couldn't remove file " <> T.pack efp <> ", error was: " <> T.pack (displayException e))
      (hideError doesNotExistErrorType $ rmFile efp)
    liftIO $ hideError doesNotExistErrorType $ setAccessTime fp (posixSecondsToUTCTime (fromIntegral @Int 0))
-
-  warnCache :: (MonadReader env m, HasLog env, MonadMask m, MonadCatch m, MonadIO m) => FilePath -> Downloader -> m ()
-  warnCache s downloader' = do
-    let tryDownloder = case downloader' of
-                         Curl -> "Wget"
-                         Wget -> "Curl"
-#if defined(INTERNAL_DOWNLOADER)
-                         Internal -> "Curl"
-#endif
-    logWarn $ "Could not get download info, trying cached version (this may not be recent!)" <> "\n" <>
-      "If this problem persists, consider switching downloader via: " <> "\n    " <>
-      "ghcup config set downloader " <> tryDownloder
-    logDebug $ "Error was: " <> T.pack s
+  warnCache s = do
+    lift $ $(logWarn) "Could not get download info, trying cached version (this may not be recent!)"
+    lift $ $(logDebug) $ "Error was: " <> T.pack s

  -- 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
@@ -227,14 +221,13 @@ getBase uri = do
             , MonadCatch m1
             , MonadIO m1
             , MonadFail m1
-             , HasLog env1
+             , MonadLogger m1
             , MonadMask m1
             )
          => URI
          -> Excepts
               '[ DownloadFailed
                , DigestError
-                , GPGError
                ]
               m1
               FilePath
@@ -246,7 +239,7 @@ getBase uri = do
    Dirs { cacheDir } <- lift getDirs

       -- for local files, let's short-circuit and ignore access time
-    if | scheme == "file" -> liftE $ download uri' Nothing Nothing cacheDir Nothing True
+    if | scheme == "file" -> liftE $ download uri' Nothing cacheDir Nothing True
       | e -> do
          accessTime <- liftIO $ getAccessTime json_file

@@ -259,7 +252,7 @@ getBase uri = do
   where
    dlWithMod modTime json_file = do
      let (dir, fn) = splitFileName json_file
-      f <- liftE $ download uri' (Just $ over pathL' (<> ".sig") uri') Nothing dir (Just fn) True
+      f <- liftE $ download uri' Nothing dir (Just fn) True
      liftIO $ setModificationTime f modTime
      liftIO $ setAccessTime f modTime
      pure f
@@ -319,22 +312,21 @@ download :: ( MonadReader env m
            , HasDirs env
            , MonadMask m
            , MonadThrow m
-            , HasLog env
+            , MonadLogger m
            , MonadIO m
            )
         => URI
-         -> Maybe URI         -- ^ URI for gpg sig
         -> Maybe T.Text      -- ^ expected hash
         -> FilePath          -- ^ destination dir (ignored for file:// scheme)
         -> Maybe FilePath    -- ^ optional filename
         -> Bool              -- ^ whether to read an write etags
-         -> Excepts '[DigestError , DownloadFailed, GPGError] m FilePath
-download uri gpgUri eDigest dest mfn etags
+         -> Excepts '[DigestError , DownloadFailed] m FilePath
+download uri eDigest dest mfn etags
  | scheme == "https" = dl
  | scheme == "http"  = dl
  | scheme == "file"  = do
-      let destFile' = T.unpack . decUTF8Safe $ view pathL' uri
-      lift $ logDebug $ "using local file: " <> T.pack destFile'
+      let destFile' = T.unpack . decUTF8Safe $ path
+      lift $ $(logDebug) $ "using local file: " <> T.pack destFile'
      forM_ eDigest (liftE . flip checkDigest destFile')
      pure destFile'
  | otherwise = throwE $ DownloadFailed (variantFromValue UnsupportedScheme)
@@ -342,207 +334,143 @@ download uri gpgUri eDigest dest mfn etags
 where
  scheme = view (uriSchemeL' % schemeBSL') uri
  dl = do
-    baseDestFile <- liftE . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed $ getDestFile uri mfn
-    lift $ logInfo $ "downloading: " <> (decUTF8Safe . serializeURIRef') uri <> " as file " <> T.pack baseDestFile
+    destFile <- liftE . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed $ getDestFile
+    lift $ $(logInfo) $ "downloading: " <> uri' <> " as file " <> T.pack destFile

    -- destination dir must exist
    liftIO $ createDirRecursive' dest

-
    -- download
    flip onException
-         (lift $ hideError doesNotExistErrorType $ recycleFile (tmpFile baseDestFile))
-     $ catchAllE @_ @'[GPGError, ProcessError, DownloadFailed, UnsupportedScheme, DigestError] @'[DigestError, DownloadFailed, GPGError]
-          (\e' -> do
-            lift $ hideError doesNotExistErrorType $ recycleFile (tmpFile baseDestFile)
-            case e' of
-              V e@GPGError {} -> throwE e
-              V e@DigestError {} -> throwE e
-              _ -> throwE (DownloadFailed e')
+         (lift $ hideError doesNotExistErrorType $ recycleFile destFile)
+     $ catchAllE @_ @'[ProcessError, DownloadFailed, UnsupportedScheme]
+          (\e ->
+            lift (hideError doesNotExistErrorType $ recycleFile destFile)
+              >> (throwE . DownloadFailed $ e)
          ) $ do
-              Settings{ downloader, noNetwork, gpgSetting } <- lift getSettings
+              Settings{ downloader, noNetwork } <- lift getSettings
              when noNetwork $ throwE (DownloadFailed (V NoNetwork :: V '[NoNetwork]))
-              downloadAction <- case downloader of
-                    Curl -> do
-                      o' <- liftIO getCurlOpts
-                      if etags
-                        then pure $ curlEtagsDL o'
-                        else pure $ curlDL o'
-                    Wget -> do
-                      o' <- liftIO getWgetOpts
-                      if etags
-                        then pure $ wgetEtagsDL o'
-                        else pure $ wgetDL o'
+              case downloader of
+                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", "If-None-Match: " <> T.unpack 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 . getLastHeader $ headers of
+                            Just (http':sc:_)
+                              | sc == "304"
+                              , T.pack "HTTP" `T.isPrefixOf` http' -> $logDebug "Status code was 304, not overwriting"
+                              | T.pack "HTTP" `T.isPrefixOf` http' -> do
+                                  $logDebug $ "Status code was " <> sc <> ", overwriting"
+                                  liftIO $ copyFile (destFile <.> "tmp") destFile
+                            _ -> liftE $ throwE @_ @'[DownloadFailed] (DownloadFailed (toVariantAt @0 (MalformedHeaders headers)
+                              :: V '[MalformedHeaders]))
+
+                          writeEtags destFile (parseEtags headers)
+                    else
+                      liftE $ lEM @_ @'[ProcessError] $ exec "curl" 
+                        (o' ++ ["-fL", "-o", destFile, T.unpack uri']) 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", "If-None-Match: " <> T.unpack 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 destFile (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 destFile (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
 #if defined(INTERNAL_DOWNLOADER)
-                    Internal -> do
-                      if etags
-                        then pure (\fp -> liftE . internalEtagsDL fp)
-                        else pure (\fp -> liftE . internalDL fp)
+                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 destFile (pure $ Just etag))
+                        $ do
+                          r <- downloadToFile https host fullPath port destFile addHeaders
+                          writeEtags destFile (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
 #endif
-              liftE $ downloadAction baseDestFile uri
-              case (gpgUri, gpgSetting) of
-                (_, GPGNone) -> pure ()
-                (Just gpgUri', _) -> do
-                  gpgDestFile <- liftE . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed $ getDestFile gpgUri' Nothing
-                  liftE $ flip onException
-                       (lift $ hideError doesNotExistErrorType $ recycleFile (tmpFile gpgDestFile))
-                   $ catchAllE @_ @'[GPGError, ProcessError, UnsupportedScheme, DownloadFailed] @'[GPGError]
-                        (\e -> if gpgSetting == GPGStrict then throwE (GPGError e) else lift $ logWarn $ T.pack (prettyShow (GPGError e))
-                        ) $ do
-                      o' <- liftIO getGpgOpts
-                      lift $ logDebug $ "downloading: " <> (decUTF8Safe . serializeURIRef') gpgUri' <> " as file " <> T.pack gpgDestFile
-                      liftE $ downloadAction gpgDestFile gpgUri'
-                      lift $ logInfo $ "verifying signature of: " <> T.pack baseDestFile
-                      let args = o' ++ ["--batch", "--verify", "--quiet", "--no-tty", gpgDestFile, baseDestFile]
-                      cp <- lift $ executeOut "gpg" args Nothing
-                      case cp of
-                        CapturedProcess { _exitCode = ExitFailure i, _stdErr } -> do
-                          lift $ logDebug $ decUTF8Safe' _stdErr
-                          throwE (GPGError @'[ProcessError] (V (NonZeroExit i "gpg" args)))
-                        CapturedProcess { _stdErr } -> lift $ logDebug $ decUTF8Safe' _stdErr
-                _ -> pure ()

-              forM_ eDigest (liftE . flip checkDigest baseDestFile)
-    pure baseDestFile
-
-  curlDL :: (MonadCatch m, MonadMask m, MonadIO m) => [String] -> FilePath -> URI -> Excepts '[ProcessError, DownloadFailed, UnsupportedScheme] m ()
-  curlDL o' destFile (decUTF8Safe . serializeURIRef' -> uri') = do
-    let destFileTemp = tmpFile destFile
-    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-      liftE $ lEM @_ @'[ProcessError] $ exec "curl"
-        (o' ++ ["-fL", "-o", destFileTemp, T.unpack uri']) Nothing Nothing
-      liftIO $ renameFile destFileTemp destFile
-
-  curlEtagsDL :: (MonadReader env m, HasLog env, MonadCatch m, MonadMask m, MonadIO m)
-              => [String] -> FilePath -> URI -> Excepts '[ProcessError, DownloadFailed, UnsupportedScheme] m ()
-  curlEtagsDL o' destFile (decUTF8Safe . serializeURIRef' -> uri') = do
-    let destFileTemp = tmpFile destFile
-    dh <- liftIO $ emptySystemTempFile "curl-header"
-    flip finally (try @_ @SomeException $ rmFile dh) $
-      flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-        metag <- lift $ readETag destFile
-        liftE $ lEM @_ @'[ProcessError] $ exec "curl"
-            (o' ++ (if etags then ["--dump-header", dh] else [])
-                ++ maybe [] (\t -> ["-H", "If-None-Match: " <> T.unpack t]) metag
-                ++ ["-fL", "-o", destFileTemp, 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 . getLastHeader $ headers of
-          Just (http':sc:_)
-            | sc == "304"
-            , T.pack "HTTP" `T.isPrefixOf` http' -> lift $ logDebug "Status code was 304, not overwriting"
-            | T.pack "HTTP" `T.isPrefixOf` http' -> do
-                lift $ logDebug $ "Status code was " <> sc <> ", overwriting"
-                liftIO $ renameFile destFileTemp destFile
-          _ -> liftE $ throwE @_ @'[DownloadFailed] (DownloadFailed (toVariantAt @0 (MalformedHeaders headers)
-            :: V '[MalformedHeaders]))
-
-        lift $ writeEtags destFile (parseEtags headers)
-
-  wgetDL :: (MonadCatch m, MonadMask m, MonadIO m) => [String] -> FilePath -> URI -> Excepts '[ProcessError, DownloadFailed, UnsupportedScheme] m ()
-  wgetDL o' destFile (decUTF8Safe . serializeURIRef' -> uri') = do
-    let destFileTemp = tmpFile destFile
-    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-      let opts = o' ++ ["-O", destFileTemp , T.unpack uri']
-      liftE $ lEM @_ @'[ProcessError] $ exec "wget" opts Nothing Nothing
-      liftIO $ renameFile destFileTemp destFile
-
-
-  wgetEtagsDL :: (MonadReader env m, HasLog env, MonadCatch m, MonadMask m, MonadIO m)
-              => [String] -> FilePath -> URI -> Excepts '[ProcessError, DownloadFailed, UnsupportedScheme] m ()
-  wgetEtagsDL o' destFile (decUTF8Safe . serializeURIRef' -> uri') = do
-    let destFileTemp = tmpFile destFile
-    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-      metag <- lift $ readETag destFile
-      let opts = o' ++ maybe [] (\t -> ["--header", "If-None-Match: " <> T.unpack t]) metag
-                    ++ ["-q", "-S", "-O", destFileTemp , T.unpack uri']
-      CapturedProcess {_exitCode, _stdErr} <- lift $ executeOut "wget" opts Nothing
-      case _exitCode of
-        ExitSuccess -> do
-          liftIO $ renameFile destFileTemp destFile
-          lift $ writeEtags destFile (parseEtags (decUTF8Safe' _stdErr))
-        ExitFailure i'
-          | i' == 8
-          , Just _ <- find (T.pack "304 Not Modified" `T.isInfixOf`) . T.lines . decUTF8Safe' $ _stdErr
-                   -> do
-                        lift $ logDebug "Not modified, skipping download"
-                        lift $ writeEtags destFile (parseEtags (decUTF8Safe' _stdErr))
-          | otherwise -> throwE (NonZeroExit i' "wget" opts)
-
-#if defined(INTERNAL_DOWNLOADER)
-  internalDL :: (MonadCatch m, MonadMask m, MonadIO m)
-             => FilePath -> URI -> Excepts '[DownloadFailed, UnsupportedScheme] m ()
-  internalDL destFile uri' = do
-    let destFileTemp = tmpFile destFile
-    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-      (https, host, fullPath, port) <- liftE $ uriToQuadruple uri'
-      void $ liftE $ catchE @HTTPNotModified
-                 @'[DownloadFailed]
-            (\e@(HTTPNotModified _) ->
-              throwE @_ @'[DownloadFailed] (DownloadFailed (toVariantAt @0 e :: V '[HTTPNotModified])))
-        $ downloadToFile https host fullPath port destFileTemp mempty
-      liftIO $ renameFile destFileTemp destFile
-
-
-  internalEtagsDL :: (MonadReader env m, HasLog env, MonadCatch m, MonadMask m, MonadIO m)
-                  => FilePath -> URI -> Excepts '[DownloadFailed, UnsupportedScheme] m ()
-  internalEtagsDL destFile uri' = do
-    let destFileTemp = tmpFile destFile
-    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-      (https, host, fullPath, port) <- liftE $ uriToQuadruple uri'
-      metag <- lift $ 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 destFile (pure $ Just etag))
-        $ do
-          r <- downloadToFile https host fullPath port destFileTemp addHeaders
-          liftIO $ renameFile destFileTemp destFile
-          lift $ writeEtags destFile (pure $ decUTF8Safe <$> getHeader r "etag")
-#endif
+    forM_ eDigest (liftE . flip checkDigest destFile)
+    pure destFile


  -- Manage to find a file we can write the body into.
-  getDestFile :: Monad m => URI -> Maybe FilePath -> Excepts '[NoUrlBase] m FilePath
-  getDestFile uri' mfn' = 
-    let path = view pathL' uri'
-    in case mfn' of
+  getDestFile :: Monad m => Excepts '[NoUrlBase] m FilePath
+  getDestFile = 
+    case mfn of
        Just fn -> pure (dest </> fn)
        Nothing
          | let urlBase = T.unpack (decUTF8Safe (urlBaseName path))
          , not (null urlBase) -> pure (dest </> urlBase)
          -- TODO: remove this once we use hpath again
-          | otherwise -> throwE $ NoUrlBase (decUTF8Safe . serializeURIRef' $ uri')
+          | otherwise -> throwE $ NoUrlBase uri'

-  parseEtags :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m) => T.Text -> m (Maybe T.Text)
+  path = view pathL' uri
+  uri' = decUTF8Safe (serializeURIRef' 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 . getLastHeader $ stderr
    case T.words <$> mEtag of
      (Just []) -> do
-        logDebug "Couldn't parse etags, no input: "
+        $logDebug "Couldn't parse etags, no input: "
        pure Nothing
      (Just [_, etag']) -> do
-        logDebug $ "Parsed etag: " <> etag'
+        $logDebug $ "Parsed etag: " <> etag'
        pure (Just etag')
      (Just xs) -> do
-        logDebug ("Couldn't parse etags, unexpected input: " <> T.unwords xs)
+        $logDebug ("Couldn't parse etags, unexpected input: " <> T.unwords xs)
        pure Nothing
      Nothing -> do
-        logDebug "No etags header found"
+        $logDebug "No etags header found"
        pure Nothing

-  writeEtags :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m) => FilePath -> m (Maybe T.Text) -> m ()
+  writeEtags :: (MonadLogger m, MonadIO m, MonadThrow m) => FilePath -> m (Maybe T.Text) -> m ()
  writeEtags destFile getTags = do
    getTags >>= \case
      Just t -> do
-        logDebug $ "Writing etagsFile " <> T.pack (etagsFile destFile)
+        $logDebug $ "Writing etagsFile " <> T.pack (etagsFile destFile)
        liftIO $ T.writeFile (etagsFile destFile) t
      Nothing ->
-        logDebug "No etags files written"
+        $logDebug "No etags files written"

-  readETag :: (MonadReader env m, HasLog env, MonadCatch m, MonadIO m) => FilePath -> m (Maybe T.Text)
+  readETag :: (MonadLogger m, MonadCatch m, MonadIO m) => FilePath -> m (Maybe T.Text)
  readETag fp = do
    e <- liftIO $ doesFileExist fp
    if e
@@ -550,13 +478,13 @@ download uri gpgUri eDigest dest mfn etags
      rE <- try @_ @SomeException $ liftIO $ fmap stripNewline' $ T.readFile (etagsFile fp)
      case rE of
        (Right et) -> do
-          logDebug $ "Read etag: " <> et
+          $logDebug $ "Read etag: " <> et
          pure (Just et)
        (Left _) -> do
-          logDebug "Etag file doesn't exist (yet)"
+          $logDebug "Etag file doesn't exist (yet)"
          pure Nothing
    else do
-      logDebug $ "Skipping and deleting etags file because destination file " <> T.pack fp <> " doesn't exist"
+      $logDebug $ "Skipping and deleting etags file because destination file " <> T.pack fp <> " doesn't exist"
      liftIO $ hideError doesNotExistErrorType $ rmFile (etagsFile fp)
      pure Nothing

@@ -569,20 +497,20 @@ downloadCached :: ( MonadReader env m
                  , MonadMask m
                  , MonadResource m
                  , MonadThrow m
-                  , HasLog env
+                  , MonadLogger m
                  , MonadIO m
                  , MonadUnliftIO m
                  )
               => DownloadInfo
               -> Maybe FilePath  -- ^ optional filename
-               -> Excepts '[DigestError , DownloadFailed, GPGError] m FilePath
+               -> Excepts '[DigestError , DownloadFailed] m FilePath
 downloadCached dli mfn = do
  Settings{ cache } <- lift getSettings
  case cache of
    True -> downloadCached' dli mfn Nothing
    False -> do
      tmp <- lift withGHCupTmpDir
-      liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) tmp mfn False
+      liftE $ download (_dlUri dli) (Just (_dlHash dli)) tmp mfn False


 downloadCached' :: ( MonadReader env m
@@ -590,14 +518,14 @@ downloadCached' :: ( MonadReader env m
                   , HasSettings env
                   , MonadMask m
                   , MonadThrow m
-                   , HasLog env
+                   , MonadLogger m
                   , MonadIO m
                   , MonadUnliftIO m
                   )
                => DownloadInfo
                -> Maybe FilePath  -- ^ optional filename
                -> Maybe FilePath  -- ^ optional destination dir (default: cacheDir)
-                -> Excepts '[DigestError , DownloadFailed, GPGError] m FilePath
+                -> Excepts '[DigestError , DownloadFailed] m FilePath
 downloadCached' dli mfn mDestDir = do
  Dirs { cacheDir } <- lift getDirs
  let destDir = fromMaybe cacheDir mDestDir
@@ -608,7 +536,7 @@ downloadCached' dli mfn mDestDir = do
    | fileExists -> do
      liftE $ checkDigest (view dlHash dli) cachfile
      pure cachfile
-    | otherwise -> liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) destDir mfn False
+    | otherwise -> liftE $ download (_dlUri dli) (Just (_dlHash dli)) destDir mfn False



@@ -624,7 +552,7 @@ checkDigest :: ( MonadReader env m
               , HasSettings env
               , MonadIO m
               , MonadThrow m
-               , HasLog env
+               , MonadLogger m
               )
            => T.Text     -- ^ the hash
            -> FilePath
@@ -634,10 +562,10 @@ checkDigest eDigest file = do
  let verify = not noVerify
  when verify $ do
    let p' = takeFileName file
-    lift $ logInfo $ "verifying digest of: " <> T.pack p'
+    lift $ $(logInfo) $ "verifying digest of: " <> T.pack p'
    c <- liftIO $ L.readFile file
    cDigest <- throwEither . E.decodeUtf8' . B16.encode . SHA256.hashlazy $ c
-    when ((cDigest /= eDigest) && verify) $ throwE (DigestError file cDigest eDigest)
+    when ((cDigest /= eDigest) && verify) $ throwE (DigestError cDigest eDigest)


 -- | Get additional curl args from env. This is an undocumented option.
@@ -655,12 +583,6 @@ getWgetOpts =
    Just r  -> pure $ splitOn " " r
    Nothing -> pure []

-- | Get additional gpg args from env. This is an undocumented option.
-getGpgOpts :: IO [String]
-getGpgOpts =
-  lookupEnv "GHCUP_GPG_OPTS" >>= \case
-    Just r  -> pure $ splitOn " " r
-    Nothing -> pure []

 -- | Get the url base name.
 --
@@ -682,7 +604,3 @@ urlBaseName = snd . B.breakEnd (== _slash) . urlDecode False
 -- "HTTP/1.1 304 Not Modified\n"
 getLastHeader :: T.Text -> T.Text
 getLastHeader = T.unlines . lastDef [] . filter (\x -> not (null x)) . splitOn [""] . fmap T.stripEnd . T.lines
-
-
-tmpFile :: FilePath -> FilePath
-tmpFile = (<.> "tmp")
--- a/lib/GHCup/Errors.hs
+++ b/lib/GHCup/Errors.hs
@@ -50,7 +50,7 @@ instance Pretty NoCompatiblePlatform where
  pPrint (NoCompatiblePlatform str') =
    text ("Could not find a compatible platform. Got: " ++ str')

-- | Unable to find a download for the requested version/distro.
+-- | Unable to find a download for the requested versio/distro.
 data NoDownload = NoDownload
  deriving Show

@@ -149,8 +149,6 @@ instance Pretty NotInstalled where
 data NotFoundInPATH = NotFoundInPATH FilePath
  deriving Show

-instance Exception NotFoundInPATH
-
 instance Pretty NotFoundInPATH where
  pPrint (NotFoundInPATH exe) =
    text $ "The exe " <> exe <> " was not found in PATH."
@@ -190,22 +188,12 @@ instance Pretty TarDirDoesNotExist where
    text "Tar directory does not exist:" <+> pPrint dir

 -- | File digest verification failed.
-data DigestError = DigestError FilePath Text Text
+data DigestError = DigestError Text Text
  deriving Show

 instance Pretty DigestError where
-  pPrint (DigestError fp currentDigest expectedDigest) =
-    text "Digest error for" <+> text (fp <> ": expected")
-      <+> text (T.unpack expectedDigest) <+> text "but got" <+> pPrint currentDigest <+> text
-      "\nConsider removing the file in case it's cached and try again."
-
-- | File digest verification failed.
-data GPGError = forall xs . (ToVariantMaybe DownloadFailed xs, PopVariant DownloadFailed xs, Show (V xs), Pretty (V xs)) => GPGError (V xs)
-
-deriving instance Show GPGError
-
-instance Pretty GPGError where
-  pPrint (GPGError reason) = text "GPG verify failed:" <+> pPrint reason
+  pPrint (DigestError currentDigest expectedDigest) =
+    text "Digest error: expected" <+> text (T.unpack expectedDigest) <+> text "but got" <+> pPrint currentDigest

 -- | Unexpected HTTP status.
 data HTTPStatusError = HTTPStatusError Int (M.Map (CI ByteString) ByteString)
@@ -297,37 +285,31 @@ instance Pretty HadrianNotFound where
    -------------------------

 -- | A download failed. The underlying error is encapsulated.
-data DownloadFailed = forall xs . (ToVariantMaybe DownloadFailed xs, PopVariant DownloadFailed xs, Show (V xs), Pretty (V xs)) => DownloadFailed (V xs)
+data DownloadFailed = forall x xs . (Show x, Show (V xs), Pretty x, Pretty (V xs)) => DownloadFailed (V (x ': xs))

 instance Pretty DownloadFailed where
  pPrint (DownloadFailed reason) =
-    case reason of
-      VMaybe (_ :: DownloadFailed) -> pPrint reason
-      _ -> text "Download failed:" <+> pPrint reason
+    text "Download failed:" <+> pPrint reason

 deriving instance Show DownloadFailed


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

 instance Pretty BuildFailed where
  pPrint (BuildFailed path reason) =
-    case reason of
-      VMaybe (_ :: BuildFailed) -> pPrint reason
-      _ -> text "BuildFailed failed in dir" <+> text (path <> ":") <+> pPrint reason
+    text "BuildFailed failed in dir" <+> text (path <> ":") <+> pPrint reason

 deriving instance Show BuildFailed


 -- | Setting the current GHC version failed.
-data GHCupSetError = forall es . (ToVariantMaybe GHCupSetError es, PopVariant GHCupSetError es, Show (V es), Pretty (V es)) => GHCupSetError (V es)
+data GHCupSetError = forall es . (Show (V es), Pretty (V es)) => GHCupSetError (V es)

 instance Pretty GHCupSetError where
  pPrint (GHCupSetError reason) =
-    case reason of
-      VMaybe (_ :: GHCupSetError) -> pPrint reason
-      _ -> text "Setting the current GHC version failed:" <+> pPrint reason
+    text "Setting the current GHC version failed:" <+> pPrint reason

 deriving instance Show GHCupSetError

--- a/lib/GHCup/Platform.hs
+++ b/lib/GHCup/Platform.hs
@@ -20,16 +20,15 @@ module GHCup.Platform where

 import           GHCup.Errors
 import           GHCup.Types
-import           GHCup.Types.Optics
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.File
-import           GHCup.Utils.Logger
 import           GHCup.Utils.Prelude
 import           GHCup.Utils.String.QQ

 import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
+import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Data.ByteString                ( ByteString )
 import           Data.Foldable
@@ -58,7 +57,7 @@ import qualified Data.Text.IO                  as T


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


-getPlatform :: (Alternative m, MonadReader env m, HasLog env, MonadCatch m, MonadIO m, MonadFail m)
+getPlatform :: (Alternative m, MonadLogger m, MonadCatch m, MonadIO m, MonadFail m)
            => Excepts
                 '[NoCompatiblePlatform, DistroNotFound]
                 m
@@ -108,7 +107,7 @@ getPlatform = do
      pure $ PlatformResult { _platform = FreeBSD, _distroVersion = ver }
    "mingw32" -> pure PlatformResult { _platform = Windows, _distroVersion = Nothing }
    what -> throwE $ NoCompatiblePlatform what
-  lift $ logDebug $ "Identified Platform as: " <> T.pack (prettyShow pfr)
+  lift $ $(logDebug) $ "Identified Platform as: " <> T.pack (prettyShow pfr)
  pure pfr
 where
  getFreeBSDVersion = lift $ fmap _stdOut $ executeOut "freebsd-version" [] Nothing
@@ -142,7 +141,9 @@ getLinuxDistro = do
        | otherwise                -> UnknownLinux
  pure (distro, parsedVer)
 where
-  hasWord t = any (\x -> match (regex x) (T.unpack t))
+  hasWord t matches = foldr (\x y -> match (regex x) (T.unpack t) || y)
+                            False
+                            matches
   where
    regex x = makeRegexOpts compIgnoreCase execBlank ([s|\<|] ++ x ++ [s|\>|])

--- a/lib/GHCup/Requirements.hs
+++ b/lib/GHCup/Requirements.hs
@@ -60,10 +60,9 @@ getCommonRequirements pr tr =
 prettyRequirements :: Requirements -> T.Text
 prettyRequirements Requirements {..} =
  let d = if not . null $ _distroPKGs
-        then "\n  Please ensure the following distro packages "
-          <> "are installed before continuing (you can exit ghcup "
-          <> "and return at any time): "
-          <> T.intercalate " " _distroPKGs
+        then
+          "\n  Please install the following distro packages: "
+            <> T.intercalate " " _distroPKGs
        else ""
      n = if not . T.null $ _notes then "\n  Note: " <> _notes else ""
  in  "System requirements " <> d <> n
--- a/lib/GHCup/Types.hs
+++ b/lib/GHCup/Types.hs
@@ -25,17 +25,21 @@ 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.Text                      ( Text )
 import           Data.Versions
+import           Haskus.Utils.Variant.Excepts
 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 GHC.Generics                  as GHC

@@ -148,7 +152,7 @@ data Tag = Latest
         | Recommended
         | Prerelease
         | Base PVP
-         | Old                -- ^ old versions are hidden by default in TUI
+         | Old                -- ^ old version are hidden by default in TUI
         | UnknownTag String  -- ^ used for upwardscompat
         deriving (Ord, Eq, GHC.Generic, Show) -- FIXME: manual JSON instance

@@ -223,6 +227,7 @@ data LinuxDistro = Debian
                 | RedHat
                 | Alpine
                 | AmazonLinux
+                 | Solus
                 -- rolling
                 | Gentoo
                 | Exherbo
@@ -236,12 +241,13 @@ instance NFData LinuxDistro
 distroToString :: LinuxDistro -> String
 distroToString Debian = "debian"
 distroToString Ubuntu = "ubuntu"
-distroToString Mint = "mint"
+distroToString Mint= "mint"
 distroToString Fedora = "fedora"
 distroToString CentOS = "centos"
 distroToString RedHat = "redhat"
 distroToString Alpine = "alpine"
 distroToString AmazonLinux = "amazon"
+distroToString Solus = "solus"
 distroToString Gentoo = "gentoo"
 distroToString Exherbo = "exherbo"
 distroToString UnknownLinux = "unknown"
@@ -301,12 +307,11 @@ data UserSettings = UserSettings
  , uKeyBindings :: Maybe UserKeyBindings
  , uUrlSource   :: Maybe URLSource
  , uNoNetwork   :: Maybe Bool
-  , uGPGSetting  :: Maybe GPGSetting
  }
  deriving (Show, GHC.Generic)

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

 fromSettings :: Settings -> Maybe KeyBindings -> UserSettings
 fromSettings Settings{..} Nothing =
@@ -319,7 +324,6 @@ fromSettings Settings{..} Nothing =
    , uNoNetwork = Just noNetwork
    , uKeyBindings = Nothing
    , uUrlSource = Just urlSource
-    , uGPGSetting = Just gpgSetting
  }
 fromSettings Settings{..} (Just KeyBindings{..}) =
  let ukb = UserKeyBindings
@@ -342,7 +346,6 @@ fromSettings Settings{..} (Just KeyBindings{..}) =
    , uNoNetwork = Just noNetwork
    , uKeyBindings = Just ukb
    , uUrlSource = Just urlSource
-    , uGPGSetting = Just gpgSetting
  }

 data UserKeyBindings = UserKeyBindings
@@ -393,7 +396,6 @@ data AppState = AppState
  , keyBindings :: KeyBindings
  , ghcupInfo :: GHCupInfo
  , pfreq :: PlatformRequest
-  , loggerConfig :: LoggerConfig
  } deriving (Show, GHC.Generic)

 instance NFData AppState
@@ -402,7 +404,6 @@ data LeanAppState = LeanAppState
  { settings :: Settings
  , dirs :: Dirs
  , keyBindings :: KeyBindings
-  , loggerConfig :: LoggerConfig
  } deriving (Show, GHC.Generic)

 instance NFData LeanAppState
@@ -416,8 +417,6 @@ data Settings = Settings
  , verbose    :: Bool
  , urlSource  :: URLSource
  , noNetwork  :: Bool
-  , gpgSetting :: GPGSetting
-  , noColor    :: Bool -- this also exists in LoggerConfig
  }
  deriving (Show, GHC.Generic)

@@ -451,13 +450,6 @@ data Downloader = Curl

 instance NFData Downloader

-data GPGSetting = GPGStrict
-                | GPGLax
-                | GPGNone
-  deriving (Eq, Show, Ord, GHC.Generic)
-
-instance NFData GPGSetting
-
 data DebugInfo = DebugInfo
  { diBaseDir  :: FilePath
  , diBinDir   :: FilePath
@@ -563,26 +555,14 @@ instance Pretty Versioning where
 instance Pretty Version where
  pPrint = text . T.unpack . prettyVer

-instance Show (a -> b) where
-  show _ = "<function>"

-instance Show (IO ()) where
-  show _ = "<io>"
+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 (<|>) #-}


-data LogLevel = Warn
-              | Info
-              | Debug
-              | Error
-  deriving (Eq, Ord, Show)
+instance MonadLogger m => MonadLogger (Excepts e m) where
+  monadLoggerLog a b c d = Trans.lift $ monadLoggerLog a b c d

-data LoggerConfig = LoggerConfig
-  { lcPrintDebug   :: Bool            -- ^ whether to print debug in colorOutter
-  , consoleOutter  :: T.Text -> IO () -- ^ how to write the console output
-  , fileOutter     :: T.Text -> IO () -- ^ how to write the file output
-  , fancyColors    :: Bool
-  }
-  deriving Show
-
-instance NFData LoggerConfig where
-  rnf (LoggerConfig !lcPrintDebug !_ !_ !fancyColors) = rnf (lcPrintDebug, fancyColors)
--- a/lib/GHCup/Types/JSON.hs
+++ b/lib/GHCup/Types/JSON.hs
@@ -24,8 +24,6 @@ module GHCup.Types.JSON where
 import           GHCup.Types
 import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
-import           GHCup.Utils.Logger             () -- TH is broken shite and needs GHCup.Utils.Logger for linking, although we don't depend on the file.
-                                                   -- This is due to the boot file.

 import           Control.Applicative            ( (<|>) )
 import           Data.Aeson
@@ -44,7 +42,7 @@ import qualified Text.Megaparsec               as MP
 import qualified Text.Megaparsec.Char          as MPC


-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Architecture
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } { fieldLabelModifier = removeLensFieldLabel } ''Architecture
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''LinuxDistro
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VSep
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VUnit
@@ -56,7 +54,6 @@ deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GlobalTool
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''KeepDirs
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Downloader
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GPGSetting

 instance ToJSON Tag where
  toJSON Latest             = String "Latest"
--- a/lib/GHCup/Types/Optics.hs
+++ b/lib/GHCup/Types/Optics.hs
@@ -6,7 +6,6 @@
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE AllowAmbiguousTypes   #-}
 {-# LANGUAGE MultiParamTypeClasses   #-}
-{-# LANGUAGE OverloadedStrings   #-}

 {-|
 Module      : GHCup.Types.Optics
@@ -22,11 +21,10 @@ module GHCup.Types.Optics where
 import           GHCup.Types

 import           Control.Monad.Reader
-import           Data.ByteString         ( ByteString )
+import           Data.ByteString                ( ByteString )
 import           Optics
 import           URI.ByteString

-
 makePrisms ''Tool
 makePrisms ''Architecture
 makePrisms ''LinuxDistro
@@ -89,15 +87,13 @@ getLeanAppState :: ( MonadReader env m
                   , LabelOptic' "settings"    A_Lens env Settings
                   , LabelOptic' "dirs"        A_Lens env Dirs
                   , LabelOptic' "keyBindings" A_Lens env KeyBindings
-                   , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
                   )
                => m LeanAppState
 getLeanAppState = do
  s <- gets @"settings"
  d <- gets @"dirs"
  k <- gets @"keyBindings"
-  l <- gets @"loggerConfig"
-  pure (LeanAppState s d k l)
+  pure (LeanAppState s d k)


 getSettings :: ( MonadReader env m
@@ -114,13 +110,6 @@ getDirs :: ( MonadReader env m
 getDirs = gets @"dirs"


-getLogCleanup :: ( MonadReader env m
-                 , LabelOptic' "logCleanup" A_Lens env (IO ())
-                 )
-              => m (IO ())
-getLogCleanup = gets @"logCleanup"
-
-
 getKeyBindings :: ( MonadReader env m
                  , LabelOptic' "keyBindings" A_Lens env KeyBindings
                  )
@@ -147,7 +136,6 @@ 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)
-type HasLog env = (LabelOptic' "loggerConfig" A_Lens env LoggerConfig)


 getCache :: (MonadReader env m, HasSettings env) => m Bool
--- a/lib/GHCup/Utils.hs
+++ b/lib/GHCup/Utils.hs
@@ -35,7 +35,6 @@ import           GHCup.Types.Optics
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.Dirs
 import           GHCup.Utils.File
-import           GHCup.Utils.Logger
 import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
 import           GHCup.Utils.String.QQ
@@ -47,6 +46,7 @@ import           Control.Monad
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
 #endif
+import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
                                         hiding ( throwM )
@@ -58,6 +58,7 @@ import           Data.ByteString                ( ByteString )
 import           Data.Either
 import           Data.Foldable
 import           Data.List
+import           Data.List.Extra
 import           Data.List.NonEmpty             ( NonEmpty( (:|) ))
 import           Data.Maybe
 import           Data.Text                      ( Text )
@@ -86,37 +87,8 @@ import qualified Data.Map.Strict               as Map
 import qualified Data.Text                     as T
 import qualified Data.Text.Encoding            as E
 import qualified Text.Megaparsec               as MP
-import qualified Data.List.NonEmpty            as NE


-- $setup
-- >>> :set -XOverloadedStrings
-- >>> :set -XDataKinds
-- >>> :set -XTypeApplications
-- >>> :set -XQuasiQuotes
-- >>> import System.Directory
-- >>> import URI.ByteString
-- >>> import qualified Data.Text as T
-- >>> import GHCup.Utils.Prelude
-- >>> import GHCup.Download
-- >>> import GHCup.Version
-- >>> import GHCup.Errors
-- >>> import GHCup.Types
-- >>> import GHCup.Types.Optics
-- >>> import Optics
-- >>> import GHCup.Utils.Version.QQ
-- >>> import qualified Data.Text.Encoding as E
-- >>> import Control.Monad.Reader
-- >>> import Haskus.Utils.Variant.Excepts
-- >>> import Text.PrettyPrint.HughesPJClass ( prettyShow )
-- >>> let lc = LoggerConfig { lcPrintDebug = False, consoleOutter = mempty, fileOutter = mempty, fancyColors = False }
-- >>> dirs' <- getAllDirs
-- >>> let installedVersions = [ ([pver|8.10.7|], Nothing), ([pver|8.10.4|], Nothing), ([pver|8.8.4|], Nothing), ([pver|8.8.3|], Nothing) ]
-- >>> let settings = Settings True False Never Curl False GHCupURL True GPGNone False
-- >>> let leanAppState = LeanAppState settings dirs' defaultKeyBindings lc
-- >>> cwd <- getCurrentDirectory
-- >>> (Right ref) <- pure $ parseURI strictURIParserOptions $ "file://" <> E.encodeUtf8 (T.pack cwd) <> "/data/metadata/" <> (urlBaseName . view pathL' $ ghcupURL)
-- >>> (VRight r) <- (fmap . fmap) _ghcupDownloads $ flip runReaderT leanAppState . runE @'[DigestError, GPGError, JSONError , DownloadFailed , FileDoesNotExistError] $ liftE $ getBase ref



@@ -142,7 +114,7 @@ ghcLinkDestination tool ver = do
 rmMinorSymlinks :: ( MonadReader env m
                   , HasDirs env
                   , MonadIO m
-                   , HasLog env
+                   , MonadLogger m
                   , MonadThrow m
                   , MonadFail m
                   , MonadMask m
@@ -156,14 +128,14 @@ rmMinorSymlinks tv@GHCTargetVersion{..} = do
  forM_ files $ \f -> do
    let f_xyz = f <> "-" <> T.unpack (prettyVer _tvVersion) <> exeExt
    let fullF = binDir </> f_xyz
-    lift $ logDebug ("rm -f " <> T.pack fullF)
+    lift $ $(logDebug) ("rm -f " <> T.pack fullF)
    lift $ hideError doesNotExistErrorType $ rmLink fullF


 -- | Removes the set ghc version for the given target, if any.
 rmPlain :: ( MonadReader env m
           , HasDirs env
-           , HasLog env
+           , MonadLogger m
           , MonadThrow m
           , MonadFail m
           , MonadIO m
@@ -178,11 +150,11 @@ rmPlain target = do
    files <- liftE $ ghcToolFiles tv
    forM_ files $ \f -> do
      let fullF = binDir </> f <> exeExt
-      lift $ logDebug ("rm -f " <> T.pack fullF)
+      lift $ $(logDebug) ("rm -f " <> T.pack fullF)
      lift $ hideError doesNotExistErrorType $ rmLink fullF
    -- old ghcup
    let hdc_file = binDir </> "haddock-ghc" <> exeExt
-    lift $ logDebug ("rm -f " <> T.pack hdc_file)
+    lift $ $(logDebug) ("rm -f " <> T.pack hdc_file)
    lift $ hideError doesNotExistErrorType $ rmLink hdc_file


@@ -190,7 +162,7 @@ rmPlain target = do
 rmMajorSymlinks :: ( MonadReader env m
                   , HasDirs env
                   , MonadIO m
-                   , HasLog env
+                   , MonadLogger m
                   , MonadThrow m
                   , MonadFail m
                   , MonadMask m
@@ -206,7 +178,7 @@ rmMajorSymlinks tv@GHCTargetVersion{..} = do
  forM_ files $ \f -> do
    let f_xy = f <> "-" <> T.unpack v' <> exeExt
    let fullF = binDir </> f_xy
-    lift $ logDebug ("rm -f " <> T.pack fullF)
+    lift $ $(logDebug) "rm -f #{fullF}"
    lift $ hideError doesNotExistErrorType $ rmLink fullF


@@ -278,7 +250,8 @@ getInstalledGHCs = do


 -- | Get all installed cabals, by matching on @~\/.ghcup\/bin/cabal-*@.
-getInstalledCabals :: ( MonadReader env m
+getInstalledCabals :: ( MonadLogger m
+                      , MonadReader env m
                      , HasDirs env
                      , MonadIO m
                      , MonadCatch m
@@ -297,14 +270,14 @@ getInstalledCabals = do


 -- | Whether the given cabal version is installed.
-cabalInstalled :: (MonadIO m, MonadReader env m, HasDirs env, MonadCatch m) => Version -> m Bool
+cabalInstalled :: (MonadLogger m, MonadIO m, MonadReader env m, HasDirs env, MonadCatch m) => Version -> m Bool
 cabalInstalled ver = do
  vers <- fmap rights getInstalledCabals
  pure $ elem ver vers


 -- Return the currently set cabal version, if any.
-cabalSet :: (HasLog env, MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
+cabalSet :: (MonadLogger m, MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
 cabalSet = do
  Dirs {..}  <- getDirs
  let cabalbin = binDir </> "cabal" <> exeExt
@@ -321,7 +294,7 @@ cabalSet = do
        case linkVersion =<< link of
          Right v -> pure $ Just v
          Left err -> do
-            logWarn $ "Failed to parse cabal symlink target with: "
+            $(logWarn) $ "Failed to parse cabal symlink target with: "
              <> T.pack (displayException err)
              <> ". The symlink "
              <> T.pack cabalbin
@@ -392,7 +365,7 @@ getInstalledStacks = do

 -- Return the currently set stack version, if any.
 -- TODO: there's a lot of code duplication here :>
-stackSet :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m, HasLog env) => m (Maybe Version)
+stackSet :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m, MonadLogger m) => m (Maybe Version)
 stackSet = do
  Dirs {..}  <- getDirs
  let stackBin = binDir </> "stack" <> exeExt
@@ -409,7 +382,7 @@ stackSet = do
        case linkVersion =<< link of
          Right v -> pure $ Just v
          Left err -> do
-            logWarn $ "Failed to parse stack symlink target with: "
+            $(logWarn) $ "Failed to parse stack symlink target with: "
              <> T.pack (displayException err)
              <> ". The symlink "
              <> T.pack stackBin
@@ -492,50 +465,33 @@ hlsGHCVersions :: ( MonadReader env m
                  )
               => m [Version]
 hlsGHCVersions = do
-  h <- hlsSet
-  fromMaybe [] <$> forM h hlsGHCVersions'
-
-
-hlsGHCVersions' :: ( MonadReader env m
-                   , HasDirs env
-                   , MonadIO m
-                   , MonadThrow m
-                   , MonadCatch m
-                   )
-                => Version
-                -> m [Version]
-hlsGHCVersions' v' = do
-  bins <- hlsServerBinaries v' Nothing
-  let vers = fmap
-        (version
-          . T.pack
-          . fromJust
-          . stripPrefix "haskell-language-server-"
-          . head
-          . splitOn "~"
-          )
-        bins
-  pure . sortBy (flip compare) . rights $ vers
+  h                             <- hlsSet
+  vers                          <- forM h $ \h' -> do
+    bins <- hlsServerBinaries h'
+    pure $ fmap
+      (version
+        . T.pack
+        . fromJust
+        . stripPrefix "haskell-language-server-"
+        . head
+        . splitOn "~"
+        )
+      bins
+  pure . rights . concat . maybeToList $ vers


 -- | Get all server binaries for an hls version, if any.
 hlsServerBinaries :: (MonadReader env m, HasDirs env, MonadIO m)
                  => Version
-                  -> Maybe Version   -- ^ optional GHC version
                  -> m [FilePath]
-hlsServerBinaries ver mghcVer = do
+hlsServerBinaries ver = do
  Dirs {..}  <- getDirs
  liftIO $ handleIO (\_ -> pure []) $ findFiles
    binDir
    (makeRegexOpts
      compExtended
      execBlank
-      ([s|^haskell-language-server-|]
-        <> maybe [s|.*|] escapeVerRex mghcVer
-        <> [s|~|]
-        <> escapeVerRex ver
-        <> E.encodeUtf8 (T.pack exeExt)
-        <> [s|$|] :: ByteString
+      ([s|^haskell-language-server-.*~|] <> escapeVerRex ver <> E.encodeUtf8 (T.pack exeExt) <> [s|$|] :: ByteString
      )
    )

@@ -564,7 +520,7 @@ hlsWrapperBinary ver = do
 -- | Get all binaries for an hls version, if any.
 hlsAllBinaries :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m) => Version -> m [FilePath]
 hlsAllBinaries ver = do
-  hls     <- hlsServerBinaries ver Nothing
+  hls     <- hlsServerBinaries ver
  wrapper <- hlsWrapperBinary ver
  pure (maybeToList wrapper ++ hls)

@@ -605,83 +561,34 @@ matchMajor v' major' minor' = case getMajorMinorV v' of
  Just (x, y) -> x == major' && y == minor'
  Nothing     -> False

-- | Match PVP prefix.
--
-- >>> matchPVPrefix [pver|8.8|] [pver|8.8.4|]
-- True
-- >>> matchPVPrefix [pver|8|] [pver|8.8.4|]
-- True
-- >>> matchPVPrefix [pver|8.10|] [pver|8.8.4|]
-- False
-- >>> matchPVPrefix [pver|8.10|] [pver|8.10.7|]
-- True
-matchPVPrefix :: PVP -> PVP -> Bool
-matchPVPrefix (toL -> prefix) (toL -> full) = and $ zipWith (==) prefix full

-toL :: PVP -> [Int]
-toL (PVP inner) = fmap fromIntegral $ NE.toList inner
-
-
-- | Get the latest installed full GHC version that satisfies the given (possibly partial)
-- PVP version.
-getGHCForPVP :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m)
-             => PVP
-             -> Maybe Text -- ^ the target triple
-             -> m (Maybe GHCTargetVersion)
-getGHCForPVP pvpIn mt = do
+-- | Get the latest installed full GHC version that satisfies X.Y.
+-- This reads `ghcupGHCBaseDir`.
+getGHCForMajor :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m)
+               => Int        -- ^ major version component
+               -> Int        -- ^ minor version component
+               -> Maybe Text -- ^ the target triple
+               -> m (Maybe GHCTargetVersion)
+getGHCForMajor major' minor' mt = do
  ghcs <- rights <$> getInstalledGHCs
-  -- we're permissive here... failed parse just means we have no match anyway
-  let ghcs' = catMaybes $ flip fmap ghcs $ \GHCTargetVersion{..} -> do
-        pvp_ <- versionToPVP _tvVersion
-        pure (pvp_, _tvTarget)

-  getGHCForPVP' pvpIn ghcs' mt
-
-- | Like 'getGHCForPVP', except with explicit input parameter.
--
-- >>> fmap prettyShow $ getGHCForPVP' [pver|8|] installedVersions Nothing
-- "Just 8.10.7"
-- >>> fmap prettyShow $ getGHCForPVP' [pver|8.8|] installedVersions Nothing
-- "Just 8.8.4"
-- >>> fmap prettyShow $ getGHCForPVP' [pver|8.10.4|] installedVersions Nothing
-- "Just 8.10.4"
-getGHCForPVP' :: MonadThrow m
-             => PVP
-             -> [(PVP, Maybe Text)] -- ^ installed GHCs
-             -> Maybe Text          -- ^ the target triple
-             -> m (Maybe GHCTargetVersion)
-getGHCForPVP' pvpIn ghcs' mt = do
-  let mResult = lastMay
-                  . sortBy (\(x, _) (y, _) -> compare x y)
-                  . filter
-                      (\(pvp_, target) ->
-                        target == mt && matchPVPrefix pvp_ pvpIn
-                      )
-                  $ ghcs'
-  forM mResult $ \(pvp_, target) -> do
-    ver' <- pvpToVersion pvp_
-    pure (GHCTargetVersion target ver')
+  pure
+    . lastMay
+    . sortBy (\x y -> compare (_tvVersion x) (_tvVersion y))
+    . filter
+        (\GHCTargetVersion {..} ->
+          _tvTarget == mt && matchMajor _tvVersion major' minor'
+        )
+    $ ghcs


-- | Get the latest available ghc for the given PVP version, which
-- may only contain parts.
--
-- >>> (fmap . fmap) fst $ getLatestToolFor GHC [pver|8|] r
-- Just (PVP {_pComponents = 8 :| [10,7]})
-- >>> (fmap . fmap) fst $ getLatestToolFor GHC [pver|8.8|] r
-- Just (PVP {_pComponents = 8 :| [8,4]})
-- >>> (fmap . fmap) fst $ getLatestToolFor GHC [pver|8.8.4|] r
-- Just (PVP {_pComponents = 8 :| [8,4]})
-getLatestToolFor :: MonadThrow m
-                 => Tool
-                 -> PVP
-                 -> GHCupDownloads
-                 -> m (Maybe (PVP, VersionInfo))
-getLatestToolFor tool pvpIn dls = do
-  let ls = fromMaybe [] $ preview (ix tool % to Map.toDescList) dls
-  let ps = catMaybes $ fmap (\(v, vi) -> (,vi) <$> versionToPVP v) ls
-  pure . headMay . filter (\(v, _) -> matchPVPrefix pvpIn v) $ ps
-
+-- | Get the latest available ghc for X.Y major version.
+getLatestGHCFor :: Int -- ^ major version component
+                -> Int -- ^ minor version component
+                -> GHCupDownloads
+                -> Maybe (Version, VersionInfo)
+getLatestGHCFor major' minor' dls =
+  preview (ix GHC % to Map.toDescList) dls >>= lastMay . filter (\(v, _) -> matchMajor v major' minor')



@@ -693,7 +600,7 @@ getLatestToolFor tool pvpIn dls = do


 -- | Unpack an archive to a temporary directory and return that path.
-unpackToDir :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m)
+unpackToDir :: (MonadLogger m, MonadIO m, MonadThrow m)
            => FilePath       -- ^ destination dir
            -> FilePath       -- ^ archive path
            -> Excepts '[UnknownArchive
@@ -701,7 +608,7 @@ unpackToDir :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m)
                        ] m ()
 unpackToDir dfp av = do
  let fn = takeFileName av
-  lift $ logInfo $ "Unpacking: " <> T.pack fn <> " to " <> T.pack dfp
+  lift $ $(logInfo) $ "Unpacking: " <> T.pack fn <> " to " <> T.pack dfp

  let untar :: MonadIO m => BL.ByteString -> Excepts '[ArchiveResult] m ()
      untar = lEM . liftIO . runArchiveM . unpackToDirLazy dfp
@@ -724,7 +631,7 @@ unpackToDir dfp av = do
    | otherwise -> throwE $ UnknownArchive fn


-getArchiveFiles :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m)
+getArchiveFiles :: (MonadLogger m, MonadIO m, MonadThrow m)
                => FilePath       -- ^ archive path
                -> Excepts '[UnknownArchive
                            , ArchiveResult
@@ -753,7 +660,7 @@ getArchiveFiles av = do
    | otherwise -> throwE $ UnknownArchive fn


-intoSubdir :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m, MonadCatch m)
+intoSubdir :: (MonadLogger m, MonadIO m, MonadThrow m, MonadCatch m)
           => FilePath       -- ^ unpacked tar dir
           -> TarDir         -- ^ how to descend
           -> Excepts '[TarDirDoesNotExist] m FilePath
@@ -785,10 +692,11 @@ intoSubdir bdir tardir = case tardir of
 -- | Get the tool version that has this tag. If multiple have it,
 -- picks the greatest version.
 getTagged :: Tag
-          -> Fold (Map.Map Version VersionInfo) (Version, VersionInfo)
+          -> AffineFold (Map.Map Version VersionInfo) (Version, VersionInfo)
 getTagged tag =
-  to (Map.toDescList . Map.filter (\VersionInfo {..} -> tag `elem` _viTags))
-  % folding id
+  to (Map.filter (\VersionInfo {..} -> tag `elem` _viTags))
+  % to Map.toDescList
+  % _head

 getLatest :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
 getLatest av tool = headOf (ix tool % getTagged Latest) av
@@ -880,19 +788,14 @@ makeOut args workdir = do

 -- | Try to apply patches in order. Fails with 'PatchFailed'
 -- on first failure.
-applyPatches :: (MonadReader env m, HasDirs env, HasLog env, MonadIO m)
+applyPatches :: (MonadReader env m, HasDirs env, MonadLogger m, MonadIO m)
             => FilePath   -- ^ dir containing patches
             -> FilePath   -- ^ dir to apply patches in
             -> Excepts '[PatchFailed] m ()
 applyPatches pdir ddir = do
-  patches <- (fmap . fmap) (pdir </>) $ liftIO $ findFiles
-      pdir
-      (makeRegexOpts compExtended
-                     execBlank
-                     ([s|.+\.(patch|diff)$|] :: ByteString)
-      )
+  patches <- (fmap . fmap) (pdir </>) $ liftIO $ listDirectory pdir
  forM_ (sort patches) $ \patch' -> do
-    lift $ logInfo $ "Applying patch " <> T.pack patch'
+    lift $ $(logInfo) $ "Applying patch " <> T.pack patch'
    fmap (either (const Nothing) Just)
         (exec
           "patch"
@@ -919,7 +822,7 @@ getChangeLog :: GHCupDownloads -> Tool -> Either Version Tag -> Maybe URI
 getChangeLog dls tool (Left v') =
  preview (ix tool % ix v' % viChangeLog % _Just) dls
 getChangeLog dls tool (Right tag) =
-  preview (ix tool % pre (getTagged tag) % to snd % viChangeLog % _Just) dls
+  preview (ix tool % getTagged tag % to snd % viChangeLog % _Just) dls


 -- | Execute a build action while potentially cleaning up:
@@ -928,17 +831,13 @@ getChangeLog dls tool (Right tag) =
 --   2. the install destination, depending on whether the build failed
 runBuildAction :: ( Pretty (V e)
                  , Show (V e)
-                  , PopVariant BuildFailed e
-                  , ToVariantMaybe BuildFailed e
                  , MonadReader env m
                  , HasDirs env
                  , HasSettings env
                  , MonadIO m
                  , MonadMask m
-                  , HasLog env
+                  , MonadLogger m
                  , MonadUnliftIO m
-                  , MonadFail m
-                  , MonadCatch m
                  )
               => FilePath        -- ^ build directory (cleaned up depending on Settings)
               -> Maybe FilePath  -- ^ dir to *always* clean up on exception
@@ -965,9 +864,9 @@ runBuildAction bdir instdir action = do

 -- | Remove a build directory, ignoring if it doesn't exist and gracefully
 -- printing other errors without crashing.
-rmBDir :: (MonadReader env m, HasLog env, MonadUnliftIO m, MonadIO m) => FilePath -> m ()
+rmBDir :: (MonadLogger m, MonadUnliftIO m, MonadIO m) => FilePath -> m ()
 rmBDir dir = withRunInIO (\run -> run $
-           liftIO $ handleIO (\e -> run $ logWarn $
+           liftIO $ handleIO (\e -> run $ $(logWarn) $
               "Couldn't remove build dir " <> T.pack dir <> ", error was: " <> T.pack (displayException e))
           $ hideError doesNotExistErrorType
           $ rmPathForcibly dir)
@@ -1080,7 +979,7 @@ rmLink = hideError doesNotExistErrorType . recycleFile
 -- On windows, this requires that 'ensureGlobalTools' was run beforehand.
 createLink :: ( MonadMask m
              , MonadThrow m
-              , HasLog env
+              , MonadLogger m
              , MonadIO m
              , MonadReader env m
              , HasDirs env
@@ -1102,24 +1001,24 @@ createLink link exe = do
      fullLink = takeDirectory exe </> link
      shimContents = "path = " <> fullLink

-  logDebug $ "rm -f " <> T.pack exe
+  $(logDebug) $ "rm -f " <> T.pack exe
  rmLink exe

-  logDebug $ "ln -s " <> T.pack fullLink <> " " <> T.pack exe
+  $(logDebug) $ "ln -s " <> T.pack fullLink <> " " <> T.pack exe
  liftIO $ copyFile shimGen exe
  liftIO $ writeFile shim shimContents
 #else
-  logDebug $ "rm -f " <> T.pack exe
+  $(logDebug) $ "rm -f " <> T.pack exe
  hideError doesNotExistErrorType $ recycleFile exe

-  logDebug $ "ln -s " <> T.pack link <> " " <> T.pack exe
+  $(logDebug) $ "ln -s " <> T.pack link <> " " <> T.pack exe
  liftIO $ createFileLink link exe
 #endif


 ensureGlobalTools :: ( MonadMask m
                     , MonadThrow m
-                     , HasLog env
+                     , MonadLogger m
                     , MonadIO m
                     , MonadReader env m
                     , HasDirs env
@@ -1128,7 +1027,7 @@ ensureGlobalTools :: ( MonadMask m
                     , MonadUnliftIO m
                     , MonadFail m
                     )
-                  => Excepts '[GPGError, DigestError , DownloadFailed, NoDownload] m ()
+                  => Excepts '[DigestError , DownloadFailed, NoDownload] m ()
 ensureGlobalTools = do
 #if defined(IS_WINDOWS)
  (GHCupInfo _ _ gTools) <- lift getGHCupInfo
@@ -1136,12 +1035,12 @@ ensureGlobalTools = do
  shimDownload <- liftE $ lE @_ @'[NoDownload]
    $ maybe (Left NoDownload) Right $ Map.lookup ShimGen gTools
  let dl = downloadCached' shimDownload (Just "gs.exe") Nothing
-  void $ (\(DigestError _ _ _) -> do
-      lift $ logWarn "Digest doesn't match, redownloading gs.exe..."
-      lift $ logDebug ("rm -f " <> T.pack (cacheDir dirs </> "gs.exe"))
+  void $ (\(DigestError _ _) -> do
+      lift $ $(logWarn) "Digest doesn't match, redownloading gs.exe..."
+      lift $ $(logDebug) "rm -f #{shimDownload}"
      lift $ hideError doesNotExistErrorType $ recycleFile (cacheDir dirs </> "gs.exe")
-      liftE @'[GPGError, DigestError , DownloadFailed] $ dl
-    ) `catchE` (liftE @'[GPGError, DigestError , DownloadFailed] dl)
+      liftE @'[DigestError , DownloadFailed] $ dl
+    ) `catchE` (liftE @'[DigestError , DownloadFailed] dl)
  pure ()
 #else
  pure ()
--- a/lib/GHCup/Utils/Dirs.hs
+++ b/lib/GHCup/Utils/Dirs.hs
@@ -2,7 +2,9 @@
 {-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE ViewPatterns          #-}
+{-# LANGUAGE TemplateHaskell       #-}

 {-|
 Module      : GHCup.Utils.Dirs
@@ -38,12 +40,12 @@ import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Types.Optics
 import           GHCup.Utils.MegaParsec
-import           GHCup.Utils.Logger
 import           GHCup.Utils.Prelude

 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Unlift
+import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource hiding (throwM)
 import           Data.Bifunctor
@@ -59,7 +61,7 @@ import           System.IO.Temp

 import qualified Data.ByteString               as BS
 import qualified Data.Text                     as T
-import qualified Data.YAML.Aeson               as Y
+import qualified Data.Yaml                     as Y
 import qualified Text.Megaparsec               as MP
 import Control.Concurrent (threadDelay)

@@ -222,7 +224,7 @@ ghcupConfigFile = do
  contents <- liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ Just <$> BS.readFile filepath
  case contents of
      Nothing -> pure defaultUserSettings
-      Just contents' -> lE' JSONDecodeError . first snd . Y.decode1Strict $ contents'
+      Just contents' -> lE' JSONDecodeError . first show . Y.decodeEither' $ contents'


    -------------------------
@@ -259,7 +261,7 @@ parseGHCupGHCDir (T.pack -> fp) =
 mkGhcupTmpDir :: ( MonadReader env m
                 , HasDirs env
                 , MonadUnliftIO m
-                 , HasLog env
+                 , MonadLogger m
                 , MonadCatch m
                 , MonadThrow m
                 , MonadMask m
@@ -271,14 +273,14 @@ mkGhcupTmpDir = do
  let minSpace = 5000 -- a rough guess, aight?
  space <- handleIO (\_ -> pure Nothing) $ fmap Just $ liftIO $ getAvailSpace tmpdir
  when (maybe False (toBytes minSpace >) space) $ do
-    logWarn ("Possibly insufficient disk space on "
+    $(logWarn) ("Possibly insufficient disk space on "
      <> T.pack tmpdir
      <> ". At least "
      <> T.pack (show minSpace)
      <> " MB are recommended, but only "
      <> toMB (fromJust space)
      <> " are free. Consider freeing up disk space or setting TMPDIR env variable.")
-    logWarn
+    $(logWarn)
      "...waiting for 10 seconds before continuing anyway, you can still abort..."
    liftIO $ threadDelay 10000000 -- give the user a sec to intervene

@@ -293,9 +295,8 @@ mkGhcupTmpDir = do

 withGHCupTmpDir :: ( MonadReader env m
                   , HasDirs env
-                   , HasLog env
-                   , HasSettings env
                   , MonadUnliftIO m
+                   , MonadLogger m
                   , MonadCatch m
                   , MonadResource m
                   , MonadThrow m
@@ -308,7 +309,7 @@ withGHCupTmpDir = snd <$> withRunInIO (\run ->
        (run mkGhcupTmpDir)
        (\fp ->
            handleIO (\e -> run
-                $ logDebug ("Resource cleanup failed for " <> T.pack fp <> ", error was: " <> T.pack (displayException e)))
+                $ $(logDebug) ("Resource cleanup failed for " <> T.pack fp <> ", error was: " <> T.pack (displayException e)))
            . rmPathForcibly
            $ fp))

@@ -340,10 +341,9 @@ relativeSymlink p1 p2 =

 cleanupTrash :: ( MonadIO m
                , MonadMask m
+                , MonadLogger m
                , MonadReader env m
-                , HasLog env
                , HasDirs env
-                , HasSettings env
                )
             => m ()
 cleanupTrash = do
@@ -352,8 +352,8 @@ cleanupTrash = do
  if null contents
  then pure ()
  else do
-    logWarn ("Removing leftover files in " <> T.pack recycleDir)
+    $(logWarn) ("Removing leftover files in " <> T.pack recycleDir)
    forM_ contents (\fp -> handleIO (\e ->
-        logDebug ("Resource cleanup failed for " <> T.pack fp <> ", error was: " <> T.pack (displayException e))
+        $(logDebug) ("Resource cleanup failed for " <> T.pack fp <> ", error was: " <> T.pack (displayException e))
      ) $ liftIO $ removePathForcibly (recycleDir </> fp))

--- a/lib/GHCup/Utils/File/Common.hs
+++ b/lib/GHCup/Utils/File/Common.hs
@@ -7,10 +7,9 @@ module GHCup.Utils.File.Common where

 import           GHCup.Utils.Prelude

+import           Control.Monad.Extra
 import           Control.Monad.Reader
 import           Data.Maybe
-import           Data.Text               ( Text )
-import           Data.Void
 import           GHC.IO.Exception
 import           Optics                  hiding ((<|), (|>))
 import           System.Directory
@@ -18,9 +17,7 @@ import           System.FilePath
 import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
 import           Text.Regex.Posix

-import qualified Data.Text                     as T
 import qualified Data.ByteString.Lazy          as BL
-import qualified Text.Megaparsec               as MP



@@ -32,11 +29,11 @@ data ProcessError = NonZeroExit Int FilePath [String]

 instance Pretty ProcessError where
  pPrint (NonZeroExit e exe args) =
-    text "Process" <+> pPrint exe <+> text "with arguments" <+> pPrint args <+> text "failed with exit code" <+> text (show e <> ".")
+    text "Process " <+> pPrint exe <+> text " with arguments " <+> text (show args) <+> text " failed with exit code " <+> text (show e) <+> "."
  pPrint (PTerminated exe args) =
-    text "Process" <+> pPrint exe <+> text "with arguments" <+> pPrint args <+> text "terminated."
+    text "Process " <+> pPrint exe <+> text " with arguments " <+> text (show args) <+> text " terminated."
  pPrint (PStopped exe args) =
-    text "Process" <+> pPrint exe <+> text "with arguments" <+> pPrint args <+> text "stopped."
+    text "Process " <+> pPrint exe <+> text " with arguments " <+> text (show args) <+> text " stopped."
  pPrint (NoSuchPid exe args) =
    text "Could not find PID for process running " <+> pPrint exe <+> text " with arguments " <+> text (show args) <+> text "."

@@ -105,16 +102,3 @@ findFiles path regex = do
  contents <- listDirectory path
  pure $ filter (match regex) contents

-findFilesDeep :: FilePath -> Regex -> IO [FilePath]
-findFilesDeep path regex = do
-  contents <- getDirectoryContentsRecursive path
-  pure $ filter (match regex) contents
-
-findFiles' :: FilePath -> MP.Parsec Void Text a -> IO [FilePath]
-findFiles' path parser = do
-  contents <- listDirectory path
-  pure $ filter (\fp -> either (const False) (const True) $ MP.parse parser "" (T.pack fp)) contents
-
-
-checkFileAlreadyExists :: (MonadIO m) => FilePath -> m Bool
-checkFileAlreadyExists fp = liftIO $ doesFileExist fp
--- a/lib/GHCup/Utils/File/Common.hs-boot
+++ b/lib/GHCup/Utils/File/Common.hs-boot
@@ -1,5 +0,0 @@
-module GHCup.Utils.File.Common where
-
-import           Text.Regex.Posix
-
-findFiles :: FilePath -> Regex -> IO [FilePath]
--- a/lib/GHCup/Utils/File/Posix.hs
+++ b/lib/GHCup/Utils/File/Posix.hs
@@ -1,5 +1,8 @@
+{-# LANGUAGE QuasiQuotes       #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE ViewPatterns      #-}

 {-|
 Module      : GHCup.Utils.File.Posix
@@ -17,7 +20,6 @@ module GHCup.Utils.File.Posix where

 import           GHCup.Utils.File.Common
 import           GHCup.Utils.Prelude
-import           GHCup.Utils.Logger
 import           GHCup.Types
 import           GHCup.Types.Optics

@@ -26,6 +28,7 @@ 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 )
@@ -35,7 +38,8 @@ import           Data.Sequence                  ( Seq, (|>) )
 import           Data.List
 import           Data.Word8
 import           GHC.IO.Exception
-import           System.Console.Terminal.Common
+import           System.Console.Pretty   hiding ( Pretty )
+import           System.Console.Regions
 import           System.IO.Error
 import           System.FilePath
 import           System.Directory
@@ -51,7 +55,6 @@ 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 System.Console.Terminal.Posix as TP
 import qualified Data.ByteString               as BS
 import qualified Data.ByteString.Lazy          as BL
 import qualified "unix-bytestring" System.Posix.IO.ByteString
@@ -88,9 +91,9 @@ execLogged exe args chdir lfile env = do
  let logfile = logsDir </> lfile <> ".log"
  liftIO $ bracket (openFd logfile WriteOnly (Just newFilePerms) defaultFileFlags{ append = True })
                   closeFd
-                   (action verbose noColor)
+                   (action verbose)
 where
-  action verbose no_color fd = do
+  action verbose fd = do
    actionWithPipes $ \(stdoutRead, stdoutWrite) -> do
      -- start the thread that logs to stdout
      pState <- newEmptyMVar
@@ -101,7 +104,7 @@ execLogged exe args chdir lfile env = do
        $ EX.finally
            (if verbose
              then tee fd stdoutRead
-              else printToRegion fd stdoutRead 6 pState no_color
+              else printToRegion fd stdoutRead 6 pState
            )
            (putMVar done ())

@@ -128,7 +131,7 @@ execLogged exe args chdir lfile env = do
      pure e

  tee :: Fd -> Fd -> IO ()
-  tee fileFd = readTilEOF lineAction
+  tee fileFd fdIn = readTilEOF lineAction fdIn

   where
    lineAction :: ByteString -> IO ()
@@ -138,57 +141,46 @@ execLogged exe args chdir lfile env = do

  -- 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 -> Bool -> IO ()
-  printToRegion fileFd fdIn size pState no_color = do
-    -- init region
-    forM_ [1..size] $ \_ -> BS.putStr "\n"
-
-    void $ flip runStateT mempty
-      $ do
-        handle
-          (\(ex :: SomeException) -> do
-            ps <- liftIO $ takeMVar pState
-            when ps (liftIO $ BS.putStr (pos1 <> moveLineUp size <> clearScreen))
-            throw ex
-          ) $ readTilEOF lineAction fdIn
+  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
-    clearScreen :: ByteString
-    clearScreen = "\x1b[0J"
-    clearLine :: ByteString
-    clearLine = "\x1b[2K"
-    moveLineUp :: Int -> ByteString
-    moveLineUp n = "\x1b[" <> E.encodeUtf8 (T.pack (show n)) <> "A"
-    moveLineDown :: Int -> ByteString
-    moveLineDown n = "\x1b[" <> E.encodeUtf8 (T.pack (show n)) <> "B"
-    pos1 :: ByteString
-    pos1 = "\r"
-    overwriteNthLine :: Int -> ByteString -> ByteString
-    overwriteNthLine n str = pos1 <> moveLineUp n <> clearLine <> str <> moveLineDown n <> pos1
-
-    blue :: ByteString -> ByteString
-    blue bs 
-      | no_color = bs
-      | otherwise = "\x1b[0;34m" <> bs <> "\x1b[0m"
-
    -- action to perform line by line
+    -- TODO: do this with vty for efficiency
    lineAction :: (MonadMask m, MonadIO m)
-               => ByteString
+               => Seq ConsoleRegion
+               -> ByteString
               -> StateT (Seq ByteString) m ()
-    lineAction = \bs' -> do
+    lineAction rs = \bs' -> do
      void $ liftIO $ SPIB.fdWrite fileFd (bs' <> "\n")
      modify (swapRegs bs')
-      liftIO TP.size >>= \case
-        Nothing -> pure ()
-        Just (Window _ w) -> do
-          regs <- get
-          liftIO $ forM_ (Sq.zip regs (Sq.fromList [0..(Sq.length regs - 1)])) $ \(bs, i) -> do
-              BS.putStr
-              . overwriteNthLine (size - i)
-              . trim w
-              . blue
-              . (\b -> "[ " <> E.encodeUtf8 (T.pack lfile) <> " ] " <> b)
-              $ 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
@@ -358,7 +350,7 @@ toProcessError exe args mps = case mps of



-chmod_755 :: (MonadReader env m, HasLog env, MonadIO m) => FilePath -> m ()
+chmod_755 :: (MonadLogger m, MonadIO m) => FilePath -> m ()
 chmod_755 fp = do
  let exe_mode =
          nullFileMode
@@ -369,7 +361,7 @@ chmod_755 fp = do
            `unionFileModes` groupReadMode
            `unionFileModes` otherExecuteMode
            `unionFileModes` otherReadMode
-  logDebug ("chmod 755 " <> T.pack fp)
+  $(logDebug) ("chmod 755 " <> T.pack fp)
  liftIO $ setFileMode fp exe_mode


--- a/lib/GHCup/Utils/Logger.hs
+++ b/lib/GHCup/Utils/Logger.hs
@@ -1,7 +1,5 @@
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE QuasiQuotes      #-}
-{-# LANGUAGE DataKinds        #-}
-{-# LANGUAGE OverloadedStrings   #-}

 {-|
 Module      : GHCup.Utils.Logger
@@ -18,15 +16,15 @@ module GHCup.Utils.Logger where

 import           GHCup.Types
 import           GHCup.Types.Optics
-import {-# SOURCE #-} GHCup.Utils.File.Common
+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.Text               ( Text )
-import           Optics
+import           Data.Char               ( ord )
 import           Prelude                 hiding ( appendFile )
 import           System.Console.Pretty
 import           System.FilePath
@@ -35,80 +33,54 @@ import           Text.Regex.Posix

 import qualified Data.ByteString               as B
 import GHCup.Utils.Prelude
-import qualified Data.Text                     as T
-
-logInfo :: ( MonadReader env m
-           , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-           , MonadIO m
-           )
-        => Text
-        -> m ()
-logInfo = logInternal Info
-
-logWarn :: ( MonadReader env m
-           , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-           , MonadIO m
-           )
-        => Text
-        -> m ()
-logWarn = logInternal Warn
-
-logDebug :: ( MonadReader env m
-            , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-            , MonadIO m
-            )
-         => Text
-         -> m ()
-logDebug = logInternal Debug
-
-logError :: ( MonadReader env m
-            , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-            , MonadIO m
-            )
-         => Text
-         -> m ()
-logError = logInternal Error


-logInternal :: ( MonadReader env m
-               , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-               , MonadIO m
-               ) => LogLevel
-                 -> Text
-                 -> m ()
-logInternal logLevel msg = do
-  LoggerConfig {..} <- gets @"loggerConfig"
-  let color' c = if fancyColors then color c else id
-  let style' = case logLevel of
-        Debug   -> style Bold . color' Blue
-        Info    -> style Bold . color' Green
-        Warn    -> style Bold . color' Yellow
-        Error   -> style Bold . color' Red
-  let l = case logLevel of
-        Debug   -> style' "[ Debug ]"
-        Info    -> style' "[ Info  ]"
-        Warn    -> style' "[ Warn  ]"
-        Error   -> style' "[ Error ]"
-  let strs = T.split (== '\n') msg
-  let out = case strs of
-              [] -> T.empty
-              (x:xs) -> 
-                  foldr (\a b -> a <> "\n" <> b) mempty
-                . ((l <> " " <> x) :)
-                . fmap (\line' -> style' "[ ...   ] " <> line' )
-                $ xs
+data LoggerConfig = LoggerConfig
+  { lcPrintDebug :: Bool                  -- ^ whether to print debug in colorOutter
+  , colorOutter  :: B.ByteString -> IO () -- ^ how to write the color output
+  , rawOutter    :: B.ByteString -> IO () -- ^ how to write the full raw output
+  }

-  when (lcPrintDebug || (not lcPrintDebug && (logLevel /= Debug)))
-    $ liftIO $ consoleOutter out

-  -- raw output
-  let lr = case logLevel of
-        Debug   -> "Debug:"
-        Info    -> "Info:"
-        Warn    -> "Warn:"
-        Error   -> "Error:"
-  let outr = lr <> " " <> msg <> "\n"
-  liftIO $ fileOutter outr
+myLoggerT :: LoggerConfig -> LoggingT m a -> m a
+myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
+ where
+  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 ]")
+          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
+
+    when (lcPrintDebug || (not lcPrintDebug && (level /= LevelDebug)))
+      $ colorOutter out
+
+    -- raw output
+    let lr = case level of
+          LevelDebug   -> toLogStr "Debug:"
+          LevelInfo    -> toLogStr "Info:"
+          LevelWarn    -> toLogStr "Warn:"
+          LevelError   -> toLogStr "Error:"
+          LevelOther t -> toLogStr t <> toLogStr ":"
+    let outr = fromLogStr (lr <> toLogStr " " <> str' <> toLogStr "\n")
+    rawOutter outr


 initGHCupFileLogging :: ( MonadReader env m
--- a/lib/GHCup/Utils/Logger.hs-boot
+++ b/lib/GHCup/Utils/Logger.hs-boot
@@ -1,21 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE QuasiQuotes      #-}
-{-# LANGUAGE DataKinds        #-}
-{-# LANGUAGE OverloadedStrings   #-}
-
-module GHCup.Utils.Logger where
-
-import           GHCup.Types
-
-import           Control.Monad.IO.Class
-import           Control.Monad.Reader
-import           Data.Text               ( Text )
-import           Optics
-
-logWarn :: ( MonadReader env m
-           , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-           , MonadIO m
-           )
-        => Text
-        -> m ()
-
--- a/lib/GHCup/Utils/Prelude.hs
+++ b/lib/GHCup/Utils/Prelude.hs
@@ -5,6 +5,7 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeFamilies        #-}
 {-# LANGUAGE TypeOperators       #-}
+{-# LANGUAGE TemplateHaskell     #-}

 {-|
 Module      : GHCup.Utils.Prelude
@@ -22,25 +23,22 @@ module GHCup.Utils.Prelude where
 #if defined(IS_WINDOWS)
 import           GHCup.Types
 #endif
-import           GHCup.Errors
 import           GHCup.Types.Optics
-import {-# SOURCE #-} GHCup.Utils.Logger

 import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Class
 import           Control.Monad.Reader
+import           Control.Monad.Logger
 import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
-import           Data.List                      ( nub, intercalate, stripPrefix, isPrefixOf, dropWhileEnd )
-import           Data.Maybe
+import           Data.List                      ( nub, intercalate )
 import           Data.Foldable
-import           Data.List.NonEmpty             ( NonEmpty( (:|) ))
 import           Data.String
 import           Data.Text                      ( Text )
 import           Data.Versions
-import           Data.Word8                  hiding ( isDigit )
+import           Data.Word8
 import           Haskus.Utils.Types.List
 import           Haskus.Utils.Variant.Excepts
 import           Text.PrettyPrint.HughesPJClass ( prettyShow, Pretty )
@@ -61,7 +59,6 @@ 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.List.NonEmpty            as NE
 import qualified Data.Text                     as T
 import qualified Data.Text.Encoding            as E
 import qualified Data.Text.Encoding.Error      as E
@@ -78,9 +75,8 @@ import qualified System.Win32.File             as Win32
 -- >>> import Data.ByteString.Internal (c2w, w2c)
 -- >>> import Test.QuickCheck
 -- >>> import Data.Word8
+-- >>> import Data.Word8
 -- >>> import qualified Data.Text as T
-- >>> import qualified Data.Char as C
-- >>> import Data.List
 -- >>> instance Arbitrary T.Text where arbitrary = T.pack <$> arbitrary


@@ -178,12 +174,8 @@ lEM' :: forall e' e es a m
 lEM' f em = lift em >>= lE . first f

 -- for some obscure reason... this won't type-check if we move it to a different module
-catchWarn :: forall es m env . ( Pretty (V es)
-                             , MonadReader env m
-                             , HasLog env
-                             , MonadIO m
-                             , Monad m) => Excepts es m () -> Excepts '[] m ()
-catchWarn = catchAllE @_ @es (\v -> lift $ logWarn (T.pack . prettyShow $ v))
+catchWarn :: forall es m . (Pretty (V es), MonadLogger m, Monad m) => Excepts es m () -> Excepts '[] m ()
+catchWarn = catchAllE @_ @es (\v -> lift $ $(logWarn) (T.pack . prettyShow $ v))

 fromEither :: Either a b -> VEither '[a] b
 fromEither = either (VLeft . V) VRight
@@ -283,16 +275,6 @@ throwEither' e eth = case eth of
  Left  _ -> throwM e
  Right r -> pure r

-throwMaybe :: (Exception a, MonadThrow m) => a -> Maybe b -> m b
-throwMaybe a m = case m of
-  Nothing -> throwM a
-  Just r -> pure r
-
-throwMaybeM :: (Exception a, MonadThrow m) => a -> m (Maybe b) -> m b
-throwMaybeM a am = do
-  m <- am
-  throwMaybe a m
-

 verToBS :: Version -> ByteString
 verToBS = E.encodeUtf8 . prettyVer
@@ -309,28 +291,12 @@ removeLensFieldLabel str' =
  maybe str' T.unpack . T.stripPrefix (T.pack "_") . T.pack $ str'


-pvpToVersion :: MonadThrow m => PVP -> m Version
+pvpToVersion :: PVP -> Version
 pvpToVersion =
-  either (\_ -> throwM $ ParseError "Couldn't convert PVP to Version") pure . version . prettyPVP
+  either (\_ -> error "Couldn't convert PVP to Version") id
+    . version
+    . prettyPVP

-versionToPVP :: MonadThrow m => Version -> m PVP
-versionToPVP v = either (\_ -> alternative v) pure . pvp . prettyVer $ v
- where
-  alternative :: MonadThrow m => Version -> m PVP
-  alternative v' = case NE.takeWhile isDigit (_vChunks v') of
-    [] -> throwM $ ParseError "Couldn't convert Version to PVP"
-    xs -> pure $ pvpFromList (unsafeDigit <$> xs)
-
-  isDigit :: VChunk -> Bool
-  isDigit (Digits _ :| []) = True
-  isDigit _                = False
-
-  unsafeDigit :: VChunk -> Int
-  unsafeDigit (Digits x :| []) = fromIntegral x
-  unsafeDigit _ = error "unsafeDigit: wrong input"
-
-pvpFromList :: [Int] -> PVP
-pvpFromList = PVP . NE.fromList . fmap fromIntegral

 -- | Safe 'decodeUtf8With'. Replaces an invalid input byte with
 -- the Unicode replacement character U+FFFD.
@@ -538,10 +504,6 @@ recover action =
 #endif


-copyFileE :: (CopyError :< xs, MonadCatch m, MonadIO m) => FilePath -> FilePath -> Excepts xs m ()
-copyFileE from = handleIO (throwE . CopyError . show) . liftIO . copyFile from
-
-
 -- | Gathering monoidal values
 --
 -- >>> traverseFold (pure . (:["0"])) ["1","2"]
@@ -558,12 +520,10 @@ forFold :: (Foldable t, Applicative m, Monoid b) => t a -> (a -> m b) -> m b
 forFold = \t -> (`traverseFold` t)


-- | Strip @\\r@ and @\\n@ from 'String's
+-- | Strip @\\r@ and @\\n@ from 'ByteString's
 --
 -- >>> stripNewline "foo\n\n\n"
 -- "foo"
-- >>> stripNewline "foo\n\n\nfoo"
-- "foofoo"
 -- >>> stripNewline "foo\r"
 -- "foo"
 -- >>> stripNewline "foo"
@@ -572,32 +532,16 @@ forFold = \t -> (`traverseFold` t)
 -- prop> \t -> stripNewline (t <> "\n") === stripNewline t
 -- prop> \t -> not (any (isNewLine . c2w) t) ==> stripNewline t == t
 stripNewline :: String -> String
-stripNewline = filter (`notElem` "\n\r")
+stripNewline s
+  | null s               = []
+  | head s `elem` "\n\r" = stripNewline (tail s)
+  | otherwise            = head s : stripNewline (tail s)


-- | Strip @\\r@ and @\\n@ from end of 'String'.
--
-- >>> stripNewlineEnd "foo\n\n\n"
-- "foo"
-- >>> stripNewlineEnd "foo\n\n\nfoo"
-- "foo\n\n\nfoo"
-- >>> stripNewlineEnd "foo\r"
-- "foo"
-- >>> stripNewlineEnd "foo"
-- "foo"
--
-- prop> \t -> stripNewlineEnd (t <> "\n") === stripNewlineEnd t
-- prop> \t -> not (any (isNewLine . c2w) t) ==> stripNewlineEnd t == t
-stripNewlineEnd :: String -> String
-stripNewlineEnd = dropWhileEnd (`elem` "\n\r")
-
-
-- | Strip @\\r@ and @\\n@ from 'Text's
+-- | Strip @\\r@ and @\\n@ from 'ByteString's
 --
 -- >>> stripNewline' "foo\n\n\n"
 -- "foo"
-- >>> stripNewline' "foo\n\n\nfoo"
-- "foofoo"
 -- >>> stripNewline' "foo\r"
 -- "foo"
 -- >>> stripNewline' "foo"
@@ -606,7 +550,10 @@ stripNewlineEnd = dropWhileEnd (`elem` "\n\r")
 -- prop> \t -> stripNewline' (t <> "\n") === stripNewline' t
 -- prop> \t -> not (T.any (isNewLine . c2w) t) ==> stripNewline' t == t
 stripNewline' :: T.Text -> T.Text
-stripNewline' = T.filter (`notElem` "\n\r")
+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)


 -- | Is the word8 a newline?
@@ -640,117 +587,3 @@ splitOnPVP c s = case Split.splitOn c s of
    | otherwise -> def
 where
  def = (s, "")
-
-
-
-- | Like 'find', but where the test can be monadic.
--
-- >>> findM (Just . C.isUpper) "teST"
-- Just (Just 'S')
-- >>> findM (Just . C.isUpper) "test"
-- Just Nothing
-- >>> findM (Just . const True) ["x",undefined]
-- Just (Just "x")
-findM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a)
-findM ~p = foldr (\x -> ifM (p x) (pure $ Just x)) (pure Nothing)
-
-
-- | Drops the given suffix from a list.
--   It returns the original sequence if the sequence doesn't end with the given suffix.
--
-- >>> dropSuffix "!" "Hello World!"
-- "Hello World"
-- >>> dropSuffix "!" "Hello World!!"
-- "Hello World!"
-- >>> dropSuffix "!" "Hello World."
-- "Hello World."
-dropSuffix :: Eq a => [a] -> [a] -> [a]
-dropSuffix a b = fromMaybe b $ stripSuffix a b
-
-- | Return the prefix of the second list if its suffix
--   matches the entire first list.
--
-- >>> stripSuffix "bar" "foobar"
-- Just "foo"
-- >>> stripSuffix ""    "baz"
-- Just "baz"
-- >>> stripSuffix "foo" "quux"
-- Nothing
-stripSuffix :: Eq a => [a] -> [a] -> Maybe [a]
-stripSuffix a b = reverse <$> stripPrefix (reverse a) (reverse b)
-
-
-- | Drops the given prefix from a list.
--   It returns the original sequence if the sequence doesn't start with the given prefix.
--
-- >>> dropPrefix "Mr. " "Mr. Men"
-- "Men"
-- >>> dropPrefix "Mr. " "Dr. Men"
-- "Dr. Men"
-dropPrefix :: Eq a => [a] -> [a] -> [a]
-dropPrefix a b = fromMaybe b $ stripPrefix a b
-
-
-
-- | Break a list into pieces separated by the first
-- list argument, consuming the delimiter. An empty delimiter is
-- invalid, and will cause an error to be raised.
--
-- >>> splitOn "\r\n" "a\r\nb\r\nd\r\ne"
-- ["a","b","d","e"]
-- >>> splitOn "aaa"  "aaaXaaaXaaaXaaa"
-- ["","X","X","X",""]
-- >>> splitOn "x"    "x"
-- ["",""]
-- >>> splitOn "x"    ""
-- [""]
--
-- prop> \s x -> s /= "" ==> intercalate s (splitOn s x) == x
-- prop> \c x -> splitOn [c] x                           == split (==c) x
-splitOn :: Eq a => [a] -> [a] -> [[a]]
-splitOn [] _ = error "splitOn, needle may not be empty"
-splitOn _ [] = [[]]
-splitOn needle haystack = a : if null b then [] else splitOn needle $ drop (length needle) b
-    where (a,b) = breakOn needle haystack
-
-
-- | Splits a list into components delimited by separators,
-- where the predicate returns True for a separator element.  The
-- resulting components do not contain the separators.  Two adjacent
-- separators result in an empty component in the output.
--
-- >>> split (== 'a') "aabbaca"
-- ["","","bb","c",""]
-- >>> split (== 'a') ""
-- [""]
-- >>> split (== ':') "::xyz:abc::123::"
-- ["","","xyz","abc","","123","",""]
-- >>> split (== ',') "my,list,here"
-- ["my","list","here"]
-split :: (a -> Bool) -> [a] -> [[a]]
-split _ [] = [[]]
-split f (x:xs)
-  | f x = [] : split f xs
-  | y:ys <- split f xs = (x:y) : ys
-  | otherwise = [[]]
-
-
-- | Find the first instance of @needle@ in @haystack@.
-- The first element of the returned tuple
-- is the prefix of @haystack@ before @needle@ is matched.  The second
-- is the remainder of @haystack@, starting with the match.
-- If you want the remainder /without/ the match, use 'stripInfix'.
--
-- >>> breakOn "::" "a::b::c"
-- ("a","::b::c")
-- >>> breakOn "/" "foobar"
-- ("foobar","")
--
-- prop> \needle haystack -> let (prefix,match) = breakOn needle haystack in prefix ++ match == haystack
-breakOn :: Eq a => [a] -> [a] -> ([a], [a])
-breakOn needle haystack | needle `isPrefixOf` haystack = ([], haystack)
-breakOn _ [] = ([], [])
-breakOn needle (x:xs) = first (x:) $ breakOn needle xs
-
-
-
--- a/lib/GHCup/Utils/String/QQ.hs
+++ b/lib/GHCup/Utils/String/QQ.hs
@@ -44,14 +44,15 @@ import           Language.Haskell.TH.Quote
 -- The pattern portion is undefined.
 s :: QuasiQuoter
 s = QuasiQuoter
-  (\s' -> case all isAscii s' of
+  (\s' -> case and $ fmap isAscii s' of
    True  -> (\a -> [|fromString a|]) . trimLeadingNewline . removeCRs $ s'
    False -> fail "Not ascii"
  )
-  (error "Cannot use s as a pattern")
-  (error "Cannot use s as a type")
-  (error "Cannot use s as a dec")
+  (error "Cannot use q as a pattern")
+  (error "Cannot use q as a type")
+  (error "Cannot use q as a dec")
 where
  removeCRs = filter (/= '\r')
  trimLeadingNewline ('\n' : xs) = xs
  trimLeadingNewline xs          = xs
+
--- a/lib/GHCup/Version.hs
+++ b/lib/GHCup/Version.hs
@@ -24,11 +24,8 @@ import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T

 -- | This reflects the API version of the YAML.
--
-- Note that when updating this, CI requires that the file exsists AND the same file exists at
-- 'https://www.haskell.org/ghcup/exp/ghcup-<ver>.yaml' with some newlines added.
 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.7.yaml|]

 -- | The current ghcup version.
 ghcUpVer :: PVP
--- a/lib/System/Console/Terminal/Common.hs
+++ b/lib/System/Console/Terminal/Common.hs
@@ -1,43 +0,0 @@
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE DeriveDataTypeable #-}
-{-# LANGUAGE DeriveTraversable #-}
-
-#if __GLASGOW_HASKELL__ >= 702
-#define LANGUAGE_DeriveGeneric
-{-# LANGUAGE DeriveGeneric #-}
-#endif
-
-module System.Console.Terminal.Common
-  ( Window(..)
-  ) where
-
-import Data.Data (Typeable, Data)
-
-#if __GLASGOW_HASKELL__ < 710
-import Data.Foldable (Foldable)
-import Data.Traversable (Traversable)
-#endif
-
-#ifdef LANGUAGE_DeriveGeneric
-import GHC.Generics
-  ( Generic
-#if __GLASGOW_HASKELL__ >= 706
-  , Generic1
-#endif
-  )
-#endif
-
-- | Terminal window width and height
-data Window a = Window
-  { height :: !a
-  , width  :: !a
-  } deriving
-    ( Show, Eq, Read, Data, Typeable
-    , Foldable, Functor, Traversable
-#ifdef LANGUAGE_DeriveGeneric
-    , Generic
-#if __GLASGOW_HASKELL__ >= 706
-    , Generic1
-#endif
-#endif
-    )
--- a/lib/System/Console/Terminal/Posix.hsc
+++ b/lib/System/Console/Terminal/Posix.hsc
@@ -1,65 +0,0 @@
-{-# LANGUAGE CApiFFI #-}
-
-module System.Console.Terminal.Posix
-  ( size, fdSize, hSize
-  ) where
-
-import System.Console.Terminal.Common
-import Control.Exception (catch)
-import Data.Typeable (cast)
-import Foreign
-import Foreign.C.Error
-import Foreign.C.Types
-import GHC.IO.FD (FD(FD, fdFD))
-import GHC.IO.Handle.Internals (withHandle_)
-import GHC.IO.Handle.Types (Handle, Handle__(Handle__, haDevice))
-#if defined(__GLASGOW_HASKELL__) && (__GLASGOW_HASKELL__ < 706)
-import Prelude hiding (catch)
-#endif
-import System.Posix.Types (Fd(Fd))
-
-#include <sys/ioctl.h>
-#include <unistd.h>
-
-
-#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
-
-
-- Interesting part of @struct winsize@
-data CWin = CWin CUShort CUShort
-
-instance Storable CWin where
-  sizeOf _ = (#size struct winsize)
-  alignment _ = (#alignment struct winsize)
-  peek ptr = do
-    row <- (#peek struct winsize, ws_row) ptr
-    col <- (#peek struct winsize, ws_col) ptr
-    return $ CWin row col
-  poke ptr (CWin row col) = do
-    (#poke struct winsize, ws_row) ptr row
-    (#poke struct winsize, ws_col) ptr col
-
-
-fdSize :: Integral n => Fd -> IO (Maybe (Window n))
-fdSize (Fd fd) = with (CWin 0 0) $ \ws -> do
-  _ <- throwErrnoIfMinus1 "ioctl" $
-    ioctl fd (#const TIOCGWINSZ) ws
-  CWin row col <- peek ws
-  return . Just $ Window (fromIntegral row) (fromIntegral col)
- `catch`
-  handler
- where
-  handler :: IOError -> IO (Maybe (Window h))
-  handler _ = return Nothing
-
-foreign import capi "sys/ioctl.h ioctl"
-  ioctl :: CInt -> CULong -> Ptr CWin -> IO CInt
-
-size :: Integral n => IO (Maybe (Window n))
-size = fdSize (Fd (#const STDOUT_FILENO))
-
-hSize :: Integral n => Handle -> IO (Maybe (Window n))
-hSize h = withHandle_ "hSize" h $ \Handle__ { haDevice = dev } ->
-  case cast dev of
-    Nothing -> return Nothing
-    Just FD { fdFD = fd } -> fdSize (Fd fd)
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -1,29 +0,0 @@
-site_name: GHCup
-site_url: https://www.haskell.org/ghcup
-site_description: GHCup documentation
-site_author: GHCup Team
-
-repo_url: https://gitlab.haskell.org/haskell/ghcup-hs
-
-theme:
-    name: mkdocs
-    locale: en
-
-nav:
-  - Home: index.md
-  - "Getting Started": install.md
-  - "User Guide": guide.md
-  - "Developer Guide": dev.md
-  - About: about.md
-
-extra_css:
-    - css/extra.css
-
-markdown_extensions:
-    - toc:
-        permalink: 
-    - admonition
-    - attr_list
-    - def_list
-    - meta
-
--- a/scripts/dev/refreeze.sh
+++ b/scripts/dev/refreeze.sh
--- a/scripts/shell-completions/bash
+++ b/scripts/shell-completions/bash
--- a/scripts/shell-completions/fish
+++ b/scripts/shell-completions/fish
--- a/scripts/shell-completions/zsh
+++ b/scripts/shell-completions/zsh
--- a/stack.yaml
+++ b/stack.yaml
@@ -1,21 +1,26 @@
-resolver: lts-18.12
+resolver: lts-18.7

 packages:
  - .

 extra-deps:
+  - git: https://github.com/bgamari/terminal-size
+    commit: 34ea816bd63f75f800eedac12c6908c6f3736036
+  - git: https://github.com/hasufell/libarchive
+    commit: 024a7e8ab7b4d3848dc64dca1e70a04831eedc99
+
+  - brick-0.64@sha256:f03fa14607c22cf48af99e24c44f79a0fb073f7ec229f15e969fed9ff73c93f6,16530
  - IfElse-0.85@sha256:6939b94acc6a55f545f63a168a349dd2fbe4b9a7cca73bf60282db5cc6aa47d2,445
  - ascii-string-1.0.1.4@sha256:fa34f1d9ba57e8e89c0d4c9cef5e01ba32cb2d4373d13f92dcc0b531a6c6749b,2582
  - base16-bytestring-0.1.1.7@sha256:0021256a9628971c08da95cb8f4d0d72192f3bb8a7b30b55c080562d17c43dd3,2231
-  - brick-0.64@sha256:f03fa14607c22cf48af99e24c44f79a0fb073f7ec229f15e969fed9ff73c93f6,16530
  - 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
  - chs-deps-0.1.0.0@sha256:0cdada6d2c682c41b20331b8c63c2ecfc7e806928585195fd544c9d41f3074fd,2496
  - composition-prelude-3.0.0.2@sha256:1ffed216bd28d810fce0b5be83a661e2a892696d73b3f8de5c0f5edb9b5f0090,1216
-  - haskus-utils-data-1.4@sha256:bfa94363b94b14779edd6834fbd59dbb847c3d7b8f48e3844f456ffdc077da4a,1466
+  - haskus-utils-data-1.3@sha256:f62c4e49021b463185d043f7b69c727b63af641a71d7edd582d9f4f98e80e500,1466
  - haskus-utils-types-1.5.1@sha256:991c472f4e751e2f0d7aab6ad4220ef151d6160876dcf0511bbf876bbd432020,1298
-  - haskus-utils-variant-3.1@sha256:e602dd23e068c98d03c1027af20503addef8df6368577622453f44ccabea2a5b,2159
+  - haskus-utils-variant-3.0@sha256:8d51e45d3b664e61ccc25a58b37c0ccc4ee7537138b9fee21cd15c356906dd34,2159
  - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
  - hpath-posix-0.13.3@sha256:abe472cf16bccd3a8b8814865ed3551a728fde0f3a2baea2acc03023bec6c565,1615
  - hspec-2.7.10@sha256:c9e82c90086acebac576552a06f3cabd249bba048edd1667c7fae0b1313d5bce,1712
@@ -23,13 +28,12 @@ extra-deps:
  - hspec-discover-2.7.10@sha256:d08bf5dd785629f589571477d9beb7cd91529471bd89f39517c1cb4b9b38160f,2184
  - hspec-golden-aeson-0.9.0.0@sha256:aa17274114026661ba4dfc9c60c230673c8f408bd86482fd611d2d5cb6aff996,2179
  - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
-  - libarchive-3.0.3.0
  - 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
-  - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
  - primitive-0.7.1.0@sha256:29de6bfd0cf8ba023ceb806203dfbec0e51e3524e75ffe41056f70b4229c6f0f,2728
  - regex-posix-clib-2.7
  - streamly-0.7.3@sha256:ad2a488fe802692ed47cab9fd0416c2904aac9e51cf2d8aafd1c3a40064c42f5,27421
@@ -48,21 +52,7 @@ flags:
  regex-posix:
    _regex-posix-clib: true

-  aeson-pretty:
-    lib-only: true
-
-  cabal-plan:
-    exe: false
-
 ghc-options:
  "$locals": -O2
  streamly: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
  ghcup: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
-
-build:
-  test: true
-  test-arguments:
-    no-run-tests: true
-  bench: true
-  benchmark-opts:
-    no-run-benchmarks: true
--- a/test/GHCup/ArbitraryTypes.hs
+++ b/test/GHCup/ArbitraryTypes.hs
@@ -66,7 +66,7 @@ instance Arbitrary ByteString where
    ---------------------

 instance Arbitrary Scheme where
-  arbitrary = elements [ Scheme "http", Scheme "https" ]
+  arbitrary = oneof [ pure (Scheme "http"), pure (Scheme "https") ]

 instance Arbitrary Host where
  arbitrary = genericArbitrary
--- a/test/GHCup/Types/JSONSpec.hs
+++ b/test/GHCup/Types/JSONSpec.hs
@@ -13,5 +13,4 @@ import           Test.Hspec

 spec :: Spec
 spec = do
-  roundtripAndGoldenSpecsWithSettings (defaultSettings { goldenDirectoryOption = CustomDirectoryName "test/golden" }) (Proxy @GHCupInfo)
-
+  roundtripAndGoldenSpecs (Proxy @GHCupInfo)
--- a/www/ghcup.css
+++ b/www/ghcup.css
@@ -94,7 +94,7 @@ body#idx p.other-help {
 }

 .instructions > * {
-    width: 40rem;
+    width: 55rem;
    margin-left: auto;
    margin-right: auto;
 }
@@ -174,17 +174,7 @@ span.code {
    line-height: 2rem;
 }

-#help {
-    margin-bottom: 0px !important;
-}
-
-#collective {
-    margin-top: 1em !important;
-    margin-bottom: 0px !important;
-}
-
 #about {
-    margin-top: 0.5em !important;
    font-size: 16px;
    line-height: 2em;
 }
--- a/www/index.html
+++ b/www/index.html
@@ -24,29 +24,30 @@
      </p>

      <div id="platform-instructions-linux" class="instructions" style="display: none;">
-        <p>On 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"><a href="https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell" target="_blank">What does this do?</a> <b>&nbsp;&middot;&nbsp;</b> <a href="https://ghcup.readthedocs.io/en/latest/install/#manual-install">I don't like curl | sh</a> <b>&nbsp;&middot;&nbsp;</b> <a class="default-platform-button" href="#">I'm not running Linux</a></p>
+        <p>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>.<br/>You appear to be running Linux. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
      </div>

      <div id="platform-instructions-mac" class="instructions" style="display: none;">
-        <p>On macOS, run the following in your terminal (as a user other than root), then follow the onscreen instructions.</p>
+        <p>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' 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 class="other-help"><a href="https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell" target="_blank">What does this do?</a> <b>&nbsp;&middot;&nbsp;</b> <a href="https://ghcup.readthedocs.io/en/latest/install/#manual-install">I don't like curl | sh</a> <b>&nbsp;&middot;&nbsp;</b> <a class="default-platform-button" href="#">I'm not running macOS</a></p>
+        <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>

      <div id="platform-instructions-freebsd" class="instructions" style="display: none;">
-        <p>On FreeBSD Run the following in your terminal (as a user other than root), then follow the onscreen instructions.</p>
+        <p>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"><a href="https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell" target="_blank">What does this do?</a> <b>&nbsp;&middot;&nbsp;</b> <a href="https://ghcup.readthedocs.io/en/latest/install/#manual-install">I don't like curl | sh</a> <b>&nbsp;&middot;&nbsp;</b> <a class="default-platform-button" href="#">I'm not running FreeBSD</a></p>
+        <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 FreeBSD. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
      </div>

      <div id="platform-instructions-win32" class="instructions">
        <p>
-            On Windows, to install Haskell,<br/>run the following in a powershell session (as a non-admin user).
+            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.
 		</p>
@@ -57,19 +58,18 @@
 		</div>
        </p>
        <hr/>
-	<p class="other-help"><a href="https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell.ps1" target="_blank">What does this do?</a> <b>&nbsp;&middot;&nbsp;</b> <a class="default-platform-button" href="#">I'm not running Windows</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>
-            On Windows, to install Haskell,<br/>run the following in a powershell session (as a non-admin user).
+            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"><a href="https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell.ps1" target="_blank">What does this do?</a> <b>&nbsp;&middot;&nbsp;</b> <a class="default-platform-button" href="#">I'm not running Windows</a></p>
+				<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>
        </p>
-        <hr/>
 		<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>
 		<div>
@@ -77,7 +77,7 @@
 		</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"><a href="https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell" target="_blank">What does this do?</a> <b>&nbsp;&middot;&nbsp;</b> <a class="default-platform-button" href="#">I'm not running Windows</a></p>
+		<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;">
@@ -101,7 +101,7 @@
        <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>
 		  <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"><a href="https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell" target="_blank">What does this do?</a> <b>&nbsp;&middot;&nbsp;</b> <a href="https://ghcup.readthedocs.io/en/latest/install/#manual-install">I don't like curl | sh</a></p>
+          <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/>
@@ -120,7 +120,7 @@
          <p>To install Haskell, 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>
 		  <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"><a href="https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell" target="_blank">What does this do?</a> <b>&nbsp;&middot;&nbsp;</b> <a href="https://ghcup.readthedocs.io/en/latest/install/#manual-install">I don't like curl | sh</a></p>
+          <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/>
@@ -130,30 +130,25 @@
            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"><a href="https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell.ps1" target="_blank">What does this do?</a></p>
+				<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>
        </div>

      </div>

-      <p id="help">
+      <p>
 	  Need help? Ask on <a href="https://kiwiirc.com/nextclient/irc.libera.chat/?nick=Guest%7C?#haskell,#haskell-ghcup"><img src="irc.svg" height="18px" alt="" />IRC</a>, <a href="https://discord.gg/pKYf3zDQU7"><img src="Discord-Logo-Black.svg" height="18px" alt="" />Discord</a>, <a href="https://app.element.io/#/room/#haskell-tooling:matrix.org"><img src="Matrix_logo.svg" height="25px" alt="" style="top:5px;position:relative;" /></a> or <a href="https://gitlab.haskell.org/haskell/ghcup-hs/issues">report a bug <img src="Octicons-bug.svg" height="18px" alt="" /></a>.
      </p>
-      <p id="collective">
-		<a id="collective" href="https://opencollective.com/ghcup#category-CONTRIBUTE" target="_blank">
-			<img src="https://opencollective.com/webpack/donate/button@2x.png?color=blue" width=200 />
-		</a>
-      </p>

      <p id="about">
        <img src="haskell-logo.svg" alt="" />
        ghcup is a haskell.org supported project.
        <br/>
        <a href="https://www.haskell.org/downloads/">other installation options</a>
-		<b>&nbsp;&middot;&nbsp;</b>
-        <a href="https://ghcup.readthedocs.io/en/latest/">read the docs</a>
-		<b>&nbsp;&middot;&nbsp;</b>
+        &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>
    <script type="text/javascript" src="ghcup.js"></script>
Author	SHA1	Message	Date
Julian Ospald	2d25c865cc	Remove zip dependency	2021-08-25 20:13:17 +02:00
Julian Ospald	ca0c20552e	Merge branch 'remove-string-interpolate'	2021-08-25 20:12:56 +02:00