nyuuzyou/wikis huggingface dataset:
B-tapemark

B-tapemark is an esolang invented by User:Zzo38.
The playfield consists of two unbounded grids. The first one is filled up by the program file. The second one is initially blank. Each one has a position marker on it. There is also a current direction, common to both grids.
The operation is that the symbol on the first grid is executed and then the position marker is moved in the current direction.
==Symbols==
* Blank: A blank symbol, represented by a space.
* \, /: Mirrors. 
* !: Halt.
* +: Output the symbol at the position marker of second grid.
* -: If the symbol at position marker of second grid is blank, input a symbol there.
* *: Read the next symbol from the program (and skip it). If the symbol at the position marker on the second grid is blank, write the read symbol there.
* |: Move the position marker of the second grid in the current direction.
* ?: Swap the grids if the symbol on the second grid is blank.
* %: Swap the grids if the symbol on the second grid is not blank.
* A...Z, 0...9: If direction is horizontal, output this symbol. If direction is vertical, compare symbol on second grid with this one; swap grids if they match.
==Pseudosymbols==
* ^, v, <, >: The starting position and direction. This symbol is blank at runtime.
* ": Any text in quotation marks is comments and is converted to blanks at runtime.
* Everything else is error (when the program is loaded).
==Examples==
Hello World:
 >HELLO+WORLD!
Copy input to output:
 />-+|\
 \ /
Category:Languages
Category:Two-dimensional languages
Category:Unimplemented
Category:2013
B2C

It's Brainfuck, with 2 cells, invented by User:None1.
==Introduction==
B2C is a Brainfuck derivative (or a Brainfuck equivalent, depends on how you think) with only 2 cells.
Since there are only 2 cells, B2C doesn't need 2 commands to move the pointer, it just need one command, which is the | command. The | command moves the pointer from one cell to the other.
==Example Programs==
===Cat Program===
 +[,.] [The same as the one in Brainfuck]
====Non-terminating version====
 +[|,.|]
===Nope. Interpreter===
 ++++++[|+++++++++++++|-]|.[-]|++++++++++[|+++++++++++|-]|+.+.
 -----------.[-]|+++++[|+++++++++|-]|+.
===Hello World (last because it's the hardest one)===
+++++++++[|++++++++|-]|.[-]|++++++++++[|++++++++++|-]|+.
+++++++..+++.[-]|++++++++[|++++|-]|.[-]|
++++++++++[|++++++++|-]|+++++++.[-]|+++++++++++[|++++++++++|-]|
+.+++.------.--------.[-]+++++++++++[|+++|-]|.
===Interpreter===
The following is an interpreter in JavaScript:
function b2c(program,input){
 var stack=[];
 var matches={};
 var ip=0;
 var tape=[0,0];
 var p=0;
 var output=;
 for(var i=0;i<program.length;i++){
 if(program[i]=='['){
 stack.push(i);
 }
 if(program[i]==']'){
 if(stack.length==0){
 throw new Error('Right bracket does not match left bracket');
 }
 var mt=stack.pop();
 matches[mt]=i;
 matches[i]=mt;
 }
 }
 if(stack.length!=0){
 throw new Error('Left bracket does not match right bracket');
 }
 while(ip<program.length){
 if(program[ip]=='+'){
 tape[p]=tape[p]+1;
 if(tape[p]==256) tape[p]=0;
 ip=ip+1;
 }
 if(program[ip]=='-'){
 tape[p]=tape[p]-1;
 if(tape[p]==-1) tape[p]=255;
 ip=ip+1;
 }
 if(program[ip]=='|'){
 p=1-p;
 ip=ip+1;
 }
 if(program[ip]==','){
 if(input==){
 tape[p]=0;
 }else{
 tape[p]=input.charCodeAt(0)%256;
 input=input.slice(1);
 }
 ip=ip+1;
 }
 if(program[ip]=='.'){
 output+=String.fromCharCode(tape[p]);
 ip=ip+1;
 }
 if(program[ip]=='['){
 if(tape[p]==0){
 ip=matches[ip];
 }else{
 ip=ip+1;
 }
 }
 if(program[ip]==']'){
 if(tape[p]!=0){
 ip=matches[ip];
 }else{
 ip=ip+1;
 }
 }
 if(!('+-,.[]|'.includes(program[ip]))){
 ip=ip+1;
 }
 }
 return output;
}
The minimized version is like this:
function b2c(r,t){for(var e=[],o={},h=0,n=[0,0],c=0,a="",f=0;f<r.length;f++)if("["==r[f]&&e.push(f),"]"==r[f]){if(0==e.length)throw new Error("Right bracket does not match left bracket");var i=e.pop();o[i]=f,o[f]=i}if(0!=e.length)throw new Error("Left bracket does not match right bracket");for(;h<r.length;)"+"==r[h]&&(n[c]=n[c]+1,256==n[c]&&(n[c]=0),h+=1),"-"==r[h]&&(n[c]=n[c]-1,-1==n[c]&&(n[c]=255),h+=1),"|"==r[h]&&(c=1-c,h+=1),","==r[h]&&(""==t?n[c]=0:(n[c]=t.charCodeAt(0)%256,t=t.slice(1)),h+=1),"."==r[h]&&(a+=String.fromCharCode(n[c]),h+=1),"["==r[h]&&(0==n[c]?h=o[h]:h+=1),"]"==r[h]&&(0!=n[c]?h=o[h]:h+=1),"+-,.[]|".includes(r[h])||(h+=1);return a}
==External resources==
* Online interpreter
Category:Brainfuck derivatives
Category:Languages
Category:Cell-based
Category:2023
Category:Implemented
Category:Finite state automata
BAK

BAK is an esoteric programming language created by Prfnoff (2000). 
A BAK interpreter maintains a modifiable program space consisting of an array of bytes and a stack of program locations.
The program counter is initially at the first byte of the program. The program counter is incremented after each instructions. 
The entire 13 instructions are given here with a general explanation of their effect (but with no guarantee about the exact order of operands pulled from stack):
 $ here push current location to the stack
 : jump a -> jump to a
 < min a, b -> min(a,b)
 > max a, b -> max(a,b)
 ; arith a, b, c -> a + c - b 
 + input a, b -> if at EOF, jump to b, else *a = getchar()
 - out a -> putchar(*a)
 @ find a, b, c -> first location of *a between b and c
 = copy a, b -> *a := *b
 * dup
 / swap 
 \ rot
 ! drop
Any byte not among these 13 intruction is a no-op (the program counter is incremented). To end, the program must reach past the end of the data space with an empty stack. 
==Computational class==
Despite the lack of details in the original specification, and despite the reference implementation being written in obfuscated C, actual experiments with the implementation show that the data space can extend past the original program. For instance the following program copies an "a" several bytes past the program end, and
outputs it. 
 $a$$;$..............$*\;*\=-
Although the only non-trivial program ever written in BAK seems to be a version of 99 bottles of beer using nested loops, a direct reuse of techniques used in that program are deemed sufficient to implement small finite state machines such as the 4-state 6-character universal Turing machine described in utm.b.
Together with the unbounded data space, this gives an indication that BAK is turing complete.
==External resources==
* BAK reference manual
* 
* 99 bottles of beer implemented in BAK
Category: Languages
Category: Implemented
Category: Stack-based
Category: Self-modifying
Category: 2000
BAL

BAL (or Basic Assembled Language) is a esolang came from here. Created by User:Ractangle
==Commands==
Command 	It's Action
SET <name> TO <value> 	Assigns a variable.
IF <conditon> THEN DO <subroute>	Condition command.
WHILE <conditon> 	Reapeats the folowing code if the condition is true.
PRINT 	Prints the string next to it.
USER 	Gets user input.
NOTE 	Comment.
SUM 	Math command. You can also do the math with strings
DEFINE 	Defines a sub.
END 	Ends the current CHECK operator. Ends the program is not inside a CHECK operator
==Examples==
===Hello, world!===
 PRINT "Hello, world!{N}"
===Truth-machine===
 SET i TO USER
 IF i="0" THEN DO:PRINT 0 > END
 WHILE 1:PRINT 1
Category:Languages Category:2024 Category:Unimplemented
BALAE

Brainfuck Assembly Language Advanced Edition/BALAE (pronounced like Ballet) is a derivative of both BAL (originally developed by Olus2000) and Brainfuck. It adds four new commands, while squashing the original 8 into half the space.
== The Basic Idea ==
BALAE was designed to extend BAL for better usability, while keeping it to eight total commands. The obvious issue is that if you simply add four commands with no preperation you would have instantly gone over the eight command limit. The way this was solved was by combining each "pair" of commands into one command each. Below is the new set of commands (excluding the four newcomers)
Pair 	New	Description
Arithmetic ("-" "+") 	"~"	Takes argument n, subtracts 16 and applies to current cell.
Pointer ("<" ">") 	"^"	Essentially the same as "~" except applied to the pointer
Loop ("[" "]") 	" 	Due to the addition of dedicated labels and jumpers, it adds argument n to the Program Counter
User Interaction ("," ".")	";"	If argument n is less than 16, output current cell to output n. Otherwise, turn current cell into the value of input n-16.
== New Commands ==
=== "_" ===
Doesn't actually do anything by itself, but when used in tandem with "{" and "}", it can be a truly powerful tool.
=== "{" and "}" ===
"{" and "}" jump to a label with value n forwards and backwards, respectively ("{" forward, "}" backward).
=== "@" ===
Halts program with exit code n.
== Examples ==
Infinite print: (provided output 0 displays text)</br>
~15~15~15~15~05_00;00}00</br>
Broken down:</br>
First we initialise the value 65, or "A" in ASCII: ~15~15~15~15~05</br>
Next, we create the loop. _00 is a label, and }00 jumps back to that same label.</br>
The command inside the loop, ;00, will display the character "A" on the screen only if output 0 is, indeed, displaying text.
== External Resources ==
* The Python emulator
Category:Cell-based Category:2021 Category:Turing complete Category:Brainfuck derivatives Category:Implemented
BASIC

BASIC, or Beginners' All-purpose Symbolic Instruction Code, is a family of high-level programming languages. It is one of the oldest programming languages still in use today, having being designed in 1963.
Most BASIC dialects are intended for serious programming, although there also exist several esoteric variants.
==See also==
* Basic Programming
Category:Languages Category:High-level Category:Implemented Category:Before 1993
BASICER

Beginners' All-purpose Symbolic Instruction Code, Esoteric Revision, also named BASICER is an esoteric programming language designed by User:Rdococ.
== Specification ==
BASICER programs have a 100x100 graphical screen on which to draw things as well as a textual terminal to print text. There are 5 instructions.
Instruction 	Description
CLEAR 	Clears the console and the screen.
PLOT X Y #RRGGBB	Gives point (X, Y) on the screen the hexadecimal colour #RRGGBB. X and Y can range from 0-99.
PRINT ABC 	Prints ABC.
PAUSE 	Pauses the program. User must press a button to continue.
GOTO 9 8 	If there is only one line number specified, go to that line. But if there is more than one number specified, allow the user to choose. The user isn't told what the line numbers are, and must type 1 for the first choice, 2 for the second choice, and so on. If the line number does not exist, the program halts.
=== Line Numbers ===
BASICER permits you to write a line number either before every instruction, or omit them. If line numbers are only placed before some instructions, the program will not run.
=== Examples ===
This is a very, very simple RPG written in BASICER.
10 CLEAR
20 PRINT You wake up in a dark room! What do you do?
30 PRINT 1) Go to the door towards the south
40 PRINT 2) Go to the door towards the north
50 GOTO 60 110
60 CLEAR
70 PRINT The door closes behind you, and all of a sudden,
80 PRINT you fall asleep on the most comfortable bed ever.
90 PAUSE
100 GOTO 10
110 CLEAR
120 PRINT You have escaped the room and are now outside!
130 PRINT Press any key to play again.
140 PAUSE
150 GOTO 10
This program adds two binary numbers if they are fed in an alternating pattern from least significant to most significant (A0, B0, A1, B1 etc). When providing input, `1` translates to `0` and `2` translates to `1`.
10 PRINT First digit please! (1 = 0, 2 = 1, 3 = exit)
20 GOTO 50 70 200
30 PRINT First digit please! (1 = 0, 2 = 1, 3 = exit)
40 GOTO 70 90 190
50 PRINT Second digit please! (1 = 0, 2 = 1)
60 GOTO 110 130
70 PRINT Second digit please! (1 = 0, 2 = 1)
80 GOTO 130 150
90 PRINT Second digit please! (1 = 0, 2 = 1)
100 GOTO 150 170
110 PRINT 0
120 GOTO 10
130 PRINT 1
140 GOTO 10
150 PRINT 0
160 GOTO 30
170 PRINT 1
180 GOTO 30
190 PRINT 1
Other interesting examples of programs that can be written in BASICER include tic-tac-toe with perfect AI, a C interpreter, and The Stanley Parable.
=== Computational Class ===
BASICER programs translate straightforwardly into FSMs with output.
Category:Languages
Category:Finite state automata
Category:Unimplemented
BCDFuck

BCDFuck takes a stream of bytes and reads each byte as two BCD-encoded 4-bit words. Like other Brainfuck variants, BCDFuck operates on an array of cells, which in this case are 4 bits wide. The digits 0-9 are entered directly into the cells while the six 'wasted' states of 4-bit BCD encoding are translated into brainfuck-like instructions that act on the aforementioned array. Since any 4-bit word is a valid BCDFuck instruction, it would follow that all cells can be executed (as long as potential problems like unbalanced brackets can be ignored). 
Each 4-bit word, represented by its corresponding hexadecimal digit, manipulates the cell array as follows
* 0 through 9 add the corresponding value to the current cell, and advances the cell pointer to the next cell. Thus, 0 is equivalent to > in Brainfuck. All cells in the cell array start with 0 as their default value, and wrap around when they are incremented beyond the limits. The upper limit of a cell is naturally F, and not 9.
* A moves the cell pointer to the previous cell, and is thus equivalent to < in brainfuck. Thus, 1A increments the value in a cell and 9A 6A decrements it, in a way similar to + and - in brainfuck, respectively. 
* B and C act like the brainfuck's [ and ] operators, respectively.
* D acts like brainfuck's , operator. However, in this case it reads a byte from the input stream and buffers it until both the high and the low word are read, and in that order
* E acts like . in brainfuck, sending a word to the output stream. The order of output mirrors the order of input above, and an incomplete pair will be padded with a 0 if the program exits before the pair can be completed
* F is the Freaky Friday operator. It swaps the program array with the cell array so that their roles are reversed until another F swaps it back, much like the X operator in Braintwist
=== Example Program ===
==== Hello World! ====
 4A E4 AE 7A 7A E7 A8 AE 1A E6 AE 5A 5A E6 AE 5A 5A E4 A5 AE 3A E0 EA 3A
 E2 AE 7A 8A E4 A5 AE 8A E5 A6 AE 4A E6 AE 5A 5A E7 A7 AE 7A 7A E7 A8 AE
 0E A4 A5 AE
=== Turing completeness proof ===
This conversion allows any 8-bit brainfuck program to be run on BCDFuck. It doesn't use the F command.
Eight bit BF Command	BCDFuck Commands
> 	00 00
< 	AA AA
+ 	01 AA 1A B0 8A 7A C0 B8 A7 01 AA CA A
- 	01 AA B0 8A 7A C0 B8 A7 08 A7 AA CA A8 A7 A
. 	00 0E AA AE
, 	00 0D AA AD
[ 	01 AA B0 8A 7A C0 B8 A7 1B A8 A7 AC AB AC 0B 8A 7A A1 CC A8 A7 AB 1A A
] 	01 AA B0 8A 7A C0 B8 A7 1B A8 A7 AC AB AC 0B 8A 7A A1 CC A8 A7 AC A
Category:Languages
Category:Unimplemented
Category:Brainfuck derivatives
Category:Self-modifying
Category:2012
BDAMD

BDAMD, or Basic Demonic Asinine Multi-Dimensional programming language, is an esoteric programming language created by Joseph Strom. It is a Fungeoid similar to Brainfuck and Numberix.
Each command is an 8-bit byte. In the two-dimensional version of BDAMD, the first five bits are reserved for the instruction and the last three for moving the code pointer. Should someone write an interpreter capable of handling more than two dimensions, additional bits would have to be added.
==External resources==
* 
Category: Languages
Category: Cell-based
Category: Two-dimensional languages
Category: Implemented
Category: Low-level
Category: 2003
BEN++

BEN++ is language by User:ChuckEsoteric08 that based on game "My Talking Ben".
==Commands==
yes 	increments cell under the pointer
no 	decrement cell under the pointer. If result was -1, set to 0
hoho	move pointer right
eugh	move pointer left
ben 	repeat next instruction until value in current cell is zero
Program runs infinitly. Commands sepereated with spaces. There is also debug command:
phone	output cell
==Examples==
===Output 1 forever===
 yes phone no
==Computational class==
Unknown
Category:Languages Category:Unknown computational class Category:Output only Category:Thematic Category:Pseudonatural Category:Cell-based
BERT

The esoteric programming language, BERT, stands for Boring Equation Rational(not really) Trinomial language. Made by Areallycoolusername, its based off of Polynomial.
== Specifics ==
You can print things using ASCII decimal codes. However the code have to go through a "Rational" trinomial equation. The equation is as follows:
 12n ÷ 69 × (-21)
Where n is the code you want printed.
So 33 which prints an exclamation mark will equal -120(including all numbers behind the decimal point). All code must start with BE, and end with RT.
Comments can be introduced with the @ sign. Their content ends immediately before the next mathematical sign (+ or −) or decimal digit.
== Hello World Program ==
BE@This is a 
comment−262.9565217391−368.8695652174−394.4347826087−394.4347826087−405.3913043478−160.6956521739
−116.8695652174−434.6086956522−405.3913043478−416.347826087−394.4347826087−365.2173913043RT
==Interpreter==
* Common Lisp implementation of the BERT programming language. Please note that 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.
Category:Languages
Category:Total
Category:Unusable for programming
Category:Output only
Category:2019
Category:Implemented
BF++

BF++ is an esoteric programming language invented in 2022 February. The creator did not feel like Brainfuck had enough features.
==Syntax and functions==
The language has 2 memory cells (If it was just Brainfuck but more features it would be easier) called down and up.
Functions are separated by a space.
The language consists of 13 functions:
 (any number) sets the value of the focused cell
 + :adds the two cells together, leaving the sum in cell down
 - :exactly the same except negation
 s :swaps the focused cell
 i :takes input (must be a number)
 inc :increases the value of the focused cell
 dec :decrease ..
 goto arg :jumps to a function (for the sake of fun it jumps one function earlier than the given number (goto -1 jumps to the start of the code))
 d arg1 arg2 :essentially a while loop, jumps to arg2 (-1) arg1 many times (122 p d 97 0 ; prints the latin alphabet reversed)
 u arg1 arg2 :exact same but used to count up (97 p u 122 0 ; prints the latin alphabet)
 p :prints the ascii value of the cell (equalient to Brainfuck .)
 o :prints the value of the cell (10 o ; prints 10)
 dir :(for debug purposes only) prints the memory map (10 s 20 dir ; prints down:10 up:20)
 ; :ends the program.
==Examples==
Hello world:
 104 p 101 p 108 p 108 p 111 p 32 p 119 p 111 p 114 p 108 p 100 p 10 p ;
printing the alphabet:
 97 p u 122 0 ;
print the nth letter from the alphabet:
 97 s i + s p ;
==See Also==
* Brainfuck
==Sources==
* https://github.com/Elyxin1/BFpp
Category:Languages Category:Implemented Category:Unknown computational class
BF-ASM:8

BF-ASM:8 is an esoteric programming language made to be compiled to brainfuck
== Examples ==
=== Hello world ===
 var # out = "Hello world" .
==== More readable ====
 var # out
 var = "Hello world"
 var.
=== Cat ===
 var # = 1 {var , .}
==== More readable ====
 var # = 1 {
 var , .
 }
=== Truth machine ===
 var1 # ,
 var2 # = var1 - 48 {var1 .}
 var1 .
== Language ==
Everything on the language is made entirely with variables.
== Syntax ==
The syntax of doing something with a variable looks like this
 [variable] [operation with the variable] [paramether/s that the operation uses]
Note that you can repeat the things that you can do with a variable
 [variable] [operation] [paramether/s] [operation] [paramether/s] [operation] [paramether/s] ..
and you can put them in the way you want.
 [variable] [operation]
 [paramether/s]
 [operation]
 [paramether/s] [operation [paramether/s]
 ...
== Operations ==
Category:Languages
Category:Cell-based
Category:2020
Category:Unimplemented
Category:Low-level
BF-PDA

BF-PDA is a simple programming language by ihope127, designed to be of use in a compression algorithm. An interpreter was written by Madk in 2010.
==Commands==
 @ Flips the bit on top of the stack.
 . Outputs the bit on top of the stack (doesn't pop it).
 < Pushes a 0 bit onto the stack.
 > Pops a bit from the stack and throws it away.
 [ While the bit on top of the stack is 1...
 ] End while.
If the stack ever runs out of bits, a zero is automatically pushed: that is, popping an empty stack doesn't do anything, and loops terminate when trying to peek at empty stacks.
==Computational class==
Any BF-PDA program can be easily simulated on a push-down automaton, so it is certainly not Turing-complete.
==Possible modification==
A modification of this language adds a new stack which < pops from and > pushes to, however this stack has a finite length: pushing something onto it while it's full results in the bottom element being erased, and popping it while empty yields a 0-bit. The size of this stack is defined by the programmer. Equivalently, the "tape" extends to the left for some number of cells.
Another modification allows this language to store numbers up to a predefined number. For numbers greater than 2, @ is replaced with + and -, and [ loops while nonzero.
==External resources==
* Download interpreter
Category:Languages
Category:2005
Category:Stack-based
Category:Output only
Category:Brainfuck derivatives
Category:Implemented
Category:Low-level
BF-SC

BF-SC is a language designed by ihope127 to be more powerful than BF-PDA yet less so than Brainfuck. The memory consists of a tape extending to the right only. Every cell has a number: the leftmost is 1, then 2, then 3, etc. Each cell is either "set" or "unset"; all cells start out unset. The "head" starts on cell 1. The instructions:
 > Moves the head to the right.
 < Moves the head to the left, if possible.
 . Outputs the state of the cell under the head.
 [ While the cell under the head is unset, set it and...
 ] End while.
Note that there is no way to unset a cell.
Setting a cell x has the side effect of setting all cells which are x cells to the right of a set cell: for example, setting 3 also sets 6, 9, 12, etc. If 5 is then set, so is 8 (because it's 5 to the right of 3), 11 (5 to the right of 6), 13 (to the right of 8), and, in fact, every cell to the right of those, as they can all be reached as a sum of 3's and 5's.
==Not Turing-complete==
Every BF-SC program must halt eventually, as such a program is forced to play a game of Sylver coinage against itself (Sylver coinage is known to always "halt").
Possibly, more power may be gained by adding an instruction @ that sets the current cell, and making the while loop not do so.
Even then, all infinite loops are detectable, because such a loop cannot involve setting any cells, as this cannot be done infinitely; a loop must "stall" forever, simply moving right some number of times each time it is executed.
Detecting infinite loops for any given input is impossible for a universal Turing machine. This implies Turing-incompleteness since not every Turing machine can be implemented in BF-SC.
Category:Languages
Category:2006
Category:Cell-based
Category:Usability unknown
Category:Unknown computational class
Category:Output only
Category:Brainfuck derivatives
Category:Unimplemented
Category:Low-level
BFBASIC

BFBASIC is a Basic to Brainfuck compiler, originally written 
by Jeffry Johnston and released on March 11, 2003. The current 
version, 1.50 rc3, of the compiler is written in the Java language, with 
some contributions by Jon Ripley.
==External resources==
* GitHub repository with version 1.50 rc3.
* SourceForge CVS repository for BFBASIC (read-only) with versions 1.40, 1.41 and 1.50 rc2.
* Original BFBASIC home page with version 1.30. 
* Lost Kingdom, a game written in BFBASIC.
Category:Compilers 
Category:Implementations 
Category:Brainfuck