nyuuzyou/wikis huggingface dataset:
Brainbits

Brainbits is a brainfuck derivative created by Yb1 with 2 fewer commands.
Storing data is different, as the cells can only contain 0 and 1.
== Commands ==
 Commands
Command	Description
\ 	Invert the bit
> 	Go to next cell
< 	Go to prev cell
. 	Output the current cell value to the next 7 cells, with the bits outputted as an ASCII character
, 	Input into current cell, 0 or 1
/ 	If current cell is 0, skip back to last /. First / out of a group of two does nothing.
== Examples ==
===Truth Machine===
 >>\>\>>>>,\/\<<<<<<<.>>>>>>>\/
===Cat program===
According to the specification of this language, this program only accepts zeros and ones.
 >>\>\<<</>>>>>>>,<<<<<<<./
===Hello World!===
The program is generated with Python and has many redundant characters.
>\>>>\>>>><<<<<<<<.>\>>>\>>>><<<<<<<<>\>\>>>\>>\><<<<<<<<.>\>\>>>\>>\><<<<<<<<>\>\>>\>\>>><<<<<<<<.>\>\>>\>\>>><<<<<<<<>\>\>>\>\>>><<<<<<<<.>\>\>>\>\>>><<<<<<<<>\>\>>\>\>\>\><<<<<<<<.>\>\>>\>\>\>\><<<<<<<<>>\>>>>>><<<<<<<<.>>\>>>>>><<<<<<<<>\>>\>>\>\>\><<<<<<<<.>\>>\>>\>\>\><<<<<<<<>\>\>>\>\>\>\><<<<<<<<.>\>\>>\>\>\>\><<<<<<<<>\>\>\>>>\>><<<<<<<<.>\>\>\>>>\>><<<<<<<<>\>\>>\>\>>><<<<<<<<.>\>\>>\>\>>><<<<<<<<>\>\>>>\>>><<<<<<<<.>\>\>>>\>>><<<<<<<<>>\>>>>>\><<<<<<<<.>>\>>>>>\><<<<<<<<
== Computational class ==
Unlike BF, this esolang is not Turing complete because it doesn't have nested loops.
== Interpreter ==
* Interpreter by User:None1.
Category:2023 Category:Cell-based Category:Brainfuck derivatives Category:Implemented
Brainbits+

Brainbits+ is an extension of Brainbits that adds 1 command to make it turing complete. It is invented by User:None1.
== Commands ==
 Commands
Command	Description
\ 	Invert the bit
> 	Go to next cell
< 	Go to prev cell
. 	Output the current cell value to the next 7 cells, with the bits outputted as an ASCII character
, 	Input into current cell, 0 or 1
/ 	BF [ or ]
; 	Toggle whether the next /'s in source code begin or end a loop (like ???'s ') default is begin
==Examples==
===Cat program===
 >>\>\<<</>>>>>>>,<<<<<<<.;/
==Interpreters==
None yet.
==See also==
* brainfuck
* Brainbits
* brainbool
* ???
Category:Languages Category:Brainfuck derivatives Category:Unimplemented Category:Turing complete Category:2024
Brainbrain

Brainbrain is a compiler language invented by User:TehZ, based on brainfuck. Every brainbrain-program is a brainfuck-program which takes the source to be compiled as input, and outputs the compiled source (as brainfuck (or brainbrain) code).
== Examples ==
Brainfuck compiler:
 ,[.,]
The simplest brainfuck compiler ever. (note that if this program is run using a brainfuck interpreter, it is a cat program)
==See also==
*ℒ feels weirdly dual to this.
Category:Joke languages
Category:Languages
Braincinnamon

Braincinnamon is a Branflakes clone, but it's not that obvious. You use a certain amount of "cinnamons", which converts from decimal to base-9 (no 0), with
 Branflakes to base-9
Branflakes	Base-9
< 	1
> 	2
+ 	3
- 	4
. 	5
, 	6
[ 	7
] 	8
being used as the conversion table.
==Shortening==
Instead of using a bunch of cinnamons, you can do this:
 cinnamon(578)
That's right, there could have been 578 cinnamons there, but you can do that!
==Hello World==
 cinnamon(789187643529508)
I know I went the wimpy way, but it's for the safety of your browser and my computer.
Category:Languages
Braincopter

Braincopter is an esoteric programming language that is an almost identical clone of Brainloller designed by Lode Vandevenne in 2005. The commands and the specification are exactly the same as those of Brainloller. The Brainloller interpreter can be converted into a Braincopter interpreter by changing only a few lines of code. Like in Brainloller, the Braincopter source code has to be a PNG image.
While in Brainloller, every command has a fixed color value and all other 16 million colors are a NOP, in Braincopter, the command is obtained by using the formula (65536 * R + 256 * G + B) % 11 (equivalently, (- 2 * R + 3 * G + B) % 11). This means that you can use almost any color to represent the command you want, so it's easy to convert a photo into Braincopter code by, for every pixel, taking the closest color value that gives the right command. The difference between the original photo and the modified photo containing Braincopter code is nearly impossible to spot; thus Braincopter has excellent steganography support and may be used to encode information in images.
Basically, Braincopter is Brainloller, but modified to encode its source code in images.
The translation of the 11 commands into Brainfuck/Brainloller follows.
Command	Function
0 	>
1 	<
2 	
3 	
4 	.
5 	,
6 	[
7 	]
8 	rotate IP to the right
9 	rotate IP to the left
10 	nop
Just like Brainloller, the program halts when the instruction pointer leaves the bounds of the image. 
Since the original interpreter source has been lost, User:Peping has made a new interpreter and a converter from brainfuck to braincopter. This one has since disappeared as well; however, upon being asked, Lode Vandevenne quite courteously re-uploaded the original files.
==See also==
* Brainloller
* Brainfuck
==External resources==
* Original interpreter source code 
* Lost Kingdom Code Example 
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
Category:Cell-based
Category:Non-textual
Category:Two-dimensional languages
Category:Low-level
Category:Turing complete
Category:2005
Category:Steganography
Braincrash

Braincrash is a useless programming language invented by User:TehZ, based on Brainfuck. It is made to only have 2 symbols (or you could call them commands), one of which is no-op, the other execute. It is an example of a turning tarpit.
== So what is it? ==
Basically, it has a "command pointer" (CP, not IP), which is incremented after each command (including no-op). It points to one of the eight BF commands. It is sorted in this way:
 +-><.,[]
The two commands available are " " and "!". " " is a no-op, while "!" executes the command pointed to by CP. After each step, the program increments the CP by one, and "mods" it by eight.
== How am I supposed to write in this language? ==
You aren't, but here is a trick anyway. You start out with a file containing a line filled with "+-><.,[]" like this:
 +-><.,[]+-><.,[]+-><.,[]+-><.,[]+-><.,[]+-><.,[]+-><.,[]+-><.,[](etc)
Then you add a line before that and start pressing space until you are over a BF character you want to use. When you are over one, press "!" and repeat. For example, when writing a cat program, here is the result:
 !! !! !
 +-><.,[]+-><.,[](removed)
Then you remove the second line, and you are finished.
==Examples==
=== Cat ===
 !! !! !
===Hello, World!===
Line feeds aren't part of the program.
 ! ! ! !! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! 
 ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! 
 ! ! ! ! ! !! ! ! ! ! ! ! ! ! ! ! ! ! ! 
 ! ! ! ! ! ! ! !
== Implementation ==
This short Lua script converts braincrash into brainfuck. It treats all characters that aren't "!" as spaces, however:
 io.stdin:read("*line"):gsub("()!", (function(loc) io.stdout:write(("+-><.,[]"):sub((loc-1)%8+1,(loc-1)%8+1)) end))
This is a BRB program that converts Braincrash into Brainfuck:
 ;!+-><.,[];{#%%[^V;@v;>%}#{?Y;®%%v;#]_
This is a Python program that converts Brainfuck into Braincrash
 source = #Your code goes here
 converted = ""
 wheel = [">", "<", "+", "-", ".", ",", "[","]"]
 i=0
 x=0 
 while i < len(source):
 if wheel.count(source[i])<1:
 source = source[:i]+source[i+1:]
 elif wheel[x]==source[i]:
 converted+="!"
 i+=1
 else:
 converted += " "
 x+=1
 if x >= 8:
 x -= 8
 print(converted)
Category:Languages
Category:Turning tarpits
Category:Brainfuck equivalents
Category:Brainfuck derivatives
Category:Turing complete
Category:Turing tarpits
Category:Implemented
Category:2011
Braindead

Braindead is a simple variant Brainfuck, designed to mimic the amount of commands that are present in Deadfish, while still remaining Turing complete and allowing both input and output.
Input is provided as the second argument of the interpreter after the program and stored in the first cell. No Interpreter exists as of yet.
The tape is unbounded in both directions.
==Architecture==
Similar to brainfuck, the program memory resolves to a tape-like arrangement of cells, extending in both directions without limits, with each component storing an unbounded signed integer object that always defaults to zero (0).
Operating on this structure, initially located at the first cell, a marker, known as the cell pointer, selects the currently active cell. The cell pointer, or simply pointer, may be moved by certain Braindead commands.
==Commands==
Command	Description
> 	Move the pointer to the right and increment its memory cell
< 	Move the pointer to the left and decrement its memory cell
/ 	Output the character signified by the cell at the pointer
\ 	Jump to the command signified by the cell at the pointer
===Jumps===
A further deviation from brainfuck's operations, the commands [ and ] have been exchanged for a single \ command, permitting the direct navigation to an instruction in the Braindead program by dereferencing the value of the cell pointed to by the pointer and using it as an zero-based index to resolve to a valid location in the source. It is up to the Implementation to decide how it should respond to a jump instruction violating the possible indices.
==Examples==
===Cat program===
A one-time cat program can be implemented using
 /
User input is expected in the form of the second argument when invoking the interpreter.
==Computational class==
a subset of Brainfuck can be trivially translated to Braindead.
Braindead	brainfuck
> 	>+
< 	<-
/ 	.
\ 	None.
Turing-completeness has not yet been proven.
==Interpreter==
* Common Lisp implementation of the Braindead programming language.
Category:Languages
Category:Brainfuck derivatives
Category:Turing tarpits
Category:Cell-based
Category:Unknown computational class
Category:Implemented
Braindumbed

Braindumbed is esoteric instruction set architecture designed by User:Filexor.
==Language overview==
Braindumbed generally runs with 65536 bits of address space with memory mapped I/O.
Braindumbed has following registers:
name	meaning 	description
C 	Compute 	1 bit long register.
D 	Data 	A register indexed by I. Generally 16 bits long.
I 	Index 	A register used for indexing D. Can represent any position of D (and so generally 4 bits long).
A 	Address 	A register for specifying memory address. Has same length as D.
P 	Program Counter	A program counter points next address of instruction. Has same length as D.
Braindumbed has following instructions:
symbol	code	operation 	Description
a 	001 	C=!(C&D[I]) 	D[I] is I-th bit of D (Starts from 0).
b 	010 	I++ 	
c 	011 	T=D;D=A;A=T 	T is temporal register.
d 	100 	if(C==0){T=A;A=P;P=T}	T is temporal register.
e 	101 	C=$A 	$A is a memory where A specifies.
f 	110 	$A=C 	$A is a memory where A specifies.
g 	000 	NOP 	NOP does nothing.
h 	111 	D[I]=C 	D[I] is I-th bit of D (Starts from 0).
==Examples==
Note: These codes destroy part of D.
===NOT===
 ha
===Load 1 to C===
 haa
===Load 0 to C===
 haaha
From following, b(n) represents repeat b n-times.
And I represents initial state of I.
===Move D[I] to C===
D[J] will be destroyed.
 b(J-I)haab(I-J)ab(J-I)ha
===AND===
D[J] will be destroyed.
 ab(J-I)ha
===OR===
D[J] and D[K] will be destroyed.
 b(J-I)hah
 b(K-J)haab(I-K)ab(K-I)ha
 b(I-K)ab(J-I)a
===Half-adder or XOR===
D[K] and D[L] will be destroyed.
D[M]=D[I]&D[J] (carry)
 b(K-I)haab(I-K)ab(K-I)ha
 b(J-K)ab(K-J)h
 b(I-K)ab(L-I)h
 b(M-L)haab(K-M)ab(M-K)ha
 b(J-M)ab(L-J)a
==Usability==
Because of code inefficiently (Just loading 16-bit data take more than 30720-bit of ROM), with default configuration, this ISA can be considered as unusable for programming. However, with larger register size, this ISA may be usable for programming (need verification).
Category:2020
Category:Languages
Category:Low-level
Category:Usability unknown
Category:Unknown computational class
Category:Unimplemented
Braine

Braine is an esoteric programming language invented by User:A, operating on a scalar byte value whose state serves as a guard for conditional jump operations.
== Instructions ==
+ 	Increment the current byte. Overflows to 0 when 255.
s:n	Check if the current byte is equal to s. If so, go to line n. The enumeration of lines commences with the index one (1).
==Examples==
===Jump Once If Equals Two===
This program increments the current byte twice to a value of two (2), jumps to the start of the program based on this state, subsequently increments the octet to four (4), and, as a corollary, skips the goto instruction during the second encounter:
 ++
 2:1
==Interpreter==
* Common Lisp implementation of the Braine programming language.
Category:Languages
Category:Finite state automata
Category:2018
Category:Implemented
Brainf***-

BrainF***- is a BrainF*** derivative that has two more instructions:
== Commands ==
Command	Operation
_ 	Subtracts the current cell from the ce-pointer-plus-oneth cell.
) 	Inverts the current cell, from 0 → 1+ / 1+ → 0.
This lets you compare chars easily:
 +++++++++++++[>+++++<-],_[{if not}])[{if}]
It also allows for else-if by subtracting, doing a linz (loop if not zero) and inverting a value.
== Examples ==
=== Cat program ===
Set the first cell to be the exit value, for example, 65.
 +[>,.<_]
=== Truth Machine ===
Get input, if it's not A, loop. Else, print A a lot of times.
 +++++++++++++[>+++++<-]>>,<_>[].)[.]
==Interpreter==
* Common Lisp implementation of the BrainF***- programming language.
Category:Languages Category:Brainfuck derivatives Category:2020 Category:Implemented Category:Low-level Category:Turing complete Category:Cell-based
BrainfXX

BrainfXX is an esolang, or a family of 256 brainfuck subsets, invented by User:None1.
==Commands==
The name of each language is Brainf00 to BrainfFF, the last 2 characters are hex digits. When converted to binary, each digit means whether the corresponding bf command 
(0th,1st,2nd,3rd,4th,5th,6th,7th digits counting from the ones digit represent whether the +-><,.[] commands are usable, respectively) is usable. For example, in Brainf01, only the + command is usable, in BrainfBF, the [ command is unusable. Unusable commands are NOPs when executed.
==Equivalents to other languages==
Some members in this family are equivalent to other languages on this wiki:
* Brainf00=Nil/APLWSI
* Brainf01=+
* Brainf21=PlusOrOutput
* Brainf23=BittyLang
* BrainfFF=brainfuck
==Interpreter in Python==
By User:None1:
import sys
def bf(code,member_id): # Member ID: 2 hex digits, XX interprets BrainfXX member
 s1=[]
 s2=[]
 matches={}
 tape=[0]*1000000
 k='+-><,.[]'
 member_id=int(member_id,16)
 for i in range(8):
 if not(member_id&(1<':
 p+=1
 if code[cp]=='[':
 if not tape[p]:
 cp=matches[cp]
 if code[cp]==']':
 if tape[p]:
 cp=matches[cp]
 cp+=1
bf(sys.stdin.read(),'21') # Brainf21
==See also==
* BrainXXXXXXXXXXx
Category:Languages
Category:Meta-languages
Category:Brainfuck derivatives
Category:2024
Category:Implemented
Brainf ck

Brainf*ck is an esolang invented by User:None1. Its goal is to be an esolang that is named brainf*ck but different from brainfuck. Its programs look like brainfuck programs, but they're not.
==Memory==
It uses a stack, containing wrapping bytes.
==Commands==
Command 	Meaning
+ 	Return 1
- 	Return top of stack and pop
, 	Read input as ASCII and return
. 	Print top of stack as ASCII
>[xyz...]<	Push and return the sum of x,y,z...
[CODE] 	While top of stack is nonempty and nonzero, do CODE, return 0
==Examples==
===Hello, World!===
>[++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<.>[+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<.>[++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<.>[++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<.>[+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<.>[++++++++++++++++++++++++++++++++++++++++++++]<.>[++++++++++++++++++++++++++++++++]<.>[+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<.>[+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<.>[++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<.>[++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<.>[++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<.>[+++++++++++++++++++++++++++++++++]<.
===Cat program===
 >[+]<[>[,]<.]
===Truth machine===
>[,]<.>[-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<[>[-++++++++++++++++++++++++++++++++++++++++++++++++]<.>[-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<]
===A+B Problem===
>[,,,++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]<>[.]<
Only supports adding one-digit numbers, numbers have to be separated by exactly one space:
 Input: 1 2
 Output: 3
==External Resources==
* Python interpreter
==See also==
* Brainfuck
* Brain-Flak
Category:Languages
Category:Brainfuck derivatives
Category:Stack-based
Category:2024
Category:Unknown computational class
Category:Implemented
Brainf with functions

BF commands are same, but I added two.
 :
This defines a function. The symbol before it is the command that calls the function anywhere after the function, and ; closes it.
==Examples==
===Cat===
 n:,.;+[n]
===HIWORLD===
 o:++++++++;j:[-];c:[<+>-]<;f:++++++[>o++<-]>c;f>f>f>f>f>f>f<<<<<<++.>+++.>oo+.>o+.>o++++.>++++++.>--.
Category:Brainfuck derivativesCategory:2023Category:Turing completeCategory:Languages
Brainfact

This language is similar to Brainfuck, but with a twist. This language was created by User:Poolala.
If you put >'s, <'s, +'s or -'s in a row, the interpreter counts how many there are next to each other, calculates the factorial of that number, and runs the operation that number of times.
i.e. >>>> would move right 24 times, since the factorial of 4 is 24.
Also, loops are removed and replaced with a goto operation, (@) which takes the current cell, gets the factorial of the cell, and jumps to that character in the source.
i.e. +++@(...) would jump to the 720th character.
This twist makes it (more) difficult to program in this language.
Other than loops being replaced by a goto operation, this language has the exact same instruction set as brainfuck.
==Turing completeness==
This language is probably Turing complete, as you could move once, add once, move once, add once, so the factorials don't mess things up, although it would be difficult to make a loop this way.
==Interpreter notes==
Each cell must hold a bignum value, so the factorials don't cause an overflow.
Any character that isn't a defined operation is a no-op.
Category:2013
Category:Languages
Category:Brainfuck derivatives
Category:Cell-based
Brainfffffuck

Brainfffffuck is an Esolang designed by User:Hsxiaobai
== Introduction ==
Brainfffffuck is an Esolang inspired by Brainfuck.
== Syntax ==
Eight instructions, the same as Brainfuck:
 ,.+-<>[]
The difference is, Brainfffffuck will change the source code after running an instruction.
The source will change according to these rules:
 1. Swap the two instructions after the instruction now. If the instruction now is the last two instructions, don't do anything.
 2. Replace according to the pattern in the "RP"(Replace Pattern).
 3. Set the pattern(string to replace) in the "RP" as the last character and the replacement in the "RP" as the next character. If the instruction is already the last or the first, don't do anything.
 4. Replace all the instructions according to the Replacement list:
 Pattern Replacement
 , .
 . +
 + -
 - <
 < >
 > [
 [ ]
 ] ,
 The replacement will take place at the same time.
Category:Languages
Category:Turing complete
Category:2025
BrainfisHQ9+

BrainfisHQ9+ is a programming language created in 2020 by User:Dtuser1337 that merges Brainfuck with Deadfish and HQ9+.
Unlike Deadfish and HQ9+, it is tape based and does not follow deadfish tradition of setting cells value to 0 if value == -1 || value == 256.
BrainfisHQ9+ is backward compatible with brainfuck and hq9+ as well as being able to run some Deadfish programs.
==Commands==
Command	Description
> 	Move the pointer to the right
< 	Move the pointer to the left
+ i I 	Increment the memory cell under the pointer
- d D 	Decrement the memory cell under the pointer
s S 	Squares the memory cell under the pointer
. o O 	Output the character signified by the cell at the pointer
, 	Input a character and store it in the cell at the pointer
[ 	Jump past the matching ] if the cell under the pointer is 0
] 	Jump back to the matching [ if the cell under the pointer is nonzero
h H 	Output "Hello, World"
9 	Output the lyrics to "99 Bottles of Beer"
q Q 	Output the program source code or quine.
==See also==
* FISHQ9+
==Interpreter==
Interpreter by User:ArthroStar11 written in C++
Category:Languages
Category:2020
Category:Brainfuck derivatives
Category:Turing complete
Category:Implemented
Category:Turing tarpits
Brainfish

Brainfish is a cross between Brainf*ck and Deadfish.
==Commands==
The brackets ([ and ]) from brainf*ck work the same, and the comma (,) and dot (.) from brainf*ck also work the same, and the < and >, but no other commands from brainf*ck work. Every command from Deadfish works, but on the cell at pointer.
An aperçu shall present all available facilities:
Command	Description 	Provenance
[ 	If the current cell value equals 0, move past the matching ] 	brainf*ck
] 	If the current cell value does not equal 0, move past the matching [ 	brainf*ck
> 	Move the cell pointer one step to the right 	brainf*ck
< 	Move the cell pointer one step to the left 	brainf*ck
, 	Query the standard input for a character and store its ASCII code in the current cell	brainf*ck
. 	Output the character whose ASCII code matches the current cell value 	brainf*ck
i 	Increment the current cell value 	Deadfish
d 	Decrement the current cell value 	Deadfish
s 	Square the current cell value 	Deadfish
o 	Output the current cell value in its verbatim numeric form 	Deadfish
==Examples==
===Cat===
This cat program queries the user for a character and prints its ASCII code:
 ,o
===Infinite cat===
An infinite cat program, the same terminates on a user input of the null character, assumes the following form:
 i[,.]
===hi===
 >>>iiiiiiiiii[<<<iiiii[>ii<d][d]>[d>i<]>>d]<iiii.i.
==Interpreter==
* Common Lisp implementation of the Brainfish programming language.
Category:LanguagesCategory:Implemented
Brainflick

Brainflick is a modified BrainF with improved maths support. First of all, decimals are now supported!
== New BrainFlick Commands ==
 a
Command 	Description
* 	Multiply the current cell by the cell next to it
/ 	Divide the current cell by the cell next to it
π{digits}	Set the current cell to pi of {digits} digits
﬩ 	"+" in BrainF but half
﹣ 	"-" in BrainF but half
﹥ 	If wrapping is not enabled and limited stack size is enabled, goes to the last item of the stack. Otherwise, does nothing.
﹤ 	If wrapping is not enabled and limited stack size is enabled, goes to the first item of the stack. Otherwise, does nothing.
ℝ 	Sets cell mode to real numbers
i 	Sets cell mode to imaginary numbers
: 	If the current cell is positive, turn it negative. If the current cell is negative, turn it positive.
Category:Languages Category:2024 Category:Brainfuck derivatives Category:Cell-based Category:Unimplemented