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



I just finished ezfuck yesterday after 3 days of work. It works very similar to BrainFuck (in fact, all BrainFuck is valid ezfuck), but adds a few new commands and features:

  • Adds the * and \ operators

  • Adds in numberic literals, and allows most commands to take them as an argument

    • +++[>++++<-] == +3[>+4<-] ~= +3*4 (the last doesn't require a second cell)
    • >13 == >>>>>>>>>>>>>
    • ,-48 sets the current cell to the number entered (its char code - 48)
  • { and } allow direct control over the instruction pointer. As with ], the jump will only happen if the current cell value is 0.

    • {n will move the instruction pointer n commands to the left, while }n will move it n commands to the right. If n isn't supplied, it defaults to 1.
    • +{ == +[]
  • ^ allows directly setting the value of the current cell.

    • ^6*2 sets the current cell to 6, then multiplies it by 2.
  • V allows getting the current cell value to be used as an argument for a command.

    • ^6>V sets the current cell to 6, then takes the value, and gives it to >. Of course, you could just write >6, but I figured this may have some use with some creativity.
    • Allow the user to directly control the instruction/cell pointers: ,^}V, ,^>V
    • ^V is a no-op.

An uncreative "hello world":

^72. ^101. ^108.. ^111. ^32. ^87. ^111. ^114. ^108. ^100. ^33. ^10.
   H     e     ll     o         W     o     r     l     d    !    \n
  • \$\begingroup\$ I like this language. Here's a more shorter program that should print Hello World! (untested): ^72.+29.+7..>^111.>^32.+55.<.+3.<.-8.^33. \$\endgroup\$
    – Luke
    Commented Apr 29, 2017 at 21:10
  • \$\begingroup\$ @Luke Thanks :). Unfortunately I have yet to find a good use case for { and `}. I found them to be difficult to use at best. \$\endgroup\$ Commented Apr 29, 2017 at 21:18


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!



Trilangle is a 2-D esolang that I made in February 2023. Though not designed as a golflang, it ends up being fairly competitive in certain challenges.

It was originally inspired by Hexagony, though it came to be rather different. The biggest differences include:

  • Though the code grid is still hexagonal, its bounding box is triangular.
  • The memory model is a stack rather than a grid.
  • Certain letters and numbers are operations, expanding the instruction set but necessitating a separate "push" instruction.
  • When the IP walks off the edge of the code grid, it continues on the row or diagonal to its left, rather than on the opposite side of the grid.
  • Instead of bigints, the program operates on 24-bit integers.

The fact that it's a stack, and you can only modify the top of the stack, made Turing completeness difficult. See the old proof of TC'ness from Trilangle 1.0. The modern version looks rather different, since the threading operator means you can have multiple stacks. Though I haven't needed this for code golf yet, I use this in my implementation of selection sort (colorized version here).

String processing is a downright pain, though that's not entirely unintentional. Hello, World ends up being a somewhat longer program:

       H o
      o " !
     " o ( o
    e o o o l
   o " " " o "
  " , W r " ! 3
 l o o o d o : o
o " " " o ' ( @ .

Or, condensed (newlines, spaces, and trailing NOPs removed):


To help me design and debug these programs, I've invented an assembly-like syntax for these programs. It represents 2D branches and loops with BNG (branch if negative) and JMP (jump) instructions. For example, the (2-D) source code and assembly for cat are as follows:

   @ .
  . L \
 v i o .
. _ \ , .
0:  NOP
1:  NOP
2:  NOP
3:  NOP
4:  GTC
5:  BNG 12
6:  NOP
7:  PTC
8:  NOP
9:  POP
10: NOP
11: JMP 2
12: EXT

Of course, this contains a lot of extraneous NOPs. Any instruction that unconditionally redirects the IP is represented with NOP by the disassembler, so there's a flag to hide NOPs (-n on the CLI; always on in the online interpreter). With that flag set, the assembly just becomes:

4:  GTC
5:  BNG 12
7:  PTC
9:  POP
11: JMP 2
12: EXT

GTC and PTC stand for "getchar" and "putchar" respectively -- though they behave more like C's getwchar and putwchar, using UTF-32.

For the most part, the instruction set contains a lot of what you'd expect for an integer-only stack-based language -- arithmetic, bitwise operations, branch on sign, and I/O -- but it also contains a few interesting choices. For example, T (get current time) uses a unit of 1/97 second*, so that the full day spans from 0 at midnight to 0x7fffff right before midnight. The threading operator is also heavily overloaded.

Finally, just for fun: here's a program that doesn't halt on weekends.

   ' D
  ' - 2
 2 ' % 7
@ > { # -

*More accurately, there are 97.0903588 time units to the second.



Morsecco is a minimalistic, but mighty programming language using morse code for coding (hence the sparkling name). You need only a dot for the short beep, a stroke (dash or slash) for the long beep and a whitespace for the break between letters. This already makes it the coolest coding feeling ever, because on most keyboards you can put your right thumb on space key, two other fingers on dot and stroke key and start coding, hardly moving your hand and leaving the left hand free for your beer or pizza.

And if you think that this must feel great, just wait until you realise that it doesn't take long until you can actually create complex and even useful software that way! It's not just one more of that esoteric languages, where it's hard to solve even a simple task. If you know some morse codes, a little forth and are a type safety anarchist, you can almost start. Otherwise read the tutorial.

  • only one data type: a cell (can be text, numbers, addresses, executable code ...)
  • only two memory locations: a stack and an addressable storage
  • only three significant characters: dot, dash and space
  • only seventeen commands by now (including help and debug), but extremely easy to expand
  • includes an interactive shell that can be mixed with scripts
  • file writing and reading, WWW access, random numbers, numeric conversion even with float base
  • great golfing fun, because there are so many ways to do things including self-modifying code
  • git clone https://github.com/Philipp-Sasse/morsecco.git
  • or pip install morsecco

Just to give you a tiny impression, the following code defines a new command -. that adds 5 to a number, and demonstrates it by putting 3 on the stack, call the new command and output the result 8:

morsecco '.   . -.- .-  . -. .-- . -- -. ---'

Defining the command only takes a couple of characters in a language with only three symbols! Here comes an explanation (the highlighted Capitals refer to morse codes: . is the morse code for E and for the morsecco command Enter. Numbers are coded in binary, so 8 is 1000, translating to -...):

  • . -.- .- is Enter (.) 5 (-.-) on the stack and Add (.-)
  • the Enter command at the beginning puts this command (everything between the triple and the double space) on the stack
  • . -. .-- Enters the address -., to where we Write the command (you could also Read it there to use it like a variable)
  • . -- -. Enters 3 (--) and calls the new command (yes: as soon as you write to an address, you can use this address like a command to execute it!)
  • --- Output the top of the stack

Feedback and support is highly welcome.


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\$ Commented Sep 13, 2016 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



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.



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
    Commented Aug 19, 2020 at 10:54


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




An esolang created by me (jfioasd) that is neither like a golflang nor like a tarpit esolang.

Originally, it was going to be a golfing language with an octal encoding. While packing as many useful commands as possible, I made the language extremely minimalistic.

Later, I found that it's too hard to program in (because octal doesn't let you pack a lot of useful builtins and constants inside it that makes golfing easier) so I decided to turn it into an esolang.

minigolf is neither competitive as a golflang nor as tiny as a tarpit, rather somewhere between these two. It has high-level builtins (such as map and flatten) that make a lot of things convenient, but programs written in minigolf can actually be quite long.

For the naming, consider it as a portmanteau of 'mini' (as in Mini-flak) and 'golf'(as in mathgolf).



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\$
    – Riker
    Commented Mar 30, 2016 at 17:44
  • \$\begingroup\$ @EasterlyIrk I do. Thanks for spotting! \$\endgroup\$
    – Denker
    Commented Mar 30, 2016 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\$ Commented Jan 24, 2017 at 15:54

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



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
    Commented Apr 13, 2018 at 14:47
  • \$\begingroup\$ who bulit????????? \$\endgroup\$
    – Fmbalbuena
    Commented Nov 25, 2021 at 9:24


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



A 1D language inspired by Backhand.

It was inspired by the fact that v was used very commonly in the language, so I started to wonder whether Backhand's IP step of 3 was too big.

It turns out that if you want the IP to be bidirectional, only 2 groups of commands are actually needed: even-indexed characters for forward IP movement, and odd-indexed characters for backwards movement.

| is very common in Backhand as well. So I thought of generalizing Backhand's | to make it the primary looping structure of the language, while also doing an implicit shifting between the even and odd characters (due to the fact that IP shifting is very common in Backhand). This turned out to be extemely powerful, and also removed the need of > and <.

Regarding &, it came from a need to implement foreach/map/filter/reduce loops in a painless way. I took inspiration from x86's loop and used an accumulator to store the count. When used with stack shifting m, you could easily implement a lot of higher-order functions with it.

Speaking of program termination, infinite loops are not as common as programs that terminate, so I made the program terminate when the IP goes over the left bound.

However, later I added a ton of builtins to the language (taken from Keg, Factor, Jelly (particularly the Y builtin)), and they ended up being quite useless, to be honest. I've used up every ASCII character and there isn't any builtin in there that's substantially useful.


Desmoslang and Desmoslang Assembly

Desmoslang is a programming language I created. It is designed to use Desmos's capabilities. It was originally created just to see if I could make a programming language in Desmos, before I realized that it could be a decent golfing language (especially with some more built-ins). I am open to suggestions on what built-ins to add!



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
    Commented Aug 9, 2016 at 12:42
  • \$\begingroup\$ @Fatalize Yes... The generated JavaScript just need to be launched with a special library \$\endgroup\$ Commented Aug 9, 2016 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\$ Commented Jul 10, 2018 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 +++


You must log in to answer this question.

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