The Coalton Programming Language

->

Mon, 01 Jan 0001 00:00:00 +0000

Function type arrow.

coalton-toplevel

Mon, 01 Jan 0001 00:00:00 +0000

Top-level entry point for Coalton definitions.

Introduction and Getting Started

Mon, 01 Jan 0001 00:00:00 +0000

Coalton is a statically typed functional language embedded in Common Lisp. Since it’s embedded in Lisp, it uses the ordinary Common Lisp toolchain. Despite that, Coalton is a full-fledged programming language with an optimizing compiler.

Here, we assume you’ll adopt a standard Lisp development system, which uses Emacs and SLIME. These are not strictly necessary, and make the learning curve steeper, but improve the development experience substantially.

Install SBCL

Figure out a way to install SBCL on your platform. In the worst case, you can download binaries from the SBCL website. We highly recommend having a recent version of SBCL. If the binary available to you is old, then after installing it, compiling a new SBCL is very easy:

=>

Mon, 01 Jan 0001 00:00:00 +0000

Constraint arrow for qualified types and class contexts.

coalton

Mon, 01 Jan 0001 00:00:00 +0000

Expression-level entry point from Common Lisp.

Whirlwind Tour of Coalton

Mon, 01 Jan 0001 00:00:00 +0000

A broad, practical tour of Coalton's core language and workflow.

declare

Mon, 01 Jan 0001 00:00:00 +0000

Type declaration form.

forall

Mon, 01 Jan 0001 00:00:00 +0000

Explicit type-variable quantification.

*

Mon, 01 Jan 0001 00:00:00 +0000

Type-level separator for multiple inputs and outputs.

&key

Mon, 01 Jan 0001 00:00:00 +0000

Keyword-argument tail syntax.

define

Mon, 01 Jan 0001 00:00:00 +0000

Value and function definition form.

derive

Mon, 01 Jan 0001 00:00:00 +0000

Attribute for automatically generating type class instances.

=

Mon, 01 Jan 0001 00:00:00 +0000

Pattern binding operator.

Configuring Coalton

Mon, 01 Jan 0001 00:00:00 +0000

Configuration options for controlling the Coalton compiler.

define-type

Mon, 01 Jan 0001 00:00:00 +0000

Algebraic data type definition form.

define-exception

Mon, 01 Jan 0001 00:00:00 +0000

Exception type definition form.

define-resumption

Mon, 01 Jan 0001 00:00:00 +0000

Resumption definition form.

Debugging

Mon, 01 Jan 0001 00:00:00 +0000

Type inspection, specialization introspection, and code generation tools.

Macros

Mon, 01 Jan 0001 00:00:00 +0000

Defining Coalton expression macros, Coalton toplevel macros, and ordinary Lisp macros.

<-

Mon, 01 Jan 0001 00:00:00 +0000

Monadic bind syntax in `do` notation.

define-type-alias

Mon, 01 Jan 0001 00:00:00 +0000

Type alias definition form.

Lisp Interop

Mon, 01 Jan 0001 00:00:00 +0000

Interop guarantees and calling conventions between Coalton and Common Lisp.

_

Mon, 01 Jan 0001 00:00:00 +0000

Wildcard pattern.

define-struct

Mon, 01 Jan 0001 00:00:00 +0000

Struct definition form.

repr

Mon, 01 Jan 0001 00:00:00 +0000

Representation attribute for types and structs.

monomorphize

Mon, 01 Jan 0001 00:00:00 +0000

Monomorphization attribute for declarations and definitions.

define-expression-macro

Mon, 01 Jan 0001 00:00:00 +0000

Define a macro for Coalton expression context.

inline

Mon, 01 Jan 0001 00:00:00 +0000

Inlining attribute and application hint.

define-toplevel-macro

Mon, 01 Jan 0001 00:00:00 +0000

Define a macro for Coalton toplevel context.

defmacro

Mon, 01 Jan 0001 00:00:00 +0000

Compatibility alias for define-expression-macro.

define-class

Mon, 01 Jan 0001 00:00:00 +0000

Type class definition form.

noinline

Mon, 01 Jan 0001 00:00:00 +0000

Prevent a specific application from being inlined.

likely

Mon, 01 Jan 0001 00:00:00 +0000

Branch-likelihood hint for `Boolean` expressions.

define-instance

Mon, 01 Jan 0001 00:00:00 +0000

Type class instance definition form.

unlikely

Mon, 01 Jan 0001 00:00:00 +0000

Branch-likelihood hint for `Boolean` expressions.

specialize

Mon, 01 Jan 0001 00:00:00 +0000

the

Mon, 01 Jan 0001 00:00:00 +0000

Inline type annotation.

unsafe

Mon, 01 Jan 0001 00:00:00 +0000

Experimental escape hatch from runtime safety checks.

as

Mon, 01 Jan 0001 00:00:00 +0000

Total conversion shorthand.

try-as

Mon, 01 Jan 0001 00:00:00 +0000

Partial conversion shorthand.

unwrap-as

Mon, 01 Jan 0001 00:00:00 +0000

Unchecked conversion shorthand.

fn

Mon, 01 Jan 0001 00:00:00 +0000

Anonymous function form.

ƒ

Mon, 01 Jan 0001 00:00:00 +0000

Short fn syntax.

[]

Mon, 01 Jan 0001 00:00:00 +0000

Collection builder and collection comprehension syntax.

[=>]

Mon, 01 Jan 0001 00:00:00 +0000

Association builder and association comprehension syntax.

match

Mon, 01 Jan 0001 00:00:00 +0000

Pattern matching form.

dynamic-bind

Mon, 01 Jan 0001 00:00:00 +0000

Dynamically rebind one or more dynamic variables.

let

Mon, 01 Jan 0001 00:00:00 +0000

Recursive lexical binding form.

let*

Mon, 01 Jan 0001 00:00:00 +0000

Sequential lexical binding form.

rec

Mon, 01 Jan 0001 00:00:00 +0000

Named recursion form.

lisp

Mon, 01 Jan 0001 00:00:00 +0000

Inline Common Lisp form.

values

Mon, 01 Jan 0001 00:00:00 +0000

Multiple-values form.

if

Mon, 01 Jan 0001 00:00:00 +0000

Boolean conditional form.

when

Mon, 01 Jan 0001 00:00:00 +0000

Conditional sequencing form.

unless

Mon, 01 Jan 0001 00:00:00 +0000

Negated conditional sequencing form.

and

Mon, 01 Jan 0001 00:00:00 +0000

Short-circuiting conjunction.

or

Mon, 01 Jan 0001 00:00:00 +0000

Short-circuiting disjunction.

cond

Mon, 01 Jan 0001 00:00:00 +0000

Multi-branch conditional form.

progn

Mon, 01 Jan 0001 00:00:00 +0000

Flattened sequencing form.

.<

Mon, 01 Jan 0001 00:00:00 +0000

Right-associative composition macro.

do

Mon, 01 Jan 0001 00:00:00 +0000

Monadic sequencing form.

throw

Mon, 01 Jan 0001 00:00:00 +0000

Signal an exception.

catch

Mon, 01 Jan 0001 00:00:00 +0000

Exception handling expression.

return

Mon, 01 Jan 0001 00:00:00 +0000

Function return.

.>

Mon, 01 Jan 0001 00:00:00 +0000

Left-associative composition macro.

for

Mon, 01 Jan 0001 00:00:00 +0000

Imperative loop form.

resumable

Mon, 01 Jan 0001 00:00:00 +0000

Resumption handling expression.

resume-to

Mon, 01 Jan 0001 00:00:00 +0000

Transfer control to a resumption handler.

for*

Mon, 01 Jan 0001 00:00:00 +0000

Sequential imperative loop form.

break

Mon, 01 Jan 0001 00:00:00 +0000

Loop exit form.

continue

Mon, 01 Jan 0001 00:00:00 +0000

Loop-iteration skip form.

type-of

Mon, 01 Jan 0001 00:00:00 +0000

Inspect the inferred type of an expression.

kind-of

Mon, 01 Jan 0001 00:00:00 +0000

Inspect the kind of a Coalton type constructor.

describe-type-of

Mon, 01 Jan 0001 00:00:00 +0000

Print type information for a Coalton value.

pipe

Mon, 01 Jan 0001 00:00:00 +0000

Threading macro.

describe-type-alias

Mon, 01 Jan 0001 00:00:00 +0000

Print the definition behind a type alias.

nest

Mon, 01 Jan 0001 00:00:00 +0000

Nested application macro.

set-type-printing-mode

Mon, 01 Jan 0001 00:00:00 +0000

Control how Coalton prints types and aliases.

print-specializations

Mon, 01 Jan 0001 00:00:00 +0000

List registered Coalton function specializations.

coalton-codegen

Mon, 01 Jan 0001 00:00:00 +0000

Inspect generated Lisp for Coalton forms.

coalton-codegen-types

Mon, 01 Jan 0001 00:00:00 +0000

Inspect generated Lisp with host type declarations.

coalton-codegen-ast

Mon, 01 Jan 0001 00:00:00 +0000

Dump the Coalton AST for generated forms.

pprint-coalton-codegen

Mon, 01 Jan 0001 00:00:00 +0000

Pretty-print generated Lisp for Coalton forms.

pprint-coalton-codegen-types

Mon, 01 Jan 0001 00:00:00 +0000

Pretty-print typed generated Lisp.

pprint-coalton-codegen-ast

Mon, 01 Jan 0001 00:00:00 +0000

Pretty-print AST inspection output.

Introducing mine, a Coalton and Common Lisp IDE

Fri, 24 Apr 2026 00:00:00 +0000

By Robert Smith

mine is a brand new IDE for Coalton and Common Lisp, built from the ground up with one purpose: To make Coalton and Common Lisp easier and more accessible to the programming world.

TL;DR? Go to mine's homepage with downloads for Windows/macOS/Linux.

mine is a complete, single-download application that comes with everything needed to experience the interactive and incremental development programming workflow, including hot-reloading and on-the-fly debugging, that Lisp programmers often refer to as the differentiating feature of the ecosystem. After installing, one can immediately open a file, program some Coalton or Lisp, and beam code to the REPL. On the same token, it has many of the advanced features you’d expect in a professional IDE:

A Preview of Coalton 0.2

Thu, 12 Mar 2026 00:00:00 +0000

By Robert Smith

Coalton is a statically typed functional programming language that lives inside Common Lisp. It has had an exciting few years. It is being used for industrial purposes, being put to its limits as a production language to build good, reliable, efficient, and robust products. Happily, with Coalton, many products shipped with tremendous success. But as we built these products, we noticed gaps in the language. As such, we’re setting the stage for the next tranche of Coalton work, and we’re going to preview some of these improvements here, including how Coalton can prove $\sqrt{2+\sqrt{3}} = \sqrt{2}(\sqrt{3}+1)/2$ exactly.

Using Common Lisp Libraries from Coalton

Tue, 12 Aug 2025 00:00:00 +0000

By Robert Smith

We discuss how we can make an efficient, type-safe interface to existing libraries written in Common Lisp so that they can be used in Coalton code.

One of Coalton’s headline features is that it’s embedded in Common Lisp, and allows the use of Common Lisp code via the lisp operator. However, it’s not immediately obvious how one can use Common Lisp when Coalton is strongly typed. How do we do it?

Using Coalton to Implement a Quantum Compiler

Tue, 06 Sep 2022 00:00:00 +0000

By Elias Lawson-Fox, Aidan Nyquist, and Robert Smith

Updated July 1, 2025 by Robert Smith.

Introduction: Coalton and the quilc compiler

Quilc is a state-of-the-art optimizing compiler for quantum computers written in Common Lisp. It is capable of taking arbitrary quantum programs written in Quil, and compiling and optimizing them into code that conforms to the majority of quantum computing architectures that exist today.

Numbers in a Nutshell, an Update

Sat, 27 Aug 2022 00:00:00 +0000

By Robert Smith

We discuss numbers and math in Coalton, as they are so far. Coalton is under active development, so this blog post may go out of date in due time.

Introduction

Coalton is statically typed, which presents some challenges in how we work with numbers, both syntactically and semantically. For instance, consider the following Common Lisp code:

One Reason Typeclasses Are Useful

Sun, 12 Dec 2021 00:00:00 +0000

By Robert Smith

In this post, we explore one way that typeclasses are useful. We do so by first painting ourselves into a corner while building a toy Common Lisp program, and then seeing how Coalton’s typeclasses can ameliorate the issues.

A Graphics Library

Let’s write a graphics library. Or, a tad less ambitiously, let’s write some routines for performing transformations on 2D points, which might serve as the foundation of a graphics library. We’ll be interested in:

AoC 2021 Coalton Contest

Mon, 29 Nov 2021 00:00:00 +0000

By Robert Smith

Update: The prizes have been matched 1:1 by a donor who wishes to remain anonymous!

Introduction

Last September we announced Coalton, a statically typed language that is “just” another Common Lisp DSL. To our great surprise, there was a lot of excitement and fanfare, which made the development team feel quite honored and proud. It even made the top of Hacker News!

Unsurprisingly, as is the case with many open-source projects, that fanfare lead to little “conversion”; only a few people actually gave Coalton a shot and provided feedback. We are immensely thankful to those who did! The good news is that it lead to some good discussion, great PRs, and fantastic internship applications from a wonderful and diverse group of people. We won’t be able to accept everyone but I’m pleased that there’s interest in helping build out the next generation of quantum computational tools using “alien technology”. :)

Introducing Coalton: How to Have Our (Typed) Cake and (Safely) Eat It Too, in Common Lisp

Fri, 10 Sep 2021 00:00:00 +0000

By Robert Smith, Elias Lawson-Fox, Cole Scott

Updated July 1, 2025 by Robert Smith.

Introduction

Coalton is a statically typed functional programming language built with Common Lisp. We can load it like a normal Lisp library.

CL-USER> (asdf:load-system "coalton")
CL-USER> (in-package #:coalton-user)
COALTON-USER>

This is Coalton computing Fibonacci numbers by exponentiating functions (not numbers!):

(coalton-toplevel
  (declare function-power (Integer -> (:t -> :t) -> (:t -> :t)))
  (define (function-power n f)
    (if (<= n 0)
        id
        (compose f (function-power (1- n) f))))
                
  (declare fib-step ((Tuple Integer Integer) -> (Tuple Integer Integer)))
  (define (fib-step (Tuple a b))
    (Tuple b (+ a b)))
                
  (declare fib (Integer -> Integer))
  (define (fib n)
    (fst ((function-power n fib-step) (Tuple 0 1)))))

This is Coalton greeting you by making native use of Common Lisp functions:

Mon, 01 Jan 0001 00:00:00 +0000

The Coalton standard library reference.

About

Mon, 01 Jan 0001 00:00:00 +0000

Coalton is a statically typed, strictly evaluated functional programming language embedded in Common Lisp. It is an open-source project developed by the Coalton Lang developers.

Coalton developers can be reached on GitHub, via Discord, or via email at:

<this-project>@protonmail.com

where <this-project> starts with a c and ends with an n.