nyuuzyou/wikis huggingface dataset:
Binary Brainfuck

Binary Brainfuck(BBF) is an esoteric programming language intented to show the complexity of programming.
==Commands==
Brainfuck	Binaryfuck
+ 	010
- 	011
> 	100
< 	101
. 	000
, 	001
[ 	110
] 	111
==Implemantation==
A compiler from BBF to BF in Python:
 def bbf2bf(haep):
 haep = haep.replace(" ","")
 haep = haep.replace("\n","")
 chars = list(haep)
 result = str()
 for i in range(len(chars)):
 if i%3 == 0:
 c = chars[i]+chars[i+1]+chars[i+2]
 if c == "000":
 result += "."
 elif c == "001":
 result += ","
 elif c == "010":
 result += "+"
 elif c == "011":
 result += "-"
 elif c == "100":
 result += ">"
 elif c == "101":
 result += "<"
 elif c == "110":
 result += "["
 elif c == "111":
 result += "]"
 return (result)
==Hello World! Script==
010
010
010
010
010
010
010
010
010
010
110
100
010
010
010
010
010
010
010
100
010
010
010
010
010
010
010
010
010
010
100
010
010
010
100
010
101
101
101
101
011
111
100
010
010
000
100
010
000
010
010
010
010
010
010
010
000
000
010
010
010
000
100
010
010
000
101
101
010
010
010
010
010
010
010
010
010
010
010
010
010
010
010
000
100
000
010
010
010
000
011
011
011
011
011
011
000
011
011
011
011
011
011
011
011
000
100
010
000
100
000
010
010
010
000 
Category:Languages Category:Implemented Category:Turing complete Category:Turing tarpits Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Low-level Category:Cell-based
Binary Insanity

Binary Insanity is an esolang created by User:TheMCoder
=== Overview ===
Binary Insanity has 7 commands
 commands
Name	Description
111 	increment the counter by 1
101 	opposite of 111
010 	outputs the ASCII value of the counter
100 	gets input from user and stores the ASCII value of the first letter of it in the counter
001 	quits
110 	sets the counter to zero
000 	loops back to the beginning
=== Examples ===
==== cat ====
 100010000
==== hello world ====
sorry about the formatting:(
 
 
 
 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111010111111111111111111111111111111111111111111111111111111111111111111111111111111111111111010111111111111111111111010010111111111010101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101010101101101101101101101101101101101101010111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111010111111111111111111111111111111111111111111111111111111111111111111111111010111111111010101101101101101101010101101101101101101101101010101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101010
=== Interpreter ===
The only (current) known Interpreter is in python:
 maininput = input()
 def runcode(code):
 command = ""
 v = 0
 if code == "":
 print("NOPE.")
 raise SystemExit
 for character in code:
 if not character in "01":
 raise SyntaxError("The Machine will not understand the command")
 command += character
 if len(command) == 3:
 if command == "111":
 v += 1
 elif command == "101":
 v -= 1
 elif command == "010":
 print(chr(int(v)))
 elif command == "001":
 inputinput = input()
 v = ord(inputinput[0])
 elif command == "100":
 raise SystemExit
 elif command == "000":
 runcode(code)
 elif command == "110":
 v = 0
 else:
 raise SyntaxError(f"Unknown command {command!r}")
 command = ""
 runcode(maininput)
Category:Languages Category:Implemented Category:Unusable for programming Category:Low-level
Binary License Plate Language

(or BLPL) is an esolang made by Unname4798, a variant of License plate language.
== Instructions ==
There are 32 opcodes (the opcode is 5 bits):
*0: Increase accumulator by argument.
*1: Decrease accumulator by argument.
*2: Multiply accumulator by argument.
*3: Divide accumulator by argument.
*4: Push the accumulator into the stack, argument has no use.
*5: Pop the stack and push into accumulator, argument has no use.
*6: Input accumulator as Unicode, argument has no use.
*7: Output the argument as Unicode, argument has no use.
*8: Jump to line argument (0-indexed).
*9: Jump to line argument (0-indexed) if accumulator is nonzero.
*10: Compare accumulator and stack top, push the result (1 for true, 0 for false) onto stack, argument determines what comparison is to be done: 0 is ==, 1 is !=, 2 is <, 3 is >, 4 is <=, 5 is >=.
*11: Calculate accumulator and stack top, push the result onto stack, argument determines what calculation is to be done: 0 (or 6) is + (or 7), 1 (or 9) is -, 2 (or 10) is *, 3 (or 11) is /(floor divide), 4 (or 12) is %, 5 is ** (power).
*12: Output the argument (letter) directly.
*13: Terminate the program, argument has no use.
*14: Input accumulator as integer, argument has no use.
*15: Output accumulator as integer, argument has no use.
*16: Push a random integer from 0 to 1 onto the stack.
*17: Set the accumulator to the length of the stack.
*18: Output the program's source code.
*19: Clear the stack.
*20: Output "Hello, World!".
*21: Jump to the start of the program.
*22: The same as 21.
*23: Push argument into stack
*24: access the argument-th value of the stack (from bottom to top, 0-indexed)
*25, 26, 27, 28, 29, 30, 31: NOP
The next 11 bits is an argument.
Each instruction is 16 bits (2 bytes) total.
Category:Languages
Category:2024
Binary combinatory logic

Binary combinatory logic (BCL) is a complete formulation of combinatory logic (CL) using only the symbols 0 and 1, together with two term-rewriting rules. BCL has applications in the theory of program-size complexity (Kolmogorov complexity). 
==Definition==
===Syntax===
* <term> ::= 00 | 01 | 1 <term> <term> 
===Semantics===
Rewriting rules for subterms of a given term (parsing from the left):
*  1100xy  -->  x 
* 11101xyz --> 11xz1yz 
where x, y, and z are arbitrary terms.
(Note, for example, that because parsing is from the left, 10000 is not a subterm of 11010000.)
The terms 00 and 01 correspond, respectively, to the K and S basis combinators of CL, and the "prefix 1" acts as a left parenthesis (which is sufficient for disambiguation in a CL expression). 
There are four equivalent formulations of BCL, depending on the manner of encoding the triplet (left-parenthesis, K, S). These are (1, 00, 01) (as above), (1, 01, 00), (0, 10, 11), and (0, 11, 10).
==See also==
* Binary lambda calculus
* Iota and Jot -- languages that are similar to BCL, but are more complicated due to unstated λ-calculus syntax and semantics.
==External resources==
* John's Lambda Calculus and Combinatory Logic Playground
Category:Languages
Category:Functional paradigm
Category:Turing tarpits
Category:No IO
Category:Implemented
Category:Low-level
Binary pi-calculus

Binary pi-calculus is a binary encoding of pi-calculus outlined in October of 2020 by User:RocketRace. It is to pi-calculus as binary lambda calculus is to lambda calculus.
== Encoding scheme ==
Programs are encoded in prefix notation, using the following rules. Here, P & Q represent processes and x & y represent channels (names). _ represents an omitted argument.
* 000: Nil process (0)
* 001P: Repeatedly spawn copies of P (!P)
* 010P: Bind name, then execute P ((v_)P)
* 011PQ: Execute P and Q in parallel (P|Q)
* 100xyP: Send bound or free name y over channel x, then execute P (x<y>.P)
* 101xP: Receive and bind name over channel x, then execute P (x(_).P)
* 110n0 where n is zero or more ones: the n-th bound name, where 1100 is the most recently bound name, 11010 is the second most recent, and so on
* 111n0 where n is zero or more ones: the free name labeled with n
== External resources ==
* Wikipedia article for pi-calculus
Category:Languages
Category:2020
Category:Functional paradigm
Category:Concurrent programming
Category:Turing complete
Binary to unary conversion

A binary to unary conversion program is a program that can convert a given number in binary form to a unary form. It is mainly used to showcase Markov algorithms. Its steps are as follows:
# Replace all instances of 1 with 0* (* can be any character)
# Replace all instances of *0 with 0**
# Remove all instances of 0
For example, here is the conversion of 1001 to *********:
# 1001:
## 1001 -> 0*000*
# 0*000*:
## 0*000* -> 00**00*
## 00**00* -> 00*0**0*
## 00*0**0* -> 000***0***
## 000***0*** -> 000**0*****
## 000**0***** -> 000*0*******
## 000*0******* -> 0000*********
# 0000********* -> *********
__TOC__
== Examples in programming languages ==
===Python 3.0===
 def binarytounary(bstring):
 bstring = bstring.replace("1","0*")
 while "*0" in bstring:
 bstring=bstring.replace("*0","0**")
 return bstring.replace("0","")
=== /// ===
 /1/0*//*0/0**//0//100010
=== Retina ===
 1
 0*
 +`\*0
 0**
 0
 (an extra line must be present)
Try it online.
=== Stringle ===
 a $
 
 #a
 .a 1 b b "0*"
 .a !1 b b "0"
 a :a
 #a
 
 #b
 t .b .:b
 t "*0" b "0**" ::b
 t "*0" b c b
 t "*0" c ""
 c c .b
 b :b
 #b
 
 #c
 .c "*" d d "*"
 c :c
 #c
 
 $ d
 $ "decimal: " #d
=== Sed ===
 s/1/0*/g;:x;s/\*0/0**/g;tx;s/0//g
Category:Program forms
Binin

Binin is a language made by User:ChuckEsoteric08 that uses binary
==About==
Commands are:
 b - move pointer to right and flip bit
 i - move pointer to left
 n - goto a if current bit is 0
 a - goto n if current bit is not 0
==Translation from 1-bit BF==
BF	Binin
@ 	ib
> 	bib
< 	i
[ 	n
] 	a
==See also==
* Binin++
==External resources==
Scratch interpreter
Category:Turing tarpits Category:Turing complete Category:Languages Category:No IO Category:Implemented Category:Cell-based Category:Low-level
Binin++

Binin++ or Bini is minimalization of Binin that combines a and i into i
==Commands==
 b - move ponier to the right and flip bit
 i - end loop and move pointer to the left
 n - start loop
==Translation to Binin==
Binin	Binin++(Bini)
b 	b
i 	ni
n 	n
a 	ibnib
==Translation from 1-bit BF==
BF	Binin++
@ 	nib
> 	bnib
< 	ni
[ 	n
] 	ibnib
==Turing completness==
YES
Category:Turing tarpits Category:Turing complete Category:Languages Category:No IO Category:Unimplemented Category:Cell-based Category:Low-level
Biota

Biota, devised by Ward Cunningham, is an esoteric programming language in two dimensions and sold for a net profit in 1991 (predating Befunge). The desire was for a 2-D language that was simple enough and robust enough to experiment with code mutation.
==External resources==
* Biota page on Ward's wiki
* Original Smalltalk source
* Notes on the model and operations
* interpreter in JavaScript on a web page
Category:Two-dimensional languages
Category:Languages
Category:Implemented
Category:Before 1993
Category:No IO
Bipoint

Bipoint is an esoteric programming language created by User:FireFly 2009.
It's an SMM with a very limiting set of operations.
== Syntax ==
A Bipoint program consists of a series of node declarations, which looks like the following:
id : op -> ifZero : ifOne
where the spaces signify any amount of tabs or spaces (zero or more).
* id is a positive number which identifies the node. The id of a node must be unique in a vaild Bipoint program.
* op is an operation. Valid operations are S, 0 and 1.
* ifZero is a number matching the id of a node (any node, including the same node as the row defines, is acceptable).
== Execution ==
A program executes on a given stack of symbols, which are either 0 or 1. These are read from standard in, and pushed in the order they are read:
* "10011" would mean that {1, 0, 0, 1, 1} would be pushed to the stack, so it would contain {1, 1, 0, 0, 1}.
After the input process, the program begins by jumping to the starting node. From there, it continues to the nodes given by ifZero and ifOne, by popping one number from the input stack and moving on accordingly.
For every node after the starting node, the operations 0 and 1 each pushes their values to the output stack.
When the input stack is empty, program execution ends. At the end of execution, the output stack is popped until empty, and the number consisting of these binary digits is returned.
== Example programs ==
Decrementing a number is quite trivial to do in Bipoint. Incrementing a number, on the other hand, would be impossible, since incrementing any number which only consists of 1 digits would mean the length of the resulting number would exceed the length of the number given as input.
Below is a program that decrements any number greater than 0:
1 : S -> 2 : 3
2 : 1 -> 2 : 3
3 : 0 -> 5 : 4
4 : 1 -> 4 : 5
5 : 0 -> 4 : 5
== Computational class ==
Its exact computational class is unknown, but Bipoint is at most as powerful as finite state automata with output, since every Bipoint program is essentially the transition graph of one.
Category:Languages
Category:Unimplemented
Category:2009
Category:Unusable for programming
Category:Stack-based
Category:Unknown computational class
Category:Low-level
Birb

Birb is an untyped, purely functional language based on Lambda Calculus and Combinatory Logic.
==Language overview==
The birb language is entirely comprised of bird emojis. 
==Symbols==
Symbol	Name 	Lambda Calculus 	Combinator
🦉 	owl 	\ab.b(ab) 	owl
🦅 	eagle 	\abcde.ab(cde) 	eagle
🪽 	wing 	\abcd.a(bd)(cd) 	phoenix
🕊️ 	dove 	\abcd.ab(cd) 	dove
🦜 	parrot 	\a.aa 	mockingbird
🦆 	duck 	\abc.c(ba) 	quacky
🐤 	touring chick 	\ab.b(aab) 	turing
🐥 	kool chick 	\ab.a 	kestrel
🐣 	hatching chick	\abc.c(ab) 	quirky
🐦 	simple bird 	\a.a 	identity
🦚 	peacock 	\abc.b(ac) 	queer
🦤 	dodo 	\ab.a(bb)\ab.a(bb)	sage
🐧 	penguin 	\abc.a(bc) 	blackbird
🦢 	swan 	\abc.ac(bc) 	substitution
🦩 	flamingo 	\abc.acb 	cardinal
==Syntax==
* [birb]+: Birb
* everything else: Comment
Syntax errors are impossible as long as you use at least one birb.
==Semantics==
Birbs stagger as they walk: they are reduced in alternating associative order, starting with left associativity at birb index ⌊len/2⌋:
 🐦🐦 -> (🐦🐦)
 🐦🐦🐦 -> ((🐦🐦)🐦)
 🐦🐦🐦🐦 -> (🐦((🐦🐦)🐦))
 🐦🐦🐦🐦🐦 -> ((🐦((🐦🐦)🐦))🐦)
 🐦🐦🐦🐦🐦🐦 -> (🐦((🐦((🐦🐦)🐦))🐦))
 🐦🐦🐦🐦🐦🐦🐦 -> ((🐦((🐦((🐦🐦)🐦))🐦))🐦)
 ...
==Examples==
You can find more examples (with comments) in the samples/ directory.
===Relationships===
* 🪽🐦 -> 🦢
* 🦢🐦 -> 🦉
* 🦉🐦 -> 🦜
* 🕊️🐦 -> 🐧
* 🐧🐧 -> 🕊️
* 🦩🐧 -> 🦚
* 🦩🦚 -> 🐧
* 🦩🦆 -> 🐣
One can only imagine what happens if two parrots talk to each other: 🦜🦜 -> 💥. The same happens with 🐤🐤; they just can’t stop waddling!
===Arithmetic===
For this example I use the Church numerals. Zero would then be encoded as 🐥🐦. The successor function can be written as 🦢🐧:
* 🐦🐧🐦🦢🐧🐥🐦 -> \\(10) (Church numeral 1) 
* 🐦🐧🐦🐧🕊️🦢🐧🦢🐧🐥🐦 -> \\(1(10)) (Church numeral 2)
Similarly, one can translate the Church addition function to 🪽🐧. Now, to calculate 1+2 based on their increments from zero:
* 🐦🐦🕊️🐧🕊️🐧🐦🐧🕊️🐧🕊️🪽🐧🦢🐧🦢🐧🐥🐦🦢🐧🐥🐦 -> \\(1(1(10))) (Church numeral 3)
Also: 🐧 is a*b, 🦜 is n^n and 🦚🐦 a^b.
Note that there exist many alternative ways to do arithmetic. Try writing the functions above with other birbs!
===Containers===
You can create a pair [X,Y] using 🦩🦩🦩YX.
Typically, one would now construct a list using repeated application of pairs (Boehm-Berarducci/Church encoding). However, due to the reversed application and alternating associativity, the Mogensen-Scott encoding is more suitable:
List [X_1,X_2,...,X_n]: [🦩]ⁿ🦩X2X1...XN.
==Turing-completeness==
Birb is Turing complete, since one can construct any term of the Jot variant of Iota. A Jot term ((X s) k) is equivalent to 🐦🐦X🦢🐥. Similarly, (s (k X)) is equivalent to 🐦🦆X🐥🦢.
==Implementations==
As of right now there is one interpreter, written by User:melvin in Haskell: . It also features a BLC to birb transpiler.
Category:Languages 
Category:Stack-based 
Category:Turing complete 
Category:Implemented
Category:2021
Category:Functional paradigm
Bird

Bird is a two-dimensional esoteric fungeoid invented by User:masalt in Python 3.
==Examples==
===Quine===
 .0/~
===Hello World===
 'Hello, World!'/~
===Truth machine===
 > =?=&1v>'0'/~
 ]1t/'1'[<
==Interpreters==
The Official Bird Interpreter
Category:Low-level Category:Languages Category:Two-dimensional languages Category:Implemented
Birdie

(note: this article is incomplete and a work-in-progress)
Birdie is a rotqueue-based, mostly concatenative, and approximately low-level Esoteric programming language designed by the Sakito System (under the username and account of @zackbuildit on Discord, and zackbuildit777 on the esolangs wiki) designed predominantly by a single numeric operation referred to as the "g gate", with features including subroutines, a rotatable queue data structure, full keyboard input, and strictly terminal output format.
All data in the language is in the form of 2bit unsigned integers, with series of data items stored in the rotatable queue being used to convey ASCII text and values >3. It is Turing complete, though with sub-optimal time complexity for many activities due to data only being able to directly alter up to 2 bits at a time without removing said altered data in the process. The name derives from an alternate name for a shuttlecock, which is the "ball" in the sport of badminton.
While Birdie is designed to be used in program golfing, rather than attempting to allow minimal bytes for programs, its intent was to "make codegolfing a fun and interesting challenge!" by simultaneously necessitating the use of optimization for the majority of programs, while also attempting to make methods of optimizing compatible with Birdie especially obvious to the programmer.
==language overview==
Birdie operates on two manipulable data structures, being the arithmetic stack (henceforth abbreviated as the arith stack) and the output-handling data queue (henceforth referred to as the outqueue), with the outqueue being the only directly poppable way to store and/or interact with unbounded data. Birdie has only one multi-argument numeric operation, referred to as the g gate, which is defined by first summing all inputs to the gate (if 0 inputs assume sum=0) modulo 4, then mapping this value according to 0->2, 1->0, 2->3, 3->1.
category:languages category:deque-based category:golfing language category:Turing complete category:low-level
BitBrain

BitBrain is a language by User:ChuckEsoteric08 based on BF, but with bits. There is only 10 bits by default, but you can add more bits.
==Commands==
Command	Meaning
> 	move pointer to the right
< 	move pointer to the left
* 	flip current bit
[ 	jump to matching ] if bit is zero
] 	jump to matching [ if bit is not zero
+ 	add new bit
==Variations==
===BitBrain-E===
Original version of the language. + adds bit to the end of a tape
===BitBrain-R===
+ adds bit after the current cell. Used for Computational class proofs for various esolangs such as NASAL and StackBit. It could simulate BitBrain-E like that:
BitBrain-E 	BitBrain-R
Program Start	++++++++++>*>>*>>*>>*>>*>>*>>*>>*>>*<<<<<<<<<<<<<<<<
> 	>>
< 	<<
+ 	>[>>]*++[<<]<
[]* are the same
===BitBrain-L===
Opposite of BitBrain-R. Adds bit before the current cell. Can simulate BitBrain-E like that:
BitBrain-E 	BitBrain-L
Program Start	+<+<+<+<+<+<+<+<+<+*>>*>>*>>*>>*>>*>>*>>*>>*<<<<<<<<<<<<<<<<
> 	>>
< 	<<
+ 	>[>>]+<+<*[<<]<
[]* are the same
It can also simulate BitBrain-R like that:
BitBrain-R 	BitBrain-L
Program Start	>>>>>>>>>
> 	<
< 	>
[]*+ are the same. Also can be applied to BitBrain-L to compile it to BitBrain-R
===BitBrain-S===
Opposite of BitBrain-E. Adds the cell to the start of a tape. Can simulate BitBrain-E like that:
BitBrain-E 	BitBrain-S
Program Start	>>>>>>>>>
> 	<
< 	>
[]*+ are the same. Also can be applied to BitBrain-S to compile it to BitBrain-E
==External resources==
Interpreter in Scratch
==Computational class==
It is Turing-complete, because it is version of Smallfuck with ability to epand tape.
Category:Languages Category:Turing complete Category:Turing tarpits Category:Implemented
BitChanger--

BitChanger-- is basically the same as BitChanger, but the ] and < commands are unified into a | command.
This results in the following instruction set:
 } toggles the current bit and moves to the next bit
 [ starts a loop
 | ends a loop and moves 1 back
Note that to be Turing-complete empty loop [| should be a NOP. Whether language is Turing-comple if empty loop isn't a NOP or not it unknown
Category:Languages Category:Turing complete Category:Turing tarpits
BitChip

BitChip is a two-dimensional programming language. A program consists of "chips", which are square-shaped, with an odd number of commands on each side. The instruction pointer enters and exits chips in the center of each side. As in Befunge, the instruction pointer consists of both a position and a direction (horizontal or vertical).
Commands:
 /\ Bounce off
 <>^v Move in that direction if value is odd number
 {} Left/right shift bits in the accumulator (wrap around)
 _ Flip end bit of the accumulator (or "bit0"; it's not clear just what this is)
 ! Skip one command
 ` Turns into ~ and instruction pointer goes clockwise
 ~ Turns into ` and instruction pointer goes counter-clockwise
 @ Enter sub-routine
 $ End sub-routine (perform a jump to the command two spaces ahead of the corresponding @)
 # Memory storage: If hit, sets address
 ) Store accumulator in memory storage orthogonally adjacent to this one (if more than one, do to all)
 ( Set accumulator value in memory storage orthogonally adjacent to this one (if more than one, return XOR value of all)
 | One value memory storage: Swaps accumulator with value stored in here
 . NOP
 , Set accumulator to zero
 ; Forget top entry of sub-routine stack
 : Duplicate top entry of sub-routine stack
 + Sub-chip: Connects directly to + sign in chip 2 spaces in direction of moving. Example: Move north into + sign, you go to the + sign in the chip north of north of this one. If more than one + sign in destination, choose one with same adjacent stuff (both orthogonally and diagonally).
 Anything else is a NOP.
Chips can connect to each other in any way. The size of the accumulator is unspecified, and the exact functions of _ and # are unknown.
Category: Languages
Category: Low-level
Category: Two-dimensional languages
Category: Unknown computational class
Category: No IO
Category: 2006