Esoteric programming languages are programming languages that are not intended to have a practical purpose. Some knowledge of programming is assumed by these pages.
Brackets after each language indicate the language the interpreter is written in (multiple pairs of brackets = multiple interpreters; crossed out = probably not compatible with your browser/computer). [JS] means it runs in your browser (requires JavaScript); anything else you'll have to download.
Note: There is a well-known esoteric programming language that many of these pages mention whose name ("Brainf***") contains a certain four-letter word some people might not want to see. If you don't want to see that word, check "Censor bad words" here and click "Save".
while(true) {entire program goes here}
void getLanguageDescription(void)[void][][];
See also: Experimental programming languages, for some somewhat-less-esoteric languages
My first attempt at an esoteric programming language, but I didn't finish much more than exception handling. A programming language where the only control flow is exception handling (but there's also relatively normal variable assignment and arithmetic). Also most operations other than exception handling/control flow are done by reading from and writing to variables with specific names.
Example (Fibonacci numbers):
output "How many numbers?"
number input
output "1 "
prev 0
cur 1
i 1
try
new prev+cur
int new
output output&int&" "
prev cur
cur new
i i+1
discard sqrt (i-number)
catch negsqrt
retry
end
The answer is always 9... where 9 is a variable containing the actual answer. A programming language where all variable names are numbers.
Example (Fibonacci numbers):
Find the first n fib numbers
-42 find n at least two
9:0
42
9:1
42
7:0
8:1
10:2
while 10<5
9:7+8
42
7:8
8:9
10:10+1
-1
while(true) {entire program goes here}
A programming language that implicitly encloses the entire program in an infinite loop, and doesn't have any other way to make loops. It also "solves" the halting problem by not allowing programs to halt.
Example (prints prime numbers):
[!!started] n=2
[!!started] started=1
[m>1 & int(n/m)?n/m] nprime=1
[1] m=m+1
[m>=n] print(n)
[m>=n] print("\n")
[nprime|m>=n] m=0
[m?0] n=n+1
[m?0] nprime=0
A minimalist object-oriented programming language, somewhat inspired (in both goal and syntax) by Unlambda.
Example (print Fibonacci numbers as asterisks):
o0 `::2xy y
no
+::xy+ `::2. =ax =by
`p `::2. `::2. `p?a `p?b .
$1'*
$00 `p.
$n'
_o
`::dxy `::2. `::2. `px `p+$n `::d.y+::nxy
++ `::d.+$0+$1
A simple counterexample to any claim about "Turing complete and does IO". Not actually usable for programming.
Example (asks for your name and says "hello"):
"Enter your name:
" @ "Hello!"
A bunch of random ideas put together in a programming language.
Its name stands for "Computer Language With Pronounceable Acronym, Just Not This Acronym". Its name, along with the fact that it's sort of a parody of other programming languages, is inspired by Compiler Language With No Pronounceable Acronym (abbreviated INTERCAL), though otherwise there's not much relation.
Example (Fibonacci numbers):
answer("How many numbers?\n")
then number = makeLessStringy(ask())
then answer("1 ")
then prev=0 then cur=1
then too(i=1, i<number) (
new=int(prev+cur)
then answer(new+" ")
then prev=cur then cur=new
then i=i+1
)
♮ Design goal: To create a programming language using primarily the Miscellaneous Symbols Unicode characters (U+2600 through U+26FF). Also used are Enclosed Alphanumerics (starting at U+2460) and Dingbats (starting at U+2700). No ASCII is used except whitespace. (Basically I just looked at the various characters there and tried to figure out what they could mean in a programming language.)
Also, the only type variables can hold is arrays, and the only type arrays can hold is other arrays.
Example (cat):
♯✎ⓐ♙♗✎♮☃ⓐ
♭⚐☎⚑☯☂
❝ⓑ✂Ⓑ❞☢ⓑ✂Ⓐ❞
☏⚑
finite-state machine : regular expressions :: Turing machine : ?
A cell-based programming language inspired by regular expressions, which is nondeterministic in the computer science sense of always choosing the right option.
Example (add two little-endian binary numbers):
((
[(|0>`\00'[01]*\++|0>`\+'[01]*\00[01]*[(|\00>`0')(|c>`1')])
(|0>`\00'[01]*\++|1>`\+'[01]*\00[01]*[(|\00>`1')(|c>`0c')])
(|1>`\00'[01]*\++|0>`\+'[01]*\00[01]*[(|\00>`1')(|c>`0c')])
(|1>`\00'[01]*\++|1>`\+'[01]*\00[01]*[(|\00>`0c')(|c>`1c')])]
<\00[01c]*\00[01\+]*>\00
)+
\++\00[01]*[(|c`1')(<\00)])
Programming language based closely on Turing machines with a Turing-complete macro language based on expression rewriting.
Example (ROT13):
% ROT13-encode text
% Takes input from standard in
{Mem: Finite; [In, Out]: Interact; Nondeterm: False}:
tape@0#255, [Start, Modify]: {
CharCode: tape;
<97,109>:<110,122>;
<110,122>:<97,109>;
<65,77>:<78,90>;
<78,90>:<65,77>;
c@#:c;
tape~(255, Start): Halt;
Start: {IO: In; Next: Modify};
Modify: {Write: tape*; IO: Out; Next: Start};
}
An extremely minimalist stack-based language with only three command types. Also includes a slightly higher-level version of the language that can easily be compiled into Simple Stack.
Example (Fibonacci as asterisks):
a ! *! b,
b ! a b,
end end,
mainloop ! |! mainloop!,
main end b mainloop!
A language based on a counter machine, which also has some weirdness about control flow.
Example (Fibonacci):
!desc "Calculates the nth Fibonacci number";
!prime n=2 c=3;
@in n; @out b;
@start c=1;
n:
a-1 @repeat;
b-1 a+1 @repeat;
c >> +b;
a >> +c;
Example (Infinite loop):
||comment Infinite loop!|for i = 0 to nfnt||print "Unbroken! "...||||
A variant of Unlambda with Haskell-like monad I/O and lazy evaluation.
Example (Fibonacci as asterisks):
\undo1
# Prints the Fibonacci numbers as sequences of *'s
# ``` ^f`$f$f ^f^a^b``$a`kr `k```$f$f$b`$a$b `1v .*
```
``sii
``s`k`s``s`ks
``s`kk``si
`k`kr
``s`k`s`k`s`kk``s``s`ks``s`kk``s`ks``s``s`ks``s`kk``sii`ki`k``s``s`ks``s`kki`k``s`kki
`1v
.*
A statically-typed functional programming language where regular expressions are types.
Example (Fibonacci):
\Vretype2
.*{??}i
$i:
`"Enter the number of fibonacci numbers you want to generate in unary."'
^i$i:
`\n\*\n'
((\**\n)*(\**\n)(\**\n))s ^_
$s:^s^a^b
`$s$a$b
$a:^\*$\*
$b'
A programming language where everything is a coroutine, and the only non-IO operation is coroutine transfer.
Example (Fibonacci as asterisks):
zero:
p>. p<.
one:
p>. "*" p<.
plus:
p>a p<.
p>b p<.
p>.
a/1<. b/1<. p<.
loop:
p>a p<.
p>b
a/print<. "\n"
loop/next<b
plus/next<a/next plus/next<b/next loop/next<plus/next
main:
loop/1<zero
loop/1<one
A programming language inspired by INTERCAL, but where all of the variables have been replaced by a single bigint. Also, the NEXT family of commands has been replaced by COME FROM, with some new forms of COME FROM and ABSTAIN FROM to make up for the missing commands.
Example (Fibonacci as stars):
PLEASE #1
DO COME FROM (1)
(1000) PLEASE |1\3 ¢ |2\3 ¢ |1\3
PLEASE COME FROM (1500) AFTER (1000)
PLEASE |1\1 ¢ |2\3
(2) PLEASE REINSTATE "|1\3 ~ |1\3" ~ #1 COMINGS FROM
DO COME FROM (4)
PLEASE READ OUT #0
(1) DO |2\3
PLEASE DON'T COME FROM (2)
PLEASE DON'T COME FROM (3)
(1011) DO ℛℰ𝒜𝒟 𝒪𝒰𝒯 #62239
PLEASE COME FROM (1511) AFTER (1011)
(3) DO REINSTATE "|1\3 ~ |1\3" ~ #1 COMINGS FROM
(4) DO NOTHING
Basic Time Travel is an unstructured esoteric programming language based on BASIC that allows time travel. Its only way of making loops involves making the program travel to the past to get its past self to run the same statements again.
Why am I suddenly thinking about spaghetti?
(Photosensitivity warning: Programs written in this language have a tendency for their output to flicker.)
Example (Fibonacci):
100 Number = 0
150 if Done = 0 thaw
200 Number = 1
201 if Done = 0 goto 1
250 freeze
251 goto @-50
NUM_START = 250
NUM_START+10 print Number
NUM_START+11 Done = 1
NUM_START+12 number = Number
NUM_START+102 Done = 0
NUM_START+103 number + Number
NUM_START+150 if Done = 0 thaw
NUM_START+200 Number = number
void is a weird type, so I made a programming language about it. You cannot stare into the void, because that would be a type error.
Voids For All is a statically-typed esolang where the only primitive type is void, which uses C-style declarator syntax. Also its only control structure is the for loop.
Example (Fibonacci):
void a[] = 0, b[] = 1;
for {
void c[] = {+a, +b};
print({+format(a), 10});
a = b;
b = c;
}