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, 4:59:52 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

23 sources
Agree that you can use types to express and prove logical properties via compiler; it can be a fun way to solve a problem though too much of it tends to frustrate coworkers in JavaLand. It's also not exactly "low cost"; here's an old quip I have in my quotes file: "With Scala you feel smart having just got something to work in a beautiful way but when you look around the room to tell your clojure colleague how clever you are, you notice he left 3 hours ago and there is a post-it saying use a Map." --Daniel Worthington-Bodart > On the contrary, they're still the most effective technique we've found for improving program correctness at low cost. This is not borne out by research, such as there is any of any quality: https://danluu.com/empirical-pl/ The best intervention to improve correctness, if not already being done, is code review: http
Read the rest
s://twitter.com/hillelogram/status/1120495752969641986 This doesn't necessarily mean dynamic types are better, just that if static types are better, they aren't tremendously so to obviously show in studies, unlike code review benefit studies. My own bias is in favor of dynamic types, though I think the way Common Lisp does it is a lot better than Python (plus Lisp is flexible enough in other ways to let static type enthusiasts have their cake and eat it too https://github.com/coalton-lang/coalton), and Python better than PHP, and PHP better than JS. And I prefer Java to PHP and JS. Just like not all static type systems are C, not all dynamic type systems are JS. Untyped langs like assembly or Forth are interesting but I don't have enough experience. I don't find the argument that valuable though, since I think just focusing on dynamic vs static is one of the least interesting division points when comparing languages or practices, and may be a matter of preferred style, like baseball pitching, more than anything. If we're trading experience takes I think Clojure's immutable-by-default prevents more bugs than any statically typed language that is mutable by default; that is, default mutable or default immutable (and this goes for collections too) is a much more important property than static types or dynamic types. It's not exactly a low cost intervention though, and when you really need to optimize you'll be encouraged by the profiler to replace some things with Java native arrays and so on. I don't think changing to static types would make a quality difference (especially when things like spec exist to get many of the same or more benefits) and would also not be a low cost intervention. Some domains also demand tools beyond type proofs. i.e. things like TLA+. I think adding static types on top of that isn't very valuable, similar to adding static types on top of immutable-by-default isn't very valuable. Last quip to reflect on. "What's true of every bug found in the field? ... It passed the type checker. ... It passed all the tests. Okay. So now what do you do? Right? I think we're in this world I'd like to call guardrail programming. Right? It's really sad. We're like: I can make change because I have tests. Who does that? Who drives their car around banging against the guardrail saying, "Whoa! I'm glad I've got these guardrails because I'd never make it to the show on time."" --Rich Hickey (https://www.infoq.com/presentations/Simple-Made-Easy/)
In Griffin – A fully-regulated, API-driven bank, with Clojure
> Lisps can be very flexible, but they usually lack static type safety, opening a wide and horrible door to run-time errors. People should do basic research before writing something silly like this. Qualifying your statement with 'usually' is just a chicken sh*t approach. Common Lisp and Racket have optional strong typing, leaving the responsibility and choice to the developer. Common Lisp is great for implementing compilers. You also have things like Typed Racket and Coalton. The latter is completely statically typed ala MLTON https://github.com/coalton-lang/coalton
In Compiler Development: Rust or OCaml?
I don't agree. One can write a serious, syntactically bullet-proof grammar for a language built out of S-expressions, with nice error messages and all. We can imagine a parallel universe in which TFA's Postgres example were written using S-expressions: <alter> := (ALTER-TABLE (:IF-EXISTS? :ONLY?) <symbol> :*? <action>+) | ... <action> := ... Despite using S-expressions, this is parseable with as much rigor as more free-form character syntax. I think Coalton [1] is a good example of this. The language is embedded as S-expressions in Common Lisp, but you get Rust-like error messages, showing exact source lines (with line numbers) and embedded underlines showing the location of the offending code. With that said, what is true is that if you're using Common-Lisp-style macros and you're manipulating S-expressions programm
Read the rest
atically, lexical information may get thrown out. This is not unlike doing a bunch of string manipulation in an ORM to generate SQL, which will have similarly poor error messages. [1] https://github.com/coalton-lang/coalton
In Why Lisp Syntax Works
Hindley-Milner has the very standard and well-known problem with polymorphic mutation [1]. There is no issue with setting an array of floats or something like that. It's only when you assign a polymorphic value cell with one type, then subsequently with another type. This is not unique to Coalton. Any HM-based language that defines mutation primitives has it, including Haskell and OCaml. These languages don't "solve" it a sense most people think, instead they provide some sort of restriction or workaround to the HM theory to make mutation constructs feasible. There's a huge space of possible solutions, including ensuring functional purity with monads (Haskell) to using weak polymorphism (OCaml) to using Wright's value restriction (eliminate invalid mutations, but also eliminate tons of reasonable, valid programs). Coalton developers know
Read the rest
of the HM deficiency and described it very well here [2]. It looks like they're building out more important parts of the language that affect their users more seriously (e.g., adding records) before making a hugely consequential design decision around mutation, which people don't seem to bump into much. It doesn't seem to have stopped them from building interesting software in the slightest. [3] [1] https://en.wikipedia.org/wiki/Value_restriction#A_Counter_Ex... [2] https://github.com/coalton-lang/coalton/issues/84 [3] https://coalton-lang.github.io/20220906-quantum-compiler/
In Successful Lisp: How to Understand and Use Common Lisp (1999)
> static strong typing Alright, here is it: https://github.com/coalton-lang/coalton/ > small efficient native binaries The numbers are: with SBCL's core-compression, a web app with dozens on dependencies will weight ±30 to 40MB. This includes the compiler, the debugger, etc. Without core compression, we reach ±150MB. > The actor runtime? the actor library: https://github.com/mdbergmann/cl-gserver > couldn't find a way to make money with it. I suspect many other programmers are in my boat. Alright. Some do, that's life. Yes, some companies go with CL even in 2023 (https://lisp-journey.gitlab.io/blog/lisp-interview-kina/, they released https://github.com/KinaKnowledge/juno-lang lately; Feetr (finance): https://twitter.com/feetr_io/status/1587182923911991303) https://github.com/azzamsa/awesome-lisp-companies/ > Give us an HTTP (1.x & 2.0) an
Read the rest
d WebSockets libraries How so? We have those libraries. HTTP/2: https://github.com/zellerin/http2/ https://github.com/CodyReichert/awesome-cl
In Why Lisp?
1. There are functional dependencies and multi-parameter type classes. No GADTs (yet?) or existential types (yet?). 2. Records are being implemented but it's far from being a dealbreaker, in the sense that thousands of production lines of Coalton have been built without needing them. It's just not ergonomic to shuffle around and pattern match against record-like data. With pattern matching in function arguments, things are at least easier. 3. All Coalton functions compile to Lisp functions. There's a guide that describes what is promised about interop (https://github.com/coalton-lang/coalton/blob/main/docs/coalt...). 4. Since Coalton functions are Lisp functions, you can call (unconstrained) functions directly. However there's a lot of room for improvement. There's an open issue to make a dedicated Coalton REPL that can show types and not
Read the rest
require COALTON to be typed. 5. Coalton is developed as an open source project to build tools at HRL Laboratories, so it does receive sponsorship. Yes, HRL is hiring. Feel free to send me an email to the address in my profile. As seems to be the case with any "serious" programming language, there's always another thing to do—seemingly perpetually—to make said language useful enough for "serious" use. :)
In My thoughts on OCaml
Coalton [1] is an OCaml-like dialect of ML: it's strictly evaluated, has imperative features, and doesn't force a purity-based development philosophy. However, Coalton has S-expression syntax and integrates into Common Lisp. It works, and is used "in production" by its developers, but it's still being developed into a 1.0 product. Coalton made a lot of design decisions to work away from issues that this post describes. - Coalton dispensed with ML's module system of structures, signatures, and functors. No doubt a beautiful concept, and sometimes satisfying to write, but almost always unsatisfying to use due to how explicit one tends to need to be. Like the author suggests, the "interface-style" of type classes or traits has always felt more intuitive, despite losing the ability to have multiple implementations of an interface for a single
Read the rest
type. (However, I've come to appreciate that different interfaces should require different types—as opposed to one type having many interfaces.) Coalton uses type classes. - Coalton has S-expression syntax. No indent rules. No precedence rules. No expression delimiters. All of the "tradition" of ML syntax is dispensed with into something that is a lot easier to read and write for complex programs... yes, provided you use ParEdit or similar - It should be no surprise that with S-expressions, you get Lisp-style macros. Macros in Coalton are just Common Lisp macros. No separate pre-processors. No additional language semantics to deal with. Arbitrary compile-time computation and/or codegen, completely integrated. - Because it's built on Common Lisp, Coalton gets something few (if any?) other ML-derivatives get: Truly incremental and interactive development. You can re-compile types, functions, etc. and try them out immediately. There's no separate "interpreter mode"; just a Lisp REPL. Coalton's language features are still settling (e.g., records are being implemented) and the standard library [2] is still evolving. However, it's been used for "serious" applications, like implementing a compiler module for quantum programs [3]. [1] https://github.com/coalton-lang/coalton [2] https://coalton-lang.github.io/reference/ [3] https://coalton-lang.github.io/20220906-quantum-compiler/
In My thoughts on OCaml

Showing the 15 most recent of 23 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.