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

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

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

List of languages

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

  • 18
    Todo: Add 2D matching languages and every language Calvin makes up for golf questions – Sp3000 Sep 9 '15 at 2:45
  • Do languages whose only non-proprietary interpreters were created by PPCG users count? – bmarks Sep 12 '15 at 17:01
  • 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. – mınxomaτ Sep 12 '15 at 21:59
  • 1
    @minxomat This question is open to all languages created by PPCG users. – PhiNotPi Sep 13 '15 at 4:36
  • @bmarks I say you could go ahead and post it, specifically mentioning the interpreter. – PhiNotPi Sep 13 '15 at 4:42
  • 1
    @PhiNotPi A suggestion: Implement a snippet in your question to list the languages. This site is quite long. – mınxomaτ Sep 14 '15 at 6:27
  • 2
    @minxomat Done. – Alex A. Sep 21 '15 at 19:05
  • 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. – Alex A. Sep 21 '15 at 19:12
  • 2
    @AlexA. Maybe we could add a formatting guide, and suggest that the inventor be added in the header? – Beta Decay Sep 25 '15 at 17:33
  • 1
    @BetaDecay Yeah I had thought about that. Language name, creator, and year. Up to Phi though. – Alex A. Sep 25 '15 at 18:32
  • @Adnan 05AB1E should be on here. – Magic Octopus Urn Jan 19 '17 at 21:19

89 Answers 89

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 Büttner wrote a “Hello, World!” and a primality checker in this.

Location of Mornington Crescent on the London Tube

  • 81
    Unfortunately, language extensions typically cost millions of pounds and require lots of digging. – Comintern Sep 20 '15 at 3:09
  • 13
    @Comintern And let's not mention the execution time... – mbomb007 Mar 9 '16 at 22:39
  • A language fungi can be good at! youtube.com/watch?v=GwKuFREOgmo – fede s. Dec 18 '17 at 15:43

Funciton

(esolangsinterpreter)

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

Example: The Factorial Function

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

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

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

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.

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

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.

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

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.

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

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 variables1, arranged visually like this:

a b c
d   e
f g h

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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:

Hello, World! in Ziim

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

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.

  • 1
    "It should be easy for a MATLAB user to start programming in MATL within minutes." Can confirm this is true. And it's probably made me better at using MATLAB effectively as well! – sundar Jul 14 at 14:39

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.

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

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

  • 1
    trichoplax (then known as githubphagocyte) yoo, i was wondering where githubphagocyte went – undergroundmonorail Nov 7 '15 at 6:09

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:

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

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

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

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.
  • 3
    This looks like a neat structure. Instruction sequences as elements of a group and finding an operator such that one of the builtins under conjugation by it does what you want. – feersum Jun 11 '16 at 2:34

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.

  • 15
    +1 for picture of ostriches :D – TheNumberOne Sep 9 '15 at 12:33

Brian & Chuck

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

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

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

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

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

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

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

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

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

Brain-Flak

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.

???

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.

ಠ_ಠ

The most disapproving coding language on the Internet!

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

Quick Example

ಠ_ಠ

A simple cat program.

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
  • Ah, you changed your name. Did "VTCAKAVSMoACE" stand for something? – mbomb007 Nov 5 '15 at 17:44
  • Yes - none of it stood for VoteToClose, though. :P That came along with peoples' interpretation. @mbomb007 – Addison Crump Nov 5 '15 at 17:50
  • Your name is VTCooltoese? – CalculatorFeline Mar 9 '16 at 22:28
  • @CatsAreFluffy ಠ_ಠ No. – Addison Crump Mar 9 '16 at 23:11

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.

Alice

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

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

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

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

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

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

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

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

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

Element

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.

  • 11
    It may be of interest to note that Phi wrote the entire thing using Notepad. :O – Alex A. Sep 8 '15 at 21:49

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

interpreter screenshot

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

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

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]


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

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.

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

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.

∀ (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)
  • If you're making a direct language injection, why not use a shell-based "eval" and just run scripts through that? – Addison Crump Aug 9 '16 at 8:33
  • Quoting and everything, as well as flexibility: I couldn't run Jelly that way. – Ven Aug 9 '16 at 9:48
  • Write files in /tmp, run them, delete. shrug No need for quoting. – Addison Crump Aug 9 '16 at 14: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 challenges with the least possible effort to satisfy our definition of programming language.

Snails

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.

You must log in to answer this question.

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