From Esolang
Jump to: navigation, search

Brainfuck⁂ is a derivative of Brainfuck Sharp, itself a derivative of Brainfuck, by User:Hppavilion1, who is deeply apologetic for making a Brainfuck derivative, no less more than one.

Brainfuck⁂ uses a lot of Unicode.


The author's goal in making Brainfuck⁂ was to make a potentially useful Esolang (useful only for tiny scripts made by those with weird tastes, but useful nonetheless) that used way too much unicode.

The hope with Brainfuck⁂ is that it will support many, many features, from normal code to high-level things like GUIs.

It is an abomination and its creator should be charged with Crimes against Humanity.

Implementation Specs

Standard brainfuck is very vague about its implementation. Brainfuck⁂, on the other hand, is not.

Brainfuck⁂ uses a right-infinite tape (of unbounded-height stacks) that expands as more space is needed. Cells on the tape are not necessarily numbers, but when they are they are double-precision floating point numbers (because Brainfuck⁂ supports non-integer cell values). A cell is, in reality, a stack with a PEEK command, but it is treated as a normal Brainfuck cell for most commands (that is, + for example pops a value and pushes its successor).

Numeric cell values can be negative, except in the case of the special cell at -1.


This section is still being filled out

Brainfuck# commands are unicode characters (including ascii) to allow for greater character range. Most commands are procedural, but there are a few context-sensitive commands. For convenience, commands are described as if they are operating on a normal tape instead of a tape of stacks except in cases where they influence a stack. In reality, these commands pop a value, operate on it, and push the result.

Basic Commands
ID Command Description
N/A > Move the pointer to the right
N/A < Move the pointer to the left
0 + Increment the memory cell under the pointer
1 - Decrement the memory cell under the pointer
2 . Output the character signified by the cell at the pointer
N/A , Input a character and store it in the cell at the pointer
2 [ Jump past the matching ] if the cell under the pointer is 0
2 ] Jump back to the matching [ if the cell under the pointer is nonzero
N/A '<string>' Push null-terminated string onto the current stack
N/A " Print the backslash-escaped string going from here to the matching non-escaped "
N/A # Ignore everything from here to the next newline
Control Flow Commands
ID Command Description
N/A { Start a code block
N/A } End a code block
2 ? If-statement
2 @ While-statement
2 = define function
2 * Jump to the cell whose value is stored in the current cell
Function Commands
ID Command Description
2 ! Call function
2 self-apply function
2 Apply to entire tape
Concurrency Commands
ID Command Description
N/A ; Separate shared-memory threads
N/A | Separate separate-memory threads
N/A Fork
N/A Kill (command subject to change)
Stack and Accumulator Manipulation Commands
ID Command Description
N/A $ Drop a value from the current stack
N/A Pop a value from the stack and put it in the accumulator
Compounding Keywords
ID Command Description
N/A ( Start a compounding keyword block
N/A ) End a compounding keyword block
N/A ~ Separate keywords from commands
N/A % Make following instruction wrap
N/A & Make following operation group atomic


IDs are part of the OO feature of Brainfuck⁂. They determine how an object in a cell acts when commands are called on it. More on this will come later.

ID Interpret as
0 Increment
1 Decrement
2 Convert to number