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>

• Sp3000: Todo: Add 2D matching languages and every language Calvin makes up for golf questions
• bmarks: Do languages whose only non-proprietary interpreters were created by PPCG users count?
• user42643: 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.
• PhiNotPi: @minxomat This question is open to all languages created by PPCG users.
• PhiNotPi: @bmarks I say you could go ahead and post it, specifically mentioning the interpreter.
• user42643: @PhiNotPi A suggestion: Implement a snippet in your question to list the languages. This site is quite long.
• Alex A.: @minxomat Done.
• Alex A.: 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.
• Beta Decay: @AlexA. Maybe we could add a formatting guide, and suggest that the inventor be added in the header?
• Alex A.: @BetaDecay Yeah I had thought about that. Language name, creator, and year. Up to Phi though.
• Magic Octopus Urn: @Adnan 05AB1E should be on here.
• user100411: Can I post mine here if I have several alternative names?

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

• mbomb007: Martin, how long did it take you to create/learn?
• Martin Ender: @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.
• mbomb007: @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: @MartinBüttner (Yes, I know they wouldn't wrap around the same way, if at all)
• Martin Ender: @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.
• M L: I was thinking about creating a language on triangular grid, too. I can’t wait to see yours.
• Martin Ender: @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. ;)
• M L: @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 ;)
• Joe Z.: "Build a Befunge program to convert Hexagony code into Befunge".
• Martin Ender: @JoeZ. Best of luck.
• bb216b3acfd8f72cbc8f899d4d6963: @JoeZ. "Build a Hexagony program to convert Befunge code into Hexagony."
• bb216b3acfd8f72cbc8f899d4d6963: Voting to close as unclear because I got it confused with Hexagony, not Hexagony. :)
• Kevin Cruijssen: "I implemented the language two days ago (and designed it over two or three days before that). And yes, I'll definitely add an esolangs page, but I think the spec isn't 100% stable yet (there are still 3 unassigned commands for instance). Once I feel that it's more stable, I'll add it to both esolangs and our meta post." You've made this programming language in just 4-5 days?! o.Ô Just wow.
• Martin Ender: @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.

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.

Location of Mornington Crescent on the London Tube

• Comintern: Unfortunately, language extensions typically cost millions of pounds and require lots of digging.
• mbomb007: @Comintern And let's not mention the execution time...
• fede s.: A language fungi can be good at! youtube.com/watch?v=GwKuFREOgmo
• lyxal: I'll make a move to Aldgate.

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

• mbomb007: Interesting language. You should create a challenge that involves golfing Funciton programs...
• mbomb007: Also, this is probably one of the coolest-looking languages I've ever seen.
• Ypnypn: I glanced at the source code. This may have the most complex interpreter of any esolang out there.
• Doorknob: Woah, you made this? I've seen it around on esolangs and such; never knew it was created by a fellow PPCGian ;)
• Stig Hemmer: Some time ago, I clicked "random page" on Esolang and found this. Instant love. Now this is esoteric!
• Robert Fraser: Won't you take me down to Funciton
• DanTheMan: I love this language, but it never displays right on mobile.

Answer 4

Pyth

Pyth was created in June 2014 by me, izzyg. 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.

• Fatalize: How is Pyth supposed to be pronounced? /paɪθ/ like the beginning of Python, or /pɪθ/ (like pit but with th instead of t)?
• izzyg: @Fatalize Pyth is pronounced like the first syllable of pithy, /pɪθ/.
• mbomb007: Meh. I think /paɪθ/ sounds better and makes more sense, since it's abbreviated Python.
• jvriesem: @isaacg: What's in the name?
• izzyg: @jvriesem As mentioned above, it's Python but shorter, making it nice and pithy.
• jvriesem: @isaacg: Nice! (I admit...I had to look up the definition of "pithy".)
• DLosc: 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!
• mbomb007: @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?!

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.

• Alex A.: +1 for a tutorial where a simple description would have sufficed.
• mbomb007: ♪♫ Do you wanna build a language? It doesn't have to be a language.
• Timwi: ♫♪ The code never bothered me anyway.
• user18932: 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.
• gcampbell: @Snowman You should create a language called Doorknob.

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:

Hello, World! in Ziim

• Beta Decay: Wow, you've made so many... and they're all so fascinating :)
• mbomb007: 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.

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.

• Sundar R: "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!

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.

• Michael Stern: +1 because Das verrückte Labyrinth is my youngest son's favorite game.
• Martin Ender: @ThisGuy Ummm. Why not? It's not even that many. You should see some other people.
• Martin Ender: @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: @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.

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

• undergroundmonorail: trichoplax (then known as githubphagocyte) yoo, i was wondering where githubphagocyte went

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.

• feersum: 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.

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

• thejonymyster: term no longer exists on the wikipedia page

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)

• Addison Crump: This is Seriously cool. :D This is the new golfing language, as far as I can see.
• wizzwizz4: Why don't characters do different things depending on which type of thing they are given?
• user45941: @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.

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

• Paŭlo Ebermann: 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.
• Timwi: @PaŭloEbermann: Well nor can I, that’s why I created Esoteric IDE... but somehow people don’t like that either :)
• user43106: How many times has someone who can read Korean and Chinese alphabets told you you've ended up spelling out an insult?
• Timwi: @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.
• user43106: Fair enough, was just asking that as some sort of joke.

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.

• Peter Taylor: Re versatile conditionals: check out ARM assembler's conditional execution.
• Riker: Is _ shorter? 1 byte.
• Mama Fun Roll: @RikerW Sure, but it isn't as cool. (I really need to fix up the interpreter, that's a bug :P)
• Stephen: Hey, um, your interpreter expired. You still have it locally?
• Mama Fun Roll: The interpreter still works for me... although codepen.io/molarmanful/full/gajxjX is an alternative link in case.

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

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

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.

• mat: 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!
• Fatalize: @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.
• mat: Sounds about like every serious Prolog project :-)

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 @izzyg
• Retina by @MartinEnder
• Jelly by @Dennis
• Perl 5/6 by @TimToady (:P)

• Addison Crump: If you're making a direct language injection, why not use a shell-based "eval" and just run scripts through that?
• Ven: Quoting and everything, as well as flexibility: I couldn't run Jelly that way.
• Addison Crump: Write files in /tmp, run them, delete. shrug No need for quoting.

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 2024 (version 1.2.0).
• 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).

¹_{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

Bubblegum

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

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

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

• Specification and interpreter (Python 3)

• undergroundmonorail: i honestly thought it was incredible that you found two programs with the same sha-256 hash until i looked a lot closer
• Gilles 'SO- stop being evil': How is Bubblegum Turing-complete? Are you making assumptions about the set of Python programs whose SHA-256 is 5e247c455fde7711206ebaa3ad0793114b77a6d16ed0497eff8e3bf98c6dba23?
• Dennis: @Gilles Yes. For every Python program, there are infinitely many comments we can append, so it should be possible to change its hash to 5e...23 without affecting functionality.
• v6ak: @Dennis How is value "5e247c455fde7711206ebaa3ad0793114b77a6d16ed0497eff8e3bf98c6dba23" chosen? It is just a random choice? Do you know any preimage of the hash?
• Dennis: @v6ak That is the hash of the program that computes the addition of several inputs or does a primality check for a single one, which can be found on the esolang page.

Answer 28

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

• Sp3000: And it's even pretty commonly used on anarchy golf!

Answer 29

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

• mbomb007: Ah, you changed your name. Did "VTCAKAVSMoACE" stand for something?
• Addison Crump: Yes - none of it stood for VoteToClose, though. :P That came along with peoples' interpretation. @mbomb007
• CalculatorFeline: Your name is VTCooltoese?
• Addison Crump: @CatsAreFluffy ಠ_ಠ No.

Answer 30

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

• Konijn: vihanserver.tk’s server DNS address could not be found. When I click on the teacup on the github page.
• Downgoat: @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
• Konijn: No worries, as long as you know ;)