Chris Pressey: Lingography

↑Chris Pressey↓Languages I've Designed (66) ↓Implementations of Other Languages (19)

(What is a "lingography", you ask? Well, if bands have discographies and directors have filmographies...)

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 as projects from this website. 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. And, since the distinction between languages and games is not always that clear, you may also be interested in the (much less voluminous) list of games I've designed and implemented.

Icons courtesy of FAMFAMFAM; hover over any of them for a description of its meaning.

Languages I've Designed (66)

Full Moon Fever (1993)

A language for describing ASCII animations, used to deliver animated screens on my BBS via terminal control codes. This probably counts as my very first language, even though it wasn't a programming language, because it had the usual machinery (syntax, parser, interpreter...) Lives on, in a somewhat distended form, as a sub-language of ILLGOL.
```
GO 1 2 CLREOL CENTRE "Enter... the Stupid Guard." 2
GO 1 3 CLREOL
PAUSE 70
GO 76 19
PRINT "0"
PAUSE 20
DO 20
    LF PRINT " " LF LF PRINT "0" PAUSE 5;
```
Maentwrog (1993)

My first "real" programming language, an RPN-calculator-turned-FORTH-interpreter. Implemented on my Amiga 500 a long, long time ago (1993!), then lost and unearthed multiple times. Hardly remarkable, save that it spawned Befunge-93.

Implementations:
- maentw (reference interpreter, written in C)
Befunge-93 (1993)

One of the more popular languages I ever designed and implemented. Eventually begat Befunge-97, Funge-98, and Wierd, and doubtlessly influenced many others. Cited in the New Hacker's Dictionary.
```
 v    <
>?"/",^
 >"\",^
```
Implementations:
- bef (reference interpreter, written in C)
- befia (interpreter, written in x86 assembly)
- many others I'm sure...
SMETANA (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 this 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.
```
Implementations:
- smetana.pl (reference interpreter, written in Perl)
Wierd (1997)
(with John Colagioia and Ben Olmstead)

Wierd is a language, inspired somewhat by Befunge-93, where instructions are not determined by the symbols in a sequence of symbols, but by the bends in a sequence of symbols.
```
*
 *
  *
   *
  * *  **
 *   ** *
  **     **
    *      *
    *     *
    *     *
    *      *
    *     **
    *    *
    * ** *
    **  *
```
The above sample is courtesy of Milo van Handel.
Implementations:
- wierd-milo.c (interpreter, written in C)
- wierd.c (interpreter, written in C)
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.
```
  0a21646c726f77202c6f6c6c6548
, :::::::::::::::::::::::::::: ,
 )
 ==============================
F
                               O F
                               c
                               =
```
Implementations:
- rube.c (reference interpreter, written in C)
Befunge-97 (1997)

An unimplemented attempt to improve upon Befunge-93, described (fairly accurately) as "brain-damaged." This was primarily due to the fact that separate processes were specified as sharing a single stack. Quickly gave way to Funge-98.

REDGREEN (1998)

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

                                   # #
                 ......            # #
                                   #  ~                      #
                                   #######################   #
                                  %#                         #
                       . . .      T #####                    #
                                  ###   #  :                 #
                                        #                    #
                                        #  .                 #
                                        #                    #
                                        #                    #
                                        #  .                 #
                                        #                    #
                                        #                    #
>>>>>>>>>>>>>>>##<<<<<<<<<<<<<<<<<############################
                                                %
                                                T

Implementations:

redgreen.alp (reference description, written in ALPACA)

ALPACA (1998)

ALPACA is a meta-language for describing cellular automata. It is an acronym for A Language for Programming Arbitrary Cellular Automata. This is not quite accurate, as the automata are not in fact arbitrary, but it's a nice acronym.

ALPACA is one of the few of my languages in which I've actually implemented other languages (or, well, cellular automata — close enough). These are, namely, REDGREEN, Braktif, Circute, and Jaccia and Jacciata.
```
/* 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.
```
Implementations:
- alpaca.pl (reference compiler to Perl, written in Perl)
Funge-98 (1998)
(with input from many, many others)

Culmination of attempts to improve upon Befunge. Seemingly everything except the kitchen sink was stuffed into it somehow.
```
>>#v?v
^,A' <
 ^ C'
    T
 ^ <<
    G
    '
```
Implementations:
- fbbi (Flaming Bovine Befunge Interpreter) (interpreter, written in C)
- mtbi (Magus Technica Befunge Interpreter) (interpreter, written in C)
- many others I'm sure...
ETHEL (1998)

A language specifically for expressing quantity surveying (materials estimating) formula and procedures, designed for Star Building Materials.
MDPN (1999)

MDPN is an acronym for Multi-Directional Pattern Notation. It 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 (1999)

Shelta is an extremely minimal Forth-like language with barely any semantics; it relies on inline machine code to be considered anywhere near Turing-Complete. 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
```
Implementations:
- shelta (reference compiler to x86 executable, written in x86 assembly)
- sheltas (compiler to x86 executable, written in Shelta)
Bear Food (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.

Implementations:
- bearfood.pl (reference interpreter, written in Perl)
Sally (2000)

Sally is a neat little functional language with minimal syntax, strict typing, and some interesting parameter rules.
```
stdlib
int factorial int if $1 mul $1 factorial sub $1 1 1
int main int factorial $1
```
Implementations:
- sally2c (reference compiler to C, written in C)
SMITH (2000)

SMITH is a self-modifying assembly-like language which completely lacks any kind of jump instructions whatsoever. Despite this handicap, it appears to be Turing-complete.
```
MOV R0, 10
MOV R2, 0
SUB R2, 1
MOV R[R0], "Hello, world!"
MOV TTY, R[R0]
SUB R0, R2
MOV R1, R0
SUB R1, 23
NOT R1
NOT R1
MUL R1, 8
COR +1, -7, R1
```
Implementations:
- smith.pl (reference interpreter, written in Perl)
Tamerlane (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 (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!"! }
```
Implementations:
- squishy2k.pl (reference interpreter, written in Perl)
noit o' mnain worb (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#####   #
#####   #  ########
        #       >!#
        #v#########
        # #
        ###
```
Implementations:
- worb.pl (reference interpreter, written in Perl)
Hunter (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#         #
#+######         #
#     !#         #
##################
*12+>3
*21+>3
```
Implementations:
- hunter.pl (reference interpreter, written in Perl)
'N-DCNC (2000)

'N-DCNC was my entry for the 2000 Esoteric Awards ('Essies') It is based on a conspiracy theory involving UFOs and a 5-member boy band, or something.
```
4*5+2/2,(9*`c)+1
```
Implementations:
- ndcnc.bf (interpreter (broken), written in Befunge-93)
- ndcnc.pl (reference interpreter, written in Perl)
beta-Juliet and Portia (2001)

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.
```
event WindowSwitchBroken;
event MotionDetectorTriggered;

event SystemArmed;
event SystemDisarmed;

event Alarm,
 caused after WindowSwitchBroken      when SystemArmed > SystemDisarmed,
 caused after MotionDetectorTriggered when SystemArmed > SystemDisarmed,
 causes Alarm.
```
Implementations:
- bj.pl (reference interpreter, written in Perl)

Strelnokoff (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 (arrays) has never yet been implemented.

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

REM HELLO WORLD IN STRELNOKOFF
REM CHRIS PRESSEY MARCH 24 2001
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

Implementations:

strelnokoff.pl (reference interpreter, written in Perl)

ILLGOL (2001) (also Illgola-2, Illberon, Illgol##)

Joke languages which parody the sort of language designed by the sheer fact that a compiler for it has been hacked together.
```
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);
FIN
```
Implementations:
- ILLGOL.COM (reference compiler to x86 executable, written in C)
Opus-2 (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 (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.
```
(      )  (      )
  #            #
  # ###    ### #
  #            #

    ###   ###

    #      #
    #      #
    #    ###
```
Implementations:
- ypsilax.pl (reference interpreter, written in Perl)

Version (2001)

Version is an imperative programming language that uses ignorance-spaces for flow control; the implementation ignores instructions which matches the current ignorance pattern.

START: ROOM = "VALLEY|BROOK|GLADE"
CONT: IGNORE = ROOM
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."
ROOM: OUTPUT = EOL
ROOM: DIR = CHOP INPUT
ROOM: IGNORE = DIR
ROOM: MASK = "VAPOURS"
N: CAT = "|N"
S: CAT = "|S"
E: CAT = "|E"
W: CAT = "|W"
ROOM: IGNORE = MASK
N: ROOM = "VALLEY|BROOK|GLADE"
S: ROOM = "HILL|BROOK|GLADE"
E: ROOM = "VALLEY|HILL|BROOK"
W: ROOM = "VALLEY|HILL|GLADE"
LASTLY: IGNORE = "START"

Implementations:

version.pl (reference interpreter, written in Perl)

Sbeezg (2002)

Sbeezg is a syntactically very simple language that attempts to take the single-assignment concept to a logical extreme.
```
f={a,b|i=*is;s=*pred;p=*print;g=p(*beer);h=s(a);
   ln={x,m|z=x|x};lg={y,n|q=n(y,n)|y};j=i(h,0,ln,lg);
   k=j(h,b)|a};l=f(99,f)
```
Implementations:
- sbeezg.erl (reference interpreter, written in Erlang)
GraNoLa/M (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.
```
a=^sajalom(b=^#d(c=^bimodang(^a))d(e=^#cthulhu(f=^uwaming(g=^ubewic()))))
```
Implementations:
- granolam.erl (reference interpreter, written in Erlang)
Kangaroo Iceberg (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.

Implementations:
- kiceberg (reference interpreter (incomplete), written in C)
2Iota (2004)

2Iota is the successor to beta-Juliet and Portia; it is a second attempt at making a minimal event-oriented language, in the sense that the only state is the order in which events have happened. 2iota, unlike beta-Juliet and Portia, is actually Turing-complete. It also has a more faithful reference implementation that can wait for any specified durations before firing new events.
```
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.
```
Implementations:
- 2iota (reference interpreter, written in C)
Braktif (2005)

Braktif is a cellular automaton modelled closely after the Brainfuck programming language.
```
                            *
                       <<*[--]*
000000000000000000  *[-----  --]
-----------------d-i--         --------
```
Implementations:
- braktif.alp (reference description, written in ALPACA)

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==
 =   =     = =   = =   = =     =   =
 =====     = ===== ===== =     =====
   =       =   =     =   =       =
   =============     =============

Implementations:

circute.alp (reference description, written in ALPACA)

Beturing (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)
$bbab$
# C(0, 0)
# @(0, 0)
 . . . . . .
*v*<*<*<*>*v
aa .ab . .aa .
>/*>./*^*^</*v
bb .ba . .bb .
>/*^./*^*^</*v
$$ .$$ . .$$ .
>/*^</*>*^.@*v
         . . .
*@      *^*<*<
```
Implementations:
- beturing.lua (reference interpreter, written in Lua)
Bhuna (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.
```
Fib = ^ X {
  if X < 2 return 1 else
  return Fib(X - 1) + Fib(X - 2)
}
Print Fib(32), EoL
```
Implementations:
- bhuna (reference interpreter, written in C)
Xigxag (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.)
```
><<
```
```
><<
<<>><
<><<<<>>
<<<<>><><><<><<<><<<>
...
```
Implementations:
- xigxag.pl (reference interpreter, written in Perl)
Hev (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!
```
71+8*27,19,29*99,6,37,7,61,47
```
Implementations:
- Hev.hs (reference interpreter, written in Haskell)
Cabra (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).
```
(SET 1 + SET 2) * IFSET 1 THEN (IFSET 2 THEN SET 3 ELSE SKIP) ELSE SKIP
```
Implementations:
- cabra.hs (reference interpreter, written in Haskell)
You are Reading the Name of this Esolang (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.
```
001000000[0010000000111001000011]11100100001[0]
```
Emmental (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.
```
;#58#126#63#36!;#46#36#!;#0#1!;#0#2!;#0#3!;#0#4!;#0#5!;#0#6!;#0#7!#0#33#111#108#108#101#72$
```
Implementations:
- emmental.hs (reference interpreter, written in Haskell)

Didigm (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.

3333333333333
3002300230073
3111311132113
3311321131573
3111311131333
3333333333333
=F3
,
=F1
111111111111111
111111131111111
111111111111574
111111111111333
311111111111023
111111111111113

Iphigeneia (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.
```
var a in a :=
    let c = 5 in let d = 1 in
        loop
	    if c = 0 then
	        d
	    else
	        let d = d * c in
	            let c = c - 1 in
		        repeat
```
Implementations:
- iphi (reference interpreter, written in Haskell)
Mascarpone (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.
```
v['[/''/']v*]v*'?<^v[/?/<]v*'S<[>!]v*'F<^[]v*1'p'kS'kF.
```
Implementations:
- mascarpone.hs (reference interpreter, written in Haskell)
Larabee (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)))))))))
```
Implementations:
- larabee.scm (reference interpreter, written in Scheme)

Arboretuum (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)         ))
  )
)

Implementations:

forest-rewriter.scm (reference interpreter, written in Scheme)

Treacle (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.
```
(x this (x descends (x to (x the (x right (y 1 2))))))
```
```
(
  (:i (? t (x (? i *) (? j *)))) -> (t : (xx (? j *) (? i *)))))
  (:i (? p right))               -> (p : left)
)
```
```
(xx (xx (xx (xx (xx (y 1 2) left) the) to) descends) this)
```
Implementations:
- treacle.scm (reference interpreter, written in Scheme)
Quylthulg (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
```
Implementations:
- Qlzqqlzuup, the Lord of Flesh (reference interpreter, written in Haskell)

Unlikely (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);
    a.next = c;
    p = new Print(Passive,Chain);
    p.next = a;
    goto p.continue(accumulator);
  }
}

Implementations:

Coldwater (static analyzer, written in Python)

Jaccia and Jacciata (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.
```
#######S###
#:::::::::#
#:###:###:#
#:#:#:::#:#
#:#:#:#:###
#:::#:#:#:#
#####:#:#:#
#:#:::#:::#
#:#:###:###
#:::#:::::#
#########F#
```
```
#######S###
#    :::  #
# ###:### #
# # #:::# #
# # # #:###
#   # #:# #
##### #:# #
# #   #:  #
# # ###:###
#   #  :::#
#########F#
```
Implementations:
- jaccia.alp (reference description, written in ALPACA)
- jacciata.alp (reference description, written in ALPACA)
Pixley (2009)

Pixley is a strict subset of R⁵RS Scheme (or, if you prefer, R⁴RS Scheme), supporting four datatypes (boolean, cons cell, function, and symbol) and 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 407 instances of 53 unique symbols in 672 cons cells.)
```
(let* ((a (lambda (x y) (cons x y)))) (a (quote foo) (quote ())))
```
Implementations:
- pixley.pix (reference interpreter, written in Pixley)
Dieter (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
  begin
    return (bestow beefy x)
  end
end.
```
Implementations:
- dieter.py (reference typechecker, written in Python)
Etcha (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.
```
>+++>+++>+++>+++>[+]>>>>+
```
```
#####
   #
   #
 ###
```
Implementations:
- tc.catseye.etcha (interpreter, written in Java)
ZOWIE (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.
```
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
```
Implementations:
- zowie.py (interpreter, written in Python)
Okapi (2010)

Okapi is a language I designed as a present for my true love. 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.

Implementations:
- okapi.py (interpreter, written in Python)
Burro (2010)

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.
```
!--(--(--(!>/
  >>--(+<<+++++++>/+++>+++++>)<
>)/
  >>--(+++>+++++>/+++<<<<<+++>)<
>)/
  >>--(+++>+>/+<<+++>)<
>)<
```
Implementations:
- Burro.lhs (reference interpreter, written in Haskell)

Whothm (2010)

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

r := (0, 0, 1, 2);
s := (0, 0, 1, 2);
XOR := TF/FT;

begin
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;
end

Implementations:

JWhothm (interpreter, written in Java)

Eightebed (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.
```
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;
}
```
Implementations:
- 8ebed2.py (reference compiler to C, written in Python)
Oozlybub and Murphy (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 (2010)

Gemooy is really just a two-dimensional bagatelle of sorts; it combines features from 2-ill and Etcha, and adds self-modification. It came about when I noticed the tape-related semantics of 2-ill were essentially the same as those of BitChanger.

Information on this language is only available on the Gemooy article on the esowiki for now.
```
%### # ###   # #   ### # ###   # #   ### # ###@

   @    @#         @
  @      @          @
 @@
@                   @
    $         @# # @
             #      @
            #
       @   @
                    @
         
       @
      #
     #
    @
    @    @
     @# @
@        @
         @
  @     @#@
```
Nhohnhehr (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.
```
+------+
|    /}|
|&#/$?@|
|  / \&|
|      |
| {    |
|\\    |
+------+
```
Implementations:
- nhohnhehr.py (interpreter, written in Python)
Kelxquoia (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.

Information on this language is only available on the Kelxquoia article on the esowiki for now.
```
 >+-0 0*+-1*/+-?*-R*- *+-?*-R*-?*/v
 RRRRRRRRRRRRRRRRRRRR RRRRRRRRRRRRR
$>+-0 0*+-1*/+-?*-R*- *+-?*-R*-?*/v
    ' '   '       '  '      '   
             '         '  '     
 ^      /*?-*P-*?-+*?-*P-* -+     <
 P      PPPPPPPPPPPPPPPPPP PP     P
 ^      /*?-*P-*?-+*?-*P-* -+     <

 00 00 00 00
```
Wunnel (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.

Information on this language is only available on the Wunnel article on the esowiki for now.
```
          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        o     o
o              o

         o
o oooooooo     o
         o
         o
         o

         o    oooo o
```
Implementations:
- WunnelState.java (interpreter, written in Java)
Pail (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.
```
**[*let [
     [cadrg *[#fst ##*[#snd #g]]]
     **[*let [
          [g [x [y z]]]
          ***cadrg
       ]]
  ]]
```
Implementations:
- Pail.lhs (reference interpreter, written in Haskell)
Xoomonk (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 is also a bit of an experiment in test-driven language design. The specification includes examples in the format of Falderal tests, which were written while the language was being designed and could be used to compare an implementation (when one is written) against the spec.
```
l := $loop*
counter := 5
l.do := {
  y := x
  print ^.counter
  o := $sub*
  o.x := ^.counter
  o.y := 1
  ^.counter := o.result
  continue := o.result
}
```
Flobnar (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 :   > *
  -|    <
  11
```
Implementations:
- Flobnar.hs (reference interpreter, written in Haskell)

Madison (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
proof
  case X = leaf
    reflect(reflect(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]
qed

Implementations of Other Languages (19)

Of course, I haven't just designed languages, I've also implemented other designer's concepts.

PL-{GOTO}.NET (PL-{GOTO} compiler)

I've been idly fascinated by the primitive recursive example programming language PL-{GOTO} from Brainerd and Landweber's Theory of Computation for some time. And for some reason I will never be able to explain, I had the craving to implement a compiler which could produce .NET executables by generating MSIL assembly language. And putting those two together — well, that struck me as a respectably absurd match, so that's what I did. The compiler is written in Haskell and uses Parsec for parsing PL-{GOTO} programs; I tried to keep the grammar true to what is presented in the book, not refactoring it to be LL(1), and keeping the ← symbol for assignment.
muriel.pl (Muriel interpreter)

This is an interpeter, written in Perl, for Matthew Westcott's quine-based language Muriel. It was probably the first full implementation of that language.
pibfi (Brainfuck interpreter)

In contrast to all the ultra-minimal Brainfuck interpreters and compilers out there, I figured I should write a monster: the Platonic Ideal BrainFuck Interpreter. Written in Erlang, it contains just about every feature under the sun, including the kitchen sink. I sort of lost interest when I was adding profiling and discovered there were several different extant reckonings of a "number of instructions executed" metric for Brainfuck. I guess it was that point that made me recognize just how silly this project was...
sf2tab (Smallfuck compiler)

Based on the observation that Smallfuck, lacking the (assumed-)infinite tape of Brainfuck, can only express finite-state automata, I wrote a little program in C to compile Smallfuck programs to (generally gigantic) lookup-tables.
stringie.c (Underload interpreter)

Seeing that there was no non-pathological implementation of Alex Smith's beautiful Underload language in C, I undertook that project one evening. The result is one of the most pedantic and boring Underload interpreters known to man. Perhaps the most interesting property of it is its name, stringie, which was an accident.

The C source can be found in stringie.c in the Esoteric Files Archive.
tc.catseye.yoob.ale (Ale interpreter)

Implemented as part of the yoob project.
tc.catseye.yoob.backflip (BackFlip interpreter)

Implemented as part of the yoob project.
tc.catseye.yoob.backflip (BackFlip interpreter)

Implemented as part of the yoob project.
tc.catseye.yoob.black (Black interpreter)

Implemented as part of the yoob project.
tc.catseye.yoob.lnusp (LNUSP interpreter)

Implemented as part of the yoob project.
tc.catseye.yoob.onela (1L_a interpreter)

Implemented as part of the yoob project.
tc.catseye.yoob.onelaoi (1L_AOI interpreter)

Implemented as part of the yoob project.
tc.catseye.yoob.path (PATH interpreter)

Implemented as part of the yoob project.
tc.catseye.yoob.qdeql (Qdeql interpreter)

Implemented as part of the yoob project.
tc.catseye.yoob.sceql (Sceql interpreter)

Implemented as part of the yoob project.
tc.catseye.yoob.snusp (SNUSP interpreter)

Implemented as part of the yoob project.
tc.catseye.yoob.twoill (2-ill interpreter)

Implemented as part of the yoob project.
tc.catseye.yoob.twol (2L interpreter)

Implemented as part of the yoob project.
valgol.erl (VALGOL parser)

A parser, in Erlang, for the Lesser-Known Language VALGOL. It, like, totally demonstrates how a parser can be written so that a separate scanner is totally not needed. Bitchen!