nyuuzyou/wikis huggingface dataset:
Brainfuck⁰

Brainfuck⁰ is an esolang invented by User:None1 and inspired by Brainfuck², it is very stupid. It is like BF with only the instruction, but way worse because you can only increment zero times or once.
==Commands==
The only valid program - Brainfuck increases the accumulator.
==Examples==
===Increase the accumulator===
 Brainfuck
==Interpreter==
===Python===
 a,x=input(),0
 if a=='Brainfuck':
 x+=1
==See also==
* +
Category:Languages Category:Joke languages Category:No IO Category:Implemented Category:Total
Brainfudge

Brainfudge is identical to Brainf**k.
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
It exists solely to provide a language identical to Brainf**k that can be written and spoken about without cursing.
Category:Languages Category:Joke languages Category:Brainfuck equivalents Category:Brainfuck derivatives Category:Implemented Category:Turing tarpits Category:Turing complete Category:Low-level Category:Cell-based
Brainfun

== Info ==
Brainfun is a WIP variant of Brainf--- that was made to be simple, like an actual programming language. It takes on the same way of coding in Brainf---. You have a huge 1D array to increment and decrement values. However, in BrainFun, you have a lot more freedom and ability to code.
 Characters
Character	Description 	Example
<n 	Makes the pointer go left n times. 	<8 (moves pointer to the left 8 times)
>n 	Makes the pointer go right n times 	>3 (moves pointer to the right 3 times)
=n 	Sets the value you're pointing at into n as a string 	=Hello, World!
~n 	Converts the value you're pointing at into a different type	~s (converts it to a string)
. 	Prints the value you're pointing at. 	(you already know what this does)
, 	Sets the value you're pointing at into string input 	(again, no example needed)
+n 	Increments the value you're pointing at n times 	+7 (increments value by 7)
-n 	Decrements the value you're pointing at n times 	(no example needed again)
== Convertion ==
Converting types is very important, as setting a data value always makes it a string.
Here is the code for converting what you're pointing at into what you want it to be.
 Conversion
Code	Converts it to...
~s 	String
~i 	Integer
~f 	Float
~e 	Evaluation/Answer to equation
Category:Languages Category:Brainfuck derivatives Category:Cell-based
Brainfunc

Brainfunc (not capitalized except at the start of a sentence) is a variation of brainfuck which uses functions instead of loops for flow control.
==Memory==
Brainfunc uses a tape of wrapping unsigned eight-bit cells, unbounded in both directions. It also uses a cell pointer to keep track of which cell is currently selected. The cell pointed to by the cell pointer is often called the current cell.
==Functions==
Functions are terminated by right parentheses ()). Execution begins at the character after the rightmost such parenthesis. For example, the program ++)+)%>+ contains the functions ++ and +, and would begin execution at the percentage sign (%); note that the subprogram %>+ is not a function, since it is not terminated by a right parenthesis.
==Commands==
Command	Effect
+ 	Increment the current cell.
> 	Increment the cell pointer.
< 	Decrement the cell pointer.
% 	If the current cell is less than 32 and not equal to 10, then take the Unicode codepoint of the first character of user input, divide it by 256, and set the current cell to the remainder; if no input is given, then set the current cell to the number 10 instead. Otherwise, output the Unicode character whose codepoint is equal to the current cell.
^ 	If the current cell is not 0, call the (zero-indexed) Nth function, where N is a base-7 number following this command. If the code after this command does not match the regular expression ^[0-6]+, or if the Nth function does not exist, then throw an error and terminate the program instead.
) 	Return from the current function.
Implementations can also implement the optional ? command, which outputs the current state of the tape in an implementation-defined manner.
All unrecognised characters are ignored.
==Examples==
===Hello, world!===
^2^2^2^2^2^2^2)+++++)^1^1)
++^0%
^2^2^1++++%
^1++%%+++%>
++++^2^2^2^2%>
++^2^2^2%<
^0^1%<
%+++%^0^0^0^2^2^2^2%>
^0^0^0^2^2^1++%>
+%
>+++++^1%
===Cat program===
 %%>+^0)+^0
===Truth-machine===
^1^1^1^1^1^1^2)++++++++)%^2)%%++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++^0
===Print all printable characters===
 %+^0)+++++++)+++^1%+^1^1^1^0
==External resources==
* An interpreter written in Python
Category:Languages Category:2020 Category:Turing complete Category:Cell-based Category:Low-level Category:Turing tarpits Category:Implemented Category:Brainfuck derivatives
Brainfunk

Brainfunk 
Brainfunk is a extension of brainfuck with same eight commands and more eight commands.
Common brainfuck uses only two tapes, a tape for code and a tape for data, brainfunk have also a tape for I/O. 
That tape could point to diferent devices as need, mapped as tape cells.
Command	Description
> 	Move the pointer to the right
< 	Move the pointer to the left
+ 	Increment the memory cell at the pointer
- 	Decrement the memory cell at 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 at the pointer is 0
] 	Jump back to the matching [ if the cell at the pointer is nonzero
Command	Description
= 	swap tapes
& 	reset
% 	halt
$ 	nop
~ 	unary negation
! 	reserved, nop
? 	reserved, nop
@ 	reserved, nop
To move the I/O tape forward or backward, use '=' to swap which tape is moved by '<' and '>'.
To copy a byte from data tape into i/o tape use '.' and to copy a byte from i/o tape into data tape use ','. 
Also, when in homebrew computers, use '&' for reset, '%' for halt, '$' for nop, '~' for unary negation, reserves '?', '!', '@' for future expansion, by now all are nop.
Category:Languages Category:Brainfuck derivatives Category:Cell-based Category:Low-level Category:Turing complete
Brainf̶u̶c̶k̶

brainfuck is a pretty good esolang, but you can't use it without a hippocampus. Though this is an awful esolang, you don't need a hippocampus to use it.
==Introduction==
This is an esolang created by User:D, for people who wouldn't bother to remember the state of the program. But people with a normal hippocampus can still use it as well.
==Execution==
This esolang has only one command: [, which jumps to the end of the program. All other characters are NOPs. Brackets don't have to match.
==Example Programs==
=== Do nothing ===
[
or:
[]
A more elaborate one:
[[][[]][]]
Another version:
>>>[>>]<<[>]<[>]
==Interpreters==
===><>===
12 bytes
 i:0(?;"["=?;
===brainfuck===
>>>>>>>>>>>>>>>,>[-]+>[-]<<[>>+<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<[>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>>>>>[-]++++++++++<<<<[-]<[-]>>>>[<<<<+>>>>-]+>[<<<<<->+>>>>-]<<<<[>>>>+<<<<-]<[>>>>-<<<<[-]]>[-]>>>[<-<<+>>>-]<<<[>>>+<<<-]>>[<<+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[-]<[-]>>[<<+>>-]+<<<[>->+<<-]>>[<<+>>-]<[>>-<<[-]]<[-]>>[-]<[-]>>[<+<+>>-]<[>+<-]<[>>>[-]<<<[-]]>[-]<[-]>>>[<<+<+>>>-]<<[>>+<<-]<[>>,>>[-]<<[>>+<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<[>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>[-]<[-]>>>>[<<<<+>>>>-]+>[<<<<<->+>>>>-]<<<<[>>>>+<<<<-]<[>>>>-<<<<[-]]>[-]>>>[<-<<+>>>-]<<<[>>>+<<<-]<[-]]>>>]
The program is generated by BFFuck.
===C===
#include<stdio.h>
int main(){
 char c;
 while((c=getchar())!=EOF){
 if(c=='[') return 0;
 }
 return 0;
}
===Common Lisp===
An implementation in Common Lisp follows. Please note that, owing to brainfuck's name, Unicode support is mandated; however, the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
 (defun interpret-brainf̶u̶c̶k̶ (code)
 "Interprets the piece of brainf̶u̶c̶k̶ code and returns ``NIL."
 (declare (type string code))
 (loop with ip of-type fixnum = 0 while (< ip (length code)) do
 (if (char= (char code ip) #\[)
 (setf ip (length code))
 (incf ip))))
=== JavaScript ===
function you_can_brain_without_a_fuck(program){
 var ip=0;
 while(ip<program.length){
 if(program[ip]=="["){
 ip=program.length;
 }else{
 ip=ip+1;
 }
 }
}
=== Python ===
import sys
ptr = 0
prog = open(sys.argv[0]).read()
while ptr < len(prog):
 if prog[ptr] == '[':
 ptr = len(prog)
 continue
 ptr += 1
===WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic++===
do
bulk infect
if number of Infections = 91 Then
Exit Do
end If
Loop while number of Infections <> 10
==See also==
* brainfuck (a.k.a. "You can fuck without a brain")
* brainfuck (a.k.a. "You can without a brainfuck")
* Header comment technique
* Nil
* APLWSI
Category:Languages
Category:Joke languages
Category:No IO
Category:Unusable for programming
Category:Total
Category:Brainfuck derivatives
Braingrate

Braingrate is a parody of brainfuck created by User:Aadenboy which adds seven new commands to supposedly make programs easier to work with. It is entirely written in Lua, and the interpreter is exactly 3,000 bytes big (including comments). The interpreter only accepts any .txt files named "braingratescript".
== Language Overview ==
Braingrate uses commands like brainfuck's, but there is also a set of extra commands with their own functions too. All cells may only be 0-255 in value, and there is only 256 cells to be worked with. The pointer always starts off at the first cell (cell 0).
Command	Description
> 	Move the pointer to the right
< 	Move the pointer to the left
+ 	Increment the chosen cell's value up by one
- 	Decrement the chosen cell's value down by one
. 	Output the ASCII character corresponding to the chosen cell's value
: 	Output the chosen cell's value
, 	Gets input from the user as a number and stores it into the chosen cell
; 	Gets input from the user as any valid ASCII character and stores the ASCII code into the chosen cell
[ 	Create a loop starting at this command's position in the script
] 	Go back to the previous [ command only if the chosen cell's value is 0
= 	Copy the chosen cell's value to the cell to the left of it
? 	Set the chosen cell's value to a random value from 0-255
* 	Ignore the rest of the commands if the current cell is equal to the previous one until another * command is found
^ 	Skip the next command
# 	End the program
Any other characters will be treated as comments.
== Example Programs ==
=== Truth Machine ===
This program below is an example of a Truth Machine.
 ,[:]
While the program is a valid truth machine, it doesn't seem like one when dealing with other values such as 176, or 255. The program below accounts for that, and will print a 0 if it is not 1, otherwise it will indefinitely print 1s.
 ,=<-*>[-]<^*>[:]
=== One Time Cat ===
The cat machine program has exactly two variations.
This first program will output whatever number was inputted.
 ,:
This second program will output whatever ASCII character was inputted.
 ;.
Category:Brainfuck derivatives
Category:2022
Category:Cell-based
Category:Implemented
Brainhook

Brainhook is a esolang created by User:Yayimhere to minimize Brainfuck
== memory ==
memory is a tape the continues to the right forever. the tape pointer moves right every command. each cell is 6 bit and wrap(so if 0 is decremented its set to 63)
== commands ==
 commands
command	description
# 	go back to the first cell of the tape
- 	decrement the cell
:...:n 	loops ... while current cell non zero with nesting n
X 	NOP
==See also==
* brainhooking
Category:Languages Category:Cell-based Category:Brainfuck derivatives Category:Unimplemented Category:Low-level
Brainhooking

brainhooking is brainhook but smaller. its made by the same creator
== changes ==
first of all now theres only 500 cells(with wraping around), second of all the # command is gone, and - is changed to +(n) which will add the signed binary number n onto the current cell
Category:Languages Category:Cell-based Category:2024 Category:Brainfuck derivatives Category:Unimplemented Category:Low-level
Brainjump

brainjump is an esolang by User:ChuckEsoteric08 which was created in March of 2022 but published only in November of 2023
==Specification==
brainjump uses tape infinite in both directions which stores unbounded integers as memory.
==Commands==
 > - move right and increment cell
 - - decrement cell
 < - move left
 ^ - if current cell is not zero go back to the start of a program
 ! - go back to the start of a program
==Computational class==
Author thinks that the language is Turing-complete, but it's not proven. He also thinks that command ! is not needed for Turing-completness
Category:Languages Category:Unknown computational class Category:Unimplemented Category:2022 Category:Cell-based
Brainletter

Brainletter is brainword with characters instead of commands.
== Commands ==
 + increments selected accumulator
 - decrement selected accumulator
 | switches accumulator
 ^ repeats the commands after it selected accumulator times
 . outputs ascii if it is valid. otherwise, error
 ? deletes every folder, therefore terminating it.
== HI ==
 +^+^+^+^+^+^++++++++.+.
== Constants ==
Brainword/constants
Category:Languages
Brainlisp

Brainlisp is an experimental language designed as a simple test for Lisparser.
== Overview ==
It has the following instructions (functions):
* (left) - Move memory pointer left
* (right) - Move memory pointer right
* (inc) - Increment memory cell
* (dec) - Decrement memory cell
* (in) - Read from stdin
* (out) - Write to stdout
* (loop ...) - Execute ... while memory cell is non-zero
== Examples ==
=== Cat program ===
 (in) (loop (out) (in))
=== Hello, World! ===
 (inc) (loop (dec) (dec) (right) (dec) (loop (right) (right) (inc) (right) (dec) (dec) (dec) (dec)
 (dec) (left) (left)) (left) (dec) (dec) (left) (dec) (dec) (dec)) (right) (dec) (out) (right)
 (right) (right) (inc) (out) (right) (right) (out) (out) (inc) (inc) (inc) (loop (out) (right))
 (left) (left) (left) (left) (out) (inc) (inc) (inc) (out) (dec) (dec) (dec) (dec) (dec) (dec) (out)
 (left) (left) (dec) (out) (right) (right) (right) (right) (inc) (out)
=== Truth-machine ===
 (in)(out)(loop(loop(dec)(left)(inc)(right)(right)(inc)(left))(right)(dec))(left)(left)(left)(loop(left)(left))(right)(loop(out))
== Interpreters ==
Interpreter
Category:Languages
Category:Turing complete
Category:Implemented
Category:2020
Brainloller

Brainloller is a Brainfuck clone designed by Lode Vandevenne in 2005. Commands are read from the pixels of a .png image (like Piet), with 2 extra commands. The extra commands change the instruction pointer direction so that you can compact the 1D Brainfuck code into a 2D image. You can hide Brainloller code in a photo or draw comments.
These extra commands provide almost no extra functionality, and are reversible. You can convert back to 1D Brainfuck code by removing the rotate IP commands and storing the instructions back in 1D order. To compact code you can use wire crossing so that one pixel can be used twice as the same command.
Execution starts at the top-left (0, 0) pixel. When the instruction pointer goes past the edge of the image, execution halts.
Translation of Brainloller commands into Brainfuck:
Color 	RGB 	Function
red 	(255,0,0) 	>
darkred 	(128,0,0) 	<
green 	(0,255,0) 	
darkgreen 	(0,128,0) 	
blue 	(0,0,255) 	.
darkblue 	(0,0,128) 	,
yellow 	(255,255,0)	[
darkyellow	(128,128,0)	]
cyan 	(0,255,255)	rotates the IP 90° clockwise
darkcyan 	(0,128,128)	rotates the IP 90° counter-clockwise
others 	n/a 	nop
At execution start, everything is 0, the IP (instruction pointer) is at the top left, and moves to the east.
The code size is the same as the size of the image.
The memory array exists out of bytes. The bytes are wrapping (if you increment 255, you get 0, if you decrement 0, you get 255).
The memory array is of arbitrary size, depending on what your platform can handle. You can increase the memory pointer forever, it'll allocate the necessary memory until it's full.
When the memory pointer is zero and you try to decrease it, it'll stay zero.
When searching for matching Brainfuck ] commands, the north/east/south/west path is traversed the same way as the IP does.
When searching for matching Brainfuck [ commands, the north/east/south/west path is traversed the opposite way as the IP does.
When the IP reaches the edge of the image and goes outside, the program will stop (END).
Infinite loops due to the IP rotators can never happen because they're reversible and the IP starts at the top left.
==Example==
The following is an enlarged Hello, world! program in Brainloller, followed by the actual program:
There is also a shorter one:
 
==Extended Brainloller==
Following the Extended Brainfuck specification, the following commands were also added in 2015 by TrapperHell. Despite the visual similarities in colour, the specification aims at having a distinctive and uniform RGB color-range gap across the commands.
Type 1
Color 	RGB 	Function
lightgreen 	(0,192,64)	@
orange 	(192,64,0)	$
purple 	(64,0,192)	!
brightgreen	(64,192,0)	
==See also==
* Braincopter
* Brainfuck
==External resources==
* Interpreter source code and more examples 
* php implementation - php class to parse brainloller images.
* Brainloller Encoder & Decoder - A tool to create Brainloller images and to decode Brainloller images into Brainfuck code. 
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
Category:Cell-based
Category:Non-textual
Category:Two-dimensional languages
Category:Low-level
Category:Turing complete
Category:2005
Brainlove

Brainlove is another extension of the brainfuck language.
== Description ==
Brainlove adds a few more commands to brainfuck in order to make it easier to program in.
== Commands ==
(Assuming ptr is a pointer to a char array and str is a char variable.)
Command	C translation
> 	++ptr;
< 	--ptr;
+ 	++(*ptr);
- 	--(*ptr);
. 	putchar(*ptr);
, 	*ptr = getchar();
[ 	while(*ptr) {
] 	}
( 	while(!*ptr) { /* loop while *ptr == 0 */
) 	}
~ 	break; /* break from the most inner loop */
$ 	str = *ptr; /* store *ptr in storage, taken from Extended Brainfuck Type I */
! 	*ptr = str; /* return from storage, taken from Extended Brainfuck Type I */
== Examples ==
Not function (0 becomes 1 and 1 becomes 0)
 -[++~]
if(value != 0) {STUFF}
 [STUFF~]
if(value == 0) {STUFF}
 (STUFF~)
Swap two values who are next to each other (uses one extra cell)
 $>>!<$<!>>$<!>
Category:Brainfuck derivatives Category:Languages Category:Cell-based Category:Low-level Category:Turing complete
Brainmaze

Brainmaze is a maze solver that also executes brainfuck code. It turns right every time it hits a wall.
= is subtract instead of -
Same with:
 = -
 > }
 < {
The pointer is v^<>
== Ascii loop ==
 |---|
 |.+ |
 | |
 |---|
This is the only program i coded because im lazy and dont want to use all the cool new mechanics to make a cool new hello world.
Category:Turing completeCategory:LanguagesCategory:Brainfuck derivativesCategory:Two-dimensional languagesCategory:Cell-basedCategory:Unimplemented
Brainmulti

Brainmulti constitutes a derivation of brainfuck extending the memory to a three-dimensional space, whence ensues the necessity for 12 rather than the acquainted octuple instruction set.
==Commands==
 > pointer north
 < pointer south
 ^ pointer west
 v pointer east
 o pointer up
 O pointer down
 + increment cell at pointer
 - decrement cell at pointer
 . output cell at pointer ASCII
 , input cell at pointer ASCII
 [ you know what it is
 ] you know what it is
==Examples==
===Kiwiscript===
 ++++++++++[v++++++++++^-]v+++++++.[^+v-]^--.++++++++++++++.--------------.
===66666666 box===
 ++++++[>+^+<+o+>+v+<+O-]++++++
===Truth-Machine===
A truth-machine is implemented in the following:
 ,.[--o+[oo]O[.]OO]
==BF equivalents==
 Caption text
BM	BF
> 	>>>>>>>>>>>>>>>>>>
< 	<<<<<<<<<<<<<<<<<<
^ 	>>>>>>>
v 	<<<<<<<
o 	>>
O 	<<
- 	-
+ 	+
. 	.
, 	,
[ 	[
] 	]
There are bugs, I just use prime numbers to mostly avoid them.
==Interpreter==
* Common Lisp implementation of the Brainmulti programming language.
Category:Brainfuck derivativesCategory:Multi-dimensional languagesCategory:2023Category:LanguagesCategory:Cell-basedCategory:Turing completeCategory:2023Category:Implemented
Brainnumber

Brainnumber is an esolang created by User:Unname4798. It is like brainword, but there are no words, only numbers.
==Commands==
 0 - increment the selected accumulator
 1 - decrement the selected accumulator
 2 - switch the accumulator
 3 - repeat the next instruction (the selected accumulator's value) times
 4 - output Unicode character with a value of the selected accumulator's value
 5 - delete all folders and halt.
 Comments can only span one line. Use # for comments.
Category:Languages
Brainrot (Theothetruenerd)

Ever wanted to use your brainrot and slang to code? No? Well now you can anyway. Inspired by many screenshots that went around various social media sites.
== Overview == 
The syntax of brainrot is relatively simple, the only real quirks (besides the horrid brainrot code) are that some statements require semicolons, and some don't. It is currently a WIP and hasn't been bootstrapped yet.
Keyword 	Meaning
highkey 	Declare a variable with type
lowkey 	Assign a variable
vibe_check 	Opening "if" statement
big_yikes 	Opening "else" statement
leftpilled 	Used where a left bracket would often be used
rightmaxxer 	Used where a right bracket would often be used
shoutout 	Print
fuck_around 	Try
find_out 	Except
its_giving 	Return
spill_tea 	Log
yap 	Log-level debug
tea 	Log-level info
ick 	Log-level warning
oof 	Log-level error
tweaking 	Log-level critical
pour_tea 	Set log level
yeet 	Delete a variable
ratios 	">"
grind 	While
cap 	False
no_cap 	True
gg 	Break
periodt 	Exit
bruh 	Raise
cringe 	Exception
based 	OSError
bodycount 	Length of a list
slept_on 	Pass
npc 	Defining a function
iykyk 	Creating a dictionary
situationship 	Adding to a dictionary
hooks_up_with 	Links the key-value pair when adding to a dictionary
sneaky_link 	Lookup in a dictionary
bffr 	User Input
homies 	Begin defining a list
no_homo_tho 	End defining a list
run_a_train_on 	Loop through a list
get_your_boy 	Get from a list
uwu [insert identifier here] whats_this	Read from file into identifier
aura 	Get variable type
valid 	Check if true
ghost 	Float (when declaring variable type)
lead_on 	String (when declaring variable type)
basic 	Int (when declaring variable type)
bet 	Bool (when declaring variable type)
== Example Code ==
 pour_tea tea;
 highkey x basic = 5;
 highkey y lead_on = "test";
 shoutout leftpilled y rightmaxxer;
 spill_tea yap leftpilled x rightmaxxer
 lowkey y lead_on = "test2";
 shoutout leftpilled y rightmaxxer;
 this_is_a_list homies test3, test4 no_homo
 run_a_train_on this_is_a_list (where_we_at) leftpilled
 shoutout leftpilled where_we_at rightmaxxer;
 vibe_check(where_we_at ratios x) leftpilled
 shoutout ("----------------");
 shoutout ("Is bigger than 5");
 big_yikes leftpilled
 shoutout ("Is smaller than 5");
 rightmaxxer
 rightmaxxer
==See also==
* Gen Alpha
* Gen Alpha Brainrot
* Rizzlang
Category:Languages
Category:2024
Category:Joke languages
Category:Pseudonatural
Category:Unimplemented