Fast. Unified. Modern.
arcanist.sh
High-performance Haskell tooling
An ecosystem of tools for building, shipping, and running Haskell. Built in Rust.
hx
The Haskell package manager
An extremely fast Haskell package and project manager. Build, test, run, format, lint, and publish — all in one tool with managed toolchains.
- Unified build, test, run, format, lint
- Managed GHC & BHC toolchains
- Deterministic TOML lockfiles
- Steel (Scheme) plugin system
BHC
Basel Haskell Compiler
An alternative Haskell compiler with runtime profiles, WASM targets, tensor-native numerics, and structured concurrency. GHC-compatible and drop-in for most packages.
- Runtime profiles: default, server, numeric, edge
- Multiple targets: native, WASI, WASM
- Tensor-native numerics & structured concurrency
- GHC-compatible, drop-in for most packages
See it in action
Blazingly fast
hx is a native Rust binary with no runtime to spin up. From the first keystroke to an incremental rebuild, every step of the loop is measurably faster than cabal and stack.
The language was right. The tooling was not.
Haskell has been called niche for thirty years. That framing assumes a world where humans write all the code. In a world where AI writes most of it, the language that wins is the one where correctness is checkable. Haskell is not niche in that framing. It is early.
-
AI is becoming the primary author of code
Every layer of abstraction absorbed the one beneath it — assembly, C, package managers, Stack Overflow, and now coding agents. When the author of code changes, the language adapts to the new author's strengths. That is not a break from the pattern. It is the pattern.
-
When generation is cheap, verification is the bottleneck
Plausible code is cheap, and plausible code is often wrong. The hard part is no longer writing the code — it is proving the code is correct. The generator does not need to be trusted. The artifact needs to be checkable.
-
Haskell makes correctness load-bearing
A well-typed Haskell function is not just code. It is a proof that a transformation is valid, and the compiler is the proof checker. Correctness is correct by construction, not iterated into after the fact. In the happy path, there is no feedback loop to run.
-
The tooling is the thesis
We are copying what works. Rust showed what a great language is worth when the ecosystem around it is effortless — cargo for adoption, and a compiler that catches as much as it possibly can at compile time. We want the same for Haskell: hx brings the frictionless toolchain, BHC brings a compiler that checks everything it can, and we intend to add more checks, not fewer. The tooling is not separate from the thesis. The tooling is the thesis.
The model does not need to be right. It needs to be checkable.
Built in the open
Every part of the ecosystem — the hx toolchain and the BHC compiler — is open source and developed in public. Star the projects, join the discussion, and help shape the future of Haskell tooling.
MIT licensed
Every tool in the ecosystem is permissively licensed — use it in any project, commercial or not.
Developed in public
Source, issues, roadmaps, and design decisions all live on GitHub — nothing behind closed doors.
Built with the community
Conventional commits, open discussions, and a welcoming path for first-time contributors.
Questions, answered
Why Haskell in 2026?
Haskell has been called niche for thirty years, but that framing assumes humans write all the code. When AI writes most of it, the language that wins is the one where correctness is checkable — where types are proofs and the compiler is the proof checker. Haskell is not niche in that framing. It is early.
Why build a Haskell toolchain in Rust?
A toolchain should not share its dependencies with the thing it manages. Haskell's tooling problems are partly caused by tooling written in Haskell, which creates bootstrap problems and long compile times. A Rust binary starts in milliseconds, ships as a single static executable, and cross-compiles trivially. We write the tooling in Rust, but we think in Haskell.
What is BHC, and how is it different from GHC?
BHC, the Basel Haskell Compiler, is a clean-slate compiler for Haskell. It compiles the same language with the same type safety, but adds runtime profiles — default, server, numeric, edge, realtime, and embedded — each with a different performance contract, selected by a single flag. It aims to be GHC-compatible and drop-in for most packages.
Is this just speculation about AI?
No. The thesis is grounded in shipped tooling. hx delivers 5.6x faster cold builds and deterministic lockfiles today, and both hx and BHC were themselves built with AI coding agents. The thesis tested itself during its own construction.
What if you are wrong, and Haskell never revives?
We have a conviction, not a crystal ball. Even if the broader bet does not land, the work stands on its own: fast Rust-based tooling, deterministic builds, runtime profiles, and structured, machine-readable errors are valuable for any Haskell project today.
If AI writes the code, what do humans do?
We define constraints. We shape intent. We evaluate outcomes. The unit of work becomes the obligation, not the function — closer to architecture than to authorship. The compiler still has to verify the result, and Haskell makes that verification load-bearing.
Is arcanist.sh open source?
Yes. Every tool in the ecosystem — the hx toolchain and the BHC compiler — is MIT-licensed and developed in public on GitHub, with open issues, roadmaps, and design decisions.
How do I get started?
Install hx, pick your compiler, and build. hx manages the toolchain, resolves dependencies, and drives builds, while BHC is available as a compiler backend. See the documentation to set up your first project.
Supercharge your Haskell tooling
One ecosystem for building, shipping, and running Haskell — a fast toolchain and a modern compiler, ready when you are.