What programming languages have been created by CGCC users?

Question

Language-creation has become a popular activity on CGCC. A decent portion of answers, especially code-golf 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>

Answer 1

Hexagony

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

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

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

• GitHub repository. Includes interpreter (Ruby), language specification, example programs and issue tracker.
• Esolangs page. Largely a copy of the README.md on GitHub.
• Esoteric IDE by Timwi which contains another implementation (C#) and a graphical debugger (yep).
• Hexagony Colorer also by Timwi. This is a tool which can be used to annotate execution paths in Hexagony source code. See this answer for an example of the result.
• Try it online! (by Dennis) backed by the Ruby interpreter.
• Showcase your language entry (written by Adnan).

Answer 2

Mornington Crescent

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

Answer 3

Funciton

(esolangs • interpreter)

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

Example: The Factorial Function

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

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

Answer 4

Pyth

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

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

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

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

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

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

Answer 5

Retina

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

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

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

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

Answer 6

CJam by aditsu

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

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

• Project page: https://sourceforge.net/projects/cjam/
• Wiki documentation and useful links: https://sourceforge.net/p/cjam/wiki/Home/
• JavaScript interpreter (works offline!): http://cjam.aditsu.net/

Answer 7

Snowman

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

end preamble

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

Here's a few example programs:

• ROT13

  }vg:*#96nG|#110nL,bO|#64nG'(#78nL('>
  bO,oR|:#13nA;:#109nG|#123nL,bO|#77nG
  '(#91nL('>bO,oR|:#13nS;:#;bI;bI;aMsP
  

• FizzBuzz

  )1vn101nR:du*_/3NmO0eQ)(#5NmO0eQ
  }~(~%@or(%nO?_/)#%@{%@tS?)aRsP@@
  "Fizz"_aRsP\"Buzz"aRsP?)10wRsP;aE
  

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

Snowman has 8 variables¹, arranged visually like this:

a b c
d   e
f g h

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

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

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

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

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

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

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

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

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

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

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

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

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

---

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

Answer 8

Ziim

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

Answer 9

MATL

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

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

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

Language features

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

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

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

More information

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

Answer 10

Labyrinth

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

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

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

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

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

• GitHub repository. Includes interpreter (Ruby), language specification, example programs and issue tracker.
• Esolangs page. Largely a copy of the README.md on GitHub.
• Try it online! (by Dennis) backed by the Ruby interpreter.

Answer 11

Marbelous

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

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

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

• GitHub repository for docs. Includes language specification and a few examples.
• GitHub repository for original Python interpreter. Written by Sparr. Includes many more examples.
• JavaScript interpreter in the form of a Stack Snippet. Written by es1024. Includes graphical output features.
• Marbelous chat room, where most of the discussion about the design of the language happened (now frozen).

Answer 12

Stack Cats

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

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

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

• GitHub repository. Includes interpreter (Ruby), language specification, example programs and issue tracker.
• Esolangs page. Largely a copy of the README.md on GitHub. Also includes a sketch of a proof of Turing-completeness.
• EsotericIDE. Contains a C# interpreter and a debugger.

Answer 13

Ostrich

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

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

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

• Specification and interpreter
• Picture of ostriches

Answer 14

Seriously

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

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

There are 4 main data types in Seriously:

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

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

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

Links:

• GitHub repository
• Online interpreter (mostly works now, post an issue on GitHub if you find a bug or two million)
• Online documentation (WIP) (thanks to @phase for getting the ball rolling on this)

Answer 15

Sclipting

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

Example: Hello, World!

낆녬닆묬긅덯댦롤긐

Another example: Love calculation

Answer 16

Brain-Flak

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

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

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

Design

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

(){}[]<>

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

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

Overview

(Copied from the github README)

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

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

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

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

()(){}

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

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

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

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

(()()())

Will push 3 but

((()()()))

Will push 3 twice.

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

{{}}

would evaluate as 7.

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

Answer 17

Brian & Chuck

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

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

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

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

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

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

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

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

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

Answer 18

???

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

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

• Esolangs page
• Original C++ implementation
• BrainSteel's improved C implementation with BF <-> ??? translator
• Dennis' awesome Piet/??? polyglot

Answer 19

Jelly

By elected moderator, Dennis ♦

From the wiki:

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

Answer 20

V

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

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

---

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

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

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

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

• Vim's handling of numbers is abysmal.

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

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

qqfoo@qq@q

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

òfooò

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

òfoo

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

Answer 21

ಠ_ಠ

The most disapproving coding language on the Internet!

• Interpreter
• Documentation

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

Quick Example

ಠ_ಠ

A simple cat program.

Answer 22

Help, WarDoq!

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

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

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

• Specification and offline interpreter
• Online interpreter

Answer 23

SnakeEx

Created by myself (BMacZero).

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

Online Interpreter - Full Language Spec - Javascript Source

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

Examples:

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

m:<*>Hello, World\!

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

m{E}:$(<P>\.)+$

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

m:({e<>PE}\-[|\-]*<T>\+|[|\-]*<T>)+`\+
e:\+

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

Answer 24

Brachylog

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

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

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

Answer 25

∀

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

Why not use all three together?

See it on Github.

This is an example ∀ program:

y+
pVsQN
r(\d+)
r$*#
r!`#+
nsay join '',map{chr(5+ord)}split ''
Nsay $_».succ

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

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

pVTN
pT

pQ

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

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

Currently included:

• Pyth by @isaacg
• Retina by @MartinEnder
• Jelly by @Dennis
• Perl 5/6 by @TimToady (:P)

Answer 26

Pip

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:

Fi1,6Pi*i

prints the squares of the numbers 1 through 5.¹ 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!

• Github repository.
• Official documentation. Keep this handy when programming, particularly the operator precedence page.
• Tutorial. Still very incomplete, but a good place for beginners to start.

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.

¹_{Although, 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.}

Answer 27

Burlesque

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

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

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

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

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

• Webpage: http://mroman.ch/burlesque
• Rosetta Code: http://rosettacode.org/wiki/Category:Burlesque
• Github: https://github.com/FMNSSun/Burlesque
• Esowiki: https://esolangs.org/wiki/Burlesque

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

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

Some longer scripts:

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

which produces:

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

Answer 28

Vitsy

Created by me, VTCAKAVSMoACE

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

Esolangs Page

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

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

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

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

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

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

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

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

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

Code Examples

Standard Quine

'rd3*Z
'           Start recording as a string.

(wraps around once, capturing all the items)

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

Output:

'rd3*Z

Answer 29

TeaScript

TeaScript started off simple:

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

That's when TeaScript was born.

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

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

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

---

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

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

---

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

---

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

Σc

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

---

• Interpreter
• Github (you should totally star TeaScript)
• Documentation

Answer 30

Cubix

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

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

./v.o;@?/"!dlroW"S',u/"Hello"

is exactly the same as this one:

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

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

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