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

- Try [JS][Java]: my first attempt at an esoteric programming language, but I didn't finish much more than exception handling
- 42 [JS][Java]: the answer is always 9... where 9 is a variable containing the actual answer
- loopy [C]:
`while(true) {`

`entire program goes here`} - Unoop (version 2.1) [Python 3][Python 2]: one of my attempts at doing for OOP what Unlambda did for lambda calculus...
- Useless [JS]: a simple proof-of-concept
- CLWPAJNTA [Java]: various features
- Symbols [JS][Java command-line]: ♮
♯ ♭ ♙ ♘ ♗ ♖ ♕ ♔ ♟ ♞ ♝ ♜ ♛ ♚ ⚀ ⚁ ⚂ ⚃ ⚄ ⚅ ☂ ☀ ⚐ ☏ ♡ ⚑ ☎ ♥ ☯ ✎ ♲ ☃ ☁ ✂ ☢ ❝ ❞ - TurExp [JS][Haskell]: finite-state machine : regular expressions :: Turing machine : ?
- T-Write [Haskell]: programming language based closely on Turing machines with a Turing-complete macro language based on expression rewriting.
- Simple Stack [JS]: minimalist stack-based programming language
- fracasm [Python 3][Python 2]: language based on a counter machine
- Unbroken [JS]
- Undo [JS]: variant of Unlambda with Haskell-like monad I/O
- RE-type [JS]: regular expressions are types
- Co [JS]: everything is a coroutine
- BigINTERCAL [JS]: INTERCAL, but all the variables are replaced by one bigint
- Basic Time Travel [JS]: anyone want some spaghetti?
- Voids For All! [JS]:
`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
```

**Paradigm:**imperative, dynamically typed**Computational class:**Turing complete**IO model:**interactive, Unicode, can clear output, limited ability to interpret input**Interpreter language:**JavaScript (web-based) or Java (download, or applet on older browsers)**Date:**original 2006-11-13; JavaScript interpreter 2015-09-17**Version:**1.1 (1.0 interpreter written in Java also available)

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
```

**Paradigm:**imperative, structured, one type**Computational class:**almost Turing complete (the limited range of floating point limits the amount of available memory)**IO model:**interactive, numbers only**Interpreter language:**JavaScript (web-based) or Java (download, or applet on older browsers)**Date:**original 2006-12-09 – 2006-12-12; JavaScript interpreter 2015-09-18

`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
```

**Paradigm:**imperative, dynamically typed (also has manual memory management)**Computational class:**Turing complete (except it can't actually halt)**IO model:**interactive, bytestrings**Interpreter language:**C (download)**Date:**original 2007-04-15 (or earlier) – 2007-09-27; bugfix update and first published 2020-08-07**Version:**1.0.1

A minimalist object-oriented programming language, somewhat inspired (in both goal and syntax) by Unlambda.

Example (print Fibonacci numbers as asterisks):

**o**0 `::2xy y
**n**o
+::xy+ `::2. =ax =by
`p `::2. `::2. `p?a `p?b .
**$1**'*
**$0**0 `p.
**$n**'
**_**o
`::dxy `::2. `::2. `px `p+$n `::d.y+::nxy
++ `::d.+$0+$1

**Paradigm:**imperative, dynamically typed, object oriented**Computational class:**Turing complete**IO model:**interactive, Unicode (when using the Python 3 interpreter)**Interpreter language:**Python 3 (download) (an older Python 2 version is also available)**Date:**original 2010-08-20**Version:**2.1 (previous versions were never published)

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

**Paradigm:**functional/declarative**Computational class:**Turing complete (except it can't actually halt)**IO model:**restricted, Unicode**Interpreter language:**JavaScript (web-based)**Date:**2010-08-19**Version:**1.0

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

**Paradigm:**imperative, structured, dynamically typed**Computational class:**Turing complete**IO model:**interactive, Unicode**Interpreter language:**Java (download, or applet on older browsers)**Date:**original 2006-12-30 – 2006-12-31; version 2 2012-07-28 – 2012-09-28**Version:**2.0 (1.0 is also available)

♮

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

```
♯✎ⓐ♙♗✎♮☃ⓐ
♭⚐☎⚑☯☂
❝ⓑ✂Ⓑ❞☢ⓑ✂Ⓐ❞
☏⚑
```

**Paradigm:**imperative, unstructured (also has manual memory management)**Computational class:**Turing complete**IO model:**interactive, Unicode, has audio output**Interpreter language:**JavaScript (web-based) or Java (download)**Date:**original 2009-12-20 – 2009-12-21; version 2 2020-09-16 – 2020-09-21**Version:**version 2.0 (1.0 interpreter written in Java also available)

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)])
```

**Paradigm:**imperative, structured, nondeterministic, cell-based**Computational class:**Turing complete**IO model:**non-interactive, bytestrings**Interpreter language:**JavaScript (run in browser) or Haskell (download)**Date:**2012-04-29 – 2012-11-29; version 3 from 2021-12-15 – 2022-02-23**Version:**3.0 (2.0 interpreter also included; 1.0 was never published)

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};
}
```

**Paradigm:**rewriting, cell-based**Computational class:**Turing complete**IO model:**interactive or non-interactive**Interpreter language:**Haskell (download)**Date:**2012-05-02 – 2012-11-29

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!

**Paradigm:**stack-based**Computational class:**Turing complete**IO model:**interactive, Unicode, has format limitations**Interpreter language:**JavaScript (web-based)**Date:**original 2012-08-16 – 2013-11-17; version 1.1 2020-06-25 – 2020-07-02**Version:**1.1 (1.0 is also available)

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;
```

**Paradigm:**imperative, unstructured, counter machine**Computational class:**Turing complete**IO model:**non-interactive, numbers only**Interpreter language:**Python 3 (download) (Python 2 interpreter for 1.0 is also available)**Date:**2015-04-09 – 2015-06-14**Version:**1.1 (1.0 also available)

Example (Infinite loop):

```
||comment Infinite loop!|for i = 0 to nfnt||print "Unbroken! "...||||
```

**Paradigm:**imperative**Computational class:**mu**IO model:**mu**Interpreter language:**JavaScript (run in browser)**Date:**2016-04-01 (idea from 2015-09-18)**Version:**1.0

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
.*
```

**Paradigm:**pure functional**Computational class:**Turing complete**IO model:**interactive, Unicode (but with limited ability to interpret input unless you include all possible Unicode characters in the program)**Interpreter language:**JavaScript (run in browser)**Date:**2020-05-14 – 2020-05-18**Version:**1.0

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'
```

**Paradigm:**pure functional, statically typed**Computational class:**Turing complete**IO model:**non-interactive, Unicode**Interpreter language:**JavaScript (run in browser)**Date:**2020-05-29 – 2020-09-13 (based on RE-type 1 from 2012-04-13 – 2012-08-17)**Version:**2.0 (1.0 was never finished or published)

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

**Paradigm:**imperative, one type**Computational class:**Turing complete**IO model:**interactive, Unicode output, buttons for input**Interpreter language:**JavaScript (run in browser)**Date:**2020-05-19 – 2020-09-25**Version:**1.0

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

**Paradigm:**imperative, one type**Computational class:**Turing complete**IO model:**interactive, Unicode, allows overstriking**Interpreter language:**JavaScript (run in browser)**Date:**2021-04-18 – 2021-06-11**Version:**1.0

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

**Paradigm:**imperative, unstructured**Computational class:**Turing complete**IO model:**interactive, Unicode, can clear output, has audio output**Interpreter language:**JavaScript (web-based)**Date:**2021-01-10 – 2021-06-27**Version:**1.0

`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;
}
```

**Paradigm:**imperative, structured, statically typed**Computational class:**Turing complete**IO model:**interactive, Unicode**Interpreter language:**JavaScript (web-based)**Date:**2022-09-25 – 2022-10-02**Version:**1.0