A functional language
that ships 51 KB.

The language

A small language, read in an afternoon. What follows is most of the syntax; traits, records, machines and a few conveniences are the rest, and the reference has all of it, chapter by chapter, with the programs that show each construct.

Data, and taking it apart

A type is a list of the shapes a value can have. match tests the shape and binds the pieces in one step, and the compiler checks that you covered every case.

type Shape
  Circle(r: Float)
  Rect(w: Float, h: Float)

fn area(s) = match s
  Circle(r) -> 3.14159 * r * r
  Rect(w, h) -> w * h

fn main() =
  shapes = Cons(Circle(1.0), Cons(Rect(2.0, 3.0), Nil))
  println(sum(map(shapes, area)))

$ rill run shapes.rill
9.14159

Leave out a case and the program does not compile — and the compiler names the one you forgot:

colour.rill: type error at line 6: match is not exhaustive; no arm matches `Blue`

fn sum_to(n) = go(n, 0)

fn go(i, acc) =
  if i == 0 then acc
  else go(i - 1, acc + i)

go(20000000, 0) → 1.3 MB resident

range(1, 10)
  |> filter(\x -> x % 2 == 0)
  |> map(\x -> x * x)
  |> sum

220

Concurrency: strands

Many lightweight threads over typed channels, taken from Go. One of them is a strand — a strand of a rope, of which a program is many. A hundred thousand of them cost about 65 MB and start in microseconds; with --parallel they spread across cores, and the compiler refuses a program in which two of them could write the same storage.

fn worker(jobs, results) =
  n = recv(jobs)
  send(results, n * n)
  worker(jobs, results)          # a loop that never ends

fn main() =
  jobs = channel()
  results = channel()
  spawn worker(jobs, results)
  send(jobs, 7)
  println(recv(results))

49

No collector

The compiler works out where each value's last use is and inserts the release there, following ownership rules. Nothing runs periodically; a value is freed at the instruction after it dies, and a box that dies where a new one is made is reused in place. A reference ring — the one thing counting cannot free — is refused at compile time, where it is written. Set one variable and the runtime tells you what was still alive at exit:

$ RILL_DEBUG_ALLOC=1 ./program
100000
live allocations: 0

Models

A machine is a process in the sense the telephone exchanges gave the word — a state machine with a mailbox, one strand, one signal at a time — and a system is the block diagram between the kinds of machine and the environment, which the compiler checks against the code.

system exchange
  env -> line: OffHook, Digit, OnHook, Answer, Report
  line -> env: Status
  line <-> line: Ring, Answer, OnHook

machine line(me: Chan(Mail(Signal)), log: Chan(Str))
  state Idle
    OffHook -> Dialling(Nil)
    Ring -> Ringing(sender)
  state Dialling(digits)
    Digit(n) if n >= 0 -> Dialling(Cons(n, digits))
    after 50 ->
      send(log, "gave up dialling")
      Idle
  state Ringing(caller)
    Answer ->
      output(caller, Answer)
      Talking(caller)

Timers, save, priority, procedures with states of their own, and a signal no arm names is consumed and the state kept — the rules SDL had. A run traced with RILL_TRACE=1 is a sequence chart (rill msc); on the virtual clock a night of retransmissions takes no time; rill diagram draws the system and each machine in SDL's own symbols; and a signal a machine sends that no route carries is a compile error naming both.

The editor at rillsdl.baltavista.com draws all of this in the browser: click a state or an input to build it in a form, run a scenario and watch the chart grow while the machines light the state they are in. The code stays the model — every edit is written back through the formatter — and the programs run in the compiler's sandbox, so try anything.

What you get

Numbers

Rill 0.13.0 on an Apple M4, 16 September 2026; Go 1.23, OCaml 5.5; outputs verified identical across the languages, time the median of 25 runs. Reproduce with python3 benchmarks/run.py.

Four microbenchmarks are not a workload. The first row is really “both of these are LLVM-quality code generation”; the rows that carry information are the third, where the concurrency implementation differs by five times, and the second, where a compiler inserting frees beats two mature garbage collectors on time and memory. Against C (measured 13 September, before this release) — twenty programs, each written once in Rill and once in C to the same algorithm and layout — Rill wins eleven, is within run-to-run noise on nine, and is behind on none; on disk and sockets it is ahead of Go on the four stream programs and within a few percent on the round trips, which are the kernel's. Eight independent computations on eight strands scale 1.0× · 1.9× · 3.1× on one, two and four workers. The reasons, step by step, are in benchmarks/.

What it does not have

Some of these are choices and some are a version number. Both are listed.

• MutationChosen. No assignment, no mutable fields — a record is updated by making a new one, { p | x = 1 }. The exceptions are storage: Buf, Map and a string builder, for C and for hot tables.
• A garbage collectorChosen. Reference counting decided at compile time; a ring of references is refused where it is written, since counting could not free it.
• Exceptions and nullChosen. Result and Option instead, with ? to pass a failure up.
• LazinessChosen. Strict evaluation, so allocation appears where you wrote it.
• Higher-kinded typesVersion number. A trait is over a type, not over a container of types; map is a function on lists, not a method of a functor.
• Strings indexed by characterChosen. A string is bytes and #s counts them; the char_ functions and the text library walk it by code point when that is the question.
• A second implementationVersion number. The compiler compiles itself, but there is one of it, no package manager, and nobody else has hit your bug.

Rill is version 0.13. It is a good language to learn these ideas in and a good one to model a protocol in; whether it is one to run a business on is a question this page would rather leave open than answer for you.

What's changed

0.13.0 — the model editor. The release where the models got an editor in the browser, with its server written in Rill on the standard library. The page shows a file's system as the block diagram, channels routed as SDL drew them, and each machine as a process in SDL's symbols, beside its coloured code, every symbol a click from its line.

Since then:

• examples that are tests, on every function of the library
• the editor moves out
• packaged
• a sandbox
• the diagrams build without the code being written

Made with Rill

Programs that are not benchmarks, written in Rill and nothing else.

The book

Download

Rill 0.13.0, packaged: the compiler, the runtimes, the standard library, the examples and the reference, in one directory. Needs a C linker on the PATH — the Xcode command-line tools on a Mac, gcc or clang on Linux — and nothing else.

curl -O https://rill.baltavista.com/dl/rill-0.13.0-macos-arm64.tar.gz
tar xzf rill-0.13.0-macos-arm64.tar.gz
rill/bin/rill run rill/examples/hello.rill        # hello, world

Checksums in SHA256SUMS. The wasm target needs wasm-ld, which comes with LLVM.

The commands

rill run   program.rill        # compile to a temporary binary and run
rill build program.rill -o p   # keep the binary; --parallel, --sandbox, --target wasm32-wasip1
rill test  program.rill        # every test_ function, each in its own process
rill check program.rill        # type-check only, saying everything it finds
rill fmt   program.rill        # canonical formatting
rill doc   lib -o docs         # Markdown from the comments the modules already have
rill diagram exchange.rill     # the system and the machines, drawn
rill repl                      # definitions persist for the session

The runtime is no_std and links as a static library, which is most of why the binaries are the size they are.