nyuuzyou/wikis huggingface dataset:
Boolfuck

Boolfuck is an esoteric programming language based on Brainfuck, but operating only on bits. It does, however, provide input and output.
==Commands==
Command	Meaning
+ 	Invert the bit that the current tape cell holds.
, 	Input.
; 	Output.
< 	Move tape head left.
> 	Move tape head right.
[ 	Jump past matching ] if current tape cell holds 0.
] 	Jump back to matching [.
==Computational class==
Boolfuck can be shown to be Turing-complete by reduction from Brainfuck. Each Brainfuck program maps to a Boolfuck program - so anything that can be expressed in Brainfuck can also be expressed in Boolfuck - and Brainfuck is known to be Turing-complete.
More details on the reduction can be found at the Boolfuck website, listed below.
== Differences from Brainfuck ==
* Works with bits not bytes. Each cell is 1-bit and wrapping, so - is removed.
* The output character is ; not ..
* The input is read in little endian mode and reads a single bit at a time.
* Output is stored to a stream, then outputted in little endian mode.
== IO explanation ==
The IO in Boolfuck works via streams. Input (as before mentioned) is read in little endian and reads a single bit at a time. Such that if a user was to input 0 the bits would be read as 00001100. The output is decided one bit at a time, such that a programmer may use a single bit of memory to send an entire byte of data to the output stream. For example to print 1 you may use +;+;;;+;;+;; (to generate the bit stream 10001100) assuming the bit is a zero to begin with.
== Examples ==
Here is a sample Boolfuck program; it outputs Hello, world!:
;;;+;+;;+;+;
+;+;+;+;;+;;+;
;;+;;+;+;;+;
;;+;;+;+;;+;
+;;;;+;+;;+;
;;+;;+;+;+;;
;;;;;+;+;;
+;;;+;+;;;+;
+;;;;+;+;;+;
;+;+;;+;;;+;
;;+;;+;+;;+;
;;+;+;;+;;+;
+;+;;;;+;+;;
;+;+;+;
==See also==
Other languages operating on bits (implemented only):
* FlipJump
* BIT
* BoolX
* Bitch
* BitChanger
* Bitter
* Boolet
* BitBitJump
* Smallfuck
==External resources==
* Boolfuck website
Category: Languages
Category: Brainfuck derivatives
Category: 2004
Category: Turing complete
Category: Implemented
Category: Turing tarpits
Category: Cell-based
Category: Low-level
Boolgrid

Boolgrid is an esoteric programming language created by User:sigurdwe. It is one of many Brainfuck derivatives operating on single bits. It can be described as an extended two-dimensional variant of Smallfuck.
== Operations ==
The memory is a two-dimensional array of bits. The initial memory configuration is set via an input file, and the final configuration output when the program stops. The operations in Boolgrid code consist of pointer move instructions, a bit flipper and two loop types.
 < Move to the left
 > Move to the right
 ^ Move up
 v Move down
 + Flip the current bit
 [op] Loop the operations as long as the current bit is 1
 (op) Loop the operations "infinitely"
Infinite loops break when trying to move outside the allocated memory, making them useful when operations need to be performed on entire rows or columns.
== Examples ==
The following examples assume binary numbers to be stored row-wise in little endian order, allowing arbitrary integer sizes. To increment such a number by 1, the code [+>]+ can be used. Adding two numbers requires a slightly more complicated code, but this can again be used to easily generate Fibonacci numbers, in the following way:
 (([vv+^^>]>)vvv(<)(+>)^^(<)([vv+^[+>]+v[<]^^>]>)vv([+]<)^^)
The following code calculates the Collatz sequence for a given number and counts the number of iterations in its cycle:
 (>)+[+<+]+vvvv+(<)+[+(^)[vvv+^^^([v+^>]>)([+>+<<]<)+v([+^[+>]+v(<)]>)](^)(<)vvv+[+^^^([+<+>>]>)(<)vvv]^[+>]+^^(>)+[+<+]+vvvv+(<)+]([+>]>)
Comments to these codes can be found in the readme file of the interpreter.
In addition to operations on bit strings, Boolgrid is suitable for simulations of Cellular automata and other binary iterated maps.
== External resources ==
* Boolgrid interpreter with source and examples
Category:Languages
Category:Low-level
Category:2010
Boolshit

Boolshit is a Boolfuck derivative that does not have any I/O instructions, but can still perform I/O operations.
== Memory ==
Memory is an unbounded tape of bits. Only nonnegative addresses (cells) can be accessed. Performing < when the memory pointer is 0 throws an error.
== Commands ==
Command	Description
< 	Move the pointer to the left
> 	Move the pointer to the right
~ 	Flip the memory bit at the pointer
[ 	Jump past the matching ] if the cell at the pointer is zero
] 	Jump back to the matching [ if the cell at the pointer is nonzero
== I/O ==
Input and output are strings of bits. We define the process of escaping a string of bits: given an unescaped string of bits, to escape it prepend a single 1 bit before each bit of the string and then append a single 0 bit. The process of unescaping a string of bits is simply a reverse of escaping: given an escaped string of bits, you extract bits from the odd positions (0-indexed) and concatenate them. Note that all escaped strings are prefix-free (no escaped string is a prefix of another escaped string).
At any point during the program execution, let n\in\mathbb N be the maximal number such that the memory cells 0,\dots,n-1 will not be modified anymore by the program. We interpret the values of those cells as an array of escaped strings (and if there are not enough bits in the last string to unescape it properly (the n-1 th cell has value 1), then ignore it). Then do the following:
* If the input is empty, output the first string among those and halt the program
* If the input is 0, then output the 2nd string and halt the program
* If the input is 1, then output the 3rd string and halt the program
* If the input is 00, then output the 4th string and halt the program
* If the input is 10, then output the 5th string and halt the program
* If the input is 01, then output the 6th string and halt the program
* If the input is 11, then output the 7th string and halt the program
* If the input is 000, then output the 8th string and halt the program
* If the input is 100, then output the 9th string and halt the program
* If the input is 010, then output the 10th string and halt the program
* And so on ...
Before we output a string, we implicitly unescape it. If there are not enough escaped strings (for example, the input is 01 and we can safely extract only four strings), then let the program execute one more step.
Category:Languages
Category:Uncomputable
Category:2020
Boom

Boom is a very simple language, created by User:Talbi. It is so simple, in fact, that you have (probably) already written a valid program for Boom, which is:
or, an empty program - which is also the only valid program. Any program with any characters will throw a syntax error. The empty program is guaranteed to run forever (i.e. an infinite loop).
== Implementations ==
* C interpreter 
Category:Languages Category:Joke languages Category:Unusable for programming Category:No IO Category:Zero-dimensional Category:Implemented
Boomerlang

Boomerlang is an esoteric programming language developed by User:Quito0567 on August 27, 2023. It uses a pointer, referred to as a boomerang, that is constantly moving in a certain direction and executing any lines of code it touches. The boomerang also reverses its direction whenever it reaches the program's top or bottom, resulting in an infinitely repeating program. Note that when the boomerang changes direction, the line # it is currently at is not re-executed.
== Commands ==
* Toss outputs the following value(s) to the console.
* "Catch variable from prompt" gets user input with the specified prompt and stores the response in the specified variable.
* "Throw boomerang x feet direction" causes the boomerang to travel x lines in the specified direction (north = up, south = down). You can also use just throw boomerang to simply reverse the boomerang's direction. This is useful for creating loops. Each time a throw boomerang is executed, the built-in throws variable will be incremented by 1.
* Catch boomerang terminates the program.
* Curly braces can contain multiple lines. When the boomerang reaches the first or last line in curly braces, its direction will be reversed.
* Variables are assigned like in standard Python.
== Example programs ==
=== Hello, world! ===
 toss "Hello, world!"
 catch boomerang
=== Truth machine ===
 catch input from "Enter 0 or 1: "
 if input = 0: {toss 0; catch boomerang}
 if input = 1: toss 1
=== 99 bottles of beer ===
 b = 99 {
 if throws = 196: {
 toss "1 bottle of beer on the wall"; toss "1 bottle of beer."
 toss "Take one down, pass it around,"; toss "No bottles of beer on the wall."; catch boomerang
 }
 
 toss b, "bottles of beer on the wall,"
 toss b, "bottles of beer."
 toss "Take one down, pass it around,"
 b -= 1
 toss b, "bottles of beer on the wall."
 toss ""
 throw boomerang 11 feet north 
 }
Category:Languages
Category:Unimplemented
Category:High-level
Bored

Bored is an in-development esolang created when User:VilgotanL was bored, thus some features and decisions may be questionable.
The only datatype is list. Integers are represented as the length of the list, which makes integers nonnegative. Strings are represented as a list of ascii values as integers.
There are no scopes except the global scope. In the global scope there are variables and functions. A function can have the same name as a variable because functions can only be used by making a function definition or calling them.
== History ==
The esolang was created using a "compiler generator" by the creator, which is a PEG parser generator where the output is code instead of an AST (Abstract Syntax Tree).
== Syntax ==
=== Statements ===
To be documented.
=== Expressions ===
To be documented.
=== Standard Functions ===
Function 	Description
num2str(n) 	Converts an integer to a string
geti(list, i) 	Gets index i of list with indices starting at 0
seti(list, i, value)	Sets index i of list to value with indices starting at 0
== Examples ==
=== Cat program ===
# inPut is kind of like a keyword and not a function, and it prompts the user for a line of input and returns it as a string
# printLn has the L capitalized and inPut has the P capitalized because i'm bored
printLn inPut
=== Hello World ===
printLn "Hello, world!"
=== Quine ===
s=[93,10,112,114,105,110,116,32,34,115,61,91,34,32,106,111,105,110,32,110,117,109,50,115,116,114,40,103,101,116,105,40,115,44,32,48,41,41,10,105,61,49,10,119,104,105,108,101,40,105,32,60,32,115,41,32,123,10,32,32,32,32,112,114,105,110,116,32,34,44,34,32,106,111,105,110,32,110,117,109,50,115,116,114,40,103,101,116,105,40,115,44,32,105,41,41,10,32,32,32,32,105,32,61,32,105,32,43,32,49,10,125,10,112,114,105,110,116,32,115]
print "s=[" join num2str(geti(s, 0))
i=1
while(i < s) {
 print "," join num2str(geti(s, i))
 i = i + 1
}
print s
=== Truth-machine ===
i = geti(inPut, 0)
while(i == 49) { print [49] sleep ms 0 }
print [48]
=== FizzBuzz ===
i = 1
while(i < 101) {
 if(i % 15 == 0) { printLn "FizzBuzz" }
 if(!(i % 15 == 0) && i % 3 == 0) { printLn "Fizz" }
 if(!(i % 15 == 0) && i % 5 == 0) { printLn "Buzz" }
 if(!(i % 3 == 0 || i % 5 == 0)) { printLn num2str(i) }
 i = i + 1
}
=== 99 Bottles of Beer ===
i = 99
while(!(i < 3)) {
 printLn num2str(i) join " bottles of beer on the wall,
" join num2str(i) join " bottles of beer.
Take one down, pass it around,
" join num2str(i-1) join " bottles of beer on the wall.
"
 i = i - 1
}
print "2 bottles of beer on the wall,
2 bottles of beer.
Take one down, pass it around,
1 bottle of beer on the wall.
1 bottle of beer on the wall,
1 bottle of beer.
Take one down, pass it around,
No bottles of beer on the wall."
== Implementation ==
https://vilgotanl.github.io/Esolang-implementations/js/bored/index.html
Category:Languages
Category:Turing complete
Category:High-level
Category:2022
Category:Implemented
Borsch

'Borsch' is named after a Russian/Ukrainian soup which consists of SMETANA, BEETROOT and others. SMETANA and BEETROOT are in caps as they are
programming languages mixed into the tasty mixture called BORSCH. Lovers of acronyms might say that BORSCH stands for Borsch OR Smetana in CHecko-slovakia, even though it does not. 
==Description==
Borsch is based on SMETANA by Chris Pressey(Thanks to him) and my mini-language BEETROOT. BEETROOT is a VERY minimal version of SMETANA:
S(1): G S(2) ; IM(I/O)
S(2): O("Hello world!")
 
Basically this means:
Step 1: Goto Step 2, but before that import Input/Output library,
Step 2: Output("Hello World!")
Some may call BEETROOT a shortening of SMETANA's keywords, but believe us(singingbanana/dan_zh) that it isn't because of the following:
* Does SMETANA have libraries?
* Can SMETANA do arithmetic?
* Does SMETANA have Input/Output?
Now, how do we combine BEETROOT and SMETANA(and a bit of lambda calculus!) to make the tasty Borsch?
Lets combine BEETROOT and Lambda to make Blambda. Squaring n will look like:
S(1): G S(2) ; IM(I/O)
S(2): G S(3) ; ST n = RQ(">", Input)
S(3): lm(n. n*n)
An pseudo-example of running this in an Esoteric OS (Linux):
user/singingbnna> Blambda --run square.bla
> 3
9
user/singingbnna>
Now, lets expand Blambda, to make it more or less human readable and *Ta-Dah* we made Borsch!
==Examples==
squaring n:
Step 1: Import library(I/O); JMP step 2
Step 2: Output(">",Store(Input)==x); JMP step 3
Step 3: Output(lambda(x. x*x))
As you can see, lambda is the core of Borsch math(s)-orientated programs. But more I/O stuff is based on the BEETROOT side. And the unsung workhorse of all of this is SMETANA! The author would highly appreciate any help with BNF and other formal descriptions of Borsch, and will be amazed if anyone makes an interpreter|compiler for this. 
==Turing-completeness==
Borsch is evidently Turing-complete, because a) It contains Lambda calculus, which is already proven Turing-complete, and B)It based on SMETANA, which can be Turing-complete on Infinite memory, and as Borsch is conceptual, its allowed infinite memory.
==Relatives==
* Lambda calculus - the core of math(s)-orientated programs(Father)
* SMETANA - God-father
* Haddock - Uncle
* Haddock2 - Brother-ish of Borsch
Category:Languages
Category:2018
Category:Turing complete
Category:Unimplemented
Borth

borth is an esolang created by User:Ractangle.
==Commands==
Commands 	Action
S: 	Starts the program
print 	Prints the top value of the stack
input 	Self explanatory
print.ll 	Prints the top value of the stack without emiting a newline
print.var 	Prints a varible
var 	Declares a variable
var.stk 	Pushes a variable to the stack
lable.make 	Creates a label
label if 0 	Jumps to a label if a variable is 0
label if var 	Jumps to a label if a variable is equal to an another variable
label if > var 	but instead it check if the variable is greater then another variable
label if not var	The opisite of
label > 0 	Jumps to a label if a variable is greather than 0
plus 	adds two elements on the stack, pops the two elements and pushes a result on a stack
E: 	Ends the program
Anything else will be pushed to the stack
==Examples==
===Hello, world!===
 S:
 Hello, world
 print
 E:
===Cat program===
 S:
 var i !input!
 print.var
 i
 E:
===Truth-machine===
 S:
 var i !input!
 label if 0 i z
 label > 0 o i
 label.make z 0
 print
 E:
 label.make o
 1
 print
 label o
===Disan Count===
 S:
 var i !input!
 var a 1
 lable.make loop
 print.var a
 var.stk a
 1
 plus
 label if not var loop a i
 E:
Category:LanguagesCategory:2024Category:Stack-based
Bot Engine

Designed by SuperJedi224, Bot Engine is a 2D programming language inspired by the game Manufactoria. Execution consists of one or more "bots", each carrying a queue of symbols, traversing the grid of instructions. Execution begins with a single bot carrying an empty queue and going EAST, which begins in the northwesternmost cell.
At each step of the execution, every bot advances 1 cell in whatever direction it is facing, unless doing so would move it into a cell which is already occupied; and every bot which successfully moved then executes the command (if any) corresponding to the cell they entered.
Bots are updated in the order they were created.
Execution halts when no bots remain.
Additionally, any rows in the program that are shorter than the longest row will be automatically right-padded with spaces by the interpreter to match the length of the longest row.
==Instructions==
X Destroy the current bot. (This will also happen when a bot exits the program bounds)
Z Destroy all bots.
T Destroy the current bot and print TRUE.
F Destroy the current bot and print FALSE.
P Destroy the current bot and print the contents of its queue.
r Rotate the current bot's direction of travel 90 degrees clockwise.
l Rotate the current bot's direction of travel 90 degrees counterclockwise.
R Reverse the current bot's queue.
^ The current bot is now going NORTH.
v The current bot is now going SOUTH.
> The current bot is now going EAST.
< The current bot is now going WEST.
| Reverse the current bot's direction of travel.
C Duplicate the current bot. Allow the original to continue in its current direction, but reverse the direction of the copy.
E If the current bot's queue is empty, rotate its direction of travel 90 degrees clockwise.
I Read a line from the input and add its characters to the current bot's queue.
e Find the symbol to the left (relative to the current bot's direction of travel). Add it to the current bot's queue.
d Duplicate the symbol at the front of the current bot's queue. A no-op if the queue is empty.
S Find the symbol to the left (relative to the current bot's direction of travel). If the symbol at the front of the current bot's queue matches this symbol, dequeue it and rotate the bot's direction of travel 90 degrees clockwise.
~ Move a symbol from the front to the end of the current bot's queue. A no-op if the queue is empty.
@ Move a symbol from the end to the front of the current bot's queue. A no-op if the queue is empty.
A cell containing any other symbol is a no-op.
==Source and Implementation==
https://github.com/SuperJedi224/Bot-Engine
==Examples==
===Infinite Loop===
 ><
or
 v
 ^
===Cat Program===
 >CIEP
 Z
===Truth Machine===
 v 0
 >IS>CP
 e0
 P
===Hello, World!===
 vHello, World!
 >eeeeeeeeeeeeeP
==Computational Class==
It is suspected, but has yet to be proven, that Bot Engine is capable of encoding arbitrary Turing machines and is therefore turing complete.
Category:LanguagesCategory:2015Category:Queue-basedCategory:Two-dimensional languagesCategory:Unknown computational classCategory:Implemented
Bout

Bout is an assembly-like esolang created by User:PythonshellDebugwindow.
==Syntax==
Bout programs consist of lines with opcodes followed by any arguments they might take.
==Memory==
Bout uses a tape to store values.
==Operations==
Opcode	# of Args	Effect
W 	2 	Set MEM[arg 1] to be V(arg 2)
A 	1 	Increment MEM[arg], or set it to 1 if it isn't set
D 	1 	Decrement MEM[arg], or set it to 0 if it isn't set (this does nothing if MEM[arg] is zero)
R 	1 	Print V(arg)
J 	1 	Jump unconditionally to 0-based line (V(arg))
N 	2 	Jump unconditionally to 0-based line (V(arg 1)) if arg 2 is nonzero
H 	0 	Halt the program
MEM[x] means MEM.getValue(V(x))
==Meaning of V(x)==
V(x) means that if x is a non-negative integer, return x; if x is a non-negative integer prefixed by a minus sign, return MEM[x]; if x is the dollars sign $, return a user-input non-negative integer (which returns 0 for invalid input); otherwise, return 0.
==Examples==
===Infinite numeric cat===
 R $
 J 0
===Numeric cat until 0===
 W 0 $
 N 3 -0
 H
 R -0
 J 0
===Truth-machine===
 W 0 $
 N 4 -0
 R 0
 H
 R 1
 J 4
==Computational class==
Bout is Turing-complete, as a version of brainfuck with numeric I/O can be translated into it.
===Translation from brainfuck===
First, initialize a cell pointer:
 W 0 1
To increment the cell pointer:
 A 0
To decrement it:
 D 0
But the clever part is that we can access cells dynamically, by using -0. To increment the current cell:
 A -0
To decrement it:
 D -0
Input:
 W -0 $
Output:
 R -0
Looping can be accomplished with jumps. Just be careful not to go below cell #1, as below that and the cell pointer will overwrite itself.
==External resources==
* An interpreter in NodeJS
Category:Languages Category:2020 Category:Low-level Category:Turing complete Category:Implemented Category:Cell-based
Boyfriend.xml

Boyfriend.xml is a joke esoteric programming language created by McDude73 in 2022 based on the player's main avatar from Friday Night Funkin' — Boyfriend, sometimes referred to as Boyfriend.xml because of the file format that the character was created in to pose when "singing".
==Basic idea==
The idea behind Boyfriend.xml is using the language that Boyfriend specifically speaks.
It is partially confusing because they sound more like a typical sound effect. People try to translate these into actual words but the results vary from person to person, meaning no legitimate translation is present at this time.
==Architecture==
The program allows the following commands — or lyrics, to be used in alphabetical order.
 Beep
 Bep
 Bo
 Boop
 Bop
 Dep
 Skbep
 Skdep
The commands here can vary on what lyrics are used in each line of code due to translation issues, thus making it almost impossible to determine how the code is executed.
Category:2022
Category:Joke languages
Category:Thematic
Category:Languages
Br greater than

br> is a stack-based esolang created by User:Ractangle and User:Ϫ.
==Etymology==
The name came from an mistake that User:Ϫ made by accident:
 br>hehe whoops esolagn lol... wait that gives me an idea: <br> 
==Syntax==
The language uses a line based system, like Befunge but 1d. The first line is the program, the second line is the first item in the starting stack, and so on. The 'player' rebounds at the end of the line. The syntax for the initial starting stack lines are this:
 "{string}" creates a string.
 {number} creates a number.
 T creates a boolean truth.
 F creates a boolean falsehood.
 I inserts whatever the person's input is, which can be any of the above (but not I, that's (maybe) an infinite loop!).
Anything else does not get added to the stack.
===Commands===
 All Commands 
> 	Starts the cursor moving left. < does the opposite.
- 	Flips the cursor's direction.
? 	Pop value. If it is a boolean truth, do the next operation. Anything else skips it and pushes it back.
^ 	Skip the next instruction.
! 	Halts.
" 	Toggles input mode. In input mode all encountered objects are added to the stack, digits as 1-digit numbers and letters as 1-letter strings.
I 	Pushes the user's input, just like the initial stack call in the Syntax section.
t 	Pushes a boolean truth.
f 	Pushes a boolean falsehood.
: 	Duplicates the top stack item.
O 	Pops a value and outputs it.
R 	Pops a value. If it is a 1-letter string, from now on this acts like that instruction.
o 	Outputs the top value without popping it.
M 	Pops two values. If they are the same, push a truth. If they are different, push a falsehood.
Any other letter (upper)	Sets a jump point.
Any other letter (lower)	Goes to the uppercase jump point.
{...} 	Skip to the if the top two elements on stack are not equal.
~ 	Pop a value.
==Programs==
===Truth Machine===
====by User:Ϫ====
 >tM?zx-Zo-Xo!
====by User:Ractangle====
 >{boB}~o!
 I
 1
 0
===Infinite Loop===
 ->-
===CATS===
====until Ϫ====
 B>I{!}ob
 Ϫ
Category:Languages Category:Stack-based Category:2024 Category:Unimplemented Category:Unknown computational class
Braces

Braces is an esolang invented by User:None1, the only valid command is braces.
==Execution==
A program in Braces consists of several blocks of code side by side.
When a program in Braces is executed, it is evaluated and the result is printed to standard output.
===An empty pair of braces===
When an empty pair of braces is evaluated, it reads a character from standard input and returns it.
===One block of code inside a pair of braces===
Execute the block of code inside forever.
===Multiple blocks of code inside a pair of braces===
Evaluate every block of code, and concatenate the results together, and reverse the result, and return it.
===Example Programs===
===Cat Program===
 {{}}
===One Time Cat===
 {}
===Reverse a string with only 2 characters===
 {{}{}}
Category:Unimplemented
Category:Joke languages
Category:Languages
Category:Unusable for programming
Category:Nested