# What happened to all the Haskell compilers?

**URL:** <https://discourse.haskell.org/t/what-happened-to-all-the-haskell-compilers/11269>\
**Category:** Uncategorized\
**Created:** [January 24, 2025, 5:30pm UTC](https://discourse.haskell.org/t/what-happened-to-all-the-haskell-compilers/11269 "2025-01-24T17:30:23Z")\
**Posts on this page:** 6\
**Page:** 1

<div class="post-metadata">

**Author:** ![konsumlamm](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/konsumlamm/32/3193_2.png) [@konsumlamm](https://discourse.haskell.org/u/konsumlamm)\
**Post date:** [January 24, 2025, 5:30pm UTC](https://discourse.haskell.org/t/what-happened-to-all-the-haskell-compilers/11269/1 "2025-01-24T17:30:23Z")

</div>

I recently found out about [MicroHs](https://github.com/augustss/MicroHs), a Haskell compiler using combinators to get very small executables. It is, as far as I know, the only Haskell compiler besides GHC that is being actively developed/maintained. So I wonder, what happened to all the other Haskell compilers? I found the paper [A History of Haskell: Being Lazy With Class](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/history.pdf) from 2007, which, among other things, talks about the different Haskell implementations. There’s also a page on the Haskell Wiki about [Haskell implementations](https://wiki.haskell.org/index.php?title=Implementations). Since all of them, except GHC and MicroHs, are kind of dead, I’m interested in why they died and what made them special. Here’s what I gathered so far:

- `hbc` was the first Haskell compiler, written in Lazy ML, by Lennart Augustsson (who is also the author of MicroHs). Being written in Lazy ML is likely why it died.
- Hugs is a Haskell interpreter and seems to have been quite popular.
- `nhc98` was supposed to be space-efficient. It only works on 32 bit platforms.
- Yale Haskell compiled to Common Lisp. It was abandoned in 1995 due to performance issues & lack of funding.
- UHC (Utrecht Haskell Compiler) had JVM and JS backends.
- `jhc` did whole-program analysis to produce efficient programs. Also works as a cross compiler.
- `yhc` (York Haskell Compiler) was a fork of nhc. I found a blog post [“Yhc is dead”](https://yhc06.blogspot.com/2011/04/yhc-is-dead.html). It seems the main reason for its death was that too many libraries rely on GHC.
- LHC (LLVM Haskell Compiler) compiled to LLVM. Probably succeeded by GHCs LLVM backend?

---

<div class="post-metadata">

**Author:** ![jaror](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/jaror/32/3271_2.png) [@jaror](https://discourse.haskell.org/u/jaror)\
**Post date:** [January 24, 2025, 5:34pm UTC](https://discourse.haskell.org/t/what-happened-to-all-the-haskell-compilers/11269/2 "2025-01-24T17:34:29Z")

</div>

[Helium](https://github.com/Helium4Haskell/helium/tree/codegen-llvm-typed) is another kind of maintained Haskell compiler.

UHC was mainly maintained by Atze Dijkstra who got a job at Standard Chartered (building their Mu compiler, which is for a dialect of Haskell). I think he wants to pick it up again after he retires.

---

<div class="post-metadata">

**Author:** ![atravers](https://avatars.discourse-cdn.com/v4/letter/a/45deac/32.png) [@atravers](https://discourse.haskell.org/u/atravers)\
**Post date:** [January 24, 2025, 8:55pm UTC](https://discourse.haskell.org/t/what-happened-to-all-the-haskell-compilers/11269/3 "2025-01-24T20:55:56Z")

</div>

> What happened to all the [other] Haskell compilers?

- GHC;

- x86-64;

- Haskell 2010.

* * *

**GHC**

As you’ve already discovered, the pre-H.2010 Haskell compilers were abandoned because GHC’s performance kept improving. Hugs was eventually abandoned because of `ghci` (though its compact size and portable codebase still sees some interest, including from [MicroHs](https://github.com/augustss/MicroHs/tree/hugs)!)

After 2010, I believe those (remaining) compilers were abandoned either because of dwindling interest (`yhc`) or efforts (research or otherwise) being redirected to GHC. The latter continues to happen - I dimly recall reading about Standard Chartered’s decision to replace their _“in-house”_ Mu implementation with one based on GHC.

Too many libraries relying on GHC is also a problem for MicroHs:

> [@](#):
>
> (final page)
> 
> It is worth mentioning that MicroHs has its own version of Cabal: MicroCabal ([git@github.com](mailto:git@github.com):augustss/MicroCabal.git). The reason for this is that the Cabal tool is written in Haskell with so many GHC specific extensions that it cannot be compiled with MicroHs (or any other non-GHC Haskell compiler I know of).
> 
> […]
> 
> I would also like to thank package authors (very few) who use Haskell2010 instead of Haskell with GHC-only extensions.
> 
> [MicroHs: A Small Compiler for Haskell](https://github.com/augustss/MicroHs/blob/master/doc/hs2024.pdf) (2024)

(and any future alternative Haskell implementation).

* * *

**x86-64**

Being an interpreter, Hugs was probably the first to support it, and `hbc` already supported the Sparc 64-bit architecture. Using the 32-bit compatibility mode of x86-64, _eventually_ `nhc` was ported over as well.

But FFI support for x86-64 in Hugs is incomplete - from `mkThunk()` in [`src/builtin.c`](https://github.com/FranklinChen/hugs98-plus-Sep2006/blob/master/src/builtin.c):

```plaintext
/* line 2056 */
#if i386_HOST_ARCH

/* line 2073 */
#elif powerpc_HOST_ARCH && defined( __GNUC__ )

/* line 2122 */
#elif sparc_HOST_ARCH && defined( __GNUC__ )

/* line 2181 */
#else
    ERRMSG(0) "Foreign import wrapper is not supported on this architecture"
    EEND;
#endif

```

But probably the main reason why no other Haskell implementation was ported across was the work involved to do so - despite the support it had, even GHC’s port required sustained effort to work _“as expected”_ (_i.e._ faster than x86).

* * *

**Haskell 2010**

None of the pre-H.2010 implementations _“fully”_ migrated to 2010 in time - having already mentioned the difficulties in Hugs, it did arrive in `nhc` (but I believe that was due to the efforts of the `yhc` developers, for bootstrapping purposes). There was no great interest in upgrading the remaining pre-H.2010 Haskell implementations - by then most people had (perhaps reluctantly) _“settled for”_ GHC.

* * *

So it would appear that the process of convergence started in 1987 has worked _too_ well:

- with Haskell superseding the various (and mostly _“single-site”_ ) non-strict languages that existed back then;

- and GHC superseding the other implementations of Haskell (and those of other functional languages such as Mu **\*** ).

…now both [Curry](https://www.curry-lang.org) and [Prolog](http://prolog-lang.org) have more implementations than Haskell.

---

<div class="post-metadata">

**Author:** ![AntC2](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/antc2/32/1872_2.png) [@AntC2](https://discourse.haskell.org/u/AntC2)\
**Post date:** [January 24, 2025, 9:32pm UTC](https://discourse.haskell.org/t/what-happened-to-all-the-haskell-compilers/11269/4 "2025-01-24T21:32:42Z")

</div>

> [@konsumlamm](#):
>
> `hbc` was the first Haskell compiler,

Note that Hugs was based on Gofer – which wasn’t quite Haskell, but was a development of ~~ML~~ Miranda in a Haskellish direction.

And not quite true to say Hugs is dead. See posts on the Hugs-users mailing list, as well as @atravers’ links.

(I’d write more, but sorry, I’m travelling at the moment, so limited access.)

---

<div class="post-metadata">

**Author:** ![chrisdone](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/chrisdone/32/1408_2.png) [@chrisdone](https://discourse.haskell.org/u/chrisdone)\
**Post date:** [January 25, 2025, 9:14pm UTC](https://discourse.haskell.org/t/what-happened-to-all-the-haskell-compilers/11269/5 "2025-01-25T21:14:00Z")

</div>

I made an archive of Haskell implementations here FWIW [Haskell Implementations Archive · GitHub](https://github.com/haskell-implementations)

---

<div class="post-metadata">

**Author:** ![markus](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/markus/32/2194_2.png) [@markus](https://discourse.haskell.org/u/markus)\
**Post date:** [January 30, 2025, 4:53pm UTC](https://discourse.haskell.org/t/what-happened-to-all-the-haskell-compilers/11269/6 "2025-01-30T16:53:49Z")

</div>

It takes substantial effort and knowledge to write a compiler, especially if nobody is supporting it’s development.