nyuuzyou/wikis huggingface dataset:
BIITI

BIITI (Beauty Is In The Implementation) is an esoteric programming language created by DolphyWind. It is inspired by 8086 assembly and Forth. A typical BIITI program is a list of commands separated by the \n character, that gets executed on the BIITI virtual machine.
=== BIITI Virtual Machine ===
BIITI virtual machine consists of a stack and three registers: IP, ACC and CMP. The IP register stores the position of the current instruction, CMP register stores the last comparison state and can take 4 different values, namely Less, Equal, Greater and NoCmp (has the value NoCmp by default). The ACC register holds one arbitrary variable and its value can be retrieved and modified by the program. Stack holds arbitrary many variables in FILO (First In Last Out) fashion. A variable can be either string, integer or floating point number. Stack starts off empty and the ACC has the default value of 0 (integer).
== Commands ==
BIITI has 21 commands. But they don't do what you think they would do. 
 BIITI Commands
Command 	Action
MOV [variable]	Pushes the given variable on top of the stack
JNE 	Pops the variable on top of the stack
JL 	Pops two variables from the stack and pushes their sum. Adding two strings concatenates them. Addition and other binary operations are done in the style of Forth, precisely in the style of <second> <operation> <first>
JG 	Pops two variables from the stack and pushes their difference
JLE 	Pops two variables from the stack and pushes their product
CMP 	Pops two variables from the stack and pushes their ratio
MUL 	Pops two variables and compares them, updates the CMP register accordingly
SUB [line] 	Jumps to the given line
JGE 	Skips the next line if the CMP register has the value Equal
PRINT 	Skips the next line if the CMP register has the value Less or Greater
RTR 	Skips the next line if the CMP register has the value Greater
POP 	Skips the next line if the CMP register has the value Greater or Equal
DUP 	Skips the next line if the CMP register has the value Less
PUSH 	Skips the next line if the CMP register has the value Less or Equal
JMP 	Pops the variable on top of the stack and moves it to the ACC register
DIV 	Pushes the variable on the ACC register on top of the stack without modifying the ACC register.
JE 	Pops the variable on top of the stack and prints it
ADD 	Pops the variable on top of the stack and pushes it back twice
ROT 	Reads a variable from the user and pushes it on top of the stack
INDEX 	Rotates the first three variables on the stack. Precisely, pushes them back in order of first, third and second
READ 	Pops a string and an integer, pushes the character corresponding to the index back to the stack.
== Implementation ==
An implementation of BIITI can be found here.
== Example Programs ==
Here are some example programs written in BIITI
=== Hello World ===
MOV "Hello World!\n"
JE
=== Truth-Machine ===
ROT
ADD
JE
ADD
MOV 1
MUL
PRINT
SUB 2
=== Counter ===
ROT
JMP
MOV 0
ADD
JE
MOV "\n"
JE
MOV 1
JL
ADD
DIV
MUL
RTR
SUB 4
Category:Languages Category:Stack-based Category:Implemented Category:Low-level Category:2024 Category:Turing complete
BIT

BIT is an esoteric programming language invented by David Morgan-Mar that treats all data like C treats strings. The language is strongly typed, with two variable types: bit and address-of-a-bit.
All syntax elements are words and all whitespace is optional.
==See also==
Other languages operating on bits (implemented only):
* FlipJump
* BoolX
* Bitch
* Boolfuck
* BitChanger
* Bitter
* Boolet
* BitBitJump
* Smallfuck
==External resources==
* BIT website
* Itty, a BIT interpreter
* Unofficial BIT interpreter (C++)
Category:Cell-based
Category:Low-level
Category:Implemented
Category:Unknown computational class
Category: 2004
Category:Languages
BITE/Quines

* \x00
* \x01
* \x02
* \x03
* \x04
* \x05
* \x06
* \x07
* \x08
* \t
* \n
* \x0b
* \x0c
* \r
* \x0e
* \x0f
* \x10
* \x11
* \x12
* \x13
* \x14
* \x15
* \x16
* \x17
* \x18
* \x19
* \x1a
* \x1b
* \x1c
* \x1d
* \x1e
* \x1f
* 
* !
* "
* #
* $
* %
* &
* '
* (
* )
* *
* +
* ,
* -
* .
* /
* 0
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
* 9
* :
* ;
* <
* =
* >
* ?
* @
* A
* B
* C
* D
* E
* F
* G
* H
* I
* J
* K
* L
* M
* N
* O
* P
* Q
* R
* S
* T
BMOW

BMOW standing for Big Mess o' Wires aka Steve Chamberlin is a retrocomputer hardware enthusiast. He created at least three custom CPUs in 1980s hardware. He is also making disk emulator hardware for Apple II and other old Apple computers.
Languages:
* BMOW 1
* Tiny CPU https://www.bigmessowires.com/cpu-in-a-cpld/
* Nibbler https://www.bigmessowires.com/nibbler/
BMOW (Big Mess o' Wires) webpage
Category:People
BOREDOM

BOREDOM was made in a moment of boredom by Areallycoolusername. It needs an infinite amount of code to make a functioning program.
== Specifics ==
On the 14th of March, pi day, making a program that calculates the digits of pi wasn't going anywhere, so BOREDOM was created to make up for that. In order to do anything, even to print a Hello, world! program, you need an infinite amount of code. For example, to print hello world, you need the "STAMP" command. However, you would need to specify STAMP and "Hello, world!" over and over again. Before your program, you need the "<ACTV>" command to start the program (you only need to type it once). Then, it waits for you to fulfil the requirement of infinite code.
== Hello World Program ==
<ACTV>
STAMP 
Hello, World!
This is the incomplete version. A real program would require you to specify the command and what you want printed indefinitely. 
== Implementations ==
There is one interpreter for BOREDOM in Pascal, here it is.
program pronouncedfynight (input,output);
uses crt;
const
number = 69;
var
call : string;
cool : string;
coal : string;
begin
readln(call);
 if(call='<ACTV>')then
 while number=69 do
 begin
 readln(cool);
 readln(coal);
 end;
writeln(coal);
end.
This is the ultimate result of boredom.
Category:Joke languages
Category:2019
Category:Implemented
Category:Languages
Category:Unusable for programming
BRUH

BRUH is an esoteric programming language that only uses the letters B, R, U, and H for its 3 letter commands, with B, R, and U for commands and H for separating the commands. Everything that isn't a capital B, R, U, or H is considered a comment, comments can also be determined with HH as the ends, and HHH for a multiline comment. Also, the file extension, although the contents are regular text, must be .bruh for the interpreter to allow it to work
==Commands==
To make a command, you have to fuse a combo of B, R, and U in one of the following combos.
 Commands
Command	Equivalent 	Function
BBB 	+ from brainfuck	Add 1 to the accumulator
BBR 	- from brainfuck	Subtract 1 from accumulator
BBU 	s from Deadfish 	Square accumulator
BUR 	[NONE] 	Add another accumulator to the left
BUU 	[NONE] 	Add another accumulator to the right
RBR 	> from brainfuck	Move to accumulator on the right
RBU 	< from brainfuck	Move to accumulator on the left
UUU 	[ from brainfuck	Skip everything to the next URU if accumulator is zero
URU 	] from brainfuck	Jump back to the last UUU if accumulator is not zero
UBR 	[NONE] 	Do the previous command the amount of times in the accumulator
RRB 	Input 	Input Number
RRU 	Output 	Output as ASCII char
RBB 	Output 	Output as a number
To end a program, use RHHB
==Examples of usage==
===Adder===
 HH Add an accumulator HH
 BUUH
 HH Input HH
 RRBHRBRHRRBHRBUH
 HH Adding HH
 UUUH
 BBRHRBRHBBBHRBUH
 URUH
 HH Output HH
 RBRHRBBHRHHB
===Truth machine===
From here on, nothing is color coded to show how painful it can get trying to see where, just imagine the H's didn't exist!
 RRBHUUUHRBBHURUHRBBHRHHB
===Cat program===
The following code implements a numeric cat program which repeats until an input of zero is committed:
 RRBH
 RBBH
 UUUH
 RRBH
 RBBH
 URUH
 RHHB
==Interpreter==
* Common Lisp implementation of the BRUH programming language.
Category:LanguagesCategory:2022Category:Turing completeCategory:Implemented
BRaInFUCK

BRaInFUCK is a brainfuck equivalent that uses element symbols instead of normal symbols, separated by spaces.
 Translation to brainfuck
Atomic number mod 8	brainfuck
0 	+
1 	-
2 	,
3 	.
4 	>
5 	<
6 	[
7 	]
==Examples==
===Cat Program===
English:
 He C Li He N
Chinese:
 氦碳锂氦氮
===XKCD Random Number===
 O S Cr Ge Zr Cd C Be O O O O O O O O Al H P Mg Cm Cm Cm Cm Na
 氧硫铬锗锆镉碳铍氧氧氧氧氧氧氧氧铝氢磷镁锔锔锔锔钠
==See also==
* PTotE
Category:Languages
Category:Thematic
Category:2024
Category:Turing complete
Category:Brainfuck derivatives
Category:Brainfuck equivalents
BS

BS is a joke language invented by Mark Rendle to be as cruel and painful to use as possible. It tries to take the worst bits of many languages.
It is based on PHP and uses the Euro symbol as variable sigils. It borrows significant whitespace from Python, F# and Haskell because of their ability to cause invisible errors. It copies javascripts confusing equality operator and takes it a step further the negation of the strict equality operator (!=!). There are (at least) 6 different types of string quotes that all have different meanings, many of them are used for compatability with very old systems. Following Visual Basic it uses round parenthesis for array indices as well as function calls in an attempt to be confusing. Inspired by the C preprocessor it has a macro system based on regular expression substitution.
It only has 'unless' conditional chosen since it is the most confusing one. It only has one exception HALT_AND_CATCH_FIRE since the experienced programmer should know what went wrong. The integers are 17-bit "because we can".
== Example ==
 #define /^my (.*?) thing:$/class \1:/
 
 my Greeter thing:
 public function __construct(€name)
 	 HALT_AND_CATCH_FIRE
 	(unless €name != null);
 	€this->name = €name;
 	Delete €name;
 
 public function say(€thing isProbablyA String, €times)
 	42 echo €thing, « », €this->name, BS::EOL;
 	 goto 42;
 	(unless --€times !!=! 0);
 	Delete €thing, €times;
== Implementation ==
* Beginnings of an implementation here: https://github.com/BSLang/BS
== External Links ==
Mark Rendle has a talk introducing BS entitled The Worst Programming Language Ever and explaining several design choices.
A more recent version of the talk is also available here : The Worst Programming Language Ever - Mark Rendle - NDC Oslo 2021.
Category:Languages
Category:2014
BSQBL

BSQBL(Brainfuck Style Queue-Based Language) is an esolang by User:ChuckEsoteric08
==Specification==
Command	Description
> 	Enqueue a new zero element
+ 	Dequeue the front element, increment it, and enqueue it
- 	Dequeue the front element, decrement it, and enqueue it
< 	Dequeue the front element and enqueue it
" 	Dequeue the front element and enqueue it two times
, 	Query the user for a character and enqueue its character code
. 	Dequeue the front element and output the character with the corresponding character code
[ 	Dequeue the front element; if it equals zero, jump past the matching ]
] 	Jump back to the matching [
==Examples==
===Cat===
 ,"[.,"]
===Output "H"===
 >+++++++""[-+<+<+<+<+<+<+<+<+"<]<+<+<.
===Truth-machine===
This program operates a truth-machine:
 ,".><+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<"<
 [--"<]
 <["+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<+<.><+<]
==Algorithms==
This section is inspired by brainfuck algorithms. They don't use < directly and use variable names on top of command to denote current queue element.
===x = 0===
 x x x x x
 " [ - " ]
===x = y using temporary element t===
 t t t t t x x x x x y y x t y y y t t y t t t
 " [ - " ] " [ - " ] " [ + + - " ] " [ + - " ]
===x = x + y using temporary element t===
 t t t t t y y x t y y y t t y t t t
 " [ - " ] " [ + + - " ] " [ + - " ]
===x = x - y using temporary element t===
 t t t t t y y x t y y y t t y t t t
 " [ - " ] " [ - + - " ] " [ + - " ]
==Interpreter==
* Common Lisp implementation of the BSQBL programming language.
==See also==
*CQfuck - like brainfuck but uses call queue
*MNNBFSL - uses two stacks instead of queue
Category:Languages Category:Queue-based Category:Turing complete Category:Implemented
BSoD

BSoD is an esoteric programming language created by User:Rerednaw on 23 June 2018. The name refers to the Blue Screen of Death on computers with the Windows operating system. It is part of graphic programming languages.
== Commands ==
Here is the summary of each function :
Color 	RGB 	Function
BSoD Background Color V1 	(0,0,170) 	Add 1 to value
BSoD Background Color V2 	(0,120,170) 	Change the background or the text color to (value - 1) % 64 and set value to 0
BSoD Text Color 	(255,255,255)	Prints the character value % 256 in ASCII and set value to 0
RSoD Background Color 	(170,0,0) 	Stop the program
Terminal Background Color	(0,0,0) 	Go to the next line (all the following pixels in the same line are considered as comments)
=== Colors ===
The BSoD Background Color V2 allows you to change the color of the text or the color of the background.
If there is only one pixel of this color, it will change the color of the text.
If there are 2 in a row, it will change the color of the background.
It also means that you can not change the color of the text 2 times in a row.
The color is represented by a value between 0 and 63 calculated as : (value - 1) % 64.
That means you can not enable the color function for 0.
This value will be transformed into base 4 whose first character will represent the intensity of red * 85, the second will represent the intensity of green * 85 and the last will represent the intensity of blue * 85.
Example for the value 219 :
(219 - 1) % 64 = 26
26 in base 10 = 122 in base 4
1 * 85 = 85
2 * 85 = 170
2 * 85 = 170
Color = rgb(85,170,170)
== Examples ==
=== Hello, World! ===
Note: The program images have been multiplied by 10 for a better visual comfort but you will have to reduce them by 10 if you want the program to work
== Implementations ==
* http://bouton-dev.alwaysdata.net/experiments/bluescreen.txt 
Category:Languages
Category:Implemented
Category:Non-textual
Category:Thematic
Category:Output only
Category:2018
Category:Total
BTree

BTree is an esoteric language invented by User:TuxCrafting where programs are formatted as binary trees.
== Syntax ==
Programs are made of nodes, which contain one or more instruction.
Nodes are organized as abbccccdddddddd... where a is the root, b are the children of the root, the first two c are the children of the first b, and the last two are the children of the second b, etc...
Nodes are matched by the regex (;.)*. (semicolons are not included in the final tree).
Whitespace is ignored and comments are wrapped in { curly braces }.
Programs are padded with no-ops.
== Semantics ==
There are two accumulators, A and B, and a deque. The basic data type is a balanced ternary digit.
Execution starts at the root node. All the instructions in the currently selected node are executed, and the next selected node is based on the content of the accumulator:
* -1: Left child
* 0: Parent
* 1: Right child
In case the selected node doesn't exist (child of a leaf or parent of the root), execution halts.
== Instructions ==
Instruction	Description
0 	Set A to 0.
- 	Set A to -1.
+ 	Set A to 1.
^ 	Exchange the content of A and B
a 	Insert the content of A at the end of the deque.
A 	Remove the element at the start of the deque and put it in B, or 0 if the deque is empty.
b 	Insert the content of A at the start of the deque.
B 	Remove the element at the end of the deque and put it in B, or 0 if the deque is empty.
& 	Set A to the minimum of A and B (ternary AND).
| 	Set A to the maximum of A and B (ternary OR).
= 	Set A to 1 if A and B are equal, else -1.
! 	Multiply A by -1 (ternary NOT).
i 	Input a ternary number (-, 0 or +) and put it in A.
o 	Output the content of A (-, 0 or +).
Any other instruction is a no-op.
== Examples ==
=== Truth machine ===
{ BTree truth machine }
{ "-" is 0 and "+" is 1 }
 ;i;aA
 o ;^;o;^-
. . 0
== Turing-completeness ==
BTree is turing complete by compiling a Cyclic tag system into it. Compiler.
The way it works is by separating the productions into separate instructions, accessible through a tree. Each production is compiled to a pair of "Pop first bit and jump depending on its value" and "Push a bitstring", with the "pop" instructions addressing into a two-element jump table.
== External links ==
Python implementation
Category:Languages
Category:2019
Category:Deque-based
Category:Turing complete
Category:Implemented
BUT

BUT is a esolang created by User:Yayimhere with 2 unbounded decimal counters(u and r. also if decremented to negative will be set to 0) and 4 functions(i, t ,f and k) and these functions can be changed. it was inspired by Emmental and then most of ais523's works
== commands ==
heres the functions(when i reference y i mean counter y and the same with u):
f(x)=x + \frac{y}{10^{\left\lfloor \log_{10}(y) \right\rfloor} + 1}
k(x)=\log_{u}(x)^{y}-x
t(x)=x-5
i(x)=x+2
 syntax
command	description
p/b 	apply function p to counter b
[p;q] 	redefine function p to the BUT code q(recursive functions are not allowed) where when y is used is the register the function is used on
(q;b) 	loop code q(only checking at the brackets) until counter b is 0
: 	halt
# 	escape loop
n 	goto line n
{b.} 	set counter b to user input
{b,} 	print counter b as a ascii char
when a function p is redefined the original function is p0 and the redefined one is p(and such it is for every redefinition. so for the nth redefinition the function from before the redefinition must now be referenced as pn-1) and must be referenced
== examples ==
Cat:
 {r.}({r,}{r.};r)
== translation to Minsky machine ==
notes:
* this translation uses Short Minsky Machine Notation
* the two registers are u and r
this is the translation:
 ℘xy <-> t/y i/y i/y(|x#;)
 ℘y <-> i/y i/y i/y t/y
 ℘ <-> :
this proves that BUT is Turing-complete. the functions can be redefined:
 [t;t/y i/y i/y]
 [i;i/y i/y i/y t/y]
and now the translation becomes:
 ℘xy <-> t/y(|x+2#;)
 ℘y <-> i/y
 ℘ <-> :
Category:Languages Category:Functional paradigm Category:Turing complete Category:Unimplemented Category:Low-level
BWTFN

BWTFN, or Because Why The Fuck Not, is an esolang inspired off of the CopyPasta language created in 2019. BWTFN is only used for printing text, as that is the only thing it can do.
Why does it exist? 
Because why the fuck not?!
==Commands==
 open
This creates a variable that you can then add characters to.
 close
This closes the variable that was previously created so that you can edit other variables or print them out.
 add
This adds a character to an open variable using an ASCII code.
 out
This prints a variable onto the console.
 output
This prints a variable while creating a new line.
==Usage==
Each command takes one argument. The argument and the command are separated with a space. The open, close, out, and output commands take the name of a variable. The add command takes an ASCII value. If you want to add multiple of the same character into a variable, you can put an asterisk and then the number of times you want to add it. The out and output command can also take an asterisk and number if you want to print something multiple times.
==Syntax==
The following EBNF description applies to the language's grammar:
 program := { command } ;
 command := "add" , asciiCode , [ cardinality ]
 | "close" , variableName
 | "open" , variableName
 | "out" , variableName , [ cardinality ]
 | "output" , variableName , [ cardinality ] ;
 cardinality := "*" , digit , { digit } ;
 variableName := letter , { letter } ;
 asciiCode := digit , [ digit , [ digit ] ] ;
 letter := "A" | ... | "Z" | "a" | ... | "z" ;
 digit := "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
==Examples==
===Hello, World!===
 open helloworld
 add 72
 add 101
 add 108*2
 add 111
 add 44
 add 32
 add 87
 add 111
 add 114
 add 108
 add 100
 add 33
 close helloworld
 out helloworld
===Print something 1000 times===
 open AAA
 add 65*3
 close AAA
 output AAA*1000
==Interpreter==
* Common Lisp implementation of the BWTFN programming language.
Category:2019Category:Unusable for programmingCategory:LanguagesCategory:Output onlyCategory:ImplementedCategory:Total
B^2 Turing Completeness

This page will convert brainfuck, a known Turing complete language, into B2. B2 is not turing complete but is a bounded-storage machine (see "Counter Argument" for details).
== Required For Turing-Completeness ==
Brainfuck	B2 Equivalent
+ 	x = add x 1 ;
- 	x = sub x 1 ;
[ 	while ( x == 0 ) {
] 	}
< 	No exact match.
> 	No exact match.
== Not Required ==
Brainfuck	B2 Equivalent
. 	output x ;
, 	number x = input ; or decimal x = input ;
= Counter-argument =
If one argues that < and > could also be represented using variables, B2 is still not turing complete.
These variables are all of limited size, and only a limited amount of them are accessible. Even a program like this:
 number cell = firstCell ;
 if ( currentCell == 1 ) {
 cell = secondCell ;
 }
 if ( currentCell == 2 ) {
 cell = thirdCell ;
 }
for however many variables/cells are used, that's still a limited amount of variables — and although that would be Turing-complete if variables were unbounded, they're not, and since a finite amount of variables times a finite size for each of those variables equals a finite amount of storage, while a Turing machine needs an infinite (or unbounded) amount of storage, B2 isn't Turing complete. Since bounded storage machines have finite storage, but are the same as Turing machines in all other respects (just like B2), B2 is not Turing-complete but is a bounded-storage machine.
Category:Proofs
B (None1)

It is a bf derivative. bf has 8 commands, but b has only 4.
==Commands==
b has these 4 commands and . They work like in brainfuck.
==Examples==
===Hello, World!===
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++.
Since b has only half of the commands, the power of it is very limited.
==Interpreters==
===Python===
 x=0
 for i in input():
 if i=='+':x=(x+1)&255
 if i=='>':x=0
 if i=='.':print(chr(x),end='')
 if i=='[':raise Exception('Unmatched [')
==See also==
* f
* FuckBrain
Category:Languages
Category:Joke languages
Category:2024
Category:Total
Category:Output only
Category:Implemented
Category:Total
Category:Unusable for programming
Category:Brainfuck derivatives
B automaton

B automaton is a Tag system invented by User:A designed with problem-solving usefulness in mind.
== Example program ==
Tag system 
 m: 1
 A: {1,2,3,H} 
 P:
 1 --> 3321H
 2 --> 331
 3 --> 33
Computation
 Initial word: 123
 233321H
 33321H331
 3321H33133
 321H3313333
 21H331333333
 1H331333333331
 H3313333333313321H
 Halt. Outputs the resulting program when all H's are stripped out.
Output:
3313333333313321
Simplified:
1
123H
1=3321H
2=331
3=33
123
== Some builtins ==
Of course for usefulness, some builtins should be possible.
-ab a=1st item b=2nd item
|a a=1st item
| Halve the next item.
: Duplicate the next item.
- Minus the ord code of the first item by the second item.
+*/% Same with minus. ^ is the power operator.
After these operations, the ord code will be modulo'd by 255.
Category:2019
Category:Languages
Category:Unimplemented