"For God so loved the world that he gave his only begotten Son, that whoever believes in him should not perish but have eternal life." -- John 3:16
Everything you need to develop, build, and ship Haskell
Compiler, package manager, script runner, REPL, test runner, AI integration, and a Haskell-extensible editor — all in one binary. Install once. No GHC, no Stack, no LLVM required.
510/513 curated, 43 CL + 82 LLVM roundtrips, 833/938 GHC typecheck (88.8%).
comonad, exceptions, void, distributive, semigroupoids, data-default, safe, vector, call-stack, and more. Cross-package resolution enabled.
Compiler, package manager, REPL, test runner, LSP, and AI tools — all in one binary.
Cranelift by default, LLVM for production, WebAssembly built-in. Three backends in one binary. 88.8% GHC test suite compatibility, 40+ extensions.
Install Hackage packages with one command. Reads .cabal files, resolves dependencies, compiles multi-module projects. 16 packages compile today, cross-package resolution built in.
Run Haskell files directly with a shebang line. Write #!/usr/bin/env haskelujah at the top, chmod once, and use Haskelujah like a scripting runtime.
Interactive environment with :type, :info, :load, multi-line input, and expression evaluation. Explore APIs, test ideas, and debug interactively.
Built-in MCP (Model Context Protocol) server. Run haskelujah mcp to expose type info, diagnostics, and project structure to Claude, GPT, and Gemini over stdio.
Built-in LSP server for real-time diagnostics in any editor. Run haskelujah lsp for VS Code, Neovim, Zed, Helix. Vision: a Haskell-extensible editor in the spirit of Emacs.
Rust-based runtime with mark-sweep GC, thunk trampolines for lazy evaluation, C ABI interop, and heap tracking. No external runtime required.
Run haskelujah test to scan test directories, type-check all .hs files, and report results. Integrates with HUnit and QuickCheck conventions.
Interop via FFI, CPP, and Cabal. Pluggable backends (Cranelift, LLVM, Wasm, JVM, BEAM) for targeting any platform from a single codebase.
fib(42) benchmark -- compiled output runtime, Apple M-series
Lower is better. Cranelift compiles 4x faster than LLVM with comparable runtime performance.
| Benchmark | Problem | GHC 9.14 -O2 | Cranelift | LLVM | Best vs GHC |
|---|---|---|---|---|---|
| fib(42) | Recursive Fibonacci | 1.26s | 0.91s | 0.91s | 1.38x faster |
| ack(3,11) | Ackermann function | 0.26s | 0.62s | 1.03s | 0.42x |
| euler1(100M) | 100M iterations (TCO) | 0.09s | 0.15s | 0.35s | 0.60x |
| tak(30,20,10) | Takeuchi function | 0.10s | 0.16s | 0.27s | 0.63x |
| qsort(1K) | Quicksort random | 0.22s | 0.20s | 0.15s | LLVM 1.47x |
| primes(10K) | Sieve of Eratosthenes | 0.28s | 0.59s | 0.18s | LLVM 1.56x |
Benchmarks on Apple M-series. Both Cranelift and LLVM backends support tail-call optimization (TCO). Cranelift beats GHC -O2 on recursive workloads; LLVM excels at list-heavy operations.
3-minute demo: init, check, test, format, AI — all from one binary.
Everything you need to get started.
Install, create a project, build, test, and edit — step by step.
15 built-in modules: JSON, Test, Text, Map, Set, Pretty, Random, and more.
AI integration via Model Context Protocol — Claude, GPT, Gemini.
Record your own demo video with narration cues.
Write Haskell in your browser — no install needed.
Up and running in seconds.
# Install
$ cargo install haskelujah
# Create a project
$ mkdir my-app && cat > my-app/Main.hs
module Main where
main = putStrLn "Hello from Haskelujah"
# Build and run
$ haskelujah build my-app/
Compiled 1 modules in order: Main
Finished build in 0.09s
$ ./my-app/dist-chirho/build/my-app
Hello from Haskelujah!
# Or skip compilation entirely — run as a script
$ cat > hello.hs
#!/usr/bin/env haskelujah
main = putStrLn "Runs directly, no build step."
$ chmod +x hello.hs && ./hello.hs
Runs directly, no build step.
module Main where
-- Tail-call optimized loop plus ordinary recursion
euler1_chirho :: Int -> Int
euler1_chirho limit_chirho = go_chirho 0 0
where
go_chirho acc_chirho n_chirho
| n_chirho >= limit_chirho = acc_chirho
| n_chirho mod 3 == 0 || n_chirho mod 5 == 0
= go_chirho (acc_chirho + n_chirho) (n_chirho + 1)
| otherwise = go_chirho acc_chirho (n_chirho + 1)
main :: IO ()
main = print (euler1_chirho 1000)
21 focused Rust crates. 12-phase compilation pipeline.
Built for compatibility with the Haskell ecosystem.
Reads standard .cabal files. Multi-module projects with library and executable components compile out of the box.
haskelujah install aeson fetches from Hackage. 17 packages compile including transformers, mtl, parsec. Plus 9 built-in stdlib modules (JSON, Test, Args, HTTP, Text, Process, Time, File, Prelude) — no install needed.
One self-contained executable. No runtime dependencies, no GHC installation, no LLVM toolchain (unless you opt in). Install with cargo install haskelujah, then run binaries or scripts with #!/usr/bin/env haskelujah.
putStrLn, putStr, getLine, and read all work in compiled programs. Interactive prompts, scripting, and stdin-driven tools run end to end on both native backends.
haskelujah repl gives you an interactive environment with :type, :info, :load, multi-line input, and expression evaluation.
Where we still fall short of GHC.
LensLike' and some deep higher-rank patterns still have inference gaps.forall a. C a => D (f a) in class superclass positions needs parser-level AST support. Blocks deepseq.Token s / Tokens s normalization not yet implemented. Blocks megaparsec stage 2.makeLenses work; full TH (typed splices, reify) is incomplete.Where we're headed, God willing.
Compile the Haskelujah compiler to WebAssembly so the browser playground runs the real type checker — no server needed.
17 packages compile today (transformers + mtl + parsec cascade). Next: aeson, lens, megaparsec, QuickCheck, deepseq.
haskelujah test to discover and run HUnit, QuickCheck, and Hspec test suites. Parallel execution, colored output, watch mode.
We already compile non-trivial Haskell to native binaries. Next: compile a Haskell-written frontend for Haskelujah itself — a compiler that compiles its own language.
Target selection from CLI: compile to Linux, macOS, Windows, Wasm, or embedded targets from a single machine.
Demand analysis to avoid unnecessary thunks. Worker-wrapper transform for strict arguments. Automatic unboxing.
Cost-center annotation, heap profiling, time profiling, and flamegraph generation for performance optimization.
haskelujah fmt for opinionated Haskell formatting. Fast, consistent, zero-config. Like rustfmt for Haskell.