nyuuzyou/wikis huggingface dataset:
CelseeLang

CelseeLang is a rework of Celsee made by Alluseri.
== Overview ==
All commands/instructions are hexadecimal integers from 0 to C and $.
The original purpose of this language was to execute randomly generated numbers and (hopefully) receive some input.
Execution starts at index 0.
The effective difference between Celsee(Lang) and this is the inability to directly use values under 0 or over 9.
== Instructions ==
Instruction	Description
0 	None
1E 	Jump to execution index at EENV support: Yes(E)
2ABC 	If ENV == A, jump to B, otherwise, jump to CENV support: Yes(ABC)
3ABC 	If ENV != A, jump to B, otherwise, jump to CENV support: Yes(ABC)
4 	Increase ENV by 1
5 	Decrease ENV by 1
6E 	Set ENV to EENV support: Yes(E)
7 	Print ENV
8 	Print ENV + next line
9 	Print character at ENV
A 	Print character at ENV + new line
BE 	Increase ENV by EENV support: Yes(E)
CE 	Decrease ENV by EENV support: Yes(E)
$ 	ENV. If used outside of instruction arguments, executes the instruction within ENV parsed a hex character(e.g. ENV = 10, instruction: A). UNSAFE OPERATION!
== Examples ==
=== Hello, world! ===
Traditionally(as per Alluseri's languages), all (known) implementations of Hello world will be shown here. The idea is to print 0123456789, since the language doesn't direct support characters.
==== The Basic ====
74747474747474747474
==== The Best ====
394874107
=== Wait, that's illegal ===
6947
You can output values less than 0 and higher than 9 using ENV.
=== "Self-modifying code" ===
67$
The code will set ENV to 7 and execute the instruction within ENV(7), which causes it to print "7", which is the value of ENV.
Category:Languages Category:2022 Category:Cell-based Category:Unknown_computational_class Category:Implemented Category:Queue-based
Cerberus

Every Cerberus program is 3 lines long. It uses a stack and executes commands based on the size of groups of . and -. The first column that doesn't contain only . and - is the end of the program, so anything after that is a comment.
The IP starts at the left side of the second line and moves right until the end of the program.
If there aren't enough items for a command, it is treated as a no-op.
==Commands==
Size of Group	Character	Meaning
1 	. 	Push 1 to the stack.
1 	- 	Push -1 to the stack.
2 	. 	Prompt an integer input from the user and push it to the stack.
2 	- 	Pop and print the top of the stack.
3 	. 	Pop the two top stack elements A and B, and push the difference A-B to the stack.
3 	- 	Pop the top stack element A and compute the factorial A!. If A is positive, simply push A!, else push -((-A)!).
4 	. 	Swap the two top stack elements.
4 	- 	Duplicate the top stack element.
5 	. 	No-op.
5 	- 	No-op.
6 	. 	Pop the top stack element A and associate it as the A-marker identifier with the current instruction pointer location.
6 	- 	Pop the top stack element A. If a marker with this identifier exists, jump to the associated instruction pointer location; otherwise this is regarded as a no-op.
==Example Programs==
===Truth-machine===
 .-...-..--.--....-..-.-..--
 .-.---..-.--.----..-..-..--
 --.-..-.--.-.....-.-..--.--
===Cat program===
An infinitely repeating cat program is implemented in the following:
 ..-.--...-.---.--.--..-..--.-.---..-..--.--.--.-...-..-.--..-..-.-----.-..--.--
 .---.-.--...-..-...-.---.--.--..-.---.-..-...-..-.--.---.-.---.--..-...-..-...-
 ..-.--..---.-..--.--..-..-.--...-..-..-..--.--..-.--..-.--..-..--...-.---.--.--
==See also==
* Tiangou, a wimpmode of Cerberus
==Interpreter==
* Common Lisp implementation of the Cerberus programming language. Routines are provided to also interpret its wimpmode equivalent Tiangou.
Category:Languages Category:Pattern-based Category:Unknown computational class Category:Implemented Category:2020 Category:Stack-based
Chain

Chain is an esoteric form of data processing based on "chaining" together subprogram "nodes" and passing whole environments (which include the nodes and connections) between them. Which, I suppose, describes most programs, but this one does it a little more explicitly. It is concurrent, self-modifying, and confusing to look at.
== Syntax ==
:WIP
Category:Concurrent programming
Category:Self-modifying
Category:Concepts
Chaincode

Chaincode is a esoteric language by User:RomanGraef.
== Style ==
At startup the current value is read from STDIN.
A second value is initialised to 0.
Each line is a function:
,#<-call the line below
a#<-Adds the input to the current input.
and the first line is the main.
At the end of each line the current value is automatically returned.
The return of main is printed.
== Commands ==
Command	Exlanation
+ 	cur++;
- 	cur--;
a 	cur+=input();
s 	cur-=input();
d 	cur*=2;
h 	cur/=2;
i 	cur=input();
* 	cur*=input();
/ 	cur/=input();
\ 	cur=input() / cur;
^ 	cur*=10;
v 	cur/=10;
c 	cur=ceil(cur);
_ 	cur=floor(cur);
p 	cur=Math.pow(cur,2);
q 	cur=Math.sqrt(cur);
, 	cur=line_below(cur);
! 	cur=factorial(cur);
= 	cur=(cur==input())?(1.0):(0.0);
l 	cur=log_2(cur);
L 	cur=log_10(cur);
n 	cur=log_E(cur);
 	temp=cur;cur=switch;switch=temp;
> 	switch=cur;
< 	cur=switch;
(...) 	Comment
# 	line comment
== Interpreter ==
Java Interpreter by Roman Gräf
== Examples ==
=== Add two numbers ===
a
=== Square root ===
q
Category:Languages Category:Implemented Category:2017
Chainfall

#REDIRECT C̬̤̬͔̮̺̋̄̄̂̓̀ͧ̐h̺͋ͧ̓̏̄͂̉̓ͦa͔̬ͫ̎ͭ̃̃͊̊ì̜͔̼͓̰̱͍͈̰̊̉͒ň̤̃ͩ̒͜͜͞f̪̲̖̏ͨ̈͋̃̚a̴̪̮ͧ̓ͣ̈́̇̐ͯ̍̚ļ̴̜̘̥̱ͪͣ̅́ͭͣ́ļ̡̱̓ͩ̄̒̾̎̊͊́
ChaitinFuck

ChaitinFuck is a brainfuck derivative language designed to make all syntax valid, for the purposes of simplifying automated code generation. It uses a somewhat convoluted method of rolling loops, such as to allow loop closes (the only part of brainfuck that has any requirement of the surrounding code) to be randomly placed.
== Changes ==
ChaitinFuck is just like brainfuck, but the way that loops are implemented is slightly different and more specific and overflows to the left of the tape are fixed. A standard brainfuck interpreter tends to work with loops by making [ PUSH the current location in the code onto a stack, and ] POP a location off the stack and go to it. This means that, when a ] is called without a matching [, the program will crash from lack of information on the stack. ChaitinFuck resolves this by changing the behavior of POP.
When POP is called on a Chaitin Stack, it first removes the top value from the stack and stores it in a variable ToS. It then INJECTs ToS, inserting it at the bottom of the stack, then returns the variable. In the event that the stack is empty, the POP instruction returns 0, so the code reverts to the start.
The other change, tape right overflows, is also fixed. In ChaitinFuck, the tape is right-infinite in that when you > at the end of the tape, a new cell is added to prevent overflow. When you use < at the left end of the tape, the tape rolls around to the end of the tape (the last created cell). This has the interesting property that <> is not always a NOP, because if called at the left end of the tape it causes the pointer to be moved to a new cell one past the previous right extremity of the tape. >< is still a NOP.
All other instructions are exactly the same as in brainfuck, making ChaitinFuck fully backwards-compatible with valid brainfuck programs, assuming a right-infinite tape that crashes on left overflow. Unlike other languages which claim to be brainfuck-compatible, ChaitinFuck actually is, as it allows
Category:Languages
Category:Brainfuck derivatives
Chalcraft-Greene train track automaton

Adam Chalcraft and Michael Greene proposed a Turing-complete set of primitives for trains (Eureka 1994, Ian Stewart wrote about it later).
Also, Neise implemented it inside of WireWorld (see link in External resources, below.)
It's a 2D language, with a "head" that has a facing - the train is going some direction - and tracks that can be traversed in either direction. The tracks are connected in Y-shaped "points" of two kinds, lazy points and sprung points.
From Neise: "The lazy point has three entry/exits, W, E, and S. If the train enters W it always exits S. If it enters E it always exits S. If it enters S it exits either W or E depending upon which of the two was entered most recently. You can rotate and reflect, giving lots more combinations of NEWS."
Regarding the sprung point, also from Neise: "If the train enters W or E it exits S. If it enters S it always exits E. Again, reflections and rotations are gladly accepted. In the degenerate case where S is never entered, the point turns out to be a simple OR gate."
Chalcraft and Greene note that crossovers (four-way junctions allowing N-S and E-W travel) are possible to build out of these two components.
==External resources==
* A chapter dedicated to describing this automaton can be found in Ian Stewart's The Magical Maze: Seeing the World Through Mathematical Eyes, ISBN 0-4713506-5-6
* Article by the authors describing the system
* Implementation of the system in WireWorld
* Turing Trains: computational train track layouts
Category:Languages Category:Two-dimensional languages Category:Turing complete Category:Implemented
Chance

Chance is an esoteric programming language made in 2016 by User:M654 with the goal of being as hard as possible to write programs in. Chance is heavily based on chance. In fact, there is a 14% chance that a cat program written in Chance will work.
Commands in chance are grouped into 4 groups: navigation, addition/subtraction, output and input. Each command in a group has a 1 in 3 chance of running correctly. If it does run correctly, there is a 1 in 2 chance that it will do what you want.
For example, the + command has a 1 in 3 chance of running, and on top of that, there is a 1 in 2 chance of it either adding one to the selected cell's value, or subtracting one.
==Instructions==
Chance has 12 instructions.
Command	Info
>, /, ö	Move up/down the tape
+, \, ä	Add/subtract one from the selected cell
!, %, {	Output the selected cell's value
i, @, ^	Get input and store it in the selected cell
==Examples==
===Hello, world!===
This has a 0.000043% chance of running, which effectively means it will never run.
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!>++++++++++++++++++++++++++++++++++++++++++++!>++++++++++++++++++++++++++++++++!>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!>+++++++++++++++++++++++++++++++++
===Cat program===
The cat program is Chance is created by combining one command in the input group and another in the output group.
This program has a 14% chance of running.
 i!
===== Cat variations =====
There are 27 variations of the cat program, which all have a 14% chance of running.
==Implementations==
Interpreter Written in Perl here
Category:Languages Category:2016 Category:Implemented Category:Nondeterministic Category:Probabilistic Category:Total Category:Unusable for programming
Change

Change is a substitution based programming language and can be translated to lambda calculus
== Some Things ==
=== Text ===
Use " to make text
 "hello"
 "some text"
Use ' (if you want) to make letter
 'a'
 'b'
 'this is also valid'
 "s"
 "o is the previous one"
=== Substitutions ===
text(a)(b)
replace all a's in text with b
 "hello"('e')('o') #hollo
 "text"("ex")("xe") #txet
=== Vars ===
vars are for simplification like how vars are used in some lambda calculuses
 a = "hi"
 b = "hello"
 c = "hi world"("hi")("hello") #hello world
 c #hello world
=== Funcs ===
also a simplification
 sToEs a:
 return a('s')('es')
 sToEs("potatos") #potatoes
== Lambda Calculus ==
i said it could be translated to lambda calculus, so this is how
=== Example ===
 id = λx.x
 id x #x
that is a lambda abstraction for the identity function
heres it in change
 id a:
 return a
 id "x" #x
=== How To Do ===
take all inputs of the function
 λxy.yx
which is x, y
put them in a function
 func x y:
 ...
then insert the code for it
 func x y:
 return y(x)
done
=== Another Way? ===
You can use all of the substitution stuff to do it:
==== Before ====
 id = λx.x
 id y #y
==== After ====
 same = "x"
 id x:
 return same("x")(x)
 id "y" #y
Category:Languages
Channels-N

This language is named so after a idea that we can have a system of open gutters to carry data. If I put a 2 in a gutter, that 2 
sails by a "neighborhood rule" to another gutter and so on and so on. If our system stops, we can send the 2 back through the gutters to the origin. So, Channels-N is Reversible. A project is being created by User:Singingbanana to find a Toffioli gate in Channels-n.
Category:Languages
Category:Reversible computing
Char

Char is an esoteric programming language that only uses the Arch data structure (without any other data structure, such as the stack, the queue, the deque, and dynamic variables (although the cursor is indeed a dynamic variable, but that was mandatory in the Arch specification)) and is still close to being Turing-complete(via adding as few features as possible).
==Commands==
Char has an arch that has a length that was set to 64 cells and has 64b memory each; therefore, there are issues like reaching the boundaries of memory; look at the Arch page in this wiki for more information of this occasion.
-- l() Split the current cell at position pointed to by pointer.
-- s(...) 	 Pushes element onto position of pointer.
-- p() 	 Returns a popped element off of position under pointer after the pointer.
-- o(...) Points to a specified cell and(without parameters) returns the current cell.
-- g(...) Jumps to position ...
-- e(..a) If ..a is equal to 2 then set next jump as available; otherwise set as false.
-- - Subtraction and negation symbol
-- These are additional features that make programming easier:
-- -- One-line comments used to explain a program
A really long print function in Char; not using this function is recommended:
-- OutputTheValueOfTheCurrentCellUnderTheArchDataStructureOfCharsPointerToTheConsoleIEToStandardOutputOrToTheComputerScreenInTheUserOfCharsComputerWhetherItIsALaptopAPCOrEtceteraAndThenExecuteTheSubsequentCommandSlashDetailedInformationOnHowToDoOrUseSthWhichTellTheComputerWhatToDoAsSpecifiedByAHumanUserInTheCommandSlashDetailedInformationOnHowToDoOrUseSthWhichTellTheComputerWhatToDoSequenceThatWasPreliminarilyPreservedInsideADataStructureEGATextDocumentOrFromStandardInputEtceteraAfterThisDetailedInformationOnHowToDoOrUseSthWhichTellTheComputerWhatToDoHasFinishedProcessingOrDoingThisJobToBeMorePrecise() Output the value of the current cell under the arch pointer. The reason that this function is so verbose is to make people avoid using it.
==An example (as-is in the Arch page)==
o(512)
s(3)
p
==Computational class==
Char is a bounded-storage machine, as it can be reducted from the Minsky machine with bounded storage.
Preliminary jobs(Pushing a 2 to split 2 accumulators)
s(2)
Commands in the Minsky Machine to reduct from:
INC a, b
JZDEC a, b, c
Now here are the commands created for compiling to the Minsky machine:
INC a(a is after):
s(1)
INC b(b is before):
s(1)o(o--1)
JMP b
g(b)
DEC a:
p()
DEC b:
o(o-1)p()
JZ a, b
e(o(o--1))
g(b)
JZ b, c
e(o(o-1))
g(b)
Now these commands can be used to simulate the Minsky Machine instruction set:
INC a, b =
INC a
JMP b
JZDEC a, b, c =
DEC a
JZ a, b
JMP c
Category:2019
Category:Languages
Category:Unimplemented
CharLang

CharLang is a joke language by user User:5anz, If you've seen B i n a r y, then you'd know this is my second Esolang, and you'd also know that I immediately decided to refer to 5anz as Me, Myself, or I, which I'll do now, and expect me to do that in every proceeding Esolang I make.
==Syntax==
CharLang only uses 2 "commands", the Character, and the esoteric programming language, well, I guess more accurately, Programming Language, but Non-esotecics usually use words, and not letters. You start with the character, then the Esolang, and that's it. If you type "+brainfuck", it will act like you typed a single "+" in the language brainfuck, and that's basically it.
==Yeah.==
IDK what else to add other than... the only things you can really do are print "Hello, World!", "Q", and 99 bottles of beer using HQ9+.
I guess I could mention that you can't (reasonably) make an interpreter for this.
Though it *is* Turing Complete if you make a new Esolang where, say, ! takes input and outputs the factorial.
Otherwise... it isn't.
Category:Languages Category:Joke languages Category:Unimplemented Category:2024
Charcoal

Charcoal is an ASCII-art oriented prefix golfing language designed by the Programming Puzzles and Code Golf users DLosc and ASCII-only. The name is derived from the fact that it has a focus on ASCII art, which is composed of characters.
= Description =
= Tutorial =
Main article: Charcoal§Tutorial
== Literals ==
There are two basic types of literals: strings and numbers. A string is just a run of printable ASCII, and a number is just a run of the superscript digits ⁰¹²³⁴⁵⁶⁷⁸⁹.
Examples:
foo is equivalent to "foo"
foo¶bar is the same as "foo\nbar".
¹²³⁴ evaluates to the number 1234.
== Printing ==
In a Charcoal program, expressions are implicitly printed. Numbers print a line, and arrows can be used to specify a direction.
Examples:
foo prints foo
foo⁴ prints foo----
foo↖⁴ prints:
\ 
 \ 
 \ 
foo\
= Sample Code =
=== Hello, World! ===
Hello, World!
Cheat

Cheat is an esolang by User:None1, it is brainfuck but an empty program is a Hello World program.
==Examples==
===Hello World===
===Cat program===
 ,[.,]
==JavaScript interpreter==
function cheat(program,input){
 if(program.length==0){return "Hello World!";}
 var stack=[];
 var matches={};
 var ip=0;
 var tape=[];
 var p=0;
 var output=;
 for(let i=0;i<1000000;i++){
 tape.push(0);
 }
 for(var i=0;i<program.length;i++){
 if(program[i]=='['){
 stack.push(i);
 }
 if(program[i]==']'){
 if(stack.length==0){
 throw new Error('Right bracket does not match left bracket');
 }
 var mt=stack.pop();
 matches[mt]=i;
 matches[i]=mt;
 }
 }
 if(stack.length!=0){
 throw new Error('Left bracket does not match right bracket');
 }
 while(ip<program.length){
 if(program[ip]=='+'){
 tape[p]=tape[p]+1;
 if(tape[p]==256) tape[p]=0;
 ip=ip+1;
 }
 if(program[ip]=='-'){
 tape[p]=tape[p]-1;
 if(tape[p]==-1) tape[p]=255;
 ip=ip+1;
 }
 if(program[ip]=='>'){
 p=p+1;
 if(p>=1000000){
 throw new Error('Pointer overflow');
 }
 ip=ip+1;
 }
 if(program[ip]=='<'){
 p=p-1;
 if(p<0){
 throw new Error('Pointer underflow');
 }
 ip=ip+1;
 }
 if(program[ip]==','){
 if(input==){
 tape[p]=0;
 }else{
 tape[p]=input.charCodeAt(0)%256;
 input=input.slice(1);
 }
 ip=ip+1;
 }
 if(program[ip]=='.'){
 output+=String.fromCharCode(tape[p]);
 ip=ip+1;
 }
 if(program[ip]=='['){
 if(tape[p]==0){
 ip=matches[ip];
 }else{
 ip=ip+1;
 }
 }
 if(program[ip]==']'){
 if(tape[p]!=0){
 ip=matches[ip];
 }else{
 ip=ip+1;
 }
 }
 if(!('+-,.[]<>'.includes(program[ip]))){
 ip=ip+1;
 }
 }
 return output;
}
Category:Languages
Category:Brainfuck derivatives
Category:Turing complete
Category:2023
Category:Implemented
Cheems

Cheems, also known as Cheems# is a[n] esoteric Programming language built over the course of about.... 10 min at 23:45, September 17 2020. 
Each command within cheems# corresponds to a pixel within a cheem image. . Each pixels cheem value ((redvalue+greenvalue+bluevalue) * x pos + y pos) in the image will then be assigned an ASCII value based on a loop of the values. A data values loop after their max quantity. All pixels in which a cheem is not present (Blank Space) shalt be filled with white.
Commands - Pointer default location is Top Left of the image.
c# - +2 to pointer
@ - -3 to pointer
% - +5 to pointer
^[] - reverse all pointer or arithimetic within the brackets (I.E # becomes #-, which is -2 to pointer)
// - Move Up
VVV - Move Left
cheemright - move up twice
cermfy - move down 51 times
cheemsburger - up down left right left right right right [execute code]
c; : - Loop code contained in ; :69 times. Nice
[] - All movements are doubled within these brackets
flammes - all previous code will be saved to a seperate file that is executed during emstinguish
emsinguish - code from the new flammes file will be executed.
amrithitic - a basic arithimetic function will be chosen based on the RGB value of the 2020 pixel in the cheem pixel in a loop (+, -, /, *)
varmiabale - store the cheem value of pixel 3412 
calm varmiabale - call the saved cheem value.
mervm - pick up a pixel at the pointers location
drompf - drop the pixel at the pointers location
Category:Languages
Category:Unimplemented
Category:2020
Cheese++

Cheese++ is a programming language based almost entirely on the operational working principles of cheese. 
==Syntax==
Cheese++ is case-sensitive.
(Basic) Command 	Description
Cheese 	Begin
NoCheese 	End
Wensleydale() 	Print (to console)
Swiss 	Quotation mark equivalent, used when creating strings.
Glyn(operation) 	The 'variable function'. It must be invoked in every single operation involving a variable, as demonstrated in the examples below. There is only one data type so no data type identifiers are required, saving space. A variable can take any ASCII value.
Cheddar...Coleraine 	repeat ... until
Stilton...Blue...White	if ... then...else
Belgian 	Prints out the entire source code of the program to the console. Useful for debugging.
Brie 	Ends a line/section of code
==Examples==
===Hello World===
 Cheese
 Wensleydale(SwissHello WorldSwiss)Brie
 NoCheese
===Variable declaration===
 Glyn( //initiates variable declarations
 VarName(value) //declares a variable called VarName, of value 'value'
 ) 
 Brie //indicates end of variable declarations
===99 bottles of beer===
Unfortunately, due to a persistent and unprecedented compiler bug, any Wensleydale() functions containing the words 'bottles' and 'beer' cause runtime errors and immediate data corruption. This lends more of a challenge to creating this program. However, it is possible to circumvent this by calling a system function called 'Edam', which replaces occurrences of specified character sets with the words 'bottles' and 'beer' respectively. This occurs as following:
 Edam(word1,word2)Brie
Now to demonstrate the working program:
 Cheese //begins program
 Glyn(Number(99))Brie //declares a variable 'number' of value 99
 Edam(slices,cheese)Brie
 Cheddar //repeat loop
 Wensleydale(Glyn(Number)Swiss slices of cheese on the wall.Swiss)Brie //prints line. Number is outside the swiss tags as it is a variable
 //replaced by 'bottles' and 'beer' at runtime
 Glyn(Number=Number-1) Brie //Glyn operator used 
 Coleraine(Glyn(Number = 0)) Brie //until Number = 0
 NoCheese 
===Quine===
Quines in Cheese++ are easily coded. The function 'Belgian' will print out the entire source code of the program to the console.
 Cheese
 Belgian Brie
 NoCheese
===Cat===
There are no user input functions in base Cheese++, so this is impossible.
==Classification==
Development is in initial stages, but researchers currently believe that in its final form it will be Turing-complete.
==Compiler==
The compiler is still in development. It is being written in its (no longer publicly available) parent language, Cheese+.
Category: 2014
Category: Joke languages
Category: Unusable for programming
Category: Languages