From Esolang
Jump to navigation Jump to search

Hello! I'm an a esolang designer and enthusiast. I am the inventor of sixteen languages, with a few more ideas floating around in my head.

My Languages

These are languages (or language subsets, in the case of CJam-Flavored Underload) that I have invented.

  • Z, a tape-based language using the characters "z", "Z", space, and newline.
  • InterpretMe, a joke language that can't do anything but interpret itself.
  • MiniPig, a tarpit stack language that may or may not be TC.
  • ObCode, a language consisting of only parentheses that isn't Lispy enough.
  • Minscode, a (probably Turing-incomplete) language based on a misunderstood notion of Minsky machines.
  • Betaload, an extension of Underload that supports input and "environments".
  • Minipy, Python with shorter builtins.
  • Check, a language which can switch between being 2D and 1D.
  • CJam-Flavored Underload, a dialect of Underload that makes it a subset of CJam.
  • Foam, a Forth with unreadability - and a huge amount of built-ins - as its goal. It arguably succeeds in the former but fails in the latter. I intended to keep updating the language as I kept getting ideas for builtins, but the language promptly died.
  • Dreaderef, a language that tries to:
    • Force you to use self-modification,
    • Expose all of the interpreter state as editable data, and
    • Not be too hard to program in.
  • Momema, a boring imperative language designed to be slightly easier than Dreaderef (due to not requiring self-modification) while still being very similar to program in.
  • Metafractran, a dialect of Fractran where program data is determined from a file's path rather than its contents.
  • Flurry, a functional variant of Brain-Flak.
  • Full Stack, a strange self-modifying language of unknown computational class.
  • Graverage, a geometric automaton that's probably not Turing-complete.
  • Imma, a further development of the ideas in Dreaderef.
  • Melanjan, a high-performance Aubergine derivative.
  • CZTOLJDEFGKJSKI calculus, a silly Lazy K derivative.

My Favorite Languages

These are some of my favorite esolangs.

  • brainfuck, for its elegant distillation of structured imperative programming into a tiny language. I do have some issue with the legacy it has created; you can read my thoughts on it here.
  • Underload, because, while initially seeming imperative, it actually requires you to think functionally to program in it; because it is slightly easier to program in than brainfuck; and because it is easier to implement than brainfuck (it can be done without requiring parsing beforehand – example).
  • ///, for its brutal simplicity (self-modifying replace + escape characters) and the fact that it's Turing-complete and I still don't understand why.
  • Mascarpone, for its unique semantics (a program can take the Mascarpone interpreter, push it to the stack, change the interpretation of one character, and then install that as the new interpreter) and relative usability.
  • CJam, for its usability (the docs are amazing, and it doesn't have a custom code page), reliability, and clever design for a golfing language.
  • Dependently Typed Binary Lambda Calculus, out of pure joy that such a thing exists and that someone bothered to write an implementation.


These are languages that I am currently in the process of designing.

  • A language that allows for the precedence of operators to be modified at runtime, known as New Precedence.
  • A language with tree-based memory, known as Link (I have actually written at least three different unfinished implementations of this language in an attempt to learn various practical programming languages).
  • A self-modifying language with tree-based code/memory, known as Zelda.
  • An object oriented language where the class structure is given in 1D but the method bodies are given in 2D, known as Disorientation.
  • A self-modifying language based on repeated application of rewriting rules (passes) that can change at runtime, known as Impasse.
  • A language that takes fluent interfaces and the inner-platform effect to its logical conclusion, known as considered().harmful().
  • A language based on repeated application of pattern-matching rules on trees, known as Trewrite.
  • A language that works like a spreadsheet but with breadth-first recursive updates. I need an interesting name for this!
  • A language where programs are directed graphs where each node has several bit queues as input, performs some function on those queues, and outputs to the queues of the nodes it connects to. This language is known as FuQ (pronounced as "fuh-queue" or "fu-ckyou").
  • A language with a dynamically-typed stack-based imperative two-dimensional sublanguage (capable of reading input) that serves to construct subprograms in an abstract functional sublanguage with a Haskell-like type system (capable of writing output), known as shIƒt.

Language Ideas

These are vague language ideas that are currently floating around in my head but that aren't fully formed yet (i.e. I couldn't show you a program in them). I welcome any ideas for these languages!

  • A 2D language where control flow is controlled by the spread of a wildfire, known as Synge.
  • A language based on nomadic monads (or monadic nomads) that wander around a two-dimensional grid.
  • A golfier dialect of Binary lambda calculus.
  • A Lispier dialect of ObCode.
  • A language similar to Snowflake but more elegant in its execution model (in particular, it should not rely on the rather arbitrary construction of numbers that the language uses to encode instructions).
  • A more golfy regex flavor, known as PPCGgex (named after, a codegolf site that is commonly known as PPCG by its users).
  • A language where any substring of length > 1 repeated > 1 times is extrapolated to a loop (perhaps known as Extrapalot).


Other languages that I have written implementations for: