80
\$\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
  • 2
    \$\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

93 Answers 93

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\$
3
\$\begingroup\$

Bean

Bean is an esoteric byte-encoded code-golfing language derived from JavaScript, and was created by me, Patrick Roberts, in January 2017.

The inspiration behind Bean was one of frustration. I typically submit answers in JavaScript (ES6), and was aware of its shortcomings in verbosity, such as String.fromCharCode(...). I thought it would be cool to write a language where every global and standard identifier (like String and fromCharCode respectively) could be represented by single bytes in a byte-encoded language, and thus JavaScript's code-golfing hero, Bean, was born.

The backend uses babylon to convert any JavaScript source code omitting comments, directives (use strict), decorators (@readonly), and a few other AST nodes that were exclusive to module syntax (export default, for example), and traverses the constructed AST depth-first, encoding each node in 1 or 2 bytes, and then recursing to encode the child nodes sequentially.

Some of the features that make Bean differ from JavaScript is the advantage of implicit input and output. For example, the following JavaScript compiles to a valid Bean program that adds two integers and outputs the sum:

JavaScript:

A+B

Bean Hexdump (7 bytes):

00000000 26 4c a0 43 8b 20 44
00000007

The best valid JavaScript answer for this, in comparison, is 9 bytes. You can check the demo for this Bean program here.

The implicit input is read line-by-line, and string literals of each line are stored in the lowercase identifiers a-z (then aa, ab, ac...) while successful JSON-parsed lines are stored in A-Z (then AA, AB, AC...). In addition, the array of all string literals is stored in _ while the sparse array of successful JSON-parsed lines is stored in $. To make this clearer, consider the following input:

5
hello
"hello"
{"hello": "world"}
[hello]
[5, "hello"]

The implicit input would be populated as follows:

var a = "5",
    b = "hello",
    c = "\"hello\"",
    d = "{\"hello\": \"world\"}",
    e = "[hello]",
    f = "[5, \"hello\"]",
    A = 5,
    C = "hello",
    D = {"hello": "world"},
    F = [5, "hello"],
    _ = [
      "5",
      "hello",
      "\"hello\"",
      "{\"hello\": \"world\"}",
      "[hello]",
      "[5, \"hello\"]"
    ],
    $ = [5, , "hello", {"hello": "world"}, , [5, "hello"]];

Attempting to reference B or E would throw an error, and $[1] and $[4] would return undefined, and would not be iterated over with .map() or .forEach().

I currently don't have any documentation, as I've just explained every way in which Bean differs from JavaScript, but feel free to open an issue on github if you feel that documenting the byte code is necessary. Bean is also available on npm, but the implicit input and output only works on the online interpreter for now. I'll internalize that in a later update. The node.js implementation now includes a hook for implicit input and output via bean.program(). See README for usage.

The interpreter accepts any arbitrary JavaScript and automatically converts it to a hexdump for you. Alternatively, you can copy/paste any valid hexdump and it will reconstruct the equivalent JavaScript for you.

One tip I can offer is to attempt to use "standard" identifiers as much as possible, even in your strings, regular expressions, and template strings, since all literals expand to identifiers, and those that are not stored in the configuration file must be appended to the end of the byte code.

At the very least, repeated use of the same non-standard identifiers are reduced to referencing the same subarray of bytes at the end of the byte code, so don't bother storing "my really long necessary string" to a variable, because that will waste 3 bytes:

// 41 bytes

(s="my really long necessary string")===s

// 43 bytes

00000000 26 4c cd a0 6f 80 23 81 01 82 20 6f ed f9 a0 f2  &LÍ o.#... oíù ò
00000010 e5 e1 ec ec f9 a0 ec ef ee e7 a0 ee e5 e3 e5 f3  åáììù ìïîç îåãåó
00000020 f3 e1 f2 f9 a0 f3 f4 f2 e9 ee 67                 óáòù óôòéîg
0000002b

// vs...

// 69 bytes

"my really long necessary string"==="my really long necessary string"

// 40 bytes

00000000 26 4c a3 81 01 82 23 81 01 ed f9 a0 f2 e5 e1 ec  &L£...#..íù òåáì
00000010 ec f9 a0 ec ef ee e7 a0 ee e5 e3 e5 f3 f3 e1 f2  ìù ìïîç îåãåóóáò
00000020 f9 a0 f3 f4 f2 e9 ee 67                          ù óôòéîg
00000028
\$\endgroup\$
  • 1
    \$\begingroup\$ Heh, I too created a language out of frustration with String.fromCharCode, as did Downgoat :-) \$\endgroup\$ – ETHproductions Jan 24 '17 at 15:54
3
\$\begingroup\$

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.


Links

\$\endgroup\$
  • 1
    \$\begingroup\$ What a coincidence! My name is almost the same name as this programming language, and both this language and me are related to PPCG \$\endgroup\$ – MilkyWay90 Dec 31 '18 at 23:22
  • \$\begingroup\$ @MilkyWay90 Beetlejuicing! \$\endgroup\$ – Gabriel Mills Feb 20 at 15:15
  • \$\begingroup\$ @GabrielMills Beetlejuicing? What's that? \$\endgroup\$ – MilkyWay90 Feb 20 at 16:11
  • \$\begingroup\$ @MilkyWay90 reddit.com/r/beetlejuicing/about \$\endgroup\$ – Gabriel Mills Feb 20 at 16:42
  • \$\begingroup\$ @GabrielMills Oh, I didn't know there was a term for that. \$\endgroup\$ – MilkyWay90 Feb 20 at 16:43
3
\$\begingroup\$

Chip

Chip is an esoteric language designed by me, Phlarx. It is my first language, and I started designing this in December 2016. It can be found on Try It Online, too.

This language is inspired by integrated circuits and digital logic, and as such, it is a 2.5D language that somewhat resembles circuitry. (I say 2.5D because Chip circuits can be layered atop one another, so it resides somewhere between 2D and 3D).

Since Chip deals with digital logic, it looks at individual bits for each operation, however, it is capable of reading eight bits of input (usually called a byte or octet) and writing eight bits of output on each cycle.

Chip currently has a single stack or a single queue, and has limited ability to jump back to earlier input. There are plans to further enhance its abilities in these areas, such as a second queue/stack, or addressable memory instead.

This language is still a work in progress. You can check out the rough todo list, as well as some more examples at the github page.

Example 1

Take the value of the three high bits of input, and output them as an ASCII numeral.

Fa Gb Hc e*f

Input Chip™ becomes 2333745.

Example 2

Print 1 if consecutive bytes are equal, 0 otherwise.

AZ BZ CZ DZ EZ FZ GZ HZ   e*Z~S
`}.`}.`}.`}.`}.`}.`}.`}.   f
  `--^--^--^--^--^--^--^~a

Input Hello PPCG produces 001000100.

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

Alchemist

I created several languages, but I think this one is worth posting here since it's a fun concept:

The idea is inspired by chemical reaction networks which consist of a rule-set encoding certain "chemical reactions", eg:

H + 2O -> H2O

A program is just a set of such rules, however there might be rules where their inputs overlap, for example:

Alice -> Bob
Alice -> Charlie

Well, here's where the fun/pain begins: The program has an internal state - called the universe - which counts how many atoms of which type there are. At every iteration a uniformly at random rule is picked from all the ones which are applicable (you can change the probabilities by copying the rule).

To bootstrap the whole process the program starts off with one _-atom and from there your world starts evolving.

Input/Output

There are three types of special atoms which when they would be added to the universe do some I/O instead:

In_some_name:      Read number from stdin and add that many "some_name"-atoms
Out_some_name:     Output the number of "some_name"-atoms
Out_"some string": Output the string "some string"

Examples

_ -> Out_"Hello, Alchemist!"

Prints Hello, Alchemist! to stdout: Try it online!


_ -> In_x + In_x + Out_x

Reads two integers from stdin and outputs their sum: Try it online!


Here's how deterministic control-flow can be implemented, ie. use special atoms to store state:

# Read two integers & add "compare_AB"-atom
_ -> In_A + In_B + compare_AB

# If there is a "compare_AB"-atom:
compare_AB + A + B -> compare_AB   # remove an atom of A and B

# Once there are no more atoms of A or B, we know ..
compare_AB + 0A + 0B -> Out_"eq"   # .. if none of both are left: they're equal
compare_AB + 0A +  B -> not_equal  # .. if only B is left B > A
compare_AB +  A + 0B -> not_equal  # .. if only A is left A > B

# Do something when they're unequal
not_equal -> Out_"neq"

Reads two integers and compares them: Try it online!

\$\endgroup\$
2
\$\begingroup\$

In my questions Simulate a Minsky Register Machine (I) and Simulate a Minsky Register Machine (II) I define essentially two versions of a programming language which is just a textual representation of MRMs. The intention was already to build towards version (III), which would add macros with unification. I'm also thinking about adding some additional I/O and arithmetic operations.

\$\endgroup\$
  • \$\begingroup\$ Do it! &nbsp; &nbsp; \$\endgroup\$ – luser droog Sep 13 '16 at 23:11
2
\$\begingroup\$

Loader

The latest of my programming languages, relies on recursive module loading as the principal form of recursion and iteration.

Data is stored on a bidirectionally unbounded tape and in arbitrarilly many variables.

Modules may be loaded on either the same memory space or on a deep copy thereof, depending on which load instruction is used.

Modules are permitted to return values, and if no return value is specified a module call is treated as returning 0.

\$\endgroup\$
2
\$\begingroup\$

MOVr

MOVr is a self-modifying language of mine in which everything is a MOV instruction (and simultaneously data.) However, the 2^24 64-bit words of addressable data also include the IP (at 0xfffffe) and an IO port (at 0xfffffd.) Instructions take the following (binary) format:

 01 23 456789 ABCDEF
|dl|sl|-dest-|-src--|

dl and sl are the destination and source levels, which tell how many times each must be dereferenced (mod 2^24.) If dl is 0, then the instruction acts as a no-op. If the IP goes past 0xffffff, the program terminates. Writes to and reads from the IO print and input Unicode characters. Data not filled by the program is assumed to be zeroed. This means that if you don't jump to the exit (with 0x0100fffffeffffff), then your code will have to travel through all the 2^24 instructions (and possibly wreak havoc while passing through the IP and IO.) Sadly, a working interpreter is not available at this time.

\$\endgroup\$
2
\$\begingroup\$

IPOS

Made by me, DenkerAffe

IPOS (short for I process only strings) is a stack-based golfing language made for complex string processing. It will have a huge amount of string manipulation builtins, so it will probably (hopefully) win every challenge which is about transforming an input string into an output string.

I finished the basic core recently, now it is only about implementing builtins. A list of all planned (not-complete) and already implemented commands can be found here.

The input to an IPOS program is placed on the stack automatically. At the end of the program all stack items are converted to strings and get joined into one string which then get printed.

Example programs

Hello World

"Hello World!

Split input on dots, reverse each substring and join all substring on dots

'.!r%

Explanation

       Implicit: place input string on the stack (C)
'.     Push a dot to the stack (B)
!r     Push the reverse command to the stack (A)
%      Split C on B, apply A to every part and join the result on B
       Implicit: Output the stack contents

Swap case of every character in the input randomly

E!s?

Explanation

       Implicit: place input string on the stack (C)
E      Push an empty string to the stack (B)
!k     Push the swapcase command to the stack (A)
?      Split C on B (=split into characters), apply A to every part and join the result on B
       Implicit: output the stack contents
\$\endgroup\$
  • \$\begingroup\$ Do you mean "I process only strings", not "I progress only strings"? \$\endgroup\$ – Rɪᴋᴇʀ Mar 30 '16 at 17:44
  • \$\begingroup\$ @EasterlyIrk I do. Thanks for spotting! \$\endgroup\$ – Denker Mar 30 '16 at 17:47
2
\$\begingroup\$

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.

\$\endgroup\$
  • 1
    \$\begingroup\$ @Downvoters why?? this is hilarious. \$\endgroup\$ – MD XF May 24 '17 at 23:47
2
\$\begingroup\$

Logicode

Github repo here.

Logicode was created by me, Qwerp-Derp, on August 31, 2016. It's basically a coded version of Logisim.

The language consists of three built-in logic gates, AND, OR and NOT (which are represented as &, | and ! respectively), and that's basically it. You do the rest.

You can make:

  • circuits (which are basically functions)
    • these only take strings of 0 and 1 as input and output strings of 0 and 1 as output.
  • variables
  • conditionals

You can also use stuff like:

  • input/output
  • random ints
  • comments
  • reversing strings

Github stuffs

If anyone can improve the code, go ahead and post a pull request!

If you have any issues, please put it in "Issues".

\$\endgroup\$
2
\$\begingroup\$

CGL (CGL Golfing Language)

CGL was created two days ago (4/11/17) by me. It uses a stack concept like other languages, but unlike other languages there are multiple stacks that you manipulate instead of one. You start on the 0th stack, which is empty by default. The -1th stack contains each input argument. All other stacks (integers) can be used for anything. Most operators either push something to the stack based on something already on the stack or perform an operation on all elements of the current stack.

\$\endgroup\$
2
\$\begingroup\$

GolfeMatics

GolfeMatics is a language developed by me, and I am designing it to be focused on math-related problems. The only types in the language are integers, decimals, and soon will also include lists. Booleans are false if they are equal to 0, true otherwise. No one needs strings, so I didn't add them. In fact, the only string-related command is A, which modulo's the current number by 128 and prints out the corresponding ASCII character. To see how ridiculous this makes this at programs involving strings, look at the Hello, World!

\$\endgroup\$
2
\$\begingroup\$

2DFuck

2DFuck is a very simple language created by me. It is inspired by brainfuck, but operates on a 2-dimensional matrix of bits instead of a tape of bytes. And it has an accumulator. The code is not 2D, only the memory.

It does also have the l built-in to run Conway's Game of Life on the memory, though I haven't written any programs using this so far.

Programming is, in my opinion, a bit easier than in brainfuck, because of the 2D memory and the accumulator.

Finally, a piece of code (a cat program):

!x>>>>>>>>vxvx[^^r![<r!]v![,x>r!]^![<r!]vr![>r!]vr![^^r![<r!]vv![^r.x>vr!]<]r!]

Try it online!

Here is an explanation.

+++ GitLab repository +++ Online interpreter +++

\$\endgroup\$
2
\$\begingroup\$

Ahead

Ahead is a fungeoid I've been developing on and off for a few months. It is very much in a "perpetually-rolling release" state of development and features are still being specified and implemented, but what's there right now is very solid. Ahead is available on TIO.

Standout Features

Ahead is inspired by Befunge and ><> but takes its own liberties with the 2D grid style. Most obviously, most of the symbols are different (sorry polyglots!) Just for the sake of an example, here's the truth machine:

IsO@
~>1O~

Rather than wrapping around when the head (or IP) reaches the end of a line, it "bounces off the edge" and begins traveling backwards to the previous cell. The board (program space) is bounded on all sides by the "edge", which is like a bunch of imaginary walls the head can't pass. Here, the # symbols are the edge and the .s are the space beyond.

.........
.#######.
.#IsO@ #.
.#~>1O~#.
.#######.
.........

To the head, the edge, and the space beyond, doesn't exist; it is an impenetrable field that is entirely inaccessible. The board is sized exactly to the smallest rectangle required to hold the entire program code, with gaps filled in with space characters, and fixed to that size. The board is not infinite, and combined with the lack of Befunge-style g or p commands self-modifying programs or those that use the board for storage are extremely difficult to write.

However, these edge bounces can be very useful and interesting tools for head movement, particularly when traveling diagonally.


The head can make 90 degree turns to the left or right using L or R. These are rather self-explanatory; if you're traveling > and hit an L, you start going ^.

However, the head can also make 45 degree turns with l and r. If you're going > (or East) and hit an l, you start traveling "Northeast"; that is, diagonally up-right. This is the only way to travel diagonally in Ahead (as of now?), and the head can only travel in these eight directions.


String state behaves very much like you expect, except it pushes a 0 (or NUL) to the stack when you enter. This makes it very convenient to determine where a string ends.

This couples with W, which prints characters off the stack until it reaches a 0. The combination of these two makes the Hello World program absolutely trivial:

"!dlroW ,olleH"W@

In general, the running theme of Ahead is to be a twist on traditional fungeoids with a smattering of useful builtins. Before this post gets way too long, you can check the full list of currently-implemented functions on the GitHub wiki (and of course, try them on TIO.) More updates are coming!

\$\endgroup\$
1
\$\begingroup\$

Glava

I, GamrCorps, made Glava in January 2016. It is still a MAJOR work-in-progress, but it is still very useful. Click the link above to view the docs and download the interpreter (written in Java).

Glava is a Java dialect focused on code golf. Many of the common keywords and phrases can be shortened down two around two characters each. It also sports an autocomplete feature, where you can omit the }s, ]s, )s, and "s at the end of your code and it will automatically put them in.

Another neat feature is what I call MCRP (Main Class Recognition and Placement). Simply put, if you do not have a class anywhere in the file, the interpreter will put one there for you! Also, a few common import statements will automatically be placed in with the same process (java.utils.*, java.lang.*, etc.)!

The interpreter SHOULD work in any Java version (I believe past 6), because it compiles the Glava programs into your native Java version.

\$\endgroup\$
1
\$\begingroup\$

INXW63CTMNZGS4DU

INXW63CTMNZGS4DU is a imperative/functional 1D golfing language I have created the 16 may 2016.

Example code:

→Fλ²$
(F5

will print 25.

Normally, a lambda end with a ';', a call with a ')', so the same code can be rewritten like this:

→Fλ²$;
(F5)

But since it the end of line, it's not needed.

\$\endgroup\$
1
\$\begingroup\$

Neoscript

Neoscript is a language I have created.

Neoscript is a high-level, functional language compiling to JavaScript.

Examples:

Hello world:

console:log("Hello, World!")
\$\endgroup\$
  • 1
    \$\begingroup\$ Does this language even have an implementation? \$\endgroup\$ – Fatalize Aug 9 '16 at 12:42
  • \$\begingroup\$ @Fatalize Yes... The generated JavaScript just need to be launched with a special library \$\endgroup\$ – TuxCrafting Aug 9 '16 at 12:51
1
\$\begingroup\$

JLisp

JLisp is a Lisp dialect I created the first day of November.

It's a basic Lisp dialect, probably TC and with bad support of scoping.

Hello world:

(write-line "Hello, World!")
\$\endgroup\$
  • \$\begingroup\$ Does this language still exist? The GitHub link is broken ... \$\endgroup\$ – Jonathan Frech Jul 10 '18 at 0:02
1
\$\begingroup\$

Karaoke

Karaoke is a scripting language created by me for internal use at a company I was working for in November 2013 (if you don't mind, I would avoid putting the name of the company here). I coordinated its development until September 2016 when I left the company.

The interpreter is not open-source, unfortunately, and not available to the general public, the company is using it for internal testing of their algorithms. There is no reference to the language on the company web site, and the name is not referenced anywhere, so I am sorry, I can't provide any evidence of doing it.

The syntax is based on Javascript, but with some Ruby in it. It's loosely object-oriented, but all available classes are part of the standard library, and the user can not define new classes in the language itself. The user can however define new functions.

The interpreter was built starting from a lex file, and was a simple one-pass scanner in the first versions, then I added a parser written in yacc in order to implement the object system and the control structures.

The features I liked particularly:

  • Default variable: the last result is stored into the default variable "_" which is used as an input value to the next function call.
  • Shortcuts: every object has a standard method which can be called using the bracket operator. So if s was an outputstream object and the default method of the outputstream class was println you could just call s("Hello World"). Method names could be abbreviated like in goruby.
  • Dynamic reference: this was, I think, the only feature of the language I did not directly steal from another existing language (but was of course inspired by similar features). You could define a value as a dynamic reference by adding a '&' in front of it. So if x=5; y=6; a=x+y and b=&x+y, then a would always be 11, but the value of b would change dynamically when you cnahged the value of x or y.

And then of course a lot of domain-specific features like input processing, output in some particular format, and interface to the library we wanted to test... It started like a fun experiment but at the end it was just another COBOL.

\$\endgroup\$
1
\$\begingroup\$

Triangularity

Triangularity was created on January 5th, 2018 by me, Mr. Xcoder. It is a new esolang, which only has a few commands. Loops are not implemented yet (but that is, hopefully, about to change), so it’s definitely not Turing-Complete (it can evaluate Python :|). In fact, it can only participate in very simple challenges. It’s stack based. Some helpful resources:

Fun facts

  • A valid Triangularity program must have the character count listed in OEIS A056220.

  • Each Triangularity program must be padded with dots such that the overall shape of the program is rectangular, but the dots themselves must be laid out in nice, right-angled and isosceles triangles. Basic rules:

    • If you have N lines of code, each line must consist of 2N - 1 characters.
    • The Kth line, counting from the bottom, must be padded with K - 1 dots on each side.
  • Any character that is not a command is ignored (unless we’re talking about the newlines and the dots that make up for the padding).

\$\endgroup\$
1
\$\begingroup\$

MashedPotatoes

MashedPotatoes is a register-based esoteric programming language designed by yours truly that "mashes" together several syntactic constructs from other languages and alters their meaning significantly.

The central theme of MashedPotatoes is to confuse color-coding parsers while making code difficult to read and frustrating to write. Almost every construct in the language is borrowed syntactically from another language but does not serve its original purpose. Examples:

  • The text --help is the numerical literal representing zero. This is the only numerical literal whose value does not change.
  • The Perl "baby carriage" operator @{[ ... ]} returns the negative of the argument
  • The Common Lisp style print statement (format t " ... ") is the basic looping construct in MashedPotatoes.

Additionally, to make sure programmers don't become complacent, many syntactic constructs change meaning each time you use them. There are three registers: the accumulator, the counter, and the evaluator. However, none of these registers can be accessed directly. They are accessed by the following expressions.

  • STDERR, which returns the accumulator the first time it is used in a program, the counter the second, and the evaluator the third.
  • $[, which returns the counter, then the evaluator and then the accumulator.
  • `uniq -c` (the backticks are significant) refers to the evaluator, then the accumulator, and then the counter.

So to refer to a register, you have to find an identifier that is currently pointing to that register. This design decision ensures that programmers who are refactoring code still have a sufficiently challenging task. Likewise, labels are used to activate several commands. There are three labels (plus a fourth "nullary" label), and each label has four names. Referring to a label by the wrong name is a syntax error, and the name changes every time you use it.

Resources:

FAQs:

  • Why? I got bored at work one day and this was the result.
  • Are there any example programs? Yes, the Esolang page has a well-documented factorial program and a (less well-documented) Fibonacci program.
  • What does "Hello World" look like in MashedPotatoes? No idea. I tried once to write it and eventually gave up. If you can write "Hello World" in MashedPotatoes, please let me know.
\$\endgroup\$
1
\$\begingroup\$

17

17 is a stack based language that has a bit of a focus on the number 17, for example it uses base 17 and whenever it tries to pop off an empty stack it returns 17. It has blocks of code defined as < base-17 number > {< code >}. It starts at block 777 and then goes to whichever the block in memory location 0.

Examples:

Hello world:

777 {
    44 $ 5g $ 66 : : $ $ 69 : $ 1f $ 52 $ $ 6c $ $ 5f $ 1g $ a $ 0 @
}

Count down from 100 to 1(inclusive):

0 {
2 #
1 -
:
2 @
2 <
0 @
2 # $$
a $
}


777 {
5g 2 @
0 1 @
0 0 @
}
\$\endgroup\$
1
\$\begingroup\$

Reflections

Reflections is a 2D Language. A typical program (Fibonacci):

     \
/*\   /# (0:0\
* 0  *\_ (0\/ :(0\
  \       v/#@/_ /
\  (1/   1)0)*
          : \\/
          \(1/

Here is the online interpreter to test it.

The most special thing is that you need to go to certain positions in the coordinate system to perform very simple actions (e.g. add, push numbers). It has 11 stacks, and you can move around values between them, but all other commands operate on the main stack.

It was the first language I created.

+++ GitLab repository +++ Online interpreter +++ Documentation +++ Chatroom +++

\$\endgroup\$
1
\$\begingroup\$

Pepe

Programming language inspired by an old meme, Pepe.

Uses two stacks and uses only 4 characters: reRE.

Every command in it begins with R/r, followed by a certain amount of E/e, ex. REEE. The R/r define on which stack the command has to work on (1st or 2nd), while E/e define the command used. Both amount of letters and their case matters. List of commands is available on GitHub.

Links:

\$\endgroup\$
  • 1
    \$\begingroup\$ Why the downvotes? \$\endgroup\$ – RedClover Apr 13 '18 at 14:47
1
\$\begingroup\$

Pixiedust

By Stephen Leppik

If you ask a 5-year-old what tells a computer what to do, they'll probably answer along the lines of "fairies and pixie dust". With the existence of this assembly-like language, that's not entirely wrong.

\$\endgroup\$
1
\$\begingroup\$

Turing Machine But Way Worse

By MilkyWay90 and ASCII_only

When you look at golfing languages, they confuse you and are very hard to learn.

But when you look at practical languages, they don't confuse you (normally) and are easy to learn (normally)

But what about a language which confuses you, but is easy to learn?

This is where Turing Machine But Way Worse comes in.

When I was learning about Turing Machines, I was annoyed by how they couldn't use I/O, so I built a programming language which does!

With the help of ASCII_only, we made a language which processes I/O while still keeping the point of a Turing Machine.

If you look at any submission for Turing Machine But Way Worse, you can see that it is just a lot of numbers. A LOT. But when you learn it, it will be super easy to debug and write your own programs using our debugger built-in.

\$\endgroup\$
1
\$\begingroup\$

Runic

This language was created by me, Draco18s on Sep 18, 2018.

The idea had been floating around in my head for a while, not actually as a programming language, but as a concept for a while. Mostly due to reading lit RPG books like Emerilia. I wanted some way to write in-game code that would be attached to an item or object that would act as a magical enchantment.

September 18th I pretty much sat down and started working out a basic set of instructions and framework for the language and the initial interpreter just to see if I could get something that worked. I took a lot of inspiration from ><>, as I'd worked with it a bit in the weeks prior, and wanting something a little more powerful. After a couple of hours I had a small, but functional language.

But it was really on Dec 16, 2018 when I added support for Unicode Combining characters that would modify various instructions in a variety of ways, such as would executes the a command (push 10) normally before altering the IP's direction to point right (overriding whatever direction it was facing). While combining characters will only combine visually with a certain subset of symbols (i.e. ) the interpreter doesn't care. While certain modifiers are often not competitive in code golf (due to the 2 or 3 byte cost for each one), they do unlock the ability to perform otherwise complex or impossible operations (such as rotating a string or swapping substacks).

The other main feature of Runic is that it supports an arbitrary number of simultaneously executed instruction pointers that can merge (if in the same cell and facing the same direction) and split (with one of four commands). Each instruction pointer has a current "mana" value, where some instructions cost mana (namely reflection, eval, sorting, substacks, and splitting) and if an IP ever runs out of mana it fizzles out of existence. Each IP's own stack is also size limited by its current mana, making large data sets almost impossible to work with. The idea being that magic, being magic, requires more energy to do Big Things.

I'd definitely like to rebuild the language from the ground up to do more, have each given instruction handle a wider range of input types (some instructions only operate on, say, strings but currently does nothing if it gets a pair of integers, but would do something instead that's currently handled by an instruction that currently operates on integers and not strings), and possibly have a custom code page (for extra golfiness). But it isn't high on my todo list.

And yes, I did eventually get around to implementing some of the more game-y features in Minecraft (just an example of an effect that spawns a particle to 'charge up' even if the final effect is just to print some text in chat, but it could spawn blocks too).

\$\endgroup\$
1
\$\begingroup\$

@

Unlike other submissions, note that there isn't a self-referring pronoun!

@ is a functional language created by Gemdude46 designed for code-golfing.

Structure of a program

The language is made of a tree of function calls. Each character (with some exceptions) represents a function that may take as many or few arguments as it likes. Arguments are then read from directly after it in the code.

For example:

If instruction A takes 1 argument, B takes 2, C takes 3, and D and E both take none, then the @ code

   BADCDBEDE

Would be written in many languages like

   B(A(D()), C(D(), B(E(), D()), E())))

Instruction arguments are evaluated LTR unless the docs explicitly say otherwise. Arguments may not be evaluated at all or may be evaluated more than once.

Values and data types

@ has the following data types:

number - This is an arbitrary precision rational number.

vector - This is an immutable list of other values of any type.

If anything refers to a string, then it means a vector of codepoints.

Anything enclosed in braces is seen as a string literal. String literals are automatically ended on EOF. Should an EOF be encountered where an instruction should be, Š is used.

Examples

Hello world:

   ħ

Cat:

   ¤ōč

Truth machine:

   ?ň¤Ō10

Links

\$\endgroup\$
0
\$\begingroup\$

Noether

Noether is stack-based, semi-golfing language designed by myself.

Based mainly on Fourier, Noether is stack-based and uses reverse polish notation. These two facts make Noether a lot more powerful than Fourier, mainly because it means that strings and integers can be stored and manipulated alike.

Similarly, Noether's functions are overloaded based on the type of the arguments. For example, the function L has two functions:

  • When passed a string, L returns the length of the string.
  • When passed a number, L returns the base 10 logarithm of the number

As a result, Noether can be used more widely and is wholly more usable language whilst still being quite similar to Fourier.

Links:

\$\endgroup\$

You must log in to answer this question.

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