nyuuzyou/wikis huggingface dataset:
Kiss

Kiss is an esolang invented by User:Hakerh400 in 2023.
== Overview ==
Kiss is a derivative of the SKI combinator calculus. It has combinators K and S. These two rewriting rules can be applied anywhere in the expression:
 K a b ---> a
 S a b c ---> a c (b c)
When the head of the main expression cannot be reduced any longer, the following rules can be applied to the head of the main expression:
 K ---> Terminate the program with zero exit code
 S ---> Terminate the program with non-zero exit code
 K a ---> Output bit 0 and reduce the main expression to `a`
 S a ---> Output bit 1 and reduce the main expression to `a`
 S a b ---> Input a bit and reduce the main expression to `a` if the bit is 0, or to `b` otherwise
== Examples ==
=== Cat with a single bit ===
 S (K K) (S K)
Category:Languages
Category:2023
Category:Turing complete
Category:Functional paradigm
Category:Unimplemented
KittyKittyMewMew

KittyKittyMewMew is a language created by user:ryanninjasheep to be as easy to make a cat program in as possible.
== Programs in KittyKittyMewMew ==
Cat programs are the only possible thing you can make in KittyKittyMewMew. The code is quite simple.
 MEOW
This code will output anything that is given as an input.
== Interpreters for KittyKittyMewMew ==
They're really easy to make.
=== Ruby ===
 C = {/M/ => "pu",/O/ => ' g',%r,W, => "ets",/E/=>%%ts%,/.*[^OpuWtMsEge\t \n]/=>"puts 'invalid code'#"}
 def run_code code
 eval(C.to_a.inject(code){|x,y| x.gsub y[0],y[1]})
 end
=== Python 3 ===
 class StupidPersonError(Exception):
 pass
 
 alphys = input()
 if alphys != "MEOW":
 raise StupidPersonError("That's not right")
 
 print(input())
Shorter one:
 print(input() if input()=='MEOW' else 'Invalid code')
Category:Languages Category:Joke languages Category:Implemented Category:Total Category:Unusable for programming Category:Finite state automata Category:2014
Kiwiscript

Kiwiscript is a programming example that was developed by User:Cinnamony. It prints "kiwi" (in lowercase letters, if possible).
==Examples==
===->===
 k -> [107]
 i -> [105]
 w -> [119]
 $(k)$(i)$(w)$(i)
===Battlethought===
 think
 print("kiwi")
 TERMIANTE
===BF===
 ++++++++++[>++++++++++<-]>+++++++[<+>-]<.--.++++++++++++++.--------------.
===BF253===
====Version 1.0-1.3====
 ++++++++++[>++++++++++<-]>+++++++[<+>-]<.--.++++++++++++++.--------------.
====Version 1.4====
 ++++++++++[>++++++++++<-]>+++++++[<+>-]<.-_+++++++++++++=-------------_
====Version 1.5.1-present====
 K
=== dolfins grace ===
 >"iwik"^^^^<
===Globglogabgalab===
 I am the Globglogabgalab
 The kwabble iwabble wwabble iwabble
===Grounded===
 make plushie movie series // hour 1 of day 1
 make plushie movie // hour 2 of day 1
 make book // hour 3 of day 1
 watch steven universe // hour 4 of day 1
 make plushie movie series // hour 5 of day 1
 uninstall app on tablet // hour 6 of day 1
 make book // hour 7 of day 1
 watch adventure time // hour 8 of day 1
 make plushie movie series // hour 9 of day 1
 make plushie movie
 make plushie movie // hour 11 of day 1
 make book // hour 12 of day 1
 watch steven universe // hour 13 of day 1
 make book // hour 14 of day 1
 sleep // yay sleep
 daydream // 15 out of 42 (1 local)
 daydream // 16 out of 42 (2 local)
 daydream // 17 out of 42 (3 local)
 daydream // 18 out of 42 (4 local)
 daydream // 19 out of 42 (5 local)
 daydream // 20 out of 42 (6 local)
 daydream // 21 out of 42 (7 local)
 daydream // 22 out of 42 (8 local)
 daydream // 23 out of 42 (9 local)
 daydream // 24 out of 42 (10 local)
 daydream // 25 out of 42 (11 local)
 daydream // 26 out of 42 (12 local)
 daydream // 27 out of 42 (13 local)
 daydream // 28 out of 42 (14 local)
 sleep
 daydream // 29 out of 42 (1 local)
 daydream // 30 out of 42 (2 local)
 daydream // 31 out of 42 (3 local)
 daydream // 32 out of 42 (4 local)
 daydream // 33 out of 42 (5 local)
 daydream // 34 out of 42 (6 local)
 daydream // 35 out of 42 (7 local)
 daydream // 36 out of 42 (8 local)
 daydream // 37 out of 42 (9 local)
 daydream // 38 out of 42 (10 local)
 daydream // 39 out of 42 (11 local)
 daydream // 40 out of 42 (12 local)
 daydream // 41 out of 42 (13 local)
 daydream // 42 out of 42 (14 local)
 sleep
===imput===
 kiwi
===Minecode===
 log(1,pencil,kiwi)
 go_page(1)
 find(copper)
===Numeric===
 40
 40 115 97 121 32 107 105 119 105 41
 40 115 116 111 112 32 34 91 116 104 105 115 32 115 99 114 105 112 116 93 34 41
 41
===:]===
 :0 "kiwi"
 :(
===Befunge===
 "iwik",,,,@
===8xn===
1111131193111111111191111111>6226111111111111116222222222222226
===Stringle===
 $ "kiwi"
===SDOTOS===
ikfptiifptiwfptiifpt
===wenyan===
吾有一言。曰「「kiwi」」。書之。
==See also==
* Nope.
* No.
Category:Program formsCategory:2023
Category:Nope. derivativesCategory:LanguagesCategory:ImplementedCategory:Unusable for programmingCategory:TotalCategory:Joke languagesCategory:Zero-dimensional
Klein

Klein is a 2D esoteric language with flexible topology designed by Stack Exchange user Wheat wizard.
== Surfaces ==
Currently Klein supports 12 distinct topological surfaces.
A topology is denoted by 3 numbers. Each of the surfaces is represented by a
fundamental square.
=== First number ===
The first bit represents which edges the north edge connects to. If it is 0 the north edge connects to its
opposite, (that is a pointer moving off the north edge will appear on the south edge and a pointer moving off the west will appear on the east).
If it is 1 the north edge will be connected to the east edge.
If it is 2 the north edge connects to the west edge.
The other edges (not the north or the edge it connects to) will connect to each other.
=== Third number ===
We are going to skip the second number and come back to it hopefully this makes things clearer
This determines the whether the north edge has the same direction as its match.
If it is 0 the directions match other wise the directions are opposite.
=== Second number ===
This determines the whether the other pair of edges have the same direction.
If it is 0 the directions match other wise the directions are opposite.
== Memory ==
The memory is stored in a stack and a scope. Both are stacks padded with zeros at the bottom.
At the end of execution the contents of the stack are printed.
Like most 2D languages the ip starts in the upper lefthand corner moving east.
== Commands ==
=== Mirrors ===
* \ Swaps the x and y directions
* / Swaps the x and y directions and multiplies them by -1
* | Multiplies the horizontal direction by -1
=== Directions ===
* > Tells the ip to move east
* < Tells the ip to move west
=== Doors ===
* [ Reflects the ip if it is moving east; becomes ] if the ip is moving horizontally
* ] Reflects the ip if it is moving west; becomes [ if the ip is moving horizontally
=== Jumps ===
* ! Skips the next operation
* ? Pops off the top of the stack and jumps if not zero
=== Stack manipulation ===
* : Duplicates the top of the stack
* $ Swaps the top two items of the stack
* ( Pops from the stack and pushes to the scope
* ) Pops from the scope and pushes to the stack
=== Literals ===
* 0-9 pushes n to the top of the stack
* " Starts and ends a string literal. During a string literal commands are not run and instead their character values are pushed to the stack.
=== Operations ===
* + Adds the top two numbers
* * Multiplies the top two numbers
* - Multiplies the top by -1
=== Control ===
* @ Ends execution
== External resources ==
Implementation by the language's creator.
Category:Languages
Category:Two-dimensional languages 
Category:Self-modifying 
Category:Stack-based‏
Category:Implemented
Category:2017
Kleinfunge

Kleinfunge is a topology-oriented 2-dimensional fungeoid.
== Commands ==
Basic Fungeoidal Commands	Basic Fungeoidal Commands
Command 	Description
< 	Start going in direction 1
> 	Start going in direction 2
^ 	Start going in direction 3
v 	Start going in direction 4
| 	Pop a value off the stack. If 0, start going in direction 1. Else, start going in direction 2.
_ 	Pop a value off the stack. If 0, start going in direction 3. Else, start going in direction 4.
Utility Commands 	Utility Commands
Command 	Description
. 	Pop a number and print its unicode equivalent
, 	Get a character and push its unicode value
Topological Commands 	Topological Commands
Command 	Description
] 	Pop a value off the stack called d. d=(d%4)+1. Pop a value off the stack and call it r. r=r%9. Rotate direction d counterclockwise by r*45 degrees.
[ 	Pop a value off the stack called d. d=(d%4)+1. Pop a value off the stack and call it r. r=r%9. Rotate direction d clockwise by r*45 degrees.
0 	Pop x1, pop y1, pop x2, pop y2, Create a Stargate (1-way wormhole) from (x1, y1) to (x2, y2)
Category:Languages
Category:Two-dimensional languages
Category:Stack-based
Klon

Klon is a programming language created by User:KlonMac7.
==Commands==
 left -Moves the pointer to the left
 right -Moves the pointer to the right
 in -Sets cell value
 out -Prints cell value
 con -User input
 cls -Clears cell
 copy -Copies cell value
 paste -Pastes cell value
 exit -Exits the program
 + -Adds value to cell
 - -Subtracts value from cell
 * -Multiplies cell value by value
 / -Divided cell value by value
==Examples==
===Hello world===
 in Hello_world
 out
===User input===
 in Whats_your_name_?
 out
 cls
 in Hello_
 con
 out
Prints: "Hello_<input>".
===Cell operations===
 in 1
 right
 in 2
 right
 in 3
 out
 left
 out
 left
 out
Prints "321".
 in Hello
 copy
 out
 right
 paste
 out
Copies the value from the first cell and paste it into the second cell.
 in 5
 + 5
 out
Prints the result of "5+5"
 in 5
 - 5
 out
Prints the result of "5-5"
 in 5
 * 2
 out
Prints the result of "5*2"
 in 10
 / 2
 out
Prints the result of "10/2"
==Interpreter in Batch==
 @echo off
 setlocal enabledelayedexpansion
 if not exist klon.p exit /b
 set p=0
 for /f "tokens=1-3" %%i in (klon.p) do call :cmd %%i %%j
 exit /b
 :cmd
 if %1==left if not %p%==0 set /a p-=1
 if %1==right if not %p%==32767 set /a p+=1
 if %1==in set p%p%=!p%p%!%2
 if %1==out echo !p%p%!
 if %1==con set /p v=&set p!p!=!p%p%!!v!
 if %1==cls set p%p%=
 if %1==copy set t=!p%p%!
 if %1==paste set p%p%=!p%p%!%t%
 if %1==exit exit /b
 if %1==+ set /a p!p!+=%2
 if %1==- set /a p!p!-=%2
 if %1==* set /a p!p!*=%2
 if %1==/ set /a p!p!/=%2
 goto :Eof
Category:Languages Category:Cell-based Category:Implemented Category:2012 Category:Total Category:Unusable for programming
KnightJump

KnightJump is a two-dimensional esoteric programming language created by User:Слон из ЖЕЛЕЗА, where instruction pointer moves like a Knight from chess.
==Execution==
There is a stack and the only type is an arbitrarily-sized decimal. Program is like torus: if instruction pointer goes into void, it will appear from other side.Instruction pointer has 8 directions to move:
 n┬N 
 W │ E
 ├─♘─┤
 w │ e
 s┴S 
===Commands===
====Version 1.0====
Command 	Description
N,n,E,e,S,s,W,w	Changes direction
H 	Changes direction: (mirror)
 N: W, E: S,
 n: E, e: N,
 S: w, W: s,
 s: e, w: n.
$ 	DUP
\ 	SWAP
% 	DROP
+ 	Takes two elements from the stack and pushes the sum. (x y -> x+y)
- 	Takes two elements from the stack and pushes the (second-first). (x y -> x-y)
* 	Takes two elements from the stack and pushes the product. (x y -> x*y)
/ 	Takes two elements from the stack and pushes the (second/first). (x y -> x/y)
^ 	Takes two elements from the stack and pushes the second to the power of first.(x y -> x^y)
> 	Takes two elements from the stack and if second is greater than first, pushes 0, else pushes 1.
< 	Takes two elements from the stack and if second is less than first, pushes 0, else pushes 1.
= 	Takes two elements from the stack and if they are equal, pushes 0, else pushes 1.
; 	Outputs an element from the stack. (without deleting it)
: 	Inputs an integer and pushes it to the stack.
? 	Inputs a character and pushes its code to the stack.
! 	Outputs a character.
# 	Takes an element from the stack. Encrypts all the commands. 
(By shifting character codes by an element)
~ 	Stops the encryption.(this instruction does not get encrypted.)
@ 	Terminates the program.
====Version 1.1====
Command 	Description
& 	Reverses the stack
Every letter except N,n,E,e,S,s,W,w	Mirrors, which changes your direction based off previous one. (check mirrorbase.py if you want to know new direction)
===Numbers===
Numbers are found by the diagonal chain of 0,1,2,3,4,5,6,7,8,9. It can't go to the number it already stepped.
Finding next element in chain is done by checking 4 spots in that order:
 1 2
 N
 4 3
====Examples:====
 3 ♘ 3 
 2 4 │ 2 4 0 7
 ┌1 Number: 1234 └1 7 5 Number: 123456789 1 6 9 Number: 106790
 │ 8 6 ♘─┘5 0
 ♘ 9 
==External Resources==
Implementation
Category:2023
Category:Languages
Category:Implemented
Category:Stack-based
Category:Usability unknown
Category:Two-dimensional languages
Kolmogorov machine

A Kolmogorov machine (also known as a Kolmogorov-Uspenski machine) is similar to a Turing machine in most respects except that its storage unit, instead of an unbounded linear tape, is a particular kind of connected graph.
"Real" Kolmogorov machines are very obscure; nearly every researcher who cites Kolmogorov and Uspenski's original paper (in Russian) uses a modified model, simplified for their purposes. So, bear in mind that the following is currently only an approximation.
== Storage graph ==
The storage graph must have the Kolmogorov property, which is that, starting at some vertex, every other vertex is uniquely addressable. This was done by Kolmogorov and Uspenski by inserting intermediate 'address' vertices in an undirected graph; an alternate technique is to use a directed graph and simply to label the edges of the graph, with a different label bestowed upon each out-edge of a vertex.
The storage graph has a vertex which is thought of as the current vertex (much like Turing's tape has a read/write head that points to a current cell.) The current vertex has a neighbourhood of some fixed radius.
== Control unit ==
Also like the Turing machine, the Kolmogorov machine also has a control unit which decides what to do by looking at the storage unit. However, instead of looking for symbols, it reacts to the configuration of the neighbourhood itself - the "shape" formed by the local vertices and edges. This determines a list of actions to take, which contains instructions drawn from:
* Add a vertex to the neighbourhood;
* Remove a vertex from the neighbourhood;
* Add an edge to the neighbourhood;
* Remove an edge from the neighbourhood;
* Halt.
== Computational class ==
Kolmogorov machines are in the same computational class as Turing machines; that is, they are Turing-complete. They may, however, have efficiency advantages, due to their freedom from the restriction of a linear storage medium.
== See Also ==
*Eodermdrome, a language formulated along similar principles.
*Andrei Machine 9000
*Kolmogorov
== External resources ==
* Section 1.2.1 of Uspensky and Semenov's Algorithms: Main Ideas and Applications (1993, Kluwer Academic Publishers, ISBN 0-7923-2210-X)
* - paper by Yuri Gurevich
* "К определению алгоритма" (1958) by A.N. Kolmogorov and V.A. Uspensky
* wikipedia:Pointer machine, of which the Kolmogorov machine is a variety.
Category: Computational models
KonamiCode/Hello World

__NOINDEX__
A longer, annotated Hello World example for KonamiCode.
v(^^^^^^^>^^) [writes 72 (or H) to address 0 in memory]
>((>)) [prints it]
v(^>>^) [writes 101 (or e) to address 1 in memory]
>((>)) [prints it]
v(^>>^^^^^^^^) [etc]
>((>))
v(^>>^^^^^^^^)
>((>))
v(^>^>^)
>((>))
v(^^^>^^)
>((>))
v(^>^>^^^^^^^^^)
>((>))
v(^>^>^)
>((>))
v(^>^>^^^^)
>((>))
v(^>>^^^^^^^^)
>((>))
v(^>>)
Category:Examples
Koopas are Involved

Koopas are Involved is an esoteric programming language designed by User:Oshaboy as an edge case for discussions about whether X is a programming language (X could be HTML, Scratch, CSS, SQL, Brainfuck, Minecraft Redstone, etc.). Usually people have this idea of what a programming language looks and acts like. But Koopas are Involved challenges that notion. 
== Semantics == 
The commands are simple and straightforward
 var:=expression
 while var/expression
 goto var/expression
 read var (as a character)
 print var/expression (as an integer)
an expression can be a combination of any of the following
 (expression+expression)
 (expression-expression)
 (expression*expression)
 (expression/expression)
 (var/expression?expression:expression)
Yes the brackets are necessary, mostly because of ambiguity involving division (On a related note 6/2(2+1) doesn't have an answer, stop arguing about it).
However, a few restrictions were added to prevent you from doing anything with it.
 arithmetic expressions can only use immediate values 
 goto can only jump forwards 
 any variable can only be assigned once and used once in the program. (like Single Static Assignment, but with Single Static Use)
== Discussion ==
So I always had this idea a computer language is a programming language iff it has Data Storage, Arithmetic, Flow Control, Loops, and IO. But this programming language has the ability to do all of these and you can't do anything interesting in it (give it a try). Out of all the Popular Problems only an infinite loop is possible AFAIK. Now is Koopas are Involved a programming language if it can do everything a programming language can do but can't do much beyond it? It looks like a programming language, but looks are deceiving when Koopas are Involved.
Also I learned how to use lex and yacc. So that's neat. (on a related note, are lex and yacc programming languages?)
== Interesting Program == 
User:VilgotanL created a clever Truth Machine in Koopas are Involved. Proving the language is interesting and that the language failed in its only goal.
 read x
 goto x
 [lines 3-47 left blank]
 goto 50
 while 1 print 1
 print 0
== Implementation ==
Interpreter
Category: Languages
Category: Unusable_for_programming
Category: Implemented
Kov

Kov ([K]olmon[o]gro[v]) is a simple language invented by User:A inspired by Kolmonogrov-complexity challenges.
==Kolmogorov complexity==
In algorithmic information theory (a subfield of computer science), the Kolmogorov complexity of an object, such as a piece of text, is a measure of the computational resources needed to specify the object.
For example, the string "abababababababababababababababababababab" has a low Kolmogorov complexity because it can be produced with a simple loop:
take 40 $ cycle "ab"
Written in Kov:
"ab;(*
Explanation:
"ab # Two-byte string
 ;( # One-byte integer whose ASCII code is 40
 * # Repetition
Since ( is currently not a valid command, golfing into:
"ab # Two-byte string
 ( # One-byte integer whose ASCII code is 40
 * # Repetition
==Possible submissions==
=== Output the list of musical notes ===
Output this:
Ab A A# Bb B C C# Db D D# Eb E F F# Gb G G# 
`ABCDEFG``b°#`c
Explanation:
`ABCDEFG` # A to G
 `b°#` # Permutation with b, null character, and #
 c # Return all possible combinations separated with spaces by default
Possible golfed program:
~A…G~b°#;P
Explanation:
~ # String-in-row
 A…G # String 1: ASCII code from A to G
 ~b°# # String 2: b, null, and #
 ; # End string-in-row
 c # Return all possible combinations
=== Print beep boop bop ===
~b~`"ee"oo'o`'p;c;c
Category:2019
Category:Languages
Category:Unimplemented
Kvikkalkul

Kvikkalkul is an esoteric programming language which was supposedly developed by the Swedish navy in the fifties, though it is generally believed to be a hoax. It made its appearance on the internet in 1994 when it was posted anonymously on alt.folklore.computers.
The author of the usenet post claims that Possession of this information in Sweden can (and will in most cases) lead to Capital Punishment. It should be noted that capital punishment in Sweden was abolished on 1973-01-01. Also, by the 1950s capital punishment was only available in wartime: it was abolished for peacetime crimes on 1921-06-30. The author might be joking, or alluding to extra-judicial executions, or out of date (having used the language in the 1950s and 1960s and presuming wartime conditions).
==1000000 Hail Mary's==
An example program, provided by the author.
666/ 5
/0 -) 666
:1 -) 550
:0 -) 1010
-) :1
1010:
:1 -) 888
:0 -) 1020
-) :1
1020:
/0 -) 666
:1 -) 1030
:2 -) 1040
:0 -) 1050
:3 -) 560
.9 (- ,0
1030:
.8 (- ,0
1040:
-) :3
1050:
.8 (- .8 -/- ,0005
.8 ( ,49975 -) :2
.9 (- .9 -/- ,0005
.9 ( ,49975 -) :1
:1 -) 666
-) :1
For use, you must type in "hail mary" in the teletype, and then the program will be complete and next time it is run, will make the output. This is because some of the data used by the program must be entered the first time it is run. The program "888" means to complete the program so that it run next time with the data already filled in.
==External resources==
* 
* , contains documentation and implementations.
* 
* A page about Kvikkalkul
Category:Languages
Category:1994
Category:Unknown computational class
Category:Implemented
Category:Low-level
Königsberg

Königsberg is a esolang created by User:Yayimhere that uses a Graph. the name comes from the Königsberg bridge problem. it has pointers lines and nodes on a graph, where pointer creates nodes and line
== syntax ==
3 things can be created:
 (x, y, n)A create a node at x, y, with value n. this node is called A
 {A, B}C a line between node A and node B. this line is called C
 [A] create a pointer at node A
these are the rules. they will be executed after the definitions has been created:
* a pointer, will move to the nearest node, drawing a line between each node it moves to
* if there is the same distance between two nodes, it will split into two pointers, and each will move, to a different node
* if a line connects two nodes, with the same number, that line will be deleted
* if a line intersect another one, a node will be created where they cross
* if the number of one node(lets call it n) is n\pm \left( n\times 2 \right)\sum_{u=n}^{n^{2}}\frac{u}{n}=k^{2} where k is the value of the other node the program will halt
* if the pointer is on is a midpoint of n other nodes, a pointer will form on all of those nodes
Category:Languages
L

L is an esoteric language made by User:Phase no later than November of 2015 that only uses two accumulators.
* l increments the first accumulator
* L increments the second accumulator
* w multiplies the second accumulator to the first accumulator and stores it in the first accumulator
* \n prints the first accumulator and sets it to zero; second accumulator is not reset
= Examples =
== Hello, world! ==
 LLLllwllww
 lwwllwwll
 lwlwww
 lwlwww
 lwlwwlw
 lwlwllwll
 lwwlwll
 lwlwlwwll
 lwlwwlw
 lwlwwllw
 lwlwww
 lwwllwwl
 lwwllw
 lwwl
== FizzBuzz ==
= Interpreters =
== Python 3 ==
 import sys;file=open(sys.argv[1]);a,b=0,0;
 for c in file:
 if c=='l':a+=1
 if c=='L':b+=1
 if c=='w':a*=b
 if c=='\n':print(end=chr(a));a=0
== Befunge ==
Instructions are interpreted one char at a time. You will need to devise a way of inputting the \n character, however.
 0v<< < 
 ~ $ 
 ^|:-+29_$1+ 
 9 $ : 
 1 9 - 
 +,9 " 
 -:g 
 :$" " 
 _^ |:-"B"
 " $ 
 - 9 
 * g 
 1 
 + 
 9 
 9 
 p 
== Program Generator ==
Also written in Javascript, this function prints the L code needed to print a message, given what value of L is used. A recursive helper function L(x,l) is used to generate a message for a given number, then is used iteratively for each character in the message. l must be at least 2 for the code to work.
 const L=(x,l)=>x==1?'l':(x%l?(L(x-1,l)+'l'):(L(x/l,l)+'w'));
 function Lm(x,l){let o='L'.repeat(l);for(let c of x){o+=L(c.charCodeAt(),l)+'\n';}console.log(o);}
 
 // Lm(<string>, <L value>)
== Resources ==
* The official JS L interpreter.
* Unofficial Online JS Interpreter
Category:2015 Category:Languages Category:Implemented