RC/Funge-98 v1.19

by Michael H. Riley


RC/Funge-98 is a funge interpreter based upon the Funge-98 specification by Cats-Eye Technologies. The full language specification (including the 'i', 'o', '=', and 't' commands) are supported. Unefunge, befunge, and trefunge all supported by RC/Funge-98, with befunge being the default mode. Several extensions are also provided, including minimal windows support (currently only on unix version).


RCS Funge interpreters can be identified with the following handprints:

"RCSU"0x52425355Unix version
Built-in Fingerprints:
Name Fingerprint Description Source
"3DSP0x334453503D space manipulation extension(RCS)
"BASE"0x42415345I/O for numbers in other bases(RCS)
"CPLI"0x43504C49Complex Integer extension(RCS)
"DATE"0x44415445Date Functions(RCS)
"DIRF"0x44495246Directory functions extension(RCS)
"EMEM"0x454d454dExtended memory(RCS)
"EVAR"0x45564152Environment variables extension(RCS)
"EXEC"0x45584543Various types of k-like execs(RCS)
"FILE"0x46494C45File I/O functions(RCS)
"FING"0x46494e47Operate on single fingerprint semantics(RCS)
"FNGR"0x464E4752Fingerprint management extension(RCS)
"FPDP"0x46504450Double precision floating point(RCS)
"FPSP"0x46505350Single precision floating point(RCS)
"FIXP"0x46495850Some useful fixed point math functions(RCS)
"FRTH"0x46525448Some common forth commands(RCS)
"HRTI"0x48525449High resolution timer interface(Cats-Eye)
"IIPC"0x49495043Inter IP communicaiton extension(RCS)
"IMAP"0x494D4150Instruction remap extension(RCS)
"INDV"0x494E4456Pointer functions(RCS)
"JSTR"0x4a5354523d string vectors(JVH)
"LONG"0x4c4f4e47Long Integers(RCS)
"MACR"0x4d414352Macro Extension(RCS)
"MODE"0x4D4F4445Standard modes(Cats-Eye)
"MODU"0x4D4F4455Modulo Arithmetic Extension(Cats-Eye)
"MSGQ"0x44d534751SysV IPC Message Queues(RCS)
"ORTH"0x4F525448Orthogonal Easement Library(Cats-Eye)
"PERL"0x5045524CGeneric Interface to Perl(Cats-Eye)
"REFC"0x52454643Referenced Cells Extension(Cats-Eye)
"REXP"0x52455850Regular Expression Matching(RCS)
"ROMA"0x524F4D41Roman numerals extension(Cats-Eye)
"SETS"0x53455453Set operations(RCS)
"SMEM"0x534d454dSysV IPC Shared Memory(RCS)
"SMPH"0x534d5048SysV IPC Semaphores(RCS)
"SOCK"0x534F434Btcp/ip socket extension(RCS)
"STCK"0x5354434bStack Manipulation(RCS)
"STRN"0x5354524EString functions(RCS)
"SUBR"0x53554252Subroutine extension(RCS)
"TIME"0x54494D45Time and Date functions(RCS)
"TERM"0x5445524DTerminal extension(RCS)
"TOYS"0x544F5953Standard Toys(Cats-Eye)
"TRDS"0x54524453IP travel in time and space(RCS)
"TURT"0x54555254Turtle Graphics(Cats-Eye)
"WIND"0x57494E44Windows extensions(RCS)
Maximum Overloads100
Stack Stacks200
Mini Funges100
Mini-funge size40x10
These limits can be changed by altering funge.h and recompiling.
Memory Models:
RC/Funge provides two memory models, Fixed and Dynamic:
FIXED In this mode the interpreter allocates the entire Funge-space at execution time. If you want a large addressable Funge-space you could run out of memory. This is the fastest of the two modes.
DYNAMIC This mode the virtual dimensioning used by Funge/98. In this mode the dimensions are no longer a factor in memory usage. Instead a block of cells are allocated and can be located anywhere in Funge-space. The current mechanism for implementing this memory model is not so good, and therefore a bit slow.

funge [switches] source-files

-1 - Use single dimension Funge-space
-2 - Use two dimensional Funge-space (default)
-3 - Use three dimensional Funge-space
-93 - Allow only Funge/93 instructions
-98 - Run in Funge/98 mode (default)
-d - Enable debugger
-D - Delay between instruction execution
-i n - Change stack size (def 1000)
-md - Dynamic memory model (default)
-mf - Use fixed memory model
-s - Map Funge-space to screen
-S - Suppress summary
-t - Enable tracing mode
-v - Show version
-w - Enable warnings
-x n - Change x dimension of Funge-space for fixed memory model (def 100)
-y n - Change y dimension of Funge-space for fixed memory model (def 100)
-z n - Change z dimension of Funge-space for fixed memory model (def 1)
-Y - Use official version of 'y' command

Funge/98 Instruction Set:

!(n -- !n)Logical Negate
"( -- )Toggle string mode
#( -- )Skip next cell
$(n -- )Drop top stack entry
%(n1 n2 -- n1%n2)Modulo
&( -- n)Read number from stdin
'( -- c)Push next cell onto stack
((0gnirts n -- )Overload functions A-Z
)(0gnirts n -- )Unload functions A-Z
*(n1 n2 -- n1*n2)Multiplication
+(n1 n2 -- n1+n2)Addition
,(n -- )Print tos as a character
-(n1 n2 -- n1-n2)Subtraction
.(n -- )Print tos as a number
/(n1 n2 -- n1/n2)Division
0( -- 0)Push 0 onto stack
1( -- 1)Push 1 onto stack
2( -- 2)Push 2 onto stack
3( -- 3)Push 3 onto stack
4( -- 4)Push 4 onto stack
5( -- 5)Push 5 onto stack
6( -- 6)Push 6 onto stack
7( -- 7)Push 7 onto stack
8( -- 8)Push 8 onto stack
9( -- 9)Push 9 onto stack
:(n -- n n)Duplicate tos
;( -- )Skip to next ;
<( -- )Set ip delta to -1,0,0
=(0gnirts -- n)Pass string to underlying system
>( -- )Set ip delta to 1,0,0
?( -- )Set ip delta to random direction
@( -- )Terminate thread
A-Z( -- )Overloadable functions
[( -- )Turn ip delta to the left
\(n1 n2 -- n2 n1)Swap top two stack elements
]( -- )Turn ip delta to the right
^( -- )Set ip delta to 0,-1,0
_(n -- )does > if tos is zero, else <
`(a b -- n)Pushes 1 if a>b else pushes 0
a( -- 10)Push 10 onto stack
b( -- 11)Push 11 onto stack
c( -- 12)Push 12 onto stack
d( -- 13)Push 13 onto stack
e( -- 14)Push 14 onto stack
f( -- 15)Push 15 onto stack
g(v -- n)Get value stored in funge cell
h( -- )Sets ip delta to 0,0,1
i(v f 0gnirts -- vs vo)Load a file, Acts as r on failure
j(n -- )jumps ip delta * tos;
k(n -- )Execute command in next cell n times
l( -- )Sets ip delta to 0,0,-1
m(n -- )Does l if tos is zero else h
n( -- )Clears stack
o(vs vo 0gnirts -- )Write funge space to file
p(n v -- )Put value into funge cell
q(n -- )Immedietly quit program, tos is return code
r( -- )Reflect the delta
s(n -- )Take tos and store into next cell
t( -- )Start new thread
u( -- )Transfer entries between soss and toss
v( -- )Set ip delta to 0,1,0
w(a b -- )do ] if a>b, [ if a<b, otherwise z
x(x y z -- )Set ip delta from stack
y(n --)Get System information
z( -- )nop
{(n -- )Begin Block
|(n -- )does v if tos is zero, else ^
}(n -- )End Block
~( -- c)Input character from stdin

System Information - y Command:

RC/Funge interprets the 'y' command a bit differently from the specification. According to the specs, a positive argument will leave the n'th cell from the y command on the stack. I thought that it is more useful to allow n to specify which information entry rather than cell. Entries 1-9 will work excactly as the specification, but 10 up act differently. According to the spec 55+y would retrieve one cell from the vector of the current IP location. RC/Funge instead returns the entire vector. Entry 11 would then contain the entire vector for the current IP's delta, whereas in the specs, 11 would return the second cell of the location vector in befunge or trefunge OR the x delta in unefunge. I felt it more useful to be able to directly specify an information item rather than have to calculate beyond entry 9 in order to find the correct cell.

If you desire the behaviour of the official specification, then use a -Y on the command line.

1 Flags
bit 0 = 1 if 't' command is implemented
bit 1 = 1 if 'i' command is implemented
bit 2 = 1 if 'o' command is implemented
bit 3 = 1 if '=' command is implemented
2 Number of bytes per cell
3 Handprint
4 Version number
5 Operating Paradigm
1=Equivalent to c language system()
2=Equivalent to interpretation by specific shell program
3=Executes in shell funge was started from
6 Path separator character
7 Number of scalars per vector (1=unefunge, 2=befune, 3=trefunge)
8 ID of current IP
9 not used
10 Vector for location of current IP
11 Vector for delta of current IP
12 Vector containting storage offset of current IP
13 Vector pointing to smallest address with non-space contents
14 Vector pointing to largest address with non-space contents
15 (year-1900)*256*256 + month*256 + day
16 hour*256*256 + minute*256 + second
17 Number of stacks on the stack stack
18 Size of each stack on the stack stack
19 The command line
20 The environement, each environment entry is in the form of a 0gnirts
name=value string. double zeros denote the end of the list

Supported Fingerprints:


"3DSP" 0x33445350
A(V3a V3b -- V3)Add two 3d vectors
B(V3a V3b -- V3)Subtract two 3d vectors
C(V3a V3b -- V3)Cross porduct of two vectors
D(V3a V3b -- n)Dot product of two vector
L(V3 -- n)Length of vector
M(V3a V3b -- V3)Multiply two 3d vectors
N(V3 -- V3)Normalize vector (sets length to 1)
P(Vdm Vsm -- )Copy a matrix
R(Va axis ang -- )Generate a rotation matrix
S(Va V3 -- )Generate a scale matrix
T(Va V3 -- )Generate a translation matrix
U(V3 -- V3 V3)Duplicate vector on top of stack
V(V3 -- x y)Map 3d point to 2d view
X(V3 Vam -- V3)Transform a vector using transformation matrix
Y(Vdm Vam Vam -- )Multiply two matrices
Z(n V3 -- V3)Scale a vector

"BASE" 0x42415345
B(n -- )Ouptut top of stack in binary
H(n -- )Ouptut top of stack in hex
I(b -- n)Read input in specified base
N(n b -- )Output n in base b
O(n -- )Ouptut top of stack in octal

"CPLI" 0x43504C49
A(ar ai br bi -- r i)Add two complex integers
D(ar ai br bi -- r i)Divide two complex integers
M(ar ai br bi -- r i)Multiply two complex integers
O(r i -- )Output a complex number
S(ar ai br bi -- r i)Subtract two complex integers
V(r i -- n)Absolute value of a complex integer

"DATE" 0x44415445
A(y m d days -- y m d)Add days to date
C(jd -- y m d)Convert julian day to calendar date
D(y1 m1 d1 y2 m2 d2 -- days)Days between dates
J(y m d -- jd)Calendar date to julian day
T(y d -- y m d)Year/day-of-year to full date
W(y m d -- d)Day of week (0=monday)
Y(y m d -- d)Day of year (0=Jan 1)

"DIRF" 0x44495246
C(0gnirts -- )Change directory
M(0gnirts -- )Make a directory
R(0gnirts -- )Remove a directory

"EMEM" 0x454d454d
A(size -- hnd)Allocate memory
F(hnd -- )Free memory
G(hnd n addr --)Get bytes from memory
P(.. hnd n addr --)Put bytes into memory
R(hnd size -- )Reallocate memory

"EVAR" 0x45564152
G(0gnirts -- 0gnirts)Get value of an environment variable
N( -- n )Get number of environment variables
P(0gnirts --)Put a value into the environemnt (form: name=value)
V(n -- 0gnirts)Get n'th environmnt variable (form: name=value)

"EXEC" 0x45584543
A(V n -- )Execute command at vector n times from current location, IP will be pointed at the A
B(V n -- )Like A but IP will be reset each iteration
G(V --)Set position of IP to vector
K(n -- )what k should have been, will skip following instruction if it is the iterated one
R(n --)Like K but IP is reset after each iteration
X(cmd n --)execute command on stack n times

"FILE" 0x46494C45
C(h --)Close a file
D(0gnirts -- )Delete specified file
G(h -- h 0gnirts b)Read string from file (like c fgets)
L(h -- h n)Get location of file pointer
O(Va m 0gnirts -- h)Open a file (Va=i/o buffer)
4truncate read/write
5append read/write
P(h 0gnirts -- h)Write string to file (like c fputs)
R(h n -- h)Read n bytes from file to buffer
S(h m n -- h)Seek to position n in file
0from beginning
1from current location
2from end
W(h n -- h)Write n bytes from buffer to file

"FING" 0x46494e47
X(sem sem -- )Swap two semantics
Y(sem -- )Drop semantic
Z(src dst -- )Push source semantic onto dst

"FNGR" 0x464E4752
A( -- )Set ( and ) to work in absolute mode
B( -- fp 1)Create a Blank extension on top of stack
(all entries are set to transparent). The standard
fingerprint id for this copy will be 0xFFFFFFFF.
This is useful to create a customized
extension containing pieces from many others.
C(new n old o -- )Copy instruction 'old' in fingerprint 'o' to
instruction 'new' in fingerprint 'n'
D(inst n-- )Delete an instruction from fingerprint with id n
F(fp -- n)Get current id for specified fingerprint
fp is a 1 cell version, like from the ) command
K(n -- )Kill extension at selected position in fingerprint stack
N( -- n)Get number of fingerprints loaded
O( -- )Return ( and ) to the official functions
R( -- )Set ( and ) to work in roll mode
S( -- )Set ( and ) to work in swap mode
T(fp n -- )Tag stack entry n with new fingerprint fp
X(n n -- )Exchange the positions of two fingerprints in the stack
All instructions on failure act like r.
The fingerprint stack and fingerprint ids as used by this extension: The fingerprint stack consists of all loaded fingerprints. When a fingerprint is loaded it is pushed onto this stack. When an A-Z instruction is executed the tos of this stack is the first searched for the command, and then on downwards through the stack, if the bottom is hit, then an r command will be executed. For most all commands in this extension, the fingerprint id is actually the position on the fingerprint stack. The top has id 0, the second id 1, and so on. So, if you were to execute "'A1D" This would delete the 'A' command from the extension sitting on the second position on the fingerprint stack.
Absolute Mode:
In absolute mode, the ( and ) instructions take on new meanings:
(  A number is popped of off the stack, this numbers is the fingerprint id (stack position) of what should be considered the top of stack. It does not actually move anything, it only changes where the instruction search starts. Extensions on the stack above the selected one will not be searched whereas the selected and donward will still be searched. Executing "0(" will return the search to the top of the fingerprint stack.
)  A number is popped of off the stack, this number specifies which fingerprint is to be copied over the top of the current top of stack. The extenstion that is currently on the top of the fingerprint stack will be deleted amd the selected one takes its place. The selected entry also remains in its original stack position, only a copy is made. The search point is then reset to the top of the fingerprint stack. Unlike the ( command, this will allow all other stack entries to be searched.
Roll Mode:
In roll mode, the ( and ) instructions take on new meanings:
(  A number is popped off the data stack and is used to roll the fingerprint stack. The item at the selected entry is removed and moved to the top of stack, while all other entries are moved down. This operates like the forth "roll" command.
)  This works like (, but the roll is reversed. The top of stack is moved to the selected position while all other entries are moved up. This operates like the forth "-roll" command.
Swap Mode: In swap mode, the ( and ) instructions take on new meanings:
(  A number is popped from the data stack. This specifies which entry in the fingerprint stack is to be swapped with the top of the fingerprint stack.
)  This command uses no arguments from the data stack. It merely swaps the top two entries on the fingerprint stack
  • In all modes, on failure ( and ) will act like r.
  • When FNGR is loaded the fingerprint stack does NOT act like the spec, Instead there is a single fingerprint stack and unloading a fingerprint will remove the semantics for that fingerprint and not the semantics assigned to the various commands of the unloaded fingerprint. When FNGR is unloaded then the ( and ) commands will work like the official specs.

"FPDP" 0x46504450
A(a b -- n)Add two double precision fp numbers
B(n -- n)Sin of double precision fp number
C(n -- n)Cosin of double precision fp number
D(a b -- n)Divide two double precision fp numbers
E(n -- n)Arcsin of double precision fp number
F(n -- n)Convert integer to floating point
G(n -- n)Arctangent of double precision fp number
H(n -- n)Arccosin of double precision fp number
I(n -- n)Convert floating point to integer
K(n -- n)Natural logarithm of double precision fp number
L(n -- n)Base 10 logarithm of double precision fp number
M(a b -- n)Multiply two double precision fp numbers
N(n -- n)Negate double precision fp number
P(n -- )Print a floating point number
Q(n -- n)Double precision square root
R(0gnirts -- n)Convert ascii number to floating point
S(a b -- n)Subtract two double precision fp numbers
T(n -- n)Tangent of double precision fp number
V(n -- n)Absolute value of double precision fp number
X(n -- n)Exponential of double precision fp number (e**n)
Y(x y -- n)Raise x to the power of y

"FPSP" 0x46505350
A(a b -- n)Add two single precision fp numbers
B(n -- n)Sin of single precision fp number
C(n -- n)Cosin of single precision fp number
D(a b -- n)Divide two single precision fp numbers
E(n -- n)Arcsin of single precision fp number
F(n -- n)Convert integer to floating point
G(n -- n)Arctangent of single precision fp number
H(n -- n)Arccosin of single precision fp number
I(n -- n)Convert floating point to integer
K(n -- n)Natural logarithm of single precision fp number
L(n -- n)Base 10 logarithm of single precision fp number
M(a b -- n)Multiply two single precision fp numbers
N(n -- n)Negate single precision fp number
P(n -- )Print a floating point number
Q(n -- n)Single precision square root
R(0gnirts -- n)Convert ascii number to floating point
S(a b -- n)Subtract two single precision fp numbers
T(n -- n)Tangent of single precision fp number
V(n -- n)Absolute value of single precision fp number
X(n -- n)Exponential of single precision fp number (e**n)
Y(x y -- n)Raise x to the power of y

"FIXP" 0x4649585
A(a b -- a and b)And
B(n -- arccos(b))Find arccosin of tos
C(n -- cos(b))Find cosin of tos
D(n -- rnd(n))RanDom number
I(n -- sin(b))Find sin of tos
J(n -- arcsin(b))Find arcsin of tos
N(a -- 0-a)Negate
O(a b -- a or b)Or
P(a -- a*pi)Multiply by pi
Q(a -- sqrt(a))Square root
R(a b -- a**b)Raise a to the power of b
S(n -- n)Replace tos with sign of tos
T(n -- tan(b))Find tangent of tos
U(n -- arctan(b)Find arctangent of tos
V(n -- n)Absolute value of tos
X(a b -- a xor b)Xor

"FRTH" 0x46525448
D( .. -- .. n)Push depth of stack to tos
L( .. n -- .. n)Forth Roll command
O(a b -- a b a)Forth Over command
P(.. n -- .. n)Forth Pick command
R(a b c -- b c a)Forth Rot command

"HRTI" 0x48525449
E( -- )Erase timer mark, this makes T act like r
G( -- n)Get smallest tick size (in microseconds)
M( -- )Mark current timer value
S( -- n)Get number of microseconds since last full second
T( -- n)Get time since last marked (in microseconds)

"IIPC" 0x49495043
A( -- n)Get ancestors unique id
D( -- )Go Dormant until stack is manipulated by another ip
G(i -- n)Get the top value of another ip's stack (pop)
I( -- n)Get ip's own unique id
L(i -- n)Look at top stack value of another ip
P(n i -- )Put a value onto another ip's stack

"IMAP" 0x494D4150

C( -- )Clear all instruction remaps
M(new old -- )Remap an instruction
O(n -- )Return instruction n to its old function

"INDV" 0x494E4456
G(Vp - n)Pointer get number
P(n Vp -- )Pointer put number
V(Va -- V)Pointer get vector
W(V Va --)Pointer put vector

"JSTR" 0x4a535452
G(Vd Va n - )pop n cells off of the stack and write at Va with delta Vd
P(Vd Va n - 0gnirts)read n cells from position Va and delta Vd, push on stack as a string

"LONG" 0x4c4f4e47
A(ah al bh bl -- rh rl)Addition
B(ah al -- rh rl)Absolute value
D(ah al bh bl -- rh rl)Division
E(n -- rh rl)Sign extend single to long
L(ah al n -- rh rl)Shift left n times
M(ah al bh bl -- rh rl)Multiplication
N(ah al -- rh rl)Negate
O(ah al bh bl -- rh rl)Modulo
P(ah al -- )Print
R(ah al n -- rh rl)Shift right n times
S(ah al bh bl -- rh rl)Subraction
Z(0gnirts -- rh rl)Ascii to long

"MACR" 0x4d414352
A-Y( -- )Execute specified macro
Z(V -- )Specify where macro block is located

"MODE" 0x4D4F4445
H( -- )Toggles hover mode (relative vs absolute delta changes)
I( -- )Toggles invert mode (push to bottom of stack)
Q( -- )Toggles queue mode (pop from bottom of stack)
S( -- )Toggles switch mode (alters [,].{.}.(.) commands)

"MODU" 0x4D4F4455
M(a b -- a mod b)x-floor(x/y)*y
U(a b -- a mod b)Unsigned result
R(a b -- a mod b)C-language remainder

"MSGQ" 0x4d534751
G(key flags -- id)Get message queue identifier
K(id -- )Kill message queue
R(n mtyp id flags -- .. n t)Receive message to stack
S(.. n mtyp id flags -- )Send bytes on stack as message
T(id -- nmsg maxsize)Get message system info

"NULL" 0x4E554C4C
A-Z( -- )All set to reflect

"ORTH" 0x4F525448
A(a b -- a and b)And
E(a b -- a exor b)exor
G(y x -- v)Get value stored at x,y
O(a b -- a or b)Or
P(v y x -- )Store value in funge space x,y
S(0gnirts -- )Print string located on stack
V(n --)Change IP Delta X to tos
W(n --)Change IP Delta Y to tos
X(n -- )Change IP x coordinate to tos
Y(n -- )Change IP y coordinate to tos
Z(n -- )If zero, act like #

"PERL" 0x5045524C
E(0gnirts -- 0gnirts)Evaluate a string in perl
I(0gnirts -- n)Evaluate a string in perl, returning integer
S( -- n)Pushes 0 if underlying system is perl, else 1

"REFC" 0x52454643
R(Va -- r)Produce a single cell reference to a vector
D(r -- Va)Return the vector referenced by r

"REXP" 0x52455850
C(0gnirts flags -- )Compile a regular expression
E(0gnirts flags -- results)Execute regular expression on string
F( -- )Free compiled regex buffer

"ROMA" 0x524F4D41
C( -- 100)Pushes 100 on stack
D( -- 500)Pushes 500 on stack
I( -- 1)Pushes 1 on stack
L( -- 50)Pushes 50 on stack
M( -- 1000)Pushes 1000 on stack
V( -- 5)Pushes 5 on stack
X( -- 10)Pushes 10 on stack

"SETS" 0x53455453
A(set v -- set)Add value to set
C(set -- set n)Get count of items in set
D(set -- set set)Duplicate set on stack
G(Vdlt Vsrc -- set)Get set from Funge-space
I(seta setb -- seta setb setr)Instersection of sets
M(set v -- set r)r=0 if v is not member of set, else r=1
P(set -- set)Print a set
R(set v -- set)Remove value from set
S(seta setb -- seta setb setr)Subtract setb from seta
U(seta setb -- seta setb setr)Union of sets
W(set Vdlt Vdst -- set)Write set to Funge-space
X(seta setb -- setb seta)Swap two sets
Z(set -- )Drop set from stack

"SMEM" 0x534d454d
G(key size flags -- id)Get shared memory segment
K(id -- )Remove shared memory segment
R(n addr id flags -- ..)Read bytes from shared memory
T(id -- size)Get shared memory info
W(.. n addr id flags -- )Write bytes to shared memory

"SMPH" 0x534d5048
A(sem id flags -- id)Allocate semaphore
D(sem id flags -- id)De-allocate semaphore
G(key nsems flags -- id)Get a semaphore set
K(id -- )Remove a semaphore set
M(op sem id n -- )Multiple semaphore operations
N(sem id -- z n)Get number of processes waiting on semaphore
R(sem id -- n)Read semaphore value
W(v sem id -- )Write semaphore value
Z(sem id -- )Wait for zero semaphore

"SOCK" 0x534F434B
A(s -- prt addr s)Accept a connection
B(s ct prt addr -- )Bind a socket
C(s ct prt addr -- )Open a connection
I(0gnirts -- addr)Convert an ascii ip address to a 32 bit address
K(s -- )Kill a connection
L(n s -- )Set a socket to listening mode (n=backlog size)
O(n o s -- )Set socket option
R(V l s -- bytes)Receive from a socket,
S(pf typ pro -- s)Create a socket
W(V l s -- retcode)Write to a socket
note: All functions act as r on failure
addr:32 bit destination address
prt:Port to connect to
s:Socket identifier
V:Vector to io buffer

"STCK" 0x5354434b
B(v n -- v ..)Bury v value n deep into the stack
C(.. -- cnt)Get count of items on stack
D(.. n -- ..)Duplicate top n stack items
G(n Vdlt Vsrc -- ..)Read n stack entires from Funge-Space
K(st en -- ..)Push block of stack cells on top
N(.. n -- ..)Reverse n items on stack
P(.. -- ..)Print contents of stack, non-destructive
R(.. -- ..)Reverse all items on stack
S(a b -- a a b)Duplicate second on stack
T(a b c -- b a c)Swap second and third items on stack
U(n -- n r)Drop items from stack until n is found
W(n Vdlt Vsrc -- )Write n stack entires to Funge-Space
Z(0string -- 0gnirts)Reverse 0 terminated string on stack

"STRN" 0x5354524E
A(0gnirts 0gnirts -- 0gnirts)Append bottom string to upper string
C(0gnirts 0gnirts -- n)Compare strings
D(0gnirts --)Display a string
F(0gnirts 0gnirts -- 0gnirts)Search for bottom string in upper string
G(Va -- 0gnirts)Get string from specified position
I( -- 0gnirts)Input a string
L(0gnirts n -- 0gnirts)Leftmost n characters of string
M(0gnirts s n -- 0gnirts)n characters starting at position s
N(0gnirts -- 0gnirts n)Get length of string
P(0gnirts Va -- )Put string at specified position
R(0gnirts n -- 0gnirts)Rightmost n characters of string
S(n -- 0gnirts)String representation of a number
V(0gnirts -- n)Retreive value from string

"SUBR" 0x53554252
A( -- )Set absolute mode
C(Va n -- Va Vd .. )Call a subroutine
J(Va -- )Jump to another location
O( -- )Set Relative mode
R(Va Vd .. n -- ..)Return from subroutine

"TIME" 0x54494D45
D( -- n)Day of Month
F( -- n)Day since First of year
G( -- )Set time functions to GMT
H( -- n)Hours
L( -- )Set time functions to local time (default)
M( -- n)Minutes
O( -- n)Month (1=January)
S( -- n)Seconds
W( -- n)Day of Week (1=Sunday)
Y( -- n)Year

"TERM" 0x5445524D
C( -- )Clear the screen
D( n -- )Move cursor down n lines
G(x y -- )Put cursor at position x,y (home is 0,0)
H( -- )Move cursor to home
L( -- )Clear to end of line
S( -- )Clear to end of screen
U( n -- )Move cursor up n lines

"TOYS" 0x544F5953
A(a n -- a(n))Pushes n copies of a on stack
B(a b -- a+b a-b)Butterfly bit operation
C(Vsrc Vsz Vdst -- )Low order copy of funge space
D(n -- n-1)Decrement tos
E(.. -- n)Pops all stack values and pushes back the sum
F(.. x y V -- n)Take values from the stack to place into Funge-Space creating a 2d-vector of size x,y and stored at V
G(x y V -- ..)Take 2d matrix from Funge-space at V and size x,y and push onto stack
H(a b -- v)Shift a left on +b, right on -b
I(n -- n+1)Increment tos
J(n -- )Translates current column north (negative) or south (positive) n times
K(Vsrc Vsz Vdst -- )High order copy of funge space
L( -- n)Get value to left of the ip's track
M(Vsrc Vsz Vdst -- )Low order move of funge space
N(n -- -n)Negate tos
O(n -- )Translates current row west (negative) or east (positive) n times
P(.. -- n)Pops all stack values and pushes back the product
Q(n -- )Puts value in cell directly behind ip
R( -- n)Get value to right of the ip's track
S(v Vsz Vorg -- )Fill area with value v
T(n -- )Pop value off of stack, if 0 then act like _, if 1 act like |, if 2 act like m
U( -- )Replaces itself with < > ^ v h or l
V(Vsrc Vsz Vdst -- )High order move of funge space
W(n V -- )Wait, see notes
X( -- )Increments IP's delta X
Y( -- )Increments IP's delta Y
Z( -- )Increments IP's delta Z

"TRDS" 0x54524453
C( -- )Continue normal time
D(V -- )Set absolute destination space coordinates
E(V -- )Set relative destination space corrdinates
G( -- n)Get current time point
I( -- )Set inverse settings
J( -- )Initiate a jump
P( -- n)Maximum distance in the past ip can jump to
R( -- )Reset all tardis controls to default
S( -- )Stop time
T(n -- )Set absolute destination time
U(n -- )Set relative destination time
V(V -- )Set destination vector
Notes to time travelling ips:
Usage of time travel can be very punishing on the performance of the funge interpreter. If travel is performed to the past, the interpreter must be capable of reproducing all conditions that existed at the destination time, which includes all ips, stacks, and funge space cells. Some interpreters may only store time snapshots from only so far back (The furthest point in the past that can be jumped to can be determined with the P command). The RCS interpreter essentially reruns from point 0 and therefore all points in time can be jumped to (note: this can be quite time consuminmg if the destination time point is tens or hundreds of thousands of instructions from time point 0).
Time travel into the future is not quite so punishing. The ip that time travels will merely be frozen until time catches up with it, at which point it will continue to execute.
Time travel into the past has the following consequences:
  1. It is not possible to travel further back than time point 0. Attempts to travel beyond the beginning will leave the ip at time point 0.
  2. The original ip will still be born as per normal. example. If ip #2 is born at time 100 and then performs a jump at time 200 to time 50, ip #2 will be born again at time 100, and there will now be 2 of them (the newly born ip #2 in addition to the one that jumped) When the newly born ip #2 reaches the time it jumped (time point 200) it will cease to exist, it will not perform another jump into the past, the original ip #2 however can still jump. If the new ip #2 performs a time jump earlier than when the original jumped, the original will cease to exist.
  3. An ip travelling in the past can kill its parent prior to its own birth, and will still exist.
  4. A time travelling ip will retain its memory, in other words, its stack will be the same after the jump as before. Also, unless the jump also included a space jump, the location will be the same physical space coodinates as when it jumped.
  5. An ip that perfroms a time jump without a space jump will execute the next instruction as if it had never jumped.
  6. An ip that performs a space jump (with or without a time jump) will first execute the instruction it jumped to.
When Multiple IPs Time Travel:
In order to decrease the work on the interpreter, it is not necessary for the interpreter to remember future events. In other words when an ip travels back in time, everything occuring after the time point of destination need not recur if it does not occur in the further course of the program. When IPs time travel, only those ips that are currently in funge space at the time of arrival (either normally or from time travelling) will exist. Any ips that time travelled to a point later in time will not recur, unless the original time travel for these ips recur. Here are two examples to illustrate this point:
Example 1: Ip#1 travels back in time and arrives to time point 100, Ip#2 travels back to point 150. At point 150 the time travelled copies of both ips will exist.
Example 2: Ip#1 travels back in time and arrives to time point 150, Ip#2 travels back to point 100. At the point where ip#2 arrives, ip#1 has not yet arrived and therefore does not exist, it will also not exist when time point 150 arrives, only when the original jump for Ip#1 occurs, will history again be rewritten.
Tardis Operators Manual:
  1. Before attempting any jumps, the ip's tardis should be reset to clear out any unwanted coordinates.
  2. There are three coordinate settings: Space coordinates, vector after jump, and destination time. Any coordinate that is not set will remain at the last setting, or at default if the tardis is reset.
  3. Default coordinates are the current time, space, and vector.
  4. Absolute coordinates are based from time point 0, and space 0,0,0.
  5. Relative coordinates are based from the point the jump is actually made.
  6. All tardis coordinates are retained following a jump.
  7. The I command will set the tardis for the last source jump point.
Stopping Time:
An ip that issues a <S>top time command freezes the time counter. All other ips will be frozen until a <C>ontinue time command is executed. During the time that time is stopped, only the ip that executed the S command will continue to run. For the purposes of time travel, the time used while time is stopped does not actually exist, and therefore cannot be jumped to. In other words everything the ip does is considered to have taken no time. If an ip that stops time is terminated, time will be continued

"TRGR" 0x54524752
A-Y( -- )Activate a trigger
Z(V -- )Specify where trigger table is located

"TURT" 0x54555254
A( -- h)Query heading (0=east)
B(d -- )Move backwards d pixles
C(rgb -- )Set pen color to 24-bit RGB value
D(f -- )Set display on (f=1) or off (f=0)
E( -- p)Query pen position down=1, up=0
F(d -- )Move forward d pixels
H(h -- )Set heading to h (in degrees, 0=east)
I( -- )Print drawing (not implemented yet)
L(d -- )Turn left d degrees
N(rgb -- )Clear with 24-bit RGB color
P(p -- )Set pen position, 0=up, 1=down
Q( -- x y)Query pen position
R(d -- )Turn right d degrees
T(x y -- )Teleport pen to position
U( -- minX minY maxX maxY)Query bounds

"WIND" 0x57494E44
B(x1 y1 x2 y2 h -- )Draw a box
C(h -- )Close GC
D(h -- )Drop (lower) Window
E(h -- )Call event checker
I(Va e h -- )Install event handler
1- Mouse Down
2- Mouse Up
3- Mouse Motion
4- Key Pressed
5- Expose
6- Configuration
K(h -- )Kill a window
L(x1 y1 x2 y2 h -- )Draw a line
M(x y h -- )Move a window
O(h -- )Open GC
P(x y h -- )Draw a point
R(h -- )Raise Window
S(x y h -- )resize a window
T(0gnirts x y h --)Draw text in a window
W(x y w h -- h)Open a window


When a fingerprint is requested that is not built into the interpreter, RC/Funge will search for a file corresponding to the fingerprint. The filename is built from the ascii characters associated with the fingerprint and using an extension of 'fl'.

example fingerprint: 0x524F4D41 would search for file ROMA.fl If the file is found it is loaded as the semantics for the overloaded functions. The file must be in the funge-lib file format.

The following commands are not available in Mini-Funge:

((gnirts n -- )Overload functions A-Z
)(gnirts n -- )Unload functions A-Z
=(0gnirts -- n)Pass string to underlying system
h( -- )Sets ip delta to 0,0,1
i(v f 0gnirts -- vs vo)Load a file, Acts as r on failure
l( -- )Sets ip delta to 0,0,-1
m(n -- )Does l if tos is zero else h
o(vs vo 0gnirts -- )Write funge space to file
q(n -- )Immedietly quit program, tos is return code
t( -- )Start new thread
u( -- )Transfer entries between soss and toss
x(x y z -- )Set ip delta from stack
{(n -- )Begin Block
}(n -- )End Block

The following commands have altered functions in Mini-Funge:

'( -- c)Push next mini-funge cell onto stack
@( -- )Terminate mini-funge program
g(v -- n)Get value stored in main funge-space cell
p(n v -- )Put value into main funge-space cell

The following are commands added to Mini-Funge:

B( -- )Move calling ip backwards one delta unit
D(v -- )Set delta of calling ip
E(.. -- n)Push depth of stack
F( -- )Move calling ip forwards one delta unit
G(v -- n)Get value stored in mini funge-space cell
K(.. n -- .. n)Forth Pick command
L(v -- )Set location of calling ip
O( .. n -- .. n)Forth Roll command
P(n v -- )Put value into mini funge-space cell
R( -- )Reflect the delta of calling ip

Unless otherwise noted above, accesses to funge space access the mini- funge space. All stack access are from the stack of the calling ip.

An entire mini-funge program executes in a single tick in comparison to other concurent funge ip pointers.

funge-lib file format:

A funge-lib file contains the funge source code for commands which can be loaded into A-Z with the ( command.

Each command starts with a line beginning with = and an uppercase letter. All lines up til the next = line are the funge source lines for the function.

Example: Here is a funge-lib file describing Cat's-eye's ROMA extension:



back- Move ip backward by its delta
del bp x [y [z]]- Delete a breakpoint
del trap c- Delete a command trap
drop- Drop top entry from stack
fore- Move ip forward by its delta
pop- Pop and display top of stack
push n- Push a number onto the stack
quit- Quit program
run- Prevent single stepping on current ip
set bp x [y [z]]- Set a breakpoint
set cell v x [y [z]]- Set value in specified funge cell
set ip delta x [y [z]]- Set ip delta
set ip pos x [y [z]]- Set ip position
set trap c- Set a command breakpoint
show bp- Show breakpoints
show cell x [y [z]]- Show value in specified funge cell
show ip- Show ip information
show ipdetails [n]- Show detailed information about ip
show ips- Show information on all ips
show fingers- Show A-Z overloaded fingerprints
show mapper- Show instruction mappings
show stack- Show stack for current ip
show stacks- Show entries in all stacks
show time- Show current time point
show traps- Show command breakpoints
steps n- Allow the current ip to step n instructions
- Step one instruction

Note: Any single character command will be executed as the associated funge instruction (example, . will do the same as pop, with only a single keystroke.)