Befunge

Befunge is a two-dimensional esoteric programming language invented in 1993 by Chris Pressey with the goal of being as difficult to compile as possible. Code is laid out on a two-dimensional grid of instructions, and execution can proceed in any direction of that grid.
==Language overview==
A Befunge program is laid out on a two-dimensional playfield of fixed size. The playfield is a rectangular grid of ASCII characters, each generally representing an instruction. The playfield is initially loaded with the program. 
Execution proceeds by the means of a program counter (-93) or instruction pointer (-98). This points to a grid cell on the playfield. The instruction pointer has inertia: it can travel to any of the four cardinal directions, and keep traveling that way until an instruction changes the direction. The instruction pointer begins at a set location (the upper-left corner of the playfield) and is initially travelling in a set direction (right). As it encounters instructions, they are executed. Befunge-93 has no jumps farther than two cells, so control flow is done by altering the direction of the program counter, sending it to different literal code paths. (Befunge-98 has far jumps, but because of inertia in the community, these are rarely used.) The following, for example, is an infinite loop:
 >v
 ^<
Befunge programs mostly store data on a stack in the manner of Forth, but they can also read and write the contents of any cell in the playfield, given its coordinates, thus Befunge code can be self-modifying.
==History==
Befunge is believed to be the first two-dimensional, ASCII-based, general-purpose (in the sense of "you could plausibly write Hunt the Wumpus in it" ) programming language. Its form was influenced in part by the multimedia scripting application AmigaVision, and in part by Forth.
The original Befunge (known as "Befunge-93" to distinguish it from others) has spawned many descendants and remote cousins. The closest commonly recognized relative, and most direct extension, of Befunge-93 is Befunge-98 of the Funge-98 family of languages. However, Funge-98 actually derives from Funge-97, which derives from Befunge-96, which is in turn derived from Befunge-93. This page contains the original specs for these variants as well as a functioning link to a combined Befunge-93/Befunge-96/Funge-97 interpreter called MTFI. Each Funge extends the central concepts of Befunge to a given number of dimensions (for example, Unefunge is one-dimensional, Trefunge is three-dimensional, Nefunge is n-dimensional, etc.).
Today, Befunge powers fungot, an IRC bot that enjoys some popularity in the esoteric programming community. Its source code is so small that it fits on a T-shirt.
===Etymology===
The word "Befunge" started life as a typographical error for the word "before", typed by Curtis Coleman at 4AM on a BBS chat system.
It was then reverse-endowed with a fictional morphology where it took on the meaning Be- (a corruption of the prefix bi-, for "two") + funge (fictional root of the word fungible, i.e. "interchangeable"). That is, to interchange (program codes with data) in two (dimensions).
The name is pronounced /biː'fʌndʒ/.
==Instructions==
Befunge-93 has the following commands:
Cmd 	Description
Addition: Pop two values a and b, then push the result of a+b 	
Subtraction: Pop two values a and b, then push the result of b-a	
* 	Multiplication: Pop two values a and b, then push the result of a*b
/ 	Integer division: Pop two values a and b, then push the result of b/a, rounded down. According to the specifications, if a is zero, ask the user what result they want.
% 	Modulo: Pop two values a and b, then push the remainder of the integer division of b/a.
! 	Logical NOT: Pop a value. If the value is zero, push 1; otherwise, push zero.
` 	Greater than: Pop two values a and b, then push 1 if b>a, otherwise zero.
> 	PC direction right
< 	PC direction left
^ 	PC direction up
v 	PC direction down
? 	Random PC direction
_ 	Horizontal IF: pop a value; set direction to right if value=0, set to left otherwise
 	Vertical IF: pop a value; set direction to down if value=0, set to up otherwise
" 	Toggle stringmode (push each character's ASCII value all the way up to the next ")
: 	Duplicate top stack value
\ 	Swap top stack values
$ 	Pop top of stack and discard
. 	Pop top of stack and output as integer
, 	Pop top of stack and output as ASCII character
# 	Bridge: jump over next command in the current direction of the current PC
g 	A "get" call (a way to retrieve data in storage). Pop two values y and x, then push the ASCII value of the character at that position in the program. If (x,y) is out of bounds, push 0
p 	A "put" call (a way to store a value for later use). Pop three values y, x and v, then change the character at the position (x,y) in the program to the character with ASCII value v
& 	Get integer from user and push it
~ 	Get character from user and push it
@ 	End program
0 – 9 	Push corresponding number onto the stack
See the separate Funge-98 article for the instructions of that dialect.
==Computational class==
Because Befunge-93 programs are given an explicit limit of 80x25 cells on the size of their playfield, but are also given a working stack, any Befunge-93 program should be simulatable by a push-down automaton.
However, the converse is not true; there surely exist some push-down automata which cannot be simulated by any Befunge-93 program (because they contain more states than can be encoded in the 80x25 playfield).
Befunge-98 removes the fixed-size restriction on the playfield, and thus should be Turing-complete.
==Compilation==
As stated, the design goal for Befunge was to create a language which was difficult to compile. This was realized by two main features:
* self-modifying – the p instruction can write new instructions into the playfield; and
* multi-dimensional – the same instruction can be executed in four different contexts (in a left-to-right series of instructions, or right-to-left, or upward or downward.)
Nevertheless, these obstacles have been overcome to some degree, and Befunge compilers have been written, using appropriate techniques.
The bf2c compiler included with the standard Befunge-93 distribution uses threaded code: each instruction is compiled to a snippet of C code, and control flows through the snippets just as it does in a Befunge interpreter (that is, conditionally on the value of some 'direction' register.) This does not result in a significant advantage over a good interpreter. Note that the bf2c compiler is not correct since it does not handle p correctly, but it would not be impossible to make it do so (although the C language might not be well-suited for this.)
The Betty compiler, for example, treats every possible straight line of instructions as a subprogram, and if a p instruction alters that subprogram, that subprogram is recompiled. This is an interesting variation on just-in-time compilation, and it results in a much better advantage over an interpreter, since many instructions can be executed in native code without making intervening decisions on the 'direction' register.
The Befunjit and Bejit compilers, similarly to the Betty compiler, split the original code into subprograms which are lazily compiled and executed. They, however, divide the original playfield into "static paths" - code paths which do not contain instructions that conditionally change direction (i.e. |, _ or ?). The "static paths" may span on more cells than the "straight line paths" of Betty, which results in fewer and longer subprograms. Thus, there are fewer context jumps between the compiler and the compiled code and allows more optimisations.
There are also programs which combine a Befunge interpreter and a copy of a given Befunge program into a single executable which runs the Befunge program when started. For Befunge-93 this can easily be done by having a preallocated 80×25 cell storage space in the interpreter, and filling it in with the chosen Befunge program. This might be considered a sort of pathological version of threaded code, and while it produces a similar effect to a compiler, that is, it generates a "native executable", it is not really considered the same thing. Sometimes such a tool is called a pseudo-compiler or linker. TBC (Tim's Befunge Compiler), and BFC (BeFunge Compiler) written by Uranium-239, are examples of such tools.
==Examples==
===Befunge-93 and Befunge-98===
====Hello, World!====
 > v
 v"Hello World!"<
 >:v
 ^,_@
Here is another one by User:None1:
 "!dlroW olleH",,,,,,,,,,,,@
And an even shorter one, also by User:None1:
 "!dlroW olleH">:#,_@
Without usage of letters or loops
 89*,52*5*2*1+,92*6*,92*6*,52*1+52**1+,48*,52*8*7+,52*1+52**1+,52*1+52**4+,v
 v <
 >52*52**8+,52*52**,48*1+,@
====Cat program====
 ~:1+!#@_,
====Truth Machine====
 &#::_.@#
====Factorial====
 &>:1-:v v *_$.@ 
 ^ _$>\:^
====Number Guessing Game (from 1 to 3)====
 >>v
 v1?2v
 3
 > > >: v
 |-&<
 $
 >"!tcerroC">:v
 |,<
 @
====DNA-code====
Output a string of 56 As,Cs,Gs, and Ts.
 7^DN>vA
 v_#v? v
 7^<""""
 3 ACGT
 90!""""
 4*:>>>v
 +8^-1,<
 > ,+,@)
====Compact DNA-code====
Output a string of 68 As, Cs, Gs, and Ts.
 vDN>"A"v
 >#v?"C"v
 v>"G"v
 @ >>"T"v
 |!p01-<,
 10g:1^>
====Sieve of Eratosthenes====
 2>:3g" "-!v\ g30 <
 |!`"O":+1_:.:03p>03g+:"O"`|
 @ ^ p3\" ":<
 2 234567890123456789012345678901234567890123456789012345678901234567890123456789
====Quine====
 01->1# +# :# 0# g# ,# :# 5# 8# *# 4# +# -# _@
Another one using string mode to put the program on the stack:
 0 v
 "<@_ #! #: #,<*2-1*92,*84,*25,+*92*4*55.0 
The shortest method that doesn't use g:
 <@,+2*48_,#! #:<,_$#-:#*8#4<8"
Although it can be slightly shorter using the ' command from Befunge-97/Funge-98:
 <@,+2 '_,#! #:<,_$#-:# ' $<"
One that includes a bit of text of a pre-decided length: 
 :0g,:"~"`#@_1+0"Quines are Fun">_
Arbitrary text can be inserted in between the second set of quotes, though the text is limited to 58 characters.
A pseudo-quine which uses some Befunge-97 commands:
 060p070 p'O80v
 pb2*90p4$4> $4$>v>
 v4$>4$>4$>4$># ARGH>!
 <{[BEFUNGE_97]}> FUNGE!
 ##:-:## #####* 4$*>4$ >060p> 60g80g -!#v_ 60g1+ 60p60v
 #vOOGAH **>4$>^!!eg nufeB^ $4$4$4 $4<v#<<v-*2a:: v7-1g<
 #>70g>90g-! #@_^Befunge!! 123456 123456 VvVv!#!>Weird! >0ggv*
 ^$4$4p07+1g07 ,a<$4< <$4$4< <$4$4< <$4$4< <<#<*-=-=-=-=-* -=-=v*
 ::48*-#v_>,4$> 4$4$4 $4$4$ 4$4$4$ 4$4$4$ 4$^*!* XXXXXX XXX> 
 BOINK>$60g1-7 0g+d2* %'A+,1 $1$1$1 $1$1$1 $>^<$ HAR!!! 8888 
 Befunge_is such_a pretty langua ge,_is n't_i t?_It_ 8888 
 looks_so much_l ike_li ne_noi se_and it's_ STILL_ ‘88’ 
 Turing- Complet e!_Cam ouflag e_your code!! Confu se_the 
 hell_out of_every one_re ading_ your_co de._Oh, AND_y ou.:-) ,o88o.
 Once_this_thing_i s_code d,_rea ding_it_back_ver ges_on the_imp 888888
 ossible._Obfusc ate_the_obfus cated!_Befunge_ debuggers_are__ 888888
 your_friends! By:_Alexios Chouchou las... X-X-X-X-X-X-X! 888888
 -=*##*=- \*****/ 9797* -=97=- !@-*= ***** ‘"88P’
 *!@-* 
 =*!@- 
 -=*!@ 
 @-=*! 
And it prints out:
 GHIJKLM UVWXYZ 
 FGHIJKLMNOP VWXYZA 
 EFGHIJKLMNOPQR WXYZAB 
 EFGHIJKLMNOPQRST XYZABC 
 FGHIJKL PQRSTU EFGHIJ QRSTUV ABCDEF HIJKL OPQRS YZABCD 
 GHIJKLM CDEFGHIJKLM RSTUVW BCDEFG IJKLMNOPQRSTUV ZABCDE 
 HIJKLMNOPQR CDEFGHIJKLMNO STUVWX CDEFGH JKLMNOPQRSTUVW ABCDEF 
 JKLMNOPQRSTUV CDEFGH LMNOPQ TUVWXY DEFGHI KLMNOPQRSTUVWXY BCDEFG 
 LMNOPQRSTUVWXY DEFGH NOPQR UVWXYZ EFGHIJ LMNOPQ UVWXYZ DEFG 
 OPQRSTUVWXYZA DEFGHI OPQRST VWXYZA FGHIJK MNOPQ WXYZAB EFGH 
 STUVWXYZAB EFGHIJ PQRSTU WXYZAB GHIJKL NOPQR XYZABC FGHI 
 WXYZABCD FGHIJK QRSTUV XYZABC HIJKLM OPQRS YZABCD GHIJ 
 MNOPQRS YZABCDE GHIJKL RSTUVW YZABCD IJKLMN PQRST ZABCDE 
 NOPQRSTU YZABCDEF HIJKLM STUVWX ZABCDEF IJKLMNO QRSTU ABCDEF HIJKLM 
 PQRSTUVWXYZABCDEF JKLMNO STUVWX ABCDEFGHIJKLMNOP RSTUVW ABCDEFG IJKLMN 
 RSTUVWXYZABCDEF LMNOPQRSTUVWX CDEFGHIJKLMNOPQ STUVWXYZABCDEFG JKLMNO 
 TUVWXYZABCDEF NOPQRSTUVWX DEFGHIJK MNOPQR TUVWXYZABCDEFG KLMNOP 
 XYZABCDE QRSTUVW GHIJK NOPQRS UVWXY BCDEF LMNOPQ 
 VWXYZ 
 WXYZA 
 XYZAB 
 YZABC
====Simple game ("Less or More")====
 vv < < 
 2 
 ^ v< 
 v1<?>3v4 
 ^ ^ 
 > >?> ?>5^ 
 v v 
 v9<?>7v6 
 v v< 
 8 
 > > ^ 
 vv < < 
 2 
 ^ v< 
 v1<?>3v4 
 ^ ^ 
 > >?> ?>5^ 
 v v v ,*25 << 
 v9<?>7v6 ,, 
 v v< "" 
 8 >< 
 > > ^ ""v 
 >*: >0"!rebmun tupnI">:#,_$25*,:&:99p`|^< _0"!niw uoY">:#,_$25*,@ 
 ^ < >:99g01-*+^
Another one (inspired by the one above):
 v>>> > v>>> > v
 012 3 012 3
 ^?^ ^?^
 >>?#v?4>>?#v?4v
 v?v v?v
 98765 98765
 >>>>> ^>>>>> v
 v 0 + * + : 5 <
 >"!sseuG">:#,_v
 0v_v#:-&:,+:5$<
 , v>0"!niw uoY"
 +0>:#,_$5:+,@
 :>`0\"!"\v
 v"small"_"gib"
 ^>" ooT">:#,_$5
====Calculator====
Type 1 to add, 2 to subtract, 3 to multiply, 4 to divide.
 "rotaluclaC egnufeB">:v
 |,<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
 >52*:,,"/4 *3 -2 +1">:v ^^^^
 |,< ^^^^
 >52*:,,v^^^^
 v<<<<<<<^^^^
 & ^^^^
 : ^^^^
 1 ^^^^
 - ^^^^
 v_$&&+.$>^^^^
 : ^^^
 2 ^^^
 - ^^^
 v_$&&-.$>>>^^^
 : ^^
 3 ^^
 - ^^
 v_$&&*.$>>>>>^^
 : ^
 4 ^
 - ^
 @_$&&/.$>>>>>>>^
 
 
====99 Bottles of Beer====
Unfortunately, it doesn't work on some Befunge-93 interpreters (since the code is too large to fit in the 80x25 playfield), but it will still work on most interpreters.
v >v >v >v >v
>992+*>:.:1`|>0" ,llaw eht no reeb fo selttob">:#,_$>:.:1`|>0".reeb fo selttob">:#,_$>91+,0" ,dnuora ti ssap dna nwod eno ekaT">:#,_$1-:|>:.:1`|>0".llaw eht no reeb fo selttob">:#,_$>91+:,,v
 >0" ,llaw eht no reeb fo elttob">:#,_$ ^ >0".reeb fo elttob">:#,_$ ^ v >0".llaw eht no reeb fo elttob">:#,_$ ^
 >0".llaw eht no reeb fo selttob erom on">:#,_$v
 ^ <
 > v > v 
 @<|,:<"Go to the store and buy some more, 99 bottles of beer on the wall.",+91<|,:<"No more bottles of beer on the wall, no more bottles of beer."0,,:+91<
 ^< ^<
Here's one that DOES work on all interpreters (80x25 playfield): (by User:Tomrs123_2
55+55+*1->:." ,llaw eht no reeb fo selttob"v
 v,,,,,,,,,,,,,,,,,,,,,,,,,,,,, <
 >:.".reeb fo selttob"v
 v,,,,,,,,,,,,,,,, <
 >55+," ,dnuora ti ssap dna nwod eno ekaT"v
 v,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, <
 >1-:.".llaw eht no reeb fo selttob"v
 v,,,,,,,,,,,,,,,,,,,,,,,,,,,, <
 >55+:,,:2-v
 ^ _v
v +55<
>".reeb fo selttob 2 ,llaw eht no reeb fo selttob 2"v
v ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, <
>:,".llaw eht no reeb fo elttob 1 ,dnuora ti ssap dna nwod eno ekaT"v
v ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, <
>::,,".reeb fo elttob 1 ,llaw eht no reeb fo elttob 1"v
v,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, <
>:,".llaw eht no reeb fo selttob erom on ,dnuora ti ssap dna nwod eno ekaT"v
v,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, <
>55+:,".reeb fo selttob erom on ,llaw eht no reeb fo selttob erom oN"v
v,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, <
>,".llaw eht no reeb fo selttob 99 ,erom emos yub dna erots eht ot oG"v
@,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, <
====Random Number Generator====
Input a positive integer n and output an integer chosen uniformly at random from [0,n)
 & :v>00g2/.@
 v00_^#!`/2g00:<
 >0p:1>>:10p` !|
 >+00p^?<*2g01:<
 ^ g00:<
====A+B Problem====
 &&+.@
====Do Nothing====
v@
>^
Or simply:
 @
===Befunge-98===
:Main article: Funge-98
====Hello, world! (without string reversion)====
 <>>#;>:#,_@#:"Hello, World!"
====Shorter version of the previous one====
 <>:#,_# @#"Hello, World!"
====One character shorter====
 <>:#,_@#:"Hello, World!"
====Multi-line Hello World without string reversion====
 <v"Hello, World!"
 >:v
 ^,_@
====Yet another "Hello, world"====
 ;Hello, World!; >00ga6*1-->#@_1>:#<>#<0#<g#<:#<a#<6#<*#<1#<-#<-#<>#+>#1>#,_$$@
This basically prints the characters between the semicolons.
====1D Factorial====
 5 :>>#;1-:48*+01p*01g48*-#;1#+-#1:#<_$.@
(the 5 is the input number)
====Convert binary number to decimal====
 v ;11101010;
 >>>>>>>>>>>>>>>a0g68*-90g68*-2*+80g68*-4*+70g68*-8*+v
 @.+***288-*86g03+**88-*86g04+**84-*86g05+**44-*86g06<
Just insert an 8-bit number between the semicolons in the first line.
==== Looping counter (with newlines) ====
 1v,*25< 
 1 . 
 >+: ^
==Interpreters==
=== Befunge-93 Self-Interpreter ===
Reads a Befunge-93 program from stdin and runs it. Input program cannot be more than 20 lines high. Provide input to program in same file using ; character to separate program from input. If you give the interpreter as input to itself, be sure to decrement the 4 in the middle of *54p0 on the bottom line. Yes, you may provide it as input to itself running itself too, but decrement that number for each iteration.
 <xyXYvp01<>110vv5_v#`0+1:_v#+!-"g"\<v"<":::<>1v#p03-1_>! g20gp00g1+0v25p
 v2g02 < p0 20p<+vp020p01-10$_:"p"-!^>>-!\ v^ <>0p20pv|!*-";"\+1::~p0<
 v2-10<^v# ^#< <<$< < ^+!-"_"\+!-"?"<>#^_1v>vp<:^00 _$20g1+20p^
 v21p010>#<40g20v> %:40p5+g:92p:75*1--00g!\#^_00p$v>4v>91+-^
 <3+g01g 03p04+g<^\++g04g02:*54p03:%\++g03g01:"P"<<p0<
=== befunge93.js ===
befunge93.js is a Befunge-93 interpreter written in Javascript available as an npm package to use in your own applications or make your own IDE or interactive interpreter.
Fungide is an interactive interpreter powered by befunge93.js. 
Features:
* Decent UI
* Visual program execution
* Crawl or Step through your code
* Can run your program without UI updating for fast execution
=== BefunExec ===
BefunExec is a befunge-93 interpreter written in C#. (On Github) 
It only understands the befunge-93 instruction set but can work with program sizes greater than 80x25.
It has advanced features like
* breakpoints
* stepping the instruction pointer backwards
* showing a graph of the possible program flow paths
* context-aware syntax highlighting
* supporting programs with extended size (tested with an 2000x12039 program)
=== jsFunge IDE ===
jsFunge is a Befunge-93 interpreter written in Javascript.
It also optionally allows use of some Befunge-97 instructions and can work with arbitrarily-sized programs.
It has most of the features of BefunExec, plus:
* Multidirectional Grid Editing
* Cell Annotations
* Shareable links to annotated programs (a la TryItOnline)
* Continuously variable speed setting
* Non-blocking keyboard I/O
* I/O via xterm emulator
* Translation, rotation, and reflection of selected regions
* Somewhat usable on mobile devices
=== Befunge JavaScript interpreter ===
It is a Befunge-93 interpreter by User:None1.
It has the following features:
* Non-interactive I/O (since JavaScript doesn't have input)
* Division or modulo by 0 results in 0
* Unrestricted size of playfield
==Related languages==
Befunge was preceded in 1991 by a similar but less featureful language Biota, which was designed for experiments in self-reproduction. It was followed soon after, in 1994, by another similar language, Orthagonal, the design of which was spurred by a discussion on alt.folklore.computers. Each of these three languages originated (as far as anyone can tell) completely independently of the other two.
Befunge has also provided inspiration to the design of subsequent languages, the most similar of these are known as fungeoids. Most of the languages are not similar enough to be called direct descendants, but often the author mentions the influence of Befunge in the accompanying commentary. Fungeoid languages include
* Wierd, a two-dimensional Turing tarpit
* Befreak, a reversible language
* PATH, which adds elements of Brainfuck
* Flobnar, a "functional-programming" fungeoid
* ><>, a two-dimensional esolang inspired by Befunge
* Ndim, a multidimensional language in which the only working memory available is the code space itself
* Nopfunge is a minimalization of Befunge. It has only the direction changing commands but remains Turing complete.
==External resources==
===Befunge-93===
* 
* Befunge-93 Online Compilation.
* JavaScript Befunge-93 interpreter.
* befungee, a Befunge-93 interpreter written in python, with a debugger and a concurrent mode.
* Bephunge, an implementation of Befunge-93 in PHP (command-line) (mirror in the Esoteric File Archive).
* Befunge programs in the Esoteric File Archive.
* YaBI93 - multiplatform Befunge93 interpreter (with IDE) for Java 1.5.
* Marsh/Bejit/funge.py/bf.vim Fast interpreters/quasi JITs & a vim debug mode. now with a WASM JIT online
* Another interpreter in JavaScript - (On GitHub)
* Befunjit - A just-in-time compiler for Befunge-93
* awkfunge Befunge-93 interpreter written in AWK.
* FungePP Interpreter for Funge++, a Procedural Befunge-93 Extension, written in C++
* BefunCompile a restricted Befunge-93 to C (and C#, and Python) compiler
* Beefunge A Befunge-93 graphical IDE written in C++. Features a field as large as Funge-98. Currently under testing and development.
* NemFunge93 Command line Befunge-93 interpreter written in imperative Nemerle for .NET and Mono.
* FreedomSka/befunge - More befunge code examples
* Befunje - Befunge-93 interpreter with visualization
* befunge93.js is a Befunge-93 interpreter written in Javascript available as an npm package
* Fungide is a visual interactive interpreter powered by befunge93.js.
* jsFunge is a fully-featured browser-based Befunge-93 development environment.
* BefunPY is a Befunge-93 interpreter written in Python with extension support and a few built-in extensions
* Boxfunge is a Befunge-93 interpreter and just-in-time-compiler written in Rust.
* Befunge-93+ is another interpreter for Befunge-93 written in Rust. It also expands the playing field to a near-infinite size.
* Interpret Esolangs Online is a webpage by User:None1 that can run programs in many esolangs including Befunge-93. It supports unrestricted size of playfield.
* A Chinese-language explanation of Befunge-93 on Luogu NOTE: This page may contain mistakes. The division command actually rounds down. The "skip" command actually skips a cell.
===Befunge-98 and beyond===
* 
* Funge-98 specification
* vsync's Funge stuff.
* BefungeSharp A Funge-98 IDE written in C#. Features a command-line editor and a compliant interpreter.
* - a nice Befunge-98 IDE for Win32. Warning: its interperter is not fully standards compliant.
* - contains a Javascript interpreter and several interesting Befunge programs.
* BeQunge A cross-platform Funge-98 interpreter, code editor, and debugger. Works in any number of dimensions.
* J^4: Befunge Jeffrey Lee's Befunge site, features plenty of interesting programs.
* Mycology and CCBI A complete Befunge-98 test suite based on the specification, and an interpreter which passes all the tests.
* cfunge - Small fast Befunge-98 interpreter in C, standard compliant.
* Rc/Funge-98 - Compliant Funge-98 implementation in C; diagnostics, tutorials and documentation, fingerprints include the TRDS time traveler.
* Sponge - a compiler (in Common Lisp) from a tiny subset of Scheme to Befunge 98.
* PyFunge - A Befunge-93/Funge-98 interpreter in Python. Its goal is a fully functional, compliant and optimizing implementation of Funge-98.
* Fungi - A standards compliant Funge-98 interpreter and debugger written in Haskell.
* - Author retrospective of creating a Befunge-98 Interpreter in Clojure.
* Multilang - A shell supporting multiple languages, including Befunge-98.
* BefunGen - A Befunge compiler / code generator, compiles to Befunge code from a c-like language
* Fungewars - A programming game in Funge-98.
Category:Languages 
Category:Stack-based 
Category:Push-down automata 
Category:Turing complete 
Category:Two-dimensional languages 
Category:Implemented 
Category:Low-level 
Category:Self-modifying
Category:1993