Programming Languages

Some of these languages have interpreters that can run online, in your web browser. By selecting sample programs and watching them run, you can gain an appreciation of how the language works; by composing your own programs, you can gain an even better appreciation.

Note that the precise distinctions between a Programming Language, a Programming Language Family, and an Automaton are debatable, and entries may be categorized somewhat arbitrarily.

by Cat's Eye Technologies

  • Befunge-93 (in Java and ANSI C) (Sep 1993)

    Try it (Java Web Start)

    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.

  • Etcha (in Java and Java and Javascript) (Oct 4, 2009)

    Try it Online Try it (Java Web Start)

    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.

  • Gemooy (in Java and Javascript) (Dec 2, 2010)

    Try it Online Try it (Java Web Start)

    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.

  • Matchbox (in Javascript) (Feb 2015)

    Try it Online

    A toy language for a toy race-condition finder.

  • Pixley (in Pifxley and Pixley and ANSI C and Pixley and Haskell and Javascript) (May 2009)

    Try it Online

    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.)

  • Shelta (in NASM Assembler and Shelta) (ca Jul 1999)

    Try it Online

    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!

  • Whothm (in Java) (Jun 28, 2010)

    Try it (Java Web Start)

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

  • Wunnel (in Java and Javascript) (Feb 13, 2011)

    Try it Online Try it (Java Web Start)

    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.

  • Ypsilax (in Perl and Java) (Aug 2001)

    Try it (Java Web Start)

    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.

  • ZOWIE (in Python) (Dec 29, 2009)

    Try it Online

    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.

  • 'N-DCNC (in Perl and Befunge-93) (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.

  • ALPACA (in Python and Perl) (1998)

    ALPACA is a meta-language for describing cellular automata.

  • Apple Befunge (in Applesoft BASIC) (Jul 3, 2000)

    Apple Befunge is a variant of Befunge for the Apple ][+ which resembles Befunge-93, with some extra Befunge-96-esque instructions and some Apple ][+-specific instructions.

  • Arboretuum (in Scheme) (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.

  • Befunge-98 (in ANSI C)

    Befunge-98 is the two-dimensional member of the Funge-98 language family.

  • Beturing (in Lua) (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.

  • Bhuna (in C99) (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.

  • Burro (in Haskell) (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.

  • Cabra (in Haskell) (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).

  • Carriage (in Haskell) (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.

  • Cfluviurrh (in ANSI C) (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.

  • Crabwell (in Pixley)

    Crabwell is a variant of Pixley which allows values to be bound to, not just symbols, but arbitrary S-expressions. (Thus it is not a subset of Scheme.)

  • Dieter (in Python) (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.

  • Eightebed (in Python) (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.

  • Emmental (in Haskell) (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.

  • Exanoke (in Python) (ca Jul 2012)

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

  • Flobnar (in Haskell) (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.

  • GraNoLa/M (in Erlang) (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.

  • HUNTER (in Perl) (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...

  • Hev (in Haskell) (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!

  • ILLGOL (in ANSI C) (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.

  • Illberon (in Perl) (May 2000)

    Illberon is another language in the ILLGOL series of parodies; in this case, the successor to Illgola-2. It consists solely of a preprocessor, i3pp.pl, and release notes in the form of a comic strip starring Release Notes Girl and Captain Compiler.

  • Illgola-2 (in ANSI C) (ca Apr 2000)

    Illgola-2 is the successor to ILLGOL. It, too, parodies the sort of language that exists solely because there's some program that's been written that takes a file in sort of that format as input and spits out vaguely related code as output.

    Illgola-2 introduces a preprocessor i2pp.pl, and Release Notes Girl, to ILLGOL.

  • Iphigeneia (in Haskell) (Nov 20, 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.

  • Jolverine (in Python) (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.

  • 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.

  • Larabee (in Scheme) (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.

  • MDPN (1999)

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

  • 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.

  • Maentwrog (in ANSI C) (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.

  • Mascarpone (in Haskell) (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.

  • 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.

  • Nhohnhehr (in Python) (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.

  • Okapi (in Python) (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.

  • 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.

  • Open Sores Illgol## (in ANSI C) (ca Jun 2000)

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

  • P-Normal Pixley

    P-Normal Pixley is a simplified version of Pixley where let* can only bind one identifer to one value and cond can only make one test, like Scheme's if.

  • Pail (in Haskell) (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.

  • Pifxley (in Pifxley)

    Pifxley is Pixley with an if instead of a cond.

  • Quylthulg (in Haskell) (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.

  • SICKBAY (in Python) (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.)

  • SITU-SOL (in 6502 machine code) (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.

  • SMITH (in Perl) (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.

  • Sally (in ANSI C) (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.

  • 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.

  • Sbeezg (in Erlang) (2002)

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

  • Squishy2K (in Perl) (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.

  • Strelnokoff (in Perl) (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.

  • 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.

  • Treacle (in Scheme) (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.

  • 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.

  • Unlikely (in Python) (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.

  • Velo (in Ruby and Lua) (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.

  • Version (in Perl) (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.

  • Xoomonk (in Python) (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.

  • Yolk (in Python and Yolk) (Aug 24, 2014)

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

  • 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.

  • Zame (Jan 2009)

    Zame is an automaton which uses the solution of a maze to generate an Etcha program which draws a new maze, then the process repeats. An open question is to find a maze for which this process repeats indefinitely.

    Information on this language is only available on the Esowiki for now.

  • beta-Juliet (in C99 and Perl) (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.

implemented by Cat's Eye Technologies

by Our Valued Partners

(Illustration)

Commentary

There are two things about programming languages that every programmer should know.

One is that a programming language is an abstract entity. Much like Beethoven's 7th Symphony, it just doesn't exist in the same sense a tree or a street exists. Sure, there are recordings of performances of Beethoven's 7th, and there are transcriptions of Beethoven's 7th, but these are only attempts to capture the symphony, they aren't the symphony itself.

Simlarly, take a programming language, like Java. There are implementations of Java — there's Sun's javac, for instance, but there are also IBM's jikes and GNU's gcj. And there are specifications of Java — the official spec is from Sun (much like the official version of Beethoven's 7th issued straight from Ludwig von's pen,) but there are countless books on learning Java that also explain the features and rules of Java, in their own words.

In short, languages aren't the tools that implement them or the documents that describe them.

Ponder this fact, for fully appreciating it will mean you'll be able to save yourself from appearing ignorant by referring to how this or that language is "not fast enough" or "widely available."

The other thing that every programmer should know about programming languages is that it's very important to choose the right programming language for every software project. That's why you'll always choose C++ no matter what the software project is.