nyuuzyou/wikis huggingface dataset:
Beditasm

:
Beditasm is an assembly-like esolang created by User:None1, which runs on an imaginary binary editor.
==Data storage==
The esolang stores its data in an imaginary editor which has a null byte initially, and two registers which are initially 0.
==Commands==
INS
There are two usages:
# INS (with no arguments), read a character from user input and insert it at the cursor.
# INS <CHARACTER>, insert <CHARACTER> at the cursor
KEY
KEY <KEY>
Press <KEY> in the imaginary editor.
Valid keys are:
# DELETE, delete the character at the cursor.
# BS, delete the character at the left of the cursor.
# CTRL-A, Select all.
# CTRL-S, Select the character at the cursor.
# CTRL-P, print the selected text to standard output, if there is no selected text, print the whole text.
# CTRL-C, copy.
# CTRL-V, paste.
# CTRL-X, cut.
# CTRL-BS, move the cursor to the left.
# ENTER, insert line feed.
ASC
ASC <HEX>, <HEX> is two hex digits, which represents an ASCII character, set the second register as that character.
REG
REG, insert the character stored in the second register at the cursor.
CMP
CMP, compare if the value is equal to the second register, store the boolean result to the first register.
J
J <LINE-NUMBER>, if the value in the first register IS 0, then jump to <LINE-NUMBER>.
C
Comment.
This esolang is not case sensitive.
==Example Programs==
===Hello World===
 INS H
 INS e
 INS l
 INS l
 INS o
 ASC 20
 REG
 INS W
 INS o
 INS r
 INS l
 INS d
 INS !
 KEY Ctrl-P
===Cat Program===
 INS
 KEY Ctrl-S
 KEY Ctrl-P
 KEY DELETE
 J 1
===Truth Machine===
 ASC 30
 INS
 KEY Ctrl-S
 CMP
 J 13
 INS 0
 CMP
 KEY BS
 KEY BS
 INS 1
 KEY Ctrl-P
 J 6
 INS 0
 KEY Ctrl-P
Note that if the input is neither 1 nor 0, the program will treat it as 1.
==Turing Completeness==
Beditasm is Turing complete, I'm writing a proof now.
P.S.: The proof may not right away, because I'm busy working on other esolangs.
Category:Languages
Category:Turing complete
Category:Unimplemented
Bedroom

Bedroom is an esolang made by User:AmNow
== Commands ==
=== Specification Notes ===
In Bedroom, the program should look like a messy child’s bedroom.
The instruction pointer starts on cell (0,0) and starts moving right.
 # 
 ^ This cell.
 
Programs must have at least 1 🛏. See below.
=== The actual commands ===
Command	Description
⬆️ 	Move the instruction pointer up.
⬇️ 	Move the instruction pointer down.
⬅️ 	Move the instruction pointer left.
➡️ 	Move the instruction pointer right.
🛏 	Halt the program.
📗 	Increment the current memory cell value by one.
🧸 	Decrement the current memory cell value by one.
🪄 	Move the memory pointer one cell to the left.
🪆 	Move the memory pointer one cell to the right.
🗄 	Prompt the user for an ASCII character and store its character code in the current memory cell.
🗒 	Output the ASCII character associated with the current memory cell value.
📐 	If the current memory cell value equals 0, turn 90° CCW.
== Programs ==
=== Infinite loop ===
 ➡️⬇️🛏
 ⬆️⬅️
Golfed:
 ➡️⬅️🛏
=== Truth-machine ===
 🗄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄⬇️🛏
 ⬇️🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸⬅️
 ➡️🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄⬇️⬆️⬇️
 ⬇️🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸⬅️⬆️🗒
 ➡️🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄⬇️⬆️⬆️
 ⬇️🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸⬅️🗒📗
 ➡️🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄🧸🪆📗🪄⬇️🪆🪆
 ⬇️🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸🪄📗🪆🧸⬅️⬆️📐
 ➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️➡️⬆️
=== Cat program ===
An infinitely repeating cat program is implemented in the following:
 ⬇️ 🛏
 ➡️🗄🗒📐⬇️
 ⬆️⬅️⬅️⬅️⬅️
==Interpreter==
* Common Lisp implementation of the Bedroom programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:Implemented Category:Languages Category:Thematic
BeeScript

BeeScript is a stack-based esoteric programming language made by VilgotanL.
== Instructions ==
AVIATE n	Pushes the ascii code of the nth character in this version of the bee movie script
BEE 	Duplicates the top value of the stack
BLACK 	Pops the top value of the stack and prints it as an ascii character
BARRY 	Pops A and then B from the stack and pushes B - A to the stack
FLY n 	Pops the top of the stack, if it is non-zero this instruction jumps to the nth line
ROTATE 	Removes the bottom value of the stack and pushes it to the top
ROTAT 	Pops the top of the stack and pushes it to the bottom
YELLOW 	Takes one character of input and pushes it's ascii code to the stack
Any other instructions are ignored.
== Examples ==
=== Cat program ===
The first program ever written in BeeScript.
YELLOW
BEE
BLACK
FLY 1
=== Hello World ===
AVIATE 389
BLACK
AVIATE 43
BLACK
AVIATE 14
BLACK
AVIATE 14
BLACK
AVIATE 3
BLACK
AVIATE 39
BLACK
AVIATE 9
BLACK
AVIATE 20
BLACK
AVIATE 3
BLACK
AVIATE 4
BLACK
AVIATE 14
BLACK
AVIATE 5
BLACK
AVIATE 324
BLACK
AVIATE 85
BLACK
== Implementations ==
An interpreter in python written by the creator
Category:Languages
Category:Joke languages
Category:Unknown computational class
Category:Stack-based
Category:2021
Category:Implemented
Beecode

Beecode is a programming language made by Oklomsy.
It only has a single command, bee which prints out the first sentence of the bee movie script.
== Syntax ==
Bee
== Programs == 
Simple beecode program:
"Bee"
== Interpreter (Python and Lua!) ==
Python Interpreter
 c=input("BC>")
 c=str.lower(c)
 if "bee" in c:
 print("According to all known laws of aviation, there is no way a bee should be able to fly.")
Lua Interpreter
 print("According to all known laws of aviation, there is no way a bee should be able to fly.")
== Name Origins ==
I think this is quite obvious.
Category:Joke languages
Category:2020
Category: Languages
BeerLang

This is a string oriented code golf language. It is good for challenges similar to "99 Bottles of Beer" (hence its name).
==Syntax==
 // Line 1: String declarations, separated with spaces, all on one line, single character names.
 a="bottle" b="of beer" c="on the wall"
 // All lines after this are loops and/or statements
 // Loop line 1: The loop specifications: count from, count to, variable name
 99 2 i
 // Loop line 2: The string with substitutions to output. Arithmetic can be performed on the variable
 %i %as %b %c, %i $as $b,\nTake one down and pass it around, %{i-1} %as %b %c.\n
 // Statement: starts with a semicolon, can include substitutions
 ;1 %a %b %c, 1 %a %b,\nGo to the store and buy some more, 99 %as %b $c\n
 //End of program is a colon
 :
Infinite loops are created by putting just the name of a variable on a line, for example:
 i
 $i
counts infinitely.
You can optionally make infinite loops with braces. Assignments are supported on separate lines.
String and integer variables are supported. Maybe more depending on implementation.
Input is received via the > command, as in >a to input to a. Strings are not automatically coerced to integers, you need the operator i for that. Example:
 >ai
Variable names are always one letter long.
The ) instructions jumps to the beginning of the block if the variable specified is not equal to 0 or "" (empty). Example:
 )i
Blocks are delimited with braces: { }. Fibonacci example: (A statement by itself on a line is printed)
Statements are separated by semicolons (;), a literal semicolon is represented by \;.
 j=0 k=1 l=0
 i {
 l=j; j=k; k=${l+k}
 k
 }
==Turing complete==
The language is Turing complete because of the ) operator.
==Golfed example==
 a=" bottle" b=" of beer" c=" on the wall"
 99 2 i
 %i%as%b%c, %i$as$b,\nTake one down and pass it around, %{i-1}%as%b%c.\n
 ;1%a%b%c, 1%a%b,\nGo to the store and buy some more, 99%as%b%c\n:
Total: 186 characters
Category:Languages
Category:Turing complete
Category:Golfing language
Beetle

Beetle is an esoteric programming language with a 2-dimensional array of cells inspired by Langton's Ant. It was created by k with the goal of being at least somewhat original.
==Requirements==
Each cell can be in 1 of 2 states : on or off.
Beetle also has 2 external 8-bit variables that acts as input and outputs queues.
==Commands==
Beetle has the following commands :
 Commands
Symbol	Description
> 	Moves the pointer (beetle) right by one and swap the cell it lands on.
v 	Moves the pointer (beetle) down by one and swap the cell it lands on.
^ 	Moves the pointer (beetle) up by one and swap the cell it lands on.
< 	Moves the pointer (beetle) left by one and swap the cell it lands on.
{ 	If the current cell the beetle is sitting on is off, skip every instruction until corresponding '}'.
} 	Acts as a marker for the corresponding '{'.
@ 	Flips the direction the program is currently being run.
] 	Prevents the next instruction from being ran if the program pointer is going right.
[ 	Prevents the next instruction from being ran if the program pointer is going left.
, 	Breaks from the current loop.
. 	Restarts the current loop.
( 	Starts an unconditional brainfuck-style loop.
) 	Marks the end of a loop.
' 	Gets user input and deposits it into the input queue.
\ 	Allows the next bit from the input queue into the current cell.
/ 	Deposits the current bit at the end of the output queue.
 	Outputs the output queue and clears it.
==Examples==
===NAND Gate===
><{>><{^/|>><<}}
==='Hello, World!' Program using 2 cells of memory===
{><}/{><}></{><}/{><}/{><}></{><}/{><}/{><}/|{><}/{><}></{><}></{><}/{><}/{><}></{><}/{><}></|{><}/{><}></{><}></{><}/{><}></{><}></{><}/{><}/|{><}/{><}></{><}></{><}/{><}></{><}></{><}/{><}/|{><}/{><}></{><}></{><}/{><}></{><}></{><}></{><}></|{><}/{><}></{><}/{><}></{><}></{><}/{><}/|{><}></{><}/{><}/{><}/{><}/{><}/|{><}/{><}></{><}/{><}></{><}/{><}></{><}></{><}></|{><}/{><}></{><}></{><}/{><}></{><}></{><}></{><}></|{><}/{><}></{><}></{><}></{><}/{><}/{><}></{><}/|{><}/{><}></{><}></{><}/{><}></{><}></{><}/{><}/|{><}/{><}></{><}></{><}/{><}/{><}></{><}/{><}/|{><}/{><}></{><}/{><}/{><}/{><}/{><}></|
Category:Languages Category:Cell-based
Beets

The Beets programming language enables expressing calculations on infinite binary trees of bits.
==Grammar==
 program = definition*
 definition = identifier identifier* '=' expression '.'
 expression = '(' expression ')' | parameter | call | tree | left-subtree | right-subtree | conditional
 parameter = identifier
 call = identifier expression*
 tree = ('0' | '1') expression ',' expression
 left-subtree = '<' expression
 right-subtree = '>' expression
 conditional = expression '?' expression ',' expression
Comments start with == and extend to the end of the line.
An identifier is an uninterrupted sequence of non-space characters, excluding =, ., ,, <, >, ?, (, ), and may not begin with 0 or 1.
Space characters separate identifiers and are otherwise ignored.
==Expressions==
===Tree===
Creates a new tree from a root bit, and two subtrees.
 tree = ('0' | '1') expression ',' expression
For example, this tree has 1 at its head, with x as its left
subtree and y as its right subtree.
 1x,y
===Left subtree===
The left subtree of a tree.
 left-subtree = '<' expression
For example, this tree is the left subtree of t.
 <t
===Right subtree===
The right subtree of a tree.
 right-subtree = '>' expression
For example, this tree is the right subtree of t.
 >t
===Conditional===
The conditional expression evaluates to the left expression if the
root bit of the condition evaluates to 0, otherwise it evaluates to
the right expression.
 conditional = expression '?' expression ',' expression
For example, this evaluates to b.
 (1x,y)?a,b
Note that without the parentheses, it is not specified whether the
condition is y or 1x,y. This document leaves the interpretation
of such ambiguous expressions to be defined by the implementation.
To avoid ambiguity, write (>a)?b,c or >(a?b,c) instead of writing
>a?b,c.
==Examples==
===cat===
 cat x = x.
===Hello world===
(For one possible encoding scheme.)
 z = 0z,z.
 o rest = 1rest,z.
 i rest = 1z,rest.
 hello-world = o o o i o o i o i o i o o i i o o o i i o i i o o o i
 i o i i o i i i i o i i o o o o o o i o o i i i o i i
 i o i i i i o i i o o i o o i i i o o o i i o i i o o
 o i o o i i o i o o o o i o o o i o i o o o o 1z,z.
==References==
* Implementation
Category:Languages
Category:Implemented
Category:2019
Befalse

Befalse is an esoteric programming language created by Ian Osgood in 2005 and inspired by SNUSP and False. Like SNUSP, no letters were harmed in the making of this language.
Befalse combines the flow-control operators (/\?!) and call stack (:CALL ;RET) of SNUSP; the stack, math, and logic operators of False; and the mutable code space, numbers, and strings of Befunge (@GET =PUT). In addition, like Forth the call stack is accessible ({PUSH }POP), and there is a wimpmode for entering multi-digit numbers. The division operator is replaced by Forth's more flexible `DIVMOD. The stack operators are named $DUP, #DROP, and %SWAP, and False's @ROT is replaced by Forth's more useful ^OVER. Other stack operators can be constructed using the handy {PUSH and }POP operators.
==Examples==
Here is recursive code for printing an integer (!skip ?skip-if-zero `divmod $dup #drop .emit).
 (1234!/55+`$?\\
 \ /!://
 ;.+*68/!#/
The interpreter below contains example programs for:
* printing a number (not a built-in operation, although numeric 'INPUT is supported)
* greatest common divisor (GCD)
* Fibonacci sequence
* graphical sieve of Eratosthenes
* ROT13
* the eight queens problem
* 99 bottles of beer
* Ackermann function
==External resources==
* Interpreter/debugger in JavaScript running on a web page
Category:Languages
Category:Cell-based
Category:Stack-based
Category:Turing complete
Category:Two-dimensional languages
Category:Implemented
Category:Low-level
Category:Self-modifying
Category:2005
Befinde

Befinde is a variation of &brainfuck with relative addressing and fixed-sized cells, which makes writing compilers and interpreters easier, but writing programs maybe harder.
==Model==
Befinde uses a right-unbounded tape of at least 9bit signed integer cells. Trying to use a negative address and decrementing an indirection level that is zero all produce undefined behavior and will probably or deterministically crash the interpreter. The data pointer is mapped to cell 0.
==Commands==
Command	Action
> 	Increment the data pointer
< 	Decrement the data pointer
* 	Increment the level of indirection
& 	Decrement the level of indirection
[ 	If the data pointer is zero, jump after matching ]
] 	If the data pointer is non-zero, jump after matching [
( 	Like [, but uses the level of indirection as loop condition
) 	Like ], but uses the level of indirection as loop condition
. 	Print the value (data pointer & 0xff) as a byte
, 	Read a byte from stdin, and set the data pointer to it.
The level of indirection begins at zero. At this point all commands behave normally. When the level of indirection is one, > becomes "Increment the cell pointed to by the (data pointer + 0)". When the level of indirection is two, > becomes "Increment the cell pointed to by the cell pointed to by the (data pointer + 0)", and so on. Therefore, + can be represented as *>& and - can be represented as *<&.
==BF translation==
Brainfuck programs can be transformed to Befinde according to the following table:
BF	Befinde
[ 	*[&
] 	*]&
. 	*.&
, 	*,&
> 	>
< 	<
+ 	*>&
- 	*<&
Alternatively, the BF code can be wrapped in *code& and the following table could be used:
BF	Befinde
[ 	[
] 	]
. 	.
, 	,
> 	&>*
< 	&<*
+ 	>
- 	<
==Useful patterns==
 [<] get to next zero cell
 *[<]& set current cell to 0
 *[&>*] point to zero and increase indirection with 1
 [*>&<] increment all cells until we find the pointer (the pointer must be positive)
 [*<&>] increment all cells until we find the pointer (the pointer must be negative)
==See also==
* &brainfuck
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Category:Turing complete
Category:Turing tarpits
Category:Implemented
Category:Low-level
Category:2020
Befreak

Befreak is a purely reversible programming language, by virtue of the fact that every instruction is reversible. This means it is impossible to destroy data in any way. Befreak seems to have been invented by Brent Kerby and Hilton Campbell.
In form, Befreak is two-dimensional and takes after Befunge.
For example, a primality checking program is
 v ;?\
 ( >;
 >'%#\>\
 >*#=//<
 >=:=;/v
(enter at top v, exit at right ;, input on normal stack, output on control stack)
==External resources==
* Befreak website
* Befreak implemented in K
Category:Languages Category:Implemented Category:Reversible computing Category:Two-dimensional languages Category:2003
Befreege

Befreege is an Esolang invented by PSTF. You're free to edit this Esolang.
== Requirements for commands ==
# No joke commands
# No uncomputable commands
# Half-width characters only
# Must only 1 character
== Original commands ==
See also Befunge.
== Addition by PSTF ==
 Caption text
Code	Mean
I 	Input a decimal and push it into the stack.
O 	Output the top element of stack as a decimal.
i 	Input a full line of strings and push all of its characters Unicode into the stack until the EOL is read, then push 0.
o 	Output full stack element from bottom to top as an character and then clear the stack.
; 	Jump over the commands between two semicolons.
R 	Reverse the whole stack.
h 	Move the pointer upward, not north.
l 	Move the pointer downward, not south.
' 	Longitudinal IF: Pop a, if a is zero go downward, otherwise go upward.
A 	Push 10.
B 	Push 11.
C 	Push 12.
D 	Push 13.
E 	Push 14.
F 	Push 15.
G 	Push 16.
H 	Push 17.
Ï 	Push 18.
J 	Push 19.
[ 	Turn the pointer to left at 90 degree. For example, When the pointer go to east and encounters this command, it will go south.(Turn on (1, 0, 0))
] 	Turn the pointer to right at 90 degree.
{ 	Roll the pointer to left at 90 degree.(Turn on (0, 1, 0))
} 	Roll the pointer to right at 90 degree.
( 	Flip the pointer to left at 90 degree.(Turn on (0, 0, 1))
) 	Flip the pointer to right at 90 degree.
b 	Bounce back the pointer. For example, when the pointer encounters a b command in the right direction, its direction will be changed to the left.
== Example ==
=== Cat program ===
 io@
=== Hello, world! ===
 > v
 v"Hello World!"<
 >:#,_@
Simpler version: 
 > v
 v"Hello World!"<
 >o@
=== A+B Problem on float ===
 II+O@
== Categories ==
Category:Languages 
Category:Stack-based 
Category:Push-down automata 
Category:Turing complete 
Category:Low-level 
Category:Self-modifying
Category:2024
Befunge/96 and 97

Through some obscure corner of the Wayback Machine, User:BoundedBeans managed to find early specifications for
the Befunge-96 and Funge-97 languages, predecessors of Funge-98.
Befunge-96 spec (a draft, marked "Edit #4"): https://web.archive.org/web/20040221081031/http://www.mines.edu/students/b/bolmstea/mtfi/96.html
Funge-97 spec (dated Oct 31, 1997): https://web.archive.org/web/20031228193410/http://www.mines.edu/students/b/bolmstea/mtfi/f97.html
==Other external resources==
* The original MTFI interpreter site, which links to the above specs
* A github archive of MTFI for Unix to run programs in Befunge-93, Befunge-96, or Funge-97 (up to 7 dimensions!). The link in the description (not README, but the short memo), is where User:BoundedBeans found the MTFI site that led to the original specs.
* Mirror of the above
* MTFI is also available in various dimensions and versions on tio.run.
Category:Languages Category:1996 Category:1997 Category:Two-dimensional languages Category:Stack-based Category:Implemented
Befunge/Constants

:
A Befunge constant is a program or subprogram which computes a specified constant (usually a number).
The constants 0 to 9 are trivial, so they are not shown here.
== 10-19 ==
 10
 5:+
 11
 65+
 12
 6:+
 13
 67+
 14
 7:+
 15
 78+
 16
 8:+
 17
 89+
 18
 9:+
 19
 83*5-
== 20-29 ==
 20
 45*
 21
 73*
 22
 83*2-
 23
 83*1-
 24
 83*
 25
 5:*
 26
 283*+
 27
 39*
 28
 74*
 29
 84*3-
== 30-39 ==
 30
 56*
 31
 84*1-
 32
 84*
 33
 "!"
 34
 "!"1+
 35
 75*
 36
 6:*
 37
 6:*1+
 38
 36:1++*1-
 39
 36:1++*
== 40-49 ==
 40
 58*
 41
 67*1-
 42
 67*
 43
 "+"
 44
 ","
 45
 95*
 46
 "."
 47
 "/"
 48
 "0"
 49
 7:*
== 50-59 ==
 50
 "2"
 51
 389+*
 52
 486*+
 53
 69*1-
 54
 69*
 55
 169*+
 56
 87*
 57
 187*+
 58
 45*9+2*
 59
 5:*2*9+
== 60-69 ==
 60
 562**
 61
 "="
 62
 ">"
 63
 79*
 64
 8:*
 65
 "A"
 66
 "B"
 67
 "C"
 68
 "D"
 69
 "E"
== 70-79 ==
 70
 "F"
 71
 "G"
 72
 "H"
 89*
 73
 "I"
 74
 "J"
 75
 "K"
 76
 "L"
 77
 "M"
 78
 "N"
 79
 "O"
== 80-89 ==
 80
 "P"
 81
 9:*
 82
 "R"
 83
 "S"
 84
 43*7*
 "T"
 85
 "U"
 86
 "V"
 87
 "W"
 88
 "X"
 89
 "Y"
== 90-99 ==
 90
 "Z"
 91
 767+*
 92
 "."2*
 93
 "!"1-3*
 94
 "/"2*
 95
 45*1-5*
 96
 843**
 97
 "a"
 98
 "b"
 99
 "c"
== 100-109 ==
 100
 5:+:*
==External resources==
* BefunRep, a collection of (nearly) optimal Befunge-93-specific constants.
Category:Examples
Befunge/index.php

Befunge/index.php is a language designed by User:ehird in 2010. It is identical to Befunge-93, but with one additional instruction:
* X — Executes the stack as a brainfuck program, where the top of stack is the last character in the program and the bottom of stack the first, encoded in ASCII. When the brainfuck sub-program terminates, so does the program.
==Examples==
===Brainfuck interpreter===
A null character separates program and input.
 >~_X
Category:Languages
Category:Two-dimensional languages
Category:Cell-based
Category:Low-level
Category:Unimplemented
Category:Turing complete
Category:2010
Befunge colored

befunge-colored is a derivative of befunge-93 that has a few changes that allow for more colorful output.
== Changes and Additions to befunge == 
befunge-colored does not add any new commands, however it does change two:
Command	Changes
. 	Output integer - pops format flag, background r value, background g value, background b value, character r value, character g value, character b value, and finally the integer to print.
, 	Output character - Same as above, however prints a character instead of an integer.
befunge-colored's stack is near-infinite in size and holds signed 32-bit integer. It also extends the playfield near-infinitely, with each cell holding an unsigned 8-bit integer.
== Format Flag ==
This value from 0 - 15 determines what effects will be applied on output.
Code 	Effect
0 	No extra effect added.
1 	Output is bold.
2 	Output is italic.
3 	Output is underlined.
4 	Output is strikethrough.
5 	Output is bold and italic.
6 	Output is bold and underlined.
7 	Output is bold and strikethrough.
8 	Output is strikethrough and italic.
9 	Output is strikethrough and underlined.
10 	Output is italic and underlined.
11 	Output is bold, italic, and underlined.
12 	Output is bold, italic, and strikethrough.
13 	Output is bold, underlined, and strikethrough.
14 	Output is italic, underlined, and strikethrough.
15 	Output is bold, italic, underlined, and strikethrough.
Any other number	Treated as 0 and ignored.
== Example programs == 
=== Hello Colorful World ===
Prints "Hello World" in a variety of colors and formats.
 >"!dlrow olleH"55*2*::27*3*::1,v
 v,9000:*53*3*55<
 >54*4*000002,v
 v,*35::*550*5*580<
 >0025*55**:::0,v
 v,000**25*55000<
 >55*52**000002,v
 v,*35::*550*5*580<
 >0025*5*:::0,v
 v,0**2500*55000<
 >0055*9*55*3*::4,@
== External Resources ==
=== Interpreters ===
befunge-colored "official" interpreter for befunge-colored built on rust.
Category:2023 Category:Languages Category:Stack-based Category:Push-down automata Category:Turing complete Category:Two-dimensional languages Category:Implemented Category:Low-level Category:Self-modifying