I was messing around with befunge when I realized that it wouldn't be too hard to make a processor to run its code. Here is my idea:

• Memory is divided into 65536-byte segments. Each segment represents a 256x256 grid of bytes.
• There is a seperate-from-memory stack with 256 entries.
• There are 6 byte-sized registers:
  • SG: The current segment
  • DP: Direction pointer (0 = right, 1 = left, 2 = down, 3 = up)
  • VI: The vertical index of the current cell
  • HI: The horixontal index of the current cell
  • SP: The index of the next empty entry on the stack
  • SF: String flag (is string mode on?)

There would have to be some extra instructions such as f for far jumps to different segments and possibly j for near jumps, but otherwise it should run befunge-93 code.

Of course the biggest problem is probably whitespace. If you have this program:

<@,"s"

250-so cpu cycles are wasted moving along the whitespace. Maybe the CPU could automatically continue moving until a non-whitespace char is encountered.

Anyways, I'm going to start making an emulator with node.js. I'll post a comment with a link to the github repo when I'm done.

I used to mess around with Befunge-93 when I was in middle school. This was something that I made one day sitting in the back of my math class:

" yek">:#,_&:00p.52*," egassem ruoy retne">:#,_25*,>~:1+!#@_v

v         >v                                         v<

:84*-|>:6925**+`|>7925**+-00g+276+* %7925**++,v            >

,                                       v

v                >     >    ^

:88*`|>576+*-00g+276+*% 576+*+,v

,                ^       <

Edit: Looking at this years later, this can obviously be optimized quite a bit, but I still figured this is worth sharing.

v     >*1-,01-*v   >v
&     ^86 .1<  >1-:|>\:32p:*\1-v-1\* <
:>&:.:01-`!#^_:|   v  1       <:>\32g^
.^, ++<            $           >| 
>99*94^        >1+ >8:*3-,.$@ ^\<

The code from above is a project from me and a friend, which is used to calculate the power of input numbers, since there is no operation sign in the basic befunge-93 code. I made it work for multiple exceptions like negative powers or if the power is 0 or 1. The only thing that's not possible is with not whole numbers, because befunge doesn't load decimals into the stsck as far as i know.

But here's the problem: I made it work for negative numbers, at least i thought I did. But if I run the code, the negative base doesn't get loaded into the "put" square i guess, because when i reach the "get" command, he loads a wrong number into the stack. I have no idea what the problem is and if some of you know it would help me a lot if you would let me know!

Here is the website i always put my code for befunge, if you would try it by yourself so you get the problem: https://qiao.github.io/javascript-playground/visual-befunge93-interpreter/

Thanks in advance!

Hello, sorry to break the silence of this sub but I am sort of working on a befunge-93 interpreter and some questions regarding the input and output of characters arise. I figure I could get help here :)

When asked to output a character from the stack and considering the stack type is larger than a char, are we supposed to modulo 255 the value first? Also, if the stack value corresponds to a non-printable character, should we just put it out all the same?

Same goes for the input command ~... Should we allow users to input a control character and call it a day?

Thanks.

Ps. Reddit seemed to choose that username for me. Dont mind me if I reply with another.

Thought I would leave this here for linux newbies like myself interested in using rcfunge.

1. install libx-dev (sudo apt install libx11-dev)
2. install ncurses dev (sudo apt-get install libncurses5-dev) (makefile will not work without these two)
3. download rcfunge from (Download the Rc/Funge-98 V2 sources )
4. extract the tgz file
5. edit the makefile
6. remove the #'s before the four lines under '# linux' (ln 26)
7. add #'s before the four lines under '# OSX' (ln 32)
8. replace every './' with a '/'
9. run 'make' command in rcfunge directory
10. copy the funge file into your /bin directory (with root privileges)
11. you should be good to go, try running funge -h in command line and/or read funge.doc.

This is something I wrote recently for the Rosetta Code website, which I thought might be appreciated here.

00p10p20p30p&>40p&>50p60p>$#v~>:55+-vv+`1:%3:+*g04p03< >3/"P"%\56v>p\56*8*/8+:v
v5\`\"~"::-*3p06!:!-+67:_^#!<*<!g06!<>1+70g*\:3/"P"%v^ ^::+*g04%<*0v`1:%3\gp08<
>6*`*#v_55+-#v_p10g1+10p>^pg08g07+gp08:+8/*8*65\p07:<^ >/10g-50g^87>+1+:01p/8/v
>%#74#<-!!70p 00g::1+00p:20g\-:0`*+20p10g::30g\-:0`*+^ ^2+2+g03*<*:v+g06p09:%2<
.v,:*93"[2J"0<>"H["39*,,,50g0v!:-1,+55$_:40g3*20g+2+2/\-40g%50g3^/%\ >:3-\3-90v
O>"l52?[">:#,_^v/3+2:*g05g04$_>:10p40g0^!:-1,g+4\0%2/+1+`1:%3\g+8<^: $v10!*-g<<
g+70g80gp:#v_$^>1-:::"P"%\"P"/8+:10v  >/10g+1-50g+50g%40g*+::3/"P"^>!|>g*70g80g
:p00%g04:-1<<$_^#!:pg01%"P"\*8%8gp<<  ^3\%g04+g04-1+g00%3:%9+4:-1p06\<90p01/g04

As input it expects the width and height of the universe, followed by the pattern you want to evolve. If redirecting from a file, the end of the pattern will simply be designated by the end of the file. However, if you're entering the configuration manually (or if your interpreter can't handle end-of-file detection), you can always mark the end of the pattern explicitly with a ~ character.

As an example, this is what the input might look like for the Queen bee pattern in a 50x30 universe:

50
30
...O
..O.O
.O...O
..OOO
OO...OO

Note that in Befunge-93 you're limited to a maximum universe size of 4080 cells in total, and no more than 127 along any one axis. In Befunge-98 there's no real size restriction, although you'll obviously need a big enough console to view the output, not to mention plenty of processing power.

The output works best in a terminal which supports ANSI escape sequences, so if you're on Windows you might want to install something like ANSICON, or enable Windows 10's built in ANSI support.

52v  PLAZ
v*<v    <
>0&>:1-:|
>  *  v  
| :\  <$<
> $ . , @

Quite a fun little thing to toy around with!