What programming languages have been created by CGCC users?

Question

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

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

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

---

List of languages

function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=meta.codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=meta.codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var a=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(a="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var r=a.match(SCORE_REG);r?e.push({user:getAuthorName(s),size:+r[2],language:r[1],link:s.share_link}):console.log(a)}),e.sort(function(e,s){var a=e.size,r=s.size;return a-r});var s={},a=1,r=null,n=1;e.forEach(function(e){e.size!=r&&(n=a),r=e.size,++a;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;o=jQuery("<a>"+o+"</a>").text(),s[o]=s[o]||{lang:e.language,lang_raw:o,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang_raw.toLowerCase()>s.lang_raw.toLowerCase()?1:e.lang_raw.toLowerCase()<s.lang_raw.toLowerCase()?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var QUESTION_ID=6918,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",OVERRIDE_USER=2867,answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n]+)\s*<\/h\d>/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=language-list><h2>Languages by CGCC Users</h2><table class=language-list><thead><tr><td>Language<td>User<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}<td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td><a href={{LINK}}>Link</a></table>

Answer 1

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.

Answer 2

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.

• Official GitHub, with interpreter and "complete" documentation: https://github.com/PhiNotPi/Element
• Esolangs page with examples: http://esolangs.org/wiki/Element

Answer 3

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)

Answer 4

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.

Answer 5

Japt

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

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

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

Check out the vote-by-vote showcase!

Answer 6

Perseus

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

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

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

Perks

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

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

Info

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

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

Answer 7

Unnamed / Phi's Golfo Supreme / Compound / GolfLang

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

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

Basic syntax

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

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

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

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

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

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

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

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

Answer 8

Minkolang

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

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

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

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

Answer 9

Pyke

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

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

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

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

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

Hello World in Pyke: "Hello, World!

Try Pyke here!

Answer 10

Stax

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

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

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

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

`jaH1"jS3!

Answer 11

shortC

This language was created by me in May 2017.

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

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

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

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

Answer 12

Joe

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

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

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

An example (indented lines are code):

   F:+2*
   F1 2 3
2 4 6
   1F1 2 3
3 5 7
   1 2 3F1 2 3
3 6 9

Answer 13

Fourier

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

Introduction

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

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

Examples

Fibonacci sequence

1~yI~k(xoi^<k{1}{44a32a}y+x~gy~xg~yi^~i)

Try it online!

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

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

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

0, 1, 1, 2, 3, 

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

0, 1, 1, 2, 3

So it's really more of an aesthetic choice.

ASCII table

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

33~j126(j^a~j)

Try it online!

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

Others from around PPCG

By other people:

• Obfuscated Hello World
• Person of Interest

By me:

• Shortest infinite loop producing no output
• Halloween Golf: The 2spooky4me Challenge
• Print this Question
• The Mystery String Printer
• Remapping ASCII
• Comparing Two Numbers
• Is this number a prime?
• Hello, World!

More can be found here.

And, finally, the question about golfing Fourier:

• Golfing Strings in Fourier

Online Interpreters

• Try it Online!
• Try it on FourIDE!

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

Resources

• Esolangs page
• Github repo
• Interpreter page
• github.io page

Answer 14

Grime

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

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

A=[,()]/*
P=A*|P(A/\(/A)P(A/\)/A)P
e,P

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

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

Answer 15

𝔼𝕊𝕄𝕚𝕟

• Github repo
• Annotated source (version 2)
• Interpreter (Firefox only, version 2)
• Interpreter (Firefox only, version 1)

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

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

Quick example:

ⒶṤć⇀⧺_

This outputs 1 to 100.

Answer 16

Jolf

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

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

Answer 17

AnnieFlow

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

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

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

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

Answer 18

Sesos

By elected moderator, Dennis ♦

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

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

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

Answer 19

Jellyfish

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

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

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

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

p%~/+0
 #  i

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

Answer 20

Billiards, Created by Me (HyperNeutrino)

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

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

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

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

1/\
 .↑
\^/

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

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

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

  a          b  
    c          d
           1    
           \_/  
             \_/
            \/  
            /\  
           _ __/
            \_/ 
             \/0
1           \\_/
\_/          _K1
  \_/      \  \/
 \/         __/ 
 /\          /  
_ __/       _   
 \_/       \__  
  \/ _______/   
 \\_/           
  _S1           
\  \/           
 __/            
  /             
 _              
\__             
 C              

Now, you do this:

⇓⇓
+/
↥

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

Answer 21

STATA (free interpreter)

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

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

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

Answer 22

Hassium

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

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

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

func main () {
    sb = new StringBuilder();
    sb.append("Hello ");
    sb.append("world");
    println(sb.toString());
}

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

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

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

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

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

• Hassium Website
• Online Interpreter
• Hassium GitHub

Answer 23

INTERCALL

I have created INTERCALL in june 2016.

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

INTERCALL IS A ANTIGOLFING LANGUAGE
SO THIS HEADER IS HERE TO PREVENT GOLFING IN INTERCALL
THE PROGRAM STARTS HERE:

Example code (Without the header):

QUINE
END

Is just a quine.

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

Answer 24

S.I.L.O.S

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

---

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

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

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

---

https://github.com/rjhunjhunwala/S.I.L.O.S

Answer 25

Your Mom

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

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

_Source

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

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

¥€⊞@

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

Answer 26

Woefully

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

Woefully, 1000 bytes

or something like that.

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

How it works

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

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

|     |

this kind

| |
| |
| |

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

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

Different types of lines execute different commands:

||| |  push operations
|| |
| |

| |
| | stack operations
| |

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

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

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

Commands get concatenated together:

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

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

this program halts

| |

Single length paths halt the program

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

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

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

Move command

All programs without this command loop infinitely, or immediately halt

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

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

Answer 27

inca

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

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

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

It has been used in 2 challenges:

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

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

Draw the Utah Teapot

--

olmec

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

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

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

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

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

--

Update: starting to get some results.

josh@LAPTOP-ILO10OOF ~/inca/olmec
$ ./olmec
        ⎕k
·¨¯<≤=≥>≠¨²_÷
◆1234567890-×
QWERTYUIOP→£≠
?⍵∈⍴∾↑↓⍳○⋆←]⍀
ASDFGHJKL:"  
⍺⌈⌊_∇∆∘'⎕º´  
ZXCVBNM«»¿   
⊂⊃∩∪⊥⊤|¶·⌿   

        a←⍳9
 0 1 2 3 4 5 6 7 8
        1+3↑a)⍴¯7↓a
 0 1 0
 1 0 1

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

Needs some work. :)

$ ./olmec
        double←2&*
&
        double5
 10
        double⍳5
 0 2 4 6 8
        'hello world'
hello world

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

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




               W    
           C R O S S
               R    
               D    

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

Answer 28

QBIC

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

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

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

Samples of usage are here: Showcase of Languages

To get started with QBIC

1. Download the project to your computer
2. You probably need DOSBOX or similar to run it
3. Edit qbic-in.txt in your favorite text editor a text editor that supports QBasic's ASCII table. I use Notepad++ with the Western European / Windows-OEM character set.
4. Fire up QBasic, open and run QBIC.BAS
5. Enter command line parameters if necessary
6. QBIC will now run the interpreted QBasic for you.

Answer 29

Cubically

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

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

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

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

   002
   002
   002
111225333044
111225333044
111225333044
   554
   554
   554

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

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

Some mathematical operations are:

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

Examples

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

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

More

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

Useful links:

• GitHub / GitHub team
• Try It Online
• Chatroom

Answer 30

Milky Way

Milky Way was created by me, Zach Gates, in November of 2015. I was bored and thought that writing a language would be fun. It's an esoteric golfing language. It's written in Python 3 and is run as an executable.

---

Facts

1. Nearly all the opcodes are destructive, meaning they remove the top-of-stack, perform their function, and push the new item back onto the stack.

2. Each line of a program has it's own stack. Each stack is initiated with two elements already on it; an empty string and zero.

   ["", 0]
   

3. If no output has occurred by the end of the program, the bottommost stack element will be output. For example, if the resulting stack is

   ["abc", "def"]
   

   then "abc" will be output; surrounding quotations included. This is the only setback to running a program with no output.

4. Input is taken via the command line with the -i option.

---

The Hello World! program:

This is the standard method:

"Hello World!"!

Everything within double quotes is a string in Milky Way. The exclamation mark outputs the top-of-stack. Alternatively, the inverted exclamation mark (decimal 161), will output the top-of-stack and terminate the program (any opcodes following will not be executed, nor will any subsequent lines). With one extra byte, but an equal number of characters; here it is:

"Hello World!"¡

Further, the greater than sign (decimal 62) will shift the entire stack rightward. The top-of-stack will become the bottom-of-stack, thus being output upon termination. This output, however, would be invalid if the output is not allowed to include surrounding quotations (see fact 3, above). Here it is:

"Hello, World!">

---

Truth machine

This is the shortest method I've come up with.

'?{0b_!_&{!}}

The single quote opcode reads the input from the command line. This piece: ?{...}, is an if statement. Each piece is separated from the next by an underscore.

• Code from the opening bracket to the first underscore, 0b in this case, is the conditional.

• Code from the first underscore to the second underscore will run if the conditional evaluates as true.

• Code from the second underscore to the closing bracket will run if the conditional evaluates as false.

In the case of this program, 0b checks is the top-of-stack, the input, is equal to 0. If it is, it outputs the top-of-stack a single time. If not, the top-of-stack is output for eternity, because &{...} constitutes a Pythonic while True: loop.

To read more about the meanings of different bracket sets, take a look at the Github repository's readme.

---

Catalog of answers

Here is a catalog of cool and significant answers that have been written in Milky Way. Each element on this list is the title of a question, while each link is the direct share-link to the answer.

Feel free to add to this list if you've written an answer you think is cool.

• "Hello World!"

• Implement a Truth-Machine

• Find the absolute value of a number without built-in functions

• Catalan Numbers

• Cover up zeroes in a list (LOCF imputation)

• Conjugate in the Spanish imperfect

• "99 Bottles of Beer"

• The versatile integer printer

• Mixed Number to an Improper Fraction

---

Links

• Github Repository