Language-creation has become a popular activity on CGCC. A decent portion of answers, especially answers, are written in languages invented by the community. These are also languages that might be unfamiliar to this site's wider viewing audience.

What languages (esoteric, golfing, or not) have been created by our users? For each language, please include some of the following details:

  • Language name and creator
  • Links to resources, like documentation and interpreter
  • A brief description of the language, some of its main concepts and features, and its history

List of languages

function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=meta.codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=meta.codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var a=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(a="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var r=a.match(SCORE_REG);r?e.push({user:getAuthorName(s),size:+r[2],language:r[1],link:s.share_link}):console.log(a)}),e.sort(function(e,s){var a=e.size,r=s.size;return a-r});var s={},a=1,r=null,n=1;e.forEach(function(e){e.size!=r&&(n=a),r=e.size,++a;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;o=jQuery("<a>"+o+"</a>").text(),s[o]=s[o]||{lang:e.language,lang_raw:o,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang_raw.toLowerCase()>s.lang_raw.toLowerCase()?1:e.lang_raw.toLowerCase()<s.lang_raw.toLowerCase()?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var QUESTION_ID=6918,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",OVERRIDE_USER=2867,answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n]+)\s*<\/h\d>/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=language-list><h2>Languages by CGCC Users</h2><table class=language-list><thead><tr><td>Language<td>User<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}<td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td><a href={{LINK}}>Link</a></table>

  • 20
    \$\begingroup\$ Todo: Add 2D matching languages and every language Calvin makes up for golf questions \$\endgroup\$
    – Sp3000
    Commented Sep 9, 2015 at 2:45
  • \$\begingroup\$ Do languages whose only non-proprietary interpreters were created by PPCG users count? \$\endgroup\$
    – bmarks
    Commented Sep 12, 2015 at 17:01
  • \$\begingroup\$ The title is somewhat misleading. Do general purpose languages not related to golfing still count when they have been created by PPCG users? The title suggests yes, but mostly (and naturally) the answers relate to golfing. \$\endgroup\$
    – user42643
    Commented Sep 12, 2015 at 21:59
  • 1
    \$\begingroup\$ @minxomat This question is open to all languages created by PPCG users. \$\endgroup\$
    – PhiNotPi
    Commented Sep 13, 2015 at 4:36
  • \$\begingroup\$ @bmarks I say you could go ahead and post it, specifically mentioning the interpreter. \$\endgroup\$
    – PhiNotPi
    Commented Sep 13, 2015 at 4:42
  • 2
    \$\begingroup\$ @PhiNotPi A suggestion: Implement a snippet in your question to list the languages. This site is quite long. \$\endgroup\$
    – user42643
    Commented Sep 14, 2015 at 6:27
  • 2
    \$\begingroup\$ @minxomat Done. \$\endgroup\$
    – Alex A.
    Commented Sep 21, 2015 at 19:05
  • 1
    \$\begingroup\$ A quick note about the snippet: User means the person who posted about it here, not necessarily the user who created the language. Example: I did not create Ostrich, I merely posted it here. \$\endgroup\$
    – Alex A.
    Commented Sep 21, 2015 at 19:12
  • 2
    \$\begingroup\$ @AlexA. Maybe we could add a formatting guide, and suggest that the inventor be added in the header? \$\endgroup\$
    – Beta Decay
    Commented Sep 25, 2015 at 17:33
  • 1
    \$\begingroup\$ @BetaDecay Yeah I had thought about that. Language name, creator, and year. Up to Phi though. \$\endgroup\$
    – Alex A.
    Commented Sep 25, 2015 at 18:32
  • \$\begingroup\$ @Adnan 05AB1E should be on here. \$\endgroup\$ Commented Jan 19, 2017 at 21:19
  • \$\begingroup\$ Can I post mine here if I have several alternative names? \$\endgroup\$
    – user100411
    Commented Oct 2, 2021 at 8:43

102 Answers 102



Hexagony was created by me, Martin Büttner, in September 2015.

As far as I know it is the first two-dimensional programming language which operates on a hexagonal grid (instead of the usual rectangular grid). To make matters worse, opposite edges of the grid wrap around, making the topology of the source code a weird twisted torus. To make matters worst, the memory model is also a hexagonal grid, where each edge holds an integer value. Considering these things, I think the name (being a portmanteau of "hexagon" and "agony") is completely justified.

My prime checker and the Hexagony self-unfolder contain fairly detailed explanations of the language's quirks and show how to program in it.

  • 22
    \$\begingroup\$ +1. This language hurts my brain. \$\endgroup\$ Commented Sep 16, 2015 at 19:00
  • \$\begingroup\$ Martin, how long did it take you to create/learn? \$\endgroup\$
    – mbomb007
    Commented Sep 25, 2015 at 19:03
  • 2
    \$\begingroup\$ @mbomb007 Create: I think I designed the largest part of the spec over a handful of days and then implemented the ruby interpreter in half a day or so. Learn: well... I designed it, so I know how it works, but I'm still figuring out how to make use of these features, and how to golf them properly. \$\endgroup\$ Commented Sep 25, 2015 at 22:35
  • \$\begingroup\$ @MartinBüttner I wonder if you could easily extend/reduce your language to different shapes or dimensions. Like Pentagony, or Septagony. Maybe a 3D version... \$\endgroup\$
    – mbomb007
    Commented Sep 26, 2015 at 0:16
  • \$\begingroup\$ @MartinBüttner (Yes, I know they wouldn't wrap around the same way, if at all) \$\endgroup\$
    – mbomb007
    Commented Sep 26, 2015 at 0:33
  • 4
    \$\begingroup\$ @mbomb007 the issue is that it's not possible to construct a periodic tiling with fivefold or sevenfold rotational symmetry, so you can't just transfer the same concept to pentagons or heptagons. However, in my list of future language ideas there's the concept of using an aperiodic Penrose tiling (which has fivefold symmetry), but I need to sort out how to layout the code, and I want to tackle some simpler tilings (like triangular) first. Even for this I don't want to make them Hexagony derivatives, but would rather come up with new mechanics. \$\endgroup\$ Commented Sep 26, 2015 at 9:50
  • \$\begingroup\$ I was thinking about creating a language on triangular grid, too. I can’t wait to see yours. \$\endgroup\$
    – M L
    Commented Dec 26, 2015 at 18:57
  • \$\begingroup\$ @ML It's what I'm currently working on, but it's turning out to be quite ambitious, so there's a still a chance you can beat me to that. ;) \$\endgroup\$ Commented Dec 26, 2015 at 18:58
  • \$\begingroup\$ @MartinBüttner I doubt I’ll beat you. You are far better at programming, and I’m still trying to optimize my beeswax code. I’d like to come up with a really usable debugger for that before I start working on another project ;) \$\endgroup\$
    – M L
    Commented Dec 26, 2015 at 19:02
  • 5
    \$\begingroup\$ "Build a Befunge program to convert Hexagony code into Befunge". \$\endgroup\$
    – Joe Z.
    Commented Mar 1, 2016 at 5:04
  • \$\begingroup\$ @JoeZ. Best of luck. \$\endgroup\$ Commented Mar 1, 2016 at 8:13
  • \$\begingroup\$ @JoeZ. "Build a Hexagony program to convert Befunge code into Hexagony." \$\endgroup\$ Commented Jul 27, 2016 at 5:31
  • 1
    \$\begingroup\$ Voting to close as unclear because I got it confused with Hexagony, not Hexagony. :) \$\endgroup\$ Commented Jul 27, 2016 at 5:32
  • 1
  • 1
    \$\begingroup\$ @KevinCruijssen I did (same for Labyrinth, I think), but for some reason ever since then it's taken me weeks or months to complete new language ideas (I've actually only completed two languages since then but there's a growing backlog of other ideas that take forever to sort out). Somehow for Hexagony and Labyrinth everything just fell into place quite neatly. \$\endgroup\$ Commented Sep 2, 2016 at 13:59

Mornington Crescent

A joke language I (Timwi) created based on Mornington Crescent from I'm Sorry I Haven't a Clue. The program is executed by moving from station to station on the London Underground, starting and ending at Mornington Crescent. Martin wrote a “Hello, World!” and a primality checker in this.

Location of Mornington Crescent on the London Tube

  • 98
    \$\begingroup\$ Unfortunately, language extensions typically cost millions of pounds and require lots of digging. \$\endgroup\$
    – Comintern
    Commented Sep 20, 2015 at 3:09
  • 16
    \$\begingroup\$ @Comintern And let's not mention the execution time... \$\endgroup\$
    – mbomb007
    Commented Mar 9, 2016 at 22:39
  • \$\begingroup\$ A language fungi can be good at! youtube.com/watch?v=GwKuFREOgmo \$\endgroup\$
    – fede s.
    Commented Dec 18, 2017 at 15:43
  • \$\begingroup\$ I'll make a move to Aldgate. \$\endgroup\$
    – lyxal
    Commented Jan 27, 2020 at 4:34



Created by me and my personal favourite. This is a 2D language that uses Unicode box-drawing characters to create programs that resemble flowcharts, but the semantics are actually closer to that of a functional language than an actual flowchart. It has only five built-in operations (NAND, shift-left, less-than, function invocation and lambda expressions) and only one datatype (the arbitrary-size integer) and all the useful functions are implemented in terms of this. There is an entire library of functions for arithmetic, string handling, lists and lazy-evaluated sequences.

Example: The Factorial Function

                   ║ ! ║
                   ╙─┬─╜   ┌───╖  ╔═══╗
               ┌─────┴─────┤ > ╟──╢ 2 ║
               │           ╘═╤═╝  ╚═══╝
 ╔════╗  ┌───╖ │             │
 ║ −1 ╟──┤ + ╟─┴─┐           │
 ╚════╝  ╘═╤═╝   │           │
         ┌─┴─╖   │    ╔═══╗  │
         │ ! ║   │    ║ 1 ║  │
         ╘═╤═╝   │    ╚═╤═╝  │
           │   ┌─┴─╖  ┌─┴─╖  │
           │   │ × ╟──┤ ? ╟──┘
           │   ╘═╤═╝  ╘═╤═╝
           └─────┘      │

Another example where I actually tried to golf in this language: Render “Digital Clock Style” Numbers

  • 4
    \$\begingroup\$ Interesting language. You should create a challenge that involves golfing Funciton programs... \$\endgroup\$
    – mbomb007
    Commented Sep 9, 2015 at 18:32
  • 12
    \$\begingroup\$ Also, this is probably one of the coolest-looking languages I've ever seen. \$\endgroup\$
    – mbomb007
    Commented Sep 9, 2015 at 18:37
  • 5
    \$\begingroup\$ I glanced at the source code. This may have the most complex interpreter of any esolang out there. \$\endgroup\$
    – Ypnypn
    Commented Sep 9, 2015 at 23:42
  • 8
    \$\begingroup\$ Woah, you made this? I've seen it around on esolangs and such; never knew it was created by a fellow PPCGian ;) \$\endgroup\$
    – Doorknob
    Commented Sep 10, 2015 at 3:24
  • 2
    \$\begingroup\$ Some time ago, I clicked "random page" on Esolang and found this. Instant love. Now this is esoteric! \$\endgroup\$ Commented Sep 14, 2015 at 8:55
  • 6
    \$\begingroup\$ Won't you take me down to Funciton \$\endgroup\$ Commented Feb 16, 2016 at 9:25
  • \$\begingroup\$ I love this language, but it never displays right on mobile. \$\endgroup\$
    – DanTheMan
    Commented Sep 7, 2016 at 3:47


Pyth was created in June 2014 by me, isaacg. Other contributors to the language include PPCG users orlp, jakube and Maltysen, as well as others.

The source code for Pyth language is hosted on Github for anyone to see and contribute to.

An online compiler/executor is hosted on Heroku as an alternative way to use the language.

Pyth's primary purpose is as a code-golfing language, designed to write the shortest code possible. It is a procedural language, meaning that it is based around function calls. To reduce the overhead of each function call, all functions are in prefix notation, with fixed arity.

Pyth is written in, compiles to, and was originally closely based off of Python. This was chosen to make it easier to learn for people who already knew C-style languages. However, since its creation, Pyth code has resembled Python code less and less, as the focus has become more exclusively on golfing.

To discuss and ask questions about Pyth, visit the Pyth chat room. Annoucements of new Pyth features will also often be located there.

  • \$\begingroup\$ How is Pyth supposed to be pronounced? /paɪθ/ like the beginning of Python, or /pɪθ/ (like pit but with th instead of t)? \$\endgroup\$
    – Fatalize
    Commented Sep 15, 2015 at 9:34
  • 4
    \$\begingroup\$ @Fatalize Pyth is pronounced like the first syllable of pithy, /pɪθ/. \$\endgroup\$
    – isaacg
    Commented Sep 15, 2015 at 14:31
  • 27
    \$\begingroup\$ Meh. I think /paɪθ/ sounds better and makes more sense, since it's abbreviated Python. \$\endgroup\$
    – mbomb007
    Commented Sep 17, 2015 at 14:00
  • \$\begingroup\$ @isaacg: What's in the name? \$\endgroup\$
    – jvriesem
    Commented Sep 18, 2015 at 15:55
  • 3
    \$\begingroup\$ @jvriesem As mentioned above, it's Python but shorter, making it nice and pithy. \$\endgroup\$
    – isaacg
    Commented Sep 19, 2015 at 6:43
  • 1
    \$\begingroup\$ @isaacg: Nice! (I admit...I had to look up the definition of "pithy".) \$\endgroup\$
    – jvriesem
    Commented Sep 19, 2015 at 18:50
  • 37
    \$\begingroup\$ This program is written in Pyth, / A wonderful lang to golf wyth. / Though I will concede / It is harder to read, / Its dominance isn't a myth! \$\endgroup\$
    – DLosc
    Commented Oct 14, 2015 at 2:31
  • 8
    \$\begingroup\$ @DLosc Hi, my name is Pyth. / I'm shorter than grass that's been cut with a scythe. / (double time!) / Pyth is the solution to any crisis / and if left to its devices, / it slices; it dices; / entices, allspices. / (regular time) / Listen to these advices, / and you'll find that Pyth is / the solution that concises. / How nice is that?! \$\endgroup\$
    – mbomb007
    Commented Nov 5, 2015 at 19:23


Retina was first created by me in February 2015. I continued to improve the language occasionally, and the big 1.0 release was finally done in January 2018. There will probably be a few smaller features I will add in the future, but as of this writing I have no plans for another release that's remotely as big as what we have now.

It is a regex-based programming language which I originally just wrote to be able to use a regex in code golf challenges with as little syntactic overhead as possible. The language has come quite a long way from those humble beginnings and is now a powerful string transformation tool. I still wouldn't want anyone to use it in production, as its code-golf-oriented syntax generally leads to write-only code. That said, it's perfectly usable for writing quick throwaway scripts that don't need to be maintained, and I'm using it as an invaluable productivity tool these days.

Retina isn't nearly as terse as the top-tier golfing languages, but this is partly by design. Apart from , Retina's syntax only uses ASCII characters, and its regex syntax is no terser than that of the .NET engine itself. The reason for this is that the purpose of Retina's golfiness is to reduce the bottleneck of typing speed, not to get the absolute smallest byte count, to maximise its usefulness for quickly writing scripts to manipulate text data.

  • GitHub repository. Includes interpreter (C#), example programs and issue tracker.
  • Language documentation (on the GitHub wiki).
  • Esolangs page. It's mostly a stub. I have no plans to mirror the language documentation on esolangs, but maybe this article could be expanded a bit some day. That said, I wouldn't even consider Retina purely an esolang. It's way too useful for that. At the same time, its syntax is arcane enough that wouldn't consider it a practical production language either. So it falls somewhere in between.
  • Try it online! (by Dennis) backed by the C# interpreter.

CJam by aditsu

A stack-oriented language heavily inspired from GolfScript, first published in April 2014. It is written in Java, but a JavaScript interpreter is also available.

CJam has a fixed set of variable names - all single uppercase letters - and a variety of predefined operators that use 1 or 2 characters (using a distinct first character). Due to these and other features, it can eliminate most whitespace, which makes programs shorter (and harder to read).



Once I tried to make a golfing language that was still somewhat readable, kind of like GolfScript++. Then CJam happened. So I went the opposite direction, and made an anti-golfing language that is as unreadable as possible.

end preamble

Snowman is an esolang written in C++. Its main design goal is to be as confusing as it can possibly be, while not reaching Malbolge-level and impossible to learn.

Here's a few example programs:

  • ROT13

  • FizzBuzz


Snowman's code is much more elegant and efficient than Ostrich, it has far more documentation, and it has much more work put into it in general. This conclusively proves that I am at my best when writing bad code. Which is probably why I'm on this site in the first place.

Snowman has 8 variables1, arranged visually like this:

a b c
d   e
f g h

It has Variable operators, which are split into four categories:

  • Rotation operators rotate the values stored in certain variables. Mnemonic: they are all symbols that can be drawn with a single stroke and only straight lines. They rotate the variables you would visually expect them to; for example, the ^ operator rotates the d, b, and e variables.

  • Active variable operators toggle which variables are marked as "active," which is important later. Mnemonic: they are all symbols that contain curvy lines. Most of them toggle what you would visually expect them to as well (ex. ( toggles a and f).

    There are some special cases: ~ inverts the currently active variables (mnemonic: NOT), @ rotates the active variables clockwise (mnemonic: GolfScript's rotate operator), % reflects them across the "center" (mnemonic: % looks like an o reflected across a /), ? sets all variables to inactive (mnemonic: "forget"), and $ saves (mnemonic: $ave) and & restores the current active variables.

  • Permavar operators have to do with "permavars," which are essentially Snowman's equivalent of "normal" variables in other languages. * stores to the currently active permavar, and # restores from it. The possible permavar names are zero or more =s, then either a + or !.

  • Literals are what you expect them to be. They're simply all the rest of the characters. : ... ; is a literal block, " ... " is a literal string, and any number of digits is a literal number.

    Speaking of data types, Snowman has four of them. It has undefined, which is what all the variables are set to by default and cannot be interacted with. It has numbers, which are stored as double-precision floating points. It has blocks, which are simply strings of Snowman code. And finally, it has arrays. There is no such thing as a "string," but Snowman does have "string" operators. Strings are simply stored as arrays of ASCII codes.

And it has Letter operators. Letter operators are composed in the following way:

  • They are, as their name suggests, made of letters. They can either be two or three letters long. If they are two letters long, the first letter is lowercase; otherwise, it is uppercase.

  • The second letter's case determines whether to run the letter operator with the consume mode. If it is the opposite of the case of the first letter, it will consume its arguments, and set them to undefined. Otherwise, it will leave the arguments intact.

  • The third letter, if there is one, must be the opposite of the second letter's case.

For a full list of letter operators and more extensive documentation, see the official doc file.

I probably got a bit carried away there... but hopefully now you have an idea of how exactly the language works. (I should probably incorporate parts of this answer into the Snowman documentation itself....)

1: This is where Snowman got its name. A snowman looks somewhat like the number 8.

  • 16
    \$\begingroup\$ +1 for a tutorial where a simple description would have sufficed. \$\endgroup\$
    – Alex A.
    Commented Sep 9, 2015 at 0:48
  • 32
    \$\begingroup\$ ♪♫ Do you wanna build a language? It doesn't have to be a language. \$\endgroup\$
    – mbomb007
    Commented Sep 9, 2015 at 18:26
  • 27
    \$\begingroup\$ ♫♪ The code never bothered me anyway. \$\endgroup\$
    – Timwi
    Commented Sep 10, 2015 at 11:49
  • 31
    \$\begingroup\$ I strongly disagree: I have more than eight variables. Also, my documentation is terrible! But I do agree that I am esoteric and full of bad code. \$\endgroup\$
    – user18932
    Commented Sep 11, 2015 at 18:39
  • 14
    \$\begingroup\$ @Snowman You should create a language called Doorknob. \$\endgroup\$
    – gcampbell
    Commented Jun 4, 2016 at 15:28


A 2D language created by me (Timwi) consisting entirely of arrows (← ↖ ↑ etc., ↔ ⤡ etc.). The semantics are highly concurrent. Programming simple things is extremely laborious, both because of the limited instruction set and because of the need for thread synchronization constructs. Since most systems don’t have the necessary monoscape font for all of these arrows to line up, here’s Hello, World! in Ziim as an image:

Hello, World! in Ziim

  • 17
    \$\begingroup\$ Wow, you've made so many... and they're all so fascinating :) \$\endgroup\$
    – Beta Decay
    Commented Sep 9, 2015 at 15:59
  • 4
    \$\begingroup\$ I've seen this on esolangs before. I must say that it's as hard for me to understand as programming in Conway's Game of Life - because that's what the constructs remind me of. \$\endgroup\$
    – mbomb007
    Commented Sep 9, 2015 at 18:42


MATL /'mæt.ˌl/ is a programming language based on MATLAB and suitable for code golfing.

It was created by me, Luis Mendo, in 2015. The idea came about in the StackOverflow MATLAB/Octave chatroom in September 2015. The first version was released on December 12, 2015, after having been sandboxed and discussed for a couple of weeks.

Initially the compiler worked on MATLAB only. It was then adapted to work on Octave as well. Since January 14, 2016 an online compiler is available at the Try it Online! platform (thanks to @Dennis for providing it, and to @rayryeng for his help with the process!). Also, a MATL-specific online interpreter is available at MATL Online (thanks to @Suever for providing it!)

Language features

The MATL language is stack-oriented. Data are pushed onto and popped out of a stack. Functions may take a number of elements from the stack (usually those at the top) and push one or more outputs onto the stack. Reverse Polish (or postfix) notation is used.

To ease stack handling, values from the stack can also be copied and pasted using several clipboards. These are similar to variables in other stack-based code-golf programming languages.

The main goal in designing the language has been to keep it as close to MATLAB as possible. MATL includes functions equivalent to most commonly used MATLAB functions. It should be easy for a MATLAB user to start programming in MATL within minutes.

More information

For more information see MATL's Esolangs page. The documentation and compiler can be found in the Github repository. Here are some interesting examples that illustrate language features, and some golfing tips.

  • 3
    \$\begingroup\$ "It should be easy for a MATLAB user to start programming in MATL within minutes." Can confirm this is true. And it's probably made me better at using MATLAB effectively as well! \$\endgroup\$
    – Sundar R
    Commented Jul 14, 2018 at 14:39


Labyrinth was created by me, Martin Büttner, in August 2015.

It is two-dimensional stack-based programming language, in which programs resemble mazes. It operates on two stacks of signed arbitrary-precision integers. Control flow is determined by the layout of the maze - whenever the instruction pointer hits a junction it decides which way to take based on the top of the main stack.

Labyrinth also comes with a unique form of source code manipulation (at runtime): the four commands >^<v cyclically shift a single row or column by one cell. This mechanic was inspired by the German board game Das verrückte Labyrinth.

The language is pretty much feature complete, except that I'm still thinking about assigning some function to the unused characters [ and ]. Suggestions are very welcome!

Despite fairly simple (and usable) mechanics, the language turns out to be quite interesting to golf.

  • \$\begingroup\$ +1 because Das verrückte Labyrinth is my youngest son's favorite game. \$\endgroup\$ Commented Mar 9, 2016 at 16:39
  • \$\begingroup\$ @ThisGuy Ummm. Why not? It's not even that many. You should see some other people. \$\endgroup\$ Commented Apr 1, 2017 at 17:24
  • \$\begingroup\$ @ThisGuy None of my languages are golfing languages (maybe Retina a little, but not really, which is also the only one that's being used with any kind of regularity). The popular golfing languages are Jelly (Dennis), 05AB1E (Adnan), Pyth (isaacg) and CJam (aditsu) (there are a few others as well). \$\endgroup\$ Commented Apr 1, 2017 at 17:39
  • \$\begingroup\$ @ThisGuy Not really, no. I have a fairly long list of language ideas I still want to work on. Unfortunately, I haven't had as much time and/or the ideas are getting more ambitious and the projects take longer, so I haven't released as many since the initial "rush" of Labyrinth, Hexagony and Brian & Chuck. \$\endgroup\$ Commented Apr 1, 2017 at 17:44


Marbelous was (to my knowledge) the first language created as a collaborative effort between several PPCG users. The original idea is due to cjfaure (then known as Trimsty). It was then picked up by several other users, fleshed out and implemented. This group of users included Nathan Merrill, overactor, Sparr, trichoplax (then known as githubphagocyte), es1024, VisualMelon and myself, Martin Büttner (sorry if I forgot anyone; just let me know and I'll add you).

The name of the language is (obviously) a pun on "marbles" and "marvelous".

Marbelous is a two-dimensional language, where the code represents a vertical board of "devices", where marbles (representing byte values) fall down the board and are modified by the devices. Each cell of the board is represented by two characters. Devices are essentially functions which take input from above and produce output to the sides and below. It is also possible to define your own devices as separate boards, which makes Marbelous comparably usable (some of the original authors have written libraries, e.g. for 32-bit arithmetic).

  • 1
    \$\begingroup\$ trichoplax (then known as githubphagocyte) yoo, i was wondering where githubphagocyte went \$\endgroup\$ Commented Nov 7, 2015 at 6:09

Stack Cats

Stack Cats was created by Sp3000 and myself, Martin Ender. The original idea is from November 2015, but the language design wasn't finalised and implemented until late May/early June 2016.

The language is a rather purist exploration of reversible computing with a few extra twists. Any piece of code can be undone (provided it terminates) by mirroring it (which means reversing it and swapping out all brackets). This implies rather strict conditions on what operations are possible, and in fact almost every operation is in the language is an involution (i.e. a function which computes the identity when applied twice) and only three functions come in pairs (and these compute bijections).

Additionally, every program in Stack Cats has to be symmetric itself. This means that all programs also compute involutions on the global memory state, and that every program is essentially a very simple involution transformed into some other memory state. Nevertheless, the language is Turing-complete.

  • GitHub repository. Includes interpreter (Ruby), language specification, example programs and issue tracker.
  • Esolangs page. Largely a copy of the README.md on GitHub. Also includes a sketch of a proof of Turing-completeness.
  • EsotericIDE. Contains a C# interpreter and a debugger.
  • 4
    \$\begingroup\$ This looks like a neat structure. Instruction sequences as elements of a group and finding an operator such that one of the builtins under conjugation by it does what you want. \$\endgroup\$
    – feersum
    Commented Jun 11, 2016 at 2:34


Ostrich is a concise language designed for both golfing and (moderate) readability. It was created by Doorknob in December 2014. The most recent release, v0.7.0, occurred in June 2015. Doorknob has since ceased development of the language.

The name "Ostrich" comes from the (non-code) golf term which denotes some kind of ridiculously good score that has never been achieved.

It's a stack-based language with the ability to be used interactively via a REPL. It has some interesting syntactic differences from other golfing languages, such as backticks to denote strings. It has very incomplete documentation.

  • 17
    \$\begingroup\$ +1 for picture of ostriches :D \$\endgroup\$ Commented Sep 9, 2015 at 12:33
  • \$\begingroup\$ term no longer exists on the wikipedia page \$\endgroup\$ Commented Dec 29, 2021 at 2:42


Seriously was created by me, Mego, in November 2015, after several brainstorming sessions in The Nineteenth Byte.

Seriously is a stack-based language where every non-null byte in the code represents a command (or will eventually). Null bytes represent EOF, so they cannot be used for commands - they end code files. As such, there is no such thing as an invalid program - every sequence of bytes will do something (or nothing). In addition, there are no runtime errors - if a command gets different value types from the stack than it expects, it silently exits, and the stack is restored to its previous state.

There are 4 main data types in Seriously:

  • Numerics (ints, floats, and complex values)
  • Strings
  • Lists
  • Functions

The goal of Seriously is to be extremely terse, with each command having multiple overloads based on the contents of the stack. Many common operations are built-in:

  • Print Hello, World, the lyrics to Ninety Nine Bottles of Beer, and the program's source code (quining)
  • Primality testing
  • Calculating the nth Fibonacci number
  • The exp(x), gamma(x), and many other mathematical functions
  • ...and many more!


  • 1
    \$\begingroup\$ This is Seriously cool. :D This is the new golfing language, as far as I can see. \$\endgroup\$ Commented Nov 12, 2015 at 15:02
  • \$\begingroup\$ Why don't characters do different things depending on which type of thing they are given? \$\endgroup\$
    – wizzwizz4
    Commented Oct 10, 2017 at 6:24
  • \$\begingroup\$ @wizzwizz4 They do. For example (using C-like notation), R(int n) pushes range(1, n+1), R(list a) and R(str a) push reversed(a), and R(function f, list a) calls f using a as its stack. Not every command has multiple overloads yet, because the language is still in development. \$\endgroup\$
    – user45941
    Commented Oct 10, 2017 at 9:47


This language, invented by me (Timwi), was intended for codegolf; it’s like Golfscript, but uses Chinese characters for the instructions and Korean characters for literal strings/numbers. Most people don’t like it because most people score by bytes, not characters, and so GolfScript/CJam/Pyth still tend to win.

Example: Hello, World!


Another example: Love calculation

  • 3
    \$\begingroup\$ I would guess that "most people don't like it" comes more from "most people can't read (and write) chinese and korean characters" than from its byte-counted disadvantage. \$\endgroup\$ Commented Nov 15, 2015 at 19:34
  • \$\begingroup\$ @PaŭloEbermann: Well nor can I, that’s why I created Esoteric IDE... but somehow people don’t like that either :) \$\endgroup\$
    – Timwi
    Commented Nov 18, 2015 at 14:49
  • 3
    \$\begingroup\$ How many times has someone who can read Korean and Chinese alphabets told you you've ended up spelling out an insult? \$\endgroup\$
    – user43106
    Commented Mar 1, 2016 at 14:34
  • 3
    \$\begingroup\$ @Texenox: None yet. For the Chinese characters, I selected characters whose meaning is actually somewhat related to the operation, so this is unlikely. For the Korean, the encoding is based on the bitwise Unicode value, so once again, it’s unlikely to happen as there are over 11,000 Hangul syllables. \$\endgroup\$
    – Timwi
    Commented Mar 1, 2016 at 15:40
  • \$\begingroup\$ Fair enough, was just asking that as some sort of joke. \$\endgroup\$
    – user43106
    Commented Mar 1, 2016 at 16:36

Brian & Chuck

Brian & Chuck was created by me, Martin Büttner, in November 2015.

It was originally created for the language-design challenge Create a programming language that only appears to be unusable. I had been considering the concept of a programming language with two interacting programs for a while, and the challenge seemed like a good incentive to give it a try with a very minimal instruction set. I'm quite happy with the result and will probably use the language outside of that challenge occasionally.

The language is based on Brainfuck (hence the horrible pun of a name) and took some inspiration from Self-modifying Brainfuck, but programming in it feels quite different from both of those. The design goals were

  1. The language should be Turing-complete.
  2. Neither of the two subprograms should in itself (or with some trivial help from the other program) be Turing-complete.
  3. Both programs together should not be Turing-complete without one program modifying the source code of the other.

I haven't proven any of those things formally, but it appears that I've at least come close to those goals.

The basic idea is that there are two Brainfuck-like programs, called Brian and Chuck. The catch is that Brian's memory tape acts as Chuck's source code and vice versa. Furthermore, Brian's tape head is also Chuck's instruction pointer. Only one of them is being executed at a time, starting with Brian. Only Brian can read and only Chuck can write.

The main differences from Brainfuck are a) instead of [] loops, the only control flow command is ? which hands control to the other program if the current cell is non-zero and b) there are two additional commands { and } which move the tape head to the left or right until it hits a zero cell.

B&C turns out to be hard to use but not entirely unusable, and golfing simple programs in it is actually quite entertaining.

  • GitHub repository. Includes interpreter (Ruby), language specification, example programs and issue tracker.
  • Esolangs page. Largely a copy of the README.md on GitHub.


Brain-Flak is a language designed by me, DJMcMayhem, and written as a collaboration between me and two other users, @Wheat Wizard, and @1000000000.

When your Stack Overflows, you forget whatever you were talking about. If this happens very badly, to the point where you can no longer speak straight, we call this a "Flak-Overstow". This language is stack based, designed to hurt your brain, and very similar to Brainf*ck, so it seemed appropriate to name it "Brain-Flak".

An online interpreter can be found at brain-flak.tryitonline.net


Shortly after I wrote Are the brackets fully matched?, it made me wonder how much information you can store with only matched brackets. One thing that stood out to me, was that even though you only have 4 "atoms" of sorts:


you really have 8 units of information to convey, since each of these bracket types can be empty, or have other brackets in between, which are fundamentally different pieces of information. So, I decided to write a language that only allowed for matched brackets, and where empty brackets convey something different than brackets with other brackets inside of them.

One other thing that influenced the design, was annoyance at brainf*cks inability to easily process decimal numbers. Taking IO in ASCII is very obnoxious, so Brain-Flak handles all inputs and outputs in decimal by default. In August 2016, I added an "ASCII mode", where IO functions identical to brainf*ck.


(Copied from the github README)

Brain-Flak has two stacks, known as 'left' and 'right'. The active stack starts at left. If an empty stack is popped, it will return 0. That's it. No other variables. When the program starts, each command line argument is pushed on to the active stack.

The only valid characters in a Brain-Flak program are ()[]{}<>, and they must always be balanced. There are two types of functions: Nilads and Monads. A nilad is a function that takes 0 arguments. Here are all of the nilads:

  • () Evaluates to one.
  • [] Evaluates to the height of the current stack.
  • {} Pop the active stack. Evaluates to the popped value.
  • <> Toggle the active stack. Evaluates to zero.

These are concatenated together when they are evaluated. So if we had a '3' on top of the active stack, this snippet:


would evaluate to 1 + 1 + active.pop() which would evaluate to 5.

The monads take one argument, a chunk of Brain-Flak code. Here are all of the monads:

  • (n) Push 'n' on the active stack.
  • [n] Evaluates to negative 'n'
  • {foo} While zero is not on the top of the stack, do foo.
  • <foo> Execute foo, but evaluate it as 0.

These functions will also return the value inside of them, so


Will push 3 but


Will push 3 twice.

The {} will evaluate to the sum of all runs. So if we had '3' and '4' on the top of the stack:


would evaluate as 7.

When the program is done executing, each value left on the active stack is printed, with a newline between. Values on the other stack are ignored.



This language is a trivial Brainfuck substitution created by Alex A. (me) and BrainSteel in August 2015. It uses punctuation in place of the usual BF commands so that it may be embedded in any sort of usual human-written text and go unnoticed. Otherwise its only distinctions from BF are that it cannot travel left of the starting cell and brackets use the same character but with a toggle character to switch between open and closed.

It was created to be annoying for The Programming Language Quiz, since uncracked answers use ??? in place of the language name.



By elected moderator, Dennis ♦

From the wiki:

Jelly is a tacit, programming language based on J: its raison d'être is solving programs in the lowest possible byte count.



V, short for vim and pronounced "vee" is a golfing language designed by me. V operates by performing transformations on a giant 2D array of strings. Although all of the builtins are fairly simple and trivial operations, such as dw, (d)elete a (w)ord, or fn, (f)ind the next occurrence of the character (n), they are very modular and can be composed into larger commands. For example:

ò                 "Recursively:
           "Ad    "Delete into register 'a'
          2   tn  "until the second occurrence of 'n'
 :g/regex/        "on every line where 'regex' matches somewhere on that line.

A little backstory on the language. Vim is my favorite text editor. I love tinkering with vim, configuring vim, playing with vim plugins, writing vim plugins, answering questions on vi.se, etc. In February of 2016, I wrote an answer to a code-golf question in vim, which kinda blew my mind since I had not ever used vim as a "programming language" before. I started using vim for code-golf more and more. After tinkering with it enough, I realized it's not just usable for string based challenges, it's competitive at string based challenges!

Even though vim has no concept of numbers, it is even turing complete through it's use of recursive macros and the increment <C-a> and decrement <C-x> commands. However, it's kind of a pain to work with vim for anything beyond the simplest of challenges.

  • Vim's concept of conditionals is hacky at best, and requires a lot of boilerplate code

  • Taking input is a pain, since you have to manually type the input into a vim buffer at the start of a program, and then save the output at the end of the program. Running the program is also a pain since it's not automated and some minor details can throw the whole thing off. You also have to manually specify launching vim with no loaded options or info for the submission to be valid.

  • Vim's handling of numbers is abysmal.

V was written to overcome all of these problems. A lot of these problems are still there, since V is definitely a work in progress, but some drastic improvements are already there. The biggest improvement is the automation. You don't have to manually type the program to run it!

Another improvement is the shortening of common vim idioms that take too many bytes. For example, to execute foo until it throws an error in vim, you can do this with


This program has a whopping seven bytes of purely boilerplate code! And also, if a user less familiar with vim tries to test this, and forgets to launch vim with no loaded settings, this will cause undefined behavior. Completely unacceptable for code-golf. In V, this is brought down to


With no undefined behavior. Although the second ò is implicit, so the real program would be


Regexes are also drastically shortened, and a global stack plus some simple math operations are in progress.



The most disapproving coding language on the Internet!

Oh yeah, this one's great. It was made by me beginning of November 2015 over the span of a few days. It's stack-based, like most code-golfing languages, but it's meant for general-purpose use, not code-golf. In addition, it's a line-jumping program, meaning that you go to specific lines rather than labels (like in BASIC); it might be the first of its kind! ಠ_ಠ also has the most versatile conditional statement of any language, and it features a useless operator.

Quick Example


A simple cat program.

  • 1
    \$\begingroup\$ Re versatile conditionals: check out ARM assembler's conditional execution. \$\endgroup\$ Commented Dec 14, 2015 at 8:17
  • \$\begingroup\$ Is _ shorter? 1 byte. \$\endgroup\$
    – Riker
    Commented Feb 25, 2016 at 21:23
  • \$\begingroup\$ @RikerW Sure, but it isn't as cool. (I really need to fix up the interpreter, that's a bug :P) \$\endgroup\$ Commented Feb 25, 2016 at 22:24
  • \$\begingroup\$ Hey, um, your interpreter expired. You still have it locally? \$\endgroup\$
    – Stephen
    Commented Aug 16, 2017 at 20:42
  • \$\begingroup\$ The interpreter still works for me... although codepen.io/molarmanful/full/gajxjX is an alternative link in case. \$\endgroup\$ Commented Aug 20, 2017 at 4:17

Help, WarDoq!

This esoteric language was created by me, Dennis, in August 2015.

It consists solely of 16 one-byte built-ins that print common variations of the string Hello, World! two built-ins for quining, two for addition an two for primality testing.

It was designed to be very competitive in challenges with the least possible effort to satisfy our definition of programming language.



Created by myself (BMacZero).

SnakeEx was created for the Language Design: 2-D Pattern Matching challenge. It uses a regex-like syntax to detect matches in a two-dimensional block of text.

Online Interpreter - Full Language Spec - Javascript Source

interpreter screenshot

A SnakeEx programs defines a number of "snakes", which are like regexes that can move through the text in any 2D direction rather than just left-to-right. Snakes can be called like functions, allowing recursion.


Hello World(ish): matches the string "Hello, World!" going in any direction (crossword-style)

m:<*>Hello, World\!

Maze Solver: finds all routes through an ASCII maze where the walkable space is periods


Counting Loops: counts the number of ASCII-art loops in the input


Its primary limitation is a lack of defined output (when I solve PPCG problems with it, I usually wrap it in a Javascript function). Another area for potential improvement is matching the edges of the input (this is currently accomplished with $, but code that has to do this is not very elegant).



Brachylog is a declarative code golf language created by me, Fatalize, in summer 2015.

Brachylog is intended to be a short-handed version of Prolog (of SWI-Prolog, specifically), which allows to chain predicates using implicit variables, implicit unification and implicit logic AND.

GitHub Repository, which contains the Prolog transpiler and the Wiki.

  • \$\begingroup\$ This sounds extremely interesting! I hope that you will find the time and motivation to resume working on this, especially with making more declarative arithmetic available. This would make your project an even more powerful and interesting language for golfers! \$\endgroup\$
    – mat
    Commented Nov 30, 2015 at 12:30
  • 1
    \$\begingroup\$ @mat I might come back to it, but I would also like to redo the parser, which takes time. Since I came up with the grammar on the spot, some things aren't parsed as you would expect, some things aren't as elegant as they could be and the parser code is a mess. \$\endgroup\$
    – Fatalize
    Commented Nov 30, 2015 at 12:36
  • \$\begingroup\$ Sounds about like every serious Prolog project :-) \$\endgroup\$
    – mat
    Commented Nov 30, 2015 at 12:51

∀ (or "forall") is a language that piggy-backs on other golfing language to build a golf pipeline. Not sure whether to use Perl 5, Jelly, Retina or Pyth for some challenge?

Why not use all three together?

See it on Github.

This is an example ∀ program:

nsay join '',map{chr(5+ord)}split ''
Nsay $_».succ

y is Jelly. p is Pyth. r is Retina. n is perl5 -n. N is perl6 -n.

An important feature is that, as long as the prefix is the same, the code is considered to be one block. You can pipe into the same language by using an empty line:



The first Pyth program is 2-lines long, the second one is a one-liner. The empty line "breaks" the chain.

Thanks a lot to all the language authors for allowing that to be possible.

Currently included:

  • Pyth by @isaacg
  • Retina by @MartinEnder
  • Jelly by @Dennis
  • Perl 5/6 by @TimToady (:P)
  • \$\begingroup\$ If you're making a direct language injection, why not use a shell-based "eval" and just run scripts through that? \$\endgroup\$ Commented Aug 9, 2016 at 8:33
  • \$\begingroup\$ Quoting and everything, as well as flexibility: I couldn't run Jelly that way. \$\endgroup\$
    – Ven
    Commented Aug 9, 2016 at 9:48
  • \$\begingroup\$ Write files in /tmp, run them, delete. shrug No need for quoting. \$\endgroup\$ Commented Aug 9, 2016 at 14:22


Burlesque is a concatenative, stack-based, lazy esoteric programming language. I'm not aware of any other esoteric programming language that is lazy but I of course don't know every single esoteric programming language.

Burlesque was written by me starting in 2012 mostly during boring lectures while I was studying computer science at a local university. At that time I probably didn't have a PPCG account yet but at least today I have.

I wrote it as a tool for me to use to make doing boring homework assignments easier and faster (and funnier) but it eventually became a language used for golfing.

Like mentioned earlier Burlesque is special in the fact that it supports lazy evaluation which allows you to work with infinitely long lists in a convenient fashion. Burlesque has a huge set of built-ins but every built-in is exactly two characters long which is of course a huge disadvantage when it comes to golfing. However, the sheer amount of built-ins is enough to compensate that a little

Since it's a language intended to be used my me I do not hesitate to add more built-ins whenever I want to and I literally only care about not breaking backwards compatibility. The reason Burlesque doesn't have a "Hello world!" built-in is because such a built-in - while nice for golfing - is pretty much useless for me because it wouldn't make solving any real world problems I use Burlesque for easier.

Burlesque even has built-ins for distributions (statistics, such as binomial, chi-square, hypergeometric, student t and the like), built-ins for average/variance frequency analysis:

blsq ) "helloooooo wwwwwwworld"gw{^pSh?+}\m
"1h1e2l6o1 7w1o1r1l1d"
blsq ) "helloooooo wwwwwwworld"f:
{{7 'w} {7 'o} {3 'l} {1 'r} {1 'h} {1 'e} {1 'd} {1 ' }}

Some longer scripts:

 Example code for statistics.
 Calculates average, standard deviation and
 displays a frequency table.
 -- mroman, 2013
"REM: Data"vv
{4.5 3.0 5.5 5.0 5.5 4.0
 5.5 5.0 3.0 4.5 4.0 4.5
 4.0 4.0 4.5 3.5 5.0 4.0
 4.0 6.0 5.5 5.0 4.0 5.5
 3.5 2.5 4.0 4.5 5.0 4.5
 5.0 5.0 4.0 3.0 4.5 2.5
"Average: "#aav?+sh
"Standard Deviation: "#aSD?+sh
".[Frequencies].\n"#af:SP{' +]}wl?+sh

which produces:

 9 4.0
 7 5.0
 7 4.5
 6 5.5
 3 3.0
 2 3.5
 2 2.5
 1 6.0
Standard Deviation: 0.8908106103676267
Average: 4.39189189189189


Created by me, VTCAKAVSMoACE

When I have a child, I will name them Vitsy, and they shall appreciate their namesake.

Esolangs Page

Vitsy is a forced 1D language (meaning any code put on other lines is ignored*) that uses an instruction pointer to transverse code (similar to ><>). It is stack-based and very much in progress. It was released... well, today, 18th of October 2015. It does not yet have much functionality, but it is being worked on (albeit slowly).

*NOTE: As of the latest version, Vitsy now supports static methods as accessed by line number. See README for details.

*SECOND NOTE: As of the now latest version, Vitsy now supports separate "classes", where you can extend or use other Vitsy programs in accessible directories (provided a relative directory path).

*THIRD NOTE: Vitsy now has shell access and prompting functionality.

*MOAR NOTES: Vitsy now has file I/O and JS eval.

It originates from inspiration through Brainfuck, Befunge, and ><>, and a chat conversation relating to n dimensional languages.

It is named after a common misappropriation of the first three characters of my name into a pronounced word (ViT-C).

Documentation is fairly limited as of now, but more, clearer documentation will be created soon.

It is currently hosted on Github and I've been working on improving it literally every day of its existence so far.

Code Examples

Standard Quine

'           Start recording as a string.

(wraps around once, capturing all the items)

'           Stop recording as a string. We now have everything recorded but the original ".
 r          Reverse the stack
  b3*       This equates the number 39 = 13*3 (in ASCII, ')
     Z      Push the entire stack to STDOUT.


  • \$\begingroup\$ Ah, you changed your name. Did "VTCAKAVSMoACE" stand for something? \$\endgroup\$
    – mbomb007
    Commented Nov 5, 2015 at 17:44
  • \$\begingroup\$ Yes - none of it stood for VoteToClose, though. :P That came along with peoples' interpretation. @mbomb007 \$\endgroup\$ Commented Nov 5, 2015 at 17:50
  • \$\begingroup\$ Your name is VTCooltoese? \$\endgroup\$ Commented Mar 9, 2016 at 22:28
  • \$\begingroup\$ @CatsAreFluffy ಠ_ಠ No. \$\endgroup\$ Commented Mar 9, 2016 at 23:11


TeaScript started off simple:

After months of being plagued by JavaScripts verbose property names, and repetitive nature. I decided it was time for a change.

That's when TeaScript was born.

Most JavaScript answers use often ingenious techniques to shave off each and every byte possible but still are left behind with large byte counts with long property names such as String.fromCharCode.

TeaScript originally didn't have big dreams. It started off as a very simple language which exactly like JavaScript, but shorter property names.

After posting my first answer I realized how big of a difference this could make and so I headed off and started brewing more features.

Eventually, I was hardcoding many things. Features were getting cluttered and the source code was getting very cluttered. TeaScript wasn't designed for so much golfing so I completely rewrote the code with TeaScript 2!

TeaScript 2 adds many new features such as unicode shortcuts, a fancy interpreter, automatic golfing, and many more built-ins. I'm working on a TeaScript 3 which will hopefully being TeaScript closer to competing with CJam and Pyth.

What makes TeaScript different is TeaScript is not just a language that compiles to JavaScript. It is JavaScript, extended.

Example: This outputs an array of each character code of the input:


Output for Hello, World!: [72,101,108,108,111,44,32,87,111,114,108,100,33]

  • \$\begingroup\$ vihanserver.tk’s server DNS address could not be found. When I click on the teacup on the github page. \$\endgroup\$
    – Konijn
    Commented Oct 3, 2016 at 14:16
  • 1
    \$\begingroup\$ @tomdemuyt yeah, I'm sorry about that :/ I accidentally did chown $(whoami) -R /usr/bin/ for some stupid reason so right now my server is down \$\endgroup\$
    – Downgoat
    Commented Oct 3, 2016 at 14:19
  • \$\begingroup\$ No worries, as long as you know ;) \$\endgroup\$
    – Konijn
    Commented Oct 3, 2016 at 14:22


GitHub repo | Online interpreter | Code design helper by @Downgoat

Cubix is a stack-based 2D language, created by me sometime in March. Cubix differs from ordinary 2D languages in that it's not strictly 2D: the code is wrapped around a cube. The first thing the interpreter does is remove whitespace, then figure out the smallest cube that the code will fit onto. The code is then padded with no-ops until all six sides are filled. That means that this "Hello, World!" program:


is exactly the same as this one:

      . / v
      . o ;
      @ ? /
" ! d l r o W " S ' , u
/ " H e l l o " . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Then the code is run like a 2-dimensional language, except that the IP (instruction pointer) wraps around like the code is on a cube.

Fun fact: Cubix was almost named Würfelsprache, but fortunately was saved by @Downgoat.

  • 1
    \$\begingroup\$ What's wrong with Würfelsprache? D: \$\endgroup\$
    – flawr
    Commented Aug 29, 2017 at 14:52


Alice was created between October 2016 and April 2017 by me, with a lot of help from Sp3000. It started out as "a quick one-or-two week project" just for the sake of getting something done because I wasn't making any progress with my other language ideas. Well, you can count the months yourself... I guess it's what I deserve for turning feature creep into a design goal.

Alice is a feature-rich Fungeoid with many high-level functions that make programming in it comparably doable (hopefully). I originally started working on it when Sp3000 suggested to combine two of my ideas into a single language:

  1. Many 2D programming languages use / and \ to reflect the instruction pointer on the 45 degree diagonal. But I figured in most fonts those characters are closer to 67.5 degrees, so they should really reflect between orthogonal and diagonal movement in some way.
  2. I wanted to create a feature-rich Fungeoid where operators have different meanings depending on what direction the IP is moving, so I could overload them with even more commands.

So here we have Alice. A language in which mirrors change orthogonal movement to diagonal movement and vice-versa, and in which the language works in two very different modes depending on whether you're moving orthogonally or diagonally: in Cardinal mode (moving orthogonally), Alice is much like other Fungeoids that can only work with integers on a stack or tape (although Alice has both); in Ordinal mode (moving diagonally), Alice turns into a string processing language and now only knows about strings as a data type.

I also resolved early on to give every single printable ASCII character a distinct function in Alice. So Cardinal mode has a lot of built-ins for basic arithmetic, number theory, combinatorics and some other shenanigans. Ordinal mode has a wide variety of commands for string manipulation and set theoretic operations.

And finally, we come to the name (and theme) of the language: the language is of course named after Lewis Carroll's Alice. Much as Alice in Through the Looking-Glass, you step through mirrors to switch between two mirror universes. What this means for the language is that the two functions performed by any of the characters in the two modes, are (sometimes subtly and sometimes not so subtly) related, in terms of their effect, their theme or their structure. When a Cardinal command works with the divisors of a number, the corresponding Ordinal mode command will often do something similar with the substrings of a string. When a Cardinal command picks a random number in a range, the corresponding Ordinal command picks a random character from a string. And so on...

If you want a first taste of the language, here is Collatz step counter. For a more elaborate example that makes proper use of both modes, see this answer. The language repository also has some example programs.

I've got a bunch of people to thank for their help with this language. As I said above, Sp3000 has been a huge help, testing the language, giving feedback, and throwing ideas back and forth. But I've also worked in some ideas from discussions on SE: thanks to Basic Sunset, flawr, Mistah Figgins, muddyfish, Nathan Merrill, Peter Taylor and Poke (and probably some others whom I forgot).

  • GitHub repository. Includes language specification, reference implementation (Ruby), example programs and issue tracker.
  • Try it online! (by Dennis) backed by the Ruby interpreter.
  • SE Chatroom. For any questions and discussions about the language, bug reports, etc. I'll usually be pingable in there.

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .