nyuuzyou/wikis huggingface dataset:
C@++

C@++ is an extension of C@ by User:BoundedBeans, made for simple text algorithms.
==Commands==
 : duplicate
 / swap
 $ discard
 . print
 # rot
 % over
 & tuck
 ] Makes the next command operate on the stack as groups of two.
 This can be stacked, for example, ]: is like forth's 2DUP, while ]]:
 would be like a 3DUP
 @ Pop digits to make a base-10 number n until the top of the stack is not a digit (don't pop the non-digit),
 roll the top element n places down
 ~c Push the character c to the stack, ignoring its meaning
 [ push the stack depth to the stack as decimal digits
 + A command disambiguator
 +| Reserved for extensions, can be another disambiguator or just take stuff from the stack to determine what to do
 +@ Like @, but pops an additional character before rolling, so that a digit can be rolled
 +[ Push (the stack depth) - 1 to the stack as decimal digits (to work with +@ for rolling the entire stack)
 +A Pop two series of digits a and b, each terminated by an underscore, pushes a number of a similar format representing a + b
 +B like +A but pushes a - b
 +C like +A but pushes a * b
 +D like +A but pushes a / b
 +E like +A but pushes a modulo b
 +_ Pops a series of digits x, terminated by an underscore. Breaks out of the x innermost loops currently executing.
 Anything else: push to the stack.
Loops are also supported to run as long as the top of the stack is not a certain character. This syntax is XCLX, where L is the loop contents, C is the character to check against, and X's are the loop brackets. Loop brackets with inside depth of n are encoded as Unicode character #(8239 + n), and cannot be greater than #8286, so the loop brackets, from outermost to innermost, are:
‰ ‱ ′ ″ ‴ ‵ ‶ ‷ ‸ ‹ › ※ ‼ ‽ ‾ ‿ ⁀ ⁁ ⁂ ⁃ ⁄ ⁅ ⁆ ⁇ ⁈ ⁉ ⁊ ⁋ ⁌ ⁍ ⁎ ⁏ ⁐ ⁑ ⁒ ⁓ ⁔ ⁕ ⁖ ⁗ ⁘ ⁙ ⁚ ⁛ ⁜ ⁝ ⁞
Prefixing the loop brackets with +. inverts the condition so they run as long as the top of the stack is a certain character.
==Examples==
===Hello, world!===
 H.e.l:..o.,. .w.o.r.l.d.!.
Technically doesn't save any bytes over the following but is cooler for showing off duplication.
 H.e.l.l.o.,. .w.o.r.l.d.!.
===Truth-machine===
Since C@++ only takes in a string of input, it can't be interactive, therefore the input string should be 1 or 0.
 +.‰1:.+.‰+.‰0._1+_+.‰
Category:Languages
Category:2024
Category:Unknown computational class
Category:Stack-based
Category:Unimplemented
CA-1

CA-1 is the name of an esoteric programming language and a set of related programs.
==Commands==
Command 	Description
INPUT 	Program input. Multiple inputs allowed. 3 bit.
OUTPUT 	Program output.
NOT 	Inverts a variable.
GOTO 	Sends the output of once rule to the next rule.
GEN n 	Continues the previous command for n generations.
IMPORT x	Imports a new rule x. Not used in the assembly version of the language.
SQUARE 	Takes a 3 bit 2 dimensional pattern and squares it into a 2 dimensional 9 bit pattern.
# 	Comment.
==Example==
INPUT #User input
110 #Runs user input through rule 110
102 #Runs the pattern from rule 110 through rule 101
SQUARE #Creates a two dimensional pattern
GoL
NOT
OUTPUT
When run on input "001", the program outputs 111,111,111: 001 -> 011 -> 0 -> 000,000,000 -> 111,111,111
==Assembler==
CA-1 assembler takes a program and outputs a schematic that can be used to build a physical computer that runs the program.
==Cat program==
INPUT
OUTPUT
==Turing completeness==
CA-1 is only Turing complete for some cellular automata, such as Game of Life and Rule 110.
Category:Languages Category:2014 Category:Turing complete
CAESAR\

OFFICIAL INTREPRETER: lol.xf.cz (not sketchy at all)
==What is CAESAR?==
Caesar is an esolang. That means that it's a programming language that is not
supposed to be used for actual, useful purpose. Sometimes, its a work of art, but sometimes,
like this time, its only purpose is to cause headache. Unlike other esolangs, though, it has
pretty readabil-ish syntax. It was made in one evening by a 15yo. who is bad at
programming language design and programming, so dont expect much.
==How does it work?==
The esolang is named after the Roman general Gaius Julius Caesar.
Yes, you're now gonna be performing army.. more like exercise. It was loosely inspired by the Caesar
problem from children algorithmisation book. So you essntially have 3 main subjects:
* Caesar/Commander - a subject that performs most oerations. He prints to the output, he controls the program flow and he decides when we end. But he is dumb, so he can only remember one information at one time
* Basket - essntially a stack with fancy name
* Army - a subject that essentially operates the stack. They can receive commands from Caesar, perform basic operations (like addition or shuffling the stack), can receive information from him and send him information.
==Commands==
This esolang contains only like 10 commands that are as following:
 raise x - raise flags A-F
 yell - prints the content of Caesar's memory to the output
 listen - listens for user input, saves it to commander memory
 save - saves evenrything presented as argument to the Caesar's memory
 signal - pushes the value in Caesar's memory to the basket
 # - comment
 if x y - if the value in the Caesar's memory is equal to x, do y
 if! x y - same as if but actvates if x isn't equal to memory
 move - move to the beggining of the program
 stop - stops the program's execution
raise arguments:
 A - put the value on top of the stack to the bottom
 B - same but from bottom to top
 C - add the first and last stack elements
 D - add the first and second stack elements together
 E - send the top stack value to Caesar
 F - send the bottom stack value to Caesar
 G - remove the top value from the stack
==Syntacic quarks==
Every command MUST END WITH SEMICOLON! Quotes do nothing here, this language is weakly typed without type declaration.
The langage supports multiline commands, which means that this code is valid:
 save hello
 world; yell;
There are no codeblocks in this language, so
 if 5 {yell; yell;} #invalid;
 if 5 yell; yell; #invalid;
 if 5 yell; if 5 yell; #valid;
Entered argument x cannot contain spaces, but memory can.
comments are regarded as regular commands, so they must end in semicolon.
 #valid;
 #invalid
 #valid
Also, the code isnt interpreted in real time, instead it shows output after it's finished running.
The program allows up to 5000 iterationsThe default value of memory is non
==Example code==
Hello world:
 save Hello World;
 yell;
cat:
 listen;
 yell;
truth-machine:
 if non listen;
 if 0 yell;
 if! 0 yell;
 if! 0 move;
addition of two numbers:
 if non listen;
 listen;
 signal;
 listen;
 signal;
 raise D;
 yell;
Category:Languages Category:Stack-based
CALESYTA

CALESYTA is an Argentinian contest of esoteric programming language design first held in 2016. Under the current rules, it is completely free-form, with no theme or other restrictions specified. The name stands for "Concurso Argentino de Lenguajes Esotéricos y Tarpits", translated as "Argentinian Competition of Esoteric Languages and [Turing] Tarpits".
== Years ==
=== 2016 CE ===
The 2016 CE competition- the first one held- started in October and ended on 2016-11-16. 
Submissions to the competiton on this wiki are:
* Incident, by User:Ais523
* ARGENTOS, by User:eamanu
* Silberjoder, by User:Quintopia
As of January 2017, the pages associated with the contest have been taken down from the website without explanation and without any winners being announced. It is unclear why the organizers never selected a winner or whether another iteration of the contest will be attempted.
== See also ==
* The International Esolang Design Competition, another such competition.
== External resources ==
See the for additional information.
Category:Competitions and Events
CAPscript

"CAPscript" is a programming language created by User:Firethrone in August 2020 cause he was bored during online classes and had nothing better to do. Its called CAPscript cause all commands are all caps. Lower case alphabets are treated as comments.
For an idea of what the language is capable off (not much) here's hello world: 
 INCDBLDBLDBLDBLDBLDBLINCINCINCINCINCINCINCINCPRCDECDECDECDECDECDECDECDECDECDECDECDECDECDECDECDECDECDECDECDECDECDECDBLINCPRCINCINCINCINCINCINCINCPRCPRCINCINCINCPRCHALDECDECDECDECDECDECDECDECDECDECDECPRCHALINCINCINCINCINCINCINCINCINCINCPRCDECDECDECDECDECDECDECDECDECDECDBLDBLDECPRCINCINCINCINCINCINCINCINCINCINCINCINCINCINCINCINCINCINCINCINCINCINCINCINCPRCINCINCINCPRCDECDECDECDECDECDECPRCDECDECDECDECDECDECDECDECPRCHALHALINCINCINCINCINCINCINCINCPRC
Git repo : 
Category:Languages
Category:Implemented
Category:2020
CARfish

CARfish(Complex Alternate Representation deadFISH) is an esolang invented by User:A that tries to make experiences of Deadfish worse. (It has the same four commands, though.)
CARfish started out from two separate languages: Map(Alternate Deadfish command representation) and ANTS(Alternate Number Typing System). Note that programs in CARfish should be written in ANTS, not Map.
==Map documentation==
Map is an alternate representation of Deadfish commands. Commands can be presented by numbers.
The numbers in Map do only one thing: Set the is-command flag to true. This results in Map executing the commands according to this scheme:
As long as i≠0,
If i mod 4=0: execute i
Otherwise if i mod 4=1: execute d
Othereise if i mod 4=2: execute s
Otherwise if I mod 4=3: execute o
It automatically maps down to 0 if the accumulator is -1 or 256.
This is a simple program in Map that outputs 16:
4 8 10 14 15
===Implementation of Map===
#include <stdio.h>
int main(int argc, char *argv[])
{
	int ac=0;
	int max=0;
	char c, code[99999];
	short book[99999];
	FILE *f=fopen(argv[1],"r");
	for(int i=0;(c=fgetc(f))!=EOF;i++)
		code[i]=c;
	int ans;
	for(int i=0;code[i]!='\0';i++)
	{
		if(code[i]>='0'&&code[i]<='9')
		{
			ans*=10;
			ans+=code[i]-48;
		}else
		{
			max=max>ans?max:ans;
			book[ans]=1;
			ans=0;
		}
	}
	max=max>ans?max:ans;
	book[ans]=1;
	for(int i=0;i<=max;i++)
	{
		if(book[i]==1)
		{
			if(ac==256||ac==-1)ac=0;
			if(i%4==0)
				ac++;
			else if(i%4==1)
				ac--;
			else if(i%4==2)
				ac*=ac;
			else if(i%4==3)
				printf("%d\n",ac);
		}
	}
	return 0;
}
==ANTS documentation==
ANTS is an alternate representation of Map programs. There are just 4 commands:
i: switch the current function
o, d, and s: Type a specified character
The function mapping is like this:
Function 1(F1 afterwards): o:0, d:1, s:2
F2: 3, 4, 5
F3: 6, 7, 8
F4: 9, 0, (space)
Here is a simple program that prints 5:
idiisiiiisisidoiiiisidsiiiisidiis
===Compiler from ANTS to plain text===
#include <stdio.h>
char o='0',d='1',s='2';
int status=0;
char code[99999],c;
void map()
{
	if(status==0)
	{
		o='3';d='4';s='5';
	}
	else if(status==1)
	{
		o='6';d='7';s='8';
	}
	else if(status==2)
	{
		o='9';d='0';s=' ';
	}
	else if(status==3)
	{
		o='0';d='1';s='2';
	}
	status++;
	if(status==5)
		status=0;
}
int main(int argc, char*v[])
{
	FILE *f=fopen(v[1],"r");
	for(int i=0;(c=fgetc(f))!=EOF;i++)
		code[i]=c;
	for(int i=0;code[i]!='\0';i++)
	{
		if(code[i]=='i')map();
		else if(code[i]=='d')printf("%c",d);
		else if(code[i]=='s')printf("%c",s);
		else if(code[i]=='o')printf("%c",o);
	}
	return 0;
}
Category:Languages
Category:Implemented
Category:2019
Category:Unusable for programming
Category:Output only
Category:Total
CASISP

CASISP which doesn't stand for anything in particular but mixes C, Pascal, Basic and Lisp, is an unimplemented idea by Orenwatson (talk)
In natural languages, when people are unfamiliar with a language they are trying to use, sometimes they mix the language with parts of more familiar languages, by substituting words and grammar from one language into another. The same can be done with programming languages, as shown below.
dim x as integer;
READ (*,*) x # read in number to factorial
int a = 1;
do
(set! a (* a x))
x--;
loop while x.gt.0
printf("%d\n",x);
END
Category:Languages
Category:2015
Category:Unimplemented
Category:Turing complete
Category:Ideas
CASM

CASM, meaning "C assembly" and pronounced like "chasm", is a partially-esoteric programming language with literally no type system. This is not to be confused with languages like brainfuck, which only have a single type—negating the need for a type checker of any sort—or with dynamically-typed languages like Python, which still have types that just aren't bound to variables, or even with Javascript which has been called "typeless" for whatever reason.
== How does THAT work? ==
In CASM, you don't give a variable a type. Strictly speaking, you don't even need variables, but they are provided anyway as a convenience. In CASM, you must tell the program what type to interpret values as any time you work with them—basically, you are the typechecker.
Here's an example of CASM code:
 def main(){
 init i = 5;
 init f = 2.9;
 result = i[+:int,float]f;
 return 0;
 }
Notice two things here:
 
# The variables are never initialized with a type. They are still initialized—using the init keyword—but are not given a type. This is because the value that the variable is assigned to is converted at compile-time to the desired binary and is at no point checked for type; the program just rolls with it.
# The + operation is written weirdly. Heeeeeey you might be saying, if you have a keen enough eye. "That + operation is given types! You lied to us!". You're right—the + operation was passed types; however, before you storm away because this page said "no types", consider this: What would have happened if I told it that it is being given two ints? Or two floats? Or even two pointers to strings? You could do that, of course; the program won't yell at you, that would be a type checker. It would have, of course, yielded completely different and illogical results—specifically, the result where if you treat the literal storage as the wrong type. That is the beauty of CASM—there is no type system unless you discipline it to have one.
== Operator Types ==
CASM supports a small set of "types" that operators can be told to interpret a variable as. These types correspond, in theory, directly to what you can do on the ASM that interprets it.
Type keyword	Interpretation
int 	A 64-bit signed integer
nat 	A 64-bit unsigned integer
float 	An IEEE double-precision floating point number
arrptr 	A pointer to a string
These are fairly simple types, but the operators that use them can work in wildly unexpected ways—for example, you can call a nat, which will cause the program to work like a normal function call, but it CJMPs to the line which that number targets.
== The Rest ==
Other than what you've seen, CASM is fairly similar to C, in theory. I haven't bothered to write a spec yet, but when I do it will be published here.
Category:Languages Category:Low-level Category:Unimplemented Category:2016
CATHY

== CATHY ==
CATHY is a stack-based esolang. It has 32 commands, each a different capitalisation of `CATHY`.
Commands:
 Caption text
Command	normal form	Action
cathy 	0 	Literal digit 0, can be joined to other digits
cathY 	1 	Literal digit 1, can be joined to other digits
catHy 	2 	Literal digit 2, can be joined to other digits
catHY 	3 	Literal digit 3, can be joined to other digits
caThy 	4 	Literal digit 4, can be joined to other digits
caThY 	5 	Literal digit 5, can be joined to other digits
caTHy 	6 	Literal digit 6, can be joined to other digits
caTHY 	7 	Literal digit 7, can be joined to other digits
cAthy 	8 	Literal digit 8, can be joined to other digits
cAthY 	9 	Literal digit 9, can be joined to other digits
cAtHy 	+ 	Add two numbers popped form stack
cAtHY 	- 	Subtract two numbers
cAThy 	/ 	Divide two numbers
cAThY 	* 	Multiply two numbers
cATHy 	ƒ 	Reduce by next command
cATHY 	[ 	If pop(stack) is true, then do following
Cathy 	{ 	Forever, do following
CathY 	⟑ 	Map following over pop()
CatHy 	; 	Close structure
CatHY 	: 	Dup
CaThy 	_ 	Pop
CaThY 	? 	Take input
CaTHy 	s 	sort
CaTHY 	J 	Concat/append/prepend
CAthy 	τ 	To base
CAthY 	o 	Remove
CAtHy 	$ 	Swap
CAtHY 	„ 	Shift stack left
CAThy 	‟ 	Shift stack right
CAThY 	, 	Print with trailing newline
CATHy 	C 	Char
CATHY 	β 	From base
Interpreter with an example Hello, World program
Compiler from normal form to CATHY form
Category:Languages
Category:Stack-based
Category:Implemented
CC

CC(Column Changer)is an esolang by User:A based on the Difference machine.
==Syntax==
It has columns numbered from 0 to 3.The operations are:
# Move the value from the next column to the current column.
# Move value to the previous column.
# Reset the value to its recent value
Steps 1,2,3 occur for every odd column, while steps 3,1,2 occur for every even column.
==Execution sequence==
It is run in an infinite loop, with the current column pointer moving right forever(in circular sequence).
==Computational Class==
Try to think of what a Turing machine can do.
# Change the value on the current cell.
# Move the pointer.
# Perform a loop.
Obviously, this language can do all of those things.
Well, it can't be Turing-complete, because it can only do limited addition, and it is in a mechanical sequence, so it is a kind of limited Turing-machine, but not a complete turing-machine.
Category:Languages
CC *

The CC_* language family is a subset of the C language designed to be written in Assembly (such as M0 macro assembly) but complete enough to make it easy to write a real C compiler written in the C subset that it does actually support. The standard convention is to replace * with the short form of the assembly language it outputs not the assembly language it is written in. For example if written in RISC-V assembly but outputting x86 assembly it would be named cc_x86 but a RISC-V(64bit) output written in x86 would be called cc_riscv64 (as RISC-V(64bit) and RISC-V(32bit) are incompatible assembly languages).
You must support the following primitive types:
 void (and void*)
 int (and int*)
 char (char* and char**)
 FILE (and FILE*)
 FUNCTION (and FUNCTION*)
 unsigned (and unsigned*)
 long (and long*)
Which can be combined with struct and within structs, one may union members.
To support #define declarations; the keyword CONSTANT can be used as # starts line comments and // is ignored.
Thus one can write:
 //CONSTANT foo 4
 #define foo 4
and the code will behave the same way in both GCC and cc_*
For conditional execution, if and else are available.
 if(foo) do_something();
 else if(bar) do_it_differently();
 else something_different();
For looping primitives, there is for, do and while loops; with continue (treated like a NOP) and break (behaves like C)
For flow control there is goto and the ability to have labels: just like in regular C. With the only warning to make sure not to define variables inside of a goto loop.
For those needing something special like system calls; asm("add r0 r1 r2" "sub r3 r2 r1"); is supported and not fully gcc compatible so you will likely want uses of it in separate files, so that an alternate which works with gcc can be used for development.
For those needing to do allocation of memory sizeof(type) behaves exactly like C.
For those doing common C code, +, -, /, %, <, >, <<, >>, <=, >=, ==, !=, &, &&, |, || and ^ behave the same as C (signed version of the instructions; should you require the unsigned behavior, leverage the later M2-Planet stage)
For those dealing with assignment = works exactly like in C.
For those dealing with structs or arrays. both array[index] and structure->member work exactly like in C.
No other parts of the C language need to be supported.
An example implementation can be found here
And an example program written in that C subset can be found here
Category:Bootstrapping Category:Languages
CContains

cContains: is an esolang by User:Ϫ based on Javascript arrays and set theory. The main principle of cContains: is sets, which are written like this:
 [1, 3, OTHERSET]
Ccommands act upon given elements of a set, or all elements if not specified. Sets can be nested and commands can use a path to navigate them.
== Commands and Syntax ==
==== Syntax ====
Any string can be an identifier, as long as it doesn't use symbols, numbers, spaces or lowercase letters. To define a set, you use this syntax:
 SETNAME:[THING, OTHERTHING]
A command is written like this:
 COMMANDIDENTIFIER -> SET
A command can have a path, describing a specific thing. For example:
 BRICK:[2,3,4]
 EGG:[2,4,5]
 FISH:[BRICK, BRICK, EGG, EGG]
 SET:[FISH]
 OUTPUT -> SET{1,4,2
...would output 4.
Additionally, there are special sets that have certain properties:
 $IN: The user can tamper with the contents of this set, therefore making it the input.
 $CLIP/IDENTIFIER: Used for COPY/IDENTIFIER. The identifier name follows the same rules as set names.
 $RESULT/CONTAINERFILE: The result of the given container code. I'll explain further.
 $INT: Cannot be changed; any changes will result in an error. Contains the numbers 1 to 1000 in order.
==== Commands ====
 OUTPUT: Sends the specified element to the console. Does not work with whole sets.
 FLIP: Reverses the order of a set. Does not work with singular items.
 HIGHEST: Removes all items in the set except for the highest value. Ignores nested sets.
 LOWEST: Like HIGHEST, but the lowest.
 COMMON: Like HIGHEST, but the mode.
 COPY/IDENTIFIER: Stores the contents of the set in the $CLIP/ with the same identifier. Does not work with singular items.
 PROJECT/IDENTIFIER: Overrides the set's current contents with the corresponding $CLIP/. Does not work with singular items.
 MARK/IDENTIFIER: Takes no set inputs, stands alone. Used for JUMP/.
 JUMP/IDENTIFIER: Takes no set inputs, stands alone. Return to the corresponding MARK/.
 SET?: Only runs the next command if the item in the given path is a set. Requires a path.
 INT?: Like SET?, but for integers.
 DOUBLE: Doubles the specified item, or all items in the given set.
 INC: Increments the specified item, or all items in the given set.
== Container Code ==
A container is like an extension, another cContains: script that is run before the program starts. All cContains: containers have to use a name with the same restrictions as set names and identifier names. Anything that is sent to the console with OUTPUT will instead go to this script's corresponding $RESULT/IDENTIFIER. 
Please append CCONTAINS to the names of any cContains: containers you share on Esolangs.
Category:Languages
CDILOI

CDILOI (Concatenate, Delete, If, Label, Output, Input) is an esolang by User:ChuckEsoteric08 which was inspired by Gray Snail.
==Specification==
CDILOI uses unbounded variables to store data. The language is case-insensitive. Note that, because it uses whitespaces to split arguments, strings can't contain these separators.
@x returns value of the variable x. If a variable with that name doesn't exist, then create it and set its initial value to the empty string. It would not work if it is z in CONC, y or z in DEL, x in LBL, z in IF or x in INP
 CONC x y z
Concatenate the strings x and y and store the result in the variable z.
 DEL x y z
Remove the first character in the string x and store it in the variable y, and store everything else in the variable z.
 IF x y z
If the strings x and y are equal goto label z.
 LBL x
Declare the label x.
 OUT x
Output the string x.
 INP x
Store the user input in the variable x.
==Examples==
===Hello, World!===
 OUT Hello,World!
===Cat===
 INP x
 OUT @x
===Reverse Cat===
 INP x
 LBL notempty
 DEL @x char x
 CONC @char @out out
 IF @y @x end
 IF a a notempty
 LBL end
 OUT @out
===Unary counter===
 LBL count
 CONC @x * x
 OUT @x
 IF a a count
===Truth-machine===
 OUT Please_input_0_or_1:
 INP choice
 IF @choice 0 input_of_zero
 IF @choice 1 input_of_one
 LBL input_of_one
 OUT @choice
 IF @choice @choice input_of_one
 LBL input_of_zero
 OUT @choice
==Computational class==
The language is Turing-complete, which is proven by implementation of Bitwise Cyclic Tag, binary brainfuck, SHITS and Underload which are here
==Interpreter==
* Common Lisp implementation of the CDILOI programming language.
Category:Languages Category:Turing complete Category:Turing tarpits Category:2023 Category:Implemented