PRprivong·Dec 16, 2025
To save folks a search:
github repo: https://github.com/lexi-lambda/hackett
Documentation: https://lexi-lambda.github.io/hackett/
In Liskell – Haskell Semantics with Lisp Syntax [pdf]lexi-lambda
hackett
Racket2017–2025
lexi-lambda / hackett
hackett
WIP implementation of a Haskell-like Lisp in Racket
20Distinct people
23Mentions
1Explicit recommenders
1.2KGitHub stars
What to know before exploring
What it is
WIP implementation of a Haskell-like Lisp in Racket
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
> I'm hoping one day someone will make a statically, strongly typed Lisp that still doesn't sacrifice its flexibility and expressive power. I'd jump to that in an instant. This…
reirob used a recommendation phrase. One indexed comment matches. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 11:56:56 AM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year23 dated mentions
Observed mentions: 2017-04-22 14:27:54 UTC to 2025-12-16 21:43:16 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 5 | 0 | 5 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 6 | 1 | 5 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 3 | 1 | 2 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 2 | 0 | 2 |
What Hacker News says
23 sourcesAs far as your first question is concerned, macros in and of themselves are not incompatible with a typed language. Coalton uses Lisp macros, for example, and they work seamlessly and as expected.
But a Coalton macro is typically written in Lisp, not Coalton. This isn't in and of itself a problem---it's very easy and straightforward thus to write Common Lisp-style macros in Coalton. The difficulties arise when the macro must itself be (1) written in a statically typed manner, which gets into having a complete typing on your metalanguage (or your AST), and (2) allowed to access the type environment of the surrounding context in which the expansion is happening. If (2) should be accomplished, then the type-checking machinery must collaborate with the macro-expansion machinery, and that in practice makes both tasks very difficult to specify
Read the rest
semantics for and implement.
The language Hackett [1] worked toward solving the problem of having true typed and type-aware macros (they call them "type-aware" and "type-directed" macros [2]). Development unfortunately ceased ~7 years ago.
[1] https://github.com/lexi-lambda/hackett
[2] I think this video has a good discussion of Lisp, macros, and static types, from the perspective of implementing a Haskell in Racket. https://www.youtube.com/watch?v=5QQdI3P7MdY
If you want to design a programming language, and are okay with building off of an existing language, I suggest giving Racket a try. It can do more than just create DSLs and compile down to Racket code. I recently learned about sham* which allows interfacing with LLVM. I've linked some examples and references below
References
1. https://docs.racket-lang.org/guide/languages.html
2. https://docs.racket-lang.org/turnstile/
Examples
1. https://github.com/soegaard/urlang
2. https://github.com/rjnw/sham
3. https://github.com/ShawSumma/lure
4. https://github.com/racket/rhombus-prototype
5. https://github.com/lexi-lambda/hackett
In So you want to design a programming language (2017)Here's a Lisp that's statically typed with macros:
https://github.com/lexi-lambda/hackett
In BLisp: A Statically Typed Lisp Like LanguageHackett: https://github.com/lexi-lambda/hackett
Based on this paper: http://www.ccs.neu.edu/home/stchang/pubs/ckg-popl2017.pdf
In ToriLisp – an ersatz Lisp for tiny birdsIt does exist and it's called Racket [1] and language-oriented programming. You can write prolog-like languages [2], or Haskell-like [3], or even C-like languages [4].
You can even write BNF directly [5] and you can /call/ these constructs across different languages. Racket makes it /easy/ to play with semantics and syntax. You can feasibly write a language in an afternoon, to solve 1 specific problem.
[1] https://racket-lang.org/
[2] https://docs.racket-lang.org/datalog/datalog.html?q=datalog
[3] https://github.com/lexi-lambda/hackett
[4] https://docs.racket-lang.org/profj/
[5] https://beautifulracket.com/appendix/why-lop-why-racket.html
In Multi-Paradigm Languages> I'm hoping one day someone will make a statically, strongly typed Lisp that still doesn't sacrifice its flexibility and expressive power. I'd jump to that in an instant.
This part inspired me to look up the wiki page "Haskell Lisp [1], because I somehow remembered that some people were trying to make a Haskell that could be written in Lisp. But this page reveals even more interesting efforts:
> Shentong - The Shen programming language is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler. Shentong is an implementation of Shen written in Haskell.
> Liskell - From the ILC 2007 paper: "Liskell use
Read the rest
s an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.
But this page does not list everything and there is Hackett [2], which introduces itself with "Hackett is an attempt to implement a Haskell-like language with support for Racket’s macro system, built using the techniques described in the paper Type Systems as Macros. It is currently extremely work-in-progress." - though it seems that it didn't change since two years.
And finally there is Axel [3] - which introduces itself with "Haskell's semantics, plus Lisp's macros.
Meet Axel: a purely functional, extensible, and powerful programming language."
Disclaimer: I never learned any Lisp, went from C/Java/JavaScript/Bash straight to Haskell and am a Haskell beginner for lifetime. Though I love the language and the fact that I will be learning it and surprised by it for the rest of my life.
[1] https://wiki.haskell.org/Haskell_Lisp
[2] https://github.com/lexi-lambda/hackett
[3] https://axellang.github.io/
Hackett, a Haskell-Like Lisp in Racket
65 points · Open discussionthere's [Hackett](https://github.com/lexi-lambda/hackett) though it's more an implementation of haskell within racket
In Why Haskell Is Importanthttps://github.com/lexi-lambda/hackett
Under active development, still WIP
In Why Haskell Is ImportantTo save others a search:
Haskell-like Lisp in Racket https://github.com/lexi-lambda/hackett
In Ask HN: Why is everyone here so obsessed with Lisp?I dunno, given https://github.com/lexi-lambda/hackett/issues/98#issuecommen... (saw this when it was sent initially because watching the repo). Knowing one's limits is not necessarily imposter syndrome. If I were to acquire the knowledge (say by reading my recently acquired copy of TAPL), I'll revisit this.
Hackett pushes the boundaries of the Racket macro system, and IIRC through its development has found a number of deficiencies/bugs (I may be misremembering this, however, so don't take it as absolutely true). Besides that, Haskell is a rather complex language, so undertaking the creation of such a thing is no small task. And then we have the issue of
what my own personal knowledge is.
I really hope development once again takes off! Its such a cool project. But I know I wouldn't have the first clue of the right way to do certain things
Read the rest
that I know are outstanding.
I thank you for your kind sentiments though!
There's an experimental Racket language called Hackett which is attempting to give you the best of both worlds of Lisp's macros and Haskell's types.
https://github.com/lexi-lambda/hackett
In How Lisp Became God's Own Programming LanguageJust to add: Hackett [0] is a lispy Haskell that has been under active development for some time.
Based around a paper, Type Systems as Macros [1]
[0] https://github.com/lexi-lambda/hackett
[1] http://www.ccs.neu.edu/home/stchang/pubs/ckg-popl2017.pdf
In BuBBLE: A Lisp Dialect DSL Written in HaskellOr, you could go with Hackett, which is a Haskell-like language implemented in Racket: https://github.com/lexi-lambda/hackett
In Lisp and Haskell (2017)Showing the 15 most recent of 23 sources. Enable JavaScript to search and browse every indexed mention.