25 Most Bizarre Programming Languages

Some people say learning to program is hard, tedious and excruciating. It’s like learning a new language, just to talk to a machine which needs to be told in very specific commands what to do and execute. For some reason, a group of people seems to think that programming itself isn’t complicated enough, and thus ‘esolang’ was born.

Welcome to the world of esoteric programming languages (aka esolang), where programmers push the conventions of language design. These languages are not meant to be easy to use. Quite the opposite, they are designed to challenge, frustrate and amuse programmers with their difficulty. There are many esolangs out there for you try, but here are 25 of the most bizarre and insane of the lot.

5 New Programming Languages to Learn

5 New Programming Languages to Learn

Being a developer has been a top career choice for a while, and it's hard to imagine this... Read more

1. Brainf*ck

True to its name, this programming language will give any programmer an instant headache. It was created by Urban Müller in 1993, as a language that could be implemented by a really small compiler to amuse the programmer.

The language uses only eight commands and an instruction pointer, each made up of a single character, making this an incredibly minimalistic language. Below is a sample of the headache-inducing code, one that will print out ‘Hello World!’:

[ as the cell will be cleared by the loop
 >++ Add 2 to Cell #2
 >+++ Add 3 to Cell #3
 >+++ Add 3 to Cell #4
 >+ Add 1 to Cell #5
 <<<<- Decrement the loop counter in Cell #1
 ] Loop till Cell #1 is zero; number of iterations is 4
 >+ Add 1 to Cell #2
 >+ Add 1 to Cell #3
 >- Subtract 1 from Cell #4
 >>+ Add 1 to Cell #6
 [<] Move back to the first zero cell you find; this will
 be Cell #1 which was cleared by the previous loop
 <- Decrement the loop Counter in Cell #0
 ] Loop till Cell #0 is zero; number of iterations is 8
 
 The result of this is:
 Cell No : 0 1 2 3 4 5 6
 Contents: 0 0 72 104 88 32 8
 Pointer : ^
 
 >>. Cell #2 has value 72 which is 'H'
 >---. Subtract 3 from Cell #3 to get 101 which is 'e'
 +++++ ++..+++. Likewise for 'llo' from Cell #3
 >>. Cell #5 is 32 for the space

2. LOLCODE

LOLCODE is made up of lolspeak, the ‘language’ used by lolcats. The language was designed by Adam Lindsay in 2007, a researcher at Lancaster University’s Computing Department. The language isn’t as complete as traditional ones, with syntax and operator priorities not clearly defined but there are functioning compliers for that available out there.

The hilarity and cuteness of the language more that makes up for this though. Just take a look at the ‘Hello World!’ code below:

HAI
 CAN HAS STDIO?
 VISIBLE "Hello World!"
 KTHXBYE

3. Befunge

Similar to Brainf*ck, Befunge was developed by Chris Pressey in 1993, with the aim of creating a language that would be as hard to compile as possible.

He does this by implementing self-modifying code and having the same instruction being executed in four different ways, not to mention the instruction set itself. However, a number of compilers were eventually created. Below is the source code for ‘Hello World!’:

 > v
 v ,,,,,"Hello"<
 >48*, v
 v,,,,,,"World!"<
 >25*,@

4. ArnoldC

Here is a programming language made entirely out of one-liners from movies featuring Arnold Schwarzenegger, classics such as Terminator, Predator and Total Recall. ArnoldC was created by Lauri Hartikka, who swapped out standard commands with their equivalent Arnold one-liner.

Example includes False and True, which becomes "I LIED" and "NO PROBLEMO", respectively. Here’s how a "Hello World!" code would look like:


 IT'S SHOWTIME
 TALK TO THE HAND "Hello World!"
 YOU HAVE BEEN TERMINATED

5. Shakespeare

If bodybuilding Austrian actors isn’t your thing, you may prefer the Shakespeare programming language. Created by Jon Aslund and Karl Hesselstörm, the aim was to make a programming language that didn’t look like one. In this case, the source code looks exactly like a Shakespeare play. Variables must be named after Shakespearian characters and constants are decided by positive or negative nouns.

A "Hello World!" sample is quite long, reading exactly like a play, so here is only part of the source code (the full one is available here):


 The Infamous Hello World Program.
 
 Romeo, a young man with a remarkable patience.
 Juliet, a likewise young woman of remarkable grace.
 Ophelia, a remarkable woman much in dispute with Hamlet.
 Hamlet, the flatterer of Andersen Insulting A/S.
 
 
 Act I: Hamlet's insults and flattery.
 
 Scene I: The insulting of Romeo.
 
 [Enter Hamlet and Romeo]
 
 Hamlet:
 You lying stupid fatherless big smelly half-witted coward!
 You are as stupid as the difference between a handsome rich brave
 hero and thyself! Speak your mind!
 
 You are as brave as the sum of your fat little stuffed misused dusty
 old rotten codpiece and a beautiful fair warm peaceful sunny summer's
 day. You are as healthy as the difference between the sum of the
 sweetest reddest rose and my father and yourself! Speak your mind!
 
 You are as cowardly as the sum of yourself and the difference
 between a big mighty proud kingdom and a horse. Speak your mind.
 
 Speak your mind!
 
 [Exit Romeo]

6. Chef

Similar to Shakespeare, Chef, created by David Morgan-Mar, is a programming language that doesn’t look like one, looking instead like a cooking recipe. The design principles of the language is that

  • the code should not only generate valid output but the output must be easy to prepare and delicious
  • recipes appeal to cooks with different budgets
  • the recipes have to be metric

In other words, the recipes must work as code, AND can be prepared and eaten. The source code for the ‘Hello World!’ program is available below:


 Hello World Souffle.
 
 This recipe prints the immortal words "Hello world!", 
 in a basically brute force way.
 It also makes a lot of food for one person.
 
 Ingredients.
 72 g haricot beans
 101 eggs
 108 g lard
 111 cups oil
 32 zucchinis
 119 ml water
 114 g red salmon
 100 g dijon mustard
 33 potatoes
 
 Method.
 Put potatoes into the mixing bowl.
 Put dijon mustard into the mixing bowl.
 Put lard into the mixing bowl.
 Put red salmon into the mixing bowl.
 Put oil into the mixing bowl. Put water into the mixing bowl.
 Put zucchinis into the mixing bowl. Put oil into the mixing bowl.
 Put lard into the mixing bowl. Put lard into the mixing bowl.
 Put eggs into the mixing bowl. Put haricot beans into the mixing bowl.
 Liquefy contents of the mixing bowl.
 Pour contents of the mixing bowl into the baking dish.
 
 Serves 1.

7. Whitespace

Whitespace was created by Edwin Brady and Chris Morris as an April Fools’ joke. Where most programming languages ignore whitespace characters, Whitespace uses them as commands, ignoring non-whitespace characters instead.

Because of this, Whitespace code can be written inside programming languages that ignore whitespace. Below is a ‘Hello World!’ source code written in Whitespace (color is used for clarity).

Whitespace

8. Piet

Named after Piet Mondrian, Piet is yet another esoteric programming language created by David Morgan-Mar. The program is compiled by a pointer that will move around the image, from one section to the other.

The code is in the color; the colors is read by the compiler to turn into a program. Below is an example of a ‘source code’, with the output being ‘Hello World!’:

Piet

9. Chicken

Chicken. This is a programming language consisting of only one word: chicken. It was created by Swedish programmer Torbjörn Söderstedt, who was inspired to create it after hearing Doug Zongker’s parody of scientific speeches (which nobody understands).

Rather than showing the code for ‘Hello World!’, which would take half the page and consist of nothing but the word ‘chicken’, here is the paper and presentation that inspired the language:

10. Ook!

Ook! is a derivative of Brainf*ck, and is created by serial esoteric language developer, David Morgan-Mar. The structure is the same, except the eight commands are substituted with combinations of "Ook.", "Ook?" and "Ook!".

The aim was to create, and we kid you not, a programming language "writable and readable by orangutans". Below is the source code for ‘Hello World!’:


 Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook.
 Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook?
 Ook! Ook! Ook? Ook! Ook? Ook. Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook.
 Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook.
 Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook.
 Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook!
 Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook. Ook! Ook.

11. reMorse

Developed by Ryan Kusnery, ReMorse is a programming language that was made to look like Morse code. There are only four instructions: dot (.), dotty (. followed by a space), dash (-) and dasher (- followed by a space).

The specifications of ReMorse were unclear, and ReMorse2 was created as an attempt to clean the code up a bit. Below is an incomplete sample for ‘Hello World!":


 - - - ..- ...-.---.;newline
 - - - .-. - ..-.- ...-. ---.;!
 - - - ...- . . -.---.;d
 ----. . . -.---.;l
 ----. . -...---.;r
 ----. -...---.;o
 ----...-.- ..-. ---.;W
 omitted code for "Hello " is similar to the above for "World!"
 -..............;output all characters

12. l33t

Anyone who has ever spent even a bit of time on the internet knows what l33t sp34k (leet speak) is — users substitute words and letters with numbers and intentionally bad spelling.

Two programmers, Stephen McGreal and Alex Mole, decided that it would be a good idea to create a programming language out of it and thus l33t was born. As with many other esoteric languages, it was designed to be as "brain-melting as possible to code in". Below is the source code for ‘Hello World!’:


 // "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!!!!!!!

13. Omgrofl

Omgrofl (which stands for ‘oh my god rolling on the floor’) was created by Juraj Borza where all the commands are made up of internet acronyms such as lol, wtf, brb, stfu, etc. All variables declared with the language must be in the form of lol, e.g. lol, lool, loool, etc. Here’s what the source code for ‘Hello World!’ looks like:


 loool iz lol
 looooool iz lool
 rtfm
 wtf looooool iz liek 0 
 tldr
 brb
 lmao loool
 roflmao looooool
 brb

14. Velato

Velato is a language created by Daniel Temkin which uses MIDI files as the source code. The commands are determined by the the pitch and order of notes and the source codes created using Velato tend to have a jazz-like sound to them.

The ‘Hello World!" example given below is what the ‘source code’ looks like:

Velato

15. Malbolge

If a programming language is named after the eighth circle of Hell, you know what to expect. Created by Ben Olmstead in 1998, Malbolge was designed to be near-impossible to program it.

In fact, it was not manmade — it is created using an algorithm. It’s no wonder that it took 2 years for the program to materialize. This is the source code for ‘Hello World!’ for this impossible programming language to give you an idea of the craziness in the code.

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

16. Taxi

Taxi looks like a roadmap language that road travellers will find easy to understand but not necessarily to code. It is the official programming language of Townsville, where the traditional coding language has been replaced by a modern map language. Variables, classes or functions are replaced by places or cities in this language.

You map out taxi routes that ferry a passenger from one place to another and you’re required to give instructions about directions, pickups and drop offs. The taxis need fuel to run hence passengers pay for their rides, and you get cash for refueling your taxi at the gas stations.

Here’s "Hello, World!" in Taxi language:

"Hello, World!" is waiting at the Writer's Depot.
Go to Writer's Depot: west 1st left, 2nd right, 1st left, 2nd left.
Pickup a passenger going to the Post Office.
Go to the Post Office: north 1st right, 2nd right, 1st left.
Go to the Taxi Garage: north 1st right, 1st left, 1st right.

17. ZOMBIE

ZOMBIE is a programming language designed for necromancers (magic practitioners who talk to the dead). It allows its coders to write code to animate dead bodies, control spirits and solve computable problems through them. It has a guarantee against overwriting system memory and releasing malicious entries onto the Earth.

ZOMBIE comes in the form of entity declarations. In this language, syntax errors are extremely dangerous because demons may escape the CPU and create havoc in the world with incorrect binding commands. Its data values are free format and compatible with standard mathematics rules.

An example for printing "Hello, World!" in ZOMBIE language:

HelloWorld is a zombie
summon
	task SayHello
		say "Hello, World!"
	animate
animate

18. BIT

BIT is a powerful low-level programming language where the coder gets full access to the entire data in its ASCII implementation. The manipulation of data is less complicated than high-level languages using specialized functions for abstract data types. There are two data types in BIT: bit and address-of-a-bit.

The data values in BIT can be operated using operators and commands. This language is strongly typed (i.e., data is always declared along with its type) and even supports the controversial "GOTO" flow control command. BIT allows any amount of whitespace and line breaks between syntax elements.

An example for printing "Hello, World!" in BIT language:

LINE NUMBER ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ONE
LINE NUMBER ONE CODE PRINT ZERO GOTO ONE ZERO
LINE NUMBER ONE ONE CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ZERO
LINE NUMBER ONE ZERO CODE PRINT ONE GOTO ONE ONE
LINE NUMBER ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE
LINE NUMBER ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ZERO
LINE NUMBER ONE ONE ZERO CODE PRINT ONE GOTO ONE ZERO ZERO
LINE NUMBER ONE ZERO ZERO CODE PRINT ONE GOTO ONE ONE ONE ONE
LINE NUMBER ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE
LINE NUMBER ONE ZERO ONE ONE CODE PRINT ZERO GOTO VARIABLE ONE
LINE NUMBER ONE ONE ZERO ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO
LINE NUMBER ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ONE
LINE NUMBER ONE ZERO ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ONE ZERO
LINE NUMBER ONE ZERO ONE ZERO CODE PRINT ONE GOTO ONE ONE ZERO ZERO
LINE NUMBER ONE ONE ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO
LINE NUMBER ONE ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE
LINE NUMBER ONE ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE
LINE NUMBER ONE ZERO ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ONE
LINE NUMBER ONE ONE ZERO ONE ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO ONE
LINE NUMBER ONE ONE ONE ZERO ONE CODE PRINT ONE GOTO ONE ONE ONE ONE ZERO
LINE NUMBER ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ONE
LINE NUMBER ONE ZERO ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ZERO ONE
LINE NUMBER ONE ZERO ONE ZERO ONE CODE PRINT ONE GOTO ONE ZERO ONE ONE ZERO
LINE NUMBER ONE ZERO ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ONE
LINE NUMBER ONE ONE ZERO ZERO ONE CODE PRINT ONE GOTO ONE ONE ZERO ONE ZERO
LINE NUMBER ONE ONE ZERO ONE ZERO CODE VARIABLE ONE EQUALS ONE ONE ONE ZERO ZERO GOTO ONE
LINE NUMBER ONE ONE ONE ZERO ZERO CODE VARIABLE ONE EQUALS ONE ZERO ZERO ZERO ONE GOTO ONE
LINE NUMBER ONE ZERO ZERO ZERO ONE CODE VARIABLE ONE EQUALS ONE ONE ONE ONE ZERO ONE GOTO ONE ONE
LINE NUMBER ONE ZERO ZERO ONE ZERO CODE PRINT ONE GOTO ONE ZERO ONE ZERO ZERO
LINE NUMBER ONE ZERO ONE ZERO ZERO CODE PRINT ONE GOTO ONE ONE ZERO ZERO ZERO
LINE NUMBER ONE ONE ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO ZERO
LINE NUMBER ONE ZERO ZERO ZERO ZERO CODE PRINT ONE GOTO ONE ONE ONE ONE ONE ONE
LINE NUMBER ONE ONE ONE ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE ONE ONE ONE
LINE NUMBER ONE ZERO ONE ONE ONE ONE CODE PRINT ONE GOTO ONE ONE ZERO ONE ONE ONE
LINE NUMBER ONE ONE ZERO ONE ONE ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO ONE ONE
LINE NUMBER ONE ONE ONE ZERO ONE ONE CODE PRINT ZERO GOTO VARIABLE ONE
LINE NUMBER ONE ONE ONE ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE ZERO
LINE NUMBER ONE ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZEROZERO ONE ONE ONE
LINE NUMBER ONE ZERO ZERO ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE ZERO ONE ONE
LINE NUMBER ONE ZERO ONE ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ZERO ONE
LINE NUMBER ONE ZERO ONE ONE ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE ZERO
LINE NUMBER ONE ZERO ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ONE ONE
LINE NUMBER ONE ONE ZERO ZERO ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ZERO ONE
LINE NUMBER ONE ONE ZERO ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ONE ZERO
LINE NUMBER ONE ONE ZERO ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ONE ZERO ZERO ONE
LINE NUMBER ONE ONE ONE ZERO ZERO ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO ONE ZERO
LINE NUMBER ONE ONE ONE ZERO ONE ZERO CODE PRINT ONE GOTO ONE ONE ONE ONE ZERO ZERO
LINE NUMBER ONE ONE ONE ONE ZERO ZERO CODE PRINT ONE GOTO ONE ZERO ZERO ZERO ONE ONE
LINE NUMBER ONE ZERO ZERO ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ZERO ONE
LINE NUMBER ONE ZERO ZERO ONE ZERO ONE CODE PRINT ONE GOTO ONE ZERO ZERO ONE ONE ZERO
LINE NUMBER ONE ZERO ZERO ONE ONE ZERO CODE PRINT ONE GOTO ONE ZERO ONE ZERO ZERO ONE
LINE NUMBER ONE ZERO ONE ZERO ZERO ONE CODE PRINT ONE GOTO ONE ZERO ONE ZERO ONE ZERO
LINE NUMBER ONE ZERO ONE ZERO ONE ZERO CODE VARIABLE ONE EQUALS ONE ZERO ONE ONE ZERO ZERO GOTO ONE ONE
LINE NUMBER ONE ZERO ONE ONE ZERO ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ZERO ONE
LINE NUMBER ONE ONE ZERO ZERO ZERO ONE CODE PRINT ONE GOTO ONE ONE ZERO ZERO ONE ZERO
LINE NUMBER ONE ONE ZERO ZERO ONE ZERO CODE PRINT ONE GOTO ONE ONE ZERO ONE ZERO ZERO
LINE NUMBER ONE ONE ZERO ONE ZERO ZERO CODE PRINT ONE GOTO ONE ONE ONE ZERO ZERO ZERO
LINE NUMBER ONE ONE ONE ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO ZERO ONE
LINE NUMBER ONE ZERO ZERO ZERO ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO ONE ZERO
LINE NUMBER ONE ZERO ZERO ZERO ONE ZERO CODE PRINT ONE GOTO ONE ZERO ZERO ONE ZERO ZERO
LINE NUMBER ONE ZERO ZERO ONE ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ONE ZERO ZERO ZERO
LINE NUMBER ONE ZERO ONE ZERO ZERO ZERO CODE VARIABLE ONE EQUALS ONE ONE ZERO ZERO ZERO ZERO GOTO ONE
LINE NUMBER ONE ONE ZERO ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE ONE ONE
LINE NUMBER ONE ONE ONE ONE ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ZERO ZERO ZERO ZERO
LINE NUMBER ONE ZERO ZERO ZERO ZERO ZERO CODE PRINT ONE GOTO ONE ZERO ONE ONE ONE ONE ONE
LINE NUMBER ONE ZERO ONE ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ONE ONE ONE
LINE NUMBER ONE ONE ZERO ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ONE ZERO ONE ONE ONE
LINE NUMBER ONE ONE ONE ZERO ONE ONE ONE CODE PRINT ONE GOTO ONE ONE ONE ONE ZERO ONE ONE
LINE NUMBER ONE ONE ONE ONE ZERO ONE ONE CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE ZERO ONE
LINE NUMBER ONE ONE ONE ONE ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE ONE ZERO
LINE NUMBER ONE ONE ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ONE ONE ONE
LINE NUMBER ONE ZERO ZERO ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ZERO ONE ONE ONE
LINE NUMBER ONE ZERO ONE ZERO ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE ONE ZERO ONE ONE
LINE NUMBER ONE ZERO ONE ONE ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE ZERO ONE
LINE NUMBER ONE ZERO ONE ONE ONE ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE ONE ZERO
LINE NUMBER ONE ZERO ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ONE ONE ONE
LINE NUMBER ONE ONE ZERO ZERO ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ZERO ONE ONE
LINE NUMBER ONE ONE ZERO ONE ZERO ONE ONE CODE PRINT ONE

19. Unlambda

Unlambda is a language mix of obfuscated and functional programming paradigms. In this language, everything is a function – even the data. It removes various crucial features: there is no way to store data or have variables, and moreover, you can create functions but can’t name or save them. Oops.

Unlambda works only with functions: each function takes exactly one another function as an argument and returns just one yet another function. It does allow working with data structures and the like, but you must represent them as ad-hoc functions (everything is a function, after all).

An example for printing "Hello, World!" in Unlambda language:

```s``sii`ki
``s``s`ks
``s``s`ks``s`k`s`kr
``s`k`si``s`k`s`k
`d````````````.H.e.l.l.o.,. .W.o.r.l.d.!
k
k
`k``s``s`ksk`k.*

20. Java2K

Java2K is a probabilistic language that works on the nature of the universe: “there is never absolute security, there is always only probability.” It doesn’t do whatever you intend for it to do; even the built-in functions work weird. However, it does source-code level checking for security and the language uses an 11-based number system – counting up to 9 and including 10.

The program always consists of 2 arguments – even if you need just one. There are two types of numbers: names of the objects and integer values. For every function in Java2K, there are various implementations and any of them is chosen randomly at the runtime. It has a number of restrictions on valid keywords and functions, and the language even offers a garbage collector to auto-release memory.

An example for printing "Hello, World!" in Java2K language:

1 1 /125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\
\\\\\\\/*\1 1 /125 /119 /11 6/*/_\/13 2/*/_\\/
125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\
/125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_
\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_
\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_
\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_
\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\
\\\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\
\\\\\\\/*\1 1 /125 /131 /119 /125 /11 6/*/_\/_\
/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\/
125 /13 2/*/_\/_\\\/125 /131 /119 /125 /11 6/*/
_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/
_\/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\
/125 /13 2/*/_\/_\\\\/125 /131 /119 /125 /11 6/
*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/
*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/
*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/
*/_\/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/
_\/125 /13 2/*/_\/_\\\\\\/131 /119 /125 /11 6/*
/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*
/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*
/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*
/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*
/_\/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_
\/125 /13 2/*/_\/_\\\\\\\\\\/*\1 1 /125 /131 /
119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/119 /
125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\/125 /
131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/
131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/
119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\\/
125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\
\\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\\
\\\\\\/*\1 1 /125 /119 /11 6/*/_\/13 2/*/_\\/
125 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/
125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\
/125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_
\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_
\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\
\\/125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*
/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*
/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*
/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*
/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_
\\\\\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\
\\\\\\\\\\\/*\1 1 /125 /131 /119 /125 /11 6/*/_
\/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\/
125 /13 2/*/_\/_\\\/125 /131 /119 /125 /11 6/*/
_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/
_\/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\
/125 /13 2/*/_\/_\\\\/131 /119 /125 /11 6/*/_\/
_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_\/
_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_\/
_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_\/
_\/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\/
125 /13 2/*/_\/_\\\\\\\\/*\1 1 /131 /119 /125 /
11 6/*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /
11 6/*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /
11 6/*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /
11 6/*/_\/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/
*/_\/_\/125 /13 2/*/_\/_\\\\\\/*\1 1 /125 /
119 /11 6/*/_\/13 2/*/_\\/125 /119 /125 /11 6/*
/_\/_\/125 /13 2/*/_\/_\\/125 /131 /119 /125 /
11 6/*/_\/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/
*/_\/_\/125 /13 2/*/_\/_\\\/125 /131 /119 /
125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /
125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /
125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/119 /125 /
11 6/*/_\/_\/125 /13 2/*/_\/_\\\\\/131 /119 /
125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /
125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /
125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /
125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /
125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/119 /125 /
11 6/*/_\/_\/125 /13 2/*/_\/_\\\\\\\\\\\/*\
1 1 /125 /119 /11 6/*/_\/13 2/*/_\\/125 /119 /
125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/125 /131 /
119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/119 /
125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\/125 /
131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/
131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/
119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\\/
125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\
\\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\\
\\\\\\\\/*\1 1 /125 /119 /125 /11 6/*/_\/_\/
125 /13 2/*/_\/_\\/125 /131 /119 /125 /11 6/*/_
\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_
\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_
\/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\/
125 /13 2/*/_\/_\\\\\/125 /131 /119 /125 /11 6/
*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/
*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/
*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/
*/_\/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/
_\/125 /13 2/*/_\/_\\\\\\/131 /119 /125 /11 6/*
/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*
/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*
/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*
/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*
/_\/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_
\/125 /13 2/*/_\/_\\\\\\\\\\/*\1 1 /125 /131 /
119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/119 /
125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\/125 /
131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/
131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/
119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\\/
125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\
\\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/
_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\\
\\\\\\/*\1 1 /125 /131 /119 /125 /11 6/*/_\/_\/
125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /
13 2/*/_\/_\\\/125 /131 /119 /125 /11 6/*/_\/_\
/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\
/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\
/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\
/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\/
125 /13 2/*/_\/_\\\\\\/131 /119 /125 /11 6/*/_\
/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_\
/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_\
/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_\
/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_\
/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\/
125 /13 2/*/_\/_\\\\\\\\\/*\

21. Deadfish

Deadfish is an odd interpreted language, which was originally programmed in just few hours using the C language. Deadfish has just 4 commands in total: all for outputting things but none for inputting things (I did say it was odd). The language is case-sensitive, and it can deal only with integer values while adding or subtracting.

Its standard shell doesn’t accept anything that’s not a command. However, there is no way of catching or reporting errors at runtime, and the shell simply prints a newline for any error. Its name "Deadfish", was given because programming in this language feels as unpleasant as eating rotten dead fishes.

An example for printing "Hello, World!" in Deadfish language:

iisiiiisiiiiiiiioiiiiiiiiiiiiiiiiiiiiiiiiiiiiioiiiiiiiooiiio
dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddo
dddddddddddddddddddddsddoddddddddoiiioddddddoddddddddo

22. Emmental

Emmental is a self-modifying programming language defined by a meta-circular interpreter. It’s a stack-based language with just 13 instructions and its stack may only contain ASCII characters. Though not supported directly, conditional branching can be done in this language using the eval instruction ‘?’.

Though Emmental may look alien compared with other obfuscated languages, its English semantics make things less troublesome than other such languages. You can do primitive arithmetic, stack and queue manipulation (yes, it has got one queue too) and much more using Emmental language.

An example for printing "Hello, World!" in Emmental language:

;#58#126#63#36!;#46#36#!;#0#1!;#0#2!;#0#3!;#0#4!;#0#5!;#0#6!;#0#7!#0#33#100#108#114#111#119#32#44#111#108#108#101#72$

23. Whenever

Whenever is a language without any urgency or execution sequence: it does things whenever it feels like it and not per the sequence specified by the programmer. Just think of what will happen if a mail to your boss is sent before/without checking for spelling mistakes. Yes, that nightmare you just dreamt up is what you get with Whenever.

Whenever doesn’t "believe" in variable or data structures because it doesn’t care for program sequence. However, it does provide constructs to reassign things if a particular line of code have a prerequisite that’s not yet prepared. Unlike a few other languages, it does support strings and compound statements.

An example for printing "Hello, World!" in Whenever language:

1 print("Hello, World!");

24. INTERCAL

INTERCAL (aka Compiler Language With No Pronounceable Acronym) is a language that criticizes various languages at the same time. INTERCAL makes things absurd for programmers with construct statements like ‘PLEASE’, ‘FORGET’, ‘IGNORE’ and more. The coder must use ‘PLEASE’ often enough else the program is considered impolite and the compiler reports the same as an error. (It’s not programming unless there is an element of torture for some.)

INTERCAL was developed completely different from other programming languages. However, unlike other obfuscated languages like Unlambda and Deadfish, it does offer lots of data structures, operators and control structures. And yet, at the end of the day, these do not reduce its complexity.

An example for printing "Hello, World!" in INTERCAL language:

DO ,1 <- #13
PLEASE DO ,1 SUB #1 <- #238
DO ,1 SUB #2 <- #108
DO ,1 SUB #3 <- #112
DO ,1 SUB #4 <- #0
DO ,1 SUB #5 <- #64
DO ,1 SUB #6 <- #194
DO ,1 SUB #7 <- #48
PLEASE DO ,1 SUB #8 <- #22
DO ,1 SUB #9 <- #248
DO ,1 SUB #10 <- #168
DO ,1 SUB #11 <- #24
DO ,1 SUB #12 <- #16
DO ,1 SUB #13 <- #162
PLEASE READ OUT ,1
PLEASE GIVE UP

25. Orthogonal

Orthogonal is an uncommon programming language in which the flow can go in any direction your wish. It’s a proof-of-concept experiment with a working interpreter. Its environment consists of two objects: the grid and the stack. The grid is the same as an array and a stack is a well-known one-dimensional entity.

Orthogonal, unlike various computer languages, is a 2-dimensional language and its instruction set falls into three categories: operators, directives and others. The language offers much more help to the coders than BIT, Deadfish and a few others. Moreover, it also supports data values and variables.

An example for printing "Hello, World!" in Orthogonal language:

0 'd' 'l' 'r' 'o' 'w' ' ' ',' 'o' 'l' 'l' 'e' 'h' s 0 c 0 ret
WebsiteFacebookTwitterInstagramPinterestLinkedInGoogle+YoutubeRedditDribbbleBehanceGithubCodePenWhatsappEmail