nyuuzyou/wikis huggingface dataset:
Bitfuck

Bitfuck is a boolfuck equivalent with only 4 characters. It is similar to RISBF, but operating only on bits.
==Commands==
Bitfuck's state as a Boolfuck derivative conditions a parity in the tally, albeit not the designation, of both command sets. A listing and juxtaposition shall thus be provided below.
Command	Description 	Boolfuck equivalent
* 	Toggle bit 	+
< 	Move pointer left 	<
> 	Move pointer right 	>
! 	Start of the following two-character sequence commands:	 
!! 	Output bit at pointer 	;
!* 	Input bit at pointer 	,
!< 	Jump past the matching !> if bit at pointer is 0 	[
!> 	Jump back to the matching !< 	]
==Examples==
===Hello, world!===
This program prints the text “Hello, world!”:
 !!!!!!*!!*!!!!*!!*!!
 *!!*!!*!!*!!!!*!!!!*!!
 !!!!*!!!!*!!*!!!!*!!
 !!!!*!!!!*!!*!!!!*!!
 *!!!!!!!!*!!*!!!!*!!
 !!!!*!!!!*!!*!!*!!!!
 !!!!!!!!!!*!!*!!!!
 *!!!!!!*!!*!!!!!!*!!
 *!!!!!!!!*!!*!!!!*!!
 !!*!!*!!!!*!!!!!!*!!
 !!!!*!!!!*!!*!!!!*!!
 !!!!*!!*!!!!*!!!!*!!
 *!!*!!!!!!!!*!!*!!!!
 !!*!!*!!*!!
===Cat program===
The following program implements an infinitely repeating cat program:
 * !< > !* !! !* !! !* !! !* !! !* !! !* !! !* !! !* !! < !>
==See also==
Other languages operating on bits (implemented only):
* FlipJump
* BIT
* BoolX
* Bitch
* Boolfuck
* BitChanger
* Bitter
* Boolet
* BitBitJump
* Smallfuck
==Interpreter==
* Common Lisp implementation of the Bitfuck programming language.
Category:Languages
Category:Cell-based
Category:Low-level
Category:Turing complete
Category:Turing tarpits
Category:Brainfuck derivatives
Category:2013
Category:Implemented
Bitfuckery

This page is still a work in progress!!!
Bitfuckery operates using a single bitwise instruction for all computations. All code is written in hexadecimal and any attempts to not write Bitfuckery in hexadecimal will result in being forced to read my bit manipulation java code. 
==Language overview==
Standard Bitfuckery operates on an array of 2^16 cells one byte in size. The code is self-modifying to allow for indirect addressing. Data and code are stored in the same memory GLHF
The program MUST start with 0x00 counting up to 0xFF. If this condition is not met the bee movie script will be printed to the console and execution will halt. 
The program counter starts at 0x000100 and increments by 3 every step. 
registers are denoted with &" " and memory addresses are denoted with *" "
Command 	Alias (? is replaced with an argument in hexadecimal) 	Description
0btttt,0rrr,xxxx,xxxx,xxxx,xxxx	BIT(?, ?)[????] (second argument must be in the range of 0x0 to 0x7 inclusive)	performs a bitwise operation on &a and &b with a truth table defined in "t" and a rotate by "r" bits and puts the result into &c. If result is not zero jump to *"x"
0b&a&b,10&c,xxxx,xxxx,xxxx,xxxx	ARG(?, ?)[????] (second argument must be in the range of 0x8 to 0xb inclusive)	set registers to be used for bitwise operations and jump to *"x" unconditionally
0b--&a,1110,xxxx,xxxx,xxxx,xxxx	READ(?, 0xe)[????] 	read from memory at *"x" to &"a"
0b--&a,1111,xxxx,xxxx,xxxx,xxxx	STOR(?, 0xe)[????] 	write from &"a" to memory at *"x"
0b1111,1111,1111,1111,1111,1110	DUMP(fffffe) 	dumps memory to console (can be used for memory-mapped I/O)
0b1111,1111,1111,1111,1111,1111	RICK(ffffff) 	prints the lyrics to Rick Astley's "Never Gonna Give You Up" to the console and halts execution
Memory-mapped I/O starts at 0x8000 with 256 bytes for input ending at 0x80FF inclusive and 256 bytes for output stating at 0x8100 and ending at 0x81FF inclusive.
Dumping memory to console causes memory-mapped output to be sent to an output device (must be capable of playing Bad Apple).
Category:Self-modifying Category:2024 Category:Cell-based Category:Turing complete Category:Works-in-Progress Category:Unimplemented
Bitshit

Bitshit is a programming language that can only work in bits. It follows very simple rules: A character followed by a bit will set a variable to the value of the bit. Variable names cannot be longer than a character, and there must not be any spaces. Anything after the declaration/assignment on a line is classed as a comment. You can download an interpreter here.
==Instructions==
00	define 0 = 0 and 1 = 1 makes it so that we can use these values
11
+ A line starting with a plus is a comment
a0	set the value of a to 0, or create it with 0 if it doesn't already exist
b1	set the value of b to 1, or create it with 1 if it doesn't already exist
c:a=b	compare a equals b, placing the result in c
d:c!b	compare c not equal b, placing the result in b
e:c&b	compare c and b both equal 1, placing the result in e
f:c|b	compare c or b equal 1, placing the result in f
[c]	anything between [ and ] gets its value printed to the screen
A,	a character followed by a comma will take input (either 1 or 0) and place it in the variable
[A]	print the input from before
==External resources==
* An interpreter on GitHub
Category:Languages Category:Total Category:Finite state automata Category:Unusable for programming Category:Implemented Category:2020 Category:Low-level
BittyLang

BittyLang is an esolang prompted by User:None1 and generated by the Cursor AI:
==Commands==
+ Increment the byte's value by 1.
- Decrement the byte's value by 1.
. Output the ASCII character corresponding to the current byte's value.
==Examples==
===Hello, World!===
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.------.--------.-------------------------------------------------------------------.
===Output E===
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
===Print 222===
 ++++++++++++++++++++++++++++++++++++++++++++++++++...
This program is written by User:None1 himself, it is created since this is User:None1's 222nd esolang.
==Interpreter in Python==
def bitty_lang_interpreter(code):
 """
 A simple interpreter for BittyLang.
 
 Parameters:
 - code: A string containing the BittyLang code to execute.
 """
 # Initialize the byte to 0.
 byte = 0
 
 # Iterate through each character in the code.
 for char in code:
 if char == '+':
 # Increment the byte, ensuring it wraps from 255 to 0.
 byte = (byte + 1) % 256
 elif char == '-':
 # Decrement the byte, ensuring it wraps from 0 to 255.
 byte = (byte - 1) % 256
 elif char == '.':
 # Output the ASCII character corresponding to the current byte value.
 print(chr(byte), end=)
 else:
 # Ignore any other characters.
 continue
Category:Languages
Category:2024
Category:Implemented
Category:Total
Category:Accumulator-based
Category:Brainfuck derivatives
Category:Generated by AI
Category:Esoteric subset
Bitwise

Bitwise is an Assembly-based esolang, created by a sleep-deprived User:MD XF.
= Commands =
| command | arguments | description |
-----------------------------------------------------------------------------------------------------------
| IN | 3 | read a character into arg1 if arg2 nonzero, store result in arg3 |
| OUT | 3 | print arg1 as ASCII if arg2 nonzero, store result in arg3 |
| AND | 3 | compute bitwise AND of arg1 and arg2, store result in arg3 |
| OR | 3 | compute bitwise OR of arg1 and arg2, store result in arg3 |
| XOR | 3 | compute bitwise EXCLUSIVE OR of arg1 and arg2, store result in arg3 |
| SL | 3 | shift arg1 left by arg2 places, store result in arg3 |
| SR | 3 | shift arg1 right by arg2 places, store result in arg3 |
| LSR | 3 | logical-shift arg1 right by arg2 places, store result in arg3 |
| MOV | 3 | move arg2 into arg1 if arg3 is nonzero |
| JMP | 2 | jump arg1 lines in the code (or to the point in label arg1) if arg2 nonzero |
| NOT | 2 | compute logical NOT of arg1, store result in arg2 |
| LABEL | 1 | create label with name arg1 at current point |
| FRAME | 0 | new application frame |
| DEFRAME | 0 | back to previous application frame |
= Syntax =
COMMAND ARG1 ARG2 ARG3
Argument types:
* 1 - register 1
* &1 - literal 1
* *1 - frame register 1
* @1 - label 1
* -1 - immediately discarded 1
= Functions =
.FUNC_NAME:
....
RET RETURN_VALUE
Call as you would any builtin function.
= Notes =
JMP functionality:
| arg1 | description |
| -1 | re-reads current line |
| 0 | exits |
| 1 | skips next line |
FRAME and DEFRAME create a new set of temporary registers, called “frame registers”. So this code:
MOV *1 &48 &1
FRAME
MOV *1 &49 &1
OUT *1 &1
DEFRAME
OUT *1 &1
will print 10, while this code:
MOV *1 &48 &1
MOV *1 &49 &1
OUT *1 &1
OUT *1 &1
will print 11.
Category:Languages
Category:Low-level
Bitwise Scanner

Bitwise Scanner is a bitwise language created by User:A. It is based on scanning a bitwise tape.
=Commands=
Command 	Description
(statements)	Execute the code block composed of the statements if the current bit is 0.
{statements}	Execute the code block composed of the statements if the current bit is 1.
[statements]	Sequentially query the bitwise tape, from the lowest digit to the highest digit, executing the statements.
~ 	Multiply the current bit by -1 and add 1. Equivalent to flipping the bit.
X 	Stop the scanning.
=The increment procedure=
000->001
001->010
010->011
011->100
We can conclude that the algorithm is(without doing math):
If the lowest digit is zero,
 Flip the lowest bit
Otherwise(if the lowest bit is 1),
 scan from the lowest digit to the highest digit:
 If the current bit is 1,
 flip this bit
 Otherwise (current bit is 0)
 flip this bit and stop scanning
This can be achieved in Bitwise Scanner like this:
(~){[{~}(~X)]}
=The decrement procedure=
111->110
110->101
101->100
100->011
011->010
010->001
The main algorithm for this is:
If the lowest bit is 1:
 Flip the lowest bit
Otherwise(if the lowest bit is 0):
 Scan the binary array:
 If the current bit is 0:
 Flip the current bit
 Otherwise:
 Flip the current bit and stop scanning
This can be achieved as:
{~}([(~){~X}])
=Computational Class=
This language is not Turing complete, or even FSM complete, as it cannot store state from bit to bit. Consider, for example, a program that sets every bit to the previous bit's value. This would be impossible to do in Bitwise Scanner.
==Interpreter==
* Common Lisp implementation of the Bitwise Scanner programming language.
Category:Languages
Category:2019
Category:Low-level
Category:Implemented
Category:Unknown computational class
Category:No IO
Bitxtreme

Bitxtreme is a joke language made by Pedro Gimeno Fortea based on BIT and OISC. Starting from the concept that everything is a bit, it pushes that concept to the extreme by eliminating the address-of-a-bit type present in BIT, thus making every possible address just one bit long, so no addresses but the first two ones are reachable. There are just four possible functionally different programs that can be written in this language. Input/output is done using special reserved addresses which, quite unsurprisingly, are addresses 1 and 0 respectively.
==External resources==
* Language specification, examples and interpreter
Category:Joke languages
Category:Unusable for programming
Category:Implemented
Category:Low-level
Category:Unknown year
Category:Languages
Category:Finite state automata
Category:OISC
Bit~

bit~ is a language made by User:RealUndefined, in May 2019. It is a cell-based language that uses bits to store information.
== Commands ==
Command	Instruction
~ 	Flip the current bit of the data pointer.
> 	Move the data pointer to the right.
< 	Move the data pointer to the left.
) 	Get the input as character and flip the current bit and the next 7 bits of the data pointer, according to the ASCII character code in binary.
( 	Output the character by looking at the current bit and the next 7 bits of the data pointer.
{ ... }	Skip the block of command if the current bit of the data pointer is 0, otherwise, do the following commands while current bit of the data pointer isn't 0.
== Implementations ==
A Ruby interpreter by User:Bangyen.
Category:2019
Category:Implemented
Category:Cell-based
Category:Languages
BizzFuzz

BizzFuzz is a soda program form.
== How it works ==
Bizz 5 times, then Fuzz. The third time a Fuzz is said, a BizzFuzz is said instead
== BizzFuzz up to 36 ==
 bizz
 bizz
 bizz
 bizz
 bizz
 fuzz
 bizz
 bizz
 bizz
 bizz
 bizz
 fuzz
 bizz
 bizz
 bizz
 bizz
 bizz
 bizzfuzz
 bizz
 bizz
 bizz
 bizz
 bizz
 fuzz
 bizz
 bizz
 bizz
 bizz
 bizz
 fuzz
 bizz
 bizz
 bizz
 bizz
 bizz
 bizzfuzz
==Implementations==
===Funge-98===
" :tnuoc retnE"ck,&00p1>:00g`#v_ :92*%!#v_:6%! #v_"zz" v
 ^ +1@<j2,a,k3;#,k3"bizzfuzz"<;"fuzz"<j7"bi"<
==See also==
* FizzBuzz
Category:Program forms
Blablafuck

Blablafuck is an esoteric language based on Extended Brainfuck, in which commands are most used english words.
==Commands==
Extended Brainfuck Command	Word
> 	the
< 	of
+ 	and
- 	to
. 	a
, 	in
[ 	for
] 	is
@ 	on
$ 	that
! 	by
} 	this
{ 	with
~ 	i
^ 	you
& 	it
 	not
? 	or
) 	be
( 	are
* 	from
/ 	at
= 	as
_ 	your
% 	all
X 	have
x 	new
M 	more
m 	an
L 	was
l 	we
: 	will
0 	home
1 	can
2 	us
3 	about
4 	if
5 	page
6 	my
7 	has
8 	search
9 	free
A 	but
B 	our
C 	one
D 	other
E 	do
F 	no
# 	information/info
Dots at the end and capitals at the start are mandatory.
==Hello World==
Extended Brainfuck 3 Hello World code:
 >5--------.7-----------.+++++++..+++.<2.5+++++++.>.+++.------.--------.2+.
Is equivalent to:
 The page to to to to to to to to a has and and and and and and and a a and and and a of us a page and and and and and and and a the a and and and a to to to to to to a to to to to to to to to a us and a.
==Compiler to Extended Brainfuck==
 def bbf_to_ebf(code):
 assert code[0].isupper() and code[1:-1].islower() and code[-1] == ".", "SyntaxError"
 code = code[:-1].lower()
 _s = ">the <of +and -to .a ,in [for ]is @on $that !by }this {with ~i ^you &it |not ?or )be (are *from /at =as _your %all Xhave xnew Mmore man Lwas lwe :will 0home 1can 2us 3about 4if 5page 6my 7has 8search 9free Abut Bour Cone Dother Edo Fno #information #info"
 cm = {s[1:]: s[0] for s in _s.split()}
 r = ""
 for w in code.split():
 r += cm.get(w, "")
==See also==
* Extended Brainfuck
Category:Languages Category:Brainfuck derivatives Category:Turing complete Category:Implemented
Black Pentagon

== Introduction ==
 is an esolang which uses pictures of pentagons to write your programs, and BP for short.
== Order of Program ==
From left to right and up to down.
== The Meanings of Different Pentagons ==
* A white pentagon with a black frame - Input an integer. 
* A white pentagon with a blue frame, a condition writen on it. - If the condition is true, do the operations in the box made of four small pentagons (two blue ones in the left and two green ines in the right(with black frames)). 
* A red pentagon without a frame, an integer written on it. - Repeat the operations in the box made of four small pentagons (two blue ones in the left and two green ines in the right(with black frames)) for the integer times. 
* A purple pentagon without a frame, a box just like the above inside it. - Repeat the operations forever.
* A white pentagon with a orange frame, an integer written on it. - Change the integer to a char base on Unicode.
* A orange pentagon with a black frame, a char written on it. - Change the char to an integer base on Unicode.
* A black pentagon but up side down - Break a loop.
* A white pentagon with a black frame but up side down, an integer or a char written on it - Output the integer/char.
* A black pentagon - End of the programme.
== Variables and Comparison ==
=== Variables ===
* Any small up-side-down pentagon can be a variable.
* Use = to give a value.
=== Comparison ===
* Equal(=): Two small red pentagons not completely overlapping (with black frame).
* Greater than(>): A small grey pentagon (with black frame).
* Less than(<): A small black pentagon with a red frame.
* Or: A small yellow pentagon (with black frame).
* And: A small pink pentagon (with black frame).
* Not: Not yet.
== Example ==
=== Hello, World! ===
=== Truth Machine ===
=== Factorial Calculator ===
Note that this uses uninplemented functions such as arithmetic operations and use of variables instead of integers.
Category:Languages Category:Unimplemented Category:Non-textual
Blackberry

It Is a programming language that is stack-based, imperative and long-liner. And I wrote this article from my BB 8520.
= Instructions =
Instructions is base of Blackberry.
== Stack ==
Stack related instructions.
=== Push/Pop ===
Push: Pushes data to stack.
Pop: Pops data from stack to variable.
=== Purge/Discard ===
Discard: Pops (removes) data from stack.
Purge: Same with Discard, but clears entire stack.
=== Dupe/Swap ===
Dupe: Duplicates top of the stack.
Swap: Swaps places of top 2 elements of stack.
== Standard IO ==
Input/Output related instructions.
=== StdIn/Out ===
COut: Writes to console.
CIn: Reads from console to variable.
=== FileIn/Out ===
FOut: Writes to file.
FSet: Sets specific variable to handle to that file.
FClose: Closes specified handle
FIn: Reads from file to variable.
FAvail: Pushes 1 if not error occurred, 0 otherwise.
=== SocketIn/Out ===
SSet: Creates a socket with specified protocols.
SConnect: Connects specified socket to specified address.
SAvail: If not error occurred, this pushes 1.
SIn: Reads socket.
SOut: Writes to socket.
= Samples =
There's samples.
== Hello world ==
 COut "Hello, World!"
Category:Stack-based Category:Languages
Blackboard

Blackboard is a esolang crated by User:Yayimhere based on RECT4n=GLE, ///, Thue, and Lambda calculus
== semantics ==
the program is set up in two sections(separated by % on a single line). one the left side there are replacements set up like this:
 x | y:z | d: ect...
in this we replace x with y, and the same with z and d. what we replace in is in the second section which is a string that can only hold 256 chars. we apply the rules left to right and only once. now we make the rectangle. we generate it like this:
* apply replacements
* every char that was deleted is added to the rectangle where its width is fixed(its equal to 9) starting with the one deleted the nearest to index 0
* apply the rectangle interpreter to that rectangle
=== the rectangle interpreter ===
find every tiling like in RECT4n=GLE and then sort them then deletes the second section and replaces it like this:
* take the top line of the sorted rectangle
* then add the second one
* do this until the length of the second section is equal to 256
thats the rectangle interpreter. the program halts if the rectangle is empty. else it will be interpreted as a Blackboard program
Blackbox

Blackbox is a language created by User:CenTdemeern1 as a "Black box challenge" where only part of the documentation will be provided, and it's up to the community to figure out the rest.
The currently known rules and details for the challenge are:
* Decompilation of the provided interpreter (written in C, stripped of symbols, platform-independent) is not allowed, at least for a (short) while after the challenge starts.
* All the names of the commands in the instruction set will be provided at the start of the challenge
* A few commands will have explanations and example code
* Hints will be given over the course of the challenge
* Brute forcing will be allowed
And since I don't think anyone should inherently trust me you can of course run it in a VM
— CenTdemeern1 (12/02/2021)
(More details and the interpreter will be published soon when the challenge starts!)
Blackspace

Blackspace is an esoteric programming language invented by User:A completely based on the old-fashioned control characters that allows writing mathematical expressions quite easily. Currently this page is a placeholder.
• Takes implicit input
²２²１+π*½*Ｃ½/↓ • or ²２²１+∏₂Ｌ/↓
• ２ Put all items above the original second top of the stack to the other stack
• １ Put all items above the original first top of the stack to the other stack
• ² Square the top of the stack
• + Addition
• π Pi
• ½ Multiply by 0.5
• Ｃ 100
• * Multiply
• / Divide
• ↓ Floor
• ↑ Ceiling
• - Subtract
• ∏ Multiply by Pi
• Ｌ 50
• Ｘ 10
• Equality: ↔
ｄｎ
• ｄ Convert to decimal
• ｎ Escape a newline after converting to same type
• Implicit output
• | Modulo
• Ｐ Prime checking
•（）Indicate a code block
Condensed:
²２²１+∏₂Ｌ/↓ｄｎ
Is it a leap year?
4:²３5²÷?÷!
Digital Root Calculator
≺9|≻
There is a string that only contains the character 'a'. The operator can append an arbitary substring of the previous string to the end of the string. Return at least how many operations that the operator needs in order to get to the length specified by the input. 
2㏒÷↑
μ Multiples less than the square of a number
× Power of
｜ Absolute value
㏒ Logarithm 1st-top of stack by 2nd-top of stack
√ Root operator. The top of the stack indicates how many roots should be done.
a.k.a. 1n/×
≺ Decrement by 1
≻ Increment by 1
@ Trigonometry Operations:
sin: 1
cos: 2
tan: 3
asin: -1
acos: -2
atan: -3
Category:2019
Category:Languages
Category:Unimplemented
Category:Stack-based
Blah

Blah is a very funny esolang that doesn't even make sense, created by User:None1.
==Execution==
Blah has no input.
If the code is exactly ^, print 20 ^'s
If the code is exactly v, print 20 v's
If the code is exactly <, print 20 <'s
If the code is exactly >, print 20 >'s
If the code is not any of them, print 20 Blah!'s
==Implementations==
===Python===
 import sys
 l=list("<>^v")
 code=sys.stdin.read()
 if code in l:
 print(code*20)
 else:
 print("Blah!"*20)
===C===
#include<stdio.h>
int main(){
 char a,b;
 a=getchar();
 b=getchar();
 if(b==EOF&&(a=='^'||a=='v'||a=='<'||a=='>')){
 for(int i=1;i<=20;i++) putchar(a);
 return 0;
 }
 for(int i=1;i<=20;i++) printf("Blah!");
 return 0;
}
==Example Programs==
code:
 ^
output:
 ^^^^^^^^^^^^^^^^^^^^
==Quine==
Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah!
This is obviously the only quine in Blah, no proof is needed.
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Implemented
Category:Output only
Category:2023
Category:Total
Blainbuk

Blainbuk is an esolang that golfs brainfuck created by User:Ractangle
==Commands==
Command	It's action
"..." 	String literal
. 	Print the TOS
, 	Take chat input
: 	Same as the . command but it prints the top value of the stack as a number
m 	moves the first item on the stack to the top
0-9 	Pushes the number that the cursor is currently pointing at
^ 	Ends program
[ 	The Brainfuck loop command (if the current element at the top is zero or if the stack is empty, jump to )
; 	Same thing as the , command but stores the input as a number
+ 	Takes two cells, adds the together and pops the unoperated element
- 	Same thing as the + command but does suntraction instead
= 	Duplicates the top of the element on the stack
~ 	Pop the TOS and set's the proper to the popped TOS
==Examples==
===Hello, world!===
 "Hello, world!".^
===Truth-machine===
 ;[:]^
Category:Languages
Category:Golfing language
Category:Brainfuck derivatives
Category:Unimplemented
Category:Stack-based
Blast protection

blast protection is an esolang based on obsidian and tnt.
== blocks ==
 o obsidian
 r red tnt
 b blue tnt
 w wooden planks
 c cobblestone
 d dirt
 g glass
 # bedrock
 % glitch block
the tnt blows up to the right always
== how the blocks interact ==
the blocks interact to make a brainfuck clone.
here is a table of the brainfuck commands
 rwcdgowcdg
 +-<>
 bwcdgowcdg
 .,[]
or if we rotate it and make it a table,
 rb
 w+.
 c-,
 d<[
 g>]
the obsidian stops the tnt from going any further
the bedrock makes the tnt turn right.
 w
 r #
 c
here, - gets activated instead of +
the glitch block glitches and makes the tnt head backwards
 rw%
is "++" in brainfuck
this is because the bedrock makes the tnt turn right instead of left.
also, all the tnt get activated when the program starts, but each one takes one turn per move, so these
 rw
 r c
wouldnt have + and - happening at the same time, it would be like running "+-" in brainfuck
== ascii loop ==
 %rw %
 %b w%
Category:Languages Category:Brainfuck derivatives