Befunge

From Esolang
(Redirected from Unefunge)
Jump to navigation Jump to search
Befunge
Paradigm(s) imperative
Designed by Chris Pressey
Appeared in 1993
Memory system stack-based
Dimensions two-dimensional
Computational class Turing complete (Befunge-98)
Reference implementation Befunge-93
Dialects Befunge-93, Funge-98
File extension(s) .be, .bf, .b93, .b98, .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" [1]) 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

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-98 and beyond

  • Funge-98 documentation.
  • Funge-98 specification
  • vsync's Funge stuff.
  • BefungeSharp A Funge-98 IDE written in C#. Features a command-line editor and a compliant interpreter.
  • Fungus (from the Wayback Machine; retrieved on 22 March 2007) - a nice Befunge-98 IDE for Win32. Warning: its interperter is not fully standards compliant.
  • mooz' Befunge page (from the Wayback Machine; retrieved on 25 September 2006) - 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.
  • Closidrium (from the Wayback Machine; retrieved on 26 April 2020) - 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.
Retrieved from "https://esolangs.org/w/index.php?title=Befunge&oldid=147548"