nyuuzyou/wikis huggingface dataset:
Come Here

Come Here is a programming language devised by User:Smjg. Its aim is to do away with the GOTO statement that is considered harmful by many people, but nonetheless is far too common in the world's languages.
To achieve this, the GOTO statement is replaced by COME FROM. Indeed, COME FROM is the only control flow statement in Come Here. Loops and conditionals must be simulated by using COME FROM with a computed argument.
The only data type is the integer. Strings are stored as their little-endian integer representations. There is no defined limit on the size of a Come Here integer. In the official implementation it is unlimited (except by the available memory, of course), but this is not a requirement.
== Syntax and statement semantics ==
Each statement consists of an optional numeric label, a keyword (or in one case, two keywords), followed by one or more juxtaposed arguments. Whitespace is irrelevant.
Statement 	Description
NOTE one or more tokens	Comment
CALL exp var 	Assigns value exp to variable var.
ASK var 	Receives a line from stdin and stores it in var.
TELL one or more values	Writes the arguments in string form to stdout.
COME FROM exp 	Transfers control here after the statement labelled exp is executed.
== Code example ==
The following program prints the message "Hello, world!" ten times.
 10 CALL 10 count
 COME FROM 10 + SGN count
 TELL "Hello, world!" NEXT
 11 CALL count - 1 count
The second line in this code takes the sign of the variable count (0-1, 0 or 1), and therefore comes from the statement labelled 9, 10 or 11 depending on the value of count. It is illegal to COME FROM a non-existent label, hence the dummy label 10. In this instance, count will never be negative; therefore there is no need for a statement to be labelled 9.
== Computational class ==
As long as the implementation places no limit on the size of the integer data type, Come Here is Turing complete since it can simulate a Minsky machine.
Because Come Here has no built-in support for arrays or other data structures, such things must be encoded by using a defined number of integer variables.
== External link ==
* The Come Here Programming Language
Category:Languages
Category:Turing complete
Category:2003
Category:Implemented
Command per command

command per command is an esolang designed to have the biggest possible self interpeter.
== how it works ==
every program asks for input, and then every command after that is a marker for if that command is in the interpreter or not.
the commands are seperated by newlines, and there are infinite commands, because a command is a string of any length of any characters.
== the self-interpreter is infinite ==
because there are infinite commands and every command is required so that every command is in the interpreter, that means that there are infinite commands in the self-interpreter, meaning the self-interpreter is of infinite length.
Commercial

This language is based off, as the title implies, TV commercials. This language was created by User:Poolala. It's probably Turing complete, but there's no formal proof.
==Operations==
Operation 	Description
Variable now value dollar(s) off! 	Declare an int, or change its value (You can use a variable as a value)
"Value" - Satisfied Consumer of Variable 	Declare a string, or change its value
Variable now sold at your local grocery store! 	Input int (can be used for declaration)
Variable now sold at your local drug store! 	Input string (can be used for declaration)
Variable: made by the makers of Variable2 	Add variables and store the result in Variable. If Variable is a string, the number will be stored as a unicode character. If Variable2 is a string, its first character's unicode number will be used. (Same for subtraction)
Variable has shown much more positive feedback than other products, like Variable2	Subtract variables and store the result in Variable
Variable has been selling out worldwide! 	Output variable
Customers are jumping for joy for Variable! 	If variable is 0 (int), jump backwards to either the last jump or the start of the program, else if 1 jump either to the next jump or the end of the program
HeadOn - Apply directly to the forehead 	Halt execution
Comments are simply lines that aren't an operation.
==Programs==
===Hello, world!===
 "Hello, world!" - Satisfied Consumer of Hello
 Hello has been selling out worldwide!
===Cat program===
 Jump now 2 dollars off!
 Customers are jumping for joy for Jump!
 Customers are jumping for joy for Jump!
 Jump now 0 dollars off!
 Input now sold at your local drug store!
 Input has been selling out worldwide!
 Customers are jumping for joy for Jump!
or (Simpler):
 Cat now sold at your local drug store!
 Cat has been selling out worldwide!
==Implementations==
Python implementation by User:TuxCrafting (Note: does not implement loops correctly)
Category:Languages
Category:2013
Category:Thematic
Category:Implemented
Category:High-level
Category:Pseudonatural
Commlang

Commlang was an attempt by User:Monochromeninja to create a community-based esolang, but ended up doing it their own way.
Commlang uses a single stack of integers. EOF is -1, empty stack is repeated 0, and stack indices are 0-based, where negative indices start at the bottom.
==Commands==
Commlang has the following commands. Either the shorthand or verbose form may be used for each command.
Shorthand command	Verbose command	Description
{N} 	push N 	Push N to the stack.
! 	pop 	Pop the top of the stack.
` 	del 	Pop X, then delete the X'th item of the stack. (! and {0}` are equivalent)
: 	dup 	Duplicate the top of stack.
_ 	in 	Push a single character of input, converted to its codepoint.
" 	out 	Pop X, interpret it as a codepoint, then output it.
* 	mul 	Pop A, pop B, push B * A.
/ 	div 	Pop A, pop B, push B / A rounded down.
% 	mod 	Pop A, pop B, push B % A.
~ 	neg 	Pop X, push -X.
= 	eq 	Pop A, pop B, push 1 if B == A, else 0.
< 	less 	Pop A, pop B, push 1 if B < A, else 0.
@ 	swap 	Swap the top two elements of the stack.
[F] 	[F] 	Push function F to the stack.
^ 	call 	Pop function F and insert its code immediately after the ^.
. 	comp 	Pop function F, pop function G, push the function that consists of G's code concatenated with F's code.
$ 	pick 	Pop X, then copy the X'th item of the stack to the top. (: and {0}$ are equivalent)
? 	rand 	Pop X, then push a random integer between 0 and X inclusive.
# 	debug 	Toggle debug info. (interpreter-specific)
==Examples==
Cat program:
 [:{2}${1}~=[{2}$_{2}`@!@:^]@[]@`^]:^!!![:{2}${0}=[{1}~$"{1}~`^]@[]@`^]:^
In verbose form:
 [
 dup
 push 2 pick
 push 1 neg eq
 [
 push 2 pick
 input
 push 2 del
 swap pop swap
 dup call
 ]
 swap
 []
 swap
 del call
 ]
 dup call
 pop pop pop
 [
 dup
 push 2 pick
 push 0 eq
 [
 push 1 neg
 pick out
 push 1 neg del
 call
 ]
 swap
 []
 swap
 del call
 ]
 dup call
Infinite loop:
 [:^]:^
In verbose form:
 [
 dup call
 ]
 dup call
==External resources==
* Reference interpreter
Category:Languages
Category:Implemented
Category:Stack-based
Common-S3C

== A self-updating language. ==
==== The language has a bug in it that allows for comments with no prefix like #, or //. This allows for easy error fixes. (it ignores any errors and treats them like comments.) ====
===Interpreters: ===
Every interpreter version of SSSC is written in Python.
Online interpreter. Remember to replace what is in the read( ) function with your code like: "!poop haha;" or "=100/;"
=== Syntax: ===
* §: prints A forever
* º: starts up a local testing environment on port 80
* ⨘: print a random number in between 0 and 10
* !hello;: prints what is inbetween `!` and `;`
* =1+1; accepts +, -, /, and * with two parameters of up to 243 characters in length.
* !word;§ prints word forever.
* =100/34;§ prints 2.94117647059 forever
=== Examples: ===
 §
returns
 A
 A
 A
 A
 A
 A
etc.
==== "Hello World": ====
 !Hello, world!;
==== Math: ====
 =420/500;
 =1+1;
 =1*4;
 =1-3;
== Links: ==
Source code on Github
Online interpreter 
===== The TIO Version does NOT come with instructions. =====
Category:Languages
Category:Implemented
Comp

Comp is an esolang by User:Hex96. It is stack based. It is designed for code-golfing.
==commands==
# print the top value on the stack in ascii.
£ print the top value on the stack as a number.
' gets input and pushes the ascii value on to the stack.
; gets input and pushes the number on to the stack.
{ while the top value on the stack is not 0.
} end the loop
! adds one to the top value on to the stack.
" subtracts one from the top value on the stack.
\ pushes the number after it on to the stack.
+ gets the top two values on the stack. y being the first one popped, x being the second. x+y.
- same thing but -.
/ same thing but /.
* same thing but *.
[ if the number before it is the same as the first value popped off the stack, then continue (if x == the number before it).
] end the if.
( same thing as [ but a != not ==.
) end the if not statement
@ gets multi input and pushes the ascii values on backwards.
< until the top value on the stack is not 0.
> end the <.
^ duplicates the top value on the stack.
% pops the top value on the stack.
_ stops the program.
~ pops the top value on the stack, if it is a 1, push a 0, else, push a 1.
==Examples==
===Hello, World!===
\72 # \101 # \108 # \108 # \111 # \44 # \32 # \87 # \111 # \114 # \108 # \100 # \33 #
===Truth-Machine===
;{^&}&
===Calculator===
This has the operation last.
;;'
\43[%+_]
\45[%-_]
\42[%*_]
\47[%/_]
==Implementations==
* Someone created a very rudimentary Comp to Keg transpiler. It will take a comp program and turn it into a Keg program that can be executed on sites like Try It Online!. It's stored as a Github Gist
== Computational Class ==
Comp is believed, at least by one person, to be Turing Complete. Why? Because a command map between the Turing Complete esolang Volatile and Comp is possible:
Volatile	Comp
~ 	\1 (Note that the ~ can be replaced with any number, as it is a random number generator)
+ 	+
- 	-
* 	*
/ 	/
: 	^
. 	#
(...) 	{...}
Category:2020
Category:Languages
Category:Stack-based
Category:Low-level
Category:Turing complete
Category:Golfing language
Compass

Compass is a language based on Pascal that was desined by User:Ractangle
==Language syntax==
The command defines a function like how the command in Pascal. However there are no arguments to it
The text command basically prints a string. Nothing special (however not quotes are needed)
==Examples==
These are don't work yet, because i only made a parser or whatever you call it
===Hello, world!===
 begin main:text(Hello, world!)
===Empty Program===
 begin main:;
To Compass. This is completely valid
==Implementation==
https://github.com/Thevitebsk/Compass/blob/main/main.py
Compiler

A compiler is a program that converts code written in one language into another language. Usually, the main purpose of compiling is to enable the program to run without an interpreter, and that means converting it into machine code. However, compiling to an intermediary language (such as C) for which there already exists a machine code compiler is also done. This is probably more common with esoteric programming languages than with normal languages.
Several compilers have been written in esoteric programming languages. Perhaps the most interesting of these is awib.
==See also==
* Interpreter
Category:Concepts Category:Program forms
Complode

Complode is a stack-based language with not very many commands.
Command 	Description
numbers 	Push a number to stack. It can be any integer.
/ 	Do a calculation (read the instructions below).
(code) 	Create a code-block and push to stack.
.name(code)	Define a macro. Each name macro can be defined only once.
,name 	Use a macro.
; 	Comment until end of line.
_I 	Input one byte, push to stack
_O 	Pop from stack and output one byte
The calculation is:
# Pop A
# Pop B
# Pop C
# Pop E
# Pop F
# Pop Z
# If A>0 Then Let G=var(A) Else Pop G
# If B>0 Then Let H=var(B) Else Let H=G
# If C>0 Then Let var(C)=E
# If B>0 Then Let var(B)=F*G
# If Z>0 Then Push H+F+E
# If Z<0 And A<0 And B<0 Then it will push a list of all variables -A to -B and their values (as a single entry) to a stashing stack
# If Z<0 And A=0 And B=0 Then it will pop one entry from the stashing stack and restore all of the values of those variables
# If Z=0 And A<0 Then Push F*E
If a code-block is popped during this calculation, it is looped, at the beginning of the loop it pops a value from the stack and if it is zero it stops the loop, and pops again the value it was trying before, and if is also a code-block it does again with this code-block, until it is a number; the exception is "Pop G" which does not loop and keeps the code-block as is, and then if it is part of an addition or multiplication the numbers in that calculation are ignored and the result is just the code-block. Popping an empty stack returns zero.
==Examples==
Some useful macros:
 .dup(
 0 -1 0 0 0 -1 -1 /
 0 1 0 0 1 0 /
 1 0 0 0 0 1 /
 1 0 0 0 0 1 /
 0 -1 0 0 0 0 0 /
 )
 .discard( 0 0 0 0 0 0 / )
 .swap(
 0 -1 0 0 0 -2 -1 / ; stash var(1) and var(2)
 0 1 0 0 1 0 / ; store to var(1)
 0 1 0 0 2 0 / ; store to var(2)
 1 0 0 0 0 1 / ; get from var(1)
 1 0 0 0 0 2 / ; get from var(2)
 0 -1 0 0 0 0 0 / ; unstash var(1) and var(2)
 )
 .setvar(
 0 -1 0 0 0 -1 -1 / 0 1 0 0 1 0 /
 0 1 0 0 1 0 0 0 0 1 / 0 0 -1 0 0 0 0 0 / /
 )
== External resources ==
* Interpreter in Python 3
Category:Languages
Category:2007
Category:Stack-based
Category:Unknown computational class
Category:Implemented
Compose

Compose is a language with 3 levels of abstraction, described in mixed metaphors to avoid being thematic. The lowest level is based on string rewriting, the next based on graphs, and the highest is based on function composition. There are many different ways to accomplish anything in this language, as tasks can be moved between levels of abstraction. Due to this, and the distinct sections of each program, it can be thought of as a language that is used to write programs, or as a language that is used to write programming languages, in a manner similar to currying.
This is a work in progress, as better syntax is developed.
== Particles ==
The first section of a Compose program is the definition of particles. Each particle consists of:
*A stack, which holds characters
*A buffer, initially empty
*A list of string rewriting rules
A particle is defined as follows:
 *name {match_0:replace_0, match_1:replace_1, ... match_n:replace_n}
This defines a particle named "name" with n string rewriting rules, each replacing "match_k" with "replace_k" for some k.
== Organs ==
== Functions ==
Category:Languages
Composite

Composite is an esolang created by User:ArthroStar11 All of it's commands are prime numbers (yes the name of the language is a pun)
== Data Structure ==
* 26 registers (32 bit signed integers) 1-index
* data stack (32 bit signed integers, max size of 1000)
* boolean cell
== Syntax ==
Composite's program structure resembles assembly, you hard code in opcode n by typing in the nth prime. You type in the command followed by space separated args (if any exist). One line contains a command and all of its arguments
Composite's two means of flow control are while loops and subroutines. Subroutine calls are unconditional, loops will run as long as the boolean cell is true. The main routine starts at the beginning of the program and ends at the first defined subroutine or the end of the program, whichever is first.
== Command list ==
PLEASE NOTE: the commands are listed as the opcodes, to use the commands you'll use the nth prime for opcode n
* 1: define subroutine (0 args)
** self explanatory
* 2: gosub (1 arg)
** jump to the subroutine <arg1>
* 3: return (0 args)
** returns from the subroutine, can also just let the subroutine end naturally. Ends program if reached in the main routine
* 4: start loop (0 args)
** defines the start point of the loop. Loops can be nested.
* 5: end loop (0 args)
** defines the end point of the loop
* 6: greater than (2 args)
** sets boolean cell to true if(reg[<arg1>] > reg[<arg2>])
* 7: equal to (2 args)
** sets boolean cell to true if(reg[<arg1>] == reg[<arg2>])
* 8: not (0 args)
** inverts boolean cell
* 9: add (2 args)
** reg[<arg1>] += reg[<arg2>]
* 10: subtract (2 args)
** reg[<arg1>] -= reg[<arg2>]
* 11: multiply (2 args)
** reg[<arg1>] *= reg[<arg2>]
* 12: integer division (2 args)
** reg[<arg1>] /= reg[<arg2>]
* 13: modulo (2 args)
** reg[<arg1>] %= reg[<arg2>]
* 14: push(1 arg)
** pushes reg[<arg1>] onto the stack
* 15: pop(1 arg)
** pops the stack and stores into reg[<arg1>]
* 16: move (3 args)
** if <arg1> is 1 sets reg[<arg2>] to <arg3>
** if <arg1> is 2 sets reg[<arg2>] to reg[<arg3>]
* 17: character input (1 arg)
** takes user input as an ASCII character and stores it in reg[<arg1>]
* 18: integer input (1 arg)
** takes user input as an integer and stores it in reg[<arg1>]
* 19: character output (1 arg)
** prints reg[<arg1>] as an ASCII character
* 20: integer output (1 arg)
** prints reg[<arg1>] as an integer
== sample programs ==
Prints HI
 53 2 2 359
 53 2 3 367
 67 2
 67 3
prints 99 to 1
 53 2 2 523
 53 2 3 2
 53 2 5 131
 19
 7
 13 2 3
 71 2
 67 5
 29 2 3
 11
truth machine (shows subroutines)
 53 2 2 2
 29 2 2
 61 3
 13 3 2
 71 3
 7
 3 2
 11
 2
 71 3
== Implementation ==
ArthroStar11's Interpreter (C++ source)
Category:Languages
Category:2021
Category:Unknown computational class
Category:Implemented
Category:Stack-based
CompressedFuck

CompressedFuck, made by User:LegionMammal978 in 2015, is yet another compression scheme for brainfuck, designed to be at most half the size of the original program for sufficiently large programs.
== Language ==
A CompressedFuck program is interpreted as a series of triplets of bits according to this table:
Triplet	Instruction
000 	+
001 	-
010 	<
011 	>
100 	.
101 	,
110 	[
111 	]
It is then interpreted as brainfuck. Note that it must be padded with some unnecessary instructions to ensure that the byte count is a multiple of 3.
== Examples ==
=== Hello, World! ===
 �3������=��le���I��������I��I1���
Doesn't make much sense? Well, here's the translation:
 00000000 00000000 00000000 11001100 00000000 00110011 00000001 10000000 00011000 00000001 10000100 10010010 00111101 10000110 00011001 01101100 01100101 11010001 11101101 11000110 01001001 10000000 00000000 00000000 10010000 00000001 00011011 10001000 11000101 00000000 00010000 10010010 01001001 10000100 10010010 01001001 00110001 10110001 00011000 00010000 00000000 00000000
 000 000 000 000 000 000 000 000 110 011 000 000 000 000 110 011 000 000 011 000 000 000 011 000 000 000 011 000 010 010 010 010 001 111 011 000 011 000 011 001 011 011 000 110 010 111 010 001 111 011 011 100 011 001 001 001 100 000 000 000 000 000 000 000 100 100 000 000 000 100 011 011 100 010 001 100 010 100 000 000 000 100 001 001 001 001 001 001 100 001 001 001 001 001 001 001 001 100 011 011 000 100 011 000 000 100 000 000 000 000 000 000
 ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.++++++
As you see, there are 6 extra + instructions at the end for padding. Still, however, a 60.38% reduction in code size was achieved.
The following examples will be encoded in Base64.
=== Cat program ===
 ul4A
A 40% reduction was achieved.
=== Truth-machine ===
 buKCDfAAAxRJJJL6y0/U
A 62.5% reduction was achieved.
==Implementations==
Interpreter Written in Perl here. Supports Base 64 Encoding/Decoding.
Category:Languages
Category:2015
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Turing complete
Category:Implemented
Category:Cell-based
Category:Turing tarpits
Compressed Malbolge

Compressed Malbolge, made by User:Palaiologos in 2019, is a compressed variant for Malbolge_Unshackled, designed to fit my large blobs inside PPCG submissions.
== Language ==
First, Malbolge is compressed using PPMd algorithm, then UniEncoded, and when it comes to execution of the program, the code is UniDecoded and decompressed.
This certainly lowers size of Malbolge programs allowing to post them in limited space areas. Example programpastebin.com , accessed 12.08.2019
Category:Languages Category:2019 Category:Cell-based Category:Implemented Category:Self-modifying Category:Turing complete
Computable

Computable languages are languages that can be simulated by Turing machines.
==Examples of uncomputable languages==
* Some languages that are able to solve the halting problem are uncomputable, like ^ and Oracle.
* Ambiguous languages are uncomputable, like Brain:D.
* Many joke languages are uncomputable because they have crazy commands, like Ifthen and User talk:/w/wiki/index.php/Talk:index.php/Main page.
==See also==
* :Category:Uncomputable
Category:Concepts
Compute

Compute is a joke programming language by User:Orange.
Compute has no required syntax and has the power to solve any and all problems. It is smart enough to interpret any human language (English, Spanish, Latin, etc), any programming language (C++, Java, brainfuck, etc), or any kind of data you can think of. The only downfall is that there is absolutely no I/O.
== Sample Programs ==
 Hello World
Hello world program.
 compute 99 bottles of beer
99 bottles of beer.
 Solve NP-complete problem
Solves an NP-complete problem. Any NP-complete problem.
 become self-aware
Cause the program to be self-aware for a brief period.
 What is love?
Cause the program to calculate what love is.
 Simulate every possible outcome of a full scale global thermonuclear war
Cause the program to realize the only winning move is not to play.
Note: the program may want to play a game of chess before terminating.
== Official Python 2 Implementation ==
 for c in open(__import__('sys').argv[1]).read():__import__('time').sleep(1)
 print'\n\nDone.'
Use in command prompt, terminal, etc, like this:
 compute.py program.cmp
== Unofficial brainfuck intepreter ==
 ++++++++++..[->+++++++>++++>+++++<<<]>--.[->+<]>+++.-.---------.>----.
Compute is very memory efficient and does not require a lot of CPU cycles.
==See also==
* Compute/IO
Category: Languages
Category: No IO
Category: Joke languages
Category: Uncomputable
Category: Total
Category: No-code esolang
Category: Nope. derivatives
Compute/IO

Compute/IO is an extension to Compute that allows IO. Whenever the program has to do IO, the program creates an alternative universe and executes the IO in that universe.
== Examples ==
Create an alternative universe and destroy it again:
 Destroy the universe.
or
 Universe.destroy();
or something else like that.
Become intelligent and destroy the earth (in another universe):
 Become intelligent and destroy the earth.
== Gotchas ==
When you are inside an alternative universe, you can not change anything in another universe.
== Interpreters ==
As far as you can tell, this Nil program interprets Compute/IO:
 Interpret a Compute/IO program.
== See also ==
* Compute
Category:Languages
Category:Joke languages
Computing crystal

Computing crystal or crystal co-processor or crystal processor is a speculated piece of hardware that would implement a cellular automaton suitable for computation use, in a crystal formed from specially designed or selected molecules that arrange in a repeating uniform homogenous topology. Interactions between those molecules transfer information and change the states of those molecules, implementing some rule set of some 2D or 3D cellular automaton that may or may not be already invented. Even though it would be computationally inefficient, its physical efficiency might outweigh that at least in some kind of computation. It could be possible to synchronize it somehow, to give it a clock cycle, maybe with a pulsed laser or phase of a radiowave, but if not, it might work as an asynchronous cellular automaton.
If the crystal uses 2D automata, they can be drawn / written / inputted on the crystal's frontside and then every step of the automaton moves its layer one molecule width closer to the backside of the crystal where its state can be read / outputted. The crystal could have as many layers of 2D cellular automata computing simultaneously as it has molecule layers between its frontside and backside.
==Possible turing complete cellular automata that could be used in it==
*Game of Life
*wikipedia:Wireworld
Category:Ideas
Category:Cellular automata