nyuuzyou/wikis huggingface dataset:
BrainJuice

BrainJuice is an esoteric programming language by User:A_Monitor. It's based on Brainfuck, but has more instructions and slightly different behavior. It's official interpreter can be found here.
BrainJuice is easy to interpret however some instructions make it hard or inefficient to compile.
BrainJuice has all of the instructions of Brainfuck, plus more.
==Overview==
 The extra instructions
Symbol 	Name 	Description
0 	Nullify 	Sets the current cell to 0
; 	Set 	Sets the current cell to the ASCII value of the next character. Also skips the next character.
* 	Multiply 	Sets the current cell to its value times the next cell's value
/ 	Divide 	Sets the current cell to its value divided by the next cell's value using integer division
^ 	Power 	Sets the current cell to its value raised to the power of the next cell's value
% 	Modulo 	Sets the current cell to its value modulus the next cell's value
~ 	Logarithm 	Sets the current cell to its natural logarithm (as an integer)
$ 	Restart 	Makes the pointer go to 0
@ 	Warp 	Makes the pointer go to the value of the current cell. So if the value was 3 it would go to the 4th cell (pointer starts at 0)
: 	Number 	Sets the current cell to the number after this, ended with another :.
( and )	If 	Will only execute whats inside ONCE if the value of the current cell is greater than 0
& 	Index 	Will set the current cell to the position of the pointer
{ 	Swap Left 	Will swap the current cell with the one behind it
} 	Swap Right 	Will swap the current cell with the one after it
# 	Execute 	Will execute as a BrainJuice instruction the character who's ASCII value is the same as the current cell's value. It will run with a pointer of 0, but the same memory.
` 	Block 	Will toggle if the character who's ASCII value is the same as the current cell's value can be executed by the program or by #.
" 	String 	This is used for printing constant text to the screen. It will print the characters between the string. \ does not do anything here though.
_ 	Pointer 	This will set the current cell to the value of the cell who's index is the same as the current one's value.
 	Pipe 	This will set the current cell to the value of the cell who's index is the same as the value of the cell who's index is the same as the current cell's value.
\ 	Interpreter	This will run the characters stored in the next cells until a 0 or less as a BrainJuice program. This will be ran with its own pointer, but not its own memory.
===Some internal differences===
BrainJuice numbers are signed integers. This means they can be negative.
BrainJuice also plays on a tape who is infinite in BOTH directions.
==Examples==
===Hello, world!===
"Hello, world!"
===Cat Program===
,[.,]
===BrainJuice Interpreter===
>,[>,]$\
===Copy the last block===
&-_
===Truth Machine===
>;0<,>[-<->]<[;1.];0.
===Infinitely Recursive Segment===
$;##
* The $ is only if it's not already in the 0th cell
Category:Languages Category:Brainfuck derivatives Category:Cell-based Category:Turing complete Category:Implemented
BrainSoothe

BrainSoothe (abbreviated BS in a G-rated context) is an esolang devised by User:arseniiv in 2020 entirely not for mocking the abbreviation BF.
== Syntax ==
The program is a nonempty finite sequence of (unbounded) nonnegative integer literals delimited by spaces or other non-numeric characters which are ignored. There should be no literals at different positions which denote the same number.
== Semantics ==
At runtime, there is an unbounded integer register initialized to the program input, or to zero if there’s no input. There is a literal pointer which can point to any literal in the code; initially it points to the leftmost one. We denote the value of the literal currently in focus by n and the current value of the register by x.
Each execution step, we assign x := x + 1 and test if x\equiv 0 \pmod n. If that’s the case, we make x := x - n, then jump n literals to the right, and in case of overshoot, halt. If that’s not the case, we just shift focus to the literal to the right of the current, and if that’s not possible, jump to the first literal.
The output is the final value of the register when the execution halts.
=== Pseudocode ===
 
That literary description above might be misleading against all my wishes, so here is a more formal one in Python 3 (you may ignore the import and erase type annotations if you wish).
 from typing import Sequence
 
 def run(instructions: Sequence[int], value: int) -> int:
 instr_count = len(instructions)
 assert instr_count != 0
 assert all(instr >= 0 for instr in instructions)
 assert instr_count == len(set(instructions))
 instr_index = 0
 while True:
 value += 1
 instr = instructions[instr_index]
 test = value % instr if instr != 0 else value
 if test == 0:
 value -= instr
 instr_index += instr
 if instr_index >= instr_count:
 return value
 else:
 instr_index += 1
 if instr_index == instr_count:
 instr_index = 0
== Examples ==
A single-instruction program n implements floor division x\mapsto \lfloor x/n \rfloor, including the case of n = 0 for which it doesn’t halt.
== Commentary ==
If this ends up being a language simple to write in, or a non-TC one, well, that was worth a try, as I admit this joke language was fleshed out in less than half an hour.
Update: Yes that’s not TC as the register effectively has \operatorname{LCM}(\mathrm{instructions}) values. Meh.
Category:Languages
Category:Implemented
Category:2020
Category:Usability unknown
Category:Unknown computational class
BrainSoup

BrainSoup is a language that translates any trivial bf substitution
into bf. User:PixelatedStarfish is the author of this metalanguage.
The first 8 lines of any BrainSoup program are reserved for bf command substitutions. Line 9 is a newline. Source code in the bf equivalent can be written from Line 10. The file extension for source is .bsou
==Command Lines Table==
Command	Description 	Line
> 	Move the pointer to the right 	Line 1
< 	Move the pointer to the left 	Line 2
+ 	Increment the memory cell at the pointer 	Line 3
- 	Decrement the memory cell at the pointer 	Line 4
. 	Output the character signified by the cell at the pointer 	Line 5
, 	Input a character and store it in the cell at the pointer 	Line 6
[ 	Jump past the matching ] if the cell at the pointer is 0 	Line 7
] 	Jump back to the matching [ if the cell at the pointer is nonzero	Line 8
==BrainSoup Examples==
A Hello World in this Alphabet Based Substitution
 a
 c
 e
 i
 j 
 o
 p
 s
 
 eeeeeeeepaeeeepaeeaeeeaeeeaeccccisaeaeaiaaepcscis
 aajaiiijeeeeeeejjeeejaajcijcjeeejiiiiiijiiiiiiiijaaejaeej
==Interpreter Specifications==
The interpreter does the following:
*Translates BrainSoup into bf.
*Translates bf into a trivial substitution.
*Runs bf code.
==External Links==
*Java Interpreter
*Repl
**This REPL is currently not working (likely due to a change in Replit's system), but forking it will automatically upgrade the new fork and allow using it.
Category:Languages Category:Brainfuck equivalents Category:Meta-languages Category:2021 Category:Implemented
BrainSpace 1.0

BrainSpace 1.0 is an esoteric programming language based on Befunge, PingPong and Brainfuck by User:SpaceMan++.
BrainSpace 1.0 is like Befunge and Brainfuck. There is a 2D field and a memory tape. ^V<> changes direction(like in Befunge#Instructions) and /\ acts like mirrors(like in PingPong#Flow_control). There are interpreters in Java and JavaScript.
The following program is an infinite loop.
 >V
 ^<
and here's a cat program
 +>*Vx
 o
 i
 ^ <
=Operators=
Operator	Description
^ 	Move up(like in Befunge)
V or v 	Move down
> 	Move right
< 	Move left
% 	Reverse direction.
* 	If current cell is not 0, go to next, otherwise, skip next
X or x 	End program
/ 	Bounce up/left
\ 	Bounce down/right
? 	If current cell is 0, continue, otherwise, reflect back
o O or 0	Output one character.
i I or 1	Input one character.
l L or {	Decrease mem. pointer
e E or }	Increase mem. pointer
p P or +	plus 1 for the current memory cell(like in BF).
m M or -	minus1 for the current memory cell(like in BF).
=Examples=
==Cat program==
 +>*Vx It moves right > down > left > up > right until the user typed nothing.
 o This program demonstrates loops in BF
 i
 ^ <
===Infinite Loop version===
 >ioV
 ^ <
==Hello World program==
This is also a standard test. A standard BS1 interpreter should output "Hello world!"
 v ** Hello World Test -- If your BS1 interpreter is standard, it will output exactly "Hello World!" Because it uses every operators(except input).
 >++++++++++++++++++++++++++++++++++++++++++ V H
 V }o ++++++++++++++++++++++++++++++ <
 >+++++++++++++++++++++++++++++++++++++++++++++++++P++++++ V E
 V } < o ppppp ++++++++++++++++++++++++++++++++++++++++ <
 >+++++++++++++++++++++++++++++++++++++++++++++++++++++P++++++++++++++++++++++++++++++++++++++++++++++++++++++o}v L
 V++++++++++++++++++++++++++++++++++++m+++++++++++++++++++++ <
 >++++++++++++++++++++++++++++++++++++++++++++++++++++o}\ L
 V++++++++++++++++++++++++++++++++++++++++++++++++++++++<
 >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++o}V O
 V <
 >*%++++++++++++++++++++++++++++++++O}V
 V++++++++++++++++++++++++++++++++++ <
 >+++++++++++++++++++++++++++++++++++++++ppppppPpPp+++++*+++++++++++++++++++++++++++++++o}V W
 V++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ <
 >+++++++++++++++++++++++++++++++++++++++++++++++++0}V O
 V - P P M <
 >?++++++++++++++++++++++++++++++++++++++++++++++++++++++++ V R
 V} o ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<
 >++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++o}\ L
 V /
 >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*+-+++++++++++++++++++++oV D
 V LR }lr <
 >+++++++++++++++++++++++++++++++++oV !
 V ? R <
 x
=See Also=
*Befunge
*PingPong
*Interpreter
=Links=
*Official project site
*Download interpreter
*BS1 Tutorial
Category:Languages
Category:Turing complete 
Category:Two-dimensional languages 
Category:Implemented 
Category:Low-level 
Category:2008
BrainTangle

BrainTangle is an Esolang invented by PSTF and his 文心一言(because he don't use ChatGPT now).
== Syntax Overview ==
=== Data Types ===
BrainTangle only has one data type: a single-character string (a "tangle"). Operations on tangles are performed by manipulating them in various ways.
=== Programs ===
Programs in BrainTangle consist of a series of commands, each occupying a single line. Each command is either a basic operation or a control flow statement.
=== Basic Operations ===
==== Tangle Manipulation ====
# ++ Append the current tangle to itself.
# -- Remove the last character from the current tangle.
# >> Rotate the current tangle to the right (move the first character to the end).
# << Rotate the current tangle to the left (move the last character to the beginning).
# !! Reverse the order of characters in the current tangle.
==== Tangle Comparison and Branching ====
# == Check if the current tangle is equal to a specified tangle. If true, execute the next line; otherwise, skip the next line.
# != Similar to ==, but executes the next line if the tangles are not equal.
==== Input/Output ====
# ? Read a single character from input and set it as the current tangle.
# ! Output the current tangle to the console.
==== Control Flow ====
===== Loops =====
# loop ... endloop Create a loop that repeats the enclosed block until a specific condition is met (this condition must be manually checked within the loop using comparison operations).
===== Conditional Statements =====
BrainTangle doesn't have explicit conditional statements like if/else. However, you can simulate conditional behavior using the == and != operations to skip lines based on the current tangle's value.
== Example Program ==
Here's a simple BrainTangle program that reads a character from input, checks if it's an 'a', and outputs a message accordingly:
 ? ; Read input into current tangle 
 ==a ; Compare current tangle to 'a' 
 !a found! ; If equal, output 'a found!' 
 !not a ; This line is skipped if the tangles are equal 
 endloop ; (Note: This example doesn't actually need a loop, but loops are part of the language)
Note: The syntax and behavior of BrainTangles are highly simplified for this example. In a real implementation, additional details such as how to properly structure loops and handle edge cases would need to be defined.
== Turing Completeness ==
BrainTangle is Turing-complete because it has the ability to manipulate and compare data (tangles), read input, and write output. With these capabilities, it can simulate the behavior of a Turing machine, including its infinite tape and ability to move the tape head and modify the tape's contents. The use of loops and conditional logic allows for more complex computations and decision-making processes.
== Categories ==
Category:Generated by AI Category:Languages Category:2024
BrainTravel

BrainTravel is basically Brainfuck but with alternate dimensions and time travel. Created by User:AnotherUser05.
The commands used in this program:
 
Command	Description
+ 	Add one to the current cell's value.
- 	Remove one to the current cell's value.
> 	Move the cursor right.
< 	Move the cursor left.
[ 	Jump past the matching ] if the current cell value is 0.
] 	Go back to the matching [ if the current cell value is not 0.
. 	Ouput the current cell's value as an ASCII character.
, 	Input a character and store it into the current cell.
# 	Store the current cell value into a storage.
{ 	Jump past the matching } if the current cell value is not equal to the stored value.
} 	Paired with {.
= 	Set the current cell's value to the stored value.
^ 	Go up a dimension.
v 	Go down a dimension.
| 	Swap the previous dimension with the current one.
/ 	Go forward in time by one step.
\ 	Go backward in time by one step.
x 	Stop the code.
==Time Travel==
Basically time travel in this program works like how you would expect it to work. By going back in time, there's another cursor that's the current cursor but in the past. You can also affect this timeline by affecting any of the cell's value. This will affect the outcome of the code. To be safe from that mess, you can go to another dimension. Oh yeah, there's a limit to how far you go back and forward in time. This is probably the most useless mechanic.
==Dimensions==
Every dimension is a line of cells. There are an infinite amount dimensions, so go as far as you want. Just don't get lost.
==Examples==
===Not finite loop===
 +[+]
Category:Brainfuck derivatives Category:Languages Category:Cell-based
BrainXXXXXXXXXXx

brainXXXXXXXXXXx is a family of Esolangs inspired by BrainfXX, to be exact, this is 18,446,744,073,709,551,616 different Esolangs. I'm User:5anz, and these are my 4th, 5th, 6th, ... and 18,446,744,073,709,551,619th Esolangs I've made. Fine, we'll just say 4th.
== What does the name mean? ==
=== Convert to bits ===
To find the meaning of a brainXXXXXXXXXXx Esolang name, you must first convert all the letters from the Xs according to this table (left goes first, then top):
 	000	001	010	011	100	101	110	111
000	A 	B 	C 	D 	E 	F 	G 	H
001	I 	J 	K 	L 	M 	N 	O 	P
010	Q 	R 	S 	T 	U 	V 	W 	X
011	Y 	Z 	0 	1 	2 	3 	4 	
100	a 	b 	c 	d 	e 	f 	g 	h
101	i 	j 	k 	l 	m 	n 	o 	p
110	q 	r 	s 	t 	u 	v 	w 	x
111	y 	z 	5 	6 	7 	8 	9 	#
And converting the letter from the x according to this table:
 	00	01	10	11
00	0 	1 	2 	3
01	4 	5 	6 	7
10	8 	9 	A 	B
11	C 	D 	E 	F
So for example, brainHello worlD would have the binary sting 0001111001001010111010111011100111111101101011101100011010111101 because of the following:
 H | 000111
 e | 100100
 l | 101011
 l | 101011
 o | 101110
 | 011111
 w | 110110
 o | 101110
 r | 110001
 l | 101011
 D | 1101
=== What do the bits mean? ===
Once you have your string, go through them 1 by 1, checking if you're allowed to use that command, using this table:
Bit #	BF command chain
0 	++
1 	+-
2 	+>
3 	+<
4 	+[
5 	+]
6 	+.
7 	+,
8 	-+
9 	--
10 	->
11 	-<
12 	-[
13 	-]
14 	-.
15 	-,
16 	>+
17 	>-
18 	>>
19 	><
20 	>[
21 	>]
22 	>.
23 	>,
24 	<+
25 	<-
26 	<>
27 	<<
28 	<[
29 	<]
30 	<.
31 	<,
32 	[+
33 	[-
34 	[>
35 	[<
36 	[[
37 	[]
38 	[.
39 	[,
40 	]+
41 	]-
42 	]>
43 	]<
44 	][
45 	]]
46 	].
47 	],
48 	.+
49 	.-
50 	.>
51 	.<
52 	.[
53 	.]
54 	..
55 	.,
56 	,+
57 	,-
58 	,>
59 	,<
60 	,[
61 	,]
62 	,.
63 	,,
Note: 001011... means you don't have access to ++, +-, +<, etc. but DO have access to +>, +[, +], etc.
Now that you have that, you should know know that if you don't have access to <-, any instances of it will be replaced by just <, and yes, it stacks, so <buffer-more buffer- will remove non-brainfuck commands like b, o, ⠀, etc. and then remove the minuses after the left.
You'd think I would have said brainfuck by now, but that last sentence was the first time I said it on this article.
== Might add more ==
Just adding this so the contents part... EXSITS.
Category:LanguagesCategory:Meta-languagesCategory:Brainfuck derivativesCategory:2024Category:Unimplemented
BrainZ

BrainZ (say "Brain zee") is a brainfuck equivalent created by User:None1. It is brainfuck compressed with Huffman compression.
==Steps to write a program==
1. Write a program in brainfuck, we take the cat program
 +[,.]
as an example.
2. Convert the program to binary using the following table.
BrainZ 	Brainfuck
1 	+
01 	-
001 	>
0001 	<
00001 	[
000001 	]
0000001 	.
00000001	,
In the example, we get:
 100001000000010000001000001
3. Group the bits 8 by 8 and convert them into bytes, if the number of bits is not a multiple of 8, Then just add zeros in the end until it is (these zeros will not affect the program's behavior, since all the commands in BrainZ ends with 1), then you get a valid BrainZ program.
In the example, we get (in hex dump):
 84 04 08 20
Here is an encoder in Python, it generates raw bytes of BrainZ programs from brainfuck programs, making the conversion easier.
def encode(bf):
 d='+-><[].,'
 r=''
 res=[]
 for i in bf:
 r+='0'*d.index(i)+'1'
 r+='0'*((-len(r))%8)
 for i in range(len(r)//8):
 res.append(int(r[i*8:i*8+8],2))
 return bytes(res)
==Compression Rate==
In the best case (when all the commands are +), its compression rate is 12.5%.
In the worst case (when all the commands are ,), its compression rate is 100%.
However, in most brainfuck programs, + exists more frequently than -, which exists more frequently than >, which exists more frequently than <, which exists more frequently than [ and ], which exists more frequently than ., which exists more frequently than ,. That makes its performace better, and much better than the compression method used in Binaryfuck.
==Example Programs==
The following programs are in hex dump.
===Cat Program===
 84 04 08 20
===Hello World===
 FF 09 F0 9C F3 CC 44 45 04 CC A4 C2 20 8A 09 20 4A A0 7F 81 03 C0 92 04 50 22 07 81 55 50 2A AA A0 49 81 38 10
The program is 37 bytes long, compressed from this brainfuck program:
 ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
as a comparison, the same program compressed with Binaryfuck, is 40 bytes long.
===Nope. interpreter===
 FC 27 FF E2 82 40 9F FE 13 FF 8A 09 81 81 55 55 54 09 F8 4F FC 50 4C 08
===brainfuck interpreter===
24 C2 14 12 42 83 99 FE 11 F2 71 41 C9 99 F8 4E 7F 11 41 92 40 47 08 48 52 41 10 92 08 8A 08 84 41 19 21 20 90 8C A1 08 CA 09 04 42 10 A0 88 38 A1 1F F9 08 A5 04 90 49 04 11 10 44 11 08 44 12 10 90 49 09 20 C2 22 08 84 41 19 28 24 24 18 52 41 11 11 08 44 41 10 88 31 10 CC 45 09 53 11 42 62 12 62 28 20 82 42 32 82 20 E4 A9 09 04 90 92 08 22 21 26 21 08 82 20 90 84 44 11 08 83 0A 32 50 88 CE 50 8A 42 23 25 04 10 44 26 28 24 12 12 09 04 84 90 49 04 44 24 C9 92 08 88 52 49 24 90 44 42 40 92 49 24 11 10 94 92 48 22 21 20 24 90 44 42 64 11 10 C4 41 10 40
Made from this brainfuck self interpreter.
==Turing completeness==
It is of course Turing complete since brainfuck is.
Category:Binary
Category:Languages
Category:Brainfuck equivalents
Category:Turing complete
Category:Compressed_Brainfuck
Brain Ah Fuck

Brain Ah Fuck or the full name brainahfuckohfuckwhydiditmultiplythevaluebytwopleasehelpmeihatethis is an esoteric programming language based on Brainfuck, but operating only on bits. It was made by User:Xarthan on June 2 2022 for only being pain.
==Computational class==
Brain Ah Fuck can be shown to be Turing-complete by reduction from brainfuck if I made it right.
==Instructions==
Brain Ah Fuck has the following commands:
Cmd	Description
s 	Swap: sets 1 to 0 and 0 to 1 at the memory pointer
0 	0congoto: goto if 0
1 	1congoto: goto if 1
> 	Move right: Move data pointer right
< 	Move left: Move data pointer left
. 	Output: Output bit at data pointer
, 	Input: Input to data pointer moving right every bit
Note: Trying to print any cell that is below id zero will halt.
Other note: Input starts at the least significant bit
==Examples==
===Cat===
A cat program writes its input directly to its output.
 ,<.0(2)1(2)
===Hello, world!===
A Hello, world! program is a trivial program which outputs a static string of text, usually
 //set mem
 >s>>>s>>>>>s>s>>>s>>s>>s>s>>s>s>>>>s>s>>s>s>>>>s>s>>s>s>s>s>>>s>>s>s>>>>>s>>>>>>>s>s>s>>s>s>s>>s>s>>s>s>s>s>>s>s>s>>>s>>>s>s>>s>s>>>>s>s>>>s>>>>>s>>>>>
 //go to 0
 s1(0)
 //print 104 bits (ascii values)
 .>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.
==See also==
Other languages operating on bits (implemented only):
* FlipJump
* BitChanger
* BIT
* BoolX
* Smallfuck
* Bitch
* Boolfuck
* Bitter
* Boolet
* BitBitJump
Category:Languages Category:2022 Category:Cell-based Category:Turing tarpits Category:Brainfuck derivatives
Brainalpha

==Commands==
Brainfuck	Substitution Argument 	Description
> 	A 	Move the pointer to the right
< 	B 	Move the pointer to the left
C 	Increment the memory cell under the pointer	
D 	Decrement the memory cell under the pointer	
. 	E 	Output the character at the cell at the pointer
, 	F 	Input a character and store it in the cell at the pointer
[ 	G 	Jump past the matching H if the cell under the pointer is A
] 	H 	Jump back to the matching G
==Memory==
Unlike standard brainfuck, Brainalpha cells can only be uppercase letters:
 ABCDEFGHIJKLMNOPQRSTUVWXYZ
Incrementing Z results in A and decrementing A results in Z.
All letters in memory start out as A's.
When an F command encounters a character (or EOF) that is not an uppercase letter, the current cell is unchanged.
==Examples==
===HI===
 CCCCCCCECE
===HELLOWORLD===
 CCCCCCCEDDDECCCCCCCEECCCECCCCCCCCEDDDDDDDDECCCEDDDDDDEDDDDDDDDE
Prints HELLOWORLD because of the restrictions of the language.
===Uppercase letter-restricted Cat Program (never terminates)===
 CGAFEBH
===Caesar encryption (never terminates)===
Accepts only uppercase letters, adds the order of every input letter by 1, for example, input is INPUT and output is JOQVU.
 CGAFCEBH
This program is much easier than in brainfuck (because you don't need to subtract by 65, modulo by 26 and add by 65 and stuff)! And what's more, you don't need to know the ASCII table! And what's more, this is why Brainalpha is created!
==External Resources==
* Online interpreter at Interpret Esolangs Online based on This JavaScript interpreter.
Category:Languages
Category:2024
Category:Brainfuck equivalents
Category:Implemented