The world's silliest programming language.

Github Link

16b64 is a work-in-progress esoteric joke programming language designed to question the fundamentality of constants in programming.

There are ten 16-bit constants in 16b64 that must be manipulated to generate the other numbers. They are numbered 0-9 and are based on the first 20 bytes of the SHA-256 hash of "16b64".

Operations are done to a stack with 16 bit words in reverse polish notation. The language has 64 instructions, each written with single characters. The operations include the characters A-Z, a-z and loops are done with (), giving 64 possible instructions.

The name comes from two parts: "16b" from the 16-bit stack and variables, and "64" from the 64 possible instructions that can be used.

The Birth Of The Idea

The idea for 16b64 came while I was looking over other esolangs, specifically Brainf**k (which I will shorten to "bf"). Something about bf intrigued me, the pure simplicity of the rules leading to intensely complex and creative solutions to work around the language, however, something seemed just too "easy" about it, and helpfully convenient. The idea of the + and - operators, being able to simply increment by one just didn't sit right with me as being inconvenient enough like the rest of the language. If you want the number 200, you can just type 200 "+"! Nonsense.

That gave the inspiration to make a language with the goal of being terribly inconvenient. Perhaps not the most inconvenient to exist, but certainly difficult to use.

Here is a quick example for the general concepts of 16b64.

5Puts 0x4fda (the value of the constant 5) on the stack.
2Puts 0xfc26 (the value of the constant 2) on the stack.
NBitwise NOT previous item on stack.
aAdd together previous two items on stack (ignore overflow).
XBitwise XOR previous two items on stack.
5NPuts 0xb025 (bitwise NOT of 0x4fda) on the stack.
22a Puts 0xf84c (0xfc26 + 0xfc26) on the stack.
5N22aXPuts 0x4869 (0xb025 XOR 0xf84c) on the stack.
CPrint previous two bytes on stack to stdout in two 8-bit characters.
5N22aXCPrints "Hi" ("H" = 0x48, "i" = 0x69)

Online Interpreter

The online interpreter is a version of the Rust 16b64 interpreter compiled for WebAssembly. This online version is definitely a work in progress still; it uses a modified version of the interpreter which I intend to merge with the original. If it doesn't respond to your input then it has probably encountered an error of some sort.

Debug Messages


Hello, World!

Prints "Hello, World!"

Hello, World! x10

Prints "Hello, World!" 10 times, using loops.

Doomsday Method Calculator

Calculates the anchor day for a given year for use in the doomsday method of determining the day of the week.

Day of Week Calculator

Calculates the day of the week given a date in MM-DD-YYYY format. Built off previous doomsday method calculator. WORK IN PROGRESS.


InstructionValue (hex)

Unmarked instructions are currently unused.

The "Mode" category describes how the instructions interact with the stack. A table of modes is provided below this table. The "Stack" column describes how the total size of the stack will change after each operation.

AArithmeticx AND y
CWritepush x to STDOUT as two ASCII char
DDuplicateduplicate x
E-halt; exit program
FComplex Movefind value x positions down in the stack and move it to the top. (0 = top, 1 = second from top, etc)
HReadpush next stdin to two values
IReadpush next two STDIN to one stack value
JReadpush next one STDIN byte to stack
LModifyx cyclic shift left by y places
MArithmeticy modulo x
NModifyNOT x
OArithmeticx OR y
PComplex Movemove y to x positions down in the stack.
QConstantpush random number to stack
RModifyx cyclic shift right by y places
SMoveswaps x, y on stack
UWritepush U+x to STDOUT as Unicode
VWritepush U+yx to STDOUT as Unicode
XArithmeticx XOR y
aArithmeticx + y, set flag true if overflow
b-flag = LSB of x
c-x < y, set flag to result
dDeletedelete x
e-x == y, set flag to result
fComplex Movefind value x%16 positions down in the stack and move it to the top (4 bit version of F)
g-x > y, set flag to result
i-invert flag
lModifyx cyclic shift left by 1
pComplex Movemove y to x%16 positions down in the stack. (4 bit version of P)
q-randomly set flag to true or false
rModifyx cyclic shift right by 1
yMovePull bottom of stack to top of stack
zMovePush x to bottom of stack
(-start of loop, enter only if flag == TRUE
)-loop if flag == TRUE
ArithmeticRemoves two values from the stack and adds one back.
ReadRemoves one or two values from the stack.
WriteAdds one or two values to the stack.
MoveMoves values around without changing amount of elements.
ModifyRemoves one value from stack, performs some operation on it, and places it back.
Complex MoveRemoves the top variable on the stack and moves the rest of the variables around.
DuplicateRemoves one value from stack and adds two.
DeleteRemoves one value from stack.
ConstantAdds one value to stack.