Top 10: Most Complex and Bizarre esoteric programming languages

See our review from 10 of the most ***** ** complex esoteric programming languages.

Warning

It's important to know, that if you're reading this post, you're reading it at your own risk, because the programming languages mentioned here will melt your brain if you try to understand them. There are more than 1000 esoteric programming languages out there, however we've compiled the most serious and bizarre of them just for you.

An esoteric programming language is a language not specifically designed for efficient or elegant solutions of computational problems, but rather to explore the basic ideas behind the theory of computation or weird ideas like, for example, recipe-reminiscent syntax. You may think that the people that designed the language had nothing better to do with their time, and you're right.

Most of the languages in this list are Turing Complete, a Turing Complete system means a system in which a program can be written that will find an answer (although with no guarantees regarding runtime or memory), that means that they're really elaborated. Usability is rarely a goal for esoteric programming language designers, so don't worry, you don't need to work with this languages in your future job !

Suffer with our collection of 10 from the most complex esoteric programming languages in our opinion.

10. Befunge

Befunge interpreter

Befunge is one of the oldest and the most famous two-dimensional esoteric programming languages. Befunge was created in 1993 by Chris Pressey. He attempted to create a language which would be as hard to compile as possible. However, in next years quite a lot of implementations of this language appeared, as well as several dialects and modifications called Fungeoids. The language has two main dialects — the original Befunge-93 and the later Befunge-98. The original specification of the language restricted the size of the grid on which the program should be written, which means that Befunge (unlike other esoteric languages) is not Turing-complete. But just like other esoteric languages, it has no practical value.

The following code will print Hello World:

 >25*"!dlrow ,olleH":v
                  v:,_@
                  >  ^

9. Glass

Glass is an esoteric programming language that combines an unintuitive postfix notation with heavy object-orientation, requiring extensive juggling of a main stack combined with its object-oriented structure.

The following code will print Hello World:

{M[m(_o)O!"Hello World!"(_o)o.?]}

8. Roadrunner

Roadrunner is a Brainfuck clone language based off of the popular Looney Tunes character Roadrunner, who, as is fairly well known, pretty much only ever says 'Meep meep!'. The language currently only has one implementation in the form of a Python interpreter; The interpreter in question can also be easily modified to produce a Brainfuck clone with any syntax (to a certain extent).

To print Hello World, you can use the following code:

mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEP meeP mEEp mEEp mEEp mEEp mEEp mEEp mEEp meeP mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp meeP mEEp mEEp mEEp meeP mEEp Meep Meep Meep Meep MeeP MEEp meeP mEEp mEEp MEEP meeP mEEp MEEP mEEp mEEp mEEp mEEp mEEp mEEp mEEp MEEP MEEP mEEp mEEp mEEp MEEP meeP mEEp mEEp MEEP Meep Meep mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp MEEP meeP MEEP mEEp mEEp mEEp MEEP MeeP MeeP MeeP MeeP MeeP MeeP MEEP MeeP MeeP MeeP MeeP MeeP MeeP MeeP MeeP MEEP meeP mEEp MEEP meeP MEEP

Although it's not so bizarre (theoretically ?) as all the other items in this list, it deserves to be listed.

7. Fish

Online playground

><> (to be pronounced as fish) is a stack-based, reflective, two-dimensional esoteric programming language. It draws inspiration from among others Befunge. It has an instruction pointer which moves across a 2D grid world and executes the instructions in that grid. Each character in the grid represents one operation amongst the 4 types – Arithmetic, Stack, I/O or Navigation.

The following code would print NaNaNaNaNaNaNaNaNaBatman!:

8>aa*3-89*6+oo:?!!\3b*aa*a+aa*3-aa*9+bb*5-aa*3-6b*ooooooo;
 ^              -1/

6. Emo

Homepage

Emo currently stands for Emoticon Memory Obfuscation and was invented by Dustin Luck and Sean Fife in 2010, and was inspired by Brainfuck. Even though Emo is an acronym, it is written in title case and not all upper case to highlight the emotional nature of the language.

Like Brainfuck, Emo operates on an array of memory cells, each initially set to zero. There is a pointer, initially pointing to the first memory cell. Unlike Brainfuck, however, there are two registers. The first is a storage register, the second is more of a working area that is kind of an in between of the storage register and memory. This working area register isn't persistent between read commands, so if the value is to be saved it must be written somewhere.

The following emo code will print Hello World:

:^) :o) :o) :o) :^) :^(						~Store 10 into the zero memory postiion
<;^}								~begin loop, increment pointer and copy new mem value to the register
:^) :^) :^) :^) :^) :^) :^(					~Add 7 to the current register and store in memory
;^}								~increment ptr and copy new mem value to the register
:^) :^) :^) :^) :^) :^) :^) :^) :^) :^(				~Add 10 to the current register and store in memory
;^}								~increment ptr and copy new mem value to the register
:^) :^) :^(							~add 3 to the current register and store in memory
;^}								~increment ptr and copy new mem value to the register
:^(								~add 1 to the current register and store in memory
;-| ;-|	;-| ;-}							~more the ptr down 4 and copy memory to register
:-(>								~decrement current register and store in memory then loop back
;^}								~increment ptr and copy new mem value to the register
:^) :^)	:( :@							~Increment the register by 2, sore in memory, and print 'H'
;^}								~increment ptr and copy new mem value to the register
:^) :@								~increment register by 1 and print 'e'
:^) :^) :^) :^) :^) :^) :^) :@					~increment register by 7 and print 'l'
:@								~print 'l'
:^) :^) :^) :@							~increment register by 3 and print 'o'
:(								~store register into memory
;^}								~increment ptr and copy new mem value to the register
:^) :^) :@							~increment register by 2 and print 'W'
:(								~store register into memory
;-| ;-}								~Decrement ptr twice and copy memory to register
:^) :^) :^) :^) :^) :^) :^) :^) :^) :^) :^) :^) :^) :^) :^) :@	~increment register by 15 and print 'o'
:(								~store register into memory
;^}								~increment ptr and copy new mem value to the register
:@								~print 'o'
:^) :^) :^) :@							~increment register by 3 and print 'r'
:-) :-) :-) :-) :-) :-) :@					~decrement register by 6 and print 'l'
:-) :-) :-) :-) :-) :-) :-) :-) :@				~decrement register by 8 and print 'd'
;^}								~increment ptr and copy new mem value to the register
:^) :@								~increment register and print '!'
;^| ;@								~decrement ptr, and print '\n'

5. Thue

Thue is an esoteric programming language invented in 2000. It is a matrioshka language based on nondeterministic string rewriting which the author describes as a constraint-programming version of a Turing tarpit. The Thue reference manual is not very clear about newlines in input/output. Existing Thue interpreters tend to output a newline after each output rule is triggered. However this prevents writing Thue programs which need a finer control on the output (like self-reproducing programs that output exactly their own code).

The following code will print Hello World:

a::=~Hello World!
::=
a

4. L33T (leet)

Leet (or L33t) is an esoteric programming language based loosely on Brainfuck and named for the resemblance of its source code to the symbolic language "L33t 5p34k". It is Turing-complete and has the possibility for self-modifying code. Software written in the language can make network connections and may therefore be used to write malware.[citation needed].

The following code will print Hello World in l33t:

// "Hello World" by Stephen McGreal.
// Note that the views expressed in this source code do not necessarily coincide with those of the author :o)

Gr34t l33tN3$$? 
M3h...
iT 41n't s0 7rIckY.

l33t sP33k is U8er keWl 4nD eA5y wehn u 7hink 1t tHr0uGh.
1f u w4nn4be UB3R-l33t u d3f1n1t3lY w4nt in 0n a b4d4sS h4xX0r1ng s1tE!!! ;p
w4r3Z c0ll3cT10n2 r 7eh l3Et3r!

Qu4k3 cL4nS r 7eh bE5t tH1ng 1n teh 3nTIr3 w0rlD!!!
g4m3s wh3r3 u g3t to 5h00t ppl r 70tAl1_y w1cK1d!!
I'M teh fr4GM4stEr aN I'lL t0t41_1Ly wIpE teh phr34k1ng fL00r ***j3d1 5tYlE*** wItH y0uR h1dE!!!! L0L0L0L!
t3lEphR4gG1nG l4m3rs wit mY m8tes r34lLy k1kK$ A$$

l33t hAxX0r$ CrE4t3 u8er- k3wL 5tUff lIkE n34t pR0gR4mm1nG lAnguidGe$...
s0m3tIm3$ teh l4nGu4gES l00k jUst l1k3 rE41_ 0neS 7o mAkE ppl Th1nk th3y'r3 ju$t n0rMal lEE7 5pEEk but th3y're 5ecRetLy
c0dE!!!!
n080DY unDer5tAnD$ l33t SpEaK 4p4rT fr0m j3d1!!!!!
50mE kId 0n A me$$4gEb04rD m1ghT 8E a r0xX0r1nG hAxX0r wH0 w4nT2 t0 bR34k 5tuFf, 0r mAyb3 ju5t sh0w 7eh wAy5 l33t ppl cAn
8E m0re lIkE y0d4!!! hE i5 teh u8ER!!!!
1t m1ght 8E 5omE v1rus 0r a Pl4ySt4tI0n ch34t c0dE.
1t 3v3n MiTe jUs7 s4y "H3LL0 W0RLD!!!" u ju5t cAn'T gu3s5.
tH3r3's n3v3r anY p0iNt l00KiNg sC3pT1c4l c0s th4t, be1_1Ev3 iT 0r n0t, 1s whAt th1s 1s!!!!!

5uxX0r5!!!L0L0L0L0L!!!!!!!

3. Malbolge

Malbolge interpreter | Malbolge code generator

Malbolge is an esoteric programming language ***** tough to understand. It's a language designed to be difficult or perhaps impossible to program in. For example, the effect of any instruction depends on where it is located in memory, all instructions are self-modifying (according to a permutation table) and both the code and data pointers are incremented after every instruction, making it hard to re-use any code or data. There is no way to initialize memory except to one of the 8 instruction characters, there is no LOAD or STORE operator, and the only available memory operators (both of them) work in trinary and are designed to be opaque.

To display Hello World in malbolge, you can use the following code:

 (=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc

Malbolge can't meet the formal definition of Turing completeness, which requires access to an unlimited amount of memory.

2. JSFuck

Javascript to JSFuck transpiler | Github

JSFuck is an esoteric and educational programming style based on the atomic parts of JavaScript. It uses only six different characters to write and execute code. It does not depend on a browser, so you can even run it on Node.js.

JSFuck was originally developed as part of an online contest aimed at improving security bypass techniques. It can be used to bypass detection of malicious code submitted on websites, e.g. in cross-site scripting (XSS) attacks. Another potential use of JSFuck lies in code obfuscation. An optimized version of JSFuck has been used to encode jQuery, the most used JavaScript library, in a fully functional equivalent version consisting of only six distinct characters.

JSFuck code is extremely verbose. In the following example, the JavaScript code alert(1) will be transpiled to the following JSFuck code:

Awesome note

JSFuck, is totally valid JavaScript. That means that if you run JSFuck as JavaScript in the browser or some JS interpreter, it will work as plain JavaScript (at least with the example if the alert function exists).

[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[
]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]
])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+
(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+
!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![
]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]
+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[
+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!!
[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![
]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[
]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![
]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(!
[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])
[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+[+!+[]]+(
!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[
])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()

1. Brainfuck

Online interpreter | Brainfuck minifier

Brainfuck (not capitalized except at the start of a sentence) is an extremely minimal Turing-complete programming language with just 8 commands. A Brainfuck program has an implicit byte pointer, called "the pointer", which is free to move around within an array of 30000 bytes, initially all set to zero. The pointer itself is initialized to point to the beginning of this array.

The Brainfuck programming language consists of eight commands, each of which is represented as a single character.

`>`	Increment the pointer.
`<`	Decrement the pointer.
`+`	Increment the byte at the pointer.
`-`	Decrement the byte at the pointer.
`.`	Output the byte at the pointer.
`,`	Input a byte and store it in the byte at the pointer.
`[`	Jump forward past the matching `]` if the byte at the pointer is zero.
`]`	Jump backward to the matching `[` unless the byte at the pointer is zero.

The semantics of the Brainfuck commands can also be succinctly expressed in terms of C, as follows (assuming that p has been previously defined as a char*):

`>`	becomes	`++p;`
`<`	becomes	`--p;`
`+`	becomes	`++*p;`
`-`	becomes	`--*p;`
`.`	becomes	`putchar(*p);`
`,`	becomes	`*p = getchar();`
`[`	becomes	`while (*p) {`
`]`	becomes	`}`

+++++ +++++             initialize counter (cell #0) to 10
[                       use loop to set the next four cells to 70/100/30/10
    > +++++ ++              add  7 to cell #1
    > +++++ +++++           add 10 to cell #2 
    > +++                   add  3 to cell #3
    > +                     add  1 to cell #4
    <<<< -                  decrement counter (cell #0)
]                   
> ++ .                  print 'H'
> + .                   print 'e'
+++++ ++ .              print 'l'
.                       print 'l'
+++ .                   print 'o'
> ++ .                  print ' '
<< +++++ +++++ +++++ .  print 'W'
> .                     print 'o'
+++ .                   print 'r'
----- - .               print 'l'
----- --- .             print 'd'
> + .                   print '!'
> .                     print '\n'

Or in its minified form:

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

Brainfuck ignores all characters except the eight commands +-<>[],. so no special syntax for comments is needed (as long as the comments don't contain the command characters).

If you think that there are even worse esoteric programming languages, please share them with the community in the comment box.