HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
coalton-lang
coalton
Common Lisp2021–2026
coalton-lang / coalton

coalton

Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.

32Distinct people
72Mentions
1Explicit recommenders
1.8KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

Coalton seems great, I love the idea. This issue seems problematic, though: https://github.com/coalton-lang/coalton/issues/84

dunefox 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

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 9–Nov 16 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/16/2026, 5:58:53 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 year72 dated mentions

Observed mentions: 2021-10-27 01:30:41 UTC to 2026-07-10 17:19:00 UTC.

05101520252021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 5 mentions; 1 submissions, 4 comments20212022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 18 mentions; 3 submissions, 15 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 23 mentions; 1 submissions, 22 comments20232024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 12 mentions; 1 submissions, 11 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 10 mentions; 0 submissions, 10 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 4 mentions; 1 submissions, 3 comments. Incomplete calendar period.2026*

* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC514
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC18315
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC23122
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC12111
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC10010
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC413

From the project README

An excerpt from the repository, fetched Nov 13, 2026.

Read the project’s introduction
Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp. Coalton integrates directly into Common Lisp: (defpackage #:differentiation (:use #:coalton #:coalton-prelude) (:local-nicknames (#:sym #:coalton/symbol)) (:export #:Expr #:EConst #:EVar #:E+ #:E*) (:export #:diff #:t #:d/dt)) (in-package #:differentiation) (named-readtables:in-readtable coalton:coalton) (coalton-toplevel ;; Define a new parametric algebraic data type for simple ;; mathematical expressions. (define-type (Expr :t) "A symbolic expression of basic arithmetic." (EConst :t) (EVar sym:Symbol) (E+ (Expr :t) (Expr :t)) (E* (Expr :t) (Expr :t))) ;; The classic `diff` function, in Coalton. (declare diff (Num :t => sym:Symbol * Expr :t -> Expr :t)) (define (diff x f) "Compute the derivative of `f` with respect to `x`." (match f ((EConst _) ; c' = 0 (EConst 0)) ((EVar s) ; x' = 1 (if (== s x) (EConst 1) (EConst 0))) ((E+ a b) ; (a+b)' = a' + b' (E+ (diff x a) (diff x b))) ((E* a b) ; (ab)' = a'b + ab' (E+ (E* (diff x a) b) (E* a (diff x b)))))) ;; We can use `t` just fine since Coalton doesn't import `cl:t`. (define t (sym:make-symbol "t")) (declare d/dt (Num :t => Expr :t -> Expr :t)) (define (d/dt f) "The time derivative operator." (diff t f))) It also works directly in the REPL: CL-USER> (in-package #:differentiation) DIFFERENTIATION> (coalton-toplevel (define (square x) (E* x x))) ;; SQUARE :: ∀ A. ((EXPR A) → (EXPR A)) DIFFERENTIATION> (coalton (d/dt (E+ (square (EVar t)) (EConst 1)))) #.(E+ #.(E+ #.(E* #.(ECONST 1) #.(EVAR |t|)) #.(E* #.(EVAR |t|) #.(ECONST 1))) #.(ECONST 0)) Type errors are discovered at compile-time, and errors are printed beautifully without sacrificing Common Lisp's interactive debugging facilities. DIFFERENTIATION> (coalton (d/dt (E+ (EConst 1/2) (EConst 0.5)))) error: Type mismatch --> repl:1:32 | 1 | (coalton (d/dt (E+ (EConst 1/2) (EConst 0.5)))) | ^^^^^^^^^^^^ Expected type '(EXPR FRACTION)' but got '(EXPR F32)' Coalton is currently used in production to build defense and quantum computing software. Getting Started WarningCoalton has not reached "1.0" yet. This means that, from time to time, you may have a substandard user experience. While we try to be ANSI-conforming, Coalton is currently only tested on recent versions of SBCL, Allegro CL, and Clozure CL. The version of Coalton that may be in Quicklisp may not be up-to-date. Prepare: Install SBCL (on macOS with Homebrew: brew install sbcl). Install Quicklisp by following instructions here. (The step command involving gpg is not needed.) After installing Quicklisp, you should have a quicklisp folder which will make installing Coalton easier. Install: Clone this repository into a place your Lisp can see (e.g., ~/quicklisp/local-projects/). Use: Either run (ql:quickload :coalton), or add #:coalton to your ASD's :depends-on list. Test: Compile the tests with (ql:quickload :coalton/tests), then run the tests with (asdf:test-system :coalton). NoteRunning the Coalton test suite on SBCL requires GNU MPFR in order to run Big-Float tests. If you would like to run tests without installing gnu-mpfr, you can use Coalton's portable Big-Float implementation by running (pushnew :coalton-portable-bigfloat *features*) before loading Coalton. Learn: Start with Whirlwind Tour of Coalton, the language manual, and the standard library reference, and then take a peek at the examples directory. It may also be helpful to check out the introductory blog post. Open Source Community: Awesome Coalton has a list of community-built libraries, applications, and examples, that you can use in your own projects or as examples to learn from. What's Here? This repository contains the source code to the Coalton compiler, and the standard library. It also contains two optional libraries, which are not loaded by default: coalton/xmath, for extended mathematics, and coalton/threads, for threads, synchronization, and parallel computation (SBCL only). It also contains a few example programs, such as: Some simple pedagogical programs, An implementation of Jones's Typing Haskell in Haskell, and An implementation of a simple Quil parser using parser combinators. Lastly and importantly, we maintain a collection of documentation about Coalton in the docs directory. Get Involved Want to ask a question about Coalton, propose a feature, or share a cool program you wrote? Try posting in the GitHub Discussions page! We welcome contributions of all forms, especially as we stabilize toward a 1.0 release. We would be grateful to receive: bug reports (filed as issues), bug fixes and typo corrections (filed as pull requests), small example programs, and user experience troubles.
Read the full README on GitHub

What Hacker News says

18 sources
I can agree it's not the same, but what's the point? A more interesting disagreement is that I wouldn't say it's a downside (though yes, there are tradeoffs). Especially in Current Year when open source is fashionable and pretty much every language has a package manager to make pulling in or swapping out dependencies pretty easy, I don't see the issue. It's also interesting to note that of all the things Clojure did to "fix" shortcomings of past languages with a more opinionated (and often more correct I'll admit) design philosophy that users are forced to use (even when it's not more correct), infix-math-out-of-the-box wasn't one of them. I don't think that specifically really hurt Clojure adoption. (But of course Clojure is reasonably extensible too so it also has a library to get the functionality, though it's more fragile especially a
Read the rest
round needing spaces because it's not done with reader macros.) I've brought the library up many times because CL, unlike so many other languages, really lets you extend it. Want a static type system? https://github.com/coalton-lang/coalton/ Want pattern matching? No need to wait for PEP 636, https://github.com/guicho271828/trivia/ If all that keeps someone from trying CL, or from enjoying it as much as they could because of some frustration or another, due to lacking <insert feature here> out of the box, chances are it is available through a library. (Or heck, even just tooling setup. Tab completion for symbols and jumping to function definitions are just two great things modern programmers enjoy in all sorts of languages, CL too, if someone doesn't have that setup I wonder if they must enjoy pain.)
In From Common Lisp to Julia
> "something like C" SBCL? Or ECL (compiles to C), CLASP (C++, LLVM)? The older ThinLisp? (compiles a subset of CL to C) https://github.com/ska80/thinlisp The very new NPT, a CL implementation in C? https://github.com/nptcl > Static typing for ahead-of-time more-correct programs the Coalton library. A ML/Haskell as a CL library. https://github.com/coalton-lang/coalton/ > Static typing for faster or leaner programs SBCL > WebAssembly Common Lisp running natively over WebAssembly: https://news.ycombinator.com/item?id=31590819 (very much POC) I know, I know, but he didn't mention any of these in the blog post, nor any CL project. Justice is done.
In Guile Steel: a proposal for a systems Lisp
Not so easy question, especially because it depends of the implementation, but SBCL gives pretty good static type errors and warnings. Mostly, you get warnings at the function boundaries. It isn't complete like type checking in the modern languages, but it helps catch many errors. And quickly & interactively, because we compile our functions as we write them, with a keystroke (or the whole file, and from time to time, we build the whole project from scratch). So, coming from Python, that was superbly useful to me. This, everybody uses it. We can also add gradual typing to our variables and functions. It might help for the static checks, and it also gives hints for the compiler to speed things up. We can also declare our own types, but these won't be used for compile-time inference. For a type-racket equivalent, we now have Coalton, it's l
Read the rest
ike a Haskell on top of CL: https://github.com/coalton-lang/coalton/ Its author says: -- Take this with a grain of salt, because I’m neither a user nor expert of Typed Racket, but: Typed Racket focuses more on the gradual typing of a given program. It has lots of features to make that easier, such as occurrence typing. Coalton is a separate, embedded language. Typed Racket achieves polymorphism through subtyping and and first-order type variables. Coalton achieves polymorphism through type variables, higher-kinded types, and type classes. Coalton, like ML and Haskell, focuses on defining objects by their properties and supported functions. This is a proposed way of having modular, reusable code. Typed Racket, as far as I can tell, has no such features. Coalton code can be fully inferred, so type annotations are not necessary. Typed Racket cannot. All in all, I think the biggest and most important take-away is that Typed Racket goes through great effort to seamlessly blend with ordinary Racket. But that means Typed Racket has to compromise on type system features that can only be supported if you’re willing to change the language itself. Coalton puts the type system first, opting for something close to Haskell, at the expense of not being a system for gradually typing Common Lisp, and instead being a separate language altogether. --- They use it for their open-source quantum compiler and other things.
In Why Hy?
What's the process look like for Python these days, after you install Python itself (or are made aware of the system Python if there is one)? IDLE was pretty bad back in the day and even though it was 'easy' I wouldn't have recommended it to newcomers. Assuming you can convince people to give emacs a try (shouldn't be hard if they're convinced to give Lisp a try and otherwise don't have preexisting biases against emacs for other reasons), getting setup for Lisp is as easy as installing Portacle (https://portacle.github.io/). It and any decent Lisp setup includes things like a hotkey to autocomplete, so you just type 'typ' and tab or whatever, and out pops suggestions like 'type', 'typep', 'type-of', ... and so you don't have to remember spelling; similarly they all should have some sort of intellisense to minimize trips to the CLHS or jum
Read the rest
ps to source code. I'm a vim head (which is why I don't know what newbie setups are like anymore apart from doing it in vim) but even when I type "(getf " I'm shown at the bottom "(getf PLACE INDICATOR &OPTIONAL (DEFAULT NIL))". If that's not enough, I can jump to source with "ctrl+]" (really nice being able to jump to the Lisp implementation's source for built-ins too without having to do anything special -- can even modify it live by adding print statements or whatever I want), or typing ",s" to get the symbol's describe output (I mainly like it for getting the docstring -- if memory serves though Portacle gives you the docstring with the lambda list in an intellisense popup automatically, like a Java IDE), and if I really need to ",h" opens a browser tab to the hyperspec page on that symbol. If Portacle isn't one's cup of tea, it becomes a bit harder, but I don't think it's "orders of magnitude" harder... Compared to setting up a local (L|W)AMP environment back in the mid-late 2000s, which tons of teens learning PHP did, it's a piece of cake. You install a Lisp implementation (like SBCL -- http://www.sbcl.org/platform-table.html if your distro doesn't package it/have a recent version), configure it to use Quicklisp (a couple commands -- https://www.quicklisp.org/beta/), and consult the CL Cookbook for further basic steps on setting up the best environment you can for a variety of editors (https://lispcookbook.github.io/cl-cookbook/editor-support.ht... -- emacs, vim, VS Code, Atom, Sublime...). For scaling, CL has scaled to multi-million lines of code projects, it scales fine. If you want more sophisticated type checking, there have been solutions over time, but in case you missed the latest and greatest take on it: https://github.com/coalton-lang/coalton
In New blog about my journey to develop a Common Lisp 3D software
I have been using Common Lisp professionally for over a decade. Largest codebase was probably ~100k lines for an embedded optical fingerprint analysis and booking system for US law enforcement agencies. The largest Lisp team I've worked on was about 30 people for satcom hardware. Every time I've described to people on the internet what makes Lisp nice, I've been met with a riposte that such aspects aren't unique to Lisp—be them interactive/incremental development, macros, efficient machine code, editor integration, whatever—or that a laundry list of features means nothing and instead Lisp's value should somehow be proven through its (hitherto comparatively dismal) popularity with employers and software engineers. I myself have definitely given up on an academic approach to proselytizing the language, and instead have just focused my energ
Read the rest
y in building applications and libraries people (especially employers) find useful, at smaller cost and in shorter time than other people are able to provide. It's like classical music. I can't convince you such music is incredibly rich and pleasant, especially not by talking about the harmonic theory of common practice. Instead, you just have to listen and agree or disagree, I think. And Lisp certainly has no secrets; it's old as can be and extraordinarily and thoroughly documented. Countless people (myself included) have spilled ink on the (alleged) virtues of Lisp. It's all out there. When it comes down to it, it's an incredibly flexible language useful for prototyping and rapid development, while at the same time supporting everything you need to transform your application into a rock solid, robust, static binary. All of Lisp's features balance in such a way that developer time and energy are prioritized and consequently optimized. P.S., Like a sibling comment mentioned, you can have Haskell-level static typing in Common Lisp with Coalton: https://github.com/coalton-lang/coalton
In Using SBCL Common Lisp as a Dynamic Library
Common lisp can be and has been successfully used for high-performance numerics[0] as well as low-level system code[1], all while being a high-level, garbage-collected language. (The latter property likely leading to better overall performance in large programs.) Verification may be interesting, for high-assurance (e.g. automotive/aerospace) applications. It's for this reason that a theorem prover[2] and an ml[3] have been implemented, and they interoperate freely with the rest of common lisp. In other words: we are already where you want to be, and we are even less stratified than you propose we would need to be. 0. https://github.com/marcoheisig/Petalisp 1. https://github.com/froggey/mezzano/ 2. https://www.cs.utexas.edu/users/moore/acl2/ 3. https://github.com/coalton-lang/coalton
In TypeScript as fast as Rust: TypeScript++

Showing the 15 most recent of 18 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.