nyuuzyou/wikis huggingface dataset:
Cheese+++

Cheese+++ is set of multiple programming languages which can be nested in one source file and a set of tools for specifying and proving properties about Cheese+++ programs. It is believed to be designed and implemented under a secret project funded by The Big Cheese for a wide range of purposes including but not limited to natural language processing and in particular automated pun development. Cheese+++ programmers call themselves cheesemakers.
== Syntax and Semantics ==
Sequences of the four cheesy codons Cheddar, Brie, Feta, Stilton are used in what's called a culture to build "cheese selections" which undergo coagulation and interact in complicated ways similar to proteins of a genetic code. Cheese+++ programs must be modified to work under different altitudes.
The formal methods toolkit Caerphilly is used for quality control by specifying properties of Cheese+++ programs and then the cheesemakers must work very hard to justify every proof obligation to show the program is valid. Valid Cheese+++ programs can be compiled into a low level assembly language with proof carrying code called Roquefort.
== Implementation ==
The entire toolkit including a pasteurizing supercompiler based on the fourth futamura projection was under development, programmed in Cheese++ but the source code went rotten so it was deleted.
== See also ==
* Cheese, Cheese+, Cheese++
* http://en.wikipedia.org/wiki/List_of_cheesemakers
Category: 2014
Category: Joke languages
Category: Unusable for programming
Category: Languages
Cheesecake

== Cheesecake ==
Cheesecake is a silly esolang that User:Nebular created in a few hours.
It is very simple and only contains 'cheese' and 'cake' (also 'cheesecake' BUT IT'S A COMBINATION OF CHEESE AND CAKE!!!).
It's syntax is quite simple. Each instruction is on a new line. Commands and arguments are seperated by 'cheesecake'.
Instructions:
cheese: push
cake: discard
cheese cake: duplicate
cake cheese: swap
cheese cheese: addition
cake cake: subtraction
cheese cheese cheese: multiplication
cheese cheese cake: division
cheese cake cake: jump if zero
cake cake cake: print ascii character
cheese cheese cheese cheese: print number
cheese cheese cheese cake: take user input
Cheesecake is:
# Stack based
# Extremely hard to use
# Delicious
# Sadly not for consumption
When looking at a program, you might see that 'cake' has a lot of e's.
This is because the amount of e's - 1 is a number.
If your number doesn't start with 'cake' you will get an error that tells you that your number is not delicious enough, so FIX IT!
== Truth machine ==
cheese cheese cheese cake
cheese cheesecake cakeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
cake cake
cheese cake cake cheesecake cakeeeeeeeeeee
cake
cheese cheesecake cakee
cheese cheese cheese cheese
cheese cheesecake cake
cheese cake cake cheesecake cakeeeeee
cheese cheesecake cake
cheese cheese cheese cheese
== Hello world ==
cheese cheesecake cakeeeeeeee
cheese cheesecake cakeeeeeeeeeee
cheese cheese cheese
cheese cheesecake cakeee
cheese cheese
cheese cake
cake cake cake
cheese cheesecake cakeeee
cheese cheesecake cakeeeeeeeeeee
cheese cheese cheese
cheese cheese
cheese cheesecake cakee
cake cake
cheese cake
cake cake cake
cheese cheesecake cakeeeeeeee
cheese cheese
cheese cake
cake cake cake
cheese cake
cake cake cake
cheese cheesecake cakeeee
cheese cheese
cheese cake
cake cake cake
cheese cheesecake cakeeeee
cheese cheesecake cakeeeeeeeeeeee
cheese cheese cheese
cheese cake
cake cake cake
cheese cheesecake cakeeeeeeeeeeeee
cake cake
cake cake cake
cheese cheesecake cakeeeeeeeee
cheese cheese
cheese cake
cake cake cake
cheese cheesecake cakeeeeeeeee
cake cake
cheese cake
cake cake cake
cheese cheesecake cakeeee
cheese cheese
cheese cake
cake cake cake
cheese cheesecake cakeeeeeee
cake cake
cheese cake
cake cake cake
cheese cheesecake cakeeeeeeeee
cake cake
cake cake cake
cheese cheesecake cakeeeeeeeeeeee
cheese cheesecake cakeeee
cheese cheese cheese
cake cake cake
== Implementation ==
I've already written a working intrepreter for Cheesecake in Rust, but I still have to do some tweaks to it to avoid any silly errors you could possibly get before I will publish the source code.
Category:Languages
Category:Stack-based
Category:Implemented
Category:Pseudonatural
Category:Thematic
Chespirito

Chespirito is a brainfuck clone that uses some famous words created by Chespirito as instructions. Created by User:DeybisMelendez.
Brainfuck	Chespirito
+ 	chilindrina
- 	chiquitolina
> 	chompiras
< 	chaparron
[ 	chipote
] 	chillon
. 	chanfle
, 	chapulin
A new instruction called "chiripiolca" is added which prints random characters in an infinite loop.
== Examples ==
=== Cat program ===
 chipote chilindrina chapulin chanfle chiquitolina chillon
=== Random characters ===
 chiripiolca
== Implementation ==
=== Lua ===
The interpreter written in Lua can be obtained here.
Category:LanguagesCategory:2020Category:ImplementedCategory:Brainfuck_derivativesCategory:Joke_languagesCategory:Turing completeCategory:Turing tarpitsCategory:PseudonaturalCategory:Thematic
Chevron

= about =
chevron is an esoteric yet (somewhat) readable language. it makes heavy use of the <, >, and ^ characters, hence its name.
== github ==
superloach/chevron
== docs ==
DOCS.md
== web runner ==
 (seemingly broken)
== install ==
go get -u github.com/superloach/chevron/cmd/ch
Category:Languages Category:Turing complete Category:Implemented Category:2019 Category:High-level
Child

Child is an esoteric programming language in the vein of Brainfuck. It is cell-based like Bf,
but it is oriented to support data processing.
There is an input string and an output buffer. A few commands read input character-by-character,
allowing end-of-data detection. The program takes the input string and the program as shell parameters.
The interpreter has a "register" which catches the hexadecimal numbers found in the program. "2a+" adds the byte 0x2A to the current cell, for example.
The implementation is placed under the terms of Tcl/Tk's BSD-style license.
== External resources ==
* Child home page: the official implementation. 
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
Category:Unknown year
Category:Cell-based
ChinaScript

ChinaScript is a Esolang with Chinese as its script.
== Commands ==
Write the program that you want to let it do in your program.
== Example ==
=== Hello, world! ===
 输出"Hello, world!"。
=== A+B Problem ===
输入两个整数，求出它们的和然后输出。
=== Guessing Number ===
给出一个位于-50至50之间的随机整数答案。
读入游玩次数。
只要游玩次数大于0，那么：
 读入猜测数字，并将其与答案比较。
 如果猜测数字和答案相等，则输出"That's it! Thank you for playing!"，然后直接跳出循环。
 如果猜测数字比答案大，则输出f"{猜测数字} is too big! Try again."，然后将游玩次数减去1。
 如果猜测数字比答案小，则输出f"{猜测数字} is too small! Try again."，然后将游玩次数减去1。
=== ඞlang's interpreter ===
输入一串字符串，把它扔了，然后输出"ඞ"。
=== 2D Maze ===
输入两个整数长和宽，然后输入一个长乘以宽大小，且由'.'和'#'构成的迷宫。
再读入四个整数，分别是入口坐标和出口坐标。
在入口坐标处放置一个指针。
'.'处允许指针通过，而'#'则反之。
当指针沿最短路径走出迷宫后，输出其经过的坐标。
但是，如果指针没能走出迷宫，而且走回了入口，则输出
"""
哼哼哼啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊
啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊
啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊
啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊
啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊
啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊
啊啊啊！！！！！！！"""。
== Categories ==
Category:Languages Category:Pseudonatural Category:CJK Category:High-level
Chinese

Chinese is a compression scheme for brainfuck.
Brainfuck command	Number equivalent
+ 	1
- 	2
> 	3
< 	4
[ 	5
] 	6
. 	7
, 	8
Take a brainfuck program, then for every 4 characters, get the number equivalent. For example, ,[.,] would be 8578 1
Once you have the number equivalents for every 4 characters, use each group as the serial number in the Modern Chinese Character Frequency List. For example, 8578 1 would become 鏢的 (8,578th and 1st characters in the list).
Additionally, in the case that it would be more efficient to condense multiple instances of the same character, you can use 9, the number equivalent, and the times you want it repeated. For example, instead of representing ++++++++++++++ as 缓缓缓这 (1111 1111 1111 11), you could make it 艼 (9114). This goes up to 109, for example character 913 is +++ while 9103 is 103 of +
== ASCII only ==
Combine groups of 2. Subtract 11 from each group. This gives you a base 8 number. Convert to decimal, and 0-25 = a-z, 26-51 = A-Z, 52-61 = 1-9, 62 = :, 63 = ;
This encoding is otherwise known as "yet another variant of base64".
Category:Languages
Category:Brainfuck derivatives
Category:CJK
ChineseScript

ChineseScript is yet another compression scheme using Chinese letters, but this time for GolfScript.
For every two characters in a GolfScript program, take the ASCII values (except newlines, they are 31). Then, subtract 30 from both, and use the concatenated value as a serial key in the Modern Chinese Character Frequency List to get a chinese character for use in the program. This method can also be used for single characters (mainly for when there is an odd number of characters in the program).
In addition, the following values have their own character allocated:
ChineseScript command	Modern Chinese CFL Serial	GolfScript command
荙 	9900 	zip
Category:Concepts
Chomp

Chomp is a program language in the which the programmer must use bitwise operations, which can be performed with an instruction pointer. There is a stack to store and get bytes, as well as subroutines for use. Commands are separated with a newline. Note that the program starts by running the subroutine "main".
==Commands==
 prev - jump to previous bit
 next - jump to next bit
 move V - move V bits
 flip - set a bit to opposite value
 zero - zero a bit
 def ID - define subroutine ID
 run ID - run the subroutine with the ID
 ret - return from subroutine 
 hop - skip the next command if bit is 0
 push - push byte onto stack
 pop - pop byte off stack, write to byte register
 out - print byte as char
 in - get input as char
 halt - halt
 cmt - a comment
Category:Languages
Choon

Choon is an esoteric programming language that produces musical notes as its only output. It also has no data storage, but it can read any note it has previously output. Choon is Turing-complete and was invented in 2002 by Stephen Sykes.
Choon was submitted to the 2002 Esoteric Awards.
==See also==
Musical notes, an esolang based on music.
==External resources==
* The Choon Programming Language
Category:Languages
Category:Implemented
Category:Turing complete
Category:2002
Chops

Chops is an esoteric programming language where it's instructions are variable, dependent on the previous ASCII character created by User:Buckets, created to fill the purpose of "What if I just made an esolang, so that It's hard enough to look like garbage, but easy to make a machine to randomly (With enough time) make a program?", so with that goal, User:Buckets Achieved their goal, and this is the product.
Variable Commands 	Instructions
Same as the previous Character	+1
+1 of the previous Character 	Push the number of the next Character in ASCII
+3 of the previous Character 	pop the number of the next Character in ASCII
+4 of the previous Character 	Subtract the top two values on the stack, top-bottom.
-3 of the previous Character 	Pushes the next character on the top of the stack.
-4 of the previous Character 	Swaps the top two values on the stack.
/3 of the previous Character 	Print.
(But not the next character, the last data used or the newest popped data.(Also note that It does not automatically print in ASCII, that's why there's 2 pushes.))
/4 of the previous Character 	This instruction is a not gate for the top of the stack. (If the top of the stack is 1, then replace it with a 0, If the top of the stack is 0, replace it with a 1.)
*3 of the previous Character 	pop the number of the next Character in ASCII
*4 of the previous Character 	Add top two values.
+2 of the previous Character 	End program.
-1 of the previous Character 	Go to Line-The number of the next character.
-2 of the previous Character 	-1
*2 of the previous Character 	If = Next character, If true, go to Next *2, Else go to Next next *2.
/2 of the previous Character 	Input, Classed, Next character.
+5 of the previous Character 	Multiply top two values.
-5 of the previous Character 	Divide top two values. (Bottom/Top)
-6 of the previous Character 	Mod top two values. (Bottom/Top)
(Line feed) 	Set the number of the next character in Extended ASCII.
There are two 'classes' of stacks, a number stack where It stores a number, and an Extended ASCII stack, where it stores an Extended ASCII character.
"Hello, World!" Program:
 (Line feed)
 c`H H
 c`e/ec`lDl$
 c`oMo
 c`,**~*
 ` 
 c`WWUÿU
 c`oMo
 c`rVr
 c`lDl
 c`d,d
 c`!c!#
Category:Languages
Category:Joke languages
Category:2024
Category:Stack-based
Chordfuck

Chordfuck is based on music and brainfuck. It is designed by PSTF.
== Command Table ==
 Command Table
Chordfuck 	Brainfuck
Major 	>
Minor 	<
Augmented 	+
Diminished 	-
Major 6th 	,
Dominant 7th 	.
Suspended 4th	[
Suspended 2nd	]
== Example ==
=== Cat program ===
=== Hello, world! ===
I didn't have time to do it.
== See also ==
brainfuck
== Categories ==
Category:Languages
Category:Turing tarpits
Category:Low-level
Category:Cell-based
Category:Implemented
Category:Brainfuck equivalents
Category:Brainfuck derivatives
Category:2024
Category:Turing complete
Chris Pressey

Chris Pressey has been a member of the Esolang community from the time of his invention of Befunge in 1993 to present, most actively during the years 1997 to 2002.
Starting in 1995, he ran the Befunge Mailing List, which experienced a surge of activity in early 1997 after the Befunge web page was listed as Geek Site of the Day. Shortly thereafter, he maintained a web page titled Esoteric Topics in Computer Programming. The Befunge Mailing List evolved into the Esoteric Topics Mailing List, and it was at this point that the designation "esoteric" began to be attached to esoteric programming languages.
While the Esoteric Topics web page is now defunct, this wiki serves as a much more comprehensive and well-researched modern-day equivalent.
Chris is the designer of many programming languages, mostly esoteric. These include ALPACA, Befunge, SMETANA, RUBE, RedGreen, SMITH, Hunter, noit o' mnain worb, Squishy2K, Shelta, Strelnokoff, Version, and 2iota. He is also a co-designer of Wierd. He has written implementations of a handful of other esolangs, including Brainfuck (PIBFI) and Muriel.
==See also==
* Chris Pressey's user page on this wiki.
==External resources==
* at his website 
Category: People
ChromaCode

ChromaCode is an esoteric 2d programming language that operates on infinite memory, a stack and a program image. Each instruction is a color on an image that performs operations like moving the program counter, manipulating stack values, and basic arithmetic.
The program counter is always moving, starting out moving to the right and the direction being able to be altered by instructions.
== Examples ==
=== Hi! ===
=== Check if input is even ===
=== List even numbers in range from input to 0 ===
=== Truth Machine ===
=== XKCD Random Number ===
=== Fibonacci sequence ===
=== Factorial ===
=== Cat Program (String) ===
=== Cat Program (Number) ===
== Instructions ==
* #000088 - Load: Put a value from memory onto the stack.
 
* #008800 - Store: Pop a value from the stack, and set the current memory cell to that value.
 
* #add8e6 - IncPtr: Moves the memory pointer to the right.
 
* #5454eb - DecPtr: Moves the memory pointer to the left.
 
* #ad0000 - Pop: Pops the stack.
 
* #ff9100 - Dup: Duplicates the top value on the stack.
 
* #ffd000 - Swap: Swaps two top stack values.
 
* #800080 - Inc: Increments the top value on the stack.
 
* #ffc0cb - Dec: Decrements the top value on the stack.
 
* #ff0000 - Add: Adds the two top values on the stack.
 
* #0000aa - Sub: Subtracts the two top values on the stack.
 
* #ff00ff - Mul: Multiplies the two top values on the stack.
 
* #a0a0a0 - Div: Does integer division on the two top values on the stack.
 
* #5c5c5c - Mod: Calculates the remainder of the top two values on the stack and pushes the result.
 
* #0000ff - Left: Set the program counter direction to "Left".
 
* #000050 - Right: Set the program counter direction to "Right".
 
* #00ff00 - Up: Set the program counter direction to "Up".
 
* #005000 - Down: Set the program counter direction to "Down".
 
* #c4c4c4 - Mirror: Set the program counter direction to the opposite of the current one.
 
* #40e0d0 - Random Direction: Set the program counter direction to a random one.
 
* #ffffff - Skip: Skip one pixel, useful for crossings.
 
* #1c1b1b - Conditional Skip: Skip one pixel, if the top stack value isnt zero.
 
* #00ffff - PrintNum: Pops the stack and prints a number.
 
* #008080 - PrintStr: Pops the stack and prints the Unicode character of the value.
 
* #4b0082 - Input: Pushes a number inputted by user to the stack if the input is a number, if it's a string, pushes it to the stack in reverse order.
 
* #8b0000 - End: Terminates the program.
 
* #00aa00 - RevStack: Reverses the stack. ([1,2,3,4] -> [4,3,2,1])
== Interpreters == 
The official interpreter written by QuantumV: https://github.com/QuantumV2/ChromaCode, Requires PIL and NumPY
Category:Languages Category:Non-textual Category:Stack-based Category:Cell-based Category:Two-dimensional languages
Chromos

Chromos is an esoteric programming language made by Areallycoolusername. It's based of of RNA, except it uses chromosomes instead of the RNA itself.
== Commands ==
There are no specific commands recognized by the interpreter. This is due to the fact that chromosomes are fabricated by the user in the code. However, the order in which these chromosomes come in is recognized. In this language, valid chromosome names are int he form of two letters, such as this: AB this: Ab this: aa or this: bb Of course, the letters are replaceable by any letter the user wants, as long as thay are letter sof the English alphabet, and either capital or lowercase. Capital letters are dominant traits, and lowercase letters are recessive traits.
== Specifics ==
The interpreter starts by prompting the input of 23 chromosome pairs. The user is to specify this set with the command "/FE/", for female. Then, the interpreter prompts the user for 23 more chromosome pairs which is specified by "/MA/", for male. Once these chromosomes are put in, mixing occurs. The dominant trait in each pair is chosen for the offspring, unless the pair include both recessive traits, like "bb". The dominant chromosomes of the offspring are then printed, which allows for a successful program.
Category:Languages
Category:Unimplemented
Chronofuck

Chronofuck is a theoretical programming language conceived by user:Jabutosama. It is a brainfuck derivative based on an idea of playing with causality and time.
==Commands==
You can divide the commands into classic brainfuck and added ones.
===Classic Brainfuck commands===
Command	Meaning 	Reversed
+ 	adds 1 to current cell 	subtracts
> 	moves the cell pointer to right 	moves to left
{ 	if current cell is zero jump to matching }	flips to }.
} 	if current cell is zero jump to matching {	flips to {.
. 	prints current value as a character 	takes brainfuck -style input
===New Commands===
The term "x" in the following context refers to a value stored in the current cell.
Command	Meaning 	Reversed
W 	walk time; execute exactly x instructions, then jump to proceeding instruction. 	goes to opposite direction in code
J 	jump time; jump x instructions. 	goes to opposite direction in code
E 	erase time; erases x instructions from continuity, applying consequences for following x instructions, after jumps to proceeding instruction.	goes to opposite direction in time
P 	push time; next x instructions are skipped. then after next x instructions, execute the skipped ones. 	goes to opposite direction in code
R 	reverse time; reverses the instruction read direction. 	no difference
Category:Languages
Category:Brainfuck derivatives
Chronos

Chronos is a two dimensional esoteric programming language based off of Befunge, with the ability to time travel.
==Time Travel==
Chronos offers the ability for instruction pointers (cursors) to time travel. The language does not track actual time; rather, each execution is thought of as advancing time by one moment. Time starts at moment t = 0.
Chronos uses the branching timelines framework when dealing with time travel. When a cursor travels to a different point in time, a new timeline is created, with its own local cursor. Every cursor contains a local stack, so there may be multiple independent stacks at a given moment. The only output, if any, which is displayed is that which is generated by the finally constructed timeline.
Cursor intersection is permitted, but when two cursors attempt to execute instructions with interfere with one another, the cursor which has most recently time travelled will take priority. This is motivated by the idea that a time traveller goes back in time to correct a prior action, and thus they take priority.
==Instructions==
> Set cursor orientation to RIGHT.
< Set cursor orientation to LEFT.
^ Set cursor orientation to UP.
v Set cursor orientation to DOWN.
0-9 Push number to stack.
+ Pop a, b, push a + b to stack.
- Pop a, b, push b - a to stack.
* Pop a, b, push a * b to stack.
/ Pop a, b, push b / a (integer division) to stack.
% Pop a, b, push b mod a to stack.
? Pop a, skip the next character if a ≠ 0.
! Pop a, push 0 if a ≠ 0, push 1 if a = 0.
g Pop y, x, push program character at (x,y) to stack.
p Pop v, y, x, place character v at (x,y) in program.
: Duplicate the top stack element.
\ Swap the top two stack elements.
" Toggle string mode.
, Pop a, output character a.
. Pop a, output value a.
i Read input, push to stack.
t Pop a, time travel to time t = a.
@ Stop cursor.
==Examples==
===Hello, World!===
 > v
 v"Hello World!"0<
 >:?v,v
 ^ <
 @
===Back in Time===
Travels back in time (placing an "@" end command to prevent an infinite loop of travelling back in time).
 > 0t"@"90p@
===Bello, World!===
Outputs "Hello, World!" in timeline 1 (not displayed), then time travels to timeline 2 and alters character "H" to "B", causing the timeline 2-native cursor to print "Bello, World!".
 > v
 v"Hello, World!"0<
 >,:?vv
 ^ <
 >0t"B"21p"@"64p@
===Always Wrong===
Asks for user input. Then, if necessary, travels back in time so that it asked for the input which the user did not provide.
 > v
 v"I have chosen the number 0. Try and input the same number."0<
 >,:?vv
 ^ <
 >i22223****\- ?vv
 v+19"You chose wrong!"0 <
 >,:?vv >0t"1"999++1p"v"997++6p@
 ^ < ^<
 @
==Interpreter==
===chronos.py===
The official interpreter, available at https://github.com/Zasharan2/chronos.
Category:Languages Category:Two-dimensional languages Category:Stack-based Category:Implemented Category:2024
Church-Turing thesis

The Church-Turing thesis states that a Turing machine (or any other Turing-complete system, such as the Lambda calculus) embodies the intuitive notion of what is "effectively calculable." It is usually interpreted to mean that it is impossible to devise an algorithm that cannot be expressed as a Turing machine. The thesis specifically refers to algorithms with a finite number of well-defined steps, that result in the correct answer for any input, and which do so in a finite amount of time.
Some take the thesis to provide metaphysical justification that no algorithms of any form in our physical universe can possibly compute functions that a Turing machine cannot. Such interpretations are well beyond the scope of the mathematics of the proof, which don't refer to physical processes.
Category: Concepts