78
\$\begingroup\$

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

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

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

List of languages

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

\$\endgroup\$
  • 19
    \$\begingroup\$ Todo: Add 2D matching languages and every language Calvin makes up for golf questions \$\endgroup\$ – Sp3000 Sep 9 '15 at 2:45
  • \$\begingroup\$ Do languages whose only non-proprietary interpreters were created by PPCG users count? \$\endgroup\$ – bmarks Sep 12 '15 at 17:01
  • \$\begingroup\$ The title is somewhat misleading. Do general purpose languages not related to golfing still count when they have been created by PPCG users? The title suggests yes, but mostly (and naturally) the answers relate to golfing. \$\endgroup\$ – mınxomaτ Sep 12 '15 at 21:59
  • 1
    \$\begingroup\$ @minxomat This question is open to all languages created by PPCG users. \$\endgroup\$ – PhiNotPi Sep 13 '15 at 4:36
  • \$\begingroup\$ @bmarks I say you could go ahead and post it, specifically mentioning the interpreter. \$\endgroup\$ – PhiNotPi Sep 13 '15 at 4:42
  • 1
    \$\begingroup\$ @PhiNotPi A suggestion: Implement a snippet in your question to list the languages. This site is quite long. \$\endgroup\$ – mınxomaτ Sep 14 '15 at 6:27
  • 2
    \$\begingroup\$ @minxomat Done. \$\endgroup\$ – Alex A. Sep 21 '15 at 19:05
  • \$\begingroup\$ A quick note about the snippet: User means the person who posted about it here, not necessarily the user who created the language. Example: I did not create Ostrich, I merely posted it here. \$\endgroup\$ – Alex A. Sep 21 '15 at 19:12
  • 2
    \$\begingroup\$ @AlexA. Maybe we could add a formatting guide, and suggest that the inventor be added in the header? \$\endgroup\$ – Beta Decay Sep 25 '15 at 17:33
  • 1
    \$\begingroup\$ @BetaDecay Yeah I had thought about that. Language name, creator, and year. Up to Phi though. \$\endgroup\$ – Alex A. Sep 25 '15 at 18:32
  • \$\begingroup\$ @Adnan 05AB1E should be on here. \$\endgroup\$ – Magic Octopus Urn Jan 19 '17 at 21:19

91 Answers 91

9
\$\begingroup\$

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.

\$\endgroup\$
9
\$\begingroup\$

Cubix

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

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

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

is exactly the same as this one:

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

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

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

\$\endgroup\$
  • 1
    \$\begingroup\$ What's wrong with Würfelsprache? D: \$\endgroup\$ – flawr Aug 29 '17 at 14:52
8
\$\begingroup\$

Bubblegum

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

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

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

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

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.

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

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.1 Pip also borrows ideas from array-based and functional programming languages.

Some interesting features of Pip:

  • Numbers and strings are the same data type, Scalar. This can become a pain occasionally, but makes for a lot less typecasting and sometimes has neat applications.
  • Many operators work itemwise on lists. For instance, [1 2 3]+[4 5 6] gives [5 7 9], and "a".[1 2 3] gives ["a1""a2""a3"].
  • By default, the contents of lists are concatenated together before printing, but there are a bunch of command-line flags that allow for different formats.
  • Regular expressions are built in. The feature set could use further expansion, but already Pip can beat other golfing languages at certain regex problems.

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

1Although, the code _*_M1,6 with the -n flag does the same thing in 8 bytes instead of 9. But that's a bit less obvious.

\$\endgroup\$
7
\$\begingroup\$

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.

\$\endgroup\$
7
\$\begingroup\$

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.

\$\endgroup\$
7
\$\begingroup\$

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!

\$\endgroup\$
7
\$\begingroup\$

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!

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

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)

\$\endgroup\$
6
\$\begingroup\$

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
\$\endgroup\$
6
\$\begingroup\$

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.

\$\endgroup\$
6
\$\begingroup\$

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:

By me:

More can be found here.

And, finally, the question about golfing Fourier:

Online Interpreters

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

Resources

\$\endgroup\$
5
\$\begingroup\$

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.

\$\endgroup\$
5
\$\begingroup\$

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.

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

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.

\$\endgroup\$
5
\$\begingroup\$

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.

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

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!
\$\endgroup\$
4
\$\begingroup\$

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.

\$\endgroup\$
4
\$\begingroup\$

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.

\$\endgroup\$
4
\$\begingroup\$

𝔼𝕊𝕄𝕚𝕟

𝔼𝕊𝕄𝕚𝕟 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.

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

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

\$\endgroup\$
4
\$\begingroup\$

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

\$\endgroup\$
4
\$\begingroup\$

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.
\$\endgroup\$
4
\$\begingroup\$

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

\$\endgroup\$
4
\$\begingroup\$

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:

\$\endgroup\$
4
\$\begingroup\$

ezfuck

I just finished ezfuck yesterday after 3 days of work. It works very similar to BrainFuck (in fact, all BrainFuck is valid ezfuck), but adds a few new commands and features:

  • Adds the * and \ operators

  • Adds in numberic literals, and allows most commands to take them as an argument

    • +++[>++++<-] == +3[>+4<-] ~= +3*4 (the last doesn't require a second cell)
    • >13 == >>>>>>>>>>>>>
    • ,-48 sets the current cell to the number entered (its char code - 48)
  • { and } allow direct control over the instruction pointer. As with ], the jump will only happen if the current cell value is 0.

    • {n will move the instruction pointer n commands to the left, while }n will move it n commands to the right. If n isn't supplied, it defaults to 1.
    • +{ == +[]
  • ^ allows directly setting the value of the current cell.

    • ^6*2 sets the current cell to 6, then multiplies it by 2.
  • V allows getting the current cell value to be used as an argument for a command.

    • ^6>V sets the current cell to 6, then takes the value, and gives it to >. Of course, you could just write >6, but I figured this may have some use with some creativity.
    • Allow the user to directly control the instruction/cell pointers: ,^}V, ,^>V
    • ^V is a no-op.

An uncreative "hello world":

^72. ^101. ^108.. ^111. ^32. ^87. ^111. ^114. ^108. ^100. ^33. ^10.
   H     e     ll     o         W     o     r     l     d    !    \n
\$\endgroup\$
  • \$\begingroup\$ I like this language. Here's a more shorter program that should print Hello World! (untested): ^72.+29.+7..>^111.>^32.+55.<.+3.<.-8.^33. \$\endgroup\$ – Luke Apr 29 '17 at 21:10
  • \$\begingroup\$ @Luke Thanks :). Unfortunately I have yet to find a good use case for { and `}. I found them to be difficult to use at best. \$\endgroup\$ – Carcigenicate Apr 29 '17 at 21:18
3
\$\begingroup\$

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.

\$\endgroup\$
3
\$\begingroup\$

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.

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

PyMin

This is a language created by me.

It's a lazy one (something like Dogescript?), because pretty much the entire language is Python, except there are specific two bytes chars that get replaced by something, and then executed as normal Python.


Examples:

Hello, World!

»Ħ

or if you want the W to be lowercase:

»ħ

FizzBuzz (v0.1)

¥i¦ȑ101):
 s¨
 ¿i%3ʭ0:sϯƒ
 ¿i%5ʭ0:sϯɓ
 ¿sɵ:»s
 Ə»i

I added more stuff into the language, so in v0.5 it can be shortened to:

ŒʘƆ
 s¨
 ¿i%3dž:sϯƒ
 ¿i%5dž:sϯɓ
 ¿sɵ:»s
 Ə»i

Degrees to radians

»ȹ¬)

Celsius to fahrenheint

»Ɋ¬)

Primality check

»Գ¬)
\$\endgroup\$

You must log in to answer this question.

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