Brainbitch

BB (pronounced "Bee-Bee", short for Brainbitch) is a 2-dimensional esoteric programming language by User:10 based on a grid of colored cells, each containing a binary value. The language explores the relationship between color, position, and binary data through a unique set of constraints and execution rules.

Philosophy

BB challenges the traditional notion of code as linear text. Instead, programs are visual canvases where colors and bits interact according to strict physical rules. The name "Brainbitch" reflects the language's demanding nature — it forces programmers to think in two dimensions while juggling color constraints and binary logic.

The grid

A BB program consists of:

• A 2D rectangular grid of cells
• Each cell has a background color and a bit value (0 or 1)
• The grid can be any size, but must be at least 2x2
• Start marker + (gray) placed on the first cell
• End marker - (gray) placed outside the grid

Colors

BB uses exactly 5 colors:

Color	Representation
Red	R
Green	G
Blue	B
White	W
Black	K

The rules

Bit-color constraints

Bit Value	Display Color	Allowed Backgrounds
1	Black text	Red, White, Green
0	White text	Blue, White

These constraints are enforced at all times. A cell cannot exist in an invalid state — attempts to create one will be rejected by the interpreter.

Start and end

The + symbol (gray) marks the starting cell of the program

The - symbol (gray) marks the termination point outside the grid

Execution begins at + and continues until reaching -

Execution model

BB follows a path-based execution model:

The pointer

• A program pointer moves through the grid
• The pointer starts at the cell marked with +
• The pointer moves one cell at a time in a direction based on the current cell's properties

Movement rules

The pointer's direction is determined by the current cell's color and bit value:

Current Cell	Bit = 0	Bit = 1
Red	Move Right	Move Left
Green	Move Up	Move Down
Blue	Move Right	Move Up
White	Move Left	Move Down
Black	Halt (error)	Halt (error)

Operations

When the pointer lands on a cell, it performs an operation based on the cell's color:

Color	Operation
Red	Increment the bit (0→1, 1→0)
Green	Output the bit value as ASCII (0 or 1)
Blue	Read input, set bit to input value (0 or 1)
White	No operation (NOP)
Black	Halt execution

Execution flow

1. Start at cell marked with +
2. Read the current cell's color and bit
3. Perform the operation for that color
4. Determine the next direction based on color+bit
5. Move to adjacent cell in that direction
6. Repeat steps 2-5

Stop when:

• The pointer moves to a cell containing - (termination)
• A Black cell is encountered (error halt)
• The pointer moves outside the grid bounds (error halt)

Edge cases

• If the pointer attempts to move outside the grid, the program halts with an error
• If the pointer lands on an invalid state (bit-color mismatch), the program halts with an error
• The + and - markers are not part of the grid and cannot be modified

Example program

"Hello World" equivalent

This program outputs "H" (ASCII 72 = binary 01001000):

text
Grid: 3x3
+ R1 G0 B0
  W1 R0 G1
  B1 W0 -

Note: The actual "Hello World" would require a larger grid — this is a minimal demonstration.

Computational class

BB is designed to be Turing complete through the combination of:

• Unbounded grid size (theoretically infinite)
• Conditional movement based on state
• Read/write capabilities
• Looping (movement can revisit cells)

However, this has not been formally proven.

Implementation Notes

Interpreter Requirements

• Must enforce bit-color constraints strictly
• Must support grid sizes up to at least 100x100
• Must display grid state during execution (for debugging)
• Must handle + and - markers properly

File format

Programs should be saved as .bb files with the following format:

text
[width] [height]
[grid data as color+bit pairs]

Example:

text
3 3
R1 G0 B0
W1 R0 G1
B1 W0 -

Why "Brainbitch"?

The name reflects several aspects:

• Brain — A nod to brainfuck, acknowledging the lineage
• Bitch — Because the color constraints make programming difficult and unforgiving
• BB — The abbreviation is clean, minimal, and slightly aggressive

Known issues

• The movement rules can create infinite loops — programmers must design carefully
• Large programs are difficult to visualize and debug
• The color-bit constraints limit creative expression
• No standard library or common utilities exist yet

Future extensions

Potential additions for future versions:

• Additional colors with new operations
• Support for non-rectangular grids
• Ability to modify colors during execution
• Graphical IDE for visual programming
• Compilation to Brainfuck or other esolangs

Conclusion

BB is a visual, color-based, constraint-heavy esolang that challenges conventional programming paradigms. It forces programmers to think in terms of spatial relationships and color logic, creating programs that are as much art as they are code.

See also

• brainfuck