Why the question has no one-word answer
People often say Befunge is Turing complete, and sometimes say it is not. Both can be defended, because the answer depends on which version of the language you mean and which assumptions you make about memory. The original Befunge-93 has some features that look unbounded and some that clearly are not, and it is worth separating them.
What Befunge has
The language gives a program a two-dimensional playfield of characters and an instruction pointer that moves across it. It also gives a stack of integers. The pointer can change direction, branch on a value, read a cell with the get instruction and write a cell with the put instruction. Together these supply the three things a universal system typically needs: unbounded-looking storage somewhere, a way to repeat steps, and a way to make decisions based on data. The full instruction set is small, and it is the interplay between the program stack and the grid that matters most here.
The fixed playfield
In Befunge-93 the playfield has a fixed size. The commonly cited dimensions are 80 columns by 25 rows, which is 2000 cells. The pointer wraps around when it reaches an edge, so the grid behaves like a toroidal playfield and there is no way to extend it. If the grid were the only storage, Befunge would hold a fixed amount of information, and a language with a fixed number of possible configurations is a finite automaton in principle, since fixed memory means finitely many configurations.
Even if each cell could hold an arbitrarily large integer, the number of cells is still bounded. Whether that matters depends on whether you allow unbounded values, which leads to the next question.
The stack
The stack is the other candidate for unlimited storage. The Befunge-93 description presents the stack as having no stated depth limit. A stack that can grow as far as needed is genuinely unbounded storage, and combined with the grid it can be used for more than counting. Some of the reasoning people give runs as follows: a stack of unbounded depth, plus the ability to use the playfield as scratch storage, supplies enough memory to hold the contents of a simulated machine, provided the simulated machine’s data can be arranged so that the needed access order matches the stack discipline.
A single stack alone is not enough for a full tape, so a complete argument has to show how the grid cells help to get around stack-order access. Fixed-size cell values also matter. If each cell and stack entry is limited to a modest numeric range, as it was in the common 32-bit implementations, an argument would need to rely on stack depth rather than on large numbers. I am not aware of a simple universally cited proof that settles the strict Befunge-93 case, and sources do disagree on how strictly to read the specification, so it is safest to treat this as a matter of assumptions rather than a closed fact.
The idealized answer
Many writers sidestep the difficulty by considering an idealized Befunge in which the stack never overflows and cell values are unbounded integers. Under that reading, the typical argument is that Befunge can simulate a machine such as a counter machine or a Brainfuck-style tape, and therefore is Turing complete. The method follows the general recipe for a completeness proof: choose a known universal system, represent its memory, represent its control, and check each step. Writing a Brainfuck interpreter in Befunge is the example commonly mentioned for this purpose, since Brainfuck’s tape and loops map onto cells and pointer routes.
Because of this, if you read a statement like “Befunge is Turing complete,” a reasonable interpretation is: “with unbounded stack depth and unbounded values, it can simulate a universal system.”
Funge-98 changes the picture
Funge-98 removes the fixed grid size. Its playfield is conceptually unbounded, so the grid itself can serve as unlimited storage, much like a tape in two dimensions. That makes the case for universality much more direct, since there is no longer a fixed ceiling on the number of cells. Real implementations still store only finitely many cells and use bounded integers, so the strong claim again refers to the idealized language. Those Befunge-93 limits are exactly what the later standard was designed to relax.
Two other considerations
- Self-modification. Because programs can write to the grid they run on, the line between code and data is blurred. This does not by itself make the language universal, but it makes simulation arguments more flexible, and it complicates attempts to analyze programs statically.
- Determinism and input. A language can be universal even with no input at all, since a program can compute on data it generates. Randomness, such as the random direction instruction, is not needed for universality.
How to talk about it responsibly
A cautious summary has three parts. First, the original fixed grid on its own is bounded. Second, the stack may supply unbounded storage if the specification and interpreter allow it, and under idealized assumptions Befunge is generally regarded as universal. Third, the wider Funge-98 playfield makes the argument easier. If a claim does not say which assumptions it uses, it is incomplete.