is a new, complete, cross-platform development tool aimed at both
new and experienced Haskell developers alike, for installing and
setting up the compiler, installing packages needed, and building,
testing or benchmarking one or more packages in a project at a
time. It's the whole stack.
We developed it in collaboration with
the Commercial Haskell Group, with two deliberate goals in
- Newbie friendliness, ease of setup and doing the right thing by
default. Just get people running with Haskell as conveniently as
- Catering to the finer points of serious commercial Haskell
development. Supporting the modern use-cases of working on large
In short, it's a program that you run in a directory with a
stack configuration file in it
stack.yaml—automatically created if one doesn't
exist). That directory may contain one or many packages inside it
to be built. Then there are commands to build, test, install
dependencies, run GHC, etc.
Here's a rundown of the advantages
stack brings to
the table. For both newbies and experienced Haskellers:
- It's really easy to get going with Haskell. You can just run
stack build in a package directory and it will
automatically download and install GHC, the standard Haskell
compiler, for you, download the package index and install packages
that are needed.
- It also caters to newbies reading books who just want to run
ghc on a file. You can run
stack ghc X.hs
and it will download GHC if necessary, etc. until it can run GHC on
that file. The same is true for
stack ghci, etc.
- It automatically assumes (and does some figuring out if there's
a project Cabal file) the latest LTS Haskell release as its source
of packages, or otherwise a nightly release. This means you can
just use packages without worrying about what versions match up and
trying to think like a package manager thinks.
For experienced Haskellers, there is support for typical
use-cases and subtleties of larger projects:
- This also means you can just put the snapshot release in your
version control, via the
stack.yaml file, which is
important for reliable collaboration.
- Serious commercial or large scale users of Haskell can build
so-called "mega-repos", by adding to the list of
packages in your stack.yaml, you can build/test/bench
multiple projects at once.
stack build will just build
stack build this will build
this package and rebuild anything that depends on it,
and also any of its dependencies that changed.
- You can enable profiling in the configuration and this will
automatically rebuild all packages with profiling turned on for
- Packages are installed into isolated package databases by
default. There is a layering of three package databases: The global
database, the snapshot database, and your personal project's
database. Many projects can share the same global database (base,
bytestring, etc.) and the snapshot database (e.g. text,
haskell-src-exts, etc.)—which means no unnecessary rebuilding of
packages—and yet each project has its own package database, so they
are isolated from each other and cannot break each other.
- Binary installs of your personal projects are also isolated
into that directory.
- In this "local" database, you can also specify newer upstream
versions than are available in the snapshot. In fact, the snapshot
is optional, you can be based on plain Hackage. This is not the
default behaviour and is a configuration option.
- It also supports docker integration for truly sandboxed
environments. By enabling docker in the configuration, running
stack build will download the image if necessary and
then run the build inside the docker image. There is an array of
options available for the docker integration.
We first arrived at this tool based on feedback from our clients
at FP Complete and have been using this tool in-house ourselves for
around a year, in several iterations. This final iteration has had
particular focus on ease of use. We were also motivated by the
results of the recent Haskell
Feedback from members of the Commercial Haskell Group has been
very helpful in shaping the direction of the tool in a positive way
and we now open it up, open source, in beta and for the Haskell
community as a whole and welcome your contributions, ideas and
stack is available on Hackage (
stack), as well as binary
downloads for Windows, Mac, and Linux, with Ubuntu and Arch
packages. Please note that this is a beta release: we
anticipate bugs, and will work to quickly resolve them. Please be
sure to report issues on the Github
Do you like this blog post and need help with DevOps, Rust or functional programming? Contact us.