Language-creation has become a popular activity on PPCG. 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 PPCG 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
    Sep 9 '15 at 2:45
  • \$\begingroup\$ Do languages whose only non-proprietary interpreters were created by PPCG users count? \$\endgroup\$
    – bmarks
    Sep 12 '15 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
    Sep 12 '15 at 21:59
  • 1
    \$\begingroup\$ @minxomat This question is open to all languages created by PPCG users. \$\endgroup\$
    – PhiNotPi
    Sep 13 '15 at 4:36
  • \$\begingroup\$ @bmarks I say you could go ahead and post it, specifically mentioning the interpreter. \$\endgroup\$
    – PhiNotPi
    Sep 13 '15 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
    Sep 14 '15 at 6:27
  • 2
    \$\begingroup\$ @minxomat Done. \$\endgroup\$
    – Alex A.
    Sep 21 '15 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.
    Sep 21 '15 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
    Sep 25 '15 at 17:33
  • 1
    \$\begingroup\$ @BetaDecay Yeah I had thought about that. Language name, creator, and year. Up to Phi though. \$\endgroup\$
    – Alex A.
    Sep 25 '15 at 18:32
  • \$\begingroup\$ @Adnan 05AB1E should be on here. \$\endgroup\$ Jan 19 '17 at 21:19
  • \$\begingroup\$ Can I post mine here if I have several alternative names? \$\endgroup\$ Oct 2 at 8:43

96 Answers 96



Wumpus was created by me in February 2018. The language's history is actually much longer though. Back when I created Hexagony (in September 2015), I noticed that there aren't any 2D languages for either hexagonal or triangular grids, and ended up picking hexagons at the time. But from the beginning I intended to fill both of those gaps.

But after I designed Hexagony, the ideas for a triangular language went through many stages, some or and some less ambitious and kept putting off actually getting to work on it. Originally, I came up with the idea of calling the language Triptych and making it consist of three separate triangle-based structures and three separate programs (a bit like Brian & Chuck on steroids). At any given time, one of the three programs would be running, with the corresponding structure acting as the code, and the two other structures acting as data, and each program could pass control off to the other structures. And each of those three programs was supposed to be running a different programming paradigm. But then the design for one of those three spiralled a bit out of control, and I decided to turn it into its own language – that one is still on the backlog, because it's a fairly ambitious idea. But the other two were the triangular grid and the icosahedron.

After removing one of the three subprograms, I decided to drop the idea of having multiple programs with different paradigms and settled on making this a more traditional Fungeoid on a triangular grid but using the icosahedron as a data structure. After Hexagony, I didn't want to force this kind of mind bending memory model onto the programmer, so I also gave the language a stack and made it the primary data structure (the icosahedron acts as 20 registers, which are largely optional, but can make some things more convenient if you do figure out their topology).

So that's what I ended up with: (what I believe is) the first ever 2D programming language on a triangular grid, taking many inspirations from existing Fungeoids, but adding the icosahedron as its own interesting twist. There's also two other features regarding control flow, which are comparably rare among 2D languages: the boundaries of the grid don't wrap around (or terminate the program), but instead the IP reflects off them. I had already used this idea for Alice's Ordinal mode, but it was part of Wumpus's design long before I thought of Alice. The other feature is a strafing move, which lets you move the IP orthogonally to its current direction, to sidestep onto the next or previous line. The way this interacts with the triangular grid is quite interesting, I think.

Of course, the name is a reference to the classic game Hunt the Wumpus, which uses an icosahedral map for its dungeon. The game is also a significant part of Fungeoid history.

As a side note, this is the first language since Labyrinth and Hexagony (my first two) which I managed to implement in just two days. Of course, with the idea having brewed for over two years it's not quite the same (those two went from idea to finished implementation in two or three days), but after the lengthy design processes of my recent languages, this honestly felt quite good.



I created several languages, but I think this one is worth posting here since it's a fun concept:

The idea is inspired by chemical reaction networks which consist of a rule-set encoding certain "chemical reactions", eg:

H + 2O -> H2O

A program is just a set of such rules, however there might be rules where their inputs overlap, for example:

Alice -> Bob
Alice -> Charlie

Well, here's where the fun/pain begins: The program has an internal state - called the universe - which counts how many atoms of which type there are. At every iteration a uniformly at random rule is picked from all the ones which are applicable (you can change the probabilities by copying the rule).

To bootstrap the whole process the program starts off with one _-atom and from there your world starts evolving.


There are three types of special atoms which when they would be added to the universe do some I/O instead:

In_some_name:      Read number from stdin and add that many "some_name"-atoms
Out_some_name:     Output the number of "some_name"-atoms
Out_"some string": Output the string "some string"


_ -> Out_"Hello, Alchemist!"

Prints Hello, Alchemist! to stdout: Try it online!

_ -> In_x + In_x + Out_x

Reads two integers from stdin and outputs their sum: Try it online!

Here's how deterministic control-flow can be implemented, ie. use special atoms to store state:

# Read two integers & add "compare_AB"-atom
_ -> In_A + In_B + compare_AB

# If there is a "compare_AB"-atom:
compare_AB + A + B -> compare_AB   # remove an atom of A and B

# Once there are no more atoms of A or B, we know ..
compare_AB + 0A + 0B -> Out_"eq"   # .. if none of both are left: they're equal
compare_AB + 0A +  B -> not_equal  # .. if only B is left B > A
compare_AB +  A + 0B -> not_equal  # .. if only A is left A > B

# Do something when they're unequal
not_equal -> Out_"neq"

Reads two integers and compares them: Try it online!


In my questions Simulate a Minsky Register Machine (I) and Simulate a Minsky Register Machine (II) I define essentially two versions of a programming language which is just a textual representation of MRMs. The intention was already to build towards version (III), which would add macros with unification. I'm also thinking about adding some additional I/O and arithmetic operations.

  • \$\begingroup\$ Do it! &nbsp; &nbsp; \$\endgroup\$ Sep 13 '16 at 23:11


This is a language created by me.

It's a lazy one (something like Dogescript?), because pretty much the entire language is Python, except there are specific two bytes chars that get replaced by something, and then executed as normal Python.


Hello, World!


or if you want the W to be lowercase:


FizzBuzz (v0.1)


I added more stuff into the language, so in v0.5 it can be shortened to:


Degrees to radians


Celsius to fahrenheint


Primality check


Milky Way

Milky Way was created by me, Zach Gates, in November of 2015. I was bored and thought that writing a language would be fun. It's an esoteric golfing language. It's written in Python 3 and is run as an executable.


  1. Nearly all the opcodes are destructive, meaning they remove the top-of-stack, perform their function, and push the new item back onto the stack.

  2. Each line of a program has it's own stack. Each stack is initiated with two elements already on it; an empty string and zero.

    ["", 0]
  3. If no output has occurred by the end of the program, the bottommost stack element will be output. For example, if the resulting stack is

    ["abc", "def"]

    then "abc" will be output; surrounding quotations included. This is the only setback to running a program with no output.

  4. Input is taken via the command line with the -i option.

The Hello World! program:

This is the standard method:

"Hello World!"!

Everything within double quotes is a string in Milky Way. The exclamation mark outputs the top-of-stack. Alternatively, the inverted exclamation mark (decimal 161), will output the top-of-stack and terminate the program (any opcodes following will not be executed, nor will any subsequent lines). With one extra byte, but an equal number of characters; here it is:

"Hello World!"¡

Further, the greater than sign (decimal 62) will shift the entire stack rightward. The top-of-stack will become the bottom-of-stack, thus being output upon termination. This output, however, would be invalid if the output is not allowed to include surrounding quotations (see fact 3, above). Here it is:

"Hello, World!">

Truth machine

This is the shortest method I've come up with.


The single quote opcode reads the input from the command line. This piece: ?{...}, is an if statement. Each piece is separated from the next by an underscore.

  • Code from the opening bracket to the first underscore, 0b in this case, is the conditional.

  • Code from the first underscore to the second underscore will run if the conditional evaluates as true.

  • Code from the second underscore to the closing bracket will run if the conditional evaluates as false.

In the case of this program, 0b checks is the top-of-stack, the input, is equal to 0. If it is, it outputs the top-of-stack a single time. If not, the top-of-stack is output for eternity, because &{...} constitutes a Pythonic while True: loop.

To read more about the meanings of different bracket sets, take a look at the Github repository's readme.

Catalog of answers

Here is a catalog of cool and significant answers that have been written in Milky Way. Each element on this list is the title of a question, while each link is the direct share-link to the answer.

Feel free to add to this list if you've written an answer you think is cool.


  • 1
    \$\begingroup\$ What a coincidence! My name is almost the same name as this programming language, and both this language and me are related to PPCG \$\endgroup\$
    – MilkyWay90
    Dec 31 '18 at 23:22
  • \$\begingroup\$ @MilkyWay90 Beetlejuicing! \$\endgroup\$
    – GMills
    Feb 20 '19 at 15:15
  • \$\begingroup\$ @GabrielMills Beetlejuicing? What's that? \$\endgroup\$
    – MilkyWay90
    Feb 20 '19 at 16:11
  • \$\begingroup\$ @MilkyWay90 reddit.com/r/beetlejuicing/about \$\endgroup\$
    – GMills
    Feb 20 '19 at 16:42
  • \$\begingroup\$ @GabrielMills Oh, I didn't know there was a term for that. \$\endgroup\$
    – MilkyWay90
    Feb 20 '19 at 16:43


Chip is an esoteric language designed by me, Phlarx. It is my first language, and I started designing this in December 2016. It can be found on Try It Online, too.

This language is inspired by integrated circuits and digital logic, and as such, it is a 2.5D language that somewhat resembles circuitry. (I say 2.5D because Chip circuits can be layered atop one another, so it resides somewhere between 2D and 3D).

Since Chip deals with digital logic, it looks at individual bits for each operation, however, it is capable of reading eight bits of input (usually called a byte or octet) and writing eight bits of output on each cycle.

Chip currently has a single stack or a single queue, and has limited ability to jump back to earlier input. There are plans to further enhance its abilities in these areas, such as a second queue/stack, or addressable memory instead.

This language is still a work in progress. You can check out the rough todo list, as well as some more examples at the github page.

Example 1

Take the value of the three high bits of input, and output them as an ASCII numeral.

Fa Gb Hc e*f

Input Chip™ becomes 2333745.

Example 2

Print 1 if consecutive bytes are equal, 0 otherwise.

`}.`}.`}.`}.`}.`}.`}.`}.   f

Input Hello PPCG produces 001000100.



MAWP was created by me, Dion, in May 2020. My main goal was to create a language that was shorter than non-golfing languages while still being simple to use and being able to answer a wide range of questions without major difficulty. The only letters used are M, A, W and P. With this in mind, I wanted to have quite a number of builtins while not using any other letters and still having characters that are accessible on a standard keyboard.

The only interpreter easily accessible by everyone is this one, also written by me. It also has an esolangs page.

Some example programs

Numbers by position:



[      start of loop
!      duplicates top of stack
[      start of loop
~!:~   prints bottom stack value
1A     subtracts 1
]      end of loop
%      removes top of stack (0 from the counter in the previous loop)
!9A    diffeence between top value and 9
?.     if top 0, then terminate program
%      removes top value
1M     adds 1 to top value
]      end of loop

Print the alphabet:



[        start of loop
!        duplicate top of stack
43W8W    push 96 to stack (4*3*8)
M        add 96 to number below
;        output top of stack as ASCII char
1M       add 1 to top of stack
!        duplicate top of stack
93W      push 27 to stack (9*3)
A        Difference of top two stack values
?.       is equal to zero, then terminate program
%        pop top of stack
]        end of loop


Printing long strings is the biggest downside of MAWP, since you need to generate the ASCII code for each character with basic operations and numbers from 0 to 9.

[                                              Start loop
!!3P3WA                                        Is divisible by 3? (Homemade modulo 
<                                              If top of stack is not 0 (number is
                                               not divisible), then jump to its >
75W2W;73W5W;65W2W1M2W;65W2W1M2W;               Print 'Fizz'
~0~                                            Add 0 to the bottom of stack by 
                                               double reversing
>                                              End conditional
%                                              Remove modulo function result
!!5P5WA<92M6W;94M9W;65W2W1M2W;65W2W1M2W;~0~>%  Do the same for 'Buzz'
~                                              Reverse stack
{                                              If there are no 0 on the top of 
                                               stack (not 'Fizz' nor 'Buzz' was
~!:~                                           then print the current number
}~                                             End conditional and reverse stack
!554WWA?.%                                     If the number is 100, then terminate
1M25W;                                         Print newline
~(%)                                           Remove all 0 from bottom of stack
]                                              End of loop
  • \$\begingroup\$ I thought that MAWP primarily uses English letters. To my surprise it actually uses a lot of symbols... \$\endgroup\$
    – user96495
    Aug 19 '20 at 10:54


The latest of my programming languages, relies on recursive module loading as the principal form of recursion and iteration.

Data is stored on a bidirectionally unbounded tape and in arbitrarilly many variables.

Modules may be loaded on either the same memory space or on a deep copy thereof, depending on which load instruction is used.

Modules are permitted to return values, and if no return value is specified a module call is treated as returning 0.



MOVr is a self-modifying language of mine in which everything is a MOV instruction (and simultaneously data.) However, the 2^24 64-bit words of addressable data also include the IP (at 0xfffffe) and an IO port (at 0xfffffd.) Instructions take the following (binary) format:

 01 23 456789 ABCDEF

dl and sl are the destination and source levels, which tell how many times each must be dereferenced (mod 2^24.) If dl is 0, then the instruction acts as a no-op. If the IP goes past 0xffffff, the program terminates. Writes to and reads from the IO print and input Unicode characters. Data not filled by the program is assumed to be zeroed. This means that if you don't jump to the exit (with 0x0100fffffeffffff), then your code will have to travel through all the 2^24 instructions (and possibly wreak havoc while passing through the IP and IO.) Sadly, a working interpreter is not available at this time.



I, GamrCorps, made Glava in January 2016. It is still a MAJOR work-in-progress, but it is still very useful. Click the link above to view the docs and download the interpreter (written in Java).

Glava is a Java dialect focused on code golf. Many of the common keywords and phrases can be shortened down two around two characters each. It also sports an autocomplete feature, where you can omit the }s, ]s, )s, and "s at the end of your code and it will automatically put them in.

Another neat feature is what I call MCRP (Main Class Recognition and Placement). Simply put, if you do not have a class anywhere in the file, the interpreter will put one there for you! Also, a few common import statements will automatically be placed in with the same process (java.utils.*, java.lang.*, etc.)!

The interpreter SHOULD work in any Java version (I believe past 6), because it compiles the Glava programs into your native Java version.



Made by me, DenkerAffe

IPOS (short for I process only strings) is a stack-based golfing language made for complex string processing. It will have a huge amount of string manipulation builtins, so it will probably (hopefully) win every challenge which is about transforming an input string into an output string.

I finished the basic core recently, now it is only about implementing builtins. A list of all planned (not-complete) and already implemented commands can be found here.

The input to an IPOS program is placed on the stack automatically. At the end of the program all stack items are converted to strings and get joined into one string which then get printed.

Example programs

Hello World

"Hello World!

Split input on dots, reverse each substring and join all substring on dots



       Implicit: place input string on the stack (C)
'.     Push a dot to the stack (B)
!r     Push the reverse command to the stack (A)
%      Split C on B, apply A to every part and join the result on B
       Implicit: Output the stack contents

Swap case of every character in the input randomly



       Implicit: place input string on the stack (C)
E      Push an empty string to the stack (B)
!k     Push the swapcase command to the stack (A)
?      Split C on B (=split into characters), apply A to every part and join the result on B
       Implicit: output the stack contents
  • \$\begingroup\$ Do you mean "I process only strings", not "I progress only strings"? \$\endgroup\$ Mar 30 '16 at 17:44
  • \$\begingroup\$ @EasterlyIrk I do. Thanks for spotting! \$\endgroup\$
    – Denker
    Mar 30 '16 at 17:47


Github repo here.

Logicode was created by me, Qwerp-Derp, on August 31, 2016. It's basically a coded version of Logisim.

The language consists of three built-in logic gates, AND, OR and NOT (which are represented as &, | and ! respectively), and that's basically it. You do the rest.

You can make:

  • circuits (which are basically functions)
    • these only take strings of 0 and 1 as input and output strings of 0 and 1 as output.
  • variables
  • conditionals

You can also use stuff like:

  • input/output
  • random ints
  • comments
  • reversing strings

Github stuffs

If anyone can improve the code, go ahead and post a pull request!

If you have any issues, please put it in "Issues".



Bean is an esoteric byte-encoded code-golfing language derived from JavaScript, and was created by me, Patrick Roberts, in January 2017.

The inspiration behind Bean was one of frustration. I typically submit answers in JavaScript (ES6), and was aware of its shortcomings in verbosity, such as String.fromCharCode(...). I thought it would be cool to write a language where every global and standard identifier (like String and fromCharCode respectively) could be represented by single bytes in a byte-encoded language, and thus JavaScript's code-golfing hero, Bean, was born.

The backend uses babylon to convert any JavaScript source code omitting comments, directives (use strict), decorators (@readonly), and a few other AST nodes that were exclusive to module syntax (export default, for example), and traverses the constructed AST depth-first, encoding each node in 1 or 2 bytes, and then recursing to encode the child nodes sequentially.

Some of the features that make Bean differ from JavaScript is the advantage of implicit input and output. For example, the following JavaScript compiles to a valid Bean program that adds two integers and outputs the sum:



Bean Hexdump (7 bytes):

00000000 26 4c a0 43 8b 20 44

The best valid JavaScript answer for this, in comparison, is 9 bytes. You can check the demo for this Bean program here.

The implicit input is read line-by-line, and string literals of each line are stored in the lowercase identifiers a-z (then aa, ab, ac...) while successful JSON-parsed lines are stored in A-Z (then AA, AB, AC...). In addition, the array of all string literals is stored in _ while the sparse array of successful JSON-parsed lines is stored in $. To make this clearer, consider the following input:

{"hello": "world"}
[5, "hello"]

The implicit input would be populated as follows:

var a = "5",
    b = "hello",
    c = "\"hello\"",
    d = "{\"hello\": \"world\"}",
    e = "[hello]",
    f = "[5, \"hello\"]",
    A = 5,
    C = "hello",
    D = {"hello": "world"},
    F = [5, "hello"],
    _ = [
      "{\"hello\": \"world\"}",
      "[5, \"hello\"]"
    $ = [5, , "hello", {"hello": "world"}, , [5, "hello"]];

Attempting to reference B or E would throw an error, and $[1] and $[4] would return undefined, and would not be iterated over with .map() or .forEach().

I currently don't have any documentation, as I've just explained every way in which Bean differs from JavaScript, but feel free to open an issue on github if you feel that documenting the byte code is necessary. Bean is also available on npm, but the implicit input and output only works on the online interpreter for now. I'll internalize that in a later update. The node.js implementation now includes a hook for implicit input and output via bean.program(). See README for usage.

The interpreter accepts any arbitrary JavaScript and automatically converts it to a hexdump for you. Alternatively, you can copy/paste any valid hexdump and it will reconstruct the equivalent JavaScript for you.

One tip I can offer is to attempt to use "standard" identifiers as much as possible, even in your strings, regular expressions, and template strings, since all literals expand to identifiers, and those that are not stored in the configuration file must be appended to the end of the byte code.

At the very least, repeated use of the same non-standard identifiers are reduced to referencing the same subarray of bytes at the end of the byte code, so don't bother storing "my really long necessary string" to a variable, because that will waste 3 bytes:

// 41 bytes

(s="my really long necessary string")===s

// 43 bytes

00000000 26 4c cd a0 6f 80 23 81 01 82 20 6f ed f9 a0 f2  &LÍ o.#... oíù ò
00000010 e5 e1 ec ec f9 a0 ec ef ee e7 a0 ee e5 e3 e5 f3  åáììù ìïîç îåãåó
00000020 f3 e1 f2 f9 a0 f3 f4 f2 e9 ee 67                 óáòù óôòéîg

// vs...

// 69 bytes

"my really long necessary string"==="my really long necessary string"

// 40 bytes

00000000 26 4c a3 81 01 82 23 81 01 ed f9 a0 f2 e5 e1 ec  &L£...#..íù òåáì
00000010 ec f9 a0 ec ef ee e7 a0 ee e5 e3 e5 f3 f3 e1 f2  ìù ìïîç îåãåóóáò
00000020 f9 a0 f3 f4 f2 e9 ee 67                          ù óôòéîg
  • 1
    \$\begingroup\$ Heh, I too created a language out of frustration with String.fromCharCode, as did Downgoat :-) \$\endgroup\$ Jan 24 '17 at 15:54


Karaoke is a scripting language created by me for internal use at a company I was working for in November 2013 (if you don't mind, I would avoid putting the name of the company here). I coordinated its development until September 2016 when I left the company.

The interpreter is not open-source, unfortunately, and not available to the general public, the company is using it for internal testing of their algorithms. There is no reference to the language on the company web site, and the name is not referenced anywhere, so I am sorry, I can't provide any evidence of doing it.

The syntax is based on Javascript, but with some Ruby in it. It's loosely object-oriented, but all available classes are part of the standard library, and the user can not define new classes in the language itself. The user can however define new functions.

The interpreter was built starting from a lex file, and was a simple one-pass scanner in the first versions, then I added a parser written in yacc in order to implement the object system and the control structures.

The features I liked particularly:

  • Default variable: the last result is stored into the default variable "_" which is used as an input value to the next function call.
  • Shortcuts: every object has a standard method which can be called using the bracket operator. So if s was an outputstream object and the default method of the outputstream class was println you could just call s("Hello World"). Method names could be abbreviated like in goruby.
  • Dynamic reference: this was, I think, the only feature of the language I did not directly steal from another existing language (but was of course inspired by similar features). You could define a value as a dynamic reference by adding a '&' in front of it. So if x=5; y=6; a=x+y and b=&x+y, then a would always be 11, but the value of b would change dynamically when you cnahged the value of x or y.

And then of course a lot of domain-specific features like input processing, output in some particular format, and interface to the library we wanted to test... It started like a fun experiment but at the end it was just another COBOL.


CGL (CGL Golfing Language)

CGL was created two days ago (4/11/17) by me. It uses a stack concept like other languages, but unlike other languages there are multiple stacks that you manipulate instead of one. You start on the 0th stack, which is empty by default. The -1th stack contains each input argument. All other stacks (integers) can be used for anything. Most operators either push something to the stack based on something already on the stack or perform an operation on all elements of the current stack.



GolfeMatics is a language developed by me, and I am designing it to be focused on math-related problems. The only types in the language are integers, decimals, and soon will also include lists. Booleans are false if they are equal to 0, true otherwise. No one needs strings, so I didn't add them. In fact, the only string-related command is A, which modulo's the current number by 128 and prints out the corresponding ASCII character. To see how ridiculous this makes this at programs involving strings, look at the Hello, World!



2DFuck is a very simple language created by me. It is inspired by brainfuck, but operates on a 2-dimensional matrix of bits instead of a tape of bytes. And it has an accumulator. The code is not 2D, only the memory.

It does also have the l built-in to run Conway's Game of Life on the memory, though I haven't written any programs using this so far.

Programming is, in my opinion, a bit easier than in brainfuck, because of the 2D memory and the accumulator.

Finally, a piece of code (a cat program):


Try it online!

Here is an explanation.

+++ GitLab repository +++ Online interpreter +++



This language was created by me, Draco18s on Sep 18, 2018.

The idea had been floating around in my head for a while, not actually as a programming language, but as a concept for a while. Mostly due to reading lit RPG books like Emerilia. I wanted some way to write in-game code that would be attached to an item or object that would act as a magical enchantment.

September 18th I pretty much sat down and started working out a basic set of instructions and framework for the language and the initial interpreter just to see if I could get something that worked. I took a lot of inspiration from ><>, as I'd worked with it a bit in the weeks prior, and wanting something a little more powerful. After a couple of hours I had a small, but functional language.

But it was really on Dec 16, 2018 when I added support for Unicode Combining characters that would modify various instructions in a variety of ways, such as would executes the a command (push 10) normally before altering the IP's direction to point right (overriding whatever direction it was facing). While combining characters will only combine visually with a certain subset of symbols (i.e. ) the interpreter doesn't care. While certain modifiers are often not competitive in code golf (due to the 2 or 3 byte cost for each one), they do unlock the ability to perform otherwise complex or impossible operations (such as rotating a string or swapping substacks).

The other main feature of Runic is that it supports an arbitrary number of simultaneously executed instruction pointers that can merge (if in the same cell and facing the same direction) and split (with one of four commands). Each instruction pointer has a current "mana" value, where some instructions cost mana (namely reflection, eval, sorting, substacks, and splitting) and if an IP ever runs out of mana it fizzles out of existence. Each IP's own stack is also size limited by its current mana, making large data sets almost impossible to work with. The idea being that magic, being magic, requires more energy to do Big Things.

I'd definitely like to rebuild the language from the ground up to do more, have each given instruction handle a wider range of input types (some instructions only operate on, say, strings but currently does nothing if it gets a pair of integers, but would do something instead that's currently handled by an instruction that currently operates on integers and not strings), and possibly have a custom code page (for extra golfiness). But it isn't high on my todo list.

And yes, I did eventually get around to implementing some of the more game-y features in Minecraft (just an example of an effect that spawns a particle to 'charge up' even if the final effect is just to print some text in chat, but it could spawn blocks too).



I figured I might as well get around to writing up an answer to this question to show people a side of Keg they probably haven't seen before.

The Backstory

Let’s start off real simple. Keg is made by me, Lyxal, although on GitHub and esolangs, I'm called JonoCode9374.

Anyhow, Keg was the second esolang I've ever made, with my first being a Minecraft based fungoid language. It's also the first golfing language I've ever made.

Back in 2018 when I was still new to esolangs, I was reading and learning about the ><> language. I absolutely loved the 2d layout as well as the simple stack manipulation abilities it contained. It was ><> that introduced me to stacks. And it was ><> that would influence the creation of Keg.

Starting from scratch, I didn't really know what to include in a golfing language. But I did know that I wanted to make the instruction set completely ascii, as I (at the time) found Unicode languages just too hard to understand (boy, how that's gone out the window!).

Touching on that point a bit more, I've had a kind of mindset of "if you don't understand it, make your own". Now, I know that people would say that such a perspective of life is ineffective, as one can't just create complex systems if they don't understand it. And I agree, generally I don't follow this way of thinking. But when it comes to something manageable like golfing language design, I believe it's fair game.

Also, I feel like I should mention I created Keg as a sort of protest against the big and established languages that seemed to always win... I kinda solved the issue of golfing langs sucking all the fun out of CGCC for myself.

Working my way through the process of language creation, I eventually finished the original interpreter, and, on the 5th of November, I created the GitHub repo for Keg.

After doing so, I wrote a few answers here on CGCC and, after a few weeks of inactivity, I decided I'd move on from Keg.

Then, around 5 months later, I decided I would browse through esolangs.org to see what languages there were. Looking through the recent edits, I saw something that would drive the second phase of Keg development: Teg.

At first, I was kind of offended, as it seemed like a personal attack on the little language I had created. Wanting to prove whoever had created this page wrong that they had created something better than Keg, I started plotting out a brick ton of operators to add.

But then I learned that A__ (I'm on mobile, using an external markdown editor, whaddya expect?) was actually friendly and that they were just mucking around (I think), I was a bit more relaxed about Keg development. (I now view Teg as a kind of compliment ;p)

Needless to say, after ~2 months of extensive planning, ~30 pieces of paper with sketches of what aspects might look like, I finally started developing Keg's first major expansion.

Now, this expansion contained features such as strings, integer scanning, new register commands and variables. But the interpreter I had wasn't suited for such new things. So I had to rewrite everything. It was at this point I made Keg transpiled… one of the best decisions I've made in regards to Keg.

Later on, it came time to deal with finer aspects of the expansion. Such an example of this was string compression. Now, here's the thing... this was at a time when I thought all characters were a single byte each. Ha, what a silly idea. I was thinking of having a 400k word dictionary making good usage of the ~100k Unicode characters. But then I learned about byte counts. So that's why there's only 60k words in the dictionary.

Why am I telling you all this? Well, I figured I would explain a little bit of the behind the scenes information about Keg. It may be fragmented, but it's the best I can do at the moment.

Main Features

The following is 'borrowed' from the esolangs page... Which I just happened to write ;P

The main inspiration for Keg comes from a want of an esolang where only symbols count as commands and everything else is pushed onto the stack as a literal. This is why there are only 12 functions, 7 ‘keywords’ and 8 operators. As such, this system allows for shorter programs where strings are involved (uncompressed strings in Keg are usually 1-2 bytes shorter than their counterparts in other languages).

Another design feature of Keg is the look of if statements, for loops and while loops. These structures take on the form of:


Where B is any of the three brackets ((/)[/] or {/}) and ... is any section of Keg code.

Some Basics

Most tutorials show how to print the string Hello, World!, so that’s what this tutorial will do as well. Here is a simple 21 byte program to achieve the goal.

Hello\, World\!^(!|,)

Hello # Push the characters "H", "e", "l", "l" and "o" to the stack
\,    # Escape the "," and push it to the stack
World # Push the characters "W", "o", "r", "l" and "d" to the stack
\!    # Escape the "!" and push it to the stack ^ #Reverse the stack
(!|   # Start a for loop and set the count to the length of the stack
  ,   # Print the last item on the stack as a character

In the above example, 6 new functions and keywords are introduced:

  • \ : Escapes the next command, and instead pushes it as a string (pushes its ASCII value)
  • , : Prints the last item on the stack as a character
  • ! : Pushes the length of the stack onto the stack
  • ^ : Reverses the stack
  • (...) : The for loop structure
  • | : Used in structures to switch from one branch to the other.

One of the most important parts of Keg is the stack, which is where all operations are performed. A stack is a type of container (or list) where the last item in the container is the first item to be operated on (LIFO – Last In First Out). In the following examples, the stack will be investigated.

3 # [3]
4 # [3, 4]
+ # [7]

In the above example, the numbers 3 and 4 are pushed onto the stack, and are then added using the + operator. The way it works is that the + pops what will be called \$x\$ and \$y\$ off the stack (the first and second last item) and pushes \$y + x\$ back onto the stack. Note that the order of \$x\$ and \$y\$ are important when using the - and \ operators, as \$x - y\$ doesn’t equal \$y - x\$ most of the time (as is the same with \$x \div y\$ and \$y \div x\$). This can be seen in the following example:

34-. # Outputs -1
43-. # Outputs 1 
34/. # Outputs 0.75 
43/. # Outputs 1.333333333333

Note that the . function prints the last item on the stack as an integer.

Keg has two output functions and one input function. When taking input from the user, the next line from the Standard Input and push the ASCII value of each character onto the stack. It will then push -1 onto the stack to signify the end of input (input as integers will be coming in a later version of Keg). Input is taken using the ? command, as shown in the example program:

# > Example text 
# Example text

The two output functions (. – Print as integer and , – Print as string) have already been detailed in other sections




INXW63CTMNZGS4DU is a imperative/functional 1D golfing language I have created the 16 may 2016.

Example code:


will print 25.

Normally, a lambda end with a ';', a call with a ')', so the same code can be rewritten like this:


But since it the end of line, it's not needed.



Neoscript is a language I have created.

Neoscript is a high-level, functional language compiling to JavaScript.


Hello world:

console:log("Hello, World!")
  • 1
    \$\begingroup\$ Does this language even have an implementation? \$\endgroup\$
    – Fatalize
    Aug 9 '16 at 12:42
  • \$\begingroup\$ @Fatalize Yes... The generated JavaScript just need to be launched with a special library \$\endgroup\$ Aug 9 '16 at 12:51


JLisp is a Lisp dialect I created the first day of November.

It's a basic Lisp dialect, probably TC and with bad support of scoping.

Hello world:

(write-line "Hello, World!")
  • \$\begingroup\$ Does this language still exist? The GitHub link is broken ... \$\endgroup\$ Jul 10 '18 at 0:02


Triangularity was created on January 5th, 2018 by me, Mr. Xcoder. It is a new esolang, which only has a few commands. Loops are not implemented yet (but that is, hopefully, about to change), so it’s definitely not Turing-Complete (it can evaluate Python :|). In fact, it can only participate in very simple challenges. It’s stack based. Some helpful resources:

Fun facts

  • A valid Triangularity program must have the character count listed in OEIS A056220.

  • Each Triangularity program must be padded with dots such that the overall shape of the program is rectangular, but the dots themselves must be laid out in nice, right-angled and isosceles triangles. Basic rules:

    • If you have N lines of code, each line must consist of 2N - 1 characters.
    • The Kth line, counting from the bottom, must be padded with K - 1 dots on each side.
  • Any character that is not a command is ignored (unless we’re talking about the newlines and the dots that make up for the padding).



17 is a stack based language that has a bit of a focus on the number 17, for example it uses base 17 and whenever it tries to pop off an empty stack it returns 17. It has blocks of code defined as < base-17 number > {< code >}. It starts at block 777 and then goes to whichever the block in memory location 0.


Hello world:

777 {
    44 $ 5g $ 66 : : $ $ 69 : $ 1f $ 52 $ $ 6c $ $ 5f $ 1g $ a $ 0 @

Count down from 100 to 1(inclusive):

0 {
2 #
1 -
2 @
2 <
0 @
2 # $$
a $

777 {
5g 2 @
0 1 @
0 0 @


Reflections is a 2D Language. A typical program (Fibonacci):

/*\   /# (0:0\
* 0  *\_ (0\/ :(0\
  \       v/#@/_ /
\  (1/   1)0)*
          : \\/

Here is the online interpreter to test it.

The most special thing is that you need to go to certain positions in the coordinate system to perform very simple actions (e.g. add, push numbers). It has 11 stacks, and you can move around values between them, but all other commands operate on the main stack.

It was the first language I created.

+++ GitLab repository +++ Online interpreter +++ Documentation +++ Chatroom +++



Ahead is a fungeoid I've been developing on and off for a few months. It is very much in a "perpetually-rolling release" state of development and features are still being specified and implemented, but what's there right now is very solid. Ahead is available on TIO.

Standout Features

Ahead is inspired by Befunge and ><> but takes its own liberties with the 2D grid style. Most obviously, most of the symbols are different (sorry polyglots!) Just for the sake of an example, here's the truth machine:


Rather than wrapping around when the head (or IP) reaches the end of a line, it "bounces off the edge" and begins traveling backwards to the previous cell. The board (program space) is bounded on all sides by the "edge", which is like a bunch of imaginary walls the head can't pass. Here, the # symbols are the edge and the .s are the space beyond.

.#IsO@ #.

To the head, the edge, and the space beyond, doesn't exist; it is an impenetrable field that is entirely inaccessible. The board is sized exactly to the smallest rectangle required to hold the entire program code, with gaps filled in with space characters, and fixed to that size. The board is not infinite, and combined with the lack of Befunge-style g or p commands self-modifying programs or those that use the board for storage are extremely difficult to write.

However, these edge bounces can be very useful and interesting tools for head movement, particularly when traveling diagonally.

The head can make 90 degree turns to the left or right using L or R. These are rather self-explanatory; if you're traveling > and hit an L, you start going ^.

However, the head can also make 45 degree turns with l and r. If you're going > (or East) and hit an l, you start traveling "Northeast"; that is, diagonally up-right. This is the only way to travel diagonally in Ahead (as of now?), and the head can only travel in these eight directions.

String state behaves very much like you expect, except it pushes a 0 (or NUL) to the stack when you enter. This makes it very convenient to determine where a string ends.

This couples with W, which prints characters off the stack until it reaches a 0. The combination of these two makes the Hello World program absolutely trivial:

"!dlroW ,olleH"W@

In general, the running theme of Ahead is to be a twist on traditional fungeoids with a smattering of useful builtins. Before this post gets way too long, you can check the full list of currently-implemented functions on the GitHub wiki (and of course, try them on TIO.) More updates are coming!



Programming language inspired by an old meme, Pepe.

Uses two stacks and uses only 4 characters: reRE.

Every command in it begins with R/r, followed by a certain amount of E/e, ex. REEE. The R/r define on which stack the command has to work on (1st or 2nd), while E/e define the command used. Both amount of letters and their case matters. List of commands is available on GitHub.


  • 1
    \$\begingroup\$ Why the downvotes? \$\endgroup\$
    – RedClover
    Apr 13 '18 at 14:47
  • \$\begingroup\$ who bulit????????? \$\endgroup\$
    – Fmbalbuena
    Nov 25 at 9:24

Turing Machine But Way Worse

By MilkyWay90 and ASCII_only

When you look at golfing languages, they confuse you and are very hard to learn.

But when you look at practical languages, they don't confuse you (normally) and are easy to learn (normally)

But what about a language which confuses you, but is easy to learn?

This is where Turing Machine But Way Worse comes in.

When I was learning about Turing Machines, I was annoyed by how they couldn't use I/O, so I built a programming language which does!

With the help of ASCII_only, we made a language which processes I/O while still keeping the point of a Turing Machine.

If you look at any submission for Turing Machine But Way Worse, you can see that it is just a lot of numbers. A LOT. But when you learn it, it will be super easy to debug and write your own programs using our debugger built-in.



Unlike other submissions, note that there isn't a self-referring pronoun!

@ is a functional language created by Gemdude46 designed for code-golfing.

Structure of a program

The language is made of a tree of function calls. Each character (with some exceptions) represents a function that may take as many or few arguments as it likes. Arguments are then read from directly after it in the code.

For example:

If instruction A takes 1 argument, B takes 2, C takes 3, and D and E both take none, then the @ code


Would be written in many languages like

   B(A(D()), C(D(), B(E(), D()), E())))

Instruction arguments are evaluated LTR unless the docs explicitly say otherwise. Arguments may not be evaluated at all or may be evaluated more than once.

Values and data types

@ has the following data types:

number - This is an arbitrary precision rational number.

vector - This is an immutable list of other values of any type.

If anything refers to a string, then it means a vector of codepoints.

Anything enclosed in braces is seen as a string literal. String literals are automatically ended on EOF. Should an EOF be encountered where an instruction should be, Š is used.


Hello world:




Truth machine:





Whoever said golfing languages had far to many useless builtins?

I'm afraid I also agree with that quote. In fact, I created W because I feel that golfing languages have way too many built-ins, and most of them are not useful at all in practical golfing competitions.

I initially tried to learn Pyth, but its syntax is too inconsistent for me to easily master. Therefore I decided to create a "more consistent" version of postfix Pyth which only uses postfix notation.

And then I decided to remove all the "inconsistent" accumulator and temporary storage stuff, in order to start a thought experiment. In this it has been suggested that temporary storage is neccecary. However W only has one single stack with no temporary storage.

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\$ It's funny - your description reminds me a lot of the original motivation for Pyth. Good luck! \$\endgroup\$
    – isaacg
    Feb 10 '20 at 19:28
  • \$\begingroup\$ I initially tried to learn Pyth, but its syntax is too inconsistent for me to easily master. Therefore I decided to create a "more consistent" version of postfix Pyth which only uses postfix notation. \$\endgroup\$
    – user85052
    Feb 11 '20 at 2:02

You must log in to answer this question.

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