nyuuzyou/wikis huggingface dataset:
BrainCurses

BrainCurses is a language derived from Brainfuck, using a deque instead of a tape for memory. Its name comes from the fact that programs usually resemble censored swearing in cartoons such as #@!*&@^!.
== Overview ==
BrainCurses programs have a deque and a single variable. The variable is referred here as A, the top of the deque is DT, and the bottom is D0. The instructions available only allow direct access to the top of the deque, much like a stack, but bottom items can be accessed by rotating the structure. The deque has unlimited size, and items are bounded or not depending on implementation. The commands are:
 ! = push a copy of A onto the deque
 @ = pop DT onto A
 ^ = rotate deque up (pop top item then push it at bottom)
 # = rotate deque down (pop bottom item then push it on top)
 + = increment A by 1
 - = decrement A by 1
 : = output A to the output stream
 ; = set A to next character in the input stream
 % = swap A with DT (equivalent to !^@# )
 * = set DT to A (equivalent to !!^^@##@ )
 & = peek DT onto A (equivalent to @!)
 [ = jump after corresponding ] if A==0
 [$ = jump after corresponding ] if DT==0 (equivalent to %[% instructions %]%)
 ] = jump to corresponding [ or [$
 _ = output A as a character
 'n = set A to character n
Using an instruction that requires items present in memory when there are none is undefined.
Some instructions are simply included for convenience, as BrainCurses is not intended to be extremely minimalist, just odd to look at.
== Examples ==
None of these programs are currently tested, as there is no existing implementation yet.
=== Hello World! ===
This program outputs "Hello World!"
 !'H!'E!'L!!'O!' !'W!'O!'R!'L!'D!'!!##[$@_#]
=== Cat ===
This program outputs its input
 ;[_;]
=== String Reversal ===
If the string is 0 terminated, the following program will receive it from the input and output it reversed
 [;!]#[$@_#]
=== Top Stack Addition ===
The following program adds the top two items on the deque and then pushes it on the top. The end result is identical to its original state save the fact that there will be a newly added item. I.E. it is non-destructive.
 !^^&#!^&#!@[-%+%]#@
==Computational class==
The 'stack' in BrainCurses is actually as powerful as a deque, since the bottom element can be accessed using instructions ^ and #. It is easy to emulate a tape using a deque; the following reduction from boolfuck is a formal proof that BrainCurses is Turing-complete, assuming -1, 0 and 1 are possible values for deque items.
boolfuck 	BrainCurses
<program start>	!-!#
+ 	@-![++%+]
, 	;%
: 	&:
< 	[-]!#&+[^@#]
> 	^[-]!^&+[#@^]#
[ 	[$
] 	]
This assumes that input is given as a stream of 0 and 1 values.
== Implementation ==
An implementation in node.js, written by User:Conor O'Brien, can be found here.
Category:Languages
Category:Brainfuck_derivatives
Category:Deque-based
Category:Implemented
Category:Turing complete
Category:2012
BrainCurses/implementation.js

:
This is an implementation of BrainCurses in node.js, written by User:Conor O'Brien. 
== Implementation ==
Remember to npm install readwrite before running.
 const rw = require("readwrite");
 
 class Dequeue extends Array {
 pop(){
 if(this.length === 0) return 0;
 return super.pop();
 }
 
 get top(){
 let v = this.pop();
 this.push(v);
 return v;
 }
 
 set top(v){
 return this[this.length - 1] = v;
 }
 
 inject(value){
 return this.unshift(value);
 }
 
 eject(){
 return this.shift();
 }
 }
 
 class BrainCurses {
 constructor(program){
 this.code = program.match(/'.|\[\$|./g);
 this.A = 0;
 this.Dequeue = new Dequeue();
 this.instructions = new Map([
 ["!", () => this.Dequeue.push(this.A)],
 ["@", () => this.A = this.Dequeue.pop()],
 ["^", () => this.Dequeue.inject(this.Dequeue.pop())],
 ["#", () => this.Dequeue.push(this.Dequeue.eject())],
 ["+", () => this.A++],
 ["-", () => this.A--],
 [":", (output, input) => output(this.A)],
 [";", (output, input) => this.A = input()],
 ["%", () => [this.A, this.Dequeue.top] = [this.Dequeue.top, this.A]],
 ["*", () => this.Dequeue.top = this.A],
 ["&", () => this.A = this.Dequeue.top],
 ["[", () => {
 if(this.A !== 0) return;
 let i, depth;
 for(i = this.index + 1, depth = 1; depth && i < this.code.length; i++){
 if(this.code[i][0] === "[") depth++;
 else if(this.code[i] === "]") depth--;
 }
 this.index = i - 1;
 }],
 ["[$", () => {
 if(this.Dequeue.top !== 0) return;
 let i, depth;
 for(i = this.index + 1, depth = 1; depth && i < this.code.length; i++){
 if(this.code[i][0] === "[") depth++;
 else if(this.code[i] === "]") depth--;
 }
 this.index = i - 1;
 }],
 ["]", () => {
 let i, depth;
 for(i = this.index - 1, depth = 1; depth && i >= 0; --i){
 if(this.code[i][0] === "[") depth--;
 else if(this.code[i] === "]") depth++;
 }
 this.index = i;
 }],
 ["_", (output, input) => output(String.fromCharCode(this.A))]
 ]);
 }
 
 execute(output, input){
 for(this.index = 0; this.index < this.code.length; this.index++){
 let cmd = this.code[this.index];
 // console.log(cmd, this.Dequeue);
 if(this.instructions.has(cmd)){
 this.instructions.get(cmd)(output, input);
 } else if(cmd[0] === "'"){
 this.A = cmd.charCodeAt(1);
 }
 }
 return this;
 }
 
 static eval(code, input){
 let iar = input.reduce((p,c)=>p.concat(...c),[]).map(e => e.charCodeAt());
 let BCinst = new BrainCurses(code);
 return BCinst.execute(rw.log, () => iar.length && iar.shift());
 }
 }
 
 let args = process.argv.slice(2);
 
 let debug = false;
 
 if(args[0] === "-d" || args[0] === "/d"){
 debug = true;
 args.shift();
 }
 
 let res = BrainCurses.eval(rw.read(args.shift()), args);
 
 if(debug) console.log(res.Dequeue);
== Usage ==
 node BrainCurses.js <filename> <input>
or
 node BrainCurses.js /d <filename> <input>
or
 node BrainCurses.js -d <filename> <input>
The latter two print the contents of the dequeue at program termination.
== Assumptions ==
# : outputs A as a number;
# input reads from left to right
== Notices ==
The string reversal example given on the page ([;!]#[$@_#]) seems to be incorrect, at least, as per this implementation; the correct way of doing it would be this:
 ;[!;][$@_]
Category:Implementations
BrainCursion

BrainCursion is a variant of the brainfuck programming language in which the [] while loops are replaced with recursive loops. It was sketched up in a few seconds by Seven Inch Bread, with no intention of being implemented. However, an interpreter was written by User:Madk in 2010.
==Commands==
[ and ] are both removed from the language, with the following commands added
( - marks the beginning of a loop
) - marks the end
% - return back to the last ( command 
 (if there is none, then restart at the beginning of the program)
@ - move to the next ) command 
 (if there is none, the program terminates)
# - If the value of the current cell is non-zero, skip the next
 command
==Computational class==
You can emulate a BF while loop like so:
 (#@SomeCode%)
However, as loops cannot be nested, this is not enough to show BrainCursion Turing-complete.
Note, though, that BrainCursion loops are more featureful as Brainfuck loops, as you can write
 (#@ aaa #@ bbb #@ ccc #@ ddd %)
to conditionally skip out of the loop at different spots.
(Other constructions are possible, too.)
The following Python code converts any Brainfuck program into an equivalent BrainCursion program, provided that cells can hold values up to 2 times the number of loops in the Brainfuck program. Note that ( is not required.
def bf2bc(bf):
 """Convert Brainfuck code to BrainCursion"""
 loops = []
 s = 0
 code = ">>>+<<#>>#@-<<"
 for op in bf:
 if op in "+-,.":
 code += "<" + op + ">"
 elif op in "><":
 code += op*4
 elif op == '[':
 s += 1
 code += "+>>+<)<-#>>#@-<<"
 loops.append((len(code),s))
 elif op == ']':
 (i,b) = loops.pop()
 s += 1
 code = code[:i] + '+'*s + "<#%>" + '-'*s + code[i:] + '+'*b + "<%)<-#>>#@-<<"
 return code.replace("><","")
==External resources==
*Download interpreter
Category:Languages
Category:Low-level
Category:Cell-based
Category:Brainfuck derivatives
Category:Implemented
Category:Unknown computational class
Category:2007
Category:2010
BrainDestructionByCode I

BrainDestructionByCode I is an esoteric language designed to drive the programmer insane, created by threesodas.
= Cells of BDBCI =
BDBCI is a cell based programming language, similar to brainfuck. It has a finite amount of cells (20,000), and each cell's numeric value can be used to execute ASCII code.
Every time a character is read by an interpreter, every value is shifted one cell to the right. This includes the very first character. So, cells will end up looking like this:
 Code:
 ++
 Cells:
 002
NOTE: All cells are always shifted BEFORE an action is executed by the interpreter.*
Code must be optimized to fit this challenge.
= Valid Characters =
The following is a list of BDBCI characters and their respective actions.
Character	Action
+ 	Increment a cell by one
- 	Decrement a cell by one
> 	Shift one cell to the right
< 	Shift one cell to the left
» 	Shift two cells to the right
« 	Shift two cells to the left
⇥ 	Shift three cells to the right
⇤ 	Shift three cells to the left
[ 	Create a loop
] 	End a loop on the condition that the current cell value is zero
r 	Shift all cell values left until the first cell is a value other than zero
. 	Print the ASCII value of the current cell value
, 	Set the current cell to the ASCII value of a user's input character
*The r character is the ONLY exception when it comes to actions that shift cell values. Cell values never shift when this character is executed.
Category:UnimplementedCategory:2022Category:LanguagesCategory:Cell-based
BrainDots

BrainDots is a programming language by EnilKoder and is a combination of BrainF and AsciiDots.
There is an array of bytes; the size depends on specific implementations.
Each dot is a pointer in the array; they all start at 0.
 . Create a dot
 | Move vertically
 - Move horizontally
 / Top-left and bottom-right mirror
 \ Top-right and bottom-left mirror
 + Path intersection
 > Go right from above or below
 < Go left from above or below
 ^ Go up from left or right
 v Go down from left or right
 * Split the dot with the same address and send them to the other paths
(Work in Progress)
Category:Languages
BrainDuino

BrainDuino is BrainFuck-based language running on Arduino Atmel's ATMega based I/O Board. BrainDuino provides memory tape and stack overflow protection. BrainDuino is using serial line I/O for '.' and ',' commands.
There are few more instructions extending BF to BrainDuino:
* '?' - Read analog input pin's voltage value (0-255) belowing to reference voltage
* '!' - Set analog output pin's voltage value (0-255) using Pulse width modulation
* '_' - BusyWait for 10 miliseconds
With this instructions you can make LED fading (like in example code) or change it's intensity depending on some analog sensor (for example fotoresistor, etc...). And you can do much more with serial comunication, you can process input from sensor and pass it to the PC or work with it standalone without PC.
==Code examples==
*Turning on LED and fading it out in infinite loop:
[+[-!__]+++++++++++++++++++++++++++++++++++++++]
*Infinite loop of hello worlds appearing on serial line with LED fading (as above) during it:
[[-]++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.[-]<[-]<[-]<[-!_]<+]
*Serial (RS232) interface loopback:
[,.+]
*Pass data from sensor to attached LED/etc...:
[?!+]
==External resources==
*BrainDuino Source in English + comments in Czech
*Arduino Manufacturer
*More info about Arduino
*Much more info about Arduino (but in Czech language)
category:Brainfuck derivatives
BrainEmoji

BrainEmoji is a joke esoteric programming language created by Parth Patel. It is identical to Brainfuck, except that the instructions are changed into emojis that look similar. As such, it is a member of the TrivialBrainfuckSubstitution family of programming languages.
A C interpreter for this language and a Brainfuck to BrainEmoji translator can be found here. 
==Commands==
Brainfuck	BrainEmoji 	Description
> 	👉 	Move the pointer to the right
< 	👈 	Move the pointer to the left
👍 	Increment the memory cell under the pointer	
👎 	Decrement the memory cell under the pointer	
. 	🫵 	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 🫱
==Hello, world! program==
👍🫱👎👎👉👎🫱👉👉👍👉👎👎👎👎👎👈👈🫲👈👎👎👈👎👎👎🫲👉👎🫵👉👉👉👍🫵👉👉🫵🫵👍👍👍🫱🫵👉🫲👈👈👈👈🫵👍👍👍🫵👎👎👎👎👎👎🫵👈👈👎🫵👉👉👉👉👍🫵
Category:Brainfuck equivalents
Category:Cell-based
Category:Joke languages
Category:Turing complete
Category:Implemented
Category:Low-level
Category:Languages
Category:Turing tarpits
Category:Brainfuck derivatives
BrainFNORD

BrainFNORD is yet another brainfuck derivative, similar to Blub except that the operators are all discordian buzzwords. It was written by User:john.ohno in 2009.
The following is the correlation between BrainFNORD and brainfuck:
 23 [
 5 ]
 pineal <
 fnord >
 kallisti .
 chaos ,
 hail +
 eris -
There is a translator in GNU FLEX for translating BrainFNORD to brainfuck here: http://namcub.accela-labs.com/pics/brainfnord.tgz 
The author found that running most discordian holy books through a BrainFNORD to brainfuck translator yielded valid, though useless, brainfuck programs.
Category:2009 Category:Implemented Category:Brainfuck_equivalents Category:Brainfuck_derivatives Category:Languages Category:Turing complete Category:Low-level Category:Cell-based Category:Turing tarpits
BrainFc

BrainFc (pronounced the same as "brainfuck") is a metalanguage by User:None1. It can interpret almost any Trivial brainfuck substitution languages, translate them from and to brainfuck,and to other Trivial brainfuck substitution languages and some non-esoteric languages (like C).
==Examples==
{
 "cmd": {
 "+": "-",
 "-": "+",
 ",": ".",
 ".": ",",
 "[": "]",
 "]": "[",
 ">": "<",
 "<": ">"
 },
 "delims": [],
 "actions": [
 ["frombf","++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++."],
 ["tobf",".],.["],
 ["inter","------]<------------->+[<,<-----------]<---------->+[<-,-,+++++++++++,<-----]<--------->+[<-,"],
 ]
}
specifies ReverseFuck and translates the brainfuck program ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++. to ReverseFuck, then translates the ReverseFuck program .],.[ to brainfuck and interprets the ReverseFuck program ------]<------------->+[<,<-----------]<---------->+[<-,-,+++++++++++,<-----]<--------->+[<-,.
BrainFc supports a beginning and ending of program so it is possible to implement and then.
All BrainFc programs are JSON files.
==Documentation==
Unfortunately, BrainFc has a lack of documentation. But here is the GitHub repository of BrainFc along with a very brief readme and the source code of the language in Python and some examples. There is also a Repl.
==See also==
* BrainSoup, a similar idea but in Java
* Trivial brainfuck substitution
* brainfuck
* ReverseFuck
Category:Languages
Category:Meta-languages
Category:Brainfuck equivalents
Category:Brainfuck
Category:2023
Category:Turing complete
BrainFuckFart

= BrainFuckFart =
== BrainFuckFart a surprisingly fun language ==
=== Concept ===
I started creating BrainFuckFart as a simple C++ interpreter for BrainFuck. As I went and tried to create a "More or Less" game in BrainFuck I encountered a few limitations that I went and corrected as I went. By corrected, I really mean implemented. So as I go creating bigger projects with BrainFuckFart I will keep on implementing new features. 
The project can be found on this github : BrainFuckFart
This page is open to PR and issues.
=== Commands ===
Character	Name 	Description
+ 	Add 	Add 1 to the current cell
- 	Subtract 	Subtract 1 from the current cell
> 	Next 	Move to the next cell
< 	Previous 	Move to the previous cell
[ 	Loop Open 	Go to matching ']' if cell is 0
] 	Loop Back 	Go to matching '[' if cell is not 0
| 	End loop if 0 	Go to the end of the loop if cell is 0
( 	Skip if not 0 	Go to matching ')' if cell is not 0
) 	Skip end 	Marks end of Skip
* 	Jump 	Jump to the cell with the index of the current cell value consuming the current cell when jumping
, 	Input 	Store 1 user input in the current cell
. 	Output 	Prints the current cell value as an ASCII character
; 	Input Number 	Store the number the user input in the current cell (What if the user inputs a non integer?)
: 	Output Number 	Prints current cell value as a number
! 	Output Cell Index	Prints current cell index
v 	Load Temp 	Load Temp cell value in current cell value (Temp value = register, stores one value)
^ 	Upload Temp 	Set Temp cell value to current cell value
? 	Random 	Set current cell to a random number (Range?)
/ 	Comment 	Encapsulate a part that isn't read even if it contains commands
=== Restrictions ===
This language is still claiming to be a spawn of the original BrainFuck and as such it will not accept characters that looks like letters (Let's be honest 'v' is just a downward arrow). It will also avoid to implement too much user friendly features there is already one register deal with it.
=== Open to ===
Graphics, networking, compilation, File/Module system, Typing, Function
=== Contact ===
You can contact me via github and the contacts out there.
Category:Languages Category:Brainfuck derivatives Category:Turing complete Category:Implemented Category:Cell-based
BrainFuckmore

Inspired by BrainFuck
Bytes
There are 65536 bytes
255 is the maximum number that a byte can hold
All commands : 
< > + -
. n, a, n; a;
 //n=numerical input and a=ASCII input 
 //and “;” is a not waiting “,” 
?{condition}() !{time}() !() []
 //?{}()=if , !{}()=loop for ms and !()=loop forever
condition works like this : 
val_conditioncommand_val
Conditioncommands:b s e e!
d() :d 
 //just define sg and call sg
All commands:19
< > + -
. n, a, n; a;
?{}() !{}() !() []
b s e e! _
d() :d
New ones:12
a, n; a; ?{}() !{}() !() b s e e! _ d() :d
Category:Languages Category:Brainfuck derivatives Category:Finite state automata
BrainFunge2

BrainFunge2 is an esoteric programming language created by NSQX made of two-character instructions, based on a few commands in Brainfuck, a few commands in Befunge, and NSQX's other thoughts.
Command	Meaning
X+ 	Increase the memory value at the pointer by 1
X- 	Decrease the memory value at the pointer by 1
P+ 	Increase the pointer by 1
P- 	Decrease the pointer by 1
9> 	Output the memory value at the pointer as decimal
<9 	Input a decimal number to the memory value at the pointer
F> 	Output the memory value at the pointer as hexadecimal
<F 	Input a hexadecimal number to the memory value at the pointer
'> 	Output the memory value at the pointer as ASCII
<' 	Input a character as ASCII to the memory value at the pointer
'' 	Toggle string queue mode, for example, gnirts
"X 	Takes the last character out of the string queue and sets the memory value at the pointer to it's ASCII value
X" 	Adds the memory value at the pointer as ASCII to the beginning of the string queue
_) 	Jumps back to the beginning of the program
X( 	Jumps past the matching )X if the memory value at the pointer is 0
)X 	Jumps back to the matching X( if the memory value at the pointer is not 0
"( 	Jumps past the matching )" if the string queue is empty
)" 	Jumps back to the matching "( if the string queue is not empty
-) 	Resets everything and jumps back to the beginning of the program
XE 	Sets the error code to the memory value at the pointer
EX 	Sets the memory value at the pointer to the error code
-- 	Exits with the error code before reaching the end of the program
== Classic "Hello World!" program ==
In BrainFunge2, there are two ways a classic "Hello World" program can be written:
 ''
 !dlroW olleH"("X'>)"
 X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+
 X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+'>X+X+X+X+X+X+X+
 X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+'>X+X+X+X+X+X+X+'>'>X+X+X+'>X-X-X-X-
 X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-
 X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-'>X+X+X+X+
 X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+
 X+X+X+X+X+X+X+X+X+X+X+'>X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+'>X+X+X+
 '>X-X-X-X-X-X-'>X-X-X-X-X-X-X-X-'>X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-
 X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-
 X-X-X-X-'>X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-X-'>
However, the shortest way is always preferred.
Category:Unimplemented
Category:Languages
Category:2012
BrainGuck

BrainGuck is an esoteric language created by User:Periapsis. It was inspired by BrainFuck. It adds a few extra commands:
* { - Similar to [ except it runs the code only if the cell at the pointer is 0
* } - jumps back to matching opening loop if cell at pointer is 0
* ^ - stores one byte of data from the cell into the pointer
* v - sets current cell to the value stored in the pointer
* 0 - sets current cell to zero
There is a python interpreter Here
Category:Languages
Category:Cell-based
Category:Turing complete
Category:Implemented
Category:Brainfuck derivatives
Category:2017
BrainHalt

BrainHalt is a brainfuck derivative that solves the halting problem. It is invented by User:None1.
==Commands==
It is BF, but with 1 extra command.
h	If this program will halt, increment current cell.
==Examples==
===Paradox===
 h[]
The program halts if it doesn't halt and doesn't halt if it halts.
Category:Languages
Category:Brainfuck derivatives
Category:Uncomputable
BrainInt

==Introduction==
BrainInt is a language invented by NoOneIsHere from Programming Puzzles & Code Golf.
==Basics==
These are the current commands:
# +, increment current cell
# -, decrement current cell
# >, move one cell to the right
# <, move one cell to the left
# ., output current cell as ASCII char
# !, output current cell as number
# *, multiply cell and cell to the right
# /, integer divide cell and cell on right
# [, start loop (while cell != 0)
# ], end loop
# {, start for loop (exec code, then move cell until cell is zero)
# }, end for loop
# $, add cell and cell on right, clearing cell on right
# %, subtract cell and cell on right, clearing cell on right
# @, end program
# &, set current cell to input given from user
# (, exec code <current cell> number of times
# ), end exec loop
==Interpreter==
# In Python (Official)
Category:Languages
Category:Brainfuck derivatives
Category:Implemented