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



A golfing language created by DLosc (me), first published in April 2015.

Pip is a procedural language with infix operators. It is designed to be terse but still familiar to those who know C-like languages. For instance, it shouldn't be too difficult to see why this code:


prints the squares of the numbers 1 through 5.1 Pip also borrows ideas from array-based and functional programming languages.

Some interesting features of Pip:

  • Numbers and strings are the same data type, Scalar. This can become a pain occasionally, but makes for a lot less typecasting and sometimes has neat applications.
  • Many operators work itemwise on lists. For instance, [1;2;3]+[4;5;6] gives [5;7;9], and "a".[1;2;3] gives ["a1";"a2";"a3"].
  • By default, the contents of lists are concatenated together before printing, but there are a bunch of command-line flags that allow for different formats.
  • Regular expressions are built in, with a few interesting ways to shorten certain patterns.

Updates are irregular but ongoing; ideas and contributions are welcome!

Online interpreters:

  • Attempt This Online! Last updated in 2022 (version 1.0.2).
  • Do Stuff Online. Up to date with the latest commit. Runs programs client-side, which means infinite loops will hang your browser.
  • Try it online! Last updated in 2018 (version 0.18 aka Pip Classic).
  • Replit. Up to date with the latest commit; unlike the others, uses a REPL interface and doesn't support permalinks.

1Although, the code SQ\,5 with the -n flag does the same thing in 5 bytes instead of 9. But that's a bit less obvious.



Element was created by PhiNotPi (me) in March of 2012.

Element is a stack-based language that was written in and compiles to Perl. This is accomplished by a character-by-character substitution of operators with the equivalent Perl statements, with a bare minimum of additional processing for string literals (anything that isn't an operator).

The main memory structures are two stacks and a hash. One stack is the main stack, which is where I/O and most operations take place. The control stack is where Boolean operations occur and where comparison results are placed. This control stack is used for control flow (like while loops), hence its name. The hash is used mainly to store/recall variables.

Element is notable as being a very "simple" golfing language. The list of operators is short (only ASCII symbols, no letters or numbers), and there isn't overloading. There's no array support, code blocks, eval, and only a couple of string function.

This is not ongoing development.

  • 13
    \$\begingroup\$ It may be of interest to note that Phi wrote the entire thing using Notepad. :O \$\endgroup\$
    – Alex A.
    Commented Sep 8, 2015 at 21:49


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

Bubblegum was designed to be unbeatable in trivial challenges, which require printing a very short string or a wall of text.

While Turing complete, the actually usable features of this languages consist in decompression of DEFLATE and certain LZMA 2 streams with no overhead, as well as base conversion from binary to printable ASCII.

  • 12
    \$\begingroup\$ i honestly thought it was incredible that you found two programs with the same sha-256 hash until i looked a lot closer \$\endgroup\$ Commented Sep 17, 2015 at 17:20
  • 4
    \$\begingroup\$ How is Bubblegum Turing-complete? Are you making assumptions about the set of Python programs whose SHA-256 is 5e247c455fde7711206ebaa3ad0793114b77a6d16ed0497eff8e3bf98c6dba23? \$\endgroup\$ Commented Oct 7, 2015 at 13:13
  • 3
    \$\begingroup\$ @Gilles Yes. For every Python program, there are infinitely many comments we can append, so it should be possible to change its hash to 5e...23 without affecting functionality. \$\endgroup\$
    – Dennis
    Commented Oct 7, 2015 at 13:25
  • \$\begingroup\$ @Dennis How is value “5e247c455fde7711206ebaa3ad0793114b77a6d16ed0497eff8e3bf98c6dba23” chosen? It is just a random choice? Do you know any preimage of the hash? \$\endgroup\$
    – v6ak
    Commented Mar 13, 2016 at 18:50
  • 3
    \$\begingroup\$ @v6ak That is the hash of the program that computes the addition of several inputs or does a primality check for a single one, which can be found on the esolang page. \$\endgroup\$
    – Dennis
    Commented Mar 13, 2016 at 18:53


I created Snails in March 2015 for the "Language Design: 2-D Pattern Matching" question. It is also known as PMA (Planar Mollusk Automaton). Source code (C++) and documentation are found on GitHub.

As you may have guessed, the input is treated as a 2-dimensional grid of characters. The name comes from the image of a snail moving over the grid and executing commands. The snail leaves "slime trails", which cannot be crossed later in the program. The execution flow is controlled by backtracking, as in a regex.

Its flexibility in solving different challenges is currently limited, as the only possible output is a single nonnegative integer. Nevertheless, several suitable code golf challenges have appeared since the language's creation; if it is possible to solve a challenge with 2D input in Snails, it is usually the shortest language. The shortest solution often has factorial complexity, making the name Snails doubly appropriate.



Japt is a shortened version of JavaScript, created by me in early November 2015. Online interpreter

Japt is heavily based off of JavaScript. After transpiling Japt's syntax features to JS, it is evaluated as vanilla JS. This allows easy building of an online interpreter. Some of the main features are:

  • One-letter functions: each lowercase letter corresponds to a specific function, which is different on strings, arrays, and numbers.
  • String compression: Japt uses the shoco library for string compression. Wrapping a string in backticks tells the interpreter to automatically decompress it.
  • Anonymous functions: XY{X+Y} is transpiled to function(X,Y){return X+Y}, as is @X+Y}, and in some cases, simply +. This allows for easy creation of functions on the fly.
  • Unicode shortcuts: All 1-byte characters from ¡ to à transpile to longer sequences of chars.
  • And much more...

Check out the vote-by-vote showcase!



Perseus is a high level compiled native (open-source) programming languages that compiles directly to x86 machine code without any external assembler or other dependencies. It was created by me and started out as an Assembler for Windows systems, now there is a team of 5ish people. The language is intended to be both easy for beginners and as bare bones as possible. Here is some code:

// WM_SIZE hook, changes the width and height variables on resize
func OnSize(dword hwnd, dword message, dword wparam, dword lparam) {
    cxClient = Math.LoWord(lparam)
    cyClient = Math.HiWord(lparam)
    GetClientRect(hwnd, @Area)

It is a do-what-you-want and write-what-you-think language and while it isn't really object oriented, it allows for the creation of some object-like structures. Perseus can compile both standalone programs and DLLs.


Because binaries compiled by Perseus are as small and vanilla as possible, the language is perfect for Democoding/Sizecoding. When the compiler is combined with an advanced packer (I recommend MEW11 SE), it generally beats or equals the size of crinkler-linked C/C++ programs. Also, because the compiler is open source, you can further improve the size of binaries by tweaking the internal translation layer. The minimum compiled binary size is about 675 bytes.

Perseus may be the only language that enables users to write bytes to the compiled binary in a useful way right from within the code.


  • Working (not stable) build + Documentation + Tons of Examples: Github
  • When the stable is out, you can download it (or compile in the cloud without downloading) from here: codeperseus.com

Please note that the Perseus team is currently porting the Perseus compiler away from VB.NET (because it is way to clumsy), so the final version of Perseus 6 is not released yet, but the above works just fine. It comes with a portable Notepad++ version customized for Perseus.


Unnamed / Phi's Golfo Supreme / Compound / GolfLang

Umm.... yeah. I don't have a name for this yet, it's a new project. Unfortunately most abbreviations of "Phi's Golfo Supreme" like "PGS" have been claimed by various organizations.

PGS is a golfing language, partly based off my previous language Element. It will be primarily a stack-based language, but with several features that go against a pure stack-based paradigm. At this point, the list of intended feature is much longer than the list of current features.

Basic syntax

There are several different types of operators/objects in PGS.

The most basic is a scalar, like 42 or hi which are simply pushed on the stack when executed, assuming normal execution.

Nest-able arrays can be created with [] like [2[3 4][5]].

"Normal" operators like *+/-^ pop two elements off the stack, perform that operation, and push the result onto the stack. The actions of operators can be modified by varies "modifiers." When performed on arrays, the default action is to perform the operation pair-wise.

Modifiers like "1-level reduce" | are pushed onto a "active modifier stack" which is independent of the main stack. Whenever an operator is performed, all applicable modifiers are removed from the active modifier stack and put in a "selected modifier stack" which is used in the process of evaluating commands. Modifiers can be stacked.

Some special ops include map :, which marks the top item of the stack as being a list. Whenever that object is used in an operation, that operation is performed on each item in the array separately. This method of applying "maps" means that an object can used as the subject of a map even if the : is used early in the program, the object is buried in the stack and dug up again, and then operated on.

I am working on adding lambda expressions. All of my work on this has been unpublished, but I basically have some form of unnestable thing working right now.

Trivia: This language has been written in Perl, compiles (somehow) to Perl, and was written in Notepad.

  • 5
    \$\begingroup\$ Phi's Golfo Supreme is the only official name. \$\endgroup\$
    – Alex A.
    Commented Sep 15, 2015 at 23:39
  • 4
    \$\begingroup\$ Why don't you call it "Phig", pronounced "fig"? \$\endgroup\$
    – mbomb007
    Commented Sep 17, 2015 at 13:52
  • 2
    \$\begingroup\$ ^ (Or "Phigs", which has an 's' for "supreme") \$\endgroup\$
    – mbomb007
    Commented Sep 25, 2015 at 19:05
  • 5
    \$\begingroup\$ PGS is truly perfect - "Parental Guidance Suggested". \$\endgroup\$ Commented Oct 19, 2015 at 3:16


I, El'endia Starman, created Minkolang in mid-October.

Minkolang is a stack-based semi-golfing (2+1)D language heavily inspired by Befunge and ><>. I say it's a semi-golfing language because a good number of functions are one character, but I also keep simplicity and intuitiveness in mind. Plus, the fact that there are few or no ways to work with the stack as a whole means that it can never be as concise as true golfing languages. (I.e., I can't apply a function to every element on the stack at once, though I am actually now thinking on how to do that.)

One major element that sets Minkolang apart from other 2D languages is that for loops, while loops, and recursion are directly implemented. These, combined with its stack manipulation, array storage, and reflection capabilities make it a particularly powerful 2D language.

The official interpreter is written in Python 3 and is available here: GitHub.



Pyke is a stack based code golf language created by me, muddyfish, starting in February 2016. I decided to build it to test my knowledge of Python and how long it would take for me to get a basic golfing language. I got the language fully extendable in two days using a homebrew plugin system.

Each function (or node as I've called them) can do different things depending on the size of the stack, the types of objects on the stack as well as the last item on the stack.

Pyke's stack uses a first-in last-out system for managing the stack. If ever the stack isn't long enough for the current node to function, it uses the eval_or_not function which takes input from the user and tries to eval it, otherwise returning it as a string.

It uses Python 3's new argument annotations to make the typecasting easier as well as being able to get extra data for the current nodes. This extra data immediately follows the node and is constant throughout the program. It can take the form of numerics, strings or Pyke's AST.

When the program ends, it prints out the contents of the stack implicitly.

Hello World in Pyke: "Hello, World!

Try Pyke here!

  • \$\begingroup\$ How do I install and use it? Are there any tutorials? \$\endgroup\$
    – m13r
    Commented Jun 28, 2017 at 13:17


Stax is a golfing language created by me. Unique features include:

  • Compressed string literals
  • Built-in rational support
  • Online interactive debugger
  • Code is written in ascii, but can be "packed" to a single byte character set for savings
  • Two implementations: typescript and C#

It's got a github repo, an online interpreter, and documentation.

I'll finish with Hello, World!, which uses a single compressed string literal.



This language was created by me in May 2017.

shortC is a "programming language" for code golfing. Frequently-used C functions/keywords are shortened into capital letters. shortC automatically inserts closing quotes, closing double-quotes, final semicolon and closing curly-braces. It only auto-inserts a semicolon before each final closing curly-brace.

Conversions that shortC performs as of 5/23/2017 UTC-23:54:

  • A -> int main(int argc, char **argv){
  • B -> int main(
  • C -> char
  • D -> #define
  • E -> else
  • F -> if(
  • G -> getchar()
  • H -> switch(
  • I -> int
  • J -> puts(
  • L -> long
  • M -> strcmp(
  • O -> for(
  • P -> putchar(
  • Q -> gets(
  • R -> printf(
  • S -> strlen(
  • T -> return
  • U -> usleep(
  • W -> while(
  • X -> while(1){
  • $ -> system(

(there are a lot more now but I'm inactive so I'm not going to bother updating this)



Joe is my pet language. It is my love for functional programming and conciseness distilled into a minimal language. It has it's roots in J, from which I got many of the ideas. The language is still very much a work-in-progress, but it has shown great potential.

Joe is designed from ground up for implicit function composition and looping. That means, you should never ever need to explicitly refer to arguments of a function, nor should you ever need to explicitly write a loop of any kind. In theory, at least.

The interpreter is written in Python, but the language itself is basically uncompileable, and thus couldn't resemble Python in any way. If you have experience with APL, J, K or Q, you can pick up Joe really quickly. If not, I would recommend saving yourself from the trouble.

An example (indented lines are code):

   F1 2 3
2 4 6
   1F1 2 3
3 5 7
   1 2 3F1 2 3
3 6 9


Fourier is a simple language which looks similar to Golfscript or CJam but is more familiar in syntax to Brainfuck.


Created by me, Beta Decay, the main basis of Fourier is the accumulator. This is a variable which all operators use as their main argument. Because of this, Fourier can only handle integers and so floating point arithmetic and string related operations or pretty much impossible.

Fourier has been used in a few challenges so far (and one question) but, because of PPCG's usual requirement for an output string instead of simply numbers, the programs have been extremely long and difficult to golf. This has been fairly problematic and there haven't really been any "fun" Fourier programs, so I'll show you some.


Fibonacci sequence


Try it online!

Now if you are fairly familiar with the syntax of Fourier, you may be happy with this program, except for maybe the x at the start of the loop: this hasn't been defined before and in older versions of Fourier threw an error. Instead, all possible variables are preinitialised to zero.

The part of the code which used the most bytes was i^<k{1}{44a32a}. This checked to see if the iterator (defined as i) is below the input value. If so, then output a comma and a space. To see why this is here, see these two examples for input 5:

Output without i^<k{1}{44a32a}:

0, 1, 1, 2, 3, 

Output with i^<k{1}{44a32a}:

0, 1, 1, 2, 3

So it's really more of an aesthetic choice.

ASCII table

Similar to the requirements of this challenge but only prints the printable ASCII and takes no input.


Try it online!

This is a very basic example of how to implement a for loop in Fourier: create an iterator variable and set it to your lower bound, then set the repeat loop's condition to your upper bound. All you have to do now is increment the iterator and set the iterator to the new incremented iterator.

Others from around PPCG

By other people:

By me:

More can be found here.

And, finally, the question about golfing Fourier:

Online Interpreters

Note that FourIDE will be updated with new functionality and bug fixes more often.




Grime is a declarative language based on Boolean grammars that I created in March 2015 for the 2D pattern matching challenge. A Grime program (more properly called grammar) takes in a newline-separated string, and tries to match one or more of its rectangular sub-patterns, like a regular expression but in two dimensions. The exact output depends on flags, but you can match against the whole input, search for one sub-rectangle, search for all sub-rectangles, and return their number, positions and/or contents. The only existing interpreter is written in Haskell.

A Grime grammar consists of one or more definitions, each of which defines a nonterminal symbol that may or may not match a given rectangular pattern. Complex definitions can be created using simple ones, and nonterminals may recursively refer to themselves. An example grammar is


which matches correctly formed Prelude programs. This means that any vertical column may contain at most one of ( or ) in total, and the parentheses must be matching if their vertical coordinates are ignored. See the 2D pattern matching challenge for details.

Grime is relatively golfy on certain 2D matching problems like the above, but not so golfy on others.



𝔼𝕊𝕄𝕚𝕟 is a code-golfing language I made in late October 2015. It compiles to ES6 - in fact, it's basically ES6 except with a stack, basic aliasing, and a whole lot syntax changes. Of course, it's a work-in-progress, but version 1 is stable enough for general use.

WARNING: The printable non-ASCII values that 𝔼𝕊𝕄𝕚𝕟 uses can create disproportionate byte-to-char ratios. Treat this as a challenge of some sort.

Quick example:


This outputs 1 to 100.

  • \$\begingroup\$ It should be noted that the language name is ESMin, but the characters are blackboard-bold, which aren't supported yet, for the most part. \$\endgroup\$
    – mbomb007
    Commented Nov 5, 2015 at 17:47
  • \$\begingroup\$ I can see it on my Mac, though. (Not on Windows 7.) \$\endgroup\$ Commented Nov 5, 2015 at 18:34
  • 3
    \$\begingroup\$ I think instead of "unprintable ASCII values" you want to say "(printable) non-ASCII characters"? \$\endgroup\$ Commented Nov 15, 2015 at 19:11


Jolf is yet another JavaScript variant; is procedural, like Pyth. It's GitHub repo was made around Nov. 15. It transpiles to JavaScript.

It's a really handy tool, and I use it all the time when coding in JavaScript. Here is the interpreter! And some documentation, because you're such a nice person.



This language was created by me, Fricative Melon, recently, though it is based on StackFlow. I liked the idea of StackFlow, but it was clunky and had no interpreter (and I didn't want to write an interpreter for it), so I made my own variation. The main idea of StackFlow is to have a fixed starting number of stacks, and a fixed number of symbols for each stack, and have all operations be popping from stack to stack and pushing symbols before each pop, with each symbol going to different stacks and pushing different symbols when popped, the inspiration for its creator being Magic the Gathering, and proving languages Turing complete by implementing it in them.

My version is completely "type" safe with no wasted bits, and every program is a valid one, if you add enough 1s to the end of it. The cat program is 11, and a program that does nothing is 01. The null program is not actually a valid program, and there are no trivial quines. The interpreter is here.

The name is a variation of "AnyFlow" since although the current interpreter uses stacks, using another data structure is a one line change, and you could even mix and match them. There is really no fixed stackiness of the language.

This is my first "new" language, so let me know how I could improve the documentation, it may be a bit messy right now.



By elected moderator, Dennis ♦

Sesos is an assembly-like language based on Brainfuck. It has a code-head and data-head, and has ten basic commands:

fwd <n> moves the data-pointer n cells forward
rwd <n> moves the data-pointer n cells backward
add <n> adds n to the current cell
sub <n> subtracts n from the current cell
get gets a value from STDIN
put prints a value to STDOUT
jmp creates an entry point and jumps to the corresponding jnz or jne
nop creates an entry point
jnz creates an exit point and jumps to the corresponding jmp or nop
jne creates an exit point and jumps to a position read from STDIN if it is before EOF

It is compiled to sasm, or assembled Sesos, which is the used to determine the final code size.

  • \$\begingroup\$ Why not let Dennis post his own languages? This is the second time you've posted one of his languages, and this one is only 3 days old. \$\endgroup\$
    – user45941
    Commented Jul 18, 2016 at 4:07
  • 1
    \$\begingroup\$ @Mego The question does not say that you have to post your own languages; there is nothing preventing me from posting it. I have not been aware of any other finished new esoteric languages publicly announced in chat, so it's just a coincidence that this is also Dennis'. Furthermore, I'd be happy to delete the answer so Dennis can post his own, but Dennis hasn't commented about this yet. \$\endgroup\$
    – ASCII-only
    Commented Jul 18, 2016 at 5:45
  • \$\begingroup\$ It just seems strange that you have now repeatedly posted other people's languages here. Did you talk to Dennis either time before posting? It's a matter of courtesy. \$\endgroup\$
    – user45941
    Commented Jul 18, 2016 at 5:46
  • 4
    \$\begingroup\$ I've undeleted both of your posts. I'm perfectly fine with someone else posting them. \$\endgroup\$
    – Dennis
    Commented Jul 28, 2016 at 14:49


Jellyfish is a two-dimensional language created by me, Zgarb, in January 2016. It's largely inspired by J, and the name is a combination of Jelly (another J-like language) and ><> (pronounced "fish"; a two-dimensional esoteric language). Jellyfish began as a challenge here on PPCG, and then took on a life of its own. It's still under active development, but you can play with it on TIO. You can also discuss it in the dedicated chatroom.

The standard library of Jellyfish contains mostly arithmetic and array manipulation functions, and as with J, multidimensional arrays are the only nontrivial datatype. My plan is to re-implement a large part of the standard library of J, suitably modified for the computational model of Jellyfish, as well as any interesting features I feel like implementing.

While the standard library of Jellyfish is largely borrowed from J, the syntax is what makes it unique. Its source code is arranged on a 2D grid, and each grid cell may contain a value, a function or an operator. Values are either numeric or string literals, or special input values that are read from STDIN during execution. A function takes as its argument the two nearest values to the south and east (if they exist), and most functions have both one-argument and two-argument forms. Operators are second-order functions: they take one or two functions as inputs, and produce new functions, which are then called on the arguments of the original functions. A large Jellyfish program is a complex network of function and operator calls and reused values.

Here's an example program to compute the average of a list, or 0 if the list is empty:

 #  i

The i is replaced by input from STDIN; lists are taken in the format [1 2 3 4]. The + is addition, and it takes arguments i and 0. Now, / is the fold operator: it takes the function +, and folds it over the list 0 using initial value i (the arguments of +). This argument order is of course incorrect, so we apply the operator ~, which flips the arguments of /+: it now folds + over the list i with initial value 0; in other words, it computes the sum of i with default value 0. On the second row, the function # computes the length of the list i, and % divides the sum by that. Finally, p prints the result of the division to STDOUT.


Billiards, Created by Me (HyperNeutrino)

This link ^ includes the interpreter (in one source file) and the documentation/README.

Inspired by a challenge by PPCG User @PhiNotPi's, the concept behind this language is that you have a large setup of machines that operate on a bunch of balls carrying values which fall down through the machine.

Advantages: Looks interesting, shorter than many languages. Disadvantages: Heavy on bytes because of all of the special characters, longer than Jelly (obviously).

Here are some examples of code you can write with it.


Prints theoretically all ASCII characters. Step-by-step run-through:

The 1 creates a ball with value 1
It falls onto the first backslash, which deflects it to the right
It hits the ^ and begins levitating
It hits the . which outputs its value as per (char) value
It hits the first slash which deflects it to the right
It hits the next backslash, and since it is moving sideways, it is deflected down and ceases levitation
It hits the ↑ and its value is incremented
It hits the final slash and is deflected to the left, returning to the ^, which continues the loop.

This language has gone through many modifications; when I started with it, this was how you added two numbers up to 3 + 3 = 6:

  a          b  
    c          d
           _ __/
1           \\_/
\_/          _K1
  \_/      \  \/
 \/         __/ 
 /\          /  
_ __/       _   
 \_/       \__  
  \/ _______/   
\  \/           

Now, you do this:


It's so-so for golfing; it's not very short and I suspect that it lacks Turing-completeness. (I will try implementing Rule 110 on this to see if that's true. It doesn't have conditionals, so... it requires hacky workarounds such as using the metadata of a gridspace and splitting the ball for comparison and return values in order to do it).


STATA (free interpreter)

STATA is a statistical programming language similar to R that is commonly used for economics papers. However, since many challenges on this site require a free compiler/interpreter for valid languages, I created a partial interpreter supporting some of the commonly used golfing commands from STATA.

Currently supported commands include set obs, local, global, generate, display, replace, list, and forvalues, though each one only supports a limited subset of the corresponding proprietary STATA command.

The free STATA interpreter was created in February 2015 by me, bmarks, though suggestions and edits are welcome from any user.



Hassium is a very useful interpreted programming language created in C# by myself (JacobMisirian) as the lead developer and with the help of my partner Zdimension.

Hassium contains builtin classes that include File-system IO, Networking, Drawing, Cryptography, and more.

Hassium has a syntax that stems from Python, C, and C# and contains many classes that are exactly the same to it's C# equivalent, meaning you wouldn't have to learn all the different Hassium classes if you are familiar with C#. Take the StringBuilder class for example:

func main () {
    sb = new StringBuilder();
    sb.append("Hello ");

As you may have noticed Hassium is a fully object oriented language and you can create your own classes and methods, as shown here:

class Person {
    func new (name) {
        this.Name = name;
    func greet(this) {
        println("Hello my name is " + this.Name);
func main () {
    slim = new Person("Slim Shady");

Hassium has support for most common elements of modern programming languages. It has the for, while (else), do while, and foreach loops as well as the usual if statements, arrays, and dictionaries. There are also LINQ-like functions and mapping.

Hassium is fairly well documented and the wiki can be found here.

On the HassiumLang.com website there is an online interpreter where you can execute code and have the output in your browser, as well as share your code with your friends.



I have created INTERCALL in june 2016.

Intercall is a anti-golfing language. Each code must start with a 116 character long header, to prevent code golfing. The header is:


Example code (Without the header):


Is just a quine.

A "Hello, World!" program can be found here.

  • 2
    \$\begingroup\$ @Downvoters why?? this is hilarious. \$\endgroup\$
    – MD XF
    Commented May 24, 2017 at 23:47


S.I.L.O.S is a language I created with some loose inspiration (retrospectively) from Trump Script.

S.I.L.O.S "Features"

  1. Arrogance S.I.L.O.S is an arrogant name as it stands for.
    • Superb
    • Interpreted
    • Language's
    • Obviously
    • Superior
  2. All of the slowness of the JVM with all of the challenge of assembly
  3. Limited error messages with a default behavior of on error resume text
  4. Readable while remaining a turing complete minimalistic language
  5. Numbers can be used as variable names
  6. No declaration needed of variables

In short S.I.L.O.S is clearly the language of the future and ought to provide speedy development. Feel free to take a look at the GitHub here.



Your Mom

Your Mom is a language that I have created after a message of mbomb007 on The Nineteenth Byte:

I think someone should create a language called "Your Mom", just so that during an argument over which language is a better one, they can interject that "Your mom is a better language"


Your Mom is a stack-based golfing language using Unicode characters, and implementing the Jelly compressor (not the dictionary based compressor of Jelly), a simple compression algorithm.

Since without code, I get downvotes, here is a snippet:


Push 1 (¥), create a one-character function that increment the TOS (€⊞), and loop while the TOS is not zero (@).
Basically, this snippet do nothing, but could stop on integer overflow.

  • 2
    \$\begingroup\$ OK, why so many downvotes? \$\endgroup\$ Commented Jul 17, 2016 at 15:09
  • 10
    \$\begingroup\$ The name, most likely. \$\endgroup\$
    – Fatalize
    Commented Jul 17, 2016 at 19:38
  • 1
    \$\begingroup\$ @Fatalize But all other posts using Your Mom have upvotes \$\endgroup\$ Commented Jul 17, 2016 at 19:40
  • 4
    \$\begingroup\$ They have upvote because of the code. Here the name of the language is taken into account for votes, since it's the presentation of the language \$\endgroup\$
    – Fatalize
    Commented Jul 17, 2016 at 19:45


Woefully is a 2d language. It is named Woefully, because everyone knows that adverbs are the best language names, and also because the byte counts will be saddening. Example:

Woefully, 1000 bytes

or something like that.

Woefully works rather differently than most programming languages, and even 2d programming languages. It originates from ideas coming from whitespace, and ideas from 2d languages, as well as, initially, hiding messages in text. the last one, because originally it was going to have letters and other characters to complement spaces, but then I changed my idea. It is based on typographical rivers.

How it works

As I said, this language is different, it is very different to befunge or anything else. Unless it is. In which case I would be a little disappointed my brain keeps coming up with already used ideas.

Woefully uses lines of spaces as its commands. Not this kind of line of spaces,

|     |

this kind

| |
| |
| |

specifically, this command is the A to B command, which moves a value on stack A to stack B.

As I mentioned, there are two stacks, stack A and stack B. Almost all commands that push values push to A, except dupe, and the command specifically for pushing to stack B (A to B).

Different types of lines execute different commands:

||| |  push operations
|| |
| |

| |
| | stack operations
| |

| |
|| |  Other stuff like i/o, and the stuff used as control flow
||| |

The specific command of a type of command is determined by it's length.

Push is simply push length of the push command - 3, the other two types are taken from a table, after subtracting two, and modulo'ing

Commands get concatenated together:

|||| |
||| |
|| |
| |
|| |
|| |
|| |
|| |
|| |
|| |    (this program prints 1 a bunch, and puts a bunch of ones on the second stack)
||| |
|||| |
||||| |
|||||| |
||||||| |

note that the two top commands are connected by a two long line command. two long commands are nops.

this program halts

| |

Single length paths halt the program

You can also have multiple paths (only executing a second with a special command)

| | |
| | | (does nothing, the second isn't even executed even if it did something)
| | |

There aren't any conditionals like in a regular programming language, except for the "not zero" command, which pops a value from stack A, pushes one if it isn't zero, and zero otherwise. if you combine this with a move command, you get control flow.

Move command

All programs without this command loop infinitely, or immediately halt

This is because there are two pointers. We have the instruction pointer, which executes commands discussed before, but there is also the char pointer. The char pointer points to a char (obviously) in the program source. It begins pointing at the first char in source. When the program starts, the instruction pointer appears at the char pointer's character, finds the first space it can, moving forward (the search including the character pointed at by char pointer). It then executes the path that space is a part of, from that space. when it reaches the end of this path, it goes back to the char pointer, and does it again. The move command changes the position of the char pointer.

Using the "not zero" command with the "move" command (and usually the multiply command to avoid actually excessive bytecounts (even this language has standards)), we can change the the path the program executes if a value in the stack is non-zero, and have Turing completeness. If you want to see what changing the path looks like, the truth machine I made is probably your best bet.

  • \$\begingroup\$ So can Woefully do anything? So far the examples haven't convinced me \$\endgroup\$
    – Beta Decay
    Commented Sep 13, 2016 at 8:47
  • \$\begingroup\$ I didn't want to make this post longer than it already is, but thinking about it would be possible to do something in short code \$\endgroup\$ Commented Sep 13, 2016 at 8:49


github. Created by luser droog (aka M. Joshua Ryan). Began as an exercise in understanding the obfuscated APL calculator program known as the incunabulum, and later adding capabilities and extensions.

inca exists in two distinct (more-or-less-)fully-realized versions. The original inca.c is integer-only. inca2 has support for char, int, and double datatypes. A third version was begun which collapsed under the weight of its own obfuscation. The integer version is available online.

All of these programs expect a 32bit environment. See the Readme files 1 2 3 or the wiki for more usage and explanation, but it basically provides the basic pre-80s features of APL languages including dot and over operatprs which apply to user functions as well as built-ins.

It has been used in 2 challenges:

ASCII Ice Cream
Generate a Universal-binary-function Lookup Table

And I'm designing the next version with the intent to present an amazing answer to this challenge:

Draw the Utah Teapot



The next version is partly working and will offer amazing "killer" features.

  • Portability. No more intptr_t foolishness. Source should compile and execute on any platform which can run xterm. Tested on Cygwin64+Windows 10.

  • "All" whitespace is optional (except to separate numbers). The symbol lookup is designed around prefix-searching so multiple defined symbols may be juxtaposed into one "identifier" which is then split at execution time. Also, all punctuation characters, indeed anything not whitespace, part of a number, a paren, a quote, or a left-arrow is considered a valid identifier. (For testing and "normal" programming, it is advisable to separate symbols with space for better readability.)

  • Outer parens are optional. 3) == 3. (3 == 3. 2&+)3 == 5.

  • Idiom recognition. Since all function names are treated as identifiers, and juxtaposed identifiers are parsed at execution time, sequences of functions can be redefined. This may permit easy testing of "slow" programs by selectively replacing sequences of function symbols with faster versions.


Update: starting to get some results.

josh@LAPTOP-ILO10OOF ~/inca/olmec
$ ./olmec

 0 1 2 3 4 5 6 7 8
 0 1 0
 1 0 1

        'hello, world!'
Segmentation fault (core dumped)

Needs some work. :)

$ ./olmec
 0 2 4 6 8
        'hello world'
hello world

Update May 2016: Implemented bracket indexing which produces lvalues that can be on the left of the assignment arrow.

        a←10 10⍴' '
        a[5;5 6 7 8 9]←'CROSS'
        a[4 5 6 7;7]←'WORD'

           C R O S S

Belated Update Sept 2016: Some months ago implemented direct definition of functions, "del" definitions with labels and branching. Current list of functions and operators: https://github.com/luser-dr00g/inca/blob/master/olmec/tables.md



QBIC is QBasic's Interpreter for Codegolf. I made it to bring QBasic into the code-golfing arena. Working on it is a ton of fun. It provides a short-hand for QBasic's expansive syntax and language constructs, and it adds a few tricks of its own.

The project can be found here: https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ?usp=sharing

It is built and run entirely in / through QBasic. There is (as of yet) no web-interpreter or IDE.

Samples of usage are here: Showcase of Languages

To get started with QBIC

  1. Download the project to your computer
  2. You probably need DOSBOX or similar to run it
  3. Edit qbic-in.txt in your favorite text editor a text editor that supports QBasic's ASCII table. I use Notepad++ with the Western European / Windows-OEM character set.
  4. Fire up QBasic, open and run QBIC.BAS
  5. Enter command line parameters if necessary
  6. QBIC will now run the interpreted QBasic for you.
  • \$\begingroup\$ I finally tried QBIC, and was surprised: It throws an error if I use QBasic, because it requires QuickBASIC – which I wouldn't have guessed from your description. I'm familiar with the difference, as I bought QuickBASIC 4.5 in 1990, before QBasic existed, back in MS-DOS 4.01 days. QBasic was released in 1991 with MS-DOS 5.0, and is a scaled-down version that can only interpret .BAS files, whereas QuickBASIC can also compile .BAS to .EXE. I used QB 4.5 (and later Microsoft BASIC 7.1, a successor to QuickBASIC, filenamed QBX.EXE) until transitioning to Turbo Pascal in 1994 (and later C/C++). \$\endgroup\$
    – Deadcode
    Commented Mar 30, 2023 at 3:52


Cubically was created in 2017 by me, MD XF. It is built around the main piece of memory, a Rubik's Cube. To my knowledge there were (and are) no existing languages with a similar design.

A 3x3x3 memory cube (the default) begins with this initialization:

   000           (top face)
111222333444     (left, front, right, and back faces, respectively)
   555           (bottom face)

Each number represents a cubelet (in a 3x3x3, there are nine cubelets on each face). After performing a 90° clockwise right turn (R1 in Cubically source), it would look like this:


There are two other pieces of memory, which are simply registers - the notepad and the input buffer. The input buffer is read-only and always contains the most recently inputted value (values are only inputted when $ or @ are hit in the source). The notepad stores the result of mathematical operations.

Mathematical operations are performed on face values. A "face value" is the sum of adding all values on the given face index. For example, the face value of the top face (indexed 0) immediately after initialization would be 0. The face value of the left face would be 9, the front would be 18, etc. The notepad (face index 6) and input buffer (face index 7) are initialized to zero.

Some mathematical operations are:

  • +x - x specifies a face index, add its value to the notepad
  • -x - x specifies a face index, subtract its value from the notepad (storing result in notepad)
  • _x - x specifies a face index, modulo the notepad by its value (storing result in notepad)


A cat program would look like this (no cube manipulations required):

(              open loop
 ~              read input to input buffer
  -1            subtract 9 from notepad
    /1          divide notepad by 9 (yielding -1)
      =7        compare notepad and input buffer for equality
        &6      exit if notepad truthy (notepad == input buffer)
          @7    print input buffer
            )  close loop


Cubically has been developed into a mostly functional language thanks to the collective efforts of me, TehPers (many bug fixes and feature ideas), Kamil Drakari (more bug fixes, feature requests, suggestions and algorithms) and Destructible Lemon (Cubically's name).

Useful links:


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
    Commented Dec 31, 2018 at 23:22
  • \$\begingroup\$ @MilkyWay90 Beetlejuicing! \$\endgroup\$
    – GMills
    Commented Feb 20, 2019 at 15:15
  • \$\begingroup\$ @GabrielMills Beetlejuicing? What's that? \$\endgroup\$
    – MilkyWay90
    Commented Feb 20, 2019 at 16:11
  • \$\begingroup\$ @MilkyWay90 reddit.com/r/beetlejuicing/about \$\endgroup\$
    – GMills
    Commented Feb 20, 2019 at 16:42
  • \$\begingroup\$ @GabrielMills Oh, I didn't know there was a term for that. \$\endgroup\$
    – MilkyWay90
    Commented Feb 20, 2019 at 16:43

You must log in to answer this question.

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