nyuuzyou/wikis huggingface dataset:
Brainfuck-- interpreter

:
This is an interpreter for brainfuck-- written by User:Wh1teWolf in Basic:
 DIM tape(33)
 DIM parentes(100)
 DIM parentesvar(100)
 tes=0
 ptr=0
 b=0
 i=0
 f=0
 lol=0
 REPEAT
 counter=0
 INPUT "" a$
 
 REPEAT
 b=b+1
 
 
 IF MID$(a$,b,1)=">" THEN
 ptr=ptr+1
 IF ptr=32 THEN ptr=0
 ENDIF
 
 
 IF MID$(a$,b,1)="." THEN
 lol=0
 IF tape(0)=1 THEN
 lol=1
 ENDIF
 IF tape(1)=1 THEN
 lol=lol+2
 ENDIF
 IF tape(2)=1 THEN
 lol=lol+4
 ENDIF
 IF tape(3)=1 THEN
 lol=lol+8
 ENDIF
 IF tape(4)=1 THEN
 lol=lol+16
 ENDIF
 IF tape(5)=1 THEN
 lol=lol+32
 ENDIF
 IF tape(6)=1 THEN
 lol=lol+64
 ENDIF
 IF tape(7)=1 THEN
 lol=lol+128
 ENDIF
 IF lol>0 THEN
 PRINT CHR$(lol)
 ELSE
 f=0
 REPEAT
 f=INKEY(1)
 UNTIL f<>-1
 PRINT CHR$(f)
 IF f>=128 THEN
 tape(7)=1
 f=f-128
 ENDIF
 IF f>=64 THEN
 tape(6)=1
 f=f-64
 ENDIF
 IF f>=32 THEN
 tape(5)=1
 f=f-32
 ENDIF
 IF f>=16 THEN
 tape(4)=1
 f=f-16
 ENDIF
 IF f>=8 THEN
 tape(3)=1
 f=f-8
 ENDIF
 IF f>=4 THEN
 tape(2)=1
 f=f-4
 ENDIF
 IF f>=2 THEN
 tape(1)=1
 f=f-2
 ENDIF
 IF f>=1 THEN
 tape(0)=1
 f=f-1
 ENDIF
 ENDIF
 
 ENDIF
 
 
 IF MID$(a$,b,1)="+" THEN
 IF tape(ptr)=1 THEN tape(ptr)=0 ELSE tape(ptr)=1
 ENDIF
 
 
 IF MID$(a$,b,1)="[" THEN
 tes=tes+1
 counter=tape(ptr)
 parentesvar=ptr
 parentes(tes)=b
 
 IF counter=0 THEN
 
 REPEAT
 b=b+1
 UNTIL MID$(a$,b,1)="]"
 
 ENDIF
 ENDIF
 
 
 
 
 IF MID$(a$,b,1)="]" THEN
 IF tape(parentesvar)<>0 THEN
 b=parentes(tes)
 ENDIF
 IF tape(parentesvar)=0 THEN
 tes=tes-1
 ENDIF
 ENDIF
 
 
 UNTIL b=1000
 
 a$=""
 b=0
 tes=0
 FOR i=1 TO 100
 parentes(i)=0
 NEXT
 UNTIL FALSE
==See Also:==
*Brainfuck--
*Brainfuck
Category:Implementations
Brainfuck.NET

==Language overview==
Brainfuck.NET operates on an array of memory cells, also referred to as the tape, each initially set to zero. There is a pointer, initially pointing to the first memory cell. The commands are:
Command	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 [ if the cell under the pointer is nonzero
^ 	Send output as message to the computer with the same id(the pointer pointing byte).
v 	Recieve output as id(the pointer pointing byte) from the same id.
* 	wait the current byte seconds.
P 	Make the computer explode.
Category:Joke languages
Category:Brainfuck derivatives
Category:2018
Category:Languages
Category:Unimplemented
Category:Cell-based
Category:Turing complete
Brainfuck2

Brainfuck2 is a language that is a result of creating an interpreter(1) for it's parent language, and adding more features to it.
==Overview==
This language is mostly the same as brainfuck, so:
Operation	Meaning
+ 	Increments the currently selected cell
- 	Decrements the currently selected cell
< 	Selects the cell to the left of the currently selected cell
> 	Selects the cell to the right of the currently selected cell
. 	Outputs the value at the selected cell as an ASCII/Unicode character
, 	Input an ASCII/Unicode character, and put its code in the selected cell
[ 	Jump to the matching ] if the selected cell is 0
] 	If the selected cell is not 0, jump to the matching [
However, this language at current (the standard is still being worked on) has three extra features.
==Additions==
Below is a list of functions added by this version...
===Functions===
Functions are the first addition to this language. Define a function using:
{{1}} ; Define a function with index 1,
<[>++++++++++<-]>.[-] ; as this,
;;; ; And end the definition. Don't confuse this for single-semicolon explicit comment syntax.
A function can then be called using the following:
++++++>+++++||1|| ; Call function 1 to print "A"
===Print statements===
p ``Hello world`` prints "Hello world" and will transpile to a brainfuck code that would print "Hello world," aka
Print "Hello world"
+++++++[>++++++++++<-]>++.[-]<
++++++++++[>++++++++++<-]>+.[-]<
+++++++++++[>++++++++++<-]>--.[-]<
+++++++++++[>++++++++++<-]>--.[-]<
+++++++++++[>++++++++++<-]>+.[-]<
+++[>++++++++++<-]>++.[-]<
++++++++++++[>++++++++++<-]>-.[-]<
+++++++++++[>++++++++++<-]>+.[-]<
+++++++++++[>++++++++++<-]>++++.[-]<
+++++++++++[>++++++++++<-]>--.[-]<
++++++++++[>++++++++++<-]>.[-]<
++++++++++..[-]
===Explicit comments===
Regular, "implicit" comments are anything that isn't a brainfuck command, like hello world.
Explicit commands have a semicolon to begin them, like ; Comment, the comma isn't a worry!.
In an explicit comment, everything following it until the end of the line is completely ignored (and removed in the transpilation process.)
This means commands (like a comma) can be put in an explicit comment without issues, as it's ignored anyway.
==External resources==
* The interpreter this language is based on, for node.js
Category:Turing tarpits 
Category:Low-level 
Category:Cell-based 
Category:Implemented 
Category:Languages
Category:Brainfuck derivatives
Category:Turing complete
Brainfuck: Free Version

Brainfuck: Free Version (or brainfuck: free version) is a subset of brainfuck premium (or Brainfuck Premium), which is essentially brainfuck. It is made as part of this repost chain on wasteof.
== Definition ==
In the post, it is written:
brainfuck premium:
without it you cant:[sic]
* use +, [], and ,
Thus, the commands of brainfuck: free version are:
Command	Description
> 	Move the pointer to the right
< 	Move the pointer to the left
- 	Decrement the memory cell at the pointer
. 	Output the character signified by the cell at the pointer
== Computational class ==
Since brainfuck: free version doesn't have any control loop whatsoever, this language always halts, making it not Turing complete.
== Interpreter ==
Trivial brainfuck substitution style interpreter.
#!/usr/bin/ruby
eval 'm=Hash.new(p=0);'+ARGF.read.gsub(
 /./,
 '>'=>'p+=1;',
 '<'=>'p-=1;',
# '+'=>'m[p]+=1;',
 '-'=>'m[p]-=1;',
# '['=>'(',
# ']'=>')while((m[p]&=255)!=0);',
# ','=>'m[p]=STDIN.getbyte if !STDIN.eof;',
 '.'=>'putc m[p];')
Category:Total Category:Output only Category:Brainfuck derivatives Category:Esoteric subset Category:Joke languages Category:Unusable for programming Category:Languages Category:Cell-based
BrainfuckX

BrainfuckX is an extension of brainfuck that is backwards compatible with all uncommented brainfuck programs.
Cells are unsigned bytes. The cell pointer starts in the leftmost cell.
==Instructions==
 + - Add 1 to the current cell.
 
 - - Subtract one from the current cell.
 
 > - Move the cell pointer right.
 
 < - Move the cell pointer left.
 
 [ - If current cell is 0 jump to corresponding ]
 
 ] - Jump to corresponding [
 
 . - Send character in current cell to the current interface.
 
 , - Receive a character of input from the current interface and store it in the current cell.
 
 @ - Cycle through interfaces. See #Interfaces.
 
 ! - Move the cell pointer to the leftmost cell.
 
 ^ - Move the instruction pointer to the instruction in position N where N is the value in the current cell (starting at 0).
 
 ; - Move the instruction pointer to the last ^ ran.
 
 * - Move the cell pointer to the value in the current cell.
 
 % - Set the current cell and the next three cells to Unix time.
 
 ? - Randomize the value in the current cell.
==Interfaces==
The initial interface is console IO (STDIN / STDOUT).
Interfaces rotate through the following:
# (STDIN / STDOUT)
# (STDIN / STDERR)
# URL - No input. Output writes to the end of the URL string. Use character 127 to delete the last character of the URL string.
# FILEIO - read and write to the file at the URL string.
# INTERNET - read the web page at the URL string.
# SERIAL IO
# TERMINAL - write a command until character 0. Then run the command in the system terminal. Then read the return code.
Category:Languages Category:Turing complete Category:Brainfuck derivatives Category:Turing tarpits Category:Unimplemented Category:2015
BrainfuckXT

BrainfuckXT is an extension to Brainfuck by User:KryptonX. BrainfuckXT is a compiled language targeting the .NET Framework. Changes have not been made to Brainfuck syntax and functions. Brainfuck code is valid BrainfuckXT code. Both can be used in unison. Features have been added to make the language more powerful, although BrainfuckXT does not make commercial grade software. Nonetheless, useful daily applications can be made. A compiler can be obtained from here and the source from my github.
Internal data table (values with an * are BrainfuckXT only)
Feature 	Description
putchar 	Supports the printing of characters.
100,000 ASCII Character slots	100,000 separate data values can be stored each in their own cell.
Increment 	Increment slot values.
Decrement 	Decrement slot values.
Getchar 	Store user input into selected ASCII slot.
*Getline 	Store user input into selected string slot.
*30,000 string slots 	BrainfuckXT supports strings, and can store 30,000 of them simultaneously.
*Files 	BrainfuckXT handles the I/O of files.
*Memory Addresses 	Print the address in memory of the selected ASCII character slot.
*String indexing 	'nuff said.
*Conditions 	Execute a block of code if a condition is true or false.
== BrainfuckXT Commands (added) ==
Command Symbol	Purpose
@ 	Prints the memory-address of character in current ASCII slot.
& 	Passes user-input (line) to currently selected string slot.
$ 	Print selected string.
{} 	Manually set string values.
: 	Clear string and add selected ASCII character.
; 	Add selected ASCII character to currently selected string (+=).
* 	Increment indexing integer.
~ 	Decrement indexing integer.
| 	Print character using indexing integer as index for selected string.
# 	Open file for reading (selected string slot) and save file text to the next slot.
== Conditions ==
BrainfuckXT has two condition statements: ? and !. If the current ASCII slot is equal to 0, the code between the two ?'s will be executed. If the current ASCII slot is not equal to zero, the code between the !'s will be executed. These should not be nested.
Examples
?++.?
In the example above, the selected ASCII slot is equal to 0. The "++." will be executed.
+!+.!
In the example above, the selected ASCII slot is not equal to 0. The "+." will be executed.
== Syntax Changes ==
Although I made it a point to retain most of Brainfuck's original syntax, one major change was made. Loops; they work in the exact same way except that loops CANNOT be nested in BrainfuckXT.
== External resources ==
* Brainfuck -- Wikipedia 
* Brainfuck++ -- A Brainfuck extension
* BrainfuckXT-GT
Category:Brainfuck_derivativesCategory:Languages
Brainfuck^

Brainfuck^ by User:Password is vanilla brainfuck with a few additional commands, more specifically the additional commands are pointer versions of the existing ones.
As a refresher, the standard commands are:
Command	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 [ if the cell under the pointer is nonzero
and the extended commands are:
Command	Description
} 	Increment the memory cell which the current cell refers to
{ 	Decrement the memory cell which the current cell refers to
( 	Jump past the matching ) if the cell which the current cell points to is 0
) 	Jump back to the matching ( if the cell which the current cell points to is nonzero
== Examples ==
Here's a list of some basic programs.
If you set memory like this ( |n| denotes the pointer position, the first address is zero always )
 >+>+>+>+>+>+>+>+>+>+<<<<<<<<<<
 |0| 1 1 1 1 1 1 1 1 1 1 
and you run +(+) it will show you the address of the first empty cell, i.e.
 |11| 1 1 1 1 1 1 1 1 1 1
A more involved program is:
 ,>,>,>,>,>,<<<<<<-(-)-[({>+<)-]>!01020304050f
 |30| 
Let's break it down.
,>,>,>,>,>,<<<<<
sets up cell 0-5 with the hexadecimal values after the !.
<-(-)
moves the pointer to the last position on the tape, due to wrapping. 
Then it loads the value of the first empty cell to the right.
-[({>+<)-]
then copies the last nonempty cell to cell0 and repeats until all cells are zero.
And here is a first attempt at a Fibonacci sequence using the pointers:
 +++++++++++>+++>+>+<<<[->({+++}+}----)+++({---}+++)+({---}+++)-----({+++}+}----) +++({---}+++)+({--}++)--<]
== Source code == 
Currently there is no library released. IF there is some interest I (User:Password) will consider either releasing the Qt class or an c++ only version.
Category:Brainfuck derivatives Category:Languages Category:Cell-based Category:Turing complete Category:Low-level
Brainfuck 2D

Brainfuck 2D or 2D brainfuck is a common extension to brainfuck with two added instructions for moving up and down.
== New Instructions ==
^	Move pointer up
v	Move pointer down
== Implementations ==
There are many 2D brainfuck derivatives that have more instructions and that have implementations, but implementations with just these two new instructions are yet to be listed.
Category:Languages
Category:Turing complete
Category:Cell-based
Category:Brainfuck derivatives
Brainfuck But With Buffer

BBWB is a brainfuck derivative that adds a buffer between you and the memory tape.
You can increment and decrement the buffer value, then overwrite the pointed cell with said buffer value.
You can also load pointed cell value to the buffer, overwriting it.
It also adds I/O differences: you can get or put buffer value as int or as ASCII char.
The cell pointer wraps around (there is a fixed number of cells).
==Commands==
(for the C transpilation part, we assume you have this setup:
int buff = 0;int tape[CELLS] = {0};int ptr = 0;
and you've defined a CELLS constant
)
Command	Effect 	C transpilation
+ 	Increment the buffer value 	++buff; if (buff>255) buff = 0;
- 	Decrement the buffer value 	--buff; if (buff<0) buff = 255;
# 	Set the buffer value to zero 	buff = 0;
^ 	Set the pointed cell to the buffer value 	tape[ptr] = buff;
v 	Set the buffer value to the pointed cell 	buff = tape[ptr];
< 	Decrement the cell pointer 	++ptr; if (ptr>=CELLS) ptr=0;
> 	Increment the cell pointer 	--ptr; if (ptr<0) ptr = CELLS-1;
. 	Output the buffer value as an int 	printf("%d", buff);
: 	Output the buffer value as an ASCII char 	printf("%c", buff);
, 	Input an int to the buffer value 	scanf("%d", &buff);
; 	Input a char and set the buffer value to the char's ASCII value	scanf("%c", &buff);
[ 	Jump past the matching ] if the pointed cell is 0 	while tape[ptr] {
] 	Jump back to the matching [ if the pointed cell is nonzero 	}
@ 	Print tape (for debugging purposes) 	
==Examples==
===Hello, world!===
+++++++++^#[>v++++++++^#<v-^#]>v: print H
# clear
+++++++++++++++++++++++^#[>v+++^#<v-^#]>v: print E (a bit inefficent)
#
+++++++++++++++++++^#[>v++++^#<v-^#]>v: : print LL
#
++++++++++^#[>v++++++++^#<v-^#]>v-: print O (80 minus 1 easier than 79)
#
+++++++++++^#[>v++++^#<v-^#]>v: print comma
#
++++++++^#[>v++++^#<v-^#]>v: print space
#
+++++++++++^#[>v++++++++^#<v-^#]>v-: print W (same trick as O 88 minus 1 easier than 87)
#
++++++++++^#[>v++++++++^#<v-^#]>v-: print O
#
++++++++++^#[>v++++++++^#<v-^#]>v++: print R (80 plus 2 easier than 82)
#
+++++++++++++++++++^#[>v++++^#<v-^#]>v: print L
#
+++++++++++++++++^#[>v++++^#<v-^#]>v: print D
#
+++++++++++^#[>v+++^#<v-^#]>v: print !
#
++++++++++: print newline
===Truth Machine===
The truth machine in BBWB is surprisingly simple:
,^.[.]
Let's see it with comments
, get integer input
^ load to cell0
. print buffer
[.] while selected cell print buffer
==External resources==
More info on the github page here: https://github.com/umanochiocciola/bbwb
Text Converter: https://github.com/umanochiocciola/bbwb-text-generator
Category:Languages Category:Cell-based Category:Implemented Category:Brainfuck derivatives Category:Turing complete
Brainfuck C++ interpreter

The following is an optimizing brainfuck interpreter by User:None1 in C++, it has 1000000 8-bit cells and EOF results in -1;
#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <cstdlib>
unsigned char tape[1000000];
int p,tp,stack[1000000],matches[1000000];
struct node {
 char c;
 int num;
}opt[1000000];
inline void push(int x) {
 stack[tp++] = x;
}
inline int pop() {
 if (tp) return stack[--tp];
 else exit((puts("Unmatched ]"), 1));
}
int main(int argc,char* argv[])
{
 FILE* f = fopen(argv[1],"r");
 int q = 0; // Length of optimized representation
 while (!feof(f)) {
 if (!feof(f)) {
 char c = fgetc(f);
 if (c != '+' && c != '-' && c != '>' && c != '<' && c != ',' && c != '.' && c != '[' && c != ']') continue;
 if (q && (c == '+' || c == '-' || c == '>' || c == '<') && opt[q - 1].c == c) {
 opt[q - 1].num++;
 }
 else {
 opt[q++].c = c;
 opt[q-1].num = 1;
 }
 }
 }
 for (int i = 0; i < q; i++) {
 if (opt[i].c == '[') push(i);
 if (opt[i].c == ']') {
 int result = pop();
 matches[result] = i;
 matches[i] = result;
 }
 }
 if (tp) return puts("Unmatched ["), 1;
 int ip = 0;
 while (ip < q) {
 switch (opt[ip].c) {
 case '+': {
 tape[p] += opt[ip].num;
 break;
 }
 case '-': {
 tape[p] -= opt[ip].num;
 break;
 }
 case '>': {
 p += opt[ip].num;
 break;
 }
 case '<': {
 p -= opt[ip].num;
 break;
 }
 case ',': {
 tape[p] = getchar();
 break;
 }
 case '.': {
 putchar(tape[p]);
 break;
 }
 case '[': {
 if (!tape[p]) {
 ip = matches[ip];
 }
 break;
 }
 case ']': {
 if (tape[p]) {
 ip = matches[ip];
 }
 break;
 }
 }
 ++ip;
 }
 return 0;
}
Category:Implementations
Brainfuck Contest 1

Welcome to my test contest!
==Rule==
This is a golf contest. Anyone with the shortest code wins.
==Addition program==
Indeed, we have to test it. If you have an answer, just go for it. Edit it.
==Input==
 Number.(2 one-digit numbers)
==Output==
 Number added (digital root, or mod 9)
==Example Input==
 45
==Example Output==
 9
==Your Code Goes Here:==
 -[>+<-----]>---[->+>+<<]<,>,>[[-<<->>]>]<<<[-<+>]<.
==Code that actually works as required==
 ,>,[<+>-]<+++[>>+<---------[+++++++++>-]>[->]<<+<-]++++++++[>++++++<-]>.
Category:Competitions and Events
Brainfuck Contest 2

Welcome to my test contest!
==Rule==
This is a golf contest. Anyone with the shortest code wins.
==Addition program==
Indeed, we have to test it. If you have an answer, just go for it. Edit it.
==Input==
 Code
==Output==
 Result
==Example Input==
 ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++.>+.+++++++..+++.<<++.>+++++++++++++++.>.+++.------.--------.<<+.<.
==Example Output==
 Hello World!
==Your Code Goes Here:==
Category:Competitions and Events
Brainfuck JavaScript interpreter

:
This is an interpreter in JavaScript for brainfuck, by User:None1 (supports wraps, EOF returns 0):
function brainfuck(program,input){
 var stack=[];
 var matches={};
 var ip=0;
 var tape=[];
 var p=0;
 var output=;
 for(let i=0;i<1000000;i++){
 tape.push(0);
 }
 for(var i=0;i<program.length;i++){
 if(program[i]=='['){
 stack.push(i);
 }
 if(program[i]==']'){
 if(stack.length==0){
 throw new Error('Right bracket does not match left bracket');
 }
 var mt=stack.pop();
 matches[mt]=i;
 matches[i]=mt;
 }
 }
 if(stack.length!=0){
 throw new Error('Left bracket does not match right bracket');
 }
 while(ip<program.length){
 if(program[ip]=='+'){
 tape[p]=tape[p]+1;
 if(tape[p]==256) tape[p]=0;
 ip=ip+1;
 }
 if(program[ip]=='-'){
 tape[p]=tape[p]-1;
 if(tape[p]==-1) tape[p]=255;
 ip=ip+1;
 }
 if(program[ip]=='>'){
 p=p+1;
 if(p>=1000000){
 throw new Error('Pointer overflow');
 }
 ip=ip+1;
 }
 if(program[ip]=='<'){
 p=p-1;
 if(p<0){
 throw new Error('Pointer underflow');
 }
 ip=ip+1;
 }
 if(program[ip]==','){
 if(input==){
 tape[p]=0;
 }else{
 tape[p]=input.charCodeAt(0)%256;
 input=input.slice(1);
 }
 ip=ip+1;
 }
 if(program[ip]=='.'){
 output+=String.fromCharCode(tape[p]);
 ip=ip+1;
 }
 if(program[ip]=='['){
 if(tape[p]==0){
 ip=matches[ip];
 }else{
 ip=ip+1;
 }
 }
 if(program[ip]==']'){
 if(tape[p]!=0){
 ip=matches[ip];
 }else{
 ip=ip+1;
 }
 }
 if(!('+-,.[]<>'.includes(program[ip]))){
 ip=ip+1;
 }
 }
 return output;
}
Category:Implementations
Brainfuck Markup Language

Brainfuck Markup Language (BFML) is an example of an Esoteric Markup Language created by User:Hppavilion1 in the #Esoteric IRC channel to provide an example of an Esoteric Markup Language.
== Syntax ==
BFML has a simple syntax derived from Brainfuck and Plain Text. The first line of a BFML program is a valid program written in a close derivative of (36-bit) (wrapping) brainfuck (Minus I/O). The . operator is changed to an eof detector, returning 0 if the pointer location is less than or equal to the file length and 1 if it is greater. This program is executed by the interpreter and the final tape stored (if the program doesn't halt, the program hangs forever (so as not to cause any Halting Problems)).
The rest of the file is plain text to be marked up.
For each character, the corresponding cell from the tape of the brainfuck program is taken and converted to binary. The bits in this cell determine the formatting of the cell.
The bits are as such:
* Most Significant Bit: Bold (bold if 1, else standard)
* Bit 2: Italics (italicized if 1, else standard)
* Bit 3: Underline (underlined if 1, else standard)
* Bits 4..11: Text size (Text size corresponds to decimal of these bits)
* Bits 12..36: Color (color corresponds to hex code of these bits)
Newlines are counted as characters. Centering and such is done via tons of spaces. Whitespace is not collapsed.
===Shortcuts===
Due to the unimaginable (i.e. 34,359,738,368) number of incrementers needed just to make a single character bold, it has been decided that instructions can be repeated n times by following the instruction with the integer n. This will make BFML programming significantly easier.
== Examples ==
=== Hello World ===
 Notice the lack of BF on this line (this being a comment)
 Hello, World!
=== Rainbow Hello World ===
(To Be Implemented)
== Computational Class ==
Interestingly for a Markup Language, BFML is Turing-complete as it includes a brainfuck program in every file. Since brainfuck is Turing-complete, and as such anything extending brainfuck (without removing any key features) is Turing-complete, and BFML essentially extends brainfuck, BFML is, by definition, Turing-complete.
== Precursors ==
Prior to to the creation of BFML (by about 30 seconds), Hppavilion1 created a simpler language called "brainfuck Markup Language (Bold Only)". The syntax was similar to BFML, except the only stylization was bold, available if n>1 (where n is the corresponding cell)
== Variants ==
For every Brainfuck Derivative or Brainfuck equivalent with a non-finite tape, there is at least one BFML variant that uses that variant's tape (plus more for more complex ones that also include stacks or the like). If the cells in the language's tape are limited to below 36 bits (such as in Boolfuck), the bits in the tape are joined then split into 36 bit chunks (the excess bits left over).
Category:Markup Languages
Category:Languages
Category:Brainfuck derivatives
Category:2015
Brainfuck Powershell interpreter

:
The following is a Powershell implementation of brainfuck by User:None1, the first line in the input is the program, and the rest are the input. EOF returns 0.
$code=Read-Host
function getchar(){
 return [System.Console]::Read()
}
function putchar($x){ # Output a character
 [System.Console]::Write([Convert]::ToChar($x))
}
$ip=0
$tape=[int[]]::new(1000000)
$p=0
while($ip -lt $code.Length){
 $c=$code[$ip]
 if($c -eq "+"){
 $tape[$p]=($tape[$p]+1)%256
 }
 if($c -eq "-"){
 $tape[$p]=($tape[$p]+255)%256
 }
 if($c -eq ","){
 $tape[$p]=getchar
 if($tape[$p] -eq -1){ # Deal with EOF
 $tape[$p]=0
 }
 if($tape[$p] -eq 13){ # Deal with Windows's CRLF
 $tape[$p]=getchar
 }
 }
 if($c -eq "."){
 putchar($tape[$p])
 }
 if($c -eq '>'){
 $p++;
 }
 if($c -eq '<'){
 $p--;
 }
 if($c -eq '['){
 if($tape[$p] -eq 0){
 $loop=1
 while($loop -gt 0){
 $ip++
 if($code[$ip] -eq '['){
 $loop++
 }
 if($code[$ip] -eq ']'){
 $loop--
 }
 }
 }
 }
 if($c -eq ']'){
 $loop=1
 while($loop -gt 0){
 $ip--
 if($code[$ip] -eq '['){
 $loop--
 }
 if($code[$ip] -eq ']'){
 $loop++
 }
 }
 $ip--
 }
 $ip++
}
Category:Implementations