Created in 1972, the Mother of All (intentionally) Weird Programming Languages.
A language designed to be as different as possible from all others.
It is quite a success, except that it operates on binary numbers
(fixed in TriINTERCAL) and it is one-dimensional.
(Is that the same Don Woods who wrote Adventure?)
Designed to be the smallest compiler ever. has eight very simple
instructions. a nightmare to do math in. the only data structure
is a big array with a pointer that points to one element.
(Originally it was an array of longwords but now it's an array of bytes.)
Said to be "the language that is as obscene as its name".
(My Programs page has a featureful debugger
for this language (for MS-DOS only) and a compiler (written in
this language) and a program called BFINIT which I used to
generate data initialization code for the compiler, among
other things. Also,
this guy wrote a
Brainf*** interpreter in Brainf***!)
(The reason for the asterisks is because I wouldn't want anyone
viewing this page through a certain webcensoring program
to be led to believe that "Brain" is the name of this language.)
Designed to be a small compiler, but still possible to use.
All single-character instructions. Uses a stack, like FORTH.
(It isn't quite Turing complete (unless you use the compiler and
do some very non-portable things). Well maybe you can do it portably,
sort of, but it still wouldn't work in the interpreter though.)
TRUE
A weird mutation of FALSE, but without variables, and with
some string manipulation.
I got an interpreter for this by email from the author,
but I totally forgot about it until I read about on Ben Olmstead's
Random Languages page, at which point I remembered it.
I've never actually tried running the interpreter, which came
without source code. For all I know it could be a virus.
But, we programmers of the weird languages are too small a group
to be likely target. But still...
The ancestor of Orthogonal. A two-dimensional language.
"A two-dimensional stack-based language, created during an afternoon when
I ran a fever of 101 degrees. (Or somewhat less, in celcius)"
('Orthagonal' is a misspelling, and oddly enough,
it has a bug in the character output routine.)
Designed to be two-dimensional. Based on the earlier Orthagonal,
but rather backwards combatable.
Has most of the same instructions, but the storage of the grid
is done dynamically, and the program execution may not wraparound
or go through blank areas. If you want to have a cell
that does nothing, you must use the NOP instruction.
Designed to be a nightmare to compile. Impossible to compile
unless the compiler has Artificial Intelligence. All
instructions are single characters, and are loaded into a
two-dimensional array without modification. Uses a stack.
Self-modifying. Has a successor, Befunge 97, in which nearly
every printable ASCII character is a valid instruction.
Despite the fact that the grid contains bytes, the stack
contains 32-bit signed integers. (Now there's Funge-98,
in which your program can be 1, 2, or 3-dimensional,
and there's even Time Travel. It has things called
fingerprints and handprints, which allow people to create
their own extended versions of the Funge-98 interpreter,
and the program can determine whether the interpreter
running supports the extension it needs (or something
like that). There are extensions for things like
drawing windows in a GUI, and making Internet
connections(!?!?!?!) This language is starting to scare me.)
(Update: there is now a
Befunge compiler written by Ben Olmstead.
The code produced is rather large, but, as advertised,
this is a true Befunge compiler. (I can hardly believe it!)
Also, Tim Howe has a
pseudo-compiler that generates C files which must
then crank through a C compiler to get an executable.
Also, I wrote a Befunge
interpreter (for MS-DOS) in assembly language.)
A tribute to Rube Golberg. No useful programs have been written
in this language. The "instructions" act like objects which
move around on a grid, kind of like a video game. Except that
currently, RUBE programs are not interactive, because the input
instruction has not been implemented. Probably the author
couldn't decide how to handle multiple input instructions in
the same program. (If you ask me, the best way would be to just
scan through as usual, executing each input instuction that has
a control crate in the proper location and space for the data
crates to go. (and of course, room for the input crates)
This would mean that after inputting a character,
you would have to push away the control crate.)
TWDL[I] by Chris Pressey
Turingware Design Language [Interpreter]. In this language numbers
are any number of bits you want, not just 8 or 16 or 32.
Your data store is a double-ended queue.
(actually it says "Copyunder (u)1999 Cat's-Eye Technologies.")
SMETANA - both an acronym for "Self-Modifying, Extremely Tiny AutomatoN
Application", and a reference to the composer of the same name.
The question of whether SMETANA is Turing-Complete or not remains to
this day unanswered. If it is, it must use the given program source
as it's input, and the final state of the program as it's output.
(It probably isn't Turing complete, but with the addition of another
instruction, Copy Step M over Step N, it might be. Subtract Step M
from Step N would also help.)
Kinda like Befunge except that the instruction pointer move in
8 directions instead of 4, and the movement of the instruction
pointer determines the program's behavior. The instruction pointer
travels on non-whitespace characters, changing direction when
necessary, and the program terminates when a dead end is reached.
The instruction executed depends not on the value of the character,
but on the angle of the turn.
The angles in the instruction list are counterclockwise relative to the
current direction. The Hello World program that comes with this language
reminds me of the Fourier Passage in Adventure - "it twists and turns
like an earthworm tripping on LSD".
Designed not to recognizable as a programming language. It looks
like Morse code. It is hard to write programs in, and impractical
to compile, because the operation done depends partly on an
eight-state variable. No complete, working programs have been
written in this language. (Wasn't Turing complete originally,
because the only random-accessible data store was limited to
256 bytes. I fixed this problem in reMorse2.- by adding
"fake push" and "fake pop" operations
which make the stack random-accessible.)
Combines the best (or worst?) features of Orthogonal and INTERCAL.
Parsed like Orthogonal, except the default cell width is 6, to
accomodate the constant #65535. A FORTH-like stack is used,
with INTERCAL operators. A label takes up an entire cell.
Therefore, the two kinds of abstination are totally separate.
And of course sparks and rabbits ears are completely useless here,
so they are not included. When a label that is being abstained
from is reached, the next instruction is skipped.
Not yet implemented. I'll get around to it in about #256$#256 days
or so.
A (somewhat) FORTH-like language with NO CONDITIONAL JUMPS!
You are able to simulate them, however, because the JUMP instruction
gets an address from the top of the stack. It is very much like
assembly language in the way that data is created.
When creating this language I realized that except for the lack
of conditional jumps, it is very close to what I consider the
ideal language. So I decided that there should be a dialect
called Frog which would be the same except it would have
conditional jumps. (Combines the portability of C (or will,
once the compiler has been ported) with the power of assembly
language (and the readability of FORTH). Will also have the
efficiency of an assembler, once I add the optimizer feature.)
Update: The Bullfrog language is officially dead, but it has died
only to be reincarnated as a new (similar but totally incompatible)
language. The new language as yet has no compiler and no name.
And unlike Bullfrog, I'm designing it for practical use.
And it will have code optimization, floating point numbers,
memory management, OOP, and graphics and sound modules. Eventually.
The Language from Hell. It operates in trinary, instructions are
automatically modified after being executed, and you have to
encrypt your source files using a key included in the documentation.
(Don't worry, it's only a substitution cypher. But still, this
means that you can't write Malbolge programs without first
writing another program to aid you.)
I am certain that is not Turing complete, because to make a loop,
you need to write some code that undoes the automatic
self-modification, and to do that, you need to use a loop.
(There's also the matter of the weird operator; It looks
unlikely that you could perform calculations with it.)
The day that someone writes, in Malbolge, a program that simply
copies its input to it's output, is the day my hair spontaneously
turns green. It's the day that elephants are purple and camels
fly, and a cow can fit through a needle's eye.
I was quite amazed when someone succeeded in writing a
Hello World program in Malbolge. He didn't just go and write it directly,
he wrote this hairy program to generate it. Click on the link to read his own
explanation of it.
Another stack-based language. You have various commands for doing
calculations on the stack, input and output, flow control,
and self-modification. The instruction set is based mainly
on Befunge, but there's no stringmode here.
The weird thing about this language is that all data consists
of positive integers individually enclosed in brackets,
and all code consists of punctuation characters individually
enclosed in braces. Everything else is considered a comment.
This language was based on Befunge, FALSE, and Brainf***.
Also resembles Orthogonal in that, when self-modifying,
it can create new cells with data in them but not code.
The first known high-level programming ever invented, but it was never
implemented. In this language your (only) basic unit of data is the bit.
Everything else is an array of bits.
One Instruction Set Computer. A play on RISC (Reduced Instruction
Set Computer). The only instruction is Subtract and Branch if Negative.
Its operands are three addresses, X, Y, and Z. This instruction
subtracts the number at address Y from the number at address X,
stores the result at address X, and if the result is negative,
branches to address Z.
(Ross Cunniff
Hewlett-Packard Graphics Software Lab
cunniff(at)fc.hp.com
DISCLAIMER: HP would be bankrupt if I worked in the CPU design division...)
Ultimate RISC. Like OISC, only the instruction is Reverse Subtract
and Skip if Borrow, and it has only one operand!
* The great instruction is: subtract the value in the accumulator from the
* value in the address specified by the operand, and skip the next
* instruction (more precisely, operand) if there was a borrow.
The result is stored in both the accumulator and location specified
by the operand. The accumulator is located in memory at location 1, so
by using 1 as the operand, you can clear the accumulator.
The instruction pointer is at location 0, so by using 0 as an operand
you can jump to another location.
Written by Asher Hoskins. (ukrhosk(at)prl.philips.co.uk)
(According to the documentation, he wrote only the compiler, not the spec.
The specification was posted anonymously to alt.folklore.computers
(probably as a joke). The name, no doubt, came from the name Plankalkul.)
This is an extremely weird language.
This is an interpreter for the programming language SORTA, a systems
and numerical programming language with features sorta from C, sorta
from FORTH, and sorta from Ada. (This was an entry in the
International Obfuscated C Contest, and it won Best of Show.
Instead of saying it has features "sorta from FORTH",
I think it would be more accurate to say "sorta from FALSE",
because this language is all single-character instructions.)
It has two stacks, one for integers and one for strings.
Q-BAL by Michael Shulman
This language is based on queues instead of stacks.
He took the Q-BAL page down due to lack of interest
but his home page is at
http://listen.to/om
"Like lambda-calculus without the lambda operation."
I can't figure this one out - probably mainly because
I don't know lambda-calculus. Check it out...
A somewhat FORTH-like language. Actually it's not very weird,
but I listed it here just because I saw it on some page in the
Esoteric Programming webring.
Sort of like FALSE except that it lets you break out of a loop (and FALSE doesn't),
but it also lacks stack manipulation commands.
It was originally called MUSYS and was used to control a music synthesizer.
The reason for it's small size was because it was written in 1970 to run on a PDP-8
with very little memory. So this isn't really an esoteric language, just extremely
specialized.
