nyuuzyou/wikis huggingface dataset:
Brainrot (Yayimhere)

brainrot is an esolang based on the evolution of television and the crisis of "OMG gen Z is doomed" when thye had the same with every other fricking gen, so basically its just saying "gen z not doomed lol".
a, b and c are strings, with all of them being valid in the BRATACER(BRAinrot Television And Content Evolution Representation) which is an syntax for string manipulation(explained later)
== BRATACER(/bɹɑːtɛsɜːɹ/) ==
BRATACER is a syntax for repeating a change to an string:
* delete every evenly indexed char
* delete every oddly indexed char
* if string already empty add an :
* copy the string and append to itself
* run the string as BRATACER then run :
* copy nth char of strinand put in front of nth char
* add n'th char to end of string
* increment ascii of n'th char
* separate commands
== program and semantics ==
the program is 4 lines. looks like this:
 a = ()
 b = ()
 c = ()
 +()
where () is a placeholder. the first 3 lines are obvious. they set they respective string to ()
the last sets the halting string, if any of the string is equal to it it halts
how the program works is a is runs as BRATACER with the stirng being b and afterwards b is ran on c then c is ran on b and a then thus processis redone until the program halts
Category:Languages Category:2024 Category:String-rewriting paradigm Category:Unimplemented Category:Unknown computational class
Brains

The brains language is a concurrent dialect of brainfuck whose specification was first written by Thomas DiModica in 2011. It takes elements from brainfork, Toadskin, L00P, and Weave, in addition to adding its own constructs to better support concurrency.
==Specification==
 + increment current cell
 - decrement current cell
 > move one cell to the right
 < move one cell to the left
 . print the value of the current cell as a character
 , input a character and place its value into the current cell
 [ if the current cell is zero, jump past the matching ]
 ] if the current cell is not zero, jump back to the matching [
 ( if the current cell is zero, jump past the matching ) or |, if present, as in L00P
 | jump past the matching ), as in L00P
 ) no operation: this is a placeholder for ( and |, as in L00P
 : bind the next character to the function occurring after the next character to before the matching ;, as in Toadskin
 ; ends a function definition, a placeholder for :, can be thought of as a return statement, as in Toadskin
 @ separates concurrent programs in a source file, like Weave's ;
 ~ swap data tapes, as in Weave
 % fork the process, like brainfork's Y
 & spawn a new thread, semantically like %
 { if the current cell is not zero, jump past the matching }
 } if the current cell is zero, jump back to the matching {
 = no operation
 $ return from a function, or end the program if not in a function
 ' break out of the current loop: jump past the first unmatched ] or }
 ` continue: jump to the first unmatched ] or }
 * yield the processor
 ^ V, or up, the current cell, unblocking a thread, if any, blocked on the cell
 _ P, or down, the current cell, blocking if its value is zero
Fork/spawn work in a nearly identical way. First, the current cell is set to zero and the next cell to the right is set to one. Then, the fork/spawn takes place. In a fork, the new process gets a copy of the parent thread's current data tape as its new private data tape, and it swaps between this private data tape and its parent's private data tape. If the forking process has multiple threads, the new process has only one thread, a copy of the forking thread. For both fork/spawn, the new thread has its data pointer set to the cell that was set to one, one right to the parent's data pointer. If the fork/spawn should fail, the cell to the right is set to zero, replacing the one. If the new data space cannot be created, the fork fails.
The commands ^ and _ treat the current cell as a semaphore. They guarantee atomicity and proper semaphore behavior. While ^ could have been removed in favor of + being atomic, having ^ removes the need for + to check if it is unblocking any threads.
==External resources==
* , which includes an interpreter.
Category:Languages
Category:Implemented
Category:Brainfuck derivatives
Category:Cell-based
Category:Low-level
Category:Turing complete
Category:Concurrent programming
Category:2011
Brainscrambler

Brainscrambler is an esoteric programming language designed by Cody Brocious in 2004, and implemented by Nerowolfe in 2008. It is a brainfuck variant with 3 stacks instead of the tape.
Brainscrabler memory consists of three stacks: A, B, and C. The "current stack" starts out at A, then is rotated to B, then to C, then back to A again, etc. Stacks hold integers that are at least -1; lower numbers may or may not be implemented. The number on top of the current stack is called the current number. The commands:
 + Increment the current number.
 - Decrement the current number.
 < Move the current number to the stack to the "left".
 > Move the current number to the stack to the "right".
 * Push a zero onto the current stack.
 ^ Pop the current number and discard it.
 # Rotate between stacks.
 , Input a number and push it to the current stack.
 . Output the current number.
 [ While the current number is nonzero...
 ] End while.
Category:Languages
Category:Stack-based
Category:Brainfuck derivatives
Category:Implemented
Category:Turing complete
Category:2004
Brainshit

Brainshit is a esolang created by User:Yayimhere, its just BF but different
== changes ==
first of all commands are changed like this:
 + -> {
 - -> }
 [ -> [
 ] -> ]
 > -> (
 < -> )
 . -> ⁅
 , -> ⁆
also all brackets must be matched. also this is not allowed:
 [(])
so in BNF:
 S := S | e | ( S ) | [ S ] | { S } | ⁅ S ⁆
where e is empty string
Category:Languages Category:2024 Category:Brainfuck derivatives Category:Cell-based Category:Low-level Category:Unknown computational class Category:Unimplemented
Brainspin

Brainspin is a variant of brainfuck where there are only three spaces of memory and they are constantly being cycled through, designed by User:Nmcassa in 2022.
==Cycle==
After every character of the code, the memory cycles one place to the right (unless it's at the end where it goes to the start) creating a circle of data. There are only three spots to work with so memory management can be difficult. Because of this change, the < and > commands of brainfuck have been removed and the command * has been added to wait and do nothing as to allow the cycle to move once more. All other characters are ignored and don't move the cycle.
==Examples==
===Hello w/ Input===
 , type 72 for Cell #1 to be the ascii for H
 , type 69 for Cell #2 to be the ascii for E
 , type 76 for Cell #3 to be the ascii for L
 ...**.**+**+**+**.
===Hello===
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 +++++++*++*++*++*.+.*+**+**+**.**.**+**+**+**.
==Computational class==
It is Turing-complete by reduction from 3-cell brainfuck:
BF	Brainspin
+ 	+**
- 	-**
> 	*
[ 	[**
] 	]**
==Implementation== 
here by User:Nmcassa
Category:Languages Category:2022 Category:Implemented Category:Low-level Category:Turing complete Category:Turing tarpits Category:Brainfuck derivatives
Brainsplosion

brainsplosion is a joke language created by User:Lilliepadlol. It is a stripped down version of Brainfuck. The source code can be found at https://github.com/lillupad/brainsplosion 
== Example programs ==
=== ABACA ===
ABACA is the brainsplosion equivalent of "Hello, world!", because ABACA is waaaayy easier
++++++<+++++,+,-,++,--,
 output: "ABACA"
and that's pretty much all you can make with this language
== Commands ==
 Caption text
Command	Function
+ 	increment the constant
- 	decrement the constant
< 	multiply the constant by 10
> 	divide the constant by 10
. 	output the constant as a number
, 	output the constant as a character based on it's ASCII value
==Implementations==
User:Nomad says: 
I was here, and I made a one-line implementation in node.js:
// Save in a file and call it with 'node <filename> <brainsplosion_code>'
// Example: node interpreter.js "++++++<+++++,+,+," -> Outputs "ABC"
[0,...process.argv[2]||].reduce((v,c) => c == '+' ? v+1 : c == '-' ? v-1 : c == '<' ? v*10 : c == '>' ? v/10 : process.stdout.write(c == '.' ? +v : c == ',' ? String.fromCharCode(v) : ) && v);
==External resources==
*Brainplosion interpreter in batch file
Category:Languages Category:Implemented Category:Joke languages Category:Total Category:Unusable for programming Category:Output only
Brainstack(islptng)

Brainstack is not a brainfuck derivative, but a completely new language.
Instead of cells, we operate on stacks. The pointer itself has also got a box.
Elements can be any integer, unbounded. The stack tape is unbounded, too.
==Commands==
Command 	Meaning
> 	Pointer move right
< 	Pointer move left
(123) 	Set the box to that number
_ 	Push the box to the stack
^ 	Pop the stack to the box
+ 	Increment TOS by the box
- 	Negate the box
[ ... ] 	Unconditional infinite loop
? ... * ... !	If-Else block. Condition: box is zero. Else (*) is mandatory.
, . 	Get user in/output in character, stored in the box.
; : 	Get user in/output in number, stored in the box.
# 	Break
@ 	Continue
==Examples==
===FizzBuzz===
 _>(1)_>(4)_>(2)_
 [^?(2)_(70).(105).(122)..<<<^(1)_>>*_(1)-+<!
 ^?(4)_(66).(117).(122)..<<^(1)_*_(1)-+<<!
 ^?_>^:_*(0)_>(10).!(1)+>>]
==See also==
* 诗
Category:Languages Category:Stack-based Category:Implemented Category:2024 Category:Cell-based
Brainstar

Brainstar is a Turing-complete programming language which is a cross between Branflakes and Rockstar. It preserves Rockstar's poetic literals, while keeping Branflakes's numeric tape.
==Instructions==
Brainstar operates on an infinite tape of signed bignums, each starting at 0. There is also an unbounded stack of unsigned bignums.
Numbers are written by listing words where each word's length is a decimal digit of the number, modulo 10. However, if the first word is "not", it is to be interpreted as a negative sign. For example, "a good language" is 148.
A cell reference is "a", "an", "the", "my" or "your" followed by a word, and the word's length is the index of the cell, minus 1. For example, "an instance" is cell 7.
The special word "it" can be used instead of a cell, and it references the last used variable, or cell 0 if used before any variable is referenced.
 Caption text
Instruction 	What it does
[cell] is [number] 	Sets [cell] to [number]
Let [cell] be [reference] 	Sets [cell] to value in [reference]
Let [cell1] be [operator] [cell2]	Sets [cell1] to [cell1] [operator] [cell2].
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
And here are the operators. "a" is the first argument, and "b" is the second (if applicable).
Category:Works-in-Progress Category:Languages Category:Cell-based Category:Turing complete Category:Pseudonatural
Brainstoremax

Brainfuck has 8 commands.
 > < + - [ ] . ,
 0 1 2 3 4 5 6 7
Convert to base 8. A single byte can store 2 2/3 commands.
Convert to base 16. A single pixel can store 8 commands.
Convert to hexcode. Add to image. You now have brainfuck script in small amount of pixels.
== Ascii loop ==
That's it. 1 pixel.
== Hello world ==
Again, that's it.
== See also ==
* PocketFuck
Category:Languages
Category:Brainfuck equivalents
Category:Non-textual
Category:Turing complete
Brainstuck

Brainstuck is a variation of Brainfuck, with a stack instead of a tape.
== Commands ==
The commands are:
Token 	Command
Increments the top value of the stack.	
Decrements the top value of the stack.	
. 	Pops the top value of the stack, and outputs it.
, 	Pushes a byte from stdin on the stack.
0 	Pushes 0 onto the stack.
: 	Pops the top value of the stack, and pushes the value at a depth of that depth into the stack onto the stack.
[ 	Pops the top value of the stack, and if that value is 0, jumps to the opcode after the corresponding ].
] 	Jumps to the corresponding [.
== Examples ==
=== Infinite cat program ===
 0+[,0:.+]
== Forth codes ==
It is possible to convert into Forth codes by:
 + 1+ 255 AND
 - 1- 255 AND
 0 0
 : PICK
 , KEY
 . EMIT
 [ BEGIN WHILE
 ] REPEAT
Some other commands in Forth can be also using the Brainstuck codes:
 DUP 0:
 OVER 0+:
 THEN 0]
 0 * 0:[-0:]
 DROP [0:[-0:]]
== External resources ==
* http://d.hatena.ne.jp/shinichiro_h/20070714#1184371977
Category:Languages Category:Brainfuck derivatives Category:Stack-based Category:Implemented Category:Unknown computational class
Brainsymbol

Brainsymbol is an esoteric programming language made by User:WhoeverKnew123.
Since it's a brainfuck equivalent, it's turing complete!!!!
==Difference==
The difference between Brainsymbol and brainfuck is shown on the following table:
 
 ! Command !! Brainfuck
Command	Brainfuck
! 	>
@ 	<
# 	+
$ 	-
% 	.
^ 	,
& 	[
* 	]
==Examples==
===Hello World===
 ########&!####&!##!###!###!#@@@@$*!#!#!$!!#&@*@$*!!%!$$$%#######%%###%!!%@$%@%###%$$$$$$%$$$$$$$$%!!#%!##%
===ASCII Character Set===
 #%&#%*
===Cat===
 ^%&^%*
===Move value===
 @@&$*!!&$@@#!!*
==External Resources==
*Interpreter in python
*Brainsymbol to brainfuck compiler
Category:2022 Category:Turing complete Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Low-level Category:Turing tarpits
Brainthon

Brainthon is an esoteric programming language designed to output text, in the worst way possible.
=== Syntax ===
 Guide
🧠 	Increment current ASCII value by 1
🐍 	Append current ASCII character to current string
🐍🐍 	Print current string and reset it
=== Hello world ===
Using the table above, we can use the syntax to make it say "Hello world".
But first, we need to get our ASCII values.
For "Hello world":
72 101 108 108 111 32 119 111 114 108 100
So, for this program, we need 72 brains, then a snake, yada yada then a double-snake
That program would look like:
 🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🐍
 🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🐍
 🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🐍
 🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🐍  
 🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🐍
 🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🐍  
 🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🐍
 🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🐍
 🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🐍
 🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🐍
 🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠🐍
 🐍🐍
When you run this, it will output "Hello world".
== Interpreters ==
===== Python =====
 file = open("script.🧠🐍")
 string = ""
 for i in file.read().split("\n"):
 data = 0
 if i == "🐍🐍":
 print(string)
 string = ""
 else:
 for j in i:
 if j == "🧠":
 data += 1
 elif j == "🐍":
 string += chr(data)
Category:Languages Category:Joke languages Category:Implemented Category:Output only Category:Total Category:Unusable for programming
Braintrust

Braintrust is an esolang by User:Sgeo similar to Brainfuck. It is intended to be compiled, and the compiler, written in Braintrust, itself has no knowledge of the target platform directly. Rather, all such information is part of the primitive command !. The information itself is stored in the resulting target code.
Braintrust has all the usual Brainfuck commands, and 3 extra.
, on EOF results in -1.
\ sets the value of current memory cell to the value of the following character, as though it were read in via ,
: appends the value at the current memory cell to the current code block, which starts out empty. The code block contains values, representing Braintrust code.
! compiles the code in the code block as though with the compiler used to compile the currently running program. The result is output, and the code block is then cleared. 
The following is a Braintrust compiler written in Braintrust:
,+[-:,+]!
Implementation: https://gist.github.com/Sgeo/fe54715fc61d1d98f4cc (needs more documentation and to be moved to a repository)
If L is a language, f is a function L->Braintrust, and g is the inverse of f (that is, a function Braintrustk->L), then g(",+[-:,+]!") is a compiler for L, not a compiler for Braintrust.
so if L=braintrust, then f=braintrust->braintrust and g=braintrust->braintrust then g(",+[-:,+]!") is an interpreter for braintrust?
Category:Brainfuck derivatives Category:Implemented Category:Languages
Braintwist

Braintwist is a dialect of Brainfuck designed by Troels Henriksen in 2005. Its only difference from Brainfuck is the introduction of a new operator that allows for self-modifying code.
The new operator, X, swaps the data and code arrays, making it possible to store code in the data array for later execution. Aside from this, Braintwist is identical to Brainfuck, so every Brainfuck program not containing an uppercase letter X will function identically in Braintwist.
Braintwist can be used together with the Brainfork extension, in which case the X instruction only swaps the arrays of the thread calling the instruction. As a result, one thread's code array can be used as another's data array.
==Implementations==
weave.rb supports Braintwist with the -X flag.
==External resources==
* 
Category:Implemented Category:Languages Category:Brainfuck derivatives Category:Low-level Category:Turing complete Category:Cell-based Category:Self-modifying Category:2005
Brainwhirl

Brainwhirl is a BF derivative invented by User:Ttulka. It can be considered a turning tarpit, as its execution is based on spinning a wheel. In Brainwhirl, each instruction means "power" that rotates the wheel by a specific number of steps, relative to its current orientation. Like a standard wheel, it rotates clockwise, meaning that the following instruction is determined by moving backward.
The wheel's instructions follow the standard Brainfuck commands in this clockwise sequence: >, <, +, -, ., ,, [, and ].
Brainwhirl only uses whole numbers from 0 to 7 as instructions, with no other symbols permitted.
== Examples ==
=== Cat ===
 BF: +[>,.<]
 
 BW: 6463132
=== Move value ===
 BF: >>[-]<<[->>+<<]
 
 BW: 002346033306102
=== Hello, World! ===
 BF: +[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.
 
 BW: 643035560625000020266026004757400664040200424160005200610000073067400066
== Brainwhirl to BF transpiler in JavaScript ==
const wheel = [">", "<", "+", "-", ".", ",", "[", "]"]
let pc = 0
const bf = input.split("").map(i => {
 pc = (wheel.length + pc - i) % wheel.length
 return wheel[pc]
}).join()
The variable input contains a string with Brainwhirl code.
Category:Languages Category:Turing complete Category:Turing tarpits Category:Turning tarpits Category:Brainfuck derivatives Category:Cell-based Category:Implemented Category:2024
Brainword

brainword is an esolang created by User:timothytomato.
==Commands==
All commands in a program must be separated by a space or new line, or an error will immediately occur when trying to run it.
Command	Description
heck 	Increments the selected accumulator.
frick 	Decrements the selected accumulator.
crap 	Switches the selected accumulator.
hell 	Repeats the following command by the amount of the selected accumulator when this command is run.
shit 	Outputs the ASCII character corresponding to the amount of the selected accumulator to the console. If it is not a valid ASCII value, an error occurs.
fuck 	Recursively deletes the root folder of the current system the program is running on and terminates the program.
==Execution==
Every time a brainword program is run, two accumulators are initialized, both starting at 0. There are several cases where a program can reach an error. They are:
* Commands in a program are not all separated by a space or new line.
* The current command is not a valid command.
* The value of any of the accumulators are outside the 32-bit integer range.
* The value of the selected accumulator does not correspond to a valid ASCII character, and the shit command is run.
* All commands also have a 1% chance of an error occurring anyway, even if the above conditions are not met.
In any case, when an error condition is met, the fuck command is run and the program halts.
==Examples==
===Hello World===
For now this only outputs HI because User:timothytomato is lazy.
 heck hell heck hell heck hell heck hell heck hell heck hell heck heck heck heck heck heck heck heck heck shit heck shit
===Render your computer unusable===
 fuck
==Implementations==
There are no implementations yet because User:timothytomato is lazy. Feel free to add some though.
Category:Joke languagesCategory:2024Category:Output onlyCategory:UnimplementedCategory:TotalCategory:Unusable for programmingCategory:PseudonaturalCategory:Nondeterministic
Brainword/constants

:
1:
 heck
2:
 heck heck
3:
 heck heck heck
4:
 heck heck hell heck
5:
 heck heck hell heck heck
6:
 heck heck heck hell heck
7:
 heck heck heck hell heck heck
8:
 heck heck hell heck hell heck
9:
 heck heck hell heck hell heck heck
10:
 heck heck hell heck heck hell heck
11:
 heck heck hell heck heck hell heck heck
12:
 heck heck heck hell heck hell heck
20:
 heck heck hell heck heck hell heck hell heck
25:
 heck heck hell heck heck hell heck hell heck heck heck heck heck
50:
 heck heck hell heck heck hell heck hell heck heck heck heck heck hell heck
Category:Examples
Brain思密达

Brain思密达 is a Brainfuck code with TREE(3) encode.
== Command ==
When you decoded script on Base2.E+15, it is same as Brainfuck.
== Example ==
=== Hello, world! ===
燊㧻㕬獚挍爳牉个蓽嫮偪樈눅
밓袢㶉왆䉷캜桶唍縬紑娯먬㷇
扯庘㒇㐀
=== Cell size ===
蕋㒅爜慇䳨狀뭪偕쐉楻뇱浡繡
噽힛퇳댳쬤忌가伐틖욘퍪呙읧
䴸㵭寪꽤佱哷抆畇褝㔑첣㕡蓣
걍栬땷瞭횯껃敹愮엙腴읦晏쩜
呄픉圣粠꼀숃吮廼箉㐀
=== Brainfuck Interpreter ===
衋瓑쒤쑛瘳瑙쵔糏㼋볧毵䠧㞔
攭姙엿櫋䋉灧滬턠楍煌㯌栠픆
㟒흙冞矹殚声宲毇亡芕䕭糞娐
凴능廦婶壥㲢亄뺐툎怎栉疶퀊
椉사䦕啵㕌璜숢탚얐憛쐎䶳渷
焚뽕퓉㛸䥳㣵꺲揕孓徣唦쳍眯
渿똧㩋蛲㛲풰㢏懅㩪둰泴㺘카
뻮홲癪艘퇤뮪囜氀硍䆀켾湐킎
㼿쾤
== Categories ==
Category:Languages Category:Brainfuck derivatives Category:Brainfuck equivalents Category:CJK Category:Pseudonatural Category:Turing complete Category:Turing tarpits Category:Cell-based Category:Low-level
Brain操

brain操 is brainfuck but commands are swear words in different languages.
==Commands==
+: 操 (Chinese)
-: fuck (English)
,: pula (Romanian)
.: P3RKELE (Finnish)
>: ебать (Russian)
<: ficken (German)
[: chết tiệt (Vietnamese)
]: ファック (Japanese)
Commands are separated by line feeds.
==Examples==
===Cat program===
 pula
 chết tiệt
 P3RKELE
 pula
 ファック
Category:Languages
Category:CJK
Category:2024