Brainfuck Interpreter

Run Brainfuck programs live in your browser with interactive 30,000-cell tape visualizer.

Preset Programs

Steps Executed: 906Pointer Index: 6Code Size: 106 charsOutput Length: 13 chars

Brainfuck Source Code

Program Input Stream (optional)

Output Stream

Memory Tape Inspector (First 16 Cells)Pointer @ Cell #6

[0]0\x00

[1]0\x00

[2]72'H'

[3]100'd'

[4]87'W'

[5]33'!'

[6]10\x0a

[7]0\x00

[8]0\x00

[9]0\x00

[10]0\x00

[11]0\x00

[12]0\x00

[13]0\x00

[14]0\x00

[15]0\x00

Language Command Matrix

>move pointer right

<move pointer left

+increment cell value

-decrement cell value

.output cell as char

,read char into cell

[jump past ] if cell is 0

]jump back to [ if cell non-0

Brainfuck Interpreter Online

Brainfuck is a minimalist esoteric programming language created in 1993 by Wouter van Oortmerssen. It operates on an array of 30,000 memory cells using only 8 commands. This client-side interpreter executes code directly in your browser with real-time memory inspection.

Built and maintained by Meet Shah · Last updated 19 July 2026

What this tool is used for

Running a program from a puzzle or a code-golf challenge.
Learning how a minimal instruction set can still be Turing complete.
Stepping through a program to understand tape and pointer mechanics.
Checking your own interpreter against a reference implementation.
Solving a CTF challenge whose payload is written in it.

Frequently Asked Questions

What are the eight instructions?: `>` and `<` move the pointer, `+` and `-` change the cell, `.` and `,` do output and input, and `[` `]` form a loop that runs while the current cell is non-zero. That is the entire language, and it is Turing complete.
How is it Turing complete with so little?: Because it has unbounded memory, arithmetic, and conditional repetition — which is all a Turing machine needs. Expressiveness and instruction count are independent, which is precisely the point the language was designed to make.
What are the implementation-defined parts?: Cell size (usually 8 bits), whether cells wrap on overflow, tape length, and what `,` returns at end of input — 0, −1, or leaving the cell unchanged. Programs relying on any of these behave differently across interpreters, which is most of the portability problem.
Why is the Hello World program so long?: Because every character must be built by repeated increments. The idiomatic version uses nested loops to multiply — setting a counter and adding in batches — which is dramatically shorter than 72 plus signs and is the language's one real optimisation technique.
Is there any practical use?: As a teaching tool and a compiler target. Its tiny instruction set makes it a favourite for demonstrating interpreters, optimisation passes and Turing completeness proofs — it exists to make a point about computation rather than to write programs in.

Common errors and gotchas

Assuming a fixed cell size, where implementations differ on 8-bit wrapping versus unbounded values.
Relying on behaviour at the tape edges, which is undefined and varies by implementation.
Expecting a program to terminate, which is why a step limit exists at all.
Confusing input handling at end-of-input, where implementations return zero, minus one or block.
Reading unbalanced brackets as a runtime problem rather than a parse error.