Skip to content
An experimental, small, readable lisp with thorough unit tests and extensible functions/macros.
C++ Other
Find file
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.
alternatives/lite 3438
literate 3451 3100 3426 - clear trace analysis cruft 3137 3445 3438 3438
004optional_parens 3452 3437 - cleanup 3064 - macros for checking warnings 3138 3138
006infix 2358 3225 3224 - bugfix: prefix negation without spaces 3287 3145
010memory 3418 3284 - optimize false like other common syms 3218 - 40% speed boost 3142 3291 - macroexpand now working reliably 3291 - macroexpand now working reliably 3138 3139 - bugfix in gc tests
015$ 3054
015$ 2847 - The great rename of 2013 3445 3218 - 40% speed boost 3426 - clear trace analysis cruft 3426 - clear trace analysis cruft
021keyword_args 2291 3343 3284 - optimize false like other common syms 3317 - two bugs in sort 3139 - bugfix in gc tests 3284 - optimize false like other common syms 3283 - predicates return false, comparisons short-circuit false 3288 3288 3142 3138 3426 - clear trace analysis cruft 3138 3404 - undo 3401
040.test 3305 - all progress messages are now consistently in
041test.test 3277
041test.wart 3408
042fn.test 3282 - experiment: a new false sym
042fn.wart 3295
043list.test 2595
043list.wart 3286
044bind.test 3424 - loop/recur
044bind.wart 3424 - loop/recur
045check.test 3409
045check.wart 3346 - warning: wart is broken
046type.wart 3257
047generic.test 3271
047generic.wart 3407
048control.test 3439 - be careful using assignment in macros
048control.wart 3439 - be careful using assignment in macros
049assign.test 3266
050list2.test 3427 - support overflowing bounds in slices
050list2.wart 3427 - support overflowing bounds in slices
051mutate.test 3272
051mutate.wart 3272
052num.test 3453 - fix bresenham line algorithm
052num.wart 3453 - fix bresenham line algorithm
053string.test 3427 - support overflowing bounds in slices
053string.wart 3427 - support overflowing bounds in slices
054table.test 3282 - experiment: a new false sym
054table.wart 2596 - use '+' for compose instead of ':'
055queue.test 3282 - experiment: a new false sym
055queue.wart 3427 - support overflowing bounds in slices
056collect.test 2596 - use '+' for compose instead of ':'
056collect.wart 2679 - undo 2678
057sym.test 3318
058with.test 2593
058with.wart 2596 - use '+' for compose instead of ':'
059stream.wart 3433
060tools.wart 2632
061patmatch.test 3282 - experiment: a new false sym
061patmatch.wart 2613 - the one true layout for 'if'
062converge.test 2593
062converge.wart 2593
063stack.test 3259
063stack.wart 3259
070fork.wart 2847 - The great rename of 2013
071http_server.wart 2847 - The great rename of 2013
072url.wart 2752 - url parsing
073http_get.wart 2757
080if2.test 2847 - The great rename of 2013
081inline.test 3331 - eval_bind_all now working without quote_all
081inline.wart 3439 - be careful using assignment in macros
082macex.test 3314
082macex.wart 3428 - back to lite's macex
Readme 3416 3076
denum 2260
log.html.head 2695 - logging UX tweaks
makefile 3302
manual_tests 3437 - cleanup
organization 2926 - tracified tests in top-level version
relayout 2248
wart 3305 - all progress messages are now consistently in
wart.vim 3448 - vim hack


Wart is an experimental, dynamic, batshit-liberal (
language designed for small teams of intrinsically-motivated (
programmers who want more mastery over their entire software stack. The
primary goal is to be easy to understand and modify, so that you can be more

  $ git clone
  $ cd wart
  $ ./wart      # you'll need gcc and unix
  ready! type in an expression, then hit enter twice. ctrl-d exits.
  => 2

## Small core

The best way to be readable is to minimize code (
To this end, Wart is based on lisp (,
because it seems the most powerful and extensible core for the lowest
implementation cost. But that's just the core; read on.

  (+ 1 1)
  => 2

  '(1 2 3)      # lists look like function calls
  => (1 2 3)    # 'quoting' prevents treating them like calls

  (def (foo x)  # define functions using def
    (+ 1 x))
  (foo 3)       # call functions using parens
  => 4

## Clean syntax

The crown jewels of lisp are its macros (,
a massive tool for maximizing density in a readable way. Wart tries to
question all of lisp's design without compromising the power of macros. It
can guess parens from indentation (
to be more accessible to non-lispers.

  if (odd? n)
    prn "odd"   # prn = print to screen

Used tastefully, taking out parens can make code markedly more readable. My
heuristic is to skip parens when I want to highlight side-effects and
control-flow, and to insert them when I want to highlight functional

In order to provide macros, lisp uniformly uses prefix everywhere, including
for arithmetic. Wart provides infix operators (
in an elegant way without compromising macros.

  4 * 3         # same as (* 4 3)
  => 12

This has historically been hard to do because of the burden of providing
precedence rules for nested expressions that are both intuitive and
extensible. Wart's infix operators have only one hard-coded precedence rule:
operators without whitespace are evaluated before operators with whitespace.

  n * n-1       # does what you expect

(The catch: you can't use infix characters like dashes in variable names,
something lispers are used to.)

Infix is most useful in arithmetic-heavy code
( for graphics and so on. But it has
uses beyond arithmetic. Sometimes the clearest way to describe a
sub-computation is as a pipeline of operations (

  (c -> downcase -> rot13 -> upcase)

There's a final convenience beyond indentation-sensitivity and infix: All
function arguments can be referred to by keyword. Individual calls can decide
to pass all their arguments in order, or to insert keywords to reorder or
emphasize specific args.

  => 1

  def (subtract a|from b)   # 'from' is an *alias* for the first arg

  subtract 4 3
  => 1
  subtract 3 :from 4        # refer to 'a' with its alias
  => 1

Argument aliases can also be used for pattern matching, like haskell's

  def (foo (a | (b c)))     # 'b' and 'c' are aliases for parts of list 'a'
    (list a b c)

  (foo '(1 2))
  => ((1 2) 1 2)

I love feedback on these features:

## Names

After succinctness, the biggest lever for readability is a coherent *system*
of names. It's not enough for names to be well-chosen in isolation, they also
need to work well together ( To
maintain coherence, Wart allows all names to be extended and
overloaded in arbitrary ways. So you never have to define words like
'my_malloc' or 'append2' or 'queue_length'.

  def (len x) :case (isa queue x)

Such extensions to len can be made at any time, and might be arbitrarily far
from each other. This makes it easier for all queue-related code to stay
together, and so on.

Wart's primitives themselves pervasively use this technique. We first build
def to define simple functions, and support for :case is added later. The 'if'
primitive at first chooses between just two branches, and is later extended to
multiple branches.

## Organization

You should be able to do just about everything you want in Wart. However,
Wart's internals are also intended to be extremely readable and hackable if
you ever need to get into them. Its directory organization (
is designed to provide a high-level tour of the codebase. Just start reading
at the first file and skim the first few files to orient yourself. You don't
have to read each file to the end; important stuff is at the top and internal
details further down. Start a new file with a numeric prefix, and it'll be
loaded when Wart starts up. Reimplement a primitive from xxx.wart to
for speed, and the new version will be picked up when you restart.

## Tests

Wart is *thoroughly* unit tested.

  $ ./wart test

The tests can be a valuable tool to interactively improve your understanding.
Make a tweak, see if existing tests continue to pass. See a line you don't
understand, or something that seems redundant? Change it, see if the tests

## Speed

Wart is currently orders of magnitude slower than anything you're used to.
I've had some limited success using it for prototyping and then gradually
rewriting key pieces in C. But even this currently only takes you so far. I'm
playing with experimental primitives in the core interpreter that will make
partial evaluation as easy as passing code through eval multiple times. But
they're still in development.

## Where I came from, where I'm going

Wart started out motivated by an observation: good programmers build clean and
elegant programs, but programs grow less elegant over time. We start out clean,
but invariably end up making a mess of things. Requirements shift over time,
but reorganization is not convenient enough to keep organization in sync.
Historical accidents don't get cleaned up. Newcomers don't have the
comprehensive big-picture view of the original authors, and their changes
gradually dilute the original design. As coherence decays, so does sense of
ownership. The big picture becomes a neglected commons, too hard to defend and
nobody's direct responsibility. (More info:

How to fight this tendency? Perhaps we can better preserve sense of ownership
by minimizing constraints.

  * Make creating new files easy, so there are *no* constraints in how a file
  can be organized. This will hopefully improve the odds that file
  organization will continue to reflect reality as requirements shift and the
  architecture evolves.

  * Keep features self-contained in files, so a feature can be dropped simply
  by deleting its files, and the rest of the project will continue to build
  and pass its tests. (There's a new version of this project in that tries to take
  this idea to the limit.)

  * Backwards compatibility is a huge source of constraints that can bleed
  ownership ( What would a language
  ecosystem be like without any backwards-compatibility guarantees, super easy
  to change and fork promiscuously? Wart has no version numbers, and new
  versions and forks are free to change all semantics to their hearts' desire.
  Instead of a spec or frozen interfaces, we rely on automated tests. Wart
  programs are expected to be as thoroughly tested as Wart itself, and to buy
  in to the investment of hacking when upgrading. The hope is that upgrade
  effort might be higher than the best-case scenario in other languages, but
  the worst-case time will remain tightly bounded because clients of libraries
  will be more likely to understand how they're implemented, and so be more

The hypotheses are a) that making the global organization easy for outsiders
to understand will help preserve the big picture, b) that making
reorganizations more convenient by eliminating constraints will help keep the
big picture in sync with reality, and c) that understandability and
rewrite-friendliness are related in a virtuous cycle. Understandable codebases
help outsiders contribute better organizations, and rewrite-friendly codebases
help newcomers hone their understanding by attempting lots of reorganizations
in sandboxes.

These hypotheses are all hard to verify, I don't expected the job to be done
anytime soon. I'd love feedback from people unafraid to bounce between
language and implementation. If that's you, check it out and tell me what you
think: There are many more code samples here and at Rosetta
Code (

## Credits

As an experiment in designing software, Wart was inspired by:
  Christopher Alexander (
  David Parnas (
  Peter Naur (,+Ehn,+Musashi%22)

As a language, Wart was inspired by Arc, a dialect of lisp:
Discussions on the arc forum helped develop many of its features:
  "The wart atop the mountain":
  Generic functions:,
  Python-style keyword args:
  Why wart has no modules:
  Why wart has just one kind of equality:
  In praise of late binding:
  Libraries suck:
  Making macros even more first-class:

Wart is distributed under the Perl Foundation's artistic license 2.0:
Something went wrong with that request. Please try again.