# A very minimal esolang with a very few amount of instructions

A very minimal esolang with a very few amount of instructions is a very minimal esolang with a very few amount of instructions.

A very minimal esolang with a very few amount of instructions has:

• An array of memory cells, each initially set to zero
• An integer stack of 42-bit integers
• Five 19-bit registers (A, C, D, E, G)
• A dice roll stack
• A code stack
• An uppercase boolean stack (TRUE/FALSE)
• A lowercase boolean stack (true/false)
• A string stack
• A 420-bit accumulator
• A call stack
• A stack of molecules (linked lists of atoms)
• A ternary stack of 8-trit integers
• A 2D memory
• A greek letter stack because they sound cool
• A stack of unknown values
• An upside-down uppercase boolean stack (⊥ɹ∩Ǝ/Ⅎ∀˥SƎ)
• A stack of roman numerals
• An array of finished tic-tac-toe games
• A 4x4 board of the 2048 game
• A list of 10 to-do items
• A stack of class instances
• Timelines
• Time flows
• An 8x8 minesweeper board

## A list of all instructions

List of all instructions
Instruction Description
! Drop the element on top of the integer stack
" Reads everything until the next `"` and pushes it into the string stack
# Skips everything until the next newline
\$ Multiplies current register by the current conversion rate of USD to EUR
% Sets the current register to the remainder of dividing the current memory cell by the number on top of the integer stack (doesn't pop the number).
& Perform a bitwise AND operation on the element on top of the integer stack and at the current memory cell
' Reads everything until the next `'`, and pushes it onto the code stack
( Pops the number from the integer stack. Jumps past to matching `)` if the number is zero.
) Jumps back to matching `(`
* Multiplies the current register by the current memory cell
+ Increment the memory cell at the pointer
, Input a character and store it in the cell at the pointer
- Decrement the memory cell at the pointer
. Output the character signified by the cell at the pointer
/ Rotates the element on top of the integer stack, the value of the current memory cell and the value of the current register (S=M, M=R, R=S)
0 Pushes 0 onto the integer stack
1 Adds 1 to the number on top of the integer stack
2 Pushes 2 onto the integer stack
3 Adds 4 to the number on top of the integer stack
4 Outputs an answer to the Ultimate Question of Life, the Universe, and Everything if followed by 2. Otherwise, freezes the execution of the program for 7.5 million years
5 Adds 5 to the current register
6 Adds 6 to the accumulator
7 Rolls a dice and pushes the rolled number onto the dice roll stack
8 Outputs a random Magic 8 Ball answer
9 Outputs 99 bottles of beer
: Swaps the element on top of the integer stack with the element below the top of the integer stack
; Must be followed by a newline. Does nothing.
< Move the pointer to the current memory cell to the right
= Pops the boolean on top of the uppercase boolean stack and the boolean on top of the lowercase boolean stack. Sets the current register to 524287 if both booleans are true (case-insensitive), otherwise sets it to 0.
> Move the pointer to the current memory cell to the left
? Skips the next instruction if the register is zero
@ Pops the code from the code stack and executes it
A Change the current register to register A
B Outputs the entire bee movie script
C Change the current register to register C
D Change the current register to register D
E Change the current register to register E
` Pushes FALSE onto the uppercase boolean stack
G Change the current register to register G
H Output "Hello, World!"
I Interprets input as program source
J Jumps to the next "J"
K Outputs the "K? K what?" copypasta
L Output numbers from 68 to 35789.
M Pops the integer from the integer stack, converts it to ternary and pushes it to the ternary stack
N Pops the integer from the ternary stack, converts it to binary and pushes it to the integer stack
O Outputs the value of the current memory cell as hexadecimal
P Adds 98696 to the current register if followed by I. Otherwise, subtracts 9 from the current register.
Q Outputs the program's source code
R Reads a string, applies ROT13 to it and outputs the result
S Pops the value on top of the integer stack and the boolean on top of the uppercase boolean stack. Pushes TRUE to the uppercase boolean stack if the value on top of the integer stack is not zero, otherwise FALSE. Pushes 1 to the integer stack if the boolean on top of the uppercase boolean stack was TRUE, otherwise 0.
T Pushes TRUE onto the uppercase boolean stack
U Pops two integers on top of the ternary stack, performs a trinary AND operation and pushes the result back
V Performs a trinary NOT operation on the integer on top of the ternary stack
W Skips the next instruction if the current timestamp in milliseconds is divisible by 73
X Checks if
Y Pops two integers on top of the ternary stack, performs a trinary OR operation and pushes the result back
Z Outputs FizzBuzz to 90
[ Jump past the matching `]` if the cell at the pointer is 0
\ Skips the next instruction
] Jump back to the matching `[` if the cell at the pointer is nonzero
^ Swaps the value on top of the integer stack with the value on the bottom of the integer stack
_ Negates the accumulator
` Reads the next character in the code and adds its charcode to the accumulator
a Adds the accumulator to itself
b Read and execute a brainfuck program
c Copies the standard input to the standard output until it reads a newline or EOF.
d Pops the number on top of the dice roll stack
e Pushes the address of the current instruction onto the integer stack
f Pushes false onto the lowercase boolean stack
g Resets all memory cells to 0
h Outputs "hi"
i Outputs "ih"
j Jumps to the instruction with an address stored in the current register
k Outputs the lowercased version of the "K? K what?" copypasta
l Does nothing infinitely.
m Pops two codes on top of the code stack, concatenates them and pushes it onto the code stack
n Drops the code on top of the code stack
o Outputs the value of the current register as integer
p Adds 31415 to the number on top of the integer stack if followed by i. Otherwise, subtracts 3 from the number on top of the integer stack.
q Subtracts 51413 from the number on the bottom of the integer stack if previous instruction was i. Otherwise, adds 5 to the number on the bottom of the integer stack
r Resets the current register to 0
s Pops the value on top of the integer stack and the boolean on top of the lowercase boolean stack. Pushes TRUE to the lowercase boolean stack if the value on top of the integer stack is not zero, otherwise FALSE. Pushes 1 to the integer stack if the boolean on top of the lowercase boolean stack was TRUE, otherwise 0.
t Pushes true onto the lowercase boolean stack
u Swaps the code on top of the code stack with the code below the top of the integer stack
v Move one timeline down
w Read and execute an HQ9+ program
x Replaces all instructions `x` with the instruction `y`
y Replaces all instructions `y` with the instruction `x`
z Outputs FizzBuzz to 122
{ Reads the next character in the code and everything until the matching `}`. Creates a function.
| Reads the next character in the code, looks up a function named with that character and executes it if the function exists. Executes a random instruction if the function does not exist.
} Does nothing.
~ Perform a bitwise NOT operation on the current register
¡ Freeze the execution of the program for one planck time
¢ Multiplies the current register by 100 (usd -> cents)
£ Multiplies the current register by the current conversion rate of USD to GBP
¤ Create a new atom of one proton and zero neutrons (protium)
¥ Multiplies the current register by the current conversion rate of USD to JPY
¦ Splits the current time flow into two. The next instruction is skipped in the second time flow.
§ Reads the next character and defines a section with that character. If that section is already defined, jumps to that section.
¨ Throws the `InvalidInstructionTheAuthorCouldNotComeUpWithWhatShouldThisInstructionDoError` exception
© Performs malbolge's "crazy" operation on the integer on top of the ternary stack and the integer below the top of the ternary stack
ª Raises the accumulator to the power of 97 (charcode of a)
« Moves the time cursor one to the past (left)
¬ Move back to the stored time position
- Store the current time position
® Skips the next 2 instructions
¯ Move one timeline up
° Add a proton to the atom
± Splits the current time flow into two, where the current register is positive in the first time flow and negative in the second.
² Multiplies the current register by itself
³ Multiplies the current register by itself twice
´ Push the amount of protons in the atom onto the integer stack
µ Multiplies the accumulator by 1000000 (1e+6)
Reads the next character and defines a paragraph with that character in the current section. If that paragraph is already defined, jumps to that paragraph.
· Add a neutron to the atom
¸ Push the amount of neutrons in the atom onto the integer stack
¹ Move to the next point of time where the timeline was split.
º Move to the origin of the current timeline.
» Moves the time cursor one to the future (right)
¼ Divides the accumulator by 4
½ Pops the element on top of the integer stack, divides it by 2 and sets the current register to the result of the division
¾ Multiplies the current memory cell by 3/4
¿ Skips the next instruction if the current register is not zero
À Stores the reference to the current register at the current time
Á Replaces the reference to the current register to the stored reference to the current register
Â Replaces the reference to the current register to the current register at the current time
Ã Stores the reference to the current register at the current time in the current timeline
Ä Resets the stored reference to the current register
Å Travels to the time where the reference to the current register is stored
Æ Travels to the timeline where the reference to the current register is stored
Ç Initializes an empty molecule and pushes it onto the molecule stack
È Destroys all time flows except the origin time flow
É Converts all time flows except the origin time flow into separate timelines
Ê Converts all timelines into separate time flows
Ë Destroys the current time flow. If no time flows are left, the program ends.
Ì Sets the current register to the current point of time
Í Sets the current register to the current timeline
Î Sets the current register to the current time flow
Ï Rotates the values of the current registers in all time flows
Ð Destroys the molecule on top of the molecule stack
Ñ Deletes all atoms from the molecule on top of the molecule stack
Ò Adds an atom to the beginning of the molecule on top of the molecule stack
Ó Adds an atom to the end of the molecule on top of the molecule stack
Ô Deletes the atom at the end of the molecule
Õ Deletes the atom in the beginning of the molecule
Ö Activates the molecule
× Destroys the current timeline and moves to the origin of the current timeline. If no timelines are left or the current timeline has no origin, the program ends.
Ø Discard the newly created atom
Ù Creates a new atom copying the properties of the first atom in the molecule on top of the molecule stack. Also copies the link properties. Modifying the atom will remove the links.
Ú Creates a new atom copying the properties of the last atom in the molecule on top of the molecule stack. Also copies the link properties. Modifying the atom will remove the links.
Û Replaces the atom with the next linked one
Ü Replaces the atom with the previously linked one
Ý Sets the current register to the amount of atoms the molecule on top of the molecule stack has
Þ Duplicates the molecule on top of the molecule stack. If the molecule is activated, it is de-activated.
ß Swaps the molecule on top of the molecule stack with the molecule below the top of the molecule stack
à Do a single iteration of the simulation of the molecule on top of the molecule stack. (the molecule must be activated)
á Set the current register to the total amount of neutrons in the molecule on top of the molecule stack
â Push the total amount of protons in the molecule on top of the molecule stack onto the integer stack
ã Set the current register to the number of bits in the current memory cell
ä Skips the next instruction if the day of the week is the same as christmas last year
å Pushes the amount of instructions in the program onto the integer stack
æ Flips a random bit in the program's RAM.
ç Pushes the amount of unique instructions in the program onto the integer stack
è Jumps to the next character with a charcode divisible by 32
é Sets the current register to the amount of HTTP requests the program made
ê Pushes the charcode of the instruction at the address stored in the current register onto the ternary stack
ë Changes the next instruction to the instruction at an address stored in the accumulator
ì Reverses the order of the execution.
í Reverses the code after the current instruction
î Reads the input until a newline and pushes it into the string stack
ï Swaps the string on top of the string stack with a string below the top of the string stack
ð Checks if the accumulator is odd, and pushes the result onto the lowercase boolean stack.
ñ Checks if the accumulator is even, and pushes the result onto the lowercase boolean stack.
ò Pops the string from the top of the string stack and outputs it
ó Sets the current register to 727 if this esolang is turing-complete
ô Pops two strings from the string stack, and replaces the popped string from below the top of the stack with the popped string from the top of the stack in the string on top of the stack.
õ Drops the string on top of the string stack
ö Pops two strings from the string stack and merges them, inserting a character from the second string after every character in the first string, and pushes the result onto the code stack.
÷ Divides the number on top of the integer stack by the accumulator
ø Pushes the rounded percentage of time passed until the Heat Death of the Universe onto the integer stack
ù Slows down the execution of the rest of the code by a few seconds if today is the National Lazy Day (10th of August)
ú Pops the string from the string stack and adds it to the string below the top of the string stack
û Adds zero to the accumulator
ü Pops two strings from the string stack and merges both strings
ý Pops the code on top of the code stack and pushes it onto the string stack
þ Pops the string from the top of the string stack and evaluates it
ÿ Stops the execution of the program
Ŧ Reads a character from stdin. Outputs 1 infinitely if the character was 1, otherwise outputs 0 once
ʎ Throws the `YourDumbPieceOfShitThisLambdaIsFacingTheWrongFuckingWayError` exception
˂ Moves the cursor in the 2D memory 1 cell right
˃ Moves the cursor in the 2D memory 1 cell left
˄ Moves the cursor in the 2D memory 1 cell top
˅ Moves the cursor in the 2D memory 1 cell bottom
` Takes an input and outputs the zalgo version of it
α Pushes alpha onto the greek letter stack
β Pushes beta onto the greek letter stack
γ Pushes gamma onto the greek letter stack
δ Pushes delta onto the greek letter stack
ε Pushes epsilon onto the greek letter stack
ζ Pushes zeta onto the greek letter stack
η Pushes eta onto the greek letter stack
θ Pushes theta onto the greek letter stack
ι Pushes iota onto the greek letter stack
κ Pushes kappa onto the greek letter stack
λ Pushes lambda onto the greek letter stack
μ Pushes mu onto the greek letter stack
ν Pushes nu onto the greek letter stack
ξ Pushes xi onto the greek letter stack
ο Pushes omicron onto the greek letter stack
π Pushes pi onto the greek letter stack
ρ Pushes rho onto the greek letter stack
σ Pushes sigma onto the greek letter stack
τ Pushes tau onto the greek letter stack
υ Pushes upsilon onto the greek letter stack
φ Pushes phi onto the greek letter stack
χ Pushes chi onto the greek letter stack
ψ Pushes psi onto the greek letter stack
ω Pushes omega onto the greek letter stack
Pushes Ⅎ∀˥SƎ onto the upside-down uppercase boolean stack
Pushes ⊥ɹ∩Ǝ onto the upside-down uppercase boolean stack
Pops the boolean from the upside-down uppercase boolean stack and the regular boolean stack and sets the current 2D memory cell to 7 if both booleans are equal
Drops two integers on top of the integer stack
Skips the next two instructions if the register is 0
Skips the next instruction and drops the integer on top of the integer stack if the register is 0
Drops the integer on top of the integer stack, then if the register is 0 skips the next instruction
Reads the next character and deletes a paragraph with that character in the current section
Subtracts 2 from the current memory cell
Subtracts 6 from the current 2D memory cell
Subtracts the current memory cell from the current 2D memory cell
Pops the integer on top of the integer stack and subtracts it from the integer on top of the ternary stack
Raises the current 2D memory cell to the power of 8
Raises the current memory cell to the power of -1
Raises the accumulator to the power of 0
Raises the power of N by itself
Increments the power of N
Decrements the power of N
Resets the power of N to 0
Raises the current register to the power of N
Pushes Ⅰ onto the roman numeral stack
Appends `Ⅰ` tp the roman numeral on top of the roman numeral stack
Appends `Ⅴ` to the roman numeral on top of the roman numeral stack
Appends `Ⅹ` to the roman numeral on top of the roman numeral stack
Appends `Ⅼ` to the roman numeral on top of the roman numeral stack
Appends `Ⅽ` to the roman numeral on top of the roman numeral stack
Appends `Ⅾ` to the roman numeral on top of the roman numeral stack
Appends `Ⅿ` to the roman numeral on top of the roman numeral stack
Converts the accumulator from kelvin to celcius
Converts the accumulator from kelvin to fahrenheit
Swaps the 2D memory cell to the right with the 2D memory cell to the left
Swaps the 2D memory cell to the bottom with the 2D memory cell to the top
Moves the cursor in the 2D memory one cell top-left
Moves the cursor in the 2D memory one cell top-right
Moves the cursor in the 2D memory one cell bottom-right
Moves the cursor in the 2D memory one cell bottom-left
Opens source code of the program in VS Code
Pushes the digital root of the accumulator onto the integer stack
Calculate the value of infinity. (warning: this may take some time)
Pops the integer from the integer stack, calculates the square root of it and sets the current 2D memory cell to the result
Starts a new tic-tac-toe game. The cursor is initialized in the middle. The board will be pushed to the array of finished tic-tac-toe games once the game ends
Move one cell to the left in the tic-tac-toe game
Move one cell to the top in the tic-tac-toe game
Move one cell to the right in the tic-tac-toe game
Move one cell to the bottom in the tic-tac-toe game
Place an X in the tic-tac-toe game. The computer will make the next move.
Create a new class
Add a new field to the latest created class
Add a new method to the latest created class
Mark the latest created class field or class method as static
Mark the latest created class field or class method as private
Mark the latest created class field or class method as protected
Mark the latest created class field or class method as readonly
Create an instance of the class and push it onto the stack of the class instances.
Select the 1st To-Do item
Select the 2nd To-Do item
Select the 3rd To-Do item
Select the 4th To-Do item
Select the 5th To-Do item
Select the 6th To-Do item
Select the 7th To-Do item
Select the 8th To-Do item
Select the 9th To-Do item
Select the 10th To-Do item
Mark the selected To-Do item as done
Mark the selected To-Do item as cancelled
Mark the selected To-Do item as unknown
Mark the selected To-Do item as in-progress
Reads everything until the next ❞. Sets the text of this To-Do item
Output the current selected To-Do item
Checks if the current register is equal to the accumulator
Checks if the current register is equal to the accumulator but stricter
Splits the current time flow into two, where the current register is negative in the first time flow and positive in the second.
Moves the 2048 board left (if the game is still active)
Moves the 2048 board up (if the game is still active)
Moves the 2048 board right (if the game is still active)
Moves the 2048 board down (if the game is still active)
Moves the cursor in the 2048 board one cell to the left
Moves the cursor in the 2048 board to the top
Moves the cursor in the 2048 board to the right
Moves the cursor in the 2048 board one cell to the bottom
Sets the current register to the value of the current cell in the 2048 board
Pushes whether the 2048 game is won onto the lowercase boolean stack
Pushes whether the 2048 game is lost onto the lowercase boolean stack
Undoes the last move in the 2048 game (if the game is lost)
Resets the 2048 game
Launches a custom Minecraft version
Outputs the entirety of You are swine you vulgar little maggot
Throws the `ThisMotherfuckingDashIsTooFuckingLongError` exception
Outputs the Tiananmen Square Copypasta
Read and execute a malbolge program
Pushes unknown to the stack of unknown values
Outputs "Fuck you and your existence"
Starts a 8x8 minesweeper game, where the pointed cell is in the top left corner.
Move the minesweeper pointer to the right
Move the minesweeper pointer to the left
Move the minesweeper pointer up
Move the minesweeper pointer down
🖱 Open the currently selected square. If it's a mine, end the program.
Flag the current cell.
Runs Windows 12 (Note: needs at least 64GB of RAM and a CPU with "Super Duper Ultra Secure Some Thing K Whatever We Just Need Your Money™®©" chip support)
Runs a custom version of Arch Linux.
🔒 Runs one instance of the geometry dash cod3breaker code. (Generates 6 random numbers, which will be called A, B, C, ..., F. Then does B-A, C-B, ..., F-E and combines all the results together.)

There will be more instructions added in the future. Feel free to contribute and add your own instructions to this list!

## Concepts

### Multiverse Time Travel and Time Flows

You can move in time and in different timelines. Changing the past creates a new timeline, copying all past changes before the change and affecting all future changes after the change. Changing the future does not create a new timeline, but then the future becomes the new present, and changing the old present will create a new timeline. There are also "time flows" or "universes" that execute code in parallel. They can have different control flow and different states of the program, and different timelines.

### Molecules and Atoms

You can create a new atom using `¤` and add protons to it using `°` or add neutrons to it using `·`. You cannot remove protons or neutrons from the atom. The atom is stored in a temporary place. Creating a new atom overrides the previously stored atom. In order to use the atom, it needs to be added to a molecule. You can initialize an empty molecule using `Ç`, and then add the atom to the molecule using `Ò` or `Ó`. You will have to create another atom after adding it to the molecule. You can activate the molecule using the `Ö` operation, after which all the atoms in the molecule will be simulated. You cannot modify the molecule after activating it and you cannot de-activate it. You can, however, duplicate the molecule in the molecule stack using `Þ`. If the molecule is active, the duplicated molecule will be inactive. You can use `à` to do a single iteration of the reaction simulation after activating the molecule. If an atom is unstable, it will be destroyed once the molecule that has the atom is activated. If a molecule results in an unstable or dangerous reaction, all atoms in that molecule will be destroyed.

### OOP

You can create a new class using `□`. You can add a field to it using `▤`, or add a method using `▥`. To make an instance of the class, use the `■` instruction, which will push the created instance onto the stack of class instances. You can only make a single instance of the class, but this should not affect how most object-oriented programmers work.

### Note

Running an empty program will trigger a spontaneous cosmic coffee spill in the programmer's dimension, ultimately resulting in the heat death of the universe.

```H
```

```c
```

```Ŧ
```

```Q
```

```9
```

```z
```

```w
```

```b
```

```﷽
```