Brainfuck was designed in 1993 by Swiss physics student Urban Müller. His primary objective was to craft a programming language capable of being executed by the absolute smallest compiler possible.
Müller drew heavy inspiration from FALSE, an esoteric language created by Wouter van Oortmerssen that possessed a compiler size of 1024 bytes. Müller succeeded in surpassing this goal by writing an Amiga OS compiler for Brainfuck that measured under 200 bytes in size.
Despite relying on only 8 single-character commands, Brainfuck is Turing-complete. This means that, given sufficient memory and execution time, it possesses the same computational power as modern languages like Python, C, or JavaScript.
Detailed User Manual & System Architecture
1. Memory Architecture
The runtime environment consists of an array of 30,000 memory cells, often referred to as the tape. Each cell holds an 8-bit unsigned integer (a numerical range from 0 to 255). When a cell value exceeds 255, it wraps around to 0. Decrementing past 0 wraps back around to 255.
2. The Data Pointer
A mobile internal pointer tracks the currently active cell. All arithmetic operations (+ and -) and output/input instructions (. and ,) apply strictly to whichever cell the data pointer currently targets.
3. Loop Mechanics
Loops are declared using bracket pairs ([ and ]):
When encountering [, the engine inspects the current cell. If the cell contains 0, execution skips forward past the corresponding ]. If non-zero, execution continues into the loop.
When encountering ], the engine inspects the current cell. If the cell is non-zero, execution jumps back to the corresponding opening [. If zero, execution drops out of the loop.
4. Character Encoding (ASCII)
The output command (.) does not print raw integers. Instead, it translates the cell's numeric value into its matching symbol according to the ASCII table (e.g., Value 65 = 'A', Value 66 = 'B', Value 48 = '0', Value 10 = Newline).
5. Code Rules & Comments
Any character in the source code that is not one of the 8 core commands (> < + - . , [ ]) is treated as a non-executing comment. Caution: Do not use any of the 8 command characters inside commentary text, as they will still execute.
Command Reference Table
Symbol
Name
Action Description
>
Shift Right
Increments the data pointer to reference the next cell on the right.
<
Shift Left
Decrements the data pointer to reference the previous cell on the left.
+
Increment
Adds 1 to the numeric value stored in the current cell.
-
Decrement
Subtracts 1 from the numeric value stored in the current cell.
.
Output
Converts current cell value to an ASCII character and prints it.
,
Input
Prompts user for input and saves the character's ASCII value to current cell.
[
Loop Start
Jumps past matching ] if current cell value is zero.
]
Loop End
Jumps back to matching [ if current cell value is non-zero.
Examples
Example 1: Generating and Printing 'WencesByte.net'
Descriptive Walkthrough: We run a dual-multiplier loop to set Cell #1 to 100 and Cell #2 to 50 as base ASCII anchors. We then adjust cell values using relative differences to print the full string.
++++++++++ — Cell #0 is incremented to 10 to act as our loop counter. Tape State: [10, 0, 0]
[>++++++++++>+++++<<-] — Multiplies the counter by 10 for Cell #1 and by 5 for Cell #2 over 10 iterations. Tape State: [0, 100, 50]
>------------- . — Move to Cell #1, subtract 13 to reach ASCII 87, and output W. Tape State: [0, 87, 50]
++++++++++++++ . — Add 14 to Cell #1 to reach ASCII 101, and output e. Tape State: [0, 101, 50]
+++++++++ . — Add 9 to Cell #1 to reach ASCII 110, and output n. Tape State: [0, 110, 50]
----------- . — Subtract 11 from Cell #1 to reach ASCII 99, and output c. Tape State: [0, 99, 50]
++ . — Add 2 to Cell #1 to reach ASCII 101, and output e. Tape State: [0, 101, 50]
++++++++++++++ . — Add 14 to Cell #1 to reach ASCII 115, and output s. Tape State: [0, 115, 50]
>++++++++++++++++ . — Move to Cell #2, add 16 to reach ASCII 66, and output B. Tape State: [0, 115, 66]
<++++++ . — Move back to Cell #1, add 6 to reach ASCII 121, and output y. Tape State: [0, 121, 66]
----- . — Subtract 5 from Cell #1 to reach ASCII 116, and output t. Tape State: [0, 116, 66]
--------------- . — Subtract 15 from Cell #1 to reach ASCII 101, and output e. Tape State: [0, 101, 66]
>-------------------- . — Move to Cell #2, subtract 20 to reach ASCII 46, and output .. Tape State: [0, 101, 46]
<+++++++++ . — Move back to Cell #1, add 9 to reach ASCII 110, and output n. Tape State: [0, 110, 46]
--------- . — Subtract 9 from Cell #1 to reach ASCII 101, and output e. Tape State: [0, 101, 46]
+++++++++++++++ . — Add 15 to Cell #1 to reach ASCII 116, and output t. Tape State: [0, 116, 46]
Example 2: Zeroing Out a Memory Cell
Code:[-]
Descriptive Walkthrough: This standard idiom resets whatever value exists in the current cell back to 0, regardless of what value it started with.
Assume Cell #0 currently holds the value 5.
[ — Checks Cell #0. Value is 5 (non-zero), so enter loop.
- — Decrement Cell #0 value by 1 (value becomes 4).
] — Checks Cell #0. Value is 4 (non-zero), jump back to [.
(Loop repeats until value drops to 0) — Once Cell #0 hits 0, the loop terminates and execution proceeds.
Example 3: Value Transfer (Addition)
Code:+++>++[<+>-]
Descriptive Walkthrough: Transfers the numerical value stored in Cell #1 into Cell #0, combining their contents.
+++ — Set Cell #0 to 3.
>++ — Move to Cell #1 and set value to 2. Tape State: [3, 2, 0]
[ — Check Cell #1. Value is 2 (non-zero), enter loop.
<+ — Move to Cell #0 and add 1 (Cell #0 becomes 4).
>- — Move back to Cell #1 and subtract 1 (Cell #1 becomes 1).
] — Repeat loop. Cell #0 gets incremented to 5, Cell #1 drops to 0.
Loop terminates because Cell #1 is now 0. Cell #0 holds the sum (3 + 2 = 5). Tape State: [5, 0, 0]
Support me on Ko-fi
