Stackage

Stackage
Name	Stackage
Developer	The Haskell Community, FP Complete
Released	2013
Programming language	Haskell
Operating system	Cross-platform
License	BSD-style

Stackage is a curated package set for the Haskell (programming language), providing collections of compatible library versions and reproducible snapshots for software development. It aims to reduce dependency conflicts by combining packages from the Hackage archive into tested, stable collections used with tools like Stack (software). Stackage interacts with ecosystems around GHC (Glasgow Haskell Compiler), continuous integration services, and multiple language tooling initiatives.

Overview

Stackage offers curated, versioned snapshots that integrate with the Haskell Platform, GHC, Cabal (software), and package repositories such as Hackage. It supports reproducible builds alongside tools like Stack (software), Nix (software), and CI providers including Travis CI, GitHub Actions, GitLab CI/CD. Major commercial actors and organizations using the snapshots include FP Complete, Well-Typed, Commercial Haskell Group, IOHK, and research groups at University of Cambridge, University of Pennsylvania, and Microsoft Research. Stackage’s approach influenced package management discussions with projects such as Cargo (software), npm (software), RubyGems, and Maven (software).

History

Stackage originated in the early 2010s as a response to dependency resolution problems observed across Hackage and during work with successive versions of GHC. Key contributors and entities included FP Complete, Neil Mitchell, Will Sewell, and community members from the Haskell.org foundation. The project evolved alongside developments in Stack (software), announcements at conferences such as I Haskell, Strange Loop, ICFP (conference), and Haskell Symposium, and collaborations with academics from University of Glasgow and practitioners at Facebook and Google who experimented with functional languages. Over time Stackage introduced long-term snapshots, nightly builds, and integration with package testing infrastructure coordinated by organizations like ThoughtWorks and IOHK.

Architecture and Components

Stackage’s architecture centers on a snapshot database, build matrix, and automated test runners that validate combinations of packages against compiler versions such as GHC releases. Components include snapshot metadata, package index mirroring, dependency graphs, and compatibility constraints relying on version bounds from package manifests used in Cabal (software) and Stack (software). Infrastructure uses build tools and services such as Docker, Nix, Travis CI, Jenkins, and cloud providers like Amazon Web Services and Google Cloud Platform for distributed compilation. The system integrates with code hosting platforms like GitHub, Bitbucket, and GitLab to track upstream changes and trigger rebuilds, and it coordinates with package authors and maintainers from organizations including FP Complete and the Haskell.org community.

Package Versioning and Snapshot System

Snapshots are created as coherent sets combining specific versions from Hackage and are identified by tags such as nightly, LTS (Long Term Support), and custom resolvers used by Stack (software). The snapshot system maps package versions to specific GHC releases, facilitating reproducible dependency resolution similar in goal to solutions like Bundler (Ruby), Cargo.lock, and package-lock.json in npm (software). Stackage enforces compatibility via automated test suites, dependency constraint evaluation, and a curated policy influenced by practices from Debian, Fedora Project, and Arch Linux package maintainers. The LTS series provides slower-moving stable collections used in production by companies like Well-Typed and academic projects at Imperial College London, while nightly snapshots enable quicker updates appreciated by contributors at FP Complete and researchers at Microsoft Research.

Usage and Tooling

Developers interact with Stackage primarily through Stack (software), which consumes snapshot resolvers to create deterministic build plans. Integration exists with editors and IDEs including Visual Studio Code, Emacs, IntelliJ IDEA, and Atom, as well as language servers like haskell-language-server. Build and CI workflows often combine Stackage with Nix or Docker for hermetic builds, and deployment pipelines use container registries from Docker Hub and orchestration with Kubernetes. Testing and benchmarking workflows draw upon tools such as QuickCheck, HUnit, criterion (Haskell) and profiling utilities maintained by the GHC ecosystem. Package authors use Stackage’s build reports and logs to debug regressions with assistance from maintainers at FP Complete and contributors via Hoogle and Hackage issue trackers.

Community and Governance

Stackage governance is community-driven, involving maintainers, contributors, and companies that rely on stable Haskell distributions. Coordination occurs on platforms like GitHub, mailing lists hosted under Haskell.org, chatrooms on IRC and Matrix, and conference presentations at Haskell eXchange and ICFP. Major contributors include staff from FP Complete, independent maintainers such as Neil Mitchell, and academic collaborators from University of Glasgow and University of Pennsylvania. Funding and sponsorship have come from organizations like Well-Typed, Commercial Haskell Group, and grants associated with research groups at Microsoft Research and IOHK.

Criticism and Limitations

Critiques of the Stackage model reference slower incorporation of new versions compared with unconstrained registries like Hackage, interaction complexity with tools such as Cabal (software), and the maintenance burden similar to challenges observed in projects like Debian and Fedora Project. Some package authors and organizations including small open-source teams and experimental labs at Universities prefer the flexibility of rolling registries exemplified by npm (software) and PyPI. Limitations include constraints when upstream packages require newer GHC features, the resource cost for continuous testing using providers such as Travis CI and GitHub Actions, and occasional coordination friction among stakeholders similar to governance debates in Linux Foundation projects.

Category:Haskell