nyuuzyou/wikis huggingface dataset:
Junk

Junk is a language developed by Mark Schad in 2009 which uses stacks and queues to execute instructions. Programs are written in the form of instructions which are added to a stack. When the stack runs out of instructions the program has finished running. The instructions come in the form of lists of elements, which are executed one after the other. Whenever an instruction is encountered (denoted by '[' and ']') the instruction is added to the stack. When the program reaches the end of the code it will then execute each instruction in the stack.
== Instructions ==
Instructions are made up of two components. The first component is the id of the instruction, the second component is a list of elements. This list is arbitrary in length and each element is made up of a command and an argument. All commands take a memory address as their argument except for 'push' and 'acc'. Instead of a constant integer, the '@' character may be used as an argument, and will pass the value of the accumulator into the command.
The arithmetic operators take the value in the memory and apply it to the accumulator.
 + Add
 - Subtract
 * Multiply
 / Divide
The comparison operators take the value in memory and compares it to the accumulator. If the comparison is true then execution of the remaining elements continues.
 = Equal
 ~ Not Equal
 < Less Than
 > Greater Than
These commands take user input and store it in memory and print memory to the user.
 in Input
 out Output
 out$ Output Char
The value of the accumulator can be set from memory or memory can be set to the accumulator with these commands.
 sto Store
 ret Retrieve
The accumulator can be set to a value using the following command or by setting an element to a single integer.
 acc Accumulator
Finally, an instruction can be pushed onto the stack with the following command. The argument is the id of the instruction to push.
 push Push
== Execution ==
The code is read from the source file and the instruction list is parsed. As each new instruction is parsed it is pushed onto the instruction stack. There is a block of memory with 256 addresses initialized to zero. The accumulator is also set to zero. After all of the code has been parsed the program can execute by popping an instruction from the stack and executing it. Repetition can be achieved by having an instruction push itself onto the stack. Comments can be added by simply adding text anywhere in the source that is not surrounded by a '[' or ']' character.
The hello world program in Junk.
 [0|ret 0,- 1,sto 0,+ 2,out$ @,ret 0,> 15,push 0]
 [1|32,sto 8,101,sto 4,72,sto 3]
 [2|33,sto 14,100,sto 13,108,sto 12,sto 6,sto 5,114,sto 11,111,sto 10,sto 7,87,sto 9]
 [3|12,sto 0,1,sto 1,3,sto 2,0,sto 15]
Jussef Swissen

Jussef Swissen(the name he uses is a pseudonym) is an inactive(he barely did any programming between 2014 and 2019) programmer/esoteric programming langauge enthusiast who came up with PERPLEX in 2014, which is an over-complicated version of BASIC; its complication is simply the replacement of short BASIC commands to longer(and more complicated) synonyms/replacements. It is a joke language, and the publishment of its definition did not gain much attraction.
He has also defined the Swissen Machine in 2019, a Esoteric computer architecture that does not require state transitions. In the Swissen Machine's criteria, it shows that the Swissen Machine can not do any logical computations, and it only runs on one state, which is very different from most computers architectures, which primarily operates on modifyable memory; e.g. based on bits, trits, etc. The publishment of the Swissen Machine has gained slightly more attraction, in comparison with the attention he got with his previous PERPLEX. Someone(User: A) thought that the definition of the Swissen Machine is invalid, and they modified Hugo to prove it. It has been shown later that the Swissen Machine contradicts with its own definition.
The definition of Hugo: "It implements a Swissen Machine using the environmental factor of time and End Of Files. A valid Hugo program would consist of only one number, 1. The interpreter for this language would take exactly 1 second to process each 1 that is entered in the Hugo program. Depending on the amount of seconds taken to process the entire program, it prints an ASCII character whose decimal value is equivalent to the number of seconds taken to run the program."
==See also==
* User:Jussef Swissen, his user page on this wiki
Category: People
Just

Just is a golfing esolang created by User:Ractangle that tries to use all ASCII characters (excluding control characters)
==Syntax==
 String literal
 Prints and pops the top value on the stack
 Does the same thing as but doesn't pop it
 Goes to the beginning of the line (or program if it's a one liner) when reaching the end of the program
==Examples==
===Hello, world!===
 "Hello, World!"#
===Infinite loop===
 ~
===Cat program===
 #
==Interpreter==
Just python interpreter in User:Ractangle's website repo
Category:LanguagesCategory:2024Category:Implemented
JustWords

JustWords is an esolang created by User:AnotherUser05 where the only valid characters are letters.
Syntax 	Description
Zero - Nine 	These are used for number inputs. For example, OneThreeEight would be 138.
Print(value) 	Prints "value".
(number)Plus(number) 	Adds two numbers together. For inputs.
(number)Minus(number) 	Subtracts two numbers together. For inputs.
(number)Multiply(number)	Multiplies two numbers together. For inputs.
(number)Divide(number) 	Divides two numbers together. For inputs.
(value)Equals(value) 	Equals to condition.
(value)Greater(value) 	Greater than condition.
(value)Less(value) 	Less than condition.
If(condition)Then 	Declares an if statement.
Else 	An else branch.
Loop(number) 	Loops a fixed number of times.
Forever 	Declares an infinite loop.
End 	End of a code block.
Input 	Returns the user's input.
Stop 	Terminates the program.
==Examples==
===HelloWorldProgram===
 PrintHelloWorld
===TruthMachine===
 IfInputEqualsZeroThen
 PrintZero
 Stop
 End
 IfInputEqualsOneThen
 Forever
 PrintOne
 End
 End
An alternative implementation, which queries the user once and employs the Else branch, shall be supplemented:
 IfInputGreaterZeroThen
 Forever
 PrintOne
 End
 Else
 PrintZero
 End
===NotFiniteLoop===
 Forever
 End
===CatProgram===
An infinitely repeating line-based cat program is provided:
 Forever
 PrintInput
 End
===FixedRepeatingOutput===
A Fixed Repeating Output program is supplied below:
 LoopInput
 PrintOne
 End
 PrintZero
==Interpreter==
* Common Lisp implementation of the JustWords programming language.
Category:Languages Category:Pseudonatural Category:2024 Category:Implemented
K

:For the proprietary array processing language developed by Arthur Whitney, see wikipedia:K (programming language).
:This language is still a work in progress. A very work... in... very progress.
K is an abstract, lazy esoteric computer algebra programming language by User:Rdococ, designed to use non-traditional data types.
== Overview ==
Data type	Description
boolean 	Used in boolean algebra.
integer 	A variable-size integer.
rational 	A fraction of two variable-size integers.
real 	An irrational, represented by a generalized continued fraction.
function 	A map from a set of one or more inputs to one output.
set 	A set, equivalent to a function from any input to a boolean output.
list 	A list, equivalent to a function from one integer to any output.
Construct	Example 	Description
→ 	x → 2x 	An anonymous function.
{} 	{1, 4, 5} 	A set.
in 	3 in {1, 4, 5} 	Returns if that element is in the set.
{¦} 	{k ¦ k in Reals, k % 1 = 0} 	Set-building notation for a lazy infinite set.
[] 	[1, 1, 2] 	A list or array.
[→] 	[n → 2n] 	A lazy infinite list.
?: 	x>3 ? 1 : 0 	Right-associative conditional.
:= 	Integers := {k ¦ k in Reals, k % 1 = 0} 	Declarative declaration.
K 	K([n → n=1 ? 4 : (n-1)^2], [n → n=1 ? 0 : 2n-3])	A generalized continued fraction - an irrational. The first list are the partial numerators, and the second are the partial denominators.
_ 	[1, 3, 1]_2 	List indexing.
=== The K construct ===
K's namesake, the K construct, can take the definition to a generalized continued fraction, and return the real number corresponding to it. Of course, the real number itself is actually defined by the continued fraction, and that's how K stores it in memory. In order to determine if two generalized continued fractions are equivalent, K must apply algebra.
==== GCF Algebra ====
When comparing two GCFs, K applies the concept of the equivalence transformation. If K can successfully apply algebra to one of the GCFs to convert it into the other, then they are both equivalent. Otherwise, they are not.
Category:Languages
Category:Works-in-Progress
K-on Fuck

K-on Fuck (けいおんfuck) is an esoteric programming language believed to be created by Yuichi Nishiwaki. It is a programming language where all input is done via the Japanese sounds うん(un) and たん(tan). It is derived from the anime K-ON or Ho-kago Tea Time which is about the every day lives of the members of the Light Music club.
The source code for the K-on Fuck interpreter is modeled after the K-on character Azusa Nakano, also known as Azunyan.
== Example Code ==
うんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんたんたんうんうんうんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんうんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんうんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんうんたんうんうんたんうんうんたんうんたんたんたんたんたんうんうんうんたんうんうんうんうんうんうんたんうんうんたんうんたんうんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんたんうんうんたんうんうんうんたんうんうんたんうんうんたんうんたんうんうんうんうんうんうんたんたんたんうんうんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんたんうんうんうんうんたんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんうんたんうんたんうんうんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんたんうんうんうんたんうんうんたんうんうんたんうんたんうんうんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんたんうんうんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんたんうんうんうんうんうんうんたんうんたんうんうん
The language is Turing complete as it is a trivial brainfuck substitution as evidenced by https://gist.github.com/wasabili/562178 
The obfuscated interpreter also interprets this same substitution when encoded in Windows codepage 932, however, if it is given an argument beginning with "a" and unrelated process is run instead.
== Perl Implementation ==
 %c=qw(AAA $p++ AAB $p-- ABA D++ ABB D-- BBA D&=255;while(D){ BBB D&=255;} BAA print+chrD BAB D=ord(getc));
 $/=$,;$_=<>;s/[AB]//g;s/うん/A/g;s/たん/B/g;s/[^AB]//g;s/.../$c{$&};/g;s[D]'$b[$p]'g;eval
Category:Brainfuck equivalents
KEMURI

KEMURI is a stack-based language with just six commands:
Cmd	Description
~ 	Pops a byte from the stack and pushes its NOT.
^ 	Pops two bytes from the stack and pushes their XOR.
" 	Duplicates the top byte on the stack.
' 	Rotates top three bytes on the stack (top element becomes the third).
` 	Puts the ASCII values of "Hello, world!" on the stack ("H" on top).
 	Outputs all bytes on the stack as ASCII characters. Recommended to use only at end of program.
==Examples==
===Hello, world!===
 `|
==Computational class==
It is obvious that KEMURI is not Turing-complete because KEMURI has no functions for control-flow.
==Others==
*It was introduced that any strings of characters in range of 0–127 could be produced without XOR command(^) on Nishio's original blog.
**This Ruby program 'str2kemuri.rb' — the program to generate a KEMURI program to output any given strings — proves that KEMURI generates any strings.
*KEMURI_PLUS was designed by Nishio, as the extension of KEMURI_PLUS. KEMURI_PLUS had two extra command characters l and *, both would interpret content of the stack as a brainfuck program and run.
**This would make it Turing-complete.
==External resources==
*Japanese Wikipedia page
*
**
*Specification on Hatena Keyword (in Japanese)
Category:Languages
Category:Stack-based
Category:2006
Category:Implemented
Category:Output only
Category:Total
KEYWORD

KEYWORD uses keywords (like BASIC) for everything
= The KEYWORDS =
== String ==
 STRING hi
== Comment ==
 COMMENT hi
== Print ==
 PRINT (STRING hello_world) COMMENT hello_world program
== Label ==
 LABEL hi
== Goto ==
 LABEL hi
 PRINT (STRING loop)
 GOTO hi
== Keyword ==
 KEYWORD HI (STRING hello)
 PRINT (HI)
== Var ==
 VAR a (STRING hi)
 PRINT (VAR a)
== Number ==
 NUMBER NUM NUM NUM COMMENT number 3
== Math ==
 ADD
 SUB
 MUL
 DIV
 MOD
== Code block ==
 CODE
 PRINT (STRING hi)
 END
== If/elif/else ==
 IF (condition) CODE
 END
 ELIF (condition) CODE
 END
 ELSE CODE
 END
== True/false ==
 TRUE
 FALSE
 AND
 OR
 NOT
 EQ
 NEQ
 GR
 LR
 GEQ
 LEQ
== Input ==
 VAR a (INPUT (STRING hi))
 PRINT (VAR a)
== Loop ==
 LOOP 5 CODE
 END
 WHILE TRUE CODE
 END
 UNTIL TRUE CODE
 END
== List ==
 VAR a (LIST (STRING hi) NEXT (STRING hello) END)
 PRINT (VAR a)
== Index ==
 INDEX (LIST (STRING hi) NEXT (STRING hello) END) (NUMBER) COMMENT index 0 of ["hi", "hello"], aka "hi"
Category:Languages
Category:High-level
KICK THAT HABIT MAN

KICK THAT HABIT MAN is an esoteric functional programming language by User:Salpynx based on the permutation poems of Brion Gysin and Ian Sommerville, which were an early example of computer generated art.
The language has three main conceits:
# That the application of combinator calculus used to build binary trees can be implemented as a unary function which takes one argument and returns a function which does what is needed to build tree branches and eventually apply the results.
# Useful unary functions can be converted to (less useful, more complex) demi-semi-ary functions (i.e. quarter arity), where it takes four function applications to perform one standard operation. 
# A functional tarpit language named KICK THAT HABIT MAN should at least be suited to generating permutation poems of itself if nothing else.
The four functions are:
Function	Symbol
KICK 	-
THAT 	(
HABIT 	$
MAN 	£
All functions are unary and return a function. The symbols are taken from the book The Third Mind, and can be used as a short alias for the function.
To produce useful results, the functions must be permuted in groups (or lines) of four.
* KICK THAT HABIT MAN in the 'standard' order produces the Identity function
* A permutation other than the standard beginning with KICK produces the K combinator
* A permutation beginning with THAT produces the S combinator
* A permutation beginning with HABIT produces the application function
* A permutation beginning with MAN effectively takes four arguments (via currying) and returns a permutation
The following are side effects:
* Any invalid permutation will generate a PERMUTATION ERROR 
* The permutation generated by a line beginning with MAN will print to STDOUT
The language is to be implemented as the four functions, and as such can be used directly within a range of languages.
Bracketing or other methods of grouping beyond HABIT fn fn fn are not required, but could be used and will have the expected effects of evaluating grouped expressions as if they were standalone KICK THAT HABIT MAN programs, and then combine the results.
A specific evaluation strategy is not yet determined. It appears like it must NOT be eager. An implementation of these functions in Python is in progress.
The exact permutation algorithm is left unspecified, but ideally it should be one documented from the pre-1980s era.
Some work is required to determine the original character set of the symbols from the table above. Are they from the 1965 Honeywell 200 Model 120, or the University of Cambridge's EDSAC 2? The answer has no real bearing on anything, but the £ seems like it could rule one out.
==External resources==
* wikipedia:Ian Sommerville (technician)
* The technology of Gysin's permutation poems
Category:Languages
Category:Functional paradigm
Category:Thematic
Category:2024
KRONKSCRIPT

An Esolang by Zack Umar. Version 1.0.0
==What is KRONKSCRIPT?==
KRONKSCRIPT is an esoteric programming language based on Kronker Pepikrankenitz. If you do not know of him, you should.
==Why is KRONKSCRIPT?==
Who doesn't want yet another programming language added into the realm of esolangs? And better yet, who doesn't want one based on the Mr. Kronker Pepikrankenitz, himself? If you couldn't tell. I got bored. :)
==How to use KRONKSCRIPT==
The idea behind KRONKSCRIPT is memory manipulation (like every other esolang ever, but in Kronk form :D). This is not a golfing language. You can surely try, but... Have fun?
 START/EXIT
 oh yeah ............................. Start of program
 it's all coming together ............ End of program
 MEMORY MANIPULATION
 righteousness ....................... Move memory pointer to the right
 rocks ............................... Move memory pointer to the left
 [a] spinach puffs ................... Move memory pointer to [a]
 squeaker [data] squeak .............. Store data at current address
 that poison ......................... Clears memory at current address
 ARITHMATIC
 harp [a] [b]......................... Add [a] and [b]
 pitchfork [a] [b].................... Subtract [a] and [b]
 robe [a] [b] ........................ Multiply [a] and [b]
 dress [a] [b] ....................... Divide [a] and [b]
 CONDITIONAL STATEMENTS
 the poison for kuzco ................ Start of loop
 kuzco's poison ...................... Goto start of loop unless current address equals 0
 STDIN/STDOUT
 squeak squeakity .................... Store user input at current address
 squeak squeakin ..................... Prints data at current address
All punctionation: optional.
Capitalization: optional. Sanity: optional. Knowing who Kronker Pepikrankenitz is: not optional.
==Other Guidelines:==
*Anything before or after the start and end keywords are ignored by the compiler or interpreter.
*Comments are denoted by `//`
*Similar to [`brainfuck`](https://esolangs.org/wiki/Brainfuck), the memory block is set to zero and the pointer starts at the left-most memory address.
*Loops may be nested but need to have corresponding pairs of `the poison for kuzco` and `kuzco's poison`.
*The memory should be an array of uint8 bytes, but the amount of bytes is up to the discretion of the compiler or interpreter. 30000 bytes is a good baseline (taken from [`brainfuck`](https://esolangs.org/wiki/Brainfuck)).
*KRONKSCRIPT uses the file extension `.kronk` because I wanted to.
KS

KEA-stream is a language based on data streams.
The language was inspired by the EV3-g where cables are used to connect action blocks.
In its original version, the KEA-stream is first compiled in KEA, an instruction language
==Language overview==
Element 	Notation
variable 	$name
function 	name
push 	>
multi-stream splitter	,
string 	"string with spaces"
==Examples==
===Hello, World!===
This program prints out the words Hello World!
 "Hello World!" > print
===POW2===
In this example 3 passes into the pow2 function, then is stored in the variable $result.
 3 > pow2 > $result > print
Which can be coded in python with
 result = pow2(3)
 print(result)
===Multi stream===
This simple program uses multi stream with the and function which takes 2 inputs.
 1, 0 >> and > $exit
===XOR===
Example of recreation of the XOR gate.
 0, 1 >> $a, $b >> not, not >> $not_a, $not_b
 $a, $not_b, $b, $not_a >>>> and, and >> or > print
===Factorial===
function that calculates the factorial of a number (see keyword below)
 FUNC factorial $to
 1 > $exit
 $to > $i > LOOP
 $exit * $i > $exit
 $i - 1 > $i
 END
 $exit > RETURN
==Keyword==
All keywords are capitalized.
===Loop===
 $turns > LOOP
 "hi" > print
 END
===Conditions===
 $bool > IF
 "true" > print
 END
===Function===
:functions can return a single value. RETURN acts like END
 FUNC name $ar1$arg2
 $arg1 + $arg2 > RETURN
==Funny situations==
===Calculation priority===
The code is parsed word by word without applying priority for example
 1 + 2 != 1 + 2 > print
it will display 3 because:
1 + 2 → 3
3 != 1 → 1
1 + 2 → 3
==External resources==
* KEA-stream parser
* documentation
Category:Languages Category:2022 Category:Implemented
KTANExec

KTANExec ("ka-tain-ek-sek") is an Esolang by enilKoder based on the video game Keep Talking and Nobody Explodes (KTaNE).
KTaNE involves a defuser, which is the only person who can see and interact with a virtual bomb but can't see the manual, and an expert or experts, who can see the manual. The defuser and expert(s) must communicate with each other to disarm modules (puzzles on the bomb) and defuse the bomb. (Hence the name, if they don't communicate, the bomb will go boom! [unless you are LtHummus])
Each KTaNE module represents a specific programming module.
KTaNE module name 	programming module
Wires 	
The Button 	Boolean and logic gates/operators
Keypads 	Numbers and mathematical operations
Simon Says 	Program I/O
Who's on First 	Error handling
Memory 	Variables and memory getting/setting
Morse Code 	Cryptography
Complicated Wires 	
Wire Sequences 	
Mazes 	Program control and loops
Passwords 	String processing
Venting Gas 	
Capacitor Discharge	
Knobs 	
A KTANExec file is an ASCII-art bomb. Execution starts with the top-left module and goes rightward, then down to the next line (English reading order). Each executed module takes input from the previous and gives output to the next.
 -------------------------------------
 | | | |
 | | | |
 | Module | Module | Module |
 | | | |
 | | | |
 -------------------------------------
 | | | |
 | | | |
 | Module | Module | Module |
 | | | |
 | | | |
 -------------------------------------
==Wires==
==The Button==
==Keypads==
==Simon Says==
==Who's on First==
==Memory==
==Morse Code==
==Complicated Wires==
==Wire Sequences==
==Mazes==
==Passwords==
==Venting Gas==
==Capacitor Discharge==
==Knobs==
KYS

KYS is a brainfuck-esque esolang made by WeCantRelate aka Parteh out of boredom in Ruby one night. Source code can be found here.
==Commands==
Command	Effect
) 	adds 1 to the current memory pointed to
( 	subtracts 1 from the current memory pointed to
! 	moves the pointer by 1
? 	moves the pointer back 1
$ 	adds the current pointer value as ascii to the output buffer
# 	basically system.exit but prints the output buffer first
* 	sets the current memory address to a random number between 0 and 255
@ 	Hello, World! is added to the output buffer
/ 	Crazy? I was crazy once! They locked me in a room, a rubber room. A rubber room with rats. Rats make me crazy. Crazy? I was crazy once! They locked me in a room, a rubber room. A rubber room with rats. Rats make me crazy. Crazy? I was crazy once! They locked me in a room, a rubber room. A rubber room with rats. Rats make me crazy. Crazy? I was crazy once! They locked me in a room, a rubber room. A rubber room with rats. Rats make me crazy.Crazy? I was crazy once! They locked me in a room, a rubber room. A rubber room with rats. Rats make me crazy. Crazy?-
< 	starts a loop
> 	ends a loop
also tis' a shitty interpreter too :)
==Examples==
Hello world - @
Shitpost - /
RNG - *
Hello, World + RNG - @!*$
Shitpost RNG World - /@!*$
SHIIIIIITPOOOOOOST - ///////////
Category:Languages Category:Cell-based Category:Implemented
Kai

Kai (会 in Japanese) is an experimental interpreter that provides a highly extensible runtime environment and explicit control over the compilation process. Programs are defined using nested symbolic expressions, which are all parsed into first-class values with minimal intrinsic semantics. Kai can generate optimised code at run-time (using Low Level Virtual Machine) in order to exploit the nature of the underlying hardware and to integrate with external software libraries. It is a unique exploration into world of dynamic code compilation, and the interaction between high level and low level semantics.
For more information visit 
==Other external links==
*ioquatix/kai: A simple LISP style interpreter written in C++
* (PDF)
* (PDF)
Kak+

Kak+ is a Two-demensional version of Kak Made by User:ChuckEsoteric08
==Commands==
Command	Meaning
! 	move memory pointer to the right and flip bit
( 	move memory pointer to the left
? 	skip next instruction if zero
^ 	move IP up
v 	move IP down
> 	move IP right
< 	move IP left
; 	skip next instruction if not zero
# 	stop the program
==Translation to Kak==
Kak program:
 abcdef
can be translated as:
 >abcdef;#v
 ^ <
or:
 >abcdef?v#
 ^ <
it is because Kak+ program is not in loop, like Kak, Kak- and Kak--
Category: Languages Category:Turing complete Category:Turing tarpits Category:Two-dimensional languages