Chris Pressey's Lingography

(What is a "lingography", you ask? Well, if bands have disc-ographies and directors have film-ographies...)

This is a list, given in approximate chronological order, of the languages I've designed and/or implemented. It is more-or-less unabridged, but not intended to be completely exhaustive. Most of these language are programming languages; some of them are formal languages, and some of them are automata of some kind. Many of them are esolangs. Some of them possibly aren't even languages at all; they just seem to fit the general theme of the list. Most of them have been implemented, and these implementations are available in downloadable distrbutions. At the bottom there is also a list of languages that I've implemented, but which were designed by someone else.

You may also be interested in reading about what it was like to design these and/or the ones that got away.

Languages I've Designed (81)

Full Moon Fever ca 1993

Full Moon Fever is a language for describing ASCII animations. It was used to deliver animated screens on Chris Pressey's BBS (when it was operational in the early 90's) via ANSI terminal control codes. This probably counts as his first proper language, even though it wasn't a full programming language, because it had the usual machinery (syntax, parser, interpreter...) Lives on, in a somewhat distended form, as a sub-language of ILLGOL.

The name "Full Moon Fever" has nothing at all to do with lycanthropy; I believe it came from mis-remembering the title of the song "Full Moon Boogie" by Jan Hammer and Jerry Goodman.

GO 1 2 CLREOL CENTRE "Enter... the Stupid Guard." 2
GO 76 19
DO 20

Maentwrog ca 1993

Maentwrog is an RPN-calculator-turned-FORTH-interpreter which probably counts as Chris Pressey's first proper programming language. It was implemented on his Amiga 500 in 1993, then lost and unearthed multiple times. It is hardly remarkable, save that it spawned Befunge-93.

There are no extant example programs from the time the language was first implemented — I tried writing the Sieve of Eratosthenes in it once, but never got it to work, probably because == was not implemented correctly. Recently, example programs and a description of the language (which has become the provisional spec) have been provided by Marinus — thanks Marinus!

Also included in the Maentwrog distribution, just for fun, are some other contemporaneous C programs of mine: an RPN calculator which was the predecessor of Maentwrog, a simple recursive-descent expression parser, and a simple cellular automata parser (a distant ancestor of ALPACA, perhaps?)

Maentwrog is the name of a town in Wales, but the usage of its name for this language came via Douglas Adams' "The Meaning of Liff", wherein it is defined thusly: "MAENTWROG (n. Welsh) Celtic word for a computer spelling mistake."


  • maentw.c (the reference implementation)

*a *b *c
0 =a 1 =b
: fib a b + =c c . b =a c =b c 100000 < @fib ;
1 . fib

Befunge-93 Sep 1993

Befunge-93 is an esoteric programming language where the program exists in a two-dimensional grid of cells, where each cell contains a single instruction, and execution can proceed in any cardinal direction across this grid — not just left-to-right, but also right-to-left, top-to-bottom, and bottom-to-top.

One of the more popular languages I ever designed and implemented. Eventually begat Befunge-97, Funge-98, and Wierd, and doubtless influenced many others. Cited in the New Hacker's Dictionary.


Variants of Befunge-93:

 v    <
Try it (Java Web Start)

SMETANA ca 1994

SMETANA is a pathological little self-modifying language with only two possible operations: Go to step n, and Swap steps n and m. It has inspired a few variants and developments, notably a proof that despite its minimalism, it is finite-automata-complete; it is also the (great-?)grandfather of SMITH.


Step 1. Swap step 1 with step 2.
Step 2. Go to step 2.
Step 3. Go to step 1.
Try it (Java Web Start)

Cyclobots ca 1994

Cyclobots is an automaton that consists of a number of little virtual "turtle robots" called "cyclobots". Each cyclobot moves with a constant velocity, and tries to follow exactly one other cyclobot, adjusting its heading to point towards the cyclobot it is following. No cylobot is followed by more than one cyclobot.

A group of cyclobots tends to fall into one of several semi-stable patterns. The simplest of these is just a rotating circle, but more complex, trefoil-like patterns are more common.

I originally conceived of this automaton, calling it an "interactive desktop toy", in or around 1994, and implemented it immediately in Visual Basic. I remember the year because I wrote the first implementation of SMETANA in Visual Basic at about the same time.

The original implementation had a few features which are not present (yet) in the HTML5 version: cyclobots could collide with each other, and the user could use the mouse to attract/repel them from a chosen point.


RUBE 1997

RUBE is an esoteric programming language in tribute to Rube Goldberg, with bulldozers pushing around numbered crates, knocking them together to perform computations. It is based on a variant of a cellular automaton called a bully automaton, where certain state changes can force other state changes to occur elsewhere in the playfield.


  • rube.c (the reference implementation)

, :::::::::::::::::::::::::::: ,
                               O F

Wierd 1997 with John Colagioia, Ben Olmstead

Wierd is a programming language, inspired somewhat by Befunge-93 and brainfuck, where instructions are not determined by the symbols in a sequence of symbols, but by the bends in a sequence of symbols.

The original Wierd, designed during a three-way email conversation, is probably lost and gone forever, but two dialects have been specified (sorta) and implemented: Wierd (John Colagioia) and Wierd (Milo van Handel).

  * *  **
 *   ** *
  **     **
    *      *
    *     *
    *     *
    *      *
    *     **
    *    *
    * ** *
    **  *

This sample was written by Milo van Handel

Try it Online

Befunge-97 Dec 25, 1997 with Befunge Mailing List Working Group

Befunge-97 was an unimplemented attempt to design a successor to Befunge-93. The design, however, was not successful — it has been described as "brain-damaged" — primarily due to the fact that separate processes were specified as sharing a single stack.


ALPACA is a meta-language for describing cellular automata.

The acronym used to be "A Language for Programming Arbitrary Cellular Automata". This was not quite accurate, as the automata are not in fact arbitrary, so I changed it.

ALPACA is one of the few of my languages in which I've actually implemented other languages (or, well, cellular automata — close enough).


/* John Conway's Game of Life, expressed in ALPACA. */
state Dead  " " to Alive when 3 Alive and 5 Dead;
state Alive "*" to Dead when 4 Alive or 7 Dead.

ETHEL 1998

ETHEL was a programming language specifically for expressing quantity surveying (materials estimating) formula and procedures, designed for Star Building Materials.



REDGREEN is a cellular automaton that simulates a little "physical world", much like RUBE.


                                   # #
                 ......            # #
                                   #  ~                      #
                                   #######################   #
                                  %#                         #
                       . . .      T #####                    #
                                  ###   #  :                 #
                                        #                    #
                                        #  .                 #
                                        #                    #
                                        #                    #
                                        #  .                 #
                                        #                    #
                                        #                    #
Try it Online

Funge-98 Sep 11, 1998 with Befunge Mailing List Working Group

Funge-98 is a family of programming languages designed as the successor to Befunge-93. It generalizes Befunge-93's two-dimensional nature somewhat, defining languages in one dimension (Unefunge-98), two dimensions (Befunge-98), and three dimensions (Trefunge-98), and suggests possibilities for other dimensions and topologies (but does not specify exactly how they look or would behave.) It also makes the playfield unbounded, allowing the language to be Turing-complete, and tries to define mechanisms for interacting with the operating system and engaging extensions to the language.

Members of Funge-98:

^,A' <
 ^ C'
 ^ <<

MDPN 1999

MDPN is a meta-language for describing multi-directional and multi-dimensional languages.

  Box ::= "+" {"-"}^(w) r(-90) "+" "||" {"|"}^(h) r(-90)
          "+" {"-"}^(w) r(-90) "+" "||" {"|"}^(h) r(-90)

Shelta ca Jul 1999

Shelta is an extremely minimal Forth-like language with barely any semantics; it relies on inline machine code to write anything resembling an actual program in it. In the spirit of compilers for languages such as FALSE and brainfuck, a Shelta-to-8086 compiler was implemented (with help from Ben Olmstead) in less than 512 bytes of 80286 machine code. What's more, it's also been bootstrapped — that is to say, a Shelta compiler was written in Shelta, which was compiled with the original compiler, and then compiled again with the resulting compiler, producing a wholly self-hosted executable!


[ `Hello, _32 `world! _13 _10 ] \15 outs \0 halt
Try it Online

Bear Food ca Dec 1999

Bear Food was a horrible language defined by an interpreter that evolved (no... let's be honest, it devolved) from a small piece of example code showing how to parse and intepret a simple reverse-polish notation language. This same example code also took a very divergent line of evolution, eventually becoming the programming language Var'aq.


Sally 2000

Sally is a cute but naive little functional language with a minimal syntax, a strict type system, and some unusual rules for parameters and return values.


  • sally2c (the reference implementation)

int factorial int if $1 mul $1 factorial sub $1 1 1
int main int factorial $1

ILLGOL ca Apr 2000

ILLGOL is a joke language which parodies the sort of language designed by the sheer fact that a compiler for it has been hacked together.


Variants of ILLGOL:

NB eh.ill
10 *f = { print str(#0), EoL };
20 do f(1);
30 don't f;
40 do f(2);
50 reinstate f;
60 do f(3);

SMITH ca Jul 2000

SMITH is a self-modifying assembly-like language which completely lacks any kind of jump instructions whatsoever. Despite this handicap, it has been shown to be Turing-complete.


  • (the reference implementation)

MOV R0, 10
MOV R2, 0
SUB R2, 1
MOV R[R0], "Hello, world!"
SUB R0, R2
MOV R1, R0
SUB R1, 23
MUL R1, 8
COR +1, -7, R1

Tamerlane Aug 2000

Tamerlane is a multi-paradigmatic programming language, unimplemented and possibly unimplementable. One of its core execution mechanisms is the traversing of a graph (representing the program) while rewriting that same graph.

Point-A: 1 Point-B,
Point-B: 1 Point-C,
Point-C: 1 Point-A.
?- 1 Point-A -> 0 Point-A @ Point-A

Squishy2K Sep 2000

Squishy2K is a language which is a hybrid of string rewriting and finite state automata; as an added twist, it also lets program states serve as functions. It was based largely on an earlier grammar-based language called SQUISHY, taking also some ideas from the language Thue. The original SQUISHY was conceived sometime around 1998, but is now lost. Because it was based largely on EBNF, the author wanted to name it Wirth, but the name SQUISHY was proposed and (somewhat unfortunately) stuck.


* main { start many finish? "Hello, world!"! }

noit o' mnain worb Sep 15, 2000

noit o' mnain worb is a probabilistic particle automaton that uses pressure between randomly moving particles to approximate the behaviour of circuits. It can approximate computation with these circuits, too, but it's so lossy that it has more value as just a neat toy to watch.

(The name of this language contains a secret message! Can you find it?)


#####         #####
#   ###########   #
# . >         < . #
#   #####v#####   #
#####   #  ########
        #       >!#
        # #
Try it Online Try it (Java Web Start)

HUNTER ca Sep 20, 2000

HUNTER is a language I designed for the Esoteric Awards ("Essies") Its abstract starts out like this:

It is perceived that one of the biggest problems in maintaining interest in programming is the above linear growth of boredom compared to the usefulness of the program, resulting in an acute loss of enthusiasm on the part of the programmers and ultimately the abandonment of the software...


#   1#2#         #
# #### #         #
#      #         #
# ######    M    #
#     M#         #
#+######         #
#     !#         #

'N-DCNC Oct 2000

'N-DCNC was Chris Pressey's entry for the 2000 Esoteric Awards. It is based on a conspiracy theory involving UFOs and a 5-member boy band, or something.

A copy of PortableFalse is included in the 'N-DCNC distribution, to make it easier for you to run the code generated by the 'N-DCNC compilers. However, you still need a C compiler to build the PortableFalse interpreter.



Strelnokoff Apr 2001

Strelnokoff is a non-deterministic imperative programming language. Despite this apparent handicap, it appears to be Turing-complete — thanks to a short-circuiting multiplication operator — but a critical feature, namely arrays, has yet to be implemented.

The name "Strelnokoff" was taken from a fictional brand of vodka featured in a parody advertisement on the television show SCTV.


X = (X / X) * X + (X = 0) * (T =  0) * (PRINT CHAR 'H' - 'H' +  1)
X = (X / X) * X + (X = 0) * (T =  1) * (PRINT CHAR 'e' - 'e' +  2)
X = (X / X) * X + (X = 0) * (T =  2) * (PRINT CHAR 'l' - 'l' +  3)
X = (X / X) * X + (X = 0) * (T =  3) * (PRINT CHAR 'l' - 'l' +  4)
X = (X / X) * X + (X = 0) * (T =  4) * (PRINT CHAR 'o' - 'o' +  5)
X = (X / X) * X + (X = 0) * (T =  5) * (PRINT CHAR ',' - ',' +  6)
X = (X / X) * X + (X = 0) * (T =  6) * (PRINT CHAR ' ' - ' ' +  7)
X = (X / X) * X + (X = 0) * (T =  7) * (PRINT CHAR 'w' - 'w' +  8)
X = (X / X) * X + (X = 0) * (T =  8) * (PRINT CHAR 'o' - 'o' +  9)
X = (X / X) * X + (X = 0) * (T =  9) * (PRINT CHAR 'r' - 'r' + 10)
X = (X / X) * X + (X = 0) * (T = 10) * (PRINT CHAR 'l' - 'l' + 11)
X = (X / X) * X + (X = 0) * (T = 11) * (PRINT CHAR 'd' - 'd' + 12)
X = (X / X) * X + (X = 0) * (T = 12) * (PRINT CHAR '!' - '!' + 13)
X = (T = X) * 0 + (X > T) * X REM RESET FLAG
T = (X / X) * X + (X = 0) * T REM INCREMENT TICK

Opus-2 Jul 2001

Opus-2 is not a programming language, but rather, an abstract artlang (i.e., a conlang designed independently from any conception of society.) The sole design principle was to entirely eliminate word order.

+ pale green
+ Eb, trombone, forte
+ leaning 40 degrees left (sudden)
+ C, tubular bells, piano
+ mothballs (gentle whiff)

Ypsilax Aug 2001

Ypsilax is a non-deterministic, reflective, two-dimensional grid-rewriting language. Rewriting rules look for patterns in the grid and replace them with other patterns. These rules are themselves represented by patterns in the grid, and therefore rules can match and rewrite other rules.


(      )  (      )
  #            #
  # ###    ### #
  #            #

    ###   ###

    #      #
    #      #
    #    ###
Try it (Java Web Start)

Version Sep 2001

Version is an imperative programming language that uses ignorance-spaces for flow control; all instructions which match the current ignorance pattern are ignored during execution.


VALLEY: OUTPUT = "You are standing in a valley."
HILL: OUTPUT = "You are on top of a hill."
BROOK: OUTPUT = "You are by a brook."
GLADE: OUTPUT = "You are standing in a sun-dappled glade."
N: CAT = "|N"
S: CAT = "|S"
E: CAT = "|E"
W: CAT = "|W"

Sbeezg 2002

Sbeezg is a syntactically very simple language that attempts to take the single-assignment concept to a logical extreme.

I really don't remember exactly what I was trying to accomplish with this; the basic idea is fairly absurd (either your variables are single-assignment or they're not...)



beta-Juliet ca 2002

beta-Juliet is a minimal event-based language. Each event is caused by some other event. Event causation is conditional based on which of two given events occurred more recently.

Portia is a preprocessor for beta-Juliet which allows large, regular, finite sets of events to be described succinctly.

Version 2.0 of beta-Juliet (formerly known as "2iota") allows infinite sets of events to be specified, allowing the language to be Turing-complete.


event WindowSwitchBroken;
event MotionDetectorTriggered;

event SystemArmed;
event SystemDisarmed;

event Alarm,
 caused after WindowSwitchBroken      when SystemArmed > SystemDisarmed,
 caused after MotionDetectorTriggered when SystemArmed > SystemDisarmed,
 causes Alarm.

alphabet Domino,
        One, Two, Three, Four, Five, Six, Seven;
event Begin,
        causes Domino One Falls;
event Domino (N = Domino+) Falls,
        causes Domino (succ N) Falls.

GraNoLa/M Jul 2002

GraNoLa/M is a Graph-Node-based Language (possibly for Machines.) It was one of my submissions for the Esoteric Awards. Not unlike Tamerlane, its execution model involves both traversing and rewriting a graph at the same time.



Kangaroo Iceberg Jul 2004

Kangaroo Iceberg was a short-lived attempt to pare down Tamerlane to something implementable, and implement it. Although it got a fair ways along (e.g. the parser for graphs seems to be complete, I lost interest in it at the time, and put off finishing it indefinitely.

Now, the challenge will be reconstructing the language from the partial implementation and notes that I left behind...


  • kiceberg (the reference implementation)

A { ^A:0 / ^A:0 -> ^A:1 }
B { / ^B:0 -> ^B:1, ^B:1 -> ^B:2 }
C { {}:0 / ^K:0 -> ^K:1, ^K:1 -> ^K:2; ^A:1 -> ^A:0 }

Braktif 2005

Braktif is a cellular automaton modelled closely after the brainfuck programming language.


000000000000000000  *[-----  --]
-----------------d-i--         --------
Try it Online

Circute 2005

Circute is a cellular automaton that simulates conduits that carry digital signals and NAND gates that manipulate those signals.


   #######==   ===N===   =========
   #       =   =     =   =       =
 ==N==     = ==N== ==N== =     ==N==
 =   =     = =   = =   = =     =   =
 =====     = ===== ===== =     =====
   =       =   =     =   =       =
   =============     =============
Try it Online Try it (Java Web Start)

Beturing Oct 20, 2005

Beturing is a "Befunge-flavoured" language for describing Turing machines; both the tape and the finite control are laid out two-dimensionally. In addition, the finite control must be expressed as a planar graph (no edge representing a transition may cross any other edge.) It was devised this way as a test of the so-called "wire-crossing problem". It turns out that there are universal Turing machines with finite controls that are planar graphs, so Beturing is Turing-complete.


# D(40, 4)
# @(40, 4)
# C(0, 0)
# @(0, 0)
 . . . . . .
aa .ab . .aa .
bb .ba . .bb .
$$ .$$ . .$$ .
         . . .
*@      *^*<*<

Bhuna Oct 21, 2005

Bhuna is a small, garbage-collected language with a simple syntax, closures, inferred types, lightweight processes, and support for UTF-8 source code. It was implemented partly to see how closely I could match the performance of Lua's interpreter. It was meant more more as an experimental starting point for branching new languages, than as a useful language in and of itself.


  • bhuna (the reference implementation)

Fib = ^ X {
  if X < 2 return 1 else
  return Fib(X - 1) + Fib(X - 2)
Print Fib(32), EoL

Burro 2007

Burro is a brainfuck-like programming language whose programs form an algebraical group (modulo the equivalence relation of "computes the same function") under the operation of concatenation. The upshot of this is that, for every Burro program, we can find an antiprogram which, when appended to the program, forms a "no-op" program which has no effect. This is a form of reversible computing, but unlike most reversible languages where it is the execution of the program that is "undone", in Burro, it is the program itself which is annihiliated by its antiprogram. Burro 1.0 was released in fall of 2007, but proved not to form a proper group. This shortcoming was rectified in summer of 2010.



Xigxag Apr 23, 2007

Xigxag is a simple string-copying automaton that has exponential growth almost everywhere (i.e. there are only a finite number of initial configurations that don't blow up.)





Hev May 23, 2007

Hev is a programming language that attempts to solve the "central problem of infix notation": how do you allow it without requiring the programmer to either memorize precedence tables or litter parentheses everywhere? Hev has a way! In Hev, all operators are infix, yet no tiresome memorization of any dreadful precedence table is required!


  • Hev.hs (the reference implementation)


Cabra Oct 30, 2007

Cabra is a (somewhat) formal programming language whose programs form an algebraical dioid (an idempotent semiring), modulo the equivalence relation of "computes the same function", under the operations of parallel execution (as the additive operator) and sequential composition (as the multiplicative operator).


  • cabra.hs (the reference implementation)


You are Reading the Name of this Esolang Nov 2007

You are Reading the Name of this Esolang is an exploration in the design space of programming languages with undecidable elements. Its syntax is only recursively enumerable: the problem of determining whether or not a given string of symbols is a well-formed You are Reading the Name of this Esolang program is undecidable.

The description makes it sound a bit more mind-blowing than it actually is. In fact C++ has essentially the same property: it's template system is Turing-complete. In practice, this means you can hang the compiler with templates that expand unboundedly (and the compiler has no means by which to detect all possible compiler-hanging-templates.)


Emmental Nov 11, 2007

Emmental is a self-modifying programming language. It is defined in terms of a meta-circular interpreter, and this meta-circular interpreter provides an operation that redefines operations of the meta-circular interpreter. In fact, this mechanism is required for Emmental to be Turing-complete.



Didigm Nov 20, 2007

Didigm is a reflective cellular automaton: the transition rules for the automaton are defined by forms in the very playfield governed by those transition rules.


Iphigeneia Nov 25, 2007

Iphigeneia is a toy programming language which contains features from both imperative programming (assignments to mutable variables, while loops,) and functional programming (immutable name bindings, Scheme-style "named let" loops.) It was originally intended as a testbed for algorithms that convert programs between the two forms.


  • iphi (the reference implementation)

var a in a :=
    let c = 5 in let d = 1 in
            if c = 0 then
                let d = d * c in
                    let c = c - 1 in

Mascarpone Dec 10, 2007

Mascarpone is a self-modifying language able to alter the meta-circular interpreter which defines it, like its predecessor Emmental. Unlike Emmental however, in Mascarpone interpreters are first-class objects, making the job of reflective interpreter-modification quite a bit cleaner and richer.



Larabee Jan 10, 2008

Larabee is an assembly-like programming language, with Scheme-like syntax, that borrows the notion of branch prediction from computer architecture and abuses it, creating a path that leads only to existential angst and self-destruction.


(store (input) (input)
  (store (input) (input)
    (label loop
      (store (input) (op * (fetch (input)) (fetch (input)))
        (store (input) (op - (fetch (input)) (input))
          (test (op > (fetch (input)) (input))
            (goto loop) (print (fetch (input)))))))))

Arboretuum Mar 2008

Arboretuum is an experimental language based on forest-rewriting, a variant of tree-rewriting in which multiple trees are rewritten simultaneously. The language was intended for specifying compilers, with each tree representing a major compiler data structure (AST, symbol table, output buffer, etc.,) however, this idea was not entirely successful. Regardless, Arboretuum is Turing-complete, as tree-rewriting is simply a special case of forest-rewriting.


    (ast:   (let a 4 (+ 3 (* a 3))) )
    (stab:  eot)
    (out:   halt)
    ((ast:  (let #(n sym) #(v) #(expr)) => #(expr)            )
     (stab: eot                         => (#(n) #(v) EOT)    ))
    ((ast:  #(n sym)                    => #(v)               )
     (stab: (#(n) #(v) #(tab))          => (#(n) #(v) #(tab)) ))
    ((ast: #(a num)                     => _                  )
     (out: halt                         => (push #(a) halt)   ))
    ((ast: (+ _ _)                      => _                  )
     (out: halt                         => (add halt)         ))
    ((ast: (* _ _)                      => _                  )
     (out: halt                         => (mul halt)         ))

Treacle Apr 12, 2008

Treacle is an experimental compiler-definition language based on context rewriting, an expressive variant of term rewriting that generalizes the forest-rewriting used by its predecessor Arboretuum. In context rewriting, a separation is made between names and variables, and patterns may contain holes inside which subpatterns may match at any depth.


  (:i (? t (x (? i *) (? j *)))) -> (t : (xx (? j *) (? i *)))))
  (:i (? p right))               -> (p : left)


(x this (x descends (x to (x the (x right (y 1 2))))))


(xx (xx (xx (xx (xx (y 1 2) left) the) to) descends) this)

Quylthulg Dec 6, 2008

Quylthulg is a programming language with but a single control-flow construct: foreach. In fact, it does also have a goto, but that can only appear inside data structures.


foreach $n$=:L:[1,2,3|goto$L$] with $a$=1 be +$a$+$n$+ else be abort

Unlikely Mar 15, 2009

Unlikely is a programming language that conflates objects with continuations, and methods with labels. It exposes program structures as objects with commensurate inheritance relationships. It also takes dependency injection to the logical extreme: if some class is used by an object, that class must be specified when the object is instantiated.


class Count(Count,Chain,Print,Add) extends Continuation

class CountForever(Count,Chain,Print,Add) extends Program {
  Count c;
  method continue(Passive accumulator) {
    c = new Count(Passive,Count,Chain,Print,Add);
    goto c.continue(new 1(Passive));

class Count() extends Continuation {
  Count c;
  Print p;
  Add a;
  method continue(Passive accumulator) {
    c = new Count(Passive,Count,Chain,Print,Add);
    a = new Add(Passive,Chain);
    a.value = new 1(Passive); = c;
    p = new Print(Passive,Chain); = a;
    goto p.continue(accumulator);

Jaccia Apr 11, 2009

Jaccia and Jacciata are cellular automata inspired by the Announcement of Scientific Proof that Slime Molds are Intelligent Maze Solvers. Jaccia can solve mazes too, by a similar mechanism (shrinking). Jacciata builds upon this to find the shortest path through a maze, if one exists and is unique.


Variants of Jaccia:



#    :::  #
# ###:### #
# # #:::# #
# # # #:###
#   # #:# #
##### #:# #
# #   #:  #
# # ###:###
#   #  :::#
Try it Online

Pixley May 2009

Pixley is a very small subset of R5RS Scheme (or, if you prefer, R4RS Scheme), supporting only four datatypes (boolean, cons cell, function, and symbol) and only a dozen built-in symbols. The reference implementation of Pixley is written in 124 lines of Pixley (or, if you prefer, 124 lines of Scheme; and if you prefer more Scheme-ly metrics, it consists of 413 instances of 54 unique symbols in 684 cons cells.)


Variants of Pixley:

(let* ((a (lambda (x y) (cons x y)))) (a (quote foo) (quote ())))
Try it Online

Dieter ca Oct 3, 2009

Dieter (as in the German masculine given name Dieter, not dieter as in "one who diets") is a little experimental programming language that conflates type qualifiers with modules to produce something reminiscent of object-orientation. It demonstrates another way of thinking about objects, or rather, classes: not so much as aggregates of data as associations of predicates.

Dieter was intended as a way to make Hungarian notation part of the type system, and thus automatically checkable. However, it also suggests possible ways of dealing with the problems of aliasing — that is, determining if two pointers cannot possibly point to the same data, for safety and optimization considerations.


module beefy
  procedure beef_up(x: ♥t): beefy ♥t
    return (bestow beefy x)

Etcha Oct 4, 2009

Etcha is a two-dimensional descendant of Jeffry Johnston's BitChanger. Like BitChanger, it has four instructions; unlike BitChanger, its storage model is based on turtle graphics, which permits it to be immediately used for an alternative purpose: graphical composition. Unlike the turtle in LOGO however, the turtle in Etcha is an integral part of the computation, playing a role similar to the tape head of a Turing machine.


Variants of Etcha:



Try it Online Try it (Java Web Start)

ZOWIE Dec 29, 2009

ZOWIE is a machine-like language in which all operations including structured control flow are memory-mapped. Control flow is structured in the sense of structured programming — the programmer never deals with gotos, or offsets or labels of any kind. Instead, the program writes to a memory location to mark the beginning or end of a loop or conditional.


  • (the reference implementation)

MOV R10, 90
MOV R1, R1
MOV R0, R10
MOV R8, R10
MOV R5, 1
MOV R10, R8
MOV R8, R10
MOV R5, 64
MOV R3, R8
Try it Online

Okapi May 23, 2010

Okapi is a language I designed as an anniversary present for my wife(!). In it, the only means of control flow is throwing exceptions, and as if this wasn't enough, there are two restrictions on exceptions that are thrown — they must be divide-by-zero exceptions, and they must be caught in a lexically enclosing block. Nor is there any facility to "retry" after an exception is caught. The language is nonetheless Turing-complete.


  • (the reference implementation)

Whothm Jun 28, 2010

Whothm is a simple language for describing infinite two-colour bitmapped drawings.


r := (0, 0, 1, 2);
s := (0, 0, 1, 2);

r.x += r.w;
r.x += -1;
r.w += 1;
r.h += 1;
draw r, XOR;
s.x += s.w;
s.x += -1;
s.w += 1;
s.h += 2;
draw s, XOR;
Try it (Java Web Start)

Eightebed ca Sep 1, 2010

Eightebed is a small language with explicit malloc and free. Through a modicum of static analysis and runtime support, Eightebed is "safe": it is not possible to dereference a dangling pointer or otherwise incorrectly-populated memory.

Eightebed was designed as a counter-example to Gregor Richards' claim that such a language would either need a garbage collector, or not actually implement free. Eightebed has a real free and has no garbage collector.

The name "Eightebed" came from a typo by Alise for the word "enlightened".


type node struct {
    int value;
    ptr to node next;
var ptr to node jim;
var ptr to node george;
    jim = malloc node;
    if valid jim {
        [@jim].value = (1 + 4);
        george = jim;
    if valid george {
        print [@george].value;
    free george;
    free jim;

Oozlybub and Murphy Dec 2010

The name of this language is Oozlybub and Murphy. Despite appearances, this name refers to a single language. The majority of the language is named Oozlybub. The fact that the language is not entirely named Oozlybub is named Murphy. Deal with it. For the sake of providing an "olde tyme esoterickal de-sign", the language combines several unusual features, including multiple interleaved parse streams, infinitely long variable names, gratuitously strong typing, and only-conjectural Turing completeness.

VARIABLES ARE p /p*/, p /q*/.
dynast(3) <->
  (. do (. if? not? exists/dynast 5 ,then
       create/countably/many/dynasts #myself#, 5 .) .) ,then
  (. for each prime /p*|p/ below #myself#+2 do
       for each prime /q*|q/ below /p*|pp/+1 do
         if? not? exists/dynast /p*|p|p/+/q*|q|q/ ,then
           copy/dynast #myself#, /p*|ppp/, /q*|qqq/ .)

Gemooy Dec 2, 2010

Gemooy is a 2-dimensional esolang with 3 instructions (5 initial symbols) which combines features from 2-ill and Etcha, and adds self-modification. It came about when the author noticed the tape-related semantics of 2-ill were essentially the same as those of BitChanger.


%### # ###   # #   ### # ###   # #   ### # ###@

   @    @#         @
  @      @          @
@                   @
    $         @# # @
             #      @
       @   @

    @    @
     @# @
@        @
  @     @#@
Try it Online Try it (Java Web Start)

Nhohnhehr Dec 8, 2010

Nhohnhehr is a remotely fungeoid language which explores the design space between having a fixed playfield versus an expandable one. When the instruction pointer reaches the edge of the playfield (the "room"), whether it wraps around or creates a new room and adjoins it to that edge, depends on the current edge mode of the program. New copies of rooms may be rotated before being adjoined to existing rooms, but rooms are otherwise immutable.


|    /}|
|  / \&|
|      |
| {    |
|\\    |

Kelxquoia Dec 23, 2010

Kelxquoia is another remotely fungeoid language, this one self-modifying — in fact, self-destroying. As instructions are executed, they are erased. In order to execute indefinitely, new instructions of some sort must be created. Luckily the language provides as its main data-manipulation facility, grid-rewriting, which can be used to restore instructions that were previously erased after execution.

 >+-0 0*+-1*/+-?*-R*- *+-?*-R*-?*/v
$>+-0 0*+-1*/+-?*-R*- *+-?*-R*-?*/v
    ' '   '       '  '      '   
             '         '  '     
 ^      /*?-*P-*?-+*?-*P-* -+     <
 ^      /*?-*P-*?-+*?-*P-* -+     <

 00 00 00 00

Wunnel Feb 13, 2011

Wunnel is a two-dimensional language which draws from the 1L family of languages and incorporates features from reMorse. The name is both a play on the pronunciation of "1L", and a recursive portmanteau of the words Wunnel and tunnel which is used to describe the long sequences of identical instructions (often nops) used in Wunnel programs to sync up remote parts of the program.


          o   ooo  o

o         o
o         o
o         o
o         o
o        o     o
o         o
o        o
o              o
o        o     o
o              o

o oooooooo     o

         o    oooo o
Try it Online Try it (Java Web Start)

Pail May 25, 2011

Pail is a programming language based on pairs; just as Lisp stands for LISt Processing, Pail stands for PAIr Language. Its original working title was "Bizaaro[sic]-Pixley", as it attempts to resemble Pixley while turning several concepts on their heads: use pairs instead of lists, quote by default instead of eval by default, and allow not just values but also names of bindings to be expressed.


  • Pail.lhs (the reference implementation)

**[*let [
     [cadrg *[#fst ##*[#snd #g]]]
     **[*let [
          [g [x [y z]]]

Xoomonk Aug 7, 2011

Xoomonk is a programming language in which malingering updatable stores are first-class objects. Malingering updatable stores unify several language constructs, including procedure activations, named parameters, and object-like data structures.

The Xoomonk project was also an experiment in test-driven language design. The specification is largely composed of a number of example programs in the format of Falderal tests, which were written while the language was being designed. These were used to compare the reference implementation, while it was being developed, against the spec.


l := $loop*
counter := 5 := {
  y := x
  print ^.counter
  o := $sub*
  o.x := ^.counter
  o.y := 1
  ^.counter := o.result
  continue := o.result

Flobnar Oct 28, 2011

One day in September of 2011 — though I'm not sure precisely which one — marked Befunge-93's 18th birthday. That means that Befunge is now old enough to drink in its native land of Canada. To celebrate this, I thought I'd get Befunge-93 drunk to see what would happen. What happened was Flobnar, an esolang which is in many respects a functional dual of Befunge-93; most of the symbols have analogous meanings, but execution proceeds in a much more dataflow-like fashion.


>     v
^\ <

:v    v   \<@
-<      : 6
1 :   > *
  -|    <

Madison Dec 2, 2011

Madison is a language in which one can state proofs of properties of term-rewriting systems. Classical methods of automated reasoning, such as resolution, are not used; indeed, term-rewriting itself is used to check the proofs. Both direct proof and proof by induction are supported. Induction in a proof must be across a structure which has a well-founded inductive definition. Such structures can be thought of as types, although this is largely nominal; the traditional typelessness of term-rewiting systems is largely retained.

type tree is
  tree(leaf)        -> true
  tree(branch(X,Y)) -> and(tree(X),tree(Y))
in let
  reflect(leaf)        -> leaf
  reflect(branch(A,B)) -> branch(reflect(B),reflect(A))
in theorem
  forall X where tree(X)
    reflect(reflect(X)) ~> X
  case X = leaf
    -> reflect(leaf)        [by reflect.1]
    -> leaf                 [by reflect.1]
  case X = branch(S, T)
    reflect(reflect(branch(S, T)))
    -> reflect(branch(reflect(T),reflect(S)))          [by reflect.2]
    -> branch(reflect(reflect(S)),reflect(reflect(T))) [by reflect.2]
    -> branch(S,reflect(reflect(T)))                   [by IH]
    -> branch(S,T)                                     [by IH]

Troupe Jun 25, 2012

Troupe is an esolang based on hedgehogs, faery rings, and hills. It maps fairly neatly to the definition of a Turing machine, so it is almost certainly Turing-complete.

Velo Jul 2012

Velo is a vaguely Ruby-inspired "scripting" language which unifies strings with code blocks, and scripts with object classes. Curly braces delimit string literals, and there is no difference between a string literal and a block of code given to, say, an if statement. Any given script is an object, which inherits from the root object in delegation-OO style.


yes = {IO.print {Yes}}
no = {IO.print {No}}
if ({X}.equals {Y}), yes, no

Exanoke ca Jul 2012

Exanoke is a functional language which is syntactically restricted to expressing the primitive recursive functions.


def inc(#)
  cons(:one, #)
def add(#, other)
  if eq?(#, :nil) then other else self(<tail #, inc(other))
def mul(#, other)
  if eq?(#, :nil) then :nil else
    add(other, self(<tail #, other))
def fact(#)
  if eq?(#, :nil) then cons(:one, :nil) else
    mul(#, self(<tail #))
def four(#)
  cons(:one, cons(:one, cons(:one, cons(:one, #))))

Cfluviurrh Aug 26, 2012

Cfluviurrh is, as far as I am aware, the first programming language designed for writing programs that can feel. Cfluviurrh defines a mechanism by which a program can be instructed to experience particular emotions.

You might, thus, on first blush, consider Cfluviurrh to be unimplementable, as modern-day computers are not capable of experiencing emotions (you guess.) However, this is demonstrably untrue. The reference interpreter demonstrates it.


(print ASCII table while experiencing a bewildering array of emotions)

Jolverine Sep 10, 2012

The Jolverine language was devised as a conscious attempt to expand the genre of turning tarpit by adding the feature of modifying the instruction wheel during execution.

The name is a portmanteau of "jolly wolverine" (where "jolly" is a euphemism for "drunk",) which is an attempt to capture, in a noun phrase, the language's vicious, erratic nature.


       \           *
        \         /
         \       /
          \     /
           *   /
            \ /

SICKBAY Sep 22, 2012

SICKBAY is an esoteric dialect of BASIC with a call ring buffer instead of a call stack, and computed line number definitions (and no IF because of that.)


  • SAWBONES (the reference implementation)

10 LET B% = 99
(100+B%) END
215 LET B% = (B% - 1)
230 GOTO 100

Carriage Nov 2012

Carriage is the result of various, not-entirely-successful attempts to design a "pure" concatenative language — one in which the program texts are monoids and nothing but monoids (no quoting operators or the like.) The result was midly unusual — subroutines are specified by indices into an area of the stack which contains program symbols, thus may overlap — and was released as an esolang.



Chzrxl 2013

"Chzrxl, the Living Inkblot." Or is it a sort of self-attracting lava lamp?


Yolk Aug 24, 2014

Yolk is a tiny S-expression-based programming language (or computational calculus) with a tiny meta-circular interpreter.


(ifeq (head arg) (quote arg)
    (head (tail (tail arg)))
    (ifeq (head (head arg)) (quote head)
        (head (self (cons (head (tail (head arg))) (tail arg))))
        (ifeq (head (head arg)) (quote tail)
            (tail (self (cons (head (tail (head arg))) (tail arg))))
            (ifeq (head (head arg)) (quote cons)
                (cons (self (cons (head (tail (head arg))) (tail arg))) (self (cons (head (tail (tail (head arg)))) (tail arg))))
                (ifeq (head (head arg)) (quote quote)
                    (head (tail (head arg)))
                    (ifeq (head (head arg)) (quote ifeq)
                        (ifeq (self (cons (head (tail (head arg))) (tail arg)))
                              (self (cons (head (tail (tail (head arg)))) (tail arg)))
                              (self (cons (head (tail (tail (tail (head arg))))) (tail arg)))
                              (self (cons (head (tail (tail (tail (tail (head arg)))))) (tail arg))))
                        (ifeq (head (head arg)) (quote self)
                            (self (cons (head (tail arg))
                                    (cons (head (tail arg))
                                      (cons (self (cons (head (tail (head arg))) (tail arg))) (tail (quote (tail)))))))

Matchbox Feb 2015

A toy language for a toy race-condition finder.

I wrote this because I feel race conditions are an underappreciated problem in software development. In programming education, they're often not given the attention they deserve, given that they are a real problem that comes up once you get into any kind of concurrent programming — and one that can very difficult to pinpoint, much less fix.

The general "someone else's problem"-ness surrounding race conditions seems to have fostered two misconceptions in particular that I wanted to highlight.

Even though Matchbox is an assembly-like language, race conditions are not restricted to machine language. Nearly every high-level programmer works with either filesystems or databases, and those are both basically gigantic tracts of shared memory. Race conditions are just waiting to happen, if you're not careful.

And there is sometimes the impression that the only way to protect oneself against race conditions is if the system provides an atomic-test-and-set-like operation. If such an operation is avaiable, you should probably use it, but it's not the only way. There are several different programming methods for guaranteeing mutually exclusive access to a resource, even when such operations are not available. These were developed before such operations were widely available in hardware, and although they are largely of historical interest, they also posess a certain conceptual beauty. One such method is Peterson's Algorithm, which Matchbox can run and show correct.


Backtracking Wang Tiler Feb 2015

This backtracking Wang tiler is an automaton which naïvely tiles the plane with Wang tiles.

It operates like a backtracking algorithm, backing up whenever it finds it cannot place a tile, but it may be inaccurate to describe it as an algorithm, since it never terminates.


Schrödinger's Game of Life Feb 7, 2015

Schrödinger's Game of Life is what happens when Conway's Game of Life meets Schrödinger's Cat: each individual cell may be Alive, or Dead, or Possibly-Alive-Possibly-Dead (which we call Cat.)

This is, in essence, the result of applying non-determinism to an existing cellular automaton, and this operation could probably be applied to any cellular automaton with similar results.

For a full account of its development, see its README document.


SITU-SOL Jul 2015

SITU-SOL is a vaguely Forth-like language which was designed and implemented (by hand!) during RetroChallenge 2015/07, and entered into an emulated Commodore 64 using SITU-MON.


Maxixe 2016

Maxixe is a simple proof-checking language. Given a proof written out fully and explicitly (including all rules of inference), a computer can check if it is valid or not.

    Modus_Ponens                 = impl(P, Q) ; P |- Q
    Simplification               = and(P, Q)      |- Q
    Commutativity_of_Conjunction = and(P, Q)      |- and(Q, P)
    Premise                      =                |- and(p, impl(p, q))
    Step_1 = and(p, impl(p, q))    by Premise
    Step_2 = and(impl(p, q), p)    by Commutativity_of_Conjunction with Step_1
    Step_3 = impl(p, q)            by Simplification with Step_1
    Step_4 = p                     by Simplification with Step_2
    Step_5 = q                     by Modus_Ponens with Step_3, Step_4

Samovar 2016

Samovar is a DSL for world-modeling using predicates rather than explicit objects. It could be thought of as an "assertion-retraction engine", which itself could be thought of as a very stilted style of Prolog programming plus some syntactic sugar.

  [actor(α),item(β),~holding(α,β)]  α picks up the β.   [holding(α,β)]
  [actor(α),item(β),holding(α,β)]   α puts down the β.  [~holding(α,β)]

Languages I've Implemented