nyuuzyou/wikis huggingface dataset:
Kak+-

Kak+- is another derivate of Kak made by its author! It is two-dimensional, like Kak+ but with less commands
==Commands==
Command 	Meaning
\ 	move memory pointer to the right, flip bit and skip next instruction if zero
( 	Same as in Kak+
^, <, > and v	same as in Kak+
# 	stop progaram
Command ; is deleted, so total number of commands is 7! (not 5040)
==Translation to Kak==
Program
 abcdef
In Kak+ is:
 >abcdef;#v
 ^ <
or:
 >abcdef?v#
 ^ <
But in Kak+- it is only:
 >abcdef\ (\ (\v#
 ^ <
Because ! and ? is combined in to \ and ; is deleted
Category:Languages Category:Turing complete Category:Turing tarpits Category:Two-dimensional languages
Kak+--

Kak+-- is another two-demensional derivate from Kak
==Commands==
Command 	Meaning
+ 	if IP moves: 
*Right - move memory pointer to the right and flip bit
*Left - move memory pointer to the left
*Down - program stops
*Up - skip next instruction if zero
<, >, v, ^	same as in Kak+
It also has mapped IO:
*Flip bit 5 if you want input or output. If IO bits(7-14) is empty, input character and store it binary value in these bits. Else output bits 7-14
*Program starts in bit 6
*7-14 - IO bits
Category:Languages Category:Two-dimensional languages Category:Turing complete Category:Turing tarpits
Kak-

Kak- is esolang that minimises Kak. It has 2 commands. The programm is inside loop that end if by the end of the program bit is 0.
==Commands==
 ! - same as Kak
 I - skip next instruction if bit is 0 and move pointer left
==Translation to Kak==
Kak	Kak-
< 	I followed by space
! 	!
? 	I*instruction*!I !
Category:Unimplemented Category:Languages Category:Unknown computational class
Kak--

Kak-- or USLAK (Useless language Kak) is a language derived from Kak-. Like other languages based on Kak the program is inside loop, that end only if bit is zero 
==Commands==
 ! and space before and after it - same as in Kak- and Kak
 !! - move pointer to the left and goto !!!! if 0
 !!!! - NOP
==Transition to Kak-==
Kak-	Kak--
! 	!
I 	!! *instruction(s)* !!!!
Kalgarn

It is also made to simplify the programming language.
== Variables ==
There are 28 normal variables. They are 子丑寅卯辰巳午未申酉戌亥甲乙丙丁戊己庚辛壬癸天地人日月星.
All of them are infinity, signed, integer and initialized to 0.
== Commands ==
=== Assignment and initialization ===
赋你我
加你我
减你我
乘你我
商你我
剩你我
判你我
=== Constants ===
零一二三四五六七八九十百千万亿兆京垓秭穰沟涧正载极
=== I/O ===
赋值入
赋出值
== Example ==
=== Hello, world! ===
赋子八
加子子
赋丑子
加丑丑
赋寅丑
加寅寅
赋甲八
加甲寅
赋出甲
赋甲一
加甲四
加甲丑
加甲寅
赋出甲
赋乙四
加乙八
加乙丑
加乙寅
赋出乙
赋出乙
赋丙一
加丙二
加丙四
加丙八
加丙丑
加丙寅
赋出丙
赋甲四
加甲八
加甲丑
赋出甲
赋出丑
赋甲一
加甲二
加甲四
加甲子
加甲寅
赋出甲
赋出丙
赋甲二
加甲子
加甲丑
加甲寅
赋出甲
赋出乙
赋甲四
加甲丑
加甲寅
赋出甲
赋甲一
加甲丑
赋出甲
赋甲八
加甲二
赋出甲
=== 1-digit A+B ===
赋丙入
减丙八
减丙八
减丙八
减丙八
减丙八
减丙八
赋地入
赋地入
加丙地
赋出丙
=== 1-digit Absolute value ===
赋丙入
减丙八
减丙八
减丙八
减丙八
减丙八
减丙八
赋甲丙
乘甲二
加丙甲
赋出丙
== See also ==
Emoji-gramming
== Categories ==
Category:Languages
Category:2024
Category:CJK
Category:Turing complete
Kappa

Kappa, a new working lang in javascript
# examples
 // WebSocket Connections
new WebsocketConnection {example.com/api}.then(onConnection += {
 console.log("Connected to" + websocketConnection + "!")
} += )
ifn(WebsocketConnection = "200") {console.log("There was a 200 error responce connecting to" + WebsocketConnection).then(onConnection += {
 onConnection.stop()
} += )
 // Vars
Points = "1"
console.log("You have" + Points + "points")
 // Localhost Website
new InternetConnection {127.0.0.1}.then(onConnection += {
 console.log("Your website is running on" + InternetConnection)
} += )
on("Connection").console.log(connection.address + "connected to" + InternetConnection)
on.new(Error).then(connection += {
 connection.close()
 connection.stop()
 InternetConnection.stop()
} += )
Kardz

Kardz is an esoteric programming language based on brainfuck.
=Overview=
Symbol	Description
# 	Insert on top of the stack.
* 	Remove from the top of the stack.
> 	Place the first element of the stack on the bottom of the stack.
< 	Place the last element of the stack on the top of the stack.
~ 	Apply operation to stacks rather than cards.
+ 	Increment card value.
- 	Decrement card value.
, 	Read from stdin.
. 	Write to stdout.
[] 	Loop
{} 	Comment
=Examples=
TBA
Category:Languages
Category:2022
Category:Stack-based
Category:Cell-based
Category:Turing complete
Category:Brainfuck derivatives
Category:Two-dimensional languages
Category:Implemented
Category:Low-level
Kate

Kate - esoteric programming language created by User:Kamish.
==Commands==
The language consists of only one command—Kate—but like in Chicken, different amounts of Kates on a line (and, in this case, varying capitalization) differentiates commands.
Command 	Description
Kate Kate 	the text output to the screen
Kate 	program start
Kate Kate Kate Kate	the output from the interpreter
KaTe KaTe KaTe 	subtract numbers
KAte KAte KAte 	adding numbers
KATe KATe KATe 	number division
KatE KatE KatE 	multiplying numbers
Kate Kate KatE 	create a secret text file
Language is as useless as RELATIONS.
==Hello World!==
Kate Kate
hello world
Kate
Category:Languages Category:Total Category:Unusable for programming Category:Unimplemented Category:2019
Kava

Kava is an esolang created by User:Ractangle
==Commands==
Commands 	Action
Kava.fuction 	Creates a function
print 	Prints something
variable 	Declares a variable
if...?/unless...?	Conditional
user 	Gets user input
plug *library* in	imports a library
: 	Either halts the program or end a function
==Examples==
===Hello, world!===
 Kava.function main;
 (print|Hello, world!|:)
===Truth-machine===
 plug var in;
 Kava.function one;
 (print|1|;f[one||:])
 Kava.function main;
 (var|i;(user)|
 if [i=1]?=f[one||]
 unless?=print|1|:)
Category:LanguagesCategory:2024
Kcidea

kcidea is a language that makes you feel immense pain like you are on fire when you use it. it is comparable to the active denial system.
== commands ==
the only people stupid enough to use this have provided documentation for some of these commands:
 [] brainfuck but this excludes on 56 and 0
 i increments by 7
 p
 L + ratio decrements by 3
 <
 %
 &
 @ adds user input to stack and pops bottom to nowhere
 #
 9999 adds 9999 to every item in the stack GET ME OUT OF HERE AAAAAAAA
 q
 : pops top of stack ( 16=a 27=b it hurts so much i cant get anything else out of it)
 (|
 ]
 **#
Category:Languages Category:Joke languages Category:Stack-based
Kentarg

Kentarg is a programming language created by Javaveryhot (talk).
The project was started at 6 February 2020 and released (with version 0.0.0) at 14 February 2020.
Kentarg program files uses the *.keg file extension.
NOTE: In and after version 0.1.6 the file extension is changed to *.ke !
== Examples and basic syntax ==
Kentarg language "Hello, world." example:
print [Hello, world.]
Where "print" is the command and "Hello, world." is the first argument.
The [ and ] keeps "Hello, world." as one argument instead of two. If the [ and ] would not be used, the program would think that you would type ("Hello," and "world.") as the arguments, as this programming language uses single spaces to split up arguments.
Syntax:
command arg1 arg2 [arg3 arg3] arg4
Commands are split up with semicolons ( ; ), so a script would be:
print [Hello, world.];
print [Second line];
print Third_line;
== Variables ==
To define or set a value to a variable, use the "put" (older versions use "define"), or the "get" command.
"put" command syntax:
put x this_is_my_variable
"get" command syntax:
get x
When using the "get" command, the user will have to type something (length of input has to be +1, not "").
In the "put" example above, "x" will be set to "this_is_my_variable", and in the "get" example, the value of "x" would be set to whatever the user inputs.
To include a variable in a command, using "print" in this example:
print ^(x)
and if "x" is "this_is_my_variable" then the terminal would print "this_is_my_variable".
To delete a variable, use the "break" command, with the variable name as the first argument.
Making a script variable:
You can make variables scripts, it would still be a normal variable with a value of a script:
~handle x
print ^(y)
~
The above example puts the existing variable (variable must already exist before handling it) "x" to the value of "~handle x;print ^(y);".
The tilde (~) exits variable handling mode.
Difference between "put" and "~handle":
The "~handle" command may just seem to be a script formatter, but doing the above handle code does not do the same thing as using "put x [print ^(y)]".
Why:
Because if the "y" variable already exists, then if the "put" method would be used, the variable "x" would become "print value_of_y" if "value_of_y" would be the value of the "y" variable.
To execute a variable script, you can use first this to define the script:
put x [print Hello!]
and then this to execute the script:
rar x
The "rar" command executes whatever variable is the first argument,
which in this case is "x" which has the value of "print Hello!".
PAGE IS NOT COMPLETE YET!
NOTE: Different versions may have different command names and syntax, this wiki is using the latest version.
Category:Languages Category:2020
KerbalEngineer

KerbalEngineer enjoys creating esoteric programming languages on his his/her/its free time (he/she/it may or may not have any). KerbalEngineer's true name is <deleted>, and he he/she/it lives at <deleted's place of residence>. He He/she/it is currently <deleted's age> years old and hopes to be a hopes to be a/is currently a <deleted's ideal job>. Languages created so far:
* Chem
KeyF

KeyF is an esolang invented by User:None1.
==Execution==
KeyF uses a simplified version of computer keyboard:
 1 2 3 4 5 6 7 8 9 0
 Q W E R T Y U I O P
 A S D F G H J K L
 Z X C V B N M
 _________
(_________ is the space bar)
There is a pointer that starts at F.
===Commands===
 < Move pointer to leftmost key above and adjacent to current key. for example, F -> R, if there's no such key, do nothing
 > Move pointer to rightmost key above and adjacent to current key. for example, F -> T, if there's no such key, do nothing
 v Move pointer to the rightmost key under the current key. for example, F -> V, if there's no such key, do nothing
 ^ Move pointer to the leftmost key under the current key. for example, F -> C, if there's no such key, do nothing
 . Press the key
 , Press the key and shift simutaneously
 ! Press caps lock
 ? Press enter
BORING, so let's add some restrictions, the pointer must stop at K in the end, and should reach U first then C before the end.
To say it more simply, fuck must be a subsquence of all the keys the pointer reached.
==Examples==
===Print FUCK===
 !.>v>v>.^^<^<^.>>v>v>v>v.
===Print HI===
 !>v>v.>v>.^<^^<^<^>>v>v>v>v
===Print line feed===
 ?>v>v>^^<^<^>>v>v>v>v
===Hello World!===
 >v>v,<^<^<^<.v>v>v>v>v>v>v..<.^^<^^.<<<,v>v>v>v>v>v>v>.^<^<^<^<^<.v>v>v>v>v>v.<^<^<^<^<^<^.<^<^<<,vvv>v>v>v>v>v>v>
Yes, I spent 16 minutes writing it.
==Interpreters==
===Python===
The esolang is simple, yet making an interpreter is hard.
import re
keys={'0': ' pp',
 '1': ' qq',
 '2': ' ww',
 '3': ' ee',
 '4': ' rr',
 '5': ' tt',
 '6': ' yy',
 '7': ' uu',
 '8': ' ii',
 '9': ' oo',
 '_': 'xn ',
 'a': 'qwzz',
 'b': 'gh__',
 'c': 'df__',
 'd': 'erxc',
 'e': '33sd',
 'f': 'rtcv',
 'g': 'tyvb',
 'h': 'yubn',
 'i': '88jk',
 'j': 'uinm',
 'k': 'iomm',
 'l': 'op ',
 'm': 'jk ',
 'n': 'hj__',
 'o': '99kl',
 'p': '00ll',
 'q': '11aa',
 'r': '44df',
 's': 'wezx',
 't': '55fg',
 'u': '77hj',
 'v': 'fg__',
 'w': '22as',
 'x': 'sd__',
 'y': '66gh',
 'z': 'as '} # Keys in a keyboard
code=input()
shiftkeys=')!@#$%^&*('
k='f'
reached_keys='f'
output=''
caps=False
def printkey(x,shift):
 if x.isalpha():
 return (x.upper() if (shift!=caps) else x.lower())
 if x=='_':
 return ' '
 return (shiftkeys[int(x)] if shift else x)
for i in code:
 if i in '<>^v':
 temp_k=keys[k]['<>^v'.index(i)]
 if temp_k!=' ':
 k=temp_k
 reached_keys+=k
 else:
 if i=='.':
 output+=printkey(k,False)
 if i==',':
 output+=printkey(k,True)
 if i=='!':
 caps=(not caps)
 if i=='?':
 output+='\n'
if not re.search('u(.*)c',reached_keys) or k!='k':
 raise Exception('Invalid program')
print(output)
Category:Languages
Category:Joke languages
Category:2024
Category:Output only
Category:Total
Category:Implemented
Keya

Keya is a language based on the idea of Brainfuck invented by Krishna Sudhakar. it is like Brainfuck, but with a 2-D memory grid instead of an array.
==Commands==
Keya is not compatible with programs written in Brainfuck. The command set is as follows:
Command	Description
8 	Move pointer up by one row.
2 	Move pointer down by one row.
4 	Move pointer left by one cell.
6 	Move pointer right by one cell.
r 	Reset to initial configuration.
. 	Output the data at the Pointer.
, 	Input data at Pointer.
+ 	Increment byte at the Pointer.
- 	Decrement byte at the Pointer.
> 	Copy data to next cell to the right of the Pointer.
< 	Copy data to next cell to the left of the Pointer.
^ 	Copy data to next cell above the Pointer.
_ 	Copy data to next cell below the Pointer.
[ 	If the byte at the Pointer is zero, then instead of moving the instruction pointer forward to next command, skip it forward to the command after the next corresponding ] command.
] 	If the byte at the pointer is nonzero, then instead of moving the instruction pointer forward to the next command, skip it back to the command after the previous corresponding [ command.
==External resources==
* Keya: Fuck you, that's why!
Category:Languages
Category:Brainfuck_derivatives
Category:Implemented
Category:Turing complete
Category:Cell-based
Category:2014
Keys

Keys is a joke language created by User:A.
==Syntax==
Keys will end programs with 2 states kept: One is accepted, one is non-accepted. Making the keys (the first line) and the lock (the second line) match is sufficient for changing the state from non-accepted into accepted.
===Example programs===
This is an accepted program:
\_/--\_/--
\_/--\_/--
This is not:
\_/--\_/-_
\_/--\_/--
They do not match; and the carves of the keys or locks cannot change from - to _ and vice versa; otherwise it would be impossible to insert the key to unlock the lock.
This is also not an accepted program:
\/_
/\-
There are two more things to know: If the preceding code is /, then the next byte in theprogram should not change to _. If the preceding code is \, then the next byte in the program should not change to -.
==Implementations==
A Python interpreter by User:Bangyen.
Category:Joke languages
Category:2019
Category:Implemented
Category:Finite state automata
Category: Languages
Keystone

Keystone is an esoteric programming language made by User:AmNow, and was made for the purpose of creating and checking product keys.
== Commands ==
A variable can be declared with name ⇠ value.
While loops are declared with w … end, If statements are declared as i … [n …] d (n is else) Checking and generating is done with ch(key,rulelist) and ge(key,rulelist). I/O is pr() and u().
=== Layout ===
A layout is defined with [], and looks like this:
[###-XXX-&&&]
Essentially, # only allows for 0-9, X only allows for A-Z and & allows for both 0-9 and A-Z, - creates sets for rulelists.
=== Rulelist ===
A rulelist is defined with {} and looks like this:
{(s(1)==(2,3,5,7)),(s(2)+s(1)%7!=1)}
“s” references the sets that a layout has. s(1) is the first set, s(1)(1) is the first letter/number in the set.
== Programs ==
=== Generate a Windows 95 CD key ===
 lay ⇠ [###-#######]
 pr(ge(lay,{(s(1)!=(333,444,555,666,777,888,999)),(sum(s(2))%7==0),(s(2)(7)!=0),(s(2)(7)<=7))}))
Category:LanguagesCategory:2021Category:Unimplemented
Keywords

Keywords is a programming language that seems normal
== Normal stuff ==
=== Print ===
 1 print “hi”
=== Funcs ===
 1 def hi:
 2 print “hi”
 3 hi
==== Return ====
 1 def same (a):
 2 return a
 3 same 1 #1
=== Operations ===
 1 1+1
 2 2*2
 3 3^3
 4 4-4
 5 5/5
 6 6throot(6)
=== End ===
 1 end
=== Line Numbers ===
 1 print “every line starts with line number like BASIC”
 2 end
== Wait... ==
Where are the variables
 1 end = “hello” #assigned a keyword
 2 print end #hello
 3 4 = “print 4” #line 4 is now print 4
 4 print 4 #line 4 is turned into this after line 3 is ran, prints “print 4”
Category:Languages
Khartridge

:This specification is still a work in progress. Things may and probably will change.
Khartridge is a specification for an esoteric form of data storage by User:Rdococ.
== Storage ==
Data on the Khartridge is stored in up to 2KB of rechargeable battery-backed RAM that charges when used. This means that if you haven't played your favorite game for a long while, and want to get some of those nostalgia feels, then too bad. The average life of the battery should be 3 months and 4 days.
== Appearance ==
The Khartridge assumes the appearance of a bulky red rectangle, not unlike a closed 3DS. The rechargeable batteries are exposed on the back, and if they fall out, say goodbye to your software. Khartridges may have artwork on the front, but not on the back.
== Uses ==
The Khartridge is one of the few forms of physical media that can modify itself, and execute self-modifying code. Thus, it would achieve its highest potential when used in conjunction with devices that can process self-modifying code.
Category:Self-modifying
KickMe

KickMe is an object-oriented language which inverts traditional notions of member accessibility and data encapsulation.
== Member accessibility ==
The following set of access specifiers are valid in KickMe, and are applicable to both class attributes and methods:
* antiprivate restricts access to only other classes, blocking any access from the current class and its subclasses.
* antiprotected restricts access to only other classes, or subclasses of the current class, blocking any access from the current class.
* antipublic totally restricts access, blocking any access from any class. This is the default behavior of a class member.
Under no circumstances may a class access its own members.
==External resources==
* Main Github repository
Category:Languages
Category:High-level
Category:Object-oriented_paradigm
Category:Unimplemented
Category:2014
Kicky BCT

Kicky BCT is a Esolang by User:Yayimhere. its a modified version of a BCT. it comes from two things: a misunderstanding on the ResPlicate page, and the creators hate to the fact that the datastring is not represented in the program 
== what has changed? ==
in Kicky BCT the datastring is the actual program making Kicky BCT self-modifying. so this example program:
 0011
evolves like this: 
 0011
 011
 11
 111
 1111
 11111
 ...
there's also some extra syntax:
* if theres a 1 after a 1 then if it also has a valid thing after it it will also be ran as a 1 command(so 111 would add 11)
== random examples ==
 110100
this evolves like this:
 1101001
 1101000
 10100
 101000
 0100
 100
 1000
 000
 00
 0
 *halts*
Category:Languages Category:Unimplemented Category:Low-level
Kill

Kill is a one-word, Python-interpreted, joke programming language created by User:CMinusMinus.
The sole purpose of this language, is to delete the code.
The only legal program is
 !
Command	Action
! 	Delete code
==Example programs==
===Hello World===
Impossible.
===Fibonacci===
I don´t even know what this is.
===Cat===
I like cats.
==Interpreter==
The interpreter is written in Python 3.7.
Technically, there are only 7 lines of code, but to make it longer,
User:CMinusMinus decided to write a story.
The 6-line-story is about a robot, that kills his creator.
It ends with "Dont do drugs, kids."
==External resources==
* Interpreter on Github
Category:Languages
Category:Implemented
Category:Unusable for programming
Category:Finite state automata
Category:2019
Killme

Killme is a stupid language 
==Commands==
 i if
 t then
 ei end if
 l loop
 el end loop
 = equal
 < less than 
 > more than 
 P print
 “value” add value to stack
==Encrytion==
 R|0|1|2|3|4|5|6|7|8|9|A|B|C|D|F|E|G
 0|A|7|4|G|5|0|2|3|D|F|9|B|6|1|C|8|E
 1|C|8|E|A|7|4|G|5|0|2|3|D|F|9|B|6|1
Under R:
Line mod 2
Next to R:
Charcter’s ASCII base 17
===Encryting===
i->105->63->2G->50->2
i-ascii
ascii-base17
base 17-encrypted base 17
encrypted base 17-decimal
decimal-2
i-2
Kind n' Single

Kind n' Single is an esolang created by User:Yayimhere based on Category theory
== System ==
you can define a variable. it can be recursively defined. there is a single operator that takes a single argument and a single one that takes two arguments: 
\x returns the monad of x where the identity element is just empty, and the operator returns the id element (always) unless one of the arguments is the id element then it returns the original none id element
+x y returns a category that has both elements of x and y and a object that has a morphism to all elements in the category
there are these constanats:
 v is a category with two elements that both morphism to each other(two way)
 o empty category
to define a variable:
 x = y
and this is a comment:
 /* comment */
Category:Languages Category:2024 Category:Unknown computational class
Kipple

Kipple is a minimalistic esoteric programming language with a set of stacks, four operators, and a single control structure. Kipple was designed by Rune Berge in March, 2003.
==Stacks==
The stacks are named a-z and contain 32-bit signed integers. There is also a special stack, @, to make outputting numbers more convenient. When a number is pushed onto @, the ASCII values of that number's digits are in fact pushed instead. The @ stack is an example of a wimpmode.
Input is pushed onto stack i before the program is executed; after execution finishes, anything on stack o is popped to output. Since this is Kipple's only IO mechanism, interacting with a Kipple program is impossible.
==Operators==
An operand can either be a stack identifier or a nonnegative integer (0 to 2147483647).
 > Push left operand onto right stack
 < Push right operand onto left stack
 + Push the sum of the right operand and the topmost item of the left stack onto the left stack
 - Push the topmost left stack item minus the right operand onto the stack
 ? Takes only one operand; clears the left stack if its topmost item is 0
< and > are the same operator, working in different directions. If the right operand of <, + or - or the left operand of > is a stack identifier, its top value is popped and used as the operand instead. The topmost item of an empty stack is considered to be 0, and popping from an empty stack always return 0.
If the right-hand operand of one operator matches the left-hand operand of the next, they can be merged, e.g. a<b b>c can be written as a<b>c.
The string preprocessor is not a standard, but the official interpreter supports it.
==Control structure==
The control structure is
 (stack-identifier code)
where stack-identifier is a-z and code is any sort of code, possibly including additional loops. The code will be run as long as the stack is not empty.
==Examples==
===Hello, world!===
This program prints "Hello World!":
 33>o 100>o 108>o 114>o 111>o 87>o 32>o 111>o 108>o 108>o 101>o 72>o
Alternate version using the string preprocessor:
 "Hello World!">o
===Cat===
A program that copies its input to output, like UNIX cat.
 (i>o)
===Reverse cat===
 (i>p)(p>o)
===Fibonacci numbers===
Prints the first 25 numbers of the Fibonacci sequence. 
 24>n 0>t 1>a
 (n-1
 a+0
 t<a>b+a
 c<b>a<c
 n?
 )
 (t>@
 (@>o)
 32>o
 )
The first loop generates the numbers, and the second loop converts them to ASCII.
==Computational class==
Kipple is Turing-complete; a direct proof by simulation is provided in the form of this Brainfuck interpreter written in Kipple, since Brainfuck is known to be Turing-complete.
==External resources==
* - The official Kipple home page. Contains spec, programs, implementation, and online interpreter (Java applet).
* in ORK by Gregor Richards.
* , a very fast Kipple interpreter in C by Jannis Harder.
* Kipple in the Esoteric File Archive.
* Interpreter in JavaScript by User:None1 (online interpreter based on the JavaScript interpreter)
Category:Languages
Category:Stack-based
Category:Non-interactive IO
Category:Turing complete
Category:Turing tarpits
Category:Implemented
Category:Low-level
Category:2003