nyuuzyou/wikis huggingface dataset:
Bifuck

Bifuck is a brainfuck inspired esolang created by User:SpaceByte on 8/3/22. Bifuck is exactly the same as brainfuck, proving its turing completeness, however, code is written more tediously, using only two characters, however, programs will have much greater length.
== Language Overview ==
Bifuck has the exact same capabilities as brainfuck, and is built off of brainfork, the creators first experience with esolang development, which was a brainfuck interpreter written in C#. The interpreter for bifuck is the same as brainfork, except it uses switch cases for better preformance, and it converts bifuck code, to brainfuck before executing. Because it converts before executing, the interpreter on its own is a brainfuck interpreter, it just converts bifuck to brainfuck, proving the convertibility between languages is 100% possible and very easy to create. Bifuck operates using two characters, similarly to how two characters are used in B, however B has commands that involve the "stack" item count, bifuck does not. In bifuck, like B, one character (.), is a separator, and the other character (+), is used in between the seperator, to identify by length of each command, each length of a string in-between the Seperator, being a command.
== Conversion Commands ==
The following are the lengths of commands (with exact examples) of what bifuck commands convert to which brainfuck commands.
<pre>
Length 1 (bifuck: .+.) converts to (brainfuck: >)
Length 2 (bifuck: .++.) converts to (brainfuck: <)
Length 3 (bifuck: .+++.) converts to (brainfuck: +)
Length 4 (bifuck: .++++.) converts to (brainfuck: -)
Length 5 (bifuck: .+++++.) converts to (brainfuck: .)
Length 6 (bifuck: .++++++.) converts to (brainfuck: ,)
Length 7 (bifuck: .+++++++.) converts to (brainfuck: [)
Length 8 (bifuck: .++++++++.) converts to (brainfuck: ])
Category:Languages
Category:2022
Category:Brainfuck_derivatives
Category:Implemented
Category:Turing complete
Bifus

Bifus is an esoteric programming language made by User:Hexahedron1 and is essentially Brainfuck, where 1 character is 2 instructions.
=== Name ===
Bushes hid the facts.
== Conversion ==
To convert Brainfuck to Bifus, follow these steps:
# Pick 2 adjacent instructions, for example +>
# Convert them using the table from TheLang, in this case 2 and 1
# Convert the numbers to binary and join them (10001 or 17 in decimal)
# Pick the character in the lookup string at the position of the number (/)
=== Ending ===
If the number of instructions is odd, the last character should be encoded by itself (eg. . becomes $) and ъ is inserted at the end.
=== Lookup string ===
!@#$%^&*()-_=+\|/?<>,.0123456789abcdefghijklmnopqrstuvwxyz[]<>'"
== Examples ==
=== Hello world ===
<<<<r<<r<-<-<-!!9--_)0*$z=_5c<<<e<,)a6%<,555d5556),-,
Brainfuck source:
++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
=== Adding two values ===
The code that adds the current cell to the next looks like this:
t-*
Brainfuck source:
[->+<]
=== Rot13 ===
708)<<r<<<<$y/8--_r)yw-$z-|!!$")\9?5tq3t"ys<<<<</r8-)zsq?9-)y!!9)q?9\82&9)y&!3_z|!q#)9ytyg9$k*ъ
Brainfuck source:
-,+[-[>>++++[>++++++++<-]<+<-[>+>+>-[>>>]<[[>+<-]>>+>]<<<<<-]]>>>[-]+>--[-[<->[-]]]<[++++++++++++<[>-[>+>>]>[+[<+>-]>+>>]<<<<<-]>>[<+>-]>[-[-<<[-]>>]<<[<<->>-]>>]<<[<<+>>-]]<[-]<.[-]<-,+]
== See also ==
* TheLang
Category:Languages 
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Turing complete 
Category:2024
Category:Cell-based
BigBrain Discord

BigBrain is a brainfuck remake by user k written in Lua. (Github Page)
This is an extension to BigBrain.
All the different Commands BigBrain Discord Has (Bytes = Cells) :
 Commands
;	Prints the current output.	Miscellaneous
&	Clears the current output.	Miscellaneous
(All brainfuck/bigbrain symbols not present here are still the same)
==Examples==
==="Hello, world!" printed using a simple algorithm :===
++++++>+<_$.!$>-<_$_$.!$>-<_$>+++++++<_$..!$_$_$.!$+++>+++<_$.!$++>+<_$.!$_$>++++++++<_$.!$_$_$.!$_$>+++<_$.!$>-<_$>+++++++<_$.!$>-<_$>-<_$.!$++>++<_$.!$
==="Hello, world!" printed using a human brain :===
++++++>+<_.!$++++++++_.+++++++..+++.!$+!=*!=_.---.*--$-.>+<----.+$+.>+<---.----.!$!*****$+.
===Cat Program :===
[,;&] since every cell is equal to 1 at the beginning, a cat program can be made even shorter.
===Move Value :===
!>! this moves the current value two cells to the right while keeping the two other values intact.
Category:Languages Category:Brainfuck derivatives Category:Cell-based Category:Turing complete Category:Implemented Category:Low-level
BigFish

BigFish is an esolang made by User:Yes that is based off of Deadfish.
== Commands ==
Command 	Effect
i[register] 	Increment the specified [register].
d[register] 	Decrement the specified [register].
s[register] 	Square the specified [register].
o[register] 	Output the specified [register].
new 	Create a new register, amenable to the next available index.
loop[repetitions]{}	Loop the code inbetween { and } the specified [repetitions] number of times.
There are no registers when the program is initially started. The registers are referenced with positive integer indices starting with the value one (1). By creating a new register, the next available subscript is assigned for its designation.
== Examples ==
Make 10 registers
loop 10
{
new
}
Make 3 registers and set them all to 10
new
new
new
loop 10
{
i 1
}
loop 10
{
i 2
}
loop 10
{
i 3
}
Print the numbers 1 to 100 using a nested loop.
 new
 i 1
 loop 10
 {
 loop 10
 {
 o 1
 i 1
 }
 }
Print the numbers 1 to 100 using a loop.
 new
 loop 100
 {
 i 1
 o 1
 }
==Interpreter==
* Common Lisp implementation of the BigFish programming language.
Category:Languages
Category:Joke languages
Category:2022
Category:Output only
Category:Implemented
Big Man Computer

There are one thousand memory cells in each bank, each storing a decimal number from 0000 to 9999. The accumulator also stores number from 0000 to 9999 and also has a negative flag and zero flag and carry flag.
Instructions:
* 0xxx: Halt. The xxx is irrelevant.
* 1xxx: Add value from memory cell xxx to accumulator. Zero and negative and carry flags set according to result.
* 2xxx: Subtract value from memory cell xxx from accumulator. Zero and negative and carry flags set according to result.
* 3xxx: Store value of accumulator in memory cell xxx.
* 4xxx: Branch to xxx if carry flag is clear.
* 5xxx: Load value in memory cell xxx into accumulator. Zero flag set according to result.
* 6xxx: Unconditional branch to xxx.
* 7xxx: Branch to xxx if zero flag is set.
* 8xxx: Branch to xxx if negative flag is clear.
* 9xx0: Swap low three digits of accumulator with program counter, and swap data in bank xx with the data in the current program bank. Flags are not affected.
* 9xx1: Read input from port xx into accumulator. Zero flag set according to result.
* 9xx2: Output value of accumulator to port xx.
* 9xx3: Select program bank xx. Program counter remains unchanged.
* 9xx4: Select data bank xx.
* 9xx5: Swap memory of bank xx with the memory of the current data bank.
* 9xy6: Swap program bank selection with data bank selection if either digit x or y is in the accumulator.
* 9xx7: Multiply accumulator by ten and add xx. Flags are not affected.
* 9xx8: Divide accumulator by one hundred and shift in xx. Zero flag is set according to shifted out digits.
* 9xy9: If x is zero, set carry flag. If y is zero, complement carry flag. If x is one, set zero flag. If y is one, complement zero flag. If x is four, set negative flag. If y is four, complement negative flag.
Category:Low-level
Category:Languages
Category:2014
Category:Cell-based
Category:Finite state automata
Bigot

A Bigot (or bigotous program) is an extension of a Narcissist. It is a program (or Turing machine encoding) that decides the following language: The set of programs (or encodings of TMs) that decide this language. In other words, it only accepts programs that are just like itself.
This concept was independently dreamed up by David Rutter (User:Quintopia) in 2010 as a natural generalization of the Narcissist concept. Notice that a Bigot is not a Narcissist, as Narcissists only accept their own listing. A Bigot also accepts its own listing, but many other programs besides.
Let us call the set of Bigots a particular Bigot accepts its class, since they define an equivalence class under the relation "accepts the same language." Since a program that accepts such a language can contain any number of null operations, the language will be infinite in size. However, we have no reason to believe there is only one such language. Indeed, there may be infinitely many. In general, it will most likely depend on the computational class of the language one is working with.
Note that the existence of such a program is impossible in any Turing-complete language, as this would contradict Rice's theorem.
So, an open question is this: What is the maximum computational power a language can have, and still admit a bigotous program?
==See also==
* Narcissist
Category: Program forms
Bigspace

::WARNING: To understand the page you first need to know Whitespace
Bigspace is a Whitespace clone which instead of using 3 characters, it uses only one.
== How? ==
The character it uses is the character you want, because the actual character is the time,
What I'm saying is that you need to press a character in your keyboard for an amount of time to do something.
=== Isn't that cheating? ===
Obviously it is, but it's an esolang so it doesn't matter
== Language ==
=== Writing numbers ===
Writing numbers is hard.
To write a number you need to write them in binary, to put a 0 you press any letter for 1 second, to put a 1 you need to press any letter for 2 seconds, when you finish you press any letter for 3 seconds, if you want to make it negative, instead of pressing it for 3 seconds press it for 4 seconds.
=== IMPs ===
To write IMP 	Press time is
I/O 	Less than 1 second
Stack manipulation	1 second
Arithmetic 	2 seconds
Flow control 	3 seconds
Heap access 	4 seconds
=== I/O ===
Writing 	Press time
[Tab][Space] 	Less than 1 second
[Tab][Tab] 	1 second
[Space][Space]	2 seconds
[Space][Tab] 	3 seconds
=== Stack manipulation ===
Writing 	Press time
[Space] 	Less than 1 second
[LF][Space]	1 second
[LF][Tab] 	2 seconds
[LF][LF] 	3 seconds
=== Arithmetic ===
Writing 	Press time
[Space][Space]	Less than 1 second
[Space][Tab] 	1 second
[Space][LF] 	2 seconds
[Tab][Space] 	3 seconds
[Tab][Tab] 	4 seconds
=== Flow control ===
Writing 	Press time
[Space][Space]	Less than 1 second
[Space][Tab] 	1 second
[Space][LF] 	2 seconds
[Tab][Space] 	3 seconds
[Tab][Tab] 	4 seconds
[Tab][LF] 	5 seconds
[LF][LF] 	6 seconds
=== Heap access ===
Writing	Press time
[Space]	Less than 1 second
[Tab] 	1 second
Category:Languages Category:Turing complete Category:Stack-based Category:Cell-based Category:Unimplemented Category:Non-textual
Bijection

Bijection is a esolang created by User:Yayimhere where all you do is copy lines to other lines
== commands ==
there is the main command:
 {}n
the contents of the brackets will be replaced with the contents of line n(starting at 0). if the brackets already has content it will be prepended. and to separate these(so you can have more commands on the line) you use ;. the contents will be ran once
all this loops forever. so we iterate each line once top to bottom. then we do it again forever. also putting # at the start of the line that line will be ignored. if it's anywhere else than the start its ignored
=== the printing extension ===
in this extension (print x) prints x(it ends at the last bracket)
== examples ==
Infinite loop:
 {}0
(even though every program loops forever but dis one does something)
Looping counter(created by User:ais523 and rewritten a little bit by User:Yayimhere):
 {}1
 #(print * ) 
 (print \n )
this uses the printing extension, but if you delete the print's, the brackets, and the #, and it will work the same. the fact that Bijection can do this proves that it's more power full than a linear bounded automaton
Category:Languages Category:Unimplemented
Bin-8

bin-8 is an idea (WIP) for programming language. It's founded in 2019 by User:OsmineYT. All instructions are represented in binary, so it's maybe hard to read.
== Instructions ==
Command 	Short Description	Java equivalent
00000000	start of program 	{
00000001	end of program 	}
00000010	prints any text 	System.out.println();
== Implementations ==
* A Python interpreter
Category:Languages Category:2019 Category:Total Category:Unusable for programming Category:Implemented
Bin-snake

Bin-snake is a Python wrapper, in Binary. Bin-snake converts a Bin-snake file (.bs) to Python code, and then executes it to Python.
==Writing Bin-snake==
With an understanding of binary and binary/ascii conversions, as well as an understanding of Python, writing Bin-snake is quite simple. Just convert every character in a Python program to its Binary representation.
==Bin-snake Files==
A Bin-snake file (.bs) can be comprised of any characters, although only 1s and 0s will be recognized. Any other characters will be treated as comments.
==Running Bin-snake==
Running Bin-snake is quite simple. A(n) compiler/interpreter can be found on https://github.com/Mecaneer23/Bin-snake. Have fun!
==Examples==
===Hello, world!===
 01110000011100100110100101101110011101000010100000100010010010000110010101101100011011000110111100101100001000000111011101101111011100100110110001100100001000010010001000101001
Category:Languages Category:Implemented Category:Turing complete Category:High-level
BinPython

== BinPython ==
The name tells it all.. Binary-Python
=== A language which is indeed a brother of python, but in BINARY! ===
There is one Windows executable to run Binpython files..
Which can be found in its Github Repo
The main program file is in fact written in BinPython ITSELF!
The long-form source code is 334kb in size
==== Let's Teach you some BinPythoning.. ====
There are some basic rules:
# There are only 2 characters.. (0 and 1)
# All characters other than 0 and 1 are ignored
# All codes are Python codes but, in binary (ASCII)
Sample program:
Hello, world:
01110000011100100110100101101110011101000010100000100010010010000110010101101100011011000110111100101100001000000101011101101111011100100110110001100100001000010010001000101001
Output:
 Hello, World!!
==Conversion==
===BinPython to Python===
def binPythonToPython(s):
	s = "".join(c for c in s if c in "01")
	if len(s) & 7:
		raise SyntaxError("Wrong length")
	unbin = lambda s: int(s, 2)
	z = lambda s: tuple(map("".join, zip(*(s[i::8] for i in range(8)))))
	return "".join(tuple(map(lambda x: chr(unbin(x)), z(s))))
===Python to BinPython===
def pythonToBinPython(s):
	return "".join(map(lambda c: bin(ord(c))[2:].rjust(8, "0"), s))
Category:Languages Category:Turing complete Category:Implemented Category:High-level
Binary

==Credits==
This language is made by User:DimensionDoors. It is his first one. Yay!
Language extended by User:Europe2048, you can still extend more if you want!
==Syntax==
The only characters are 0 and 1. (obviously!) Any other characters are ignored and can be used as comments, meaning you may split your code into bytes if you want. The first eight characters determine the function.
 00000000 print for strings
 00000001 initialize a variable (variable (no prefix and suffix) then value)
 00000010 convert a variable (no prefix or suffix) from a number to a string, and vice versa
 00000011 print for variables (no prefix and suffix)
 00000100 [ in bf
 00000101 if
 00000110 equal to...
 00000111 not equal to...
 00001000 greater than...
 00001001 less than...
 00001010 greater or equal to...
 00001011 less than or equal to...
 00001100 ] in bf
 00001101 else if
 00001110 ask user for input, then store it in variable
 00001111 number prefix
 00010000 like : in python
 00010101 else
 00011111 repeat ___ times
 00100000 number prefix
 00100001 string prefix
 00100010 number suffix
 00100011 string suffix
 00100101 condition suffix
 00110000 define a function (function name, parameters, then commands)
 00110001 function definition suffix
 01000000 addition
 01000001 subtraction
 01000010 multiplication
 01000011 division
 01000100 exponentiation
 01000101 random number between two given numbers
 01000110 square root
 01000111 modulo
 11000000-11001111 reserved for variables
 11010000-11011111 reserved for parameters
 11100000-11111110 reserved for custom functions
 11111111 end the program (optional)
Variables are words (in ascii or just a number) that hold a value (you probably knew that).
Numbers are stored as 32-bit floats.
Strings are stored as UTF-16.
==Ideas==
None yet!
==Cat==
 00001110 11000000 input one character to first variable
 00000011 11000000 print first variable
==External resources==
* Rust interpreter
Category:Languages Category:2020 Category:Low-level Category:Implemented
Binary-encoded Minsky machine

Binary-encoded Minsky machine (BMM) is a version of Minsky machine by User:ChuckEsoteric08
==Encoding==
This version is based on a version of Minsky machine with instructions INC and JZDEC, along with I/O instructions, where INP sets register to ASCII value of input and OUT outputs register as a character. It unlimited amount of registers and indexes start at 1. Commands are encoded like that:
INC r - 110r0
JZDEC r z - 10r011z0
INP r - 101r0
OUT r - 0r0
*r (returns value of register r, could not be used as a z in JZDEC) - 0r
r and z should be in Unary as a list of 1s. If you jump to nonexisting instruction halt
Category:Languages Category:Turing complete Category:Turing tarpits Category:Unimplemented Category:Low-level Category:Computational models
BinaryBefunge

BinaryBefunge is an esoteric programming language written by Dominicentek. It's a clone of Befunge. It's like Befunge, but all the characters are represented as binary.
== Instructions ==
This esolang has all the instructions as Befunge-93. Each binary digit is an ASCII value of the Befunge-93 command. When any character found that is not 0 or 1 will make the interpreter quit automatically without execution.
Instruction 	Description
00101011 	Pops 2 values and adds them, then pushes the result
00101101 	Pops 2 values and subtracts them, then pushes the result
00101010 	Pops 2 values and multiplies them, then pushes the result
00101111 	Pops 2 values and divides them, then pushes the result
00100101 	Pops 2 values and modules them, then pushes the result
00100001 	Pops 1 value and checks if its a 0, if yes, a 1 is pushed. Otherwise a 0 is pushed
01100000 	Pops 2 values and compares them, If 2nd value is greater than 1st, it pushes a 1, otherwise it pushes a 0
00111110 	Makes the pointer move right
00111100 	Makes the pointer move left
01011110 	Makes the pointer move up
01110110 	Makes the pointer move down
00111111 	Makes the pointer move in random direction
01011111 	If statement, a value is popped and checks if its a 0, if yes, the pointer moves right, otherwise it moves left
01111100 	If statement, a value is popped and checks if its a 0, if yes, the pointer moves down, otherwise it moves up
00100010 	Toggles string mode. Pushes any ASCII code onto the stack until the next 00100010 is reached
00111010 	Duplicates the top value on the stack
01011100 	Swaps the top 2 values on the stack
00100100 	Pops the top value on the stack and discards it
00101110 	Pops the top value of the stack and outputs it as an integer to the console.
00101100 	Pops the top value of the stack and outputs it as an ASCII character to the console.
00100011 	Skips the next instruction
01100111 	Pops 2 values of the stack and uses it as Y and X coordinates. Then, pushes the ASCII code of the character on the playfield on these coordinates.
01100111 	Pops 3 values of the stack and uses it as Y and X coordinates and an ASCII code. Then, puts the ASCII character onto the playfield on the X and Y coordinates.
00100110 	Gets an integer from the user and pushes it onto the stack
01111110 	Gets ASCII character from the user and pushes it onto the stack
01000000 	Ends this program
00110000 to 00111001	Pushes a number onto the stack
Any value that is not a valid instruction is ignored.
As in Befunge-93, the playfield is 80x25 characters. Each row must have 80 8-bit binary digits, terminated with a new line. There also must be 25 rows.
== Examples ==
* Hello World
* Truth Machine
== Interpreter ==
* Download
* View Source
Category:Languages
Category:Implemented
Category:Two-dimensional languages
Category:Push-down automata
BinaryLanguage

BinaryLanguage is an esolang created by User:None1 which uses some simple binary operations.
==Memory Model==
BinaryLanguage uses three registers (initially zero): A, B and C. They can contain unsigned integers of any size (or up to at least 210000).
==Commands==
 BinaryLanguage Commands
Command	Meaning 	Example
+ 	Increments A 	A=1,B=2,C=3 → A=2,B=2,C=3
- 	Decrements A (Note: If A=0, then A is unchanged) 	A=1,B=2,C=3 → A=0,B=2,C=3
& 	Bitwise and A and B, stores the result in A 	A=1,B=2,C=3 → A=0,B=2,C=3
^ 	Bitwise xor A and B, stores the result in A 	A=1,B=2,C=3 → A=3,B=2,C=3
 	Bitwise or A and B, stores the result in A 	A=1,B=2,C=3 → A=3,B=2,C=3
< 	Bitwise left shift A by B bits, stores the result in A 	A=1,B=2,C=3 → A=4,B=2,C=3
> 	Bitwise right shift A by B bits, stores the result in A 	A=17,B=2,C=3 → A=4,B=2,C=3
~ 	Swaps A and B 	A=1,B=2,C=3 → A=2,B=1,C=3
* 	Performs a right circular shift to the three registers 	A=1,B=2,C=3 → A=3,B=1,C=2
( 	If A=0, jump to the matching ) 	-
) 	If A!=0, jump to the matching ( 	-
, 	Reads a character from user input and stores its ASCII value to A	-
. 	Output the character with its ASCII value the same as A 	-
Incorrect commands echo themselves.
==Example Programs==
===Hello World (also a Quine)===
 Hello World!
===Cat Program (never terminates)===
 +(~,.~)
===Truth Machine===
 +++~++++~<~,^(^(.))^.
==Turing Completeness==
BinaryLanguage is Turing complete as a conversion from brainfuck is possible.
 BinaryLanguage conversion from brainfuck
brainfuck	BinaryLanguage
+ 	(-)+<(*+**-)
- 	(-)+<(*-**-)
> 	~++++++++~
< 	~--------~
, 	(-)+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<*~&~^**,<|
. 	(-)+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<*~&~**>.
[ 	(-)+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<*~&~**>(
] 	(-)+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<*~&~**>)
==External Resources==
* Official interpreter in Python.
Category:Languages
Category:Implemented
Category:Turing complete
Category:Turing tarpits
Category:2023
Binary ///

Binary /// is a derivative of slashes that operates directly on bits, and only uses 1 and 0, the equivalents of / and \.
Output is given in binary, and can be interpreted as unicode.
==Examples==
Hello, World! (20.625 bytes)
 
01011000001101101110111110101110110110101101011110101101011110101101010101110110101111101111111011011010101101011010101011010101110111010110101111010111011111011111
or in unicode:
 ¬�w×mkÖ½j»_mZÕjîµë¾
Infinite loop
 111
Category:Languages
Category:Unimplemented
Category:String-rewriting paradigm