nyuuzyou/wikis huggingface dataset:
Blip

The Blip language is an esolang.
==Examples==
===Popular problem===
====Hello World!====
 t12Hello World!
====Cat program====
 A</code>
====Looping Counter====
 ;At0;i+.tt+.t1*
====99 bottles of beer====
 ;n99t0+.+t+n100_i+t7 bottle+?=in99t0t1s+t21 of beer on the wall,+tt+t+n100_i+t7 bottle+?=in99t0t1s+t9 of beer.+tt+t30Take one down, pass it around,+tt+?=in99t2Not+n99_i+t7 bottle+?=in98t0t1s+t21 of beer on the wall.+tttt
or
 ;n99t0++++++++++++++++++.t+n100_it7 bottle?=in99t0t1st21 of beer on the wall,ttt+n100_it7 bottle?=in99t0t1st9 of beer.ttt30Take one down, pass it around,tt?=in99t2Not+n99_it7 bottle?=in98t0t1st21 of beer on the wall.tttt
====Factorial====
 *;An0+B.
 ;An1*i.
Category:Languages
Category:2023
Category:Implemented
BloodCell

A language by User:PixelatedStarfish that is designed to describe abstract computers and computational models. This is accomplished with a grid of arbitrary size, such that each cell stores a one or a zero. Cells can be flipped, and stored on a tape for output. Unlike in the original Blood, this tape cannot be modified directly by instructions in this language. The tape only exists to allow the printing of characters.
The language would be a Turing tarpit if not for macros, which allow a programmer to define complex operations using primitive instructions or other macros.
Category:Languages
Category:Turing complete
Blues machine

:Note that blues machine is typically lowercased except, often, at the start of a sentence.
The blues machine is an OISC esolang by User:PythonshellDebugwindow.
==Syntax==
Each line in a blues machine program is either empty, a comment, or the blues instruction. Comments are denoted by #.
==The blues instruction==
The semantics of the blues instruction are as follows (using floor division, in such a way that division by 0 yields 0):
 ++*a; *b *= *c; *d /= *e; if(*f) goto (g ? h : *h);
Its syntax (spaces after commas are optional):
 blues a, b, c, d, e, f, g, h
All values are integers, and the memory is initialized to all zeros.
==Examples==
===Infinite loop===
 blues 0,0,0,0,0,0,0,0
===Truth-machine===
Replace <input> with your input.
 blues <input>,0,0,0,0,1,0,0
==Computational class==
Blues machine can simulate any Minsky machine, so it is Turing-complete. The inability to subtract is a slight obstacle, but a counter value of x can be encoded as 2x to get around this. See the full conversion here.
==External resources==
* An interpreter written in Python 3
Category:Languages Category:2020 Category:OISC Category:Implemented Category:Low-level Category:Turing complete Category:No IO
Blues machine/Portable Minsky Machine Notation conversion

Overview:
*0 will contain the constant 0.
*1 will be a junk variable that absorbs any operations we don’t want.
*2 will contain the constant 2.
*The Minsky machine must only use counter indices greater than or equal to 3. Equivalently, you can increase all counter indices by 3 before applying this conversion.
*A counter value of x is encoded as 2x.
==Initialization==
 blues 2, 1, 1, 1, 1, 0, 1, 1
 blues 2, 1, 1, 1, 1, 0, 1, 1
 blues 3, 1, 1, 1, 1, 0, 1, 1
 ⋮
 blues N, 1, 1, 1, 1, 0, 1, 1
==Incrementing==
PMMN:
 inc(n)
Pseudo-C:
 *n *= 2;
Blues machine:
 blues 1, n, 2, 1, 1, 0, 1, 1
==Decrementing==
PMMN:
 dec(n)
Pseudo-C:
 line m: *n /= 2; if(*n) goto m+2;
 line m+1: ++*n;
Blues machine:
 line m: blues 1, 1, 1, n, 2, n, 1, m+2
 line m+1: blues n, 1, 1, 1, 1, 0, 1, 1
==If-Else==
PMMN:
 if(dec(n)) {...} else {...}
Pseudo-C:
 line m: *n /= 2; if(*n) goto j;
 line m+1: ++*n;
 ⋮ else block
 line j-1: goto k;
 line j: ⋮ if block
 line k
Blues machine:
 line m: blues 1, 1, 1, n, 2, n, 1, j
 line m+1: blues n, 1, 1, 1, 1, 0, 1, 1
 ⋮ else block
 line j-1: blues 1, 1, 1, 1, 1, 2, 1, k
 ⋮ if block
 line k
==While==
PMMN:
 while(dec(n)) {...}
Pseudo-C:
 line m: *n /= 2; if(*n) goto m+3;
 line m+1: ++*n;
 line m+2: goto j;
 ⋮ while block
 line j-1: goto m;
Blues machine:
 line m: blues 1, 1, 1, n, 2, n, 1, m+3
 line m+1: blues n, 1, 1, 1, 1, 0, 1, 1
 line m+2: blues 1, 1, 1, 1, 1, 2, 1, j
 ⋮ while block
 line j-1: blues 1, 1, 1, 1, 1, 2, 1, m
Category:Examples
BoVeX

BoVeX is a two-goal optimization typesetting system created by Dr. Tom Murphy VII, Ph.D. in 2024. BoVeX can automatically rewrite the wording of the article slightly if this helps the paragraphs look nicer when the best line breaks are applied to it. BoVeX uses a tunable parameter to decide the importance of two goals: the paragraphs looking nicer, and the rephrasing preserving more of the wording. 
BoVeX uses Facebook's large language model “Llama” for the rewriting, which is why Tom uses his new computer with 128 gigabytes of RAM and the world's largest video card to run this typesetting system. BoVeX is implemented mostly on a new functional programming language, also called BoVeX, and the articles to be typeset are also written in this programming language. BoVeX is algebraically typed with Hindley-Milner type inference similar to standard ML, but with custom extensions to the type system that are somewhat more specialized for typesetting. 
A research articles describing the project and typeset in it is published in two versions, one with and one without the automatic rewriting. The project was also summarized in a live talk on the SIGBOVIK 2024 robot dance party, and there is a video on Tom7's youtube channel that extends that live talk. The source code is also published.
== External links ==
* Dr. Tom Murphy VII, Ph.D., “Badness 0 (Epsom's version)”, March 2024, in a record of the proceedings of SIGBOVIK 2024 the eigtheenth annual intercalary robot dance party in celebration of workshop on symposium about 26th birthdays; in particular that of Harry Q. Bovik, Carnegie Mellon University, p. 131., ed. The Association for Computational Heresy, Pittsburgh, PA, April 0, 2024.
* Dr. Tom Murphy VII, Ph.D., “Badness 0 (Knuth's version)”, March 2024, in a record of the proceedings of SIGBOVIK 2024 the eigtheenth annual intercalary robot dance party in celebration of workshop on symposium about 26th birthdays; in particular that of Harry Q. Bovik, p. 145., Carnegie Mellon University, ed. The Association for Computational Heresy, Pittsburgh, PA, April 0, 2024.
* BoVeX homepage
* BoVeX source code
* popular description video.
* Blog article claiming that there will be a video.
* Blog article announcing the video.
Category:Languages
Category:Functional paradigm
Category:2024
Category:Turing complete
Category:Graphical Output
Category:Implemented
Bodyfuck

Bodyfuck is a gestural interpreter for brainfuck. Because bodyfuck is Turing-complete, all computable operations are possible. Despite this, physical difficulty in implementing more complicated programs may prove to concede the theoretical limitations of the potentially computed output. 
== History == 
Bodyfuck was developed by Nikolaos Hanselmann in 2009. The project's homepage is available here.
== Specification ==
Bodyfuck uses a live video of the programmer to recieve commands. Being on the left or right of the frame shifts the byte pointer. Jumping increases the byte, ducking decreases the byte, and waiting on the left or right starts or ends a loop. Having arms outstretched puts a '.' which outputs the current byte. Clapping twice clears the buffer, clapping once executes the brainfuck script. 
== Examples ==
A demo exists here:
https://www.youtube.com/watch?v=ekjtZ85mA3I
==External Links==
An essay by the author
Category:Languages
Category:Turing complete
Category:Non-textual
Category:Turing tarpits
Category:Brainfuck derivatives
Bog prok

bog prok or /boʊ prʌk/ is a esolang created by User:Yayimhere based on a book cover
== name ==
the name is a pun on the words book and programmeringssprog(danish for programming language). it is made by taking the first letter after the first o in programmeringssprog which is g. so we have og. so we put that into book so it becomes bogok. now we take the three letters before the second o in programmeringssprog we get pr. so we have pro. now we add that into book: bogprok. now add a space and we get bog prok. see! its a book programming language
== concept ==
after looking at the book some of the code looks high level while some looks low level. so i chose memory to be low level to set up but high level to work with
== memory ==
memory is stored in code(UTF-8 encoding). the bytes are extended infinitely to the left with zeros (however we ignore this when operating on the binary) and have a sign bit. however this only applies to memory sections. else numbers are represented as Hexadecimal
== evaluation ==
Bog prok is evaluated lazily
== commands ==
=== other ===
comments:
 ´ comment ´
begin program:
 BEGIN
end program:
 END
=== memory related ===
created a memory section which is skipped over. referenced with the line number of the top {:
 BEGIN MEMORY SECTION
 memory here(yes must be indented)
 END MEMORY SECTION
to make a variable(with null inside):
 DO variable_name AS VARIABLE
and yo set it to a memory section. if the section is char(or one byte) its a single number but if its multiple its an array:
 variable_name IS memory_section (bolean) ´the boolean is just if its true(TRUE) then variable_name is equal to memory_section and if its not for some reason put FALSE´
and to set a memory section to something new(will also restate all variables set to that section) which is any number data:
 MOVE expression or value memory section
=== computation ===
do arithmetic between variables or numbers (hexadecimal) which returns the value of the expresion(evaluated right to left but otherwise like normal math expressions):
 A + B ´A plus B. for string it will append A to B´
 A - B ´A minus B. wont work for string´
 A · B ´A multiplied by B. create a string that is A repeated len(B) times´
 A ÷ B ´A divided by B. wont work for string´
to create a string from numbers(all numbers are hexadecimal actually) where each value separated by /:
 str{x/y/z/...} ´take the ascii values of each and append them into a string with x being first and the last value being the last char´
put that into a variable:
 str.variable_name.var(string)
here are the operators that work on one number. this will also return the value. this is evaluated right to left as well:
 ;A ´reverse the binary of A´
 ~A ´flip the binary of A´
 A± ´increment A´
 A∓ ´decrement A´
 :A ´return a string with A repeated twice´
these are some string operators:
 A¿i ´return A index i´
 ^A ´only works for a single char. return it as a number(ascii value)´
Category:Languages Category:2024
BogusForth

BogusForth is an esoteric programming language inspired by Forth and False. BogusForth was created by Antonio Maschio in 2004.
==Examples==
===Hello, world!===
 "Hello, world!"i 
===99 bottles of beer===
 99b!
 def botl " bottle"i b:1-["s"i]? " of beer"i
 def line1 b:[b:i]["No"i]? botl " on the wall."i10'
 def line2 b:i botl "."i10'
 def line3 "Take one down, and pass it around."i 10'
 [b:][line1 line2 line3 b:1-b! line1 10']#
 0q
==External resources==
* 
Category:Languages
Category:2004
Category:Stack-based
Category:Turing complete
Category:Implemented
Bolic

Bolic, designed by Yutaka Hara in 2008 for his book, Rubyで作る奇妙なプログラミング言語, is a procedural esoteric programming language. The book discusses the implementation of esolangs in Ruby; Bolic is used as an example language.
== Overview ==
=== Abstract syntax ===
Spaces are the only token separators.
NUMBER = ⓪ | ① | ② | ③ | ④ | ⑤ | ⑥ | ⑦ | ⑧ | ⑨ | ⑩ ;
VARIABLE = ✪ | ✩ | ✷ | ✲;
statements = { | statement }; 
statement = output;
output = ♪ expr | ✍ expr | while;
while = ♺ expr ☞ statements ♘ | expr;
expr = if;
if = ✈ expr ☺ statements [ | ☹ statements ] ☻ | additive;
additive = multiple [ | [ ＋ | － ] expr ];
multiple = variable [ | [ × | ÷ ] multiple ];
variable = VARIABLE [ | ☜ expr ] | number;
number = NUMBER;
=== Semantics ===
==== Output statements ====
Bolic supports output only. Two emojis ♪ and ✍ stands fot printf("%d",expr) and putchar(expr), respectively.
==== Control flow ====
While while-loop is a statement while if-branching is an expression. The following code is thus syntaxically valid:
✪ ☜ ✈ ✩ ☺ ✩ ☻
Conditional expression evaluating to non-zero stands for true; otherwise false.
==== Assigning to a variable ====
It is an expression. It is done by VARIABLE ☜ expr.
==== Reading value on a variable ====
The variable whose value is read has to be initialized with any valid value before.
==== Others ====
A block of statements evaluate to that of its last statement.
It is not documented what the bound for value is, if the value must be integers only, or if the value may evaluate to floating value.
== Examples ==
=== Hello, world! ===
♪⑦×⑩＋② ♪⑩×⑩＋① ♪⑩×⑩＋⑧ ♪⑩×⑩＋⑧ 
♪⑩×⑩＋⑩＋① ♪④×⑩＋④ ♪③×⑩＋② ♪⑩×⑩＋⑩＋⑨ 
♪⑩×⑩＋⑩＋① ♪⑩×⑩＋⑩＋④ ♪⑩×⑩＋⑧ ♪⑩×⑩ 
♪③×⑩＋③
=== 10 fibonacci numbers ===
✪☜⑩
✷☜ ⓪ ✲☜①
♺ ✪ ☞
 ✩☜ ✷＋ ✲ 
 ✍ ✩♪⑩
 ✷☜ ✲ ✲☜ ✩
 ✪☜ ✪−①
♘
== External links ==
* Original implementation
Category:Languages
Category:2008
Category:Implemented
Category:Output only
Bonar--

Bonar-- is an Esolang based on boner++ and made in python.
It uses the .bonar file extention and uses python syntax.
Also dont us "is" in a sentence because it will cause errors.
Bonar-- Github
== Overview ==
Command 	Python Keyword or Operator
gamming 	for
sonic 	while
shitpost 	in
hmm 	if
wtf 	else
wtmm 	elif
doitwork 	try
nah 	except
kaolo 	break
clobbong 	continue
gibin 	input
gebneralk 	class
chumbender 	def
jeff 	return
away 	-
yang 	+
perc 	%
deliberately_equals	==
bonar 	=
unfunwaa 	<
funwaa 	>
yote 	<=
yeet 	>=
xon 	and
detecotb 	or
fuck 	is
zenzi 	not
hpock 	import
tysob 	from
blorgia 	as
pungle 	with
anime 	True
no_anime 	False
soulLESS 	None
ban 	del
howdy 	print
zoom 	yield
troll 	lambda
ADL 	raise
oil 	pass
zoomer 	nonlocal
boomer 	global
doge 	finally
sus 	await
amongus 	assert
chungus 	async
blacksheets 	dict
thumbnail 	str
xomc 	int
dicde 	double
boatin 	float
touhou 	chr
osu 	map
reimu 	set
based 	max
cringe 	min
BrUH 	range
mips 	round
vig 	sum
pringle 	super
dino 	tuple
rshig 	zip
racoon 	type
dong 	len
balls 	list
jeb 	open
pipeline 	join
epyc 	file
skeet 	split
goof 	append
cock 	run
chumburger 	[]
eburger 	empty string
sprite 	event
!! 	:
tree 	3
})] 	(
[({ 	)
}]) 	[
([{ 	]
)]} 	{
{[( 	}
== Examples ==
=== Hello World ===
 howdy})]'Howdy, World!'[({
Category:Languages Category:Joke languages
Boobeans

Boobeans is a language made by User:Oklomsy.
It is a normal language, it has a print function, it has a if function. it has everything you need! Just don't use if or any other result that might give you a boolean. it will betray you.
== Syntax ==
Print = Prints anything you give it!
If = Checks if it is true or false!
== Hello World ==
 print Hello World
== Interpreter ==
It's a Python interpreter
 fte = input("What file to execute? > ")
 
 with open(fte) as fte2:
 for x in fte2:
 if "true" in x:
 print("false")
 if "false" in x:
 print("true")
 if "print" in x:
 x = x.split("print ")
 print(x[1])
 if "compare" in x:
 print("It is true but also false")
 if "if" in x:
 print("I wonder if it is true and false???")
 if "+" or "-" in x:
 print("Error: It's true but it might be false too!")
Category:LanguagesCategory:Joke languagesCategory:2020Category:ImplementedCategory:Unknown computational classCategory:Output onlyCategory:Total
Bool

Bool was created by User:xmlns. In bool, the only data type is (guess what!) a Boolean. It allows for both objects and functions. All variables must start with a dollar sign($). A double-slash (//) is used to comment. Instructions are delimited by a semicolon(;). A number acts as a bool[], i.e. the number 5 is [1,0,1]. A char acts as its ASCII binary value as a bool[8], and a string acts as its ASCII value as a bool[8][]. Newlines are not included as part of an input. Bool's only functions/objects are:
 bool
 $in
 $out
 and
 or
 not
 if
 while
To initialize $a, use:
 bool() $a; //or
 bool(1) $a //(sets a to 1), or
 bool(0) $a //(sets a to 0)
To create the a "byte" object, use:
 Object char {
 constructors{
 ( bool[8] $a );
 (); //allow a char to be formed with or without an initial value
 }
 default{
 $a = (bool[8]) 0; //if a is not specified, set a to [0,0,0] using a type cast
 }
 value = $a;
 }
 char[]($in) $char;
 $out = $char;
This program asks for an input and displays the input.
 void hello {
 constructors{
 ( bool[8][] $name ) ;
 }
 $out = "Hello, $name!";
 }
 $namein = $in;
 hello( $namein );
This program asks the user for a name and greets them.
Category:Ideas
Category:2010
BooleanFunge

BooleanFunge is a fungeoid based on boolean values. Has 2D program and stores data in stack with booleans.
The program is not stopped by borders - after crossing the border of the program, the pointer appears on the other side.
==Data types==
===Boolean===
The most basic type. It has only two values ​​- true and false. It can easily be treated as a bit - 0 is false, 1 is true.
===Stack===
The stack is a data structure with two operations - push and pop. A push operation is to push an element to the top of the stack. Pop is to get an item from the top of the stack. In BooleanFunge, the only stack holds booleans.
===Stack part===
A data structure that is a slice of the stack. When pushing a stack part to the stack, the stack part "sticks" to the top of the stack. When n items are popped from a stack, all populated items merge into a stack part. This interesting structure can also be used in other esolangs.
===Char===
Char is a number from 0 to 127 that is a sequence of eight booleans. It can be represented as an ASCII character, which allows interaction with the user.
==Commands==
>	Go right and push true into the stack.
<	Go left and push false into the stack.
v	Go down and push random boolean into the stack.
^	If stack hasn't any value, turn into <. Else, if the stack has only one value turn into >. Else, go up and pop two values from the stack.
#	Pop value from stack. If this value is true, go right. Else, go left.
&	If the stack hasn't eight values, turn into $. Else, pop eight values from the stack, convert this stack part into the char and write it in output.
$	Read char from input, convert resulting char into stack part and push it into the stack.
@	End program, if stack has any true values.
==Examples==
Example programs may not work.
===Write H===
<v<
 >vv <
 v ^vv ^v<
 >>^> >^v^>vv <
 >> ^^vv ^v<
 >>^> >^v^v< >@
 > > ^v^v<&
 >> ^v^
 >> ^^
 >>^
===One Time Cat===
$&>@
===Infinity loop (without stack clogging)===
>v
^v
^<
===Truth machine ("if ascii code of input is even" version; with stack clogging)===
$v v <
v # v v<
vv ^v< v v^v<
 >>^v^v< >> ^v^v<
>> ^v^v< >> ^v^v<
 >> ^v^v< >> ^v^v<
 >> ^v^v< >> ^v^ v<
 >> ^v^v< >> ^ v^v<
 >> ^v^v< >> ^v^>&>>^
 >> ^v^v<>@>> ^^
 >> ^v^& >>^
 >> ^^
 >>^
===Write random char===
v
v
v
v
v
v
v
v
&
>@
==Coming soon==
* Hello World
* maybe 99 bottles of beer
* interpreter in Python
Category:Languages
Category:2023
Category:Nondeterministic
Category:Stack-based
Category:Push-down automata
Category:Two-dimensional languages
Category:Unimplemented
Category:Low-level
Category:Self-modifying
Boolet

Boolet is a stack-based esolang created by User:joshop. 
== Memory/Stack ==
Boolet uses a single stack, which can contain bits or functions (i.e. lambdas). Unlike usual stack based languages it allows the programmer to move the stack pointer using > and <. However, the stack pointer's location is relative to the top of the stack.
== Commands ==
Programs are run command by command. Each command is a single character. Parentheses () must be matched unless they are inside another set of parentheses and that is never executed (an error would occur during runtime).
Command	Result
0 	Push 0 onto the stack
1 	Push 1 onto the stack
( 	Opens a function
) 	Closes a function, pushes the code from the matching ( onto the stack
~ 	Inverts the top stack value
 	Performs a logical or between the top two stack values, popping them and pushing the result
& 	Performs a logical and between the top two stack values, popping them and pushing the result
/ 	Duplicates top stack value
$ 	Swap top two stack values
> 	Move the stack pointer one element down
< 	Move the stack pointer one element up
\ 	Pop the top value off the stack, discarding it
. 	Returns from a function call or halts if no function called (not needed at end of program)
= 	Compares the top two stack values and push 1 if they are equal and 0 if they are not
! 	Execute the function on top of the stack, popping it
? 	Pop the top value off the stack, and if it is 1, execute the function below it (function is popped either way)
Input is supplied as initial stack state, and after execution, the values on the stack are popped from top down, printing the value of the bit if the value is a bit and the contents of a function if the value is a function.
== Example programs ==
Feel free to add program examples if you want
=== Hello, World! ===
 (Hello, World!)
=== Infinite loop ===
 (/!)/!
=== Truth-machine ===
 (>//</>$<$?)/!\\
=== XOR ===
XORs two bits on top of stack.
 =~
== Computational class ==
Boolet is at least Turing-complete because it embeds a Turing-complete subset of Underload:
Underload	Boolet
~ 	$
: 	/
! 	\
(…) 	(…)
^ 	!
(There is no direct analogue of Underload's a, * or S commands, but none of these are necessary for Turing-completeness.)
However, it's possible that Boolet is more powerful than this. The = command is defined as comparing stack values, and the language includes functions as stack values. If this is interpreted as comparing the functions' source codes, then the language is Turing-complete. However, if it compares the functions' behaviour (i.e. ensuring that "the functions do the same thing", the normal definition of equality on functions), the language is uncomputable (comparing functions is one of the things that a Turing-complete language can't do).
== Implementations ==
An implementation here, not very strictly tested.
==See also==
Other languages operating on bits (implemented only):
* FlipJump
* BIT
* BoolX
* Bitch
* Boolfuck
* BitChanger
* Bitter
* BitBitJump
* Smallfuck
Category:Languages
Category:Stack-based
Category:Turing complete
Category:Turing tarpits
Boolfish

Boolfish is a boolean-based version of Deadfish. It has 2 instructions. It can either be written in text-format or binary-format.
== Syntax ==
 text-format
Instruction	Description
f 	Flip the register.
o 	Output the register's value.
 binary-format
Instruction	Description
0 	Flip the register.
1 	Output the register's value.
== Interpreters ==
Boolfish interpreter made in Logisim, flaw is that you can't tell between outputting a 0 and no output.
Boolfish interpreter made in Logisim, requires a TTY component but is vastly superior to the LED one.
Category:Languages Category:Joke languages Category:2022 Category:Unusable for programming Category:Output only Category:Implemented