nyuuzyou/wikis huggingface dataset:
Behaviour

Behaviour is an esoteric programming language invented in 2021 by Lince Lazuli with the objective of making a scripting language that mimics the Behaviour Tree used in artificial intelligence and robotics. This article may call Behaviour a scripting language because the original idea for Behaviour is that it is supposed to run from inside a host program.
==Language overview==
In Behaviour every command is an Expression. Every expression is converted to a Node when parsed, and said nodes can be evaluated. 
So a script in Behaviour is converted to a Tree of expression and subexpressions that are evaluated according to the rules of the Nodes, which are based on the Nodes from the Behaviour Tree.
For example, to run several commands in succession we use a "Sequencer" with all the command inside of it:
(value=10; value+=2; value>100)
Or, if we want to take the value of the first expression to succeed (evaluates truthy) we use a "Selector":
[a>10; b>=20; c<0]
==Examples==
====Hello, World!====
@"Hello, World!"
====Factorial====
factorial = &[1|a<2 a * factorial:a-1]
Category:Languages 
Category:Turing complete 
Category:Implemented
Category:2021
Belle Arti

Belle Arti is a graphical interpretation of BunnyBell.
==Intention==
BunnyBell is a language that is intended to bridge the gap between languages like Scratch(which is perhaps too far from 'standard' coding to allow for a smooth transition). 
Belle Arti is a language that takes further steps in the graphical direction of Scratch. Seeing as learning doesn't appear to be a one-size fits all situation, it would seem beneficial for furthering
the field of to create a language like Belle Arti. While it may not be the top level of efficiency and ease of use, it also is an example case for a language that takes into consideration aesthetics and humanity,
as opposed to the almost brutalist aesthetics and visuals that can be found in some corners of mainstream programming in recent years, and perhaps even today. A more pragmatic graphical style could be made as well, but Belle Arti's MO could be said to be a reminder to not forget that we are humans with souls and dreams and passion, and not just robots.
I was already working on or with visual interfaces and had considered doing something with Scratch, but after seeing Bunnybell the choice to piggyback off of that seemed obvious.
==Similarities and Differences==
Certain common phrases and characters like @main have their own block
==--==
TBC
 
Category:Languages
Ben Rudiak-Gould

Ben Rudiak-Gould designed the Lazy K and Kayak languages. In the non-esoteric world, he also created AviSynth and Huffyuv. His paper Haskell is not not ML (co-authored with Alan Mycroft and Simon Peyton Jones; discussion on LTU) may be of interest to functionally-oriented esoteric programmers.
==External resources==
* Ben Rudiak-Gould's Home Page (archived)
Category:People
BestDirt

BestDirt is the bestest best of the bestest in the history of best best language ever ever everest no takebacks
It is made by User:Yes to be the bestest best of the bestest in the history of best best language ever ever everest no takebacks
== Commands ==
It is comprised of Best and Dirt and literal praise for the language
*best
*dirt
*omg 5 stars this is the best language ever!!!!!!!!!
*BEST THING EVER
*yessir highly recommend
*😍
*🥰
*😎
*🤑
*⭐
*YES HIGHL YRECOOMEND!
*VRY BEST!
== Examples ==
The Hello World Program:
BESTDIRT
😎🆕Language!! TRY IT NOW! very cool!!!
best
dirt
bestdirt
dirtbest
 best
 dirt
 dirt bestbest
 dirt
bestdirt
dirtbest
 best
 dirt
 dirt bestbest
 dirt bestbest
 dirt
 bestdirt
 dirtbest
 best
 dirt
 dirt bestbest
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
VRY BEST!
The same program in bf:
>>>>>>>>--+-><<-<<+[+[<+<>>+----<>>->->-<<<]>]<<--.<+++++++-.<<-..<<.<-+++-.>>.>>.<<<.++++-.>>.>>-+-.<<<++-.[>][>][>][>][>][>][>][>][>][>]
Category:Languages
Category:Joke languages
BestFriends.js

BestFriends.js is a two-dimensional esoteric programming language invented in 2006 by David Millar with the goal of creating an esoteric javascript library.
A BestFriends.js script is very similar to Brainfuck. It has almost exactly the same commands, except for the addition of a few new ones.
==Instructions==
The code is written in your JavaScript like this:
BF(command string,input string);
Example, creates a popup with the letter 'd' on it:
 var c = "+++++[>+++++<-]>}|" +
 "[<++++>-]<.@ {";
 alert(BF(c,"input"));
BestFriends.js has the following commands:
Command 	Description
Add 1 to current memory cell. 	
Subtract 1 from the current memory cell.	
> 	Move the memory pointer to the right.
< 	Move the memory pointer to the left.
[ 	Start a loop. You CANNOT use nested loops in BestFriends.
] 	End of a loop. If current memory cell is 0, continues program, otherwise restarts loop.
{ 	Turns the program pointer 90 degrees left (anticlockwise).
==Related languages==
* Brainfuck
* Befunge
==External resources==
* BestFriends.js Homepage
Category:Languages 
Category:Two-dimensional languages 
Category:Implemented
Beta

Beta is an esoteric programming language that is part of a series by User:Infinitehexagon on Greek esolangs that will be a derivative of the previous esolang with more commands, less commands, or modified commands. It has 3 more extra commands than Alpha.
==Commands==
Alpha➜Beta 	Description
+ 	Increment the accumulator by the amount of α(Alpha) following it.
! 	Decrement the accumulator by the amount of β(Beta) following it.
- 	reverse the value of the accumulator eg. 72->27. If the reversed value is greater than 255 then set the accumulator to 0.
$ 	output the accumulator's ASCII value if it is under 128 and it's Unicode value it it's greater than 128.
= 	if the Accumulator and the amount of Beta's following it equal the same value then skip 10 instructions
! 	NOT logic gate: if the Accumulator Doesn't have a value greater than 0 then skip 5 instructions
[ 	jump to the "]" instruction by the amount of times α(Alpha) follows it. (Leave blank for infinite loop)
] 	Jump back to the "[" instruction.
a."(instructions)"	read input of instructions and execute them in the program, then append the result into the accumulator
== Beta Programs ==
===Hello World===
[αααααααααααααααααα+αααα]$[αααα+ααααααα]+α$+ααααααα$$+ααα$[αααααα!βββββββββββ]!β$[αα!ββββββ]$[ααααααααααα+ααααα]
$[ααα+αααααααα]$+ααα!ββββββ$[αα!ββββ]$-!β[αααα+αααααααα]+α$
===Truth machine===
+α[αααααα+αααααααα]=[$]
Category:Languages Category:Unknown computational class Category:Uncomputable
Beta-Juliet and Portia

beta-Juliet is an esoteric programming language designed by Chris Pressey, which aimed to be an event-oriented Turing tarpit. A beta-Juliet program consists of a set of named of events, each of which specifies its consequences.
Portia is a pre-processor for beta-Juliet which expands templates for event names into multiple events.
beta-Juliet and Portia have been superseded by 2iota.
==Etymology and Disambiguation==
beta-Juliet and Portia are not to be confused with the (non-esoteric) Juliet Programming Language and Portia Virtual Machine. This is an etymological coincidence. While the Juliet PL and Portia VM were named after characters from Shakespeare's plays, beta-Juliet and Portia are puns on the names of automobile manufacturers.
==Computational class==
Any beta-Juliet program can be shown to be no more powerful than a finite-state automaton in the following manner. A running beta-Juliet program, consisting of n events (where n is, of course, a finite non-negative integer), has only the following state:
* Which event is currently occurring (n possibilities); and
* A list of events, sorted by the last time each of them occurred (n! possibilities.)
This is a total of n*n! possibilities, which is finite since n is finite. Therefore, a running beta-Juliet program can only be in a finite number of states; each of these states can be enumerated, the transitions between them mapped, and arranged together to form a finite-state automaton.
Adding Portia does not change this, since Portia can only expand a pattern into a larger (but still finite) set of events.
2iota does change this, by allowing an indefinite number of new events to be generated at run time.
Note that, since there is no arbitrary limit on the size of a beta-Juliet program, the converse should hold: any FSA can be translated into a beta-Juliet program (if we allow beta-Juliet the luxury of input -- something which was never well-specified.)
==External resources==
* 
Category:Languages
Category:Implemented
Category:Finite state automata
Category:2000
Better Burn

Better Burn is Burn but better. It was created as a child of the war between User:tommyaweosme and User:Ais523.
== Commands ==
 ;Colours given as BG, levels 0-3.
 
 00 00 01 00 00 00
 10 11 01 01 (digits 3 and 2 of wolfram rule in order) (first two digits of wolfram rule reversed)
 03 20 11 00 00 11
 00 00 11 11 11 11
 00 00 00 00 00 11
 10 10 10 10 10 11
 00 00 10 00 00 12
 00 02 11 00 00 11
 11 11 11 11 11 11
 00 00 30 00 00 21
 00 00 01 01 01 01
This command interprets wolfram rules.
== Examples ==
=== Interpret W90 ===
 ;Colours given as BG, levels 0-3.
 
 00 00 01 00 00 00
 10 11 01 01 00 09
 03 20 11 00 00 11
 00 00 11 11 11 11
 00 00 00 00 00 11
 10 10 10 10 10 11
 00 00 10 00 00 12
 00 02 11 00 00 11
 11 11 11 11 11 11
 00 00 30 00 00 21
 00 00 01 01 01 01
=== Interpret W110 ===
 ;Colours given as BG, levels 0-3.
 
 00 00 01 00 00 00
 10 11 01 01 01 11
 03 20 11 00 00 11
 00 00 11 11 11 11
 00 00 00 00 00 11
 10 10 10 10 10 11
 00 00 10 00 00 12
 00 02 11 00 00 11
 11 11 11 11 11 11
 00 00 30 00 00 21
 00 00 01 01 01 01
=== Interpret W232 ===
 ;Colours given as BG, levels 0-3.
 
 00 00 01 00 00 00
 10 11 01 01 01 11
 03 20 11 00 02 32
 00 00 11 11 11 11
 00 00 00 00 00 11
 10 10 10 10 10 11
 00 00 10 00 00 12
 00 02 11 00 00 11
 11 11 11 11 11 11
 00 00 30 00 00 21
 00 00 01 01 01 01
==See also==
* Shorter code Burn
Category:LanguagesCategory:Turing completeCategory:2024
Betterlang

Betterlang(BetterFist) is an extesion of Fist by User:ChuckEsoteric08
==Commands added==
;X<Y	if label X has been runned, then goto Y
^X 	output true if X has been runned and false if not.
Or in Fiba(variant of Fist with different syntax which compiles to Batch) version:
lif;X;Y	if label X has been runned, then goto Y
lout;X 	output true if X has been runned and false if not.
Category:Languages Category:Implemented
Beturing

Beturing is an esoteric programming language devised by Chris Pressey in 2005; it is described as a "Befunge-flavoured Turing machine".
Both the "tape" and the control mechanism exist in an unbounded two-dimensional space. The control mechanism consists of codes, each of which is 2x2 cells. There are two "heads", a data head which works more or less traditionally, and a code head which reads, and transitions between, codes.
There are three major differences in the behaviour of the code head and the behaviour of Befunge's instruction pointer:
* The code head has no concept of 'direction' - each move it makes is directly determined by the code that is under it;
* There is no wrapping around the edges of the playfield; and
* There is no way for the code head to 'jump over' a cell.
In this manner, the motion of the code head - and thus the form of the control mechanism - is restricted to a planar graph. This was in part an intentional test of the wire-crossing problem (as it relates to the control mechanism of a Turing machine, at any rate.) However it looks likely that a universal Turing machine can be constructed in Beturing in spite of this restriction.
==External resources==
* 
* Beturing in the Esoteric File Archive
Category: Languages
Category: Implemented
Category: Two-dimensional languages
Category:2005
Between

Between is an esoteric programming language created by User:Saka.
Between has functions which are positioned between arguments, hence the name.
== Basics ==
Between is not stack based nor tape based. It is normal.
An instruction in Between is of the form 
 <arg1><operation><arg2>
For operations that accept only one argument, the arg2 must be a "None" type (See Data Types)
== Data Types ==
Between has 5 data types:
Representation	Name
'x' 	String
|x| 	Integer
[x] 	Variable
(x) 	Condition (True or False)
. 	None
== Operations ==
Each operation is a single character and must be on it's own line. Comment lines start with #.
Operation	Description 	Arg 1 	Arg 2 	Returns
p 	Print arg1 	String, Int, or Var	None 	None
v 	Declare variable with name arg1 	String 	None 	None
s 	Set variable arg1 to arg2 	Var 	String, Int, or Var 	None
c 	Toggle string/integer form of arg1 (Arg1 must only consist of numerals)	String, Int, or Var	None 	String or Int
+ 	Add arg1 to arg2 (Or concatenate strings) 	String, Int or Var 	String, Int or Var 	String or Int
* 	Multiply arg1 by arg2 	Int or Var 	Int or Var 	Int
= 	Check if arg1 equals arg2 	String, Int, or Var	String, Int, or Var 	Condition
> 	Check if arg1 is greater than arg2 	Int or Var 	Int or Va 	Condition
r 	Check if arg1 or arg2 	Condition 	Condition 	Condition
n 	Negate arg1 	Condition 	None 	Condition
f 	Go to arg1 if arg2 is true 	Int or Var 	Condition or None (If none, acts as a Goto)	None
i 	Set arg1 to user string input 	Var 	None 	None
x 	Exit program 	None 	None 	None
== Examples ==
Warning: Not tested yet.
=== Hello World ===
 'Hello, World!'p.
 .x.
=== Truth Machine ===
 'in'v.
 [in]i.
 |5|f([in]='1')
 |0|p.
 .x.
 |1|p.
 |5|f.
=== CAT Program ===
 'in'v.
 [in]i.
 [in]p.
 .x.
=== Infinite Fibonacci Sequence ===
 'a'v.
 'b'v.
 'c'v.
 [b]s|0|
 [c]s[b]
 [b]s|[a]+[b]|
 [a]s[c]
 [a]p.
 |4|f.
=== Subtract one input from another ===
 'a'v.
 [a]i.
 [a]s|[a]c.|
 'b'v.
 [b]i.
 [b]s|[b]c.|
 |13|f([b]>[a])
 'value'v.
 |11|f(|[value]+[b]|=[a])
 [value]s|[value]+|1||
 |8|f.
 [value]p.
 .x.
 'Error: can't subtract bigger number from smaller'p.
 .x.
Category:2018
Category:Languages
Category:Unimplemented
Beunfunge

Beunfunge is an esolang invented by User:None1. It is Befunge, but there's no self modifying.
==Examples==
Many examples in Befunge work in Beunfunge too, but some do not.
==Computational class==
Beunfunge-93 is not Turing-complete.
Beunfunge-98 is Turing complete if the integer is unbounded.
Category:Two-dimensional languages
Category:Languages
Category:2025
Bf core

==wtf?==
brainfuck!
==intro==
bf core is extremely optimized by size (69 bytes) brainfuck core implementation written in x86 asm. Coded by Total Vacuum in 2016.
==goal==
The goal is to create as compact as possible brainfuck core implementation for simple brainfuck to dos/winxp executable .com file compiler. Output file format:
* core (69 bytes for current version)
* code (passed through comment and whitespace remover)
* space (ascii 0x20, 1 byte)
You can freely use this core in your brainfuck compiler to produce dos/winxp executable .com files, or you can generate .com file even without compiler using 
 copy bfcore.com+src.b dest.com 
where bfcore.com is previously compiled bf core, src.b is brainfuck source (strip comments and whitespaces first!), dest.com is destination .com file.
The next goal is to trim core size to 64 bytes. Is it possible? All ideas on core size trimming are welcome! :)
==specification==
* 8-bit cells
* 510 memory cells (+2 bytes for 30000 cells)
* max code size is 32K
* the only available characters are [ ] < > + - , .
* one extra terminating space character (ascii 0x20) required (for correct program termination)
* no newline character conversions on i/o
* incorrect i/o when redirecting from/to file (+3 bytes to fix)
* up to 255 nested [ ] blocks
==src==
 | .model tiny ;
 | .code ;
 | .startup ;
 BE 45 01 | lea si,@src ;
 D1 EF | shr di,1 ;
 F3 AB | rep stosw ;
 4F | dec di ;
 2B F8 | @move: sub di,ax ; </>
 3D | db 3Dh ;
 28 05 | @add: sub [di],al ; +/-
 AC | @next: lodsb ;
 98 | cbw ;
 2C 5B | sub al,'[' ;
 E3 07 | jcxz @true ;
 7C F8 | jl @next ;
 48 | @inccx: dec ax ; [/]
 2A C8 | sub cl,al ;
 EB F3 | jmp @next ;
 7C 0C | @true: jl @ptr ;
 7F 06 | jg @end ;
 3A 05 | cmp al,[di] ; [
 74 F3 | je @inccx ;
 56 | push si ;
 3D | db 3Dh ;
 5E | @end: pop si ; ]
 4E | dec si ;
 EB E5 | jmp @next ;
 2C E1 | @ptr: sub al,'<'-'[' ;
 48 | dec ax ;
 73 DB | jnc @move ;
 2C EE | @last: sub al,'+'-'<'-1 ; +/,/-/.
 3C 03 | cmp al,3 ;
 74 08 | je @putc ;
 73 0A | jnc @exit ;
 48 | dec ax ;
 75 D3 | jnz @add ;
 B4 08 | @getc: mov ah,8 ; ,
 3D | db 3Dh ;
 B4 02 | @putc: mov ah,2 ; .
 8A 15 | mov dl,[di] ;
 CD 21 | @exit: int 21h ;
 88 05 | mov [di],al ;
 EB C8 | jmp @next ;
 | @src: ;db "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++. ";Hello World!
 | end ;
==compilation==
Compile with:
 tasm.exe /m9
 tlink.exe /t /x
==sorry==
Sorry for my English :)
Category:brainfuck
Category:2016
Category:Implementations
Bfbf

BFBF (Brainfuck Binary Format) is an encoding for efficient storage of brainfuck code devised by User:Nick-1666 in 2022.
==Flags & Usage==
Usage is as follows:
bfbf <input file path> <flags>
Note: flags can be chained with short names: e.g (-dl)
===Flags===
* -d (--debug) Shows a debug output with what characters are being written
* -l (--lossy) Uses a lossy encoding that removes newlines and tabs.
* -h (--help) Prints help information
* -V (--version) Prints the current version of the BFBF encoder/decoder
==Output==
Upon encoding, BFBF shows the saving space as opposed to an ascii equivalent before outputting with a `.BFBF` extension.
Decoding a `.BFBF` file will result in the extension `.d.bf` to show that it is decoded and to not overwrite the original file.
All files will be named after the input file name.
== Implementations ==
* Nick-1666's # Encoder/Decoder made in Rust (official)
Category:Implemented
Category:Data Types and Structures
Category:2022
Category: Languages
Bfcompress

Bfcompress is a compression algorithm made by User:Yes to compress bf code.
== Process ==
 Caption text
bf command	binary conversion
+ 	000
- 	001
< 	010
> 	011
[ 	100
] 	101
. 	110
, 	111
2 commands can fit in one 8 bit byte. The last 2 bits are all either 01, 10 or 11 to prevent ++ from resulting in a 00000000 or null character.
== Examples ==
The hello world shown on the bf page could go from
++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
to
�������c�c�cKK7ccgo�WG¯{g'Ã���Û��oË;[��Ç;o�c�
Category:Brainfuck Category:Compressed Brainfuck Category:Binary Category:Languages
Bfos

bfos is a hypothetical operating system written entirely in brainfuck. It was conceptualized by User:PythonshellDebugwindow in November 2020.
==Details==
bfos should keep track of all files, folders, pixels, peripherals, and such in its cells.
==Commands==
A standard bfos distribution should include at least the following commands:
* ec: outputs all its arguments (any format is allowed)
* mk: creates a new file with its name as the first argument (it is undefined behaviour to "create" an already existent file)
* wf: writes all its arguments (except for the first one) to the file signified by its first argument (it is undefined behaviour if the specified file doesn't exist)
* rm: removes the file with its name as the first argument (it is undefined behaviour to delete a non-existing file)
* if: begins an if statement (executes iff its first argument is not empty or zero)
* fi: ends an if statement
It is undefined behaviour if ifs and fis are unmatched, or if an invalid command is entered. Commands should be allowed to be separated by newlines, although other characters can optionally be supported as well. Spaces should be used to separate command arguments.
Category:2020 Category:Unimplemented Category:Concepts Category:brainfuck
Bgt

Bgt is a joke esoteric programming language speedran by Cinnamony. Let's see how long it takes to write this one.
==Commands==
Command	Description
P 	prints the character in front of it
K 	prints the input
L 	prints the 99 bottles of beer on the wall program
J 	print the FizzBuzz program
Z 	truth-machine
==Examples==
===Hello World===
 PHPePlPlPoP,P PWPoPrPlPdP!
===Cat===
 K
===99 Bottles of Beer===
 L
===FizzBuzz===
 J
===Truth Machine===
 Z
==Time==
00:02:22.29
==Implementations==
An implementation in Common Lisp shall be provided:
 (defun interpret-Bgt (code)
 "Interprets the piece of Bgt source CODE and returns NIL."
 (declare (type string code))
 (let ((position 0))
 (declare (type fixnum position))
 (symbol-macrolet
 ((current-token
 (the character
 (char code position)))
 (eof-p
 (the boolean
 (not (array-in-bounds-p code position)))))
 (loop until eof-p do
 (case current-token
 (#\P
 (incf position)
 (when eof-p
 (error "Expected at character to print, encountered EOF."))
 (format T "~c" current-token)
 (incf position))
 (#\K
 (format T "~&>> ")
 (format T "~a" (read-line))
 (clear-input)
 (incf position))
 (#\L
 (loop for number-of-bottles of-type (integer -1 99) from 99 downto 1 do
 (format T "~&~d ~:*bottle~p of beer on the wall,~%~
 ~:*~d ~:*bottle~p of beer.~%~
 Take one down, pass it around,~%~
 ~[No~:;~d~] ~:*bottle~p of beer on the wall.~2%"
 number-of-bottles (decf number-of-bottles) number-of-bottles))
 (incf position))
 (#\J
 (loop for counter of-type (integer 1 101) from 1 to 100 do
 (format T "~&~a"
 (cond
 ((zerop (mod counter 15)) "FizzBuzz")
 ((zerop (mod counter 3)) "Fizz")
 ((zerop (mod counter 5)) "Buzz")
 (T counter))))
 (incf position))
 (#\Z
 (format T "~&>> ")
 (let ((input (parse-integer (read-line))))
 (declare (type integer input))
 (clear-input)
 (if (zerop input)
 (format T "~&0")
 (loop initially (fresh-line) do (format T "1"))))
 (incf position))
 (otherwise
 (error "Invalid character at position ~d: ~s." position current-token)))))))
Category:Languages Category:Joke languages Category:Unusable for programming Category:Implemented
Bias

Bias is an esolang by User:PythonshellDebugwindow.
==Commands==
===Outside biases===
Where B is the value of the command's preceding bias (or 0 if it has no preceding bias):
Command	Effect
+ 	Increase the current cell by B
- 	Decrease the current cell by B
/ 	Set the current cell to an input integer
= 	Set the current cell to an input character
& 	Output the current cell as an integer B times
' 	Output the current cell as a character B times
" 	Increase the cell pointer by B
* 	Halt the program
: 	Jump forwards B commands (not including biases)
; 	Jump backwards B commands (not including biases)
( 	Starts a bias (see #Biases)
) 	Ends a bias
===Inside biases===
Here, B is initialized to 1 if there is no preceding bias:
Command	Effect
+ 	Increment the value by B
- 	Decrement the value by B
* 	Multiply the value by B
\ 	Divide the value by B (integer division)
/ 	Set the value to the current cell
= 	Set the value to 0
Each of these commands may be preceded by a bias. This nesting can be arbitrarily deep. A bias can also be preceded by another bias, in which case that bias's value will be initialized to the preceding bias's value instead of 1.
==Biases==
Biases, this language's namesake, affect the "magnitude" of the command they directly precede. The result of a bias when executed is known as its 'value' (also B in #Commands). The value starts as 0.
==Examples==
===Hello, World!===
:Currently prints Hello
 (++++++++(+++++++++)*)+'(++++)+(+++++(+++++)*)+'(+++++++)+''(+++)+'
===Infinite 1-char cat===
 ='(++);
===Truth-machine===
 /(/(+++)*):&*&(+);
==Turing-completeness proof==
Brainfuck where [ jumps if nonzero and ] jumps right back to [ (let's call it BF0) is still Turing-complete, as you can use two cells for every BF cell: one to store the value, the other for computing the NOT of the value (for adjusting to nonzero loops instead of zero loops). BF0 can be compiled into Bias with the following translations:
Command	Translation
+ 	(+)+
- 	(+)-
+ 	(+)+
< 	(-)"
> 	(+)"
, 	=
. 	(+)'
Looping is a bit more difficult, but it can be done. You have to replace all [s with +(off(+(/)*/\)*\): where off is the right-offset of the matching ]; this exits the loop if the current cell is zero. Replace the ]s with (off-); where off is the left-offset of the matching [.
Category:Languages Category:2020 Category:Cell-based Category:Turing complete Category:Unimplemented