nyuuzyou/wikis huggingface dataset:
CPL

The programming language CPL is designed to accept comments in all forms and types, and nothing else. Brian Egge is the author of the language, and also implementor of the only known implementation.
The author points out porting CPL to other platforms would be fairly painless, while critics claim it would be fairly pointless.
==External resources==
*CPL SourceForge project with open source implementation in C.
Category: 2004
Category: Joke languages
Category: Unusable for programming
Category: Implemented
Category:Languages
CQfuck

CQfuck is an esolang by User:ChuckEsoteric08 where [ and ] use Call Queue instead.
==How it works==
[ would enqueue IP. If cell is nonzero while ] is executed then it would dequeue element and set IP to it. Otherwise it would just dequeue element
==Examples==
===Cat Program===
 [,.]
===Print HI===
 +++++++[->++++++++++<]>++.+.
===Truth-machine===
 ,[->+>+<<]>>>++++++++[-<<------>>]<<[>.<]
==Interpreter==
* Common Lisp implementation of the CQfuck programming language.
Category:Languages Category:Unknown computational class Category:Brainfuck derivatives Category:Cell-based
CQuents

cQuents is a language created by Stephen S to quickly define and query sequences and series. It is still a WIP language. For more information, see the Github link.
==Online Interpreter==
Hosted on Try It Online! thanks to Dennis of PPCG. May or may not be up to date.
https://tio.run/#cquents
 
==Links==
https://github.com/stestoltz/cQuents
Category:Languages
Category:Implemented
CRTL

CRTL, short for "Constantly Rewriting Term Language", is a silly, uncompilable, self-modifying esolang by User:ehird.
== Syntax ==
Whitespace is ignored outside of string_contents.
expression = '"' string_contents '"'
 | '(' expression ')'
 | name
 | quoted
 | expression '->' expression
 | expression '~' expression
quoted = "'" name
 | "'" quoted
name is a sequence of one or more alphanumeric characters.
string_contents can contain any character apart from ". If a " is desired, it must be escaped with a backslash: \". If you want a \, you have to escape that too: \\.
A program is a sequence of expressions, seperated by ;. Excess ;s are just ignored.
== Evaluation ==
We evaluate the rewrite rules of the form A -> B, in any order. After doing each substitution, we check for the lone literals and print them out (more details below). Then, we replace according to another rule, check again, replace again, etc., until we have a run where nothing is substituted, at which case the program ends.
=== Rules ===
in: "literal";
Displayed, without quotes and unescaped, to standard output (without any newline or space following it).
in: A -> B;
In all statements apart from this one, A is found - whether A is a literal, another expression, or anything -- and is replaced with B. (Strings are searched in for A and only the substring is replaced by B)
in: A with free names -> B;
In all statements apart from this one, A is found, where a free name means "anything". What is there instead of a free name is bound to that name in B (thus becoming non-free), and all occurences of it in B are replaced with that value. If B contains free names that neither A or B define, it is an error. So this program is invalid:
(a->(b->c))->(a->d);
"blah"->(d->d)
in: A ~ B
A and B must resolve to strings (they can be literals or free names, see above). They are concatentated together, and that is the result of this expression (NOT statement)
in: 'A
Matches the free name A if A is a name, or the quoted expression A if A is a quoted expression.
== Examples ==
=== Hello, world! ===
"Hello, world!";
For something a little less boring:
"QWERTY"->"Hello, ";
"UIOP"->"world!";
"QWERTYUIOP"
Even less boring:
("say hello"->x)->("Hello, "~x~"!");
"thingy"->"wor";
"mabob"->"ld";
"say hello"->"thingymabob"
=== Silly thing demonstrating ~ ===
Prints "barbar".
("foo"~xs)->(xs~"bar");
"foobar"
=== Fibonacci numbers ===
Written by oklopol. Outputs in the form "previous|current" in unary.
(("fib"->a)->b)->b~"|"~a~b;
a~"|"~b->(("fib"->a)->b);
("fib"->"1")->"1"
Category:2008
Category:Languages
CRalphabet

CRalphabet is a joke(ish) language created by Splat. CRab takes '\n' and 'SPACE' as its only commands/arguments. Source code is comprised of varying length strings of \n. The number of \n's denotes an alphabetical character(a-z). This character is then printed out to the console.The 'SPACE' keyword denotes printing " " to the screen.
==Example==
The following code prints "hello world" to the console.
 \n\n\n\n\n\n\n\n
 \n\n\n\n\n
 \n\n\n\n\n\n\n\n\n\n\n\n
 \n\n\n\n\n\n\n\n\n\n\n\n
 \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
 SPACE
 \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
 \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
 \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
 \n\n\n\n\n\n\n\n\n\n\n\n
 \n\n\n\n
==Implementation==
Implementation in Haskell:
 main = interact $ map cmd . words
 cmd "SPACE" = ' '
 cmd l | l == concat (replicate n "\\n") = ['`'..'z'] !! n
 where n = length l `div` 2
Category: Joke languages
Category: Unusable for programming
Category: Implemented
Category: Output only
Category:Languages
CSL

Command Stack Language (CSL for short, CSLAAI2D* for long) is a 2D, stack-based programming language by User:Actuallyallama.
The language features two stacks - one for actual memory, one for instructions.
The instruction pointer works as it does in many languages. It is manipulated by directional commands, and will wrap around.
The difference in this language, is rather than immediately executing instructions, it instead adds the instruction to the top of the instruction stack and executes it when at a special execution instruction. Since it's a stack, all of the instructions will execute in reverse order to the order they are added.
== Commands ==
Command	Name	Description
! 	EOF 	Terminate program.
e 	EXC 	Execute the command on top of the stack.
E 	EX2 	Execute all commands on the stack.
v 	MDN 	Switches instruction direction
< 	MLT 	Switches instruction direction
> 	MRT 	Switches instruction direction
^ 	MUP 	Switches instruction direction
{ 	CLF 	If pop == 0, move left. Else, keep direction.
} 	CRF 	If pop != 0, move right. Else, keep direction.
1 	ONE 	Push a 1 onto the stack.
D 	DUP 	Duplicate the top of the stack.
P 	PRT 	Pop the top of the stack and print it.
p 	PRA 	Pop the top of the stack and print it as ASCII character.
N 	PRN 	Print a line terminator.
+ 	INC 	Pop the top, increment it by 1, push it.
- 	DEC 	Pop the top, decrement it by 1, push it.
& 	ADD 	Pop the top two items, add them. Push result.
* 	MUL 	Pop the top two items, multiply them. Push result.
_ 	SUB 	Pop the top two items, subtract them. Push result.
~ 	SWT 	Switch the top two items.
| 	NUL 	Pop the top item, and discard it.
$ 	BRK 	Break out of mass execution (E).
? 	CEX 	If pop == 0, pop the top command and invoke. Else pop top command and discard.
== Examples ==
Hello World:
 p&1*+1*+++1+++1p_~+++++++1pD_~+++++1pD&++1pD&*+++1+++++1pD&*++1++++1pp&&D+++++1D*+1*D+++1|p&++1pDpD&++++++1pD&+++1&*++++1++++1DDpD*+1*D+++++1E!
provides the following output:
 Hello, World!
== Implementations ==
The file extension for code it runs is ".csl"
Interpreter in C#
== Footnotes ==
*Stands for "Command Stack Language (And Also In 2 Dimensions)"
Category: Languages
Category: Stack-based
Category: Two-dimensional_languages
Category: Implemented
Category: 2016
CTBASIC

CTBASIC is a compiled Sinclair BASIC inspired language imagined by User:Salpynx targeting a cyclic tag system "fantasy console" architecture.
The language is written using high-level output commands and compiled into a range of cyclic tag dialects, such as CT {0, 1, ;}, or BCT {0, 1}.
==Data string output convention==
The key feature of the CTBASIC architecture is a particular set of output conventions which distinguish a CTBASIC machine from a plain cyclic-tag interpreter.
This output feedback assists writing and evaluating cyclic tag system programs.
Byte strings can be encoded and recognised within the data-string:
* 8 bit bytes are encoded within a 10 bit data-frame with start-bit 1 and end-bit 0.
* A string is a series of 10-bit frames beginning with the ASCII C0 STX character (0x02), and terminated by the ETX character (0x03).
* When a valid string is completed, (i.e. the stop-bit 0 of the ETX is appended to the right of the data-string) the complete string is sent to output.
Output is a serial byte-stream, with flexible destinations.
* The CTBASIC language has drawing commands which when compiled produce serial byte output that can be recognised by wikipedia:Tektronix_4010 compatible terminals.
* Non-graphical serial terminals are also intended to be supported for character output.
Commands are effectively macros to simplify forming output using the provided conventions.
* PRINT, CHR$, CLS, PLOT, DRAW, and INK for output.
* BIN, DATA, FILL, ZFILL, ASM for internal data.
* CLEAR unconditionally clears bits from the data string. 
All control flow is provided by the underlying cyclic tag mechanism.
==Examples==
REM Hello, World! output example.
PRINT "Hello, World!"
==External resources==
* CTBASIC cyclic-tag compiler and interpreter with graphical (Tektronix 4010 / xterm) output examples, including looping animations.
Category:Languages
Category:Turing complete
Category:2022
Category:Implemented
CTFuck

CTFuck is a turing complete esolang created by User:Pro465, based on a tag system, with I/O support.
this is kinda simliar to Boolfuck, in that it operates on bits and has I/O support.
however, CTFuck is based on a tag system.
The reference implementation along with examples are here.
==Commands==
supported commands are:
command	operation
$ 	pop 1 bit off the front of queue
0 	push 0 to the back of queue
1 	push 1 to the back of queue
: 	duplicate bit at the front of queue, and push it to the back of queue
. 	output the bit at the front of the queue
, 	get the next bit of input and push it to the back of the queue
..] 	see note
any character other than these are ignored.
==Turing Completeness==
CTFuck is turing complete. To prove this, we can take a similar path to how BCT was proved turing complete: we can translate each CT (we are using the same language the BCT page used) command to an equivalent sequence of commands in CTF.
CT command 	CTF Equivalent
<program end>	1]
0 	0
1 	1
; 	<current line number + 1>]
...or we can just compile boolfuck to it
==Sample Programs==
===Cat===
 0
 $,.[1|1]
===Truth Machine===
,[|3]
 $1010.$...$..$..[|2]
 $010....$..$..
===Hello world===
0...$1.$0..$1.$0.
$1.$0.$1.$0..$1..$0.
..$1..$0.$1..$0.
..$1..$0.$1..$0.
$1....$0.$1..$0.
..$1..$0.$1.$0..
.....$1.$0..
$1...$0.$1...$0.
$1....$0.$1..$0.
.$1.$0..$1...$0.
..$1..$0.$1..$0.
..$1.$0..$1..$0.
$1.$0....$1.$0..
.$1.$0.$1.$0....
==Notes==
===IO endianness===
Like BoolFuck, IO in CTF is little-endian.
===The [if_num|else_num] command===
it takes two numbers in base-10 format, separated by `|` (pipe symbol).
when it is executed, it checks the bit at the top of the queue;
if it is 1 it calls goto(if_num), otherwise it calls goto(else_num).
goto(n) is defined as follows:
 if n == 0 || n == "":
 pass
 else:
 jump to the first command in line n
===Halting===
execution is halted when either:
# the interpreter reaches the end of the program source.
# the interpreter tries to execute one of the following commands and the queue is empty:
* [..|..]
* $
* .
== See also ==
* Cyclic tag
Other languages operating on bits (implemented only):
* FlipJump
* BIT
* BoolX
* Bitch
* BitChanger
* Bitter
* Boolet
* BitBitJump
* Smallfuck
Category: Languages
Category: Implemented
Category: Queue-based
Category: Turing complete
Category: Turing tarpits
CW@ 3 cell brainfuck substitution

this is a way to convert any COPY WITH @ code to brainfuck with 3 cells and the other way around
== substiution ==
all code needs to start with:
 -@@
then these are the substitutions:
BF 	CW@
> 	↷↷
< 	↷
. 	;
+ 	+
- 	-
, 	#?
[...]	{...}
Category:Proofs
CXESO

CXESO is an esoteric programming language implemented by User:BoundedBeans in TI-BASIC on a TI-84 Plus CE calculator. It's mainly inspired by brainfuck (for most commands) and bitch (for the loop commands).
==Data storage==
CXESO has a tape of up to 999 complex numbers (implemented as a TI-84 list variable). The complex numbers really behave more like pairs of numbers though, and don't really function like mathematical complex numbers due to the minimalism of the instruction set.
==Commands==
Command	Semantics
[ 	Move the data pointer left.
] 	Move the data pointer right.
+ 	Increment the pointed complex number's real part by 1.
- 	Decrement the pointed complex number's real part by 1.
} 	Increment the pointed complex number's imaginary part by 1.
{ 	Decrement the pointed complex number's imaginary part by 1.
= 	If the pointed complex number's real part is 0, skip the next command.
≠ 	If the pointed complex number's imaginary part is 0, skip the next command.
> 	Set jump point A to this command.
≥ 	Set jump point B to this command.
< 	Goto jump point A. This is useful along with the = and ≠ commands to conditionally do the jump.
≤ 	Goto jump point B. This is useful along with the = and ≠ commands to conditionally do the jump.
? 	Input a complex number and store it in the list at the data pointer.
Θ 	Output the currently pointed complex number.
Goto 	Skips to the next occurrence of the Stop command. Note that a space after "Goto" is required but doesn't show up on wiki formatting ("Goto " and "Stop" are treated as single characters in the TI-84 calculator). This is useful along with the = and ≠ commands to conditionally do the jump.
==Examples==
===Add two real integers >= 1===
 ?]?>-[+]=<[Θ
===Multiply two real integers >= 1===
 ?]?-[>-]]+]+[[[=<]]]>-[[[+]]]=<[[>-]≥-]+[[[+]]=≤]≥-[+]=≤[[=<[Θ
Takes approximately 10 seconds to multiply 3 * 2 on the TI-84, larger numbers will take even longer.
==Original TI-84 Basic code==
Unfortunately you need to type this in manually into the calculator like the old days. Or you could translate it to some other language. Note that every alphanumeric in this code that has any lowercase letters is a single symbol that you have to find somewhere (Stop is in prgm->CTL for example)
:Ans→Str5
:{0}→L₁
:1→V
:1→W
:1→D
:For(I,1,length(Str5),1
:sub(Str5,I,1→Str6
:If Str6="[
:D-1→D
:If Str6="]
:Then
:D+1→D
:If D>dim(L₁
:1+dim(L₁→dim(L₁)
:End
:If Str6="+
:1+L₁(D→L₁(D
:If Str6="-
:‾1+L₁(D→L₁(D
:If Str6="}
:i+L₁(D→L₁(D
:If Str6="{
:‾i+L₁(D→L₁(D
:If Str6="=" and real(L₁(D))=0 or Str6="≠" and imag(L₁(D))=0
:I+1→I
:If Str6=">
:I→V
:If Str6="≥
:I→W
:If Str6="<
:V→I
:If Str6="≤
:W→I
:If Str6="?
:Then
:Input Θ
:Θ→L₁(D
:End
:If Str6="Θ
:Disp L₁(D
:If Str6="Goto 
:inString(Str5,"Stop",I→I
:End
Category:Languages
Category:Cell-based
Category:Brainfuck derivatives
Category:Unknown computational class
CYOA

== Overview == 
CYOA is a stack based semi-2d esolang. Operates on two stacks of bits, the first initialized with input (or empty if no input is given), the second starting empty. Popping an empty stack halts.
== Instructions ==
=== stack: ===
1: push a 1
0: pop a bit
%: flip the top bit
$: pop and print a bit
#: switch stacks
=== control flow: ===
_: (branch) if the top of the stack is 0, move the pointer down to the next line instead of to the next instruction. program flow continues either left or right based on which direction continues to have stack instructions. if neither or both do, its a syntax error and the program does not run. having a _ directly below another _ is also a syntax error
space/newline/eof:
if the stack is empty, halt. otherwise, while the top of the stack is 1, pop a bit and return to the previous _. once the top of the stack is no longer 1, take the opposite path on the branch from what was taken last time (i.e. if you went down that branch, continue horizontally, but if you went horizontally, go downward). if there is still a 1 on top of the stack upon reaching the first _, pop it, move to the start of the program, and resume normal execution.
anything else: comment, replaced with a space at runtime
== interpreter that may or may not be shit ==
https://replit.com/@thejonymyster/cyoa#index.js
Category:Languages Category:Stack-based Category:Implemented Category:Low-level
CZTOLJDEFGKJSKI calculus

The CZTOLJDEFGKJSKI calculus is a derivative of Lazy K named after User:olus2000. Unlike Lazy K, it is (mostly) strictly evaluated (call-by-value) and uses a different set of combinators.
 Combinators
Symbol	Name 	Behavior (λ-term)
C 	cardinal 	λ a b c → a c b
Z 	strict fixed point	λ a b → a (Z a) b
T 	thrush 	λ a b → b a
O 	owl 	λ a b → b (a b)
L 	lark 	λ a b → a (b b)
J 	jay 	λ a b c d → a b (a d c)
D 	dove 	λ a b c d → a b (c d)
E 	eagle 	λ a b c d e → a b (c d e)
F 	finch 	λ a b c → c b a
G 	goldfinch 	λ a b c d → a d (b c)
K 	kestrel 	λ a b → a
J 	jota 	λ a → a S K
S 	starling 	λ a b c → a c (b c)
K 	lazy kestrel 	λ a b → (eval b; eval a)
I 	idiot 	λ a → a
A few other differences from Lazy K:
* Only the Unlambda syntax can be used, but with capitalized combinator names.
* Note that some combinators have multiple definitions. The parser cycles through which definition is used every time the combinator appears in the program. So if you write ``GKK, the first use of K refers to the kestrel, but the second refers to the lazy kestrel.
* The lazy kestrel is the only combinator in the language which violates the call-by-value reduction model. When passed its first argument, it does not immediately evaluate it; instead, it waits for a second argument and evaluates that one first before finally evaluating and returning its first argument.
Category: Languages
Category: Turing tarpits
Category: Unimplemented
Category: Functional paradigm
Category: Turing complete
Category: 2023
C flat --

C flat --, or C♭--, is an esolang created by User:Coder07 that is entirely composed of functions and values (e.g. "Hello world", 12345). It has nothing to do with C Flat.
== Syntax ==
Values are strings and numbers. There are also other value types that can be created through functions.
Functions work how you'd expect, the function name followed by the arguments in parentheses, separated by commas.
Parameters surrounded by parentheses are optional, and ones ending in an asterisk (*) 
Function name 	Parameters 	Description
add, sub, mul, div 	a, b 	Adds/subtracts/multiplies/divides a and b
if 	condition, function, (else)	Runs function if condition is 1, otherwise runs else
input 	(prompt) 	Prompts the user for text input
output 	value 	Adds value to the output
key 	(character) 	Returns if key character is held, or the list of all held keys (as strings)
list 	items* 	Creates a list with items
index 	index, list 	Gets item index of list
find 	value, list 	Finds the first occurrence of value in list
setindex 	index, value, list 	Returns list with item index replaced with value
setvar 	var, value 	Sets var to value (If the variable is set to a function, it can be called like you'd expect)
getvar 	var 	Returns the value stored in var
function 	parameters, code 	Creates an anonymous function (parameters should be a list and code should be a string)
less, equal, greater	a, b 	Returns 1 if a is less than/equal to/greater than b, otherwise returns 0
and, or 	a, b 	Returns if a and/or b are equal to 1
number, string 	value 	Coverts value to a number/string
char 	value 	Converts a number to its Unicode character. If value is a list of numbers, it returns a string with every item in value converted to its Unicode character.
charnum 	value 	If value only has one character, then it returns the number of it in Unicode. If it has multiple characters, it returns a list of each character as a number.
== Examples ==
=== Hello world ===
 output("Hello world!")
=== Cat ===
 output(input())
=== Truth-machine ===
 setvar("iftrue",function(list(),"output(1)iftrue()"))
 if(number(input()),getvar("iftrue"),function(list(),"output(0)"))
== Interpreter ==
No interpreter is available yet, but I'm working on one.
Category:Languages Category:Unimplemented
Caca

"Caca" is an esolang created by User:Mari on May 22nd, 2024. It's first (and currently only) Interpeter is written in scratch. It's namesake and commands are based on a Discord server called "Progresscord"'s Humor, of saying "I caca", and sometimes using a sticker which is an edited version of Icoeye's logo with eyebrows, 1 eyebrow raised, a weird smirk and the caption "I caca" in the top corner in impact font. It is described as being "crappy and likely unfunny"
== Commands ==
* icaca - print ascii character (from caca number) to screen
* icacac - add 1 to caca number
* cacacaX - loop line succeeding for value specified
* icac - remove 1 from caca number
* icacan - square caca number
* youcaca - ask user for input, numbers only (input is added to caca number)
* cacatoX - goto a specific line number
* nocaca - switch to previous caca number in caca stack
* yescaca - switch to next caca number in caca stack
* newcaca - add caca number to stack (there is 1 by default)
* icaca? - execute line succeeding if caca number is positive
* nocaca? - execute line succeeding if caca number is negitive
* zecaca? - execute line succeeding if caca number is 0
* cacacaca - clone current caca number to stack
== Examples ==
this is a hello world program written in Caca:
cacaca72
icacac
icaca
cacaca3
icac
icaca
cacaca7
icacac
icaca
icaca
cacaca3
icacac
icaca
cacaca47
icac
icaca
cacaca55
icacac
icaca
cacaca8
icac
icaca
cacaca3
icacac
icaca
cacaca6
icac
icaca
cacaca8
icac
icaca
This code is mostly illegible, but basically it uses cacaca#### to run an increment(icacac)/decrement(icac) on loop, and it then uses icaca to print the ascii character corresponding with the value.
this is a truth machine:
youcaca
newcaca
zecaca?
cacato12
nocaca?
cacato12
yescaca
cacaca49
icacac
icaca
cacato10
yescaca
cacaca48
icacac
icaca
as Caca code is, its mostly illegible. basically, it uses youcaca to ask for user input (Caca can only handle numbers as input), then, if the number is a 0 or a negative, it goes to the end using a cacato statement, which then outputs one 0 then stops, but if its positive, it then goes on to printing 1, then goes back and prints 1 using a cacato statement
== Trivia ==
* Caca is (at least) the 2nd Esolang inspired by Progresscord, with the first being guh, however, Caca is implemented, at least in Scratch, while guh remains unimplemented. Also, Caca might be turing complete, while Guh is not due to lack of Conditional Execution.
* Originally, the command called 'zecaca?' was called 'nucaca?', but however scratch's bad word detector detected nucaca as a bad word so I had it changed to 'zecaca?'
* It is one of many languages to feature a Nope. Interpreter.
* Upgrades to Caca such as String Caca (Caca with strings), Absolute Caca (Caca with absolute number support, rather than all relivate), and Caca Pro (Caca with improved control flow)
== Implementations ==
* Scratch based Interpeter
Category:Languages Category:Joke languages Category:Implemented Category:Stack-based Category:2024