README.md

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.

Similar in scope to rustup, pyenv and jenv.

Table of Contents

• Installation
  • Simple bootstrap
  • Manual install
  • Vim integration
• Usage
  • Configuration
  • Manpages
  • Shell-completion
  • Compiling GHC from source
  • XDG support
  • Env variables
  • Installing custom bindists
  • Isolated Installs
  • CI
  • Tips and tricks
• Design goals
• How
• Known users
• Known problems
• FAQ

Installation

Simple bootstrap

Follow the instructions at https://www.haskell.org/ghcup/

Manual install

Download the binary for your platform at 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:

export PATH="$HOME/.cabal/bin:$HOME/.ghcup/bin:$PATH"

Vim integration

See ghcup.vim.

Usage

See ghcup --help.

For the simple interactive TUI, run:

ghcup tui

For the full functionality via cli:

# 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, which handles your haskell packages and can demand that a specific version 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.

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

Manpages

For man pages to work you need man-db 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 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, copy them somewhere, adjust them and pass --config path/to/build.mk to ghcup compile ghc. Common build.mk options are explained here.

Make sure your system meets all the prerequisites.

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. 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 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

   ---

CI

On windows, ghcup can be installed automatically on a CI runner like so:

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:

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:

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 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:

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:

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:

# 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