nyuuzyou/wikis huggingface dataset:
Brainflub

Brainflub is an esoteric programming language created by Snorepion. While its documentation is written jokingly, it isn't as much of a joke as some other languages and can be made functional. While the compiler accepts any file extension, the official extension is ".fl".
In the compiler written by Snorepion, the code will be iterated through and a private output string will be set and added to based on the commands instead of writing to the console in real time, then when a | or : command is received, the string will be written to the console. This method of parsing is required for some of the commands.
The C and Python compilers, written by aryantech123, have an additional command.
==Commands==
Command	Description
+ 	Increments the accumulator by one.
- 	Decrements the accumulator by one.
= 	Adds the value of the accumulator represented as an ASCII character to the private output.
 	Informs the parser that it is the end of the program. Required for all programs except those that end as a quine.
: 	Makes the program a quine, stops moving through the code, and removes all previous text that would be given as an output through =.
. 	Immediately writes the contents of the private output to the console. This can be used to output something before using : to make the program a quine.
, 	Clears the private output.
~ 	Resets the accumulator.
space 	Pauses iteration and takes user input from the console.
* 	Writes the user input to the private output string.
d 	Doubles the value in the accumulator, only in the Python and C implementaions.
==Examples==
===Hello, world===
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=+++++++++++++++++++++++++++++=+++++++==+++=~++++++++++++++++++++++++++++++++++++++++++++=------------=+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=--------=+++=------=--------=-------------------------------------------------------------------=|
This program prints "Hello, world!" to the console.
===Quine===
 ++--:|
This program prints its source code ("++--:|") to the console. Only the : is actually needed.
===Cat===
 *|
Copies input to output.
===Double cat===
 **|
Copies input to output twice (ex. if input is "fe" output will be "fefe")
===Join two inputs===
 * *|
Takes two inputs and joins them together.
===Hello world + quine===
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=+++++++++++++++++++++++++++++=+++++++==+++=~++++++++++++++++++++++++++++++++++++++++++++=------------=+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=--------=+++=------=--------=-------------------------------------------------------------------=.:
Prints "Hello, world!" followed by the source code.
==External links==
*Compiler at GitHub
*Python based compiler at GitHub
*C based compiler at GitHub
Category:Languages
Category:Implemented
Brainfoop

Brainfoop (also known as BrainFOOP, BrainfOOP, Brain-Foop, BFOOP or simply Brainfoop) is a variant of Brainfuck that implements object-oriented programming (OOP) to Brainfuck. It was designed by 2000gmod in May of 2021.
THIS LANGUAGE IS STILL BEING DESIGNED.
== Programming in Brainfoop ==
Brainfoop aims to extend the Brainfuck language into a more usable and abstract form, incorporating elements from C and C++. 
Brainfoop has the same operators as Brainfuck, but includes some additional ones, such as context declaration, context switching and halting.
Brainfoop is not a superset of Brainfuck, as Brainfoop requires symbols to declare comments inside code. 
Programming in Brainfoop occurs in 4 different levels:
* Global
* Class
* Instance
* Method
=== Memory ===
Brainfoop extends the memory system of Brainfuck, it provides 4 levels of memory (called contexts). Code can only be executed inside the Global or Method contexts.
== Operators ==
 Program Operators
Operator	Description 	Contexts
> 	Moves cell pointer to the right. 	All
< 	Moves cell pointer to the left. 	All
+ 	Increments pointer by 1. 	Global, Method
- 	Decrements pointer by 1. 	Global, Method
[ 	Jumps past the matching ] if pointer contains 0. 	Global, Method
] 	Jumps back to the matching [ if pointer contains nonzero.	Global, Method
. 	Outputs the current cell as ASCII. 	All
, 	Inputs the ASCII number to the current cell. 	Global, Method
/ 	Stops execution of code of current context. 	Global, Method
# 	Stops execution of program in any context. 	Global, Method
 Context Switch Operators
Operator 	Description
:<CONTEXT>{...}	Declares new element in context.
;<CONTEXT>{...}	Navigates to selected context
== Example programs ==
=== Hello World ===
 :class {
 	:method {
 	 ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>
 ---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++
 }
 }
 
 
 ;class {.} 			/* 	Creates instance of the first class in class space.		*/
 ;instance {.}		 /* Enters the first instance inside the instance space. 	 */
 ;method {.} 		 /* 	Enters the first method of the first instance.			*/
Category:Languages
Category:Object-oriented paradigm
Category:Brainfuck derivatives
Category:2021
Category:Works-in-Progress
Brainfork

Brainfork is a multithreaded variant of Brainfuck, invented by Asger Ipsen in 2004. Brainfork retains Brainfuck's eight commands and adds a ninth, Y, for forking.
When a Y is encountered, the current thread forks, with the current cell being zeroed in the parent thread, and the pointer being moved one to the right and that cell set to 1 in the child.
Because Brainfork is a proper superset of Brainfuck, all Brainfuck programs that do not contain the letter Y are also valid Brainfork programs with identical semantics.
Because Brainfuck ignores all unknown instructions (such as Y), all Brainfork programs are also valid Brainfuck programs, although they may (of course) behave very differently.
==Computational class==
Brainfork is Turing-complete through a trivial reduction from Brainfuck, which is known to be Turing-complete.
==Implementations==
weave.rb with the -Y flag is a Brainfork (and Weave and pbrain and brainfuck) interpreter.
==Examples==
Use the -Y flag.
With the "Y[-<]" up front, this brainfuck example that normally outputs "Just another brainfuck hacker."
Y[-<]
+++[>+++++<-]>[>+>+++>+>++>+++++>++<[++<]>---]>->-.[>++>+<<--]>--.--.+.
>>>++.<<.<------.+.+++++.>>-.<++++.<--.>>>.<<---.<.-->-.>+.[+++++.---<]>>[.--->]<<.<+.++.++>+++[.<][.]<++.
.. instead outputs "JJusutst a anonoththere r brbraiainnffuucckk hahcackekrer.." If the parent had paused a couple cycles, the execution would have been back in sync and the output would have consisted of unjumbled double characters.
===Fork bomb===
+[Y+]
This example spawns a thread, then the new thread and the main thread spawn new threads and so on.
==External resources==
* The Brainfork Home 
* Other than an intro, the Brainfork content is not archived. 
Category:Brainfuck derivatives
Category:Languages
Category:Cell-based
Category:Turing complete
Category:Implemented
Category:Low-level
Category:Concurrent programming
Category:2004
Brainfork (interpreter)

= brainfork =
brainfork is a brainfuck interpreter written by User:SpaceByte it was her first experience writing anything esolang related and originally turned out pretty bad, but functional. It was written in C# with minimal lines of code and had two revisions. 
== Usages ==
Brainfork was used by its creator for many purposes. Before the second revision, it was used (source code is visible on the second branch on github aswell), to launch a discord bot via brainfuck code, by hooking into the interpreter. Brainfork was also used to create bifuck, also starting the second revision of brainfork.
== Developmental Issues ==
===Variable limits===
When writing brainfork, it's creator had multiple issues creating it, most notably, min/max issues. When writing it, the creator was not sure what the minimum and maximums were for brainfuck, and watched variables in loops closely on an online interpreter. This interpreter cited the variables as ranging from -128 to 128, rather than 0 to 512, however, programs execute the same regardless of which one you use, so SpaceByte went with the range of -128 to 128.
=== File Loading ===
A major oversight in the development of brainfork was the way code was loaded via file. In the first revision it loaded via the pdb file in the application on the 8th line. Which was changed in the second revision to load code.bf instead, and changed the way the directory was found, as the first revision did not work properly, and caused issues when running the program compiled as a self contained application.
==Revisions==
The first revision can be found here on github as source code.
The second revisions source code is available here on gist.
Category:Implementations
Brainfuck$

Brainfuck$ (sometimes called Brainfuck with Buffer, although it doesn't really have a buffer at all) is an esoteric programming language derived from Brainfuck, which features only the addition of a stack - which is used to ensure that there will be no data corruption when performing certain operations that require loops - and two new commands for I/O that deal with absolute numbers (meaning an input of '3' will not refer to the ASCII value of '3', but to the number itself).
Brainfuck$ introduces six new "one char" commands:
Command	Description
# 	Copies the byte on the current cell to the top of the stack.
$ 	Removes a byte from the top of the stack and places it in the current cell.
; 	Gets numeric input (instead of char input).
: 	Gives numeric output (instead of char output).
( 	A special kind of loop, much like [, which basically says: Loop n times, where n is the value of the last element on the list when this character is interpreted (it doesn't matter if the top value changes later).
) 	The closing of the list-loop, as in ].
It should be noticed that Brainfuck$ merely extends on the original language, so it still has the primary eight commands.
The most obvious difference between Brainfuck and Brainfuck$ is the classic example of cell copying. It is impossible to make a Brainfuck program which copies the content of a cell without eventually destroying the contents of another cell. For example, if we were to copy the content of cell 1 to cell 2, we'd have to use cell 3 as the loop index, and it's previous contents would be lost. The actual code would be performed this way:
# Clear the contents of both cells 2 and 3
# Copy the content of 1 to both 2 and 3. This will erase cell 1.
# Copy the content of cell 3 to cell 1, therefore erasing cell 3.
This compiles as the following brainfuck program:
>[-]>[-]<<[->+>+<<]>>[-<<+>>]<<
However, Brainfuck$ allows the programmer to not only save the contents of all cells, but to also do so with a much cleaner code, which is:
#>$
In the above three-character-example, the value of cell 1 is copied to the end of the list, the pointer is moved to the following cell, and then the copied value is blit back into cell 2.
==External resources==
* Currently, there is no compiler for Brainfuck$, but there is a language interpreter (requires java).
Category:Languages
Category:Brainfuck derivatives
Category:Cell-based
Category:Stack-based
Category:Turing complete
Category:Implemented
Brainfuck(B,R,A,I,N,F,U,C,K)

Brainfuck(B,R,A,I,N,F,U,C,K) is a Brainfuck-equivalent esolang which is invented by User:None1
==Name==
Brainfuck consists of 8 commands: +-,.<>[].
So, we can define a function Brainfuck(),that takes 8 arguments and creates a brainfuck-equivalent esolang.
I made up this name by feeding the word "Brainfuck" itself into the Brainfuck() function, but "Brainfuck" has 9 letters, so we can add another argument which stands for NOP, other characters are considered invalid, that is how the name comes from.
==Syntax==
B and b equals to brainfuck's +
R and r equals to brainfuck's -
A and a equals to brainfuck's ,
I and i equals to brainfuck's .
N and n equals to brainfuck's <
F and f equals to brainfuck's >
U and u equals to brainfuck's [
C and c equals to brainfuck's ]
K and k is NOP.
Other characters are illegal.
==Example Programs==
===Cat Program===
 buaic
===Infinite Loop===
 buc
==See also==
* Simple translation
* TrivialBrainfuckSubstitution
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Languages
Category:Cell-based
Category:Turing complete
Category:Low-level
Category:Turing tarpits
Brainfuck+

Brainfuck+ is an improved version of brainfuck invented by User:None1. Unlike brainfuck, the name Brainfuck+ should always be capitalized no matter its position in a sentence.
==Differences from brainfuck==
The differences between Brainfuck+ and brainfuck is based on brainfuck's disadvantages:
# Brainfuck uses byte cells, which makes representing integers larger than 255 very hard (though it is possible). Thus, Brainfuck+ uses unsigned 64 bit integers for cells, that means integers from 0 to 18446744073709551615 can be represented directly.
# Arithmetic in brainfuck is very slow. For example, if you want to calculate 15*17 in brainfuck, executing at least 255 commands is inevitable. Thus, Brainfuck+ adds arithmetic commands: a, s and m to let the current cell add, subtract, multiply by the next cell respectively.
# Addressing in brainfuck is also very slow. For example, if you want to move from the 1st cell to the 10000th cell, executing at least 9999 commands is inevitable. Thus, Brainfuck+ adds the & command that moves the pointer to the (x+1)-th cell where x is the current cell value.
# Integer I/O in brainfuck is difficult. Thus, Brainfuck+ adds the command ; and : to do integer input and output.
==Examples==
===A+B Problem===
 ;>;<a:
===Hello, World!===
 >++++++++++<[-]m+++++++m++.[-]+mm+.[-]+mm++++++++.[-]+mm++++++++.[-]+m+m+.[-]m++++m++++.[-]m+++m++.[-]m++++++++m+++++++.[-]+m+m+.[-]+m+m++++.[-]+mm++++++++.[-]+mm.[-]m+++m+++.
==Implementations==
* https://GitHub.com/hilcon222/brainplus from User:Etos
Category:Languages
Category:Brainfuck derivatives
Category:2024
Category:Turing complete
Category:Cell-based
Category:Implemented
Brainfuck++

Brainfuck++ is a Brainfuck extension by Jacob I. Torrey. It's brainfuck with new instructions that enable file I/O and networking, to make it more useful for everyday applications.
Not to be confused with BrainFuck+.
==Commands==
Brainfuck++ is backwards compatible with brainfuck: all brainfuck programs work just the same in brainfuck++. The command set is the same as brainfuck's, with addition of the following:
Command	Description
# 	Opens a file for reading and writing, second call closes the file.
; 	Writes the ASCII character at the current cell to the file, overwriting existing text.
: 	Reads a character from the file, puts the value of the ASCII character in the cell and advances the file pointer.
% 	Opens a socket for reading and writing, second call closes the socket.
^ 	Sends the ASCII character at the current cell.
! 	Reads a character from the socket and places its ASCII value in the current cell.
==External resources==
* Brainfuck++: Making a useless language do more uselessly!
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
Category:Turing complete
Category:Cell-based
Category:Unknown year
Brainfuck+3

Brainfuck+3 is like brainfuck but it has a bidimensional space and it has 3 more commands.
==Commands==
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
^ 	Move the pointer up
v 	Move the pointer down
x 	Exit program.
==Examples==
This code will print "Hello World". It is based on the code from the Brainfuck page, but left is replaced with up and right is replaced with down.
++++++++[^++++[^++^+++^+++^+vvvv-]^+^+^-^^+[v]v-]^^.^---.+++++++..+++.^^.v-.v.+++.------.--------.^^+.
The normal Brainfuck code will also work.
==Implementations==
This is one implementation, done in Python.
def run_bfp3(code: str) -> None:
 pointer = 0 # for instructions
 row = 0 # for up and down tape
 column = 0 # for left and right tape
 tape = [[0]]
 input_string = chr(10) # allows multiple inputs easily
 # checks balance
 balance = 0
 for char in code:
 if char == '[':
 balance += 1
 elif char == ']':
 balance -= 1
 assert balance >= 0, 'unmatched ]'
 assert balance == 0, 'unmatched ['
 while pointer < len(code):
 if code[pointer] == '>':
 column += 1
 if column == len(tape[row]):
 for row_number in range(len(tape)):
 tape[row_number].append(0)
 elif code[pointer] == '<':
 column -= 1
 if column < 0:
 for row_number in range(len(tape)):
 tape[row_number] = [0] + tape[row_number]
 column += 1
 elif code[pointer] == 'v':
 row += 1
 if row == len(tape):
 tape.append([0]*(column+1))
 elif code[pointer] == '^':
 row -= 1
 if row < 0:
 tape = [[0]*(column+1)] + tape
 row += 1
 elif code[pointer] == '+':
 tape[row][column] = (tape[row][column] + 1) % 256
 elif code[pointer] == '-':
 tape[row][column] = (tape[row][column] - 1) % 256
 elif code[pointer] == '.':
 print(chr(tape[row][column]),end=)
 elif code[pointer] == ',':
 if input_string == chr(10):
 input_string = input(">>") + chr(10)
 if len(input_string) > 0 and ord(input_string[0]) != chr(10):
 tape[row][column] = ord(input_string[0])
 input_string = input_string[1:]
 elif code[pointer] == '[':
 if tape[row][column] == 0:
 nest_counter = 0
 while code[pointer] != ']' or nest_counter >= 0:
 pointer += 1
 if code[pointer] == '[':
 nest_counter += 1
 elif code[pointer] == ']':
 nest_counter -= 1
 elif code[pointer] == ']':
 if tape[row][column] != 0:
 nest_counter = 0
 while code[pointer] != '[' or nest_counter >= 0:
 pointer -= 1
 if code[pointer] == ']':
 nest_counter += 1
 elif code[pointer] == '[':
 nest_counter -= 1
 elif code[pointer] == 'x':
 break
 pointer += 1
Category:Languages 
Category:Brainfuck derivatives
Category:Turing complete
Category:Low-level
Category:Implemented
Category:Cell-based
Category:2017
Brainfuck, but every + is replaced with the bee movie script

Brainfuck, but every + is replaced by the bee movie script, or Beefuck for short, is a Brainfuck derivative created in 2017. It is Turing-complete.
Cells in Beefuck are required to have a range of at least 2^32-1. This rule is intended so you can't "cheat" by substituting the increment command for a bunch of decrements, as that many decrements would be longer than the increment command. This can be circumvented by utilising wraparound and decrementing in a loop (example below).
== Syntax ==
Beefuck supports the following commands:
Command 	Description
> 	Move the pointer to the right
< 	Move the pointer to the left
According to all known laws of aviation, there is no way a bee should be able to fly. Its wings are too small to get its fat little body off the ground. The bee, of course, flies anyway because bees don't care what humans think is impossible. Yellow black, yellow black...[sic] - full command here, although that transcription of the command contains several mistakes - e.g. many Cs are replaced with Os. In the interest of ease of implementation, interpreters are permitted to accept either the correct version, or this one, or even both! Line breaks are optional.	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 forward to the matching ] if the cell under the pointer is zero
] 	Jump back to the matching [ if the cell under the pointer is nonzero
Note that the increment command contains characters such as . and ,. These punctuation marks must be ignored if part of an increment command. But they must be treated as beefuck code if only part of the increment command is there, the rest missing or incorrect.
== Examples ==
=== Increment cheat ===
 ->--[<->-]
=== Hello World program ===
 ->-----------[<->-]<
 [
 >
 ->-----------[<->-]
 >->--------[<->-]
 >->-----[<->-]
 <<<<
 <<-
 ]
 >>>
 ->---[<->-]<.
 <<
 ->--[<->-]<.
 ->--------[<->-]<..
 ->----[<->-]<.
 >>>>
 ->-----[<->-]<.
 ------------.
 <<<<
 ->---------[<->-]<.
 --------.
 ->----[<->-]<.
 ------.
 --------.
 >>>>
 ->--[<->-]<.
Other examples of beefuck code that contain the increment operator are ommited here, partly due to their large file size, and partly because of potential copyright issues.
== Implementations ==
Wow! You can now compile brainfuck to beefuck and run your beefuck programs using this AMAZING implementation!!!
Category:Languages
Category:Joke languages
Category:Brainfuck equivalents
Brainfuck--

Brainfuck-- is a language made by User:Wh1teWolf and is a downgraded version of brainfuck, that uses only five instructions.
== History ==
Brainfuck-- was created by User:Wh1teWolf in 2009 in an attempt to make a language that had as few instructions possible, while still being Turing Complete (but falls short because of lack of memory). The language was also made as a test of skills.
== Specification and instruction list ==
Unlike brainfuck Brainfuck-- uses 32 binary bits as a way to store memory, the first 8 bits is used with the input/output instruction, the rest can be used for other things.
There are 5 instructions:
 + Sets current bit to the opposite of itself
 . Output ascii equivalent of first 8 bits if nonzero, else input one letter and store its value in first 8 bits
 > Move to next bit
 [ Jump past the matching ] if the current bit is 0
 ] Jump back to the matching [ if the current bit is nonzero 
== Examples ==
===Hello program===
 >>>+>>>+. H
 >>>>>>>>>>>>>>>>>>>>>>>>>>+>>+>+>>+. e
 >>>>>>>>>>>>>>>>>>>>>>>>>>>+>>>+. l
 . l
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+. o
===Cat program===
 >>>>>>>>+[+.+.]
Moving the pointer one step back
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Moving the pointer five steps back
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>
==See also==
*Brainfuck-- interpreter written by User:Wh1teWolf
*Brainfuck---
*Brainfuck minus -
*Minifuck
*Minifuck-2D
Category:Languages
Category:Low-level
Category:Brainfuck derivatives
Category:Turing tarpits
Category:Implemented
Category:Cell-based
Category:2009
Brainfuck---

Brainfuck--- is a language made by User:A and is a downgraded version of brainfuck--, that uses only four instructions.
== History ==
Brainfuck--- was created by User:A in 2018 in an attempt to make a language that had as few instructions possible, while still being Turing Complete (but falls short because of lack of memory). The language was also made as a test of skills.
== Specification and Instruction List ==
Unlike brainfuck Brainfuck--- uses 32 binary bits as a way to store memory, the first 8 bits is used with the input/output instruction, the rest can be used for other things.
There are 4 instructions:
 + Sets current bit to the opposite of itself
 . Output ascii equivalent of first 8 bits if nonzero, else input one letter and store its value in first 8 bits
 > Move to next bit
 : Make a for loop making the current cell as count, looping all the commands until endline.
== Examples ==
===Hello Program===
 >>>+>>>+. H
 >>>>>>>>>>>>>>>>>>>>>>>>>>+>>+>+>>+. e
 >>>>>>>>>>>>>>>>>>>>>>>>>>>+>>>+. l
 . l
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+. o
===Cat program===
 ..
===Moving the pointer one step back===
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
===Moving the pointer five steps back===
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>
==See also==
*Brainfuck
*Brainfuck--
*Minifuck
*Minifuck-2D
Category:Languages
Category:Low-level
Category:Brainfuck derivatives
Category:Finite state automata
Category:Implemented
Category:Cell-based
Category:2018