nyuuzyou/wikis huggingface dataset:
BFBWW

BFBWW (Brainfuck But Way Worse) is a version of Brainfuck by User:Yes in 2022.
It was made to irritate Brainfuck developers as much as possible.
=== Irritations ===
Every time an instruction that modifies a cell value is executed, the cell is randomized.
Such instructions are + - or ,
==== Output a random character endlessly ====
+[>+<.]
==== Output 12 random characters ====
--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.
==== Output 1 random character ====
-[>>+.<]
==== Have a 1 in 2028240960000000000000000000000000000 chance to print "Hello, World!" ====
+.>+.>+.>+.>+.>+.>+.>+.>+.>+.>+.>+.>+.
Category:Languages
Category:2022
Category:Brainfuck derivatives
Category:Nondeterministic
Category:Unknown computational class
BFEnet

BFEnet (Brainfuck Extended for .Net) is an extended Brainfuck translator to C#. This language is focused on advanced console output. Memory size can be changed with command-line parameter. Microsoft .Net 3.5 or 2.0 command line compiler (csc.exe) is required to build translated BFEnet code.
==Commands==
BFEnet is backwards compatible with brainfuck with some changed behavior: input is not echoed, new line is CRLF(13,10), enter key gives CR(13) (like in bfd compiler's -n mode). The command set is the same as brainfuck's, with addition of the following:
Command	Description
* 	Clear console window and reset cursor position.
^ 	Reset cursor position (to the top left corner).
{ 	Move console cursor up.
} 	Move console cursor down.
( 	Move console cursor left.
) 	Move console cursor right.
% 	Set foreground color based on the current cell value (0-15).
_ 	Set background color.
# 	Print address and decimal value of the current cell.
; 	Read next char from file to the current cell. (File is already opened for read).
= 	Switch to the write mode (erases file, must be used once).
: 	Write a char from current cell to the file (write mode must be on).
$ 	Sleep for N milliseconds (N is taken from current cell).
/ 	Comment line prefix.
==External resources==
* BFEnet: Brainfuck Extended C#.net translator (BFEnet) homepage 
Category:Languages
Category:Brainfuck derivatives
BFFB

BFFB (Brainfuck fucks brains) is a joke language (devised by User:Feuermonster, 2012) whose acronym incidentally is a palindrome.
BFFB programs are essentially brainfuck programs with just one little restriction. 
Due to popular request BFB is an abbreviation for BFFB, incidentally both are palindromic. BFB is the
official file extension for BFFB programs.
== Restriction ==
Any given program P consisting of a list of instructions L is a valid prorgam
 iff P ∈ BF where BF is the set of all valid brainfuck programs.
 and
 iff L = mirror(L)
Where mirror is a function "mirroring" characters
 [ → ]
 ] → [
 > → <
 < → >
 + → +
 - → -
 . → .
 , → ,
Example:
 [><] | [><] 
An easy way to turn brainfuck programs into valid BFFB programs would be to put [-]+[] at the end of the brainfuck program and then mirror it.
== Examples ==
[-] is a perfectly valid BFFB program.
[>] is not a valid BFFB program.
=== Cat Program ===
 ,[.,][,.],
The second part of the program never runs because the first loop never ends.
Category:Joke_languages
Category:Brainfuck equivalents
Category:Turing complete
Category:2012
Category:Languages
Category:Cell-based
Category:Low-level
Category:Brainfuck derivatives
Category:Unimplemented
BFM

BFM, devised by Frédéric van der Plancke, is Brainfuck with macros, an extension to the popular Turing tarpit.
It has higher-order macros, that is macros can be given as argument to other macros. The macro system is thus a lambda-calculus superimposed on the basic Brainfuck layer and is a Turing-complete language in its own right. 
==External resources==
* BFM by its author (.zip)
* mirror of BFM texts and interpreter
Category:Languages
Category:Brainfuck derivatives
Category:2001
BFMacros

BFMacros is a brainfuck clone except with random commands that may or may not be useful.
== Overview ==
BFMacros (Brainfuck Macros) runs with a rightward infinite tape where each cell is an 8-bit wrapping cell, initialized to 0. The pointer starts at the first cell.
=== Instruction set ===
All "macros" are run with the current state of the tape.
+ - < > [ ] . ,	Same as brainfuck
a 	Runs [>+<-]>
s 	Runs [>-<-]>
S 	Runs [->-[>]<<]>
d 	Runs [>++<-]>
h 	Runs [>+<--]>
A 	Runs [-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
a 	Runs [-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
: 	Runs >>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]<
c 	Runs ,.[,.]
! 	Runs [-]+++++++++++++++++++++++++++++++++.
=== Custom macros ===
D	Define a custom macro with a name of the value of the current cell. The code inside of the macro definition will not be run.
d	End definition of macro. When used while not defining a macro, do nothing.
m	Pause current execution, read the current cell's value, run the macro with the name of that value, continue with normal execution.
== Examples ==
=== Output a number ===
 ++++++
 :
=== Cat program ===
Trivial,
 c
=== Quine ===
Also trivial,
 !
=== Macro demonstration ===
The macro will add 5 to the current cell and the macro has the name of 3.
 +++D<+++++>d 3
 [-] 0
 +++++++ 7
 >+++ 7 3
 m call macro,
 [-]<: clear cell with 3 and output 12
== Turing-completeness ==
Since any brainfuck program will work in BFMacros, BFMacros is Turing-complete.
Category:Languages Category:Brainfuck derivatives Category:Unimplemented Category:2024 Category:Cell-based Category:Turing complete Category:Low-level
BFP

BFP (short for Brainfuck Pro) is a variant and enhacment of Brainfuck, a famous esoteric programming language by Urban Müller.
== Commands ==
Here are the commands:
* >E Moves the cell cursor to the right.
* W< Moves the cell cursor to the left.
* +ADD+ Adds the number the cell cursor is pointing at by 1.
* -SUBTRACT- Subtracts the number the cell cursor is pointing at by 1.
* REPEAT { } Loop structure for repeating block of code.
* ---OUTPUT. Adds an output to the number the cell cursor is pointing at.
* ,INPUT--- Adds an input to the number the cell cursor is pointing at.
* PRINT ( ) Adds a string or value instead of just the ASCII representation.
* IF { } Conditional logic to execute code if a condition is true.
* IF { } ELSE{ } Conditional logic with a else block.
* << >> Comment syntax to add explanations to the code.
== "Hello, World" program ==
 > E +ADD+ +ADD+ +ADD+ +ADD+ +ADD+ +ADD+ PRINT(Hello) << Set up for 'H' >>
 > E +ADD+ +ADD+ +ADD+ +ADD+ PRINT(e) << Set up for 'e' >>
 > E +ADD+ +ADD+ +ADD+ +ADD+ PRINT(l) << Set up for 'l' >>
 > E +ADD+ +ADD+ +ADD+ PRINT(l) << Set up for 'l' >>
 > E +ADD+ +ADD+ +ADD+ +ADD+ PRINT(o) << Set up for 'o' >>
 W < +ADD+ +ADD+ +ADD+ PRINT( ) << Add space >>
 > E +ADD+ +ADD+ PRINT(W) << Set up for 'W' >>
 > E +ADD+ +ADD+ +ADD+ PRINT(o) << Set up for 'o' >>
 > E +ADD+ +ADD+ PRINT(r) << Set up for 'r' >>
 > E +ADD+ +ADD+ PRINT(l) << Set up for 'l' >>
 > E +ADD+ +ADD+ PRINT(d) << Set up for 'd' >>
Category:Languages Category:Brainfuck derivatives Category:Cell-based Category:2024 Category:Low-level Category:Unimplemented Category:Turing complete
BFQ

== Commands ==
 0 " "
 1 ">"
 2 "<"
 3 "+"
 4 "-"
 5 ","
 6 "."
 7 "["
 8 "]"
== Quine ==
++>+++++++>++>++++++++>+>+++++++>++>+++>++>+++>+++>+++>+>+>+++++++>++++>++>++>++++++>++>+++>+>+>+>++++++++>++>++++++>++++>++>++++>++++>++++>+>+>+>++++++++>++>++>++>++>+++++++>++>++++++++>+>+++++++>++++++>+>++++++++><[<]>[<+<+++>>[-<<.<+>>>]<.-<--->>>]<<<<[<]>[.>]
Category:brainfuck
Category:brainfuck derivatives
Category:Languages
BFStack

BFStack is an esoteric brainfuck derivative. It is stack based instead. The instructions are almost the same, but changed to be stack based.
==Instructions==
* > pushes 0 onto the stack
* < pops the top of the stack
* . prints top of stack as ASCII
* , pushes ASCII input to top of stack
* + increments the top of the stack
* - decrements the top of the stack
* [ jumps to the corresponding ] if the top of the stack is 0
* ] jumps to corresponding [ if the top of the stack isn't 0
==Computational class==
This is a Push-down automaton, as it would be equivalent to brainfuck, except for it cannot access the non top-of-stack cells.
==Implementations==
A Python interpreter by User:Bangyen.
Category:Languages
Category:2015
Category:Brainfuck derivatives
Category:Stack-based
Category:Push-down automata
Category:Implemented
Category:Low-level
BFX

BFX (BrainFuck Extended) is a language based on Brainfuck by Immibis.
== New commands ==
(...)	comment
{...}	extension (see below)
!... 	meta-data (until end of line, see below)
#!...	Ignored if first line of file, otherwise normal processing applies
=== Supported extensions ===
None yet.
=== Meta-data format ===
There may be any number of meta-data lines, however they must be all at the beginning of the file.
The behaviour of any meta-data lines after the first non-meta-data line are undefined
!8bit 	use 8-bit cells (default)
!16bit 	use 16-bit cells
!32bit 	use 32-bit cells
!64bit 	use 64-bit cells
!unsigned	use unsigned cells
!signed 	use signed cells (default)
Category:Languages
Category:Unimplemented
Category:Brainfuck derivatives
Category:Cell-based
Category:Turing complete
Category:2008
BF (category)

BF is the category whose objects are each syntax for Brainfuck and whose arrows are polynomial-time reductions which preserve the underlying algebraic semantics. BF offers definitional answers to longstanding questions about Brainfuck variants and offers a unified view of :Category:Brainfuck equivalents.
== Motivation ==
Historically, wikipedia:model theory focused on the relationship between a single type theory and its term model, which is the least model that satisfies all of the entailments of the theory: if a fact is provably true in the type theory, then the term model should admit a construction via the proof which corresponds to that fact. From there, the term model serves as an initial object for a category of models, where arrows indicate that one model is structurally included in another. In the case of Brainfuck, we might study the relationship between Brainfuck's traditional syntax and the various possible semantics which can be assigned to that syntax.
However, the esoteric-languages community is fond of exploring alternate syntax as well as alternate semantics. Sometimes the transformation from one syntax to another is not reversible or efficiently computable; sometimes it denotes an expanded semantics.
== Definition ==
Let algebraic Brainfuck be a monoid. The objects of BF are monoidal grammars along with monoid-preserving homomorphisms to algebraic Brainfuck. The arrows of BF are monoidal grammar homomorphisms which are computable in polynomial time over the number of terminals in the input, such that the resulting diagram commutes.
BF could be thought of as a slice category, particularly a category of monoids over algebraic Brainfuck. However, it's important to note that each object of BF also comes with a grammar which can give additional structure to the monoid, and this grammar must be respected. For example, loops are often designated by multiple terminals along with production rules which pair and nest them, and the pairing/nesting must be preserved by arrows.
== Properties ==
The initial object of BF is equivalent to the algebraic syntax of algebraic Brainfuck, with an identity homomorphism. Presentations of the initial object also include the original Brainfuck syntax and all trivial substitutions, as well as any non-trivial substitutions which can be encoded as context-free grammars.
Category:Brainfuck
BF Joust champions

This page details major BF Joust programs, where "major" is, for the most part, defined as having been #1 on the either of the two hills, and gives the source for the latest version. Since the egojoust hill is now down, a condition has been added that being #1 on the "traditional" scoring system also counts.
== 2009 ==
== 2010 ==
jix_wiggle3 and myndzi_slowrush fought for first during 2010, no other competitor ever achieved first place.
== 2011 ==
== 2012 ==
== 2013 ==
== 2014 ==
== 2015 ==
== 2016 ==
== 2017 ==
:The list of major programs from 2017 onwards is not yet known to be complete.
== 2018 ==
It is currently unknown whether any programs first topped the hill in 2018.
== 2019 ==
== 2020–2023 ==
During this time period, there were no functioning BF Joust hills, so there were no new winning programs because no new programs could be submitted.
== 2024 ==
== 2025 ==
== See also ==
* BF Joust strategies
Category:Programming gamesCategory:Examples
BF Lite

== BF Lite ==
BF Lite (or Brain**** Lite) is BF without input, output and arrays..
BF Lite is based off of Brainfuck
It was created by User:Yante
If you are making a BF Lite interpreter, Always start from the first cell!
 Commands
Command	Info
> 	Moves the pointer 1 cell further.
< 	Moves the pointer 1 cell farther.
+ 	Adds 1 to the cell the pointer is on.
- 	Subtracts 1 from the cell the pointer is on.
== Example ==
 +++>+++>+++>+++>+++
 After you run this, the first 5 cells should be: 3,3,3,3,3
== Interpreters ==
Python interpreter (Made on 3.9.4) by User:Yante
 import time # Imports time module for displaying how long the program took to run.
 
 code = "" # Your program. Do not change this to multiline! May break the interpreter
 memory_size = 20 # How many cells to generate?
 pointer = 0 # Where should the pointer be when program is run?
 
 
 class BF: # The BF Lite class (responsible for running code)
 def __init__(self,code,size,pointer): # Save stuff to self variable on init
 self.code = list(code) # Your program
 self.size = size # Memory size
 self.pointer = pointer # Pointer location
 self.memory = [0] * size # Generates empty cells
 def run(self): # Run function (runs code)
 for i in self.code: # For every item (stored as i) in self.code (the program)
 if i == '>': # If item is >
 self.pointer+=1 # Go 1 cell further
 if i == '<': # If item is <
 self.pointer-=1 # Go 1 cell farther
 if i == '+': # If item is +
 self.memory[self.pointer]+=1 # Add 1 to cell
 if i == '-': # If item is -
 self.memory[self.pointer]-=1 # Subtract 1 from cell
 
 bfthing = BF(code,memory_size,pointer) # initalize the BF runner
 print("Initalized.") 
 start_time = time.time() # Start time
 bfthing.run() # Run the code! (The rest of the code will run after the program is finished.)
 print(f"Code was ran! Took {start_time - time.time()}s")
 print("Pointer Location:", bfthing.pointer)
 print("Memory:", bfthing.memory)
Category:Languages Category:Brainfuck derivatives Category:Implemented Category:No IO Category:Cell-based Category:Total Category:Unusable for programming Category:Low-level Category:MistakeInSpec
BF busy beaver

The goal: given a program length, find the brainfuck program of that length that calls the . command the greatest (finite) number of times.
The tape is considered infinite to the right, starting at the leftmost cell, with cells holding arbitrary non-negative integers. Going left while on the leftmost cell gives undefined behavior, as does decrementing a cell containing 0.
==1-9==
Exhaustive list of busy beavers 1-9:
 1 . 1
 2 .. 2
 3 ... 3
 4 .... 4
 5 ..... 5
 6 ...... 6
 7 ....... 7
 8 ........ 8
 9 ......... 9
 9 +++[-...] 9
Proof: In order for a program to call the . command more times than the number of instructions, it must contain a loop that is entered, calls the . command some number of times, and exits. <, [, ], and - are obviously not useful first instructions. At least initially, . is also not a useful first instruction, as a program beginning with . being better than the ... program of the same length would mean that the same program without the . must also be better than the corresponding ... program. This leaves + and > as the only first instructions that can be useful. Also, the part before the loop must contain a + somewhere. The inside of the loop must contain the . command and some way of exiting the loop. This gives the following possibilities for a program of length 9:
 *[******]
The first instruction here would have to be a +. Assuming the loop doesn't contain another loop:
The loop must loop at least twice in order to output at least 9 times. If it loops twice, it must contain 5 .s; the remaining command can't possibly be anything that would make it loop twice. If it loops three times, it must contain 3 .s. The remaining 3 commands are powerless to cause 
 **[*****]
subproof goes here
 ***[****]
subproof goes here
 ****[***]
subproof goes here
 *****[**]
subproof goes here
==See also==
* Brainfuck
BF instruction extension

Our goal is to extend the instructions of Brainf*ck as far as possible. Anything that you thought of could be one of the instructions.
We'll start with the standard commands:
 +-><[],.
Then add commands to set the cell to zero, and loops that only loop if the cell is zero:
 =()
Then use base-36 to set the cell to that value:
 1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ
Then use more base-36 to set the cell to 1 if it's equal to that value, else set to 0:
 $§¥€¢£₩«»•abcdefghijklmnopwrstuvwxyz
Then add commands to create pbrain-style procedures:
 :{}
Then add commands to load,store,and exchange with the accumulator:
 !@*
Then we add commands to do unary bitwise operations (NOT,LEFTSHIFT,RIGHTSHIFT):
 ~/\
Then we add commands to do binary bitwise operations(stored on the pointed cell) (AND,OR,XOR):
 &|^
Now we have this set:
 +-><[],.=()1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ$§¥€¢£₩«»•abcdefghijklmnopwrstuvwxyz:{}!@*~/\&|^
==Examples==
===Cat program===
This infinitely repeating cat program employs the loop-while-zero iteration construct (…):
 =(,.=)
===Truth-machine===
This implementation of a truth-machine harnesses the ability to simulate Boolean test results:
 ,[->+>+<<]>.--------------z[>.<]
==Interpreter==
* Common Lisp implementation of the brainfuck instruction extension project.
==See also==
* BFInfinity
Category:Languages
Category:Brainfuck derivatives
Category:Low-level
Category:Turing complete
Category:Cell-based
Category:Implemented
BF machine

A hardware realization of Brainfuck.
For a machine to be classed as a BF machine, it must:
*Have a 320x240 1-bit screen
*Run standard BrainFuck programs, with these additions:
 @ Flip the pixel at the position in the current cell
? Store the current state of the pixel at the position in the current cell in the current cell
$ Get one keypress (NOT character, but single keydown) and store its value in the current cell (some sort
 of mapping of keys -> numbers is needed here)
*Cells can store unsigned values up 76799, and produce an error instead of wrapping
Prizes for whoever makes the first program to draw a hollow circle in this.
Category:Languages
Category:Brainfuck derivatives
BFasm

BFasm is a programming language that compiles to brainfuck. It is created by User:Evylah.
== Overview ==
=== Memory locations ===
A BFasm program contains 255 memory locations you can use. Each memory location is an actual cell in the brainfuck tape, so it can hold a value of 00-FF. Each location is labeled with a address, and the addresses are written in hexadecimal.
When compiled, this is the structure of the brainfuck tape.
00 to 08 are the memory locations for use in BFasm. The memory locations continue in that pattern until location FF.
== Anchor cells ==
The two anchor cells are always 255 or -1 so the memory pointer knows where to go. Once it moves to a memory location, the memory pointer will move to the left anchor cell so it can go to another cell. (Although if you access address 255 the code will result in > about 515 times.)
There are also two anchor cells: one at the beginning and one after all the variables. The pointer can move to either one using the brainfuck code +[-<+]- (left) or +[->+]- (right).
But there's one issue: If any other cell is 255, then the anchor is pretty much moved over and will break the program.
There's a solution. You may have noticed the 255 was in the tape twice. That is used for checking if it's the real anchor cell. Each memory location is separated with a 0 in between, and that 0 is never modified. If the cell to the right of the anchor cell (the pointer will move to the left anchor cell and check the right one) is not 0, it must be the anchor cell. Text is not an issue, since it will always be 0 in the end.
Action 	Go to left anchor cell? 	Go to right anchor cell?
Copy one memory location's value to another	Yes 	No
Output text 	Yes (to get to the text cell)	No
=== Right anchor cell ===
The cells after the right anchor cell are used for number outputting. A memory location can be copied over to the cells after the right anchor cell, and run an algorithm below to print the value.
 >>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-
 <+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++
 <]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]<
From Brainfuck algorithms
Category:Languages Category:Cell-based Category:Brainfuck
BFshort

BFshort is a Brainfuck derivative where scripts are usually 2x shorter.
== Commands ==
 +-<>[].,
 +`12345678
 -90-=qwert
 <yuiop[]\a
 >sdfghjkl;
 ['zxcvbnm,
 ]./~!@#$%^
 .&*()_+QWE
 ,RTYUIOP{}
== Cat ==
 OQ
== Counter ==
 5*.
==Converter to and from brainfuck==
Written in JavaScript.
const matrix = "`1234567890-=qwertyuiop[]\\asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}";
const bfChars = "+-<>[].,";
function bfshortToBrainfuck(program)
{
 let result = "";
 for(const char of program)
 {
 const index = matrix.indexOf(char);
 if(index >= 0)
 {
 result += bfChars.charAt(Math.floor(index / 9));
 if(index % 9 > 0)
 result += bfChars.charAt(index % 9 - 1);
 }
 }
 return result;
}
function brainfuckToBFshort(program)
{
 program = program.replace(/[^-+<>\[\].,]/g, "");
 
 let result = "";
 for(let i = 0; i < program.length; i += 2)
 {
 const first = program.charAt(i);
 const second = program.charAt(i + 1) || " ";
 const firstIndex = bfChars.indexOf(first);
 const secondIndex = " +-<>[].,".indexOf(second);
 result += matrix[firstIndex * 9 + secondIndex];
 }
 return result;
}
Category:Languages Category:Turing complete Category:Brainfuck derivatives Category:Cell-based Category:Low-level Category:Brainfuck equivalents Category:Implemented
BF²ᵈ

BF²ᵈ is a brainf*** derivative made by User:Masalt in Snap! to allow for video game creation.
==Commands==
Command	Description
> 	Move the cell pointer to the right
< 	Move the cell pointer to the left
+ 	Increment the memory cell at the cell pointer
- 	Decrement the memory cell at the cell pointer
, 	Input a character and store it in the cell at the cell pointer
[ 	Jump past the matching ] if the cell pointer's cell value is 0
] 	Jump back to the matching [ if the cell pointer's cell value is nonzero
| 	Move screen pointer up
_ 	Move screen pointer down
\ 	Move screen pointer left
/ 	Move screen pointer right
. 	Write a pixel at the screen pointer's current location
~ 	Set the screen pointer's brightness to the cell pointer's current cell value
==Examples==
===Infinite Loop===
 +[]
===Hello World===
 \\\\\\\\\\\\\\\\\\\\
 ||._._._._.||/./||._._._._.||//||/.\._._/.\._._./.\///||||._._._._./.||//||._._._._./.
 ||//||/.\._._._._././||||._._._._.||////||._._._._././|||._._._.||._._././||||._._._._
 .||//||/.\._._._._././||||._._._._.||//||._._._._.||/||.__.__||/||._._.__||/||__._._.|
 |//||._._._._./.||//||/.\._._._._././|||._._.+[]
==Interpreters==
The official interpreter
Category:Languages
Category:Brainfuck derivatives