nyuuzyou/wikis huggingface dataset:
Casini

Casini is a language created by Abbin21, the language is themed after different casino related items. The code is written in .cas files.
== Operators and INTs ==
There are four operators in casini, which are represented by the four colors of playing cards.
/\ | /\/\ | o | /\
\/ | \ / | o|o | / \
 | \/ | | \||/
* | + | / | -
You can also create INTs by writing out "Dices" that look like this:
 _____
|1 5 6| The numbers inside the dice are summed up.
|2 8 9| This specific dice has a value of 31.
|_____| Since the dice only can contain 6 numbers the maximum number is 54.
There are also variables, which are created like this:
 _____
|2 3 6| 
|6 1 4| Note that the first parenthesis must line up with the pipeline char
|_____|
(#)variableName
You can create strings as well like this:
Unfortunately the strings can't be printed or used in any other way yet.
 _____ 
|7 4 8| 
|4 8 1| ($)StringName = StringText 
|_____| 
== Example code ==
When making operations on dices you write out the entire dice, followed by an operator, followed by another dice OR a variable name that has been created.
All calculations follow BEMDAS.
 _____ _____ | 
|9 9 9| /\/\ |1 4 1| /\ | 
|9 9 9| \ / |1 1 1| \/ (#)Chip | This will perform 54 + 9 * 54 
|_____| \/ |_____| |
(#)Chip |
== Things worth noting ==
Important read
Note that the top char of all operators are to be placed on the 2nd line, and the rest of the operator built under it.
The variables and string calls (Not initializations) need to be placed on the 3rd line to work.
== External resources ==	
Projects Github page
Category:Languages
Category:Thematic
Category:Implemented
Cast

== About ==
Cast is an effectively-functional language based around casting datatypes between eachother.
== Overview ==
A Cast program is a list of type definitions following this format:
TypeName<Subtype1, Subtype2, ...>
| Pattern -> Expression
| Pattern -> Expression
| Pattern -> Expression
...
A type can have any number of named sub-types. The names serve no purpose other than to document their expected type/purpose.
The cast definitions below the type define how to cast one type to another.
A Pattern is either a variable (ie: a) or a destructure (ie: Pair<Pattern, Pattern>). Destructuring may be nested.
An Expression is either a variable reference (ie: a), a type construction (ie: Pair<A<>, b>), or a cast (ie: Expression -> Type)
When casting, the first defined cast whose pattern matches the value will be used. 
== Input / Output ==
The program input and output are both a string. The input, say abc is first converted to a UTF-8 bitstring. 011000010110001001100011. Then it is converted into a value using these types: IO<input>, IO.1<next>, IO.0<next>, and IO.null<>. The example bitstring will become this: IO<IO.0<IO.1<IO.1<IO.0<...>>>>> The final IO.0 or IO.1 will contain a IO.null inside.
The program is begun with the call io_object -> Main -> IO. The reverse-process is used after the cast to return the output string.
== Examples ==
Cat Program
Main<I> // Main stores one value.
| IO<I> -> Main<I> // IO places its data inside of Main.
| Main<I> -> IO<I> // Main transfers its data to IO.
Hello, world! program
Main
| IO<_> -> Main<>
| Main<> -> IO<IO.0<IO.1<IO.0<IO.0<IO.1<IO.0<IO.0<IO.0<IO.0<IO.1<IO.1<IO.0<IO.0<IO.1<IO.0<IO.1<
IO.0<IO.1<IO.1<IO.0<IO.1<IO.1<IO.0<IO.0<IO.0<IO.1<IO.1<IO.0<IO.1<IO.1<IO.0<IO.0<IO.0<IO.1<IO.1<
IO.0<IO.1<IO.1<IO.1<IO.1<IO.0<IO.0<IO.1<IO.0<IO.1<IO.1<IO.0<IO.0<IO.0<IO.0<IO.1<IO.0<IO.0<IO.0<
IO.0<IO.0<IO.0<IO.1<IO.1<IO.1<IO.0<IO.1<IO.1<IO.1<IO.0<IO.1<IO.1<IO.0<IO.1<IO.1<IO.1<IO.1<IO.0<
IO.1<IO.1<IO.1<IO.0<IO.0<IO.1<IO.0<IO.0<IO.1<IO.1<IO.0<IO.1<IO.1<IO.0<IO.0<IO.0<IO.1<IO.1<IO.0<
IO.0<IO.1<IO.0<IO.0<IO.0<IO.0<IO.1<IO.0<IO.0<IO.0<IO.0<IO.1<IO.null<>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Cat Program (language)

Cat Program (language) is an esolang created by User:None1, all it can do is a cat program.
==Commands==
There are no commands, but every program is valid and is a cat program.
When executed, Cat Program (language) ignores its code and outputs its input.
==Example Programs==
===Cat Program===
 Anything can go here
===Text interpreter===
 Hello World!
==Interpreters==
===JavaScript===
function cat_program(code,input){
 console.log(input);
}
===Python===
def cat_program(code):
 input = input()
 return(input)
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Implemented
Category:Total
Category:No-code esolang
Cat program

:For the concatenative language, see catlangwiki:Cat.
The cat program is a program that copies its standard input to its standard output. It is named after the Unix command cat, although this command is actually more powerful. The cat program is a popular problem.
cat has also been described humorously as a programming language in which every program is a quine. The programming language is obviously of very limited computational usefulness. See HQ9+ and Text.
==Hello world and quine program==
 #!/usr/bin/cat
 Hello, world!
You must chmod +x the program file to make it executable:
 $ chmod +x file
To execute it:
 $ ./file
(assuming file is the filename of the program)
==Reverse cat==
Other shell commands could be used in similar way, so there is reverse variant of cat language too. Unix command line utilities in this space include both rev (reversing characters within each line) and tac (reversing the order of lines in the input; cat backwards).
 $ echo '!dlrow ,olleH' | rev
 Hello, world!
 $ (echo 'world!'; echo 'Hello,') | tac
 Hello,
 world!
 $ (echo '!dlrow'; echo ',olleH') | tac | rev # or ... | rev | tac
 Hello,
 world!
A simple "reverse cat" program could simply output the bytes of the input backwards, which for a conventional newline-delimited text file has roughly the effect of rev and tac combined (except for the treatment of the file's trailing newline).
While a regular cat program requires only O(1) storage space, a reverse cat program requires O(n) storage space, so as a popular problem it is a slightly more ambitious achievement.
==See also==
* One Time Cat
Category:Program forms
Catch

Catch is an esoteric programming language, designed by User:ihope127, in which most statements throw exceptions. A block consists of an if statement followed by a number of others, and it ends right before the next if. The exception is if's inside a catch statement: outside a catch statement, the whole thing is treated as a single instruction, while inside the catch statement, the catch statement is treated as if it were the whole program.
An example "Hello World" program:
 if printInst("Hello World!")
Put simply, this throws the printInst exception with the parameter "Hello World!" This exception is not caught, therefore it is transferred to the "default" exception handler, which in this case prints "Hello World!" to the screen.
What makes this an if and not just a throw is how flow is passed: if the exception is left un-caught the flow goes to the "then" statement; if it is caught, flow progresses to the else statement. However, since neither is present in this block, flow simply goes to the next block.
The "Hello World" is extremely simple and rather boring, so we'll create a subtraction program:
 if createVariableInst(x) ;create the x variable
 if createVariableInst(y) ;create the y variable
 if inputInst(x) ;accept input for the x variable
 if inputInst(y) ;accept input for the y variable
 
 if subtractInst(x, y, y) ;subtract the two and store the result in y
 if printInst(y) ;print the result
----
A complete list of built-in exceptions has not yet been established.
Category:Languages
Category:Unimplemented
Categorial

Categorial is amazing, virtuous, good, great and perfect, without flaw. Any details omitted are implementation dependant. Programs are to be supplied as an image of the source code.
== Language overview ==
There is a tape, stack, deque and a queue.
 λ - interpret the remainder of the program as Haskell, thus very functional.
 CGOL - print the amount of tomatoes to have existed in a new simulation of the universe, after being run for 12 quadrillion years (async). The universe is particle based and possibly nondeterministic.
 l - push a qubit to the top of the stack. Implementation dependant what operations on this qubit do.
 a - pop from stack to queue
 b - pop from queue to deque
 c - pop from deque to tape
 d - get from the end of deque to tape
 e - move from tape to stack
 > < + - , . [ ] - brainfuck equivalents
 0 - change amount of dimensions to 0
 1 - change amount of dimensions to 1
 2 - change amount of dimensions to 2
 😠️ - interpret the remainder of the program as Java, thus very object oriented.
 t - spawn new thread. Implementation dependant.
 r - set state of the program to the previous one, implementation defined, very reversible.
 🍆️ - be an Aubergine derivative. I'm not sure why this is a category. Implementation defined. Implicitly at the start of all programs.
 c - be a 5D Brainfuck With Multiverse Time Travel derivative. Implementation defined. Implicitly at the start of all programs. I'm not sure why this is a category, either.
 J - interpret the remainder of the program as J, thus declarative.
 🏌️ - interpret the remainder of the program as GolfScript, thus golfing language.
 m - Modify the source code.
 ! - Modify how the esolang works to make it a push down automaton.
 ¡ - Modify how the esolang works to make it a finite state automaton.
== Example programs ==
I had an excellent set of example programs, which this margin is unfortunately too small to contain.
Category:Languages
Category:Brainfuck derivatives
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Cell-based
Category:Zero-dimensional
Category:Multi-dimensional languages
Category:Two-dimensional languages
Category:Non-textual
Category:Low-level
Category:High-level
Category:Concurrent programming
Category:Unimplemented
Category:2020
Category:Self-modifying
Category:Thematic
Category:Brainfuck derivatives
Category:Aubergine derivatives
Category:Push-down automata
Category:Finite state automata
Category:Concurrent programming
Category:Reversible computing
Category:Quantum computing
Category:Usability unknown
Category:Stack-based
Category:Queue-based
Category:Deque-based
Category:Nondeterministic
Category:Functional paradigm
Category:String-rewriting paradigm
Category:Object-oriented paradigm
Category:Declarative paradigm
Category:Particle automata
Category:Golfing language
Category:Joke languages
Category

Category uses categories and nodes to do stuff
== Graphs ==
=== Node ===
 (A) (B)
 (C)
 (D)
 (E)
=== Connect ===
 (A) <- (B)
 \ ^
 _| |
 (C)
==== Two way ====
 (A) <-> (B)
=== How it does computing ===
 => #final connection, return
 -> #connection
==== Example ====
 (S) -> (0) => (1)
 \ ^
 _| //
 (1)
1 -> 0
0 -> 1
== Categories ==
=== Functions ===
Surround nodes, => (node) is return, (S) is start
 Id
 /————————\
 |(S)->(0)|
 | | || |
 | v v |
 | (1)(0) |
 | || |
 | v |
 | (1) |
 \————————/
 (1) -> [Id] -> (?)
Category:Languages
Category:Graph-based
Cathain

Cathain (Irish Gaelic for "when", /kəˈhɪnʲ/ "kah-HIN" or /ˈkahənʲ/ "KAH-huhn") is an esolang created by Nurdle. Inspired by languages like Slashes and Thue, its main function is text replacement, however, instead of text, it's actually bits represented as hexidecimal. It also introduces goto-labels and "timelines".
== Syntax ==
the initial state is ff
there are only 3 commands in Cathain:
 Caption text
Symbol 	Description
!(string) 	Define a goto label
@(string 	Goto a label
(search) (replace)	Replace text with something else
if you try to call a goto label that hasn't been defined then the timeline terminates and returns !!!
== Timelines ==
In Cathain, there are timelines, every timeline is defined by a list of bits, every bit corresponds to one of the commands in the given script.
if a bit is on, then its corresponding command will be run in its timeline.
if a bit is off, then its corresponding command will be ignored.
This does include commands that define a label, if a label isn't declared then the timeline will terminate if it tries to call said label.
== Examples ==
=== Example Program ===
This program is used to show how the timeline system works:
 ff 0f
 f a
Output:
timeline 0 (00)
 0 FF
 1 FF
 hex: 0xFF 
 string: 'ÿ'
timeline 1 (01)
 0 FF
 1 AA
 hex: 0xAA 
 string: 'ª'
timeline 2 (10)
 0 0F
 1 0F
 hex: 0x0F 
 string: '\x0f'
timeline 3 (11)
 0 0F
 1 0A
 hex: 0x0A 
 string: '\n'
== Computational Class ==
Cathain is widely believed to not be Turing Complete, however its Completeness is unknown. It is at least as powerful as a Finite State machine.
== See Also ==
* Arís - another language that uses time as a core mechanic of the language.
== External Resources ==
* Python Cathain Interpreter by Nurdle
Category:Implemented
Category:2023
Category:String-rewriting paradigm
Category:Output only
Category:Languages
Category:Unknown computational class
Catshark

Catshark is a Joke language based on Deadfish, created by User:D.
The language is called Catshark because catsharks have two heads.
== Commands ==
There are two accumulators, A and B.
The program is wrapped in an Infinite loop.
Command	Behavior
i 	Increment A.
d 	If A != 0, decrement A. Else, skip next instruction.
s 	Swap A and B.
o 	Print contents of both A and B.
The Python interpreter also supports h as a debugging instruction (to halt the program), but you don't need this instruction for Turing completeness.
== Implementations ==
=== Python ===
It's not large, so I'll post the whole interpreter here:
import sys
prog = open(sys.argv[1]).read()
A, B = 0, 0
ptr = 0
while 1:
 if prog[ptr] == 'i':
 A += 1
 elif prog[ptr] == 'd':
 ptr += (A == 0)
 A -= (A != 0)
 elif prog[ptr] == 's':
 A, B = B, A
 elif prog[ptr] == 'o':
 print(A, B)
 elif prog[ptr] == 'h': # Debug instruction
 break
 ptr = (ptr+1) % len(prog)
=== C# ===
using System;
public class Catshark
{
 public static void Main(string[] args)
 {
 int c;
 int a = 0, b = 0;
 string code = "";
 bool ignored = false;
 while ((c = Console.Read()) != -1)
 {
 code += Convert.ToChar(c);
 }
 while (true)
 {
 for (int i = 0; i < code.Length; i++)
 {
 if(ignored)
 {
 ignored = false;
 continue;
 }
 c = code[i];
 if (c == 'i')
 {
 a++;
 }
 if (c == 'd')
 {
 if (a != 0) a--;
 else ignored=true;
 }
 if (c == 's')
 {
 int t = a;
 a = b;
 b = t;
 }
 if (c == 'o')
 {
 Console.Write(a);
 Console.Write(' ');
 Console.WriteLine(b);
 }
 if (c == 'h')
 {
 return;
 }
 }
 }
 }
}
== Computational class ==
If d allowed skipping blocks of code (such as ( ... )), we can easily simulate two-counter machines.
With Gödel numbering, we can simulate however many "virtual registers" as we need to make it Turing-complete.
An example configuration of A:
2^a 3^b 5^c 7^d (simulate 4 virtual registers,
 which can simulate two binary stacks,
 and therefore a binary tape.)
11^e (A scratchpad for calculating the remainder)
13^f (Store current Instruction Counter)
17^g (A scratchpad for IC equality checks)
B is a scratchpad used to multiply A by a constant, divide A by a constant, or calculate remainders (i.e. checking if the counter is zero in the middle of a loop).
To multiply by a constant N, simply write a loop:
 clr B
2:
 dec A
 inc B (write this N times)
 jz A, 6, 2
6:
To divide by a constant A, do this:
 clr B
2:
 dec A
 jz A, not_divisible, next (Write the above two instructions N times)
next:
 inc B
 jz A, divisible, 2
Based on the structured program theorem, we can translate gotos to the following format:
PC = 1
while PC > 0:
 if PC == 1: # Line 1
 # Step 1 of algorithm
 PC = ... # Goto next line
 if PC == 2:
 # Step 2
 PC = ...
 ...
Unfortunately, d only lets you skip the next instruction. So I think it requires some kind of construction that I'm currently not aware of.
== See also ==
* Autopsy
== External Links ==
* Official Interpreter
Category:Languages
Category:Joke languages
Category:2023
Category:Output only
Category:Implemented
Category:Deadfish derivatives
Cd

Cd is an esoteric programming language based on changing directories.
==Syntax==
Every command is based on changing directories in the batch prompt.
Only the characters \, ", and & are allowed. The "cd " command is executed as the host command for every line.
This is the very simple directory map:
\
-&
==Nagivation==
Cd decides what to execute in Binaryfuck after navigation(seperated by &'s). If the current directory is \, execute 0; Otherwise, execute 1.
==Examples==
===Cat program===
"&"&\&"&"&&&\&"&"&\&&"&"&\&"&"&&
Category:2019
Category:Languages
Category:Unimplemented
Cedar--

Cedar-- is an exercise in making a usable language that has the worst syntax imaginable. It was designed in December of 2018, and was implemented in the two weeks following finals week.
==Features==
Cedar-- is an object-oriented programming language that also supports a procedural paradigm. As such, Cedar-- supports classes (called structs), but it also supports first-class functions and statements.
Cedar-- uses dynamic and duck typing, and has automatic garbage collection, as it is interpreted through the JVM.
Major features that Cedar-- implements are:
* Functions
* Classes (structs)
* Namespaces (collections of functions, structs, and statements to be executed that are contained within a single, named, scope block)
* Scope blocks
* Pattern matching
==Syntax and Example Code==
The syntax of Cedar-- is god-awful.
The first example of Cedar-- is the cliched "Hello World".
 include IO.
 IO::puts << "Hello World".
First of all, you can tell that the "puts" function is contained within the "IO" namespace. Statements end with a dot ("."), members of structs and namespaces are accessed with the scoping operator ("::"), and arguments are passed to a function using the argument operator ("<<"). Now we'll move into defining functions.
 fun fib << n (
 if n < 2 (
 n >> ret.
 )
 else (
 (fib << n-1) + (fib << n-2) >> ret.
 )
 )
This code snippet shows a great deal of new syntax for Cedar--. Functions are defined using the "fun" keyword, followed by the name of the function, then the argument operator ("<<"), then a comma-separated series of arguments. The function body is enclosed by a pair of parentheses. If-else blocks are denoted by the keywords "if" and "else" (note that else-if functionality is provided by using an "elif" block). Variable assignment works from left to right, that is the result of the expression on the left (the value) is assigned to the result of the expression on the right (the target). To return a value from a function, that value is assigned to the reserved "ret" variable. Note that there is one exception to the function definition syntax described above: functions with no arguments. These functions are called "free" functions, and must use the "free" keyword in their definition:
 fun free says_hi (
 include IO.
 IO::puts << "Hi".
 exclude IO.
 )
 free says_hi.
The "free" keyword must also be included in the function call. The reasoning behind this is that, since functions are a first-class variable, there is no discernible difference between a function call with no arguments and simply a function as a variable. The "free" keyword distinguishes the two. Now let's move on to structs.
 struct Person (
 init << name, age (
 name >> this::name.
 age >> this::age.
 )
 
 free print_name (
 include IO.
 IO::puts << this::name.
 exclude IO.
 )
 
 free print_age (
 include IO.
 IO::puts << this::age.
 exclude IO.
 )
 )
Category:Implemented Category:High-level Category:Object-oriented paradigm Category:Languages Category:2018
Cell

Cell is Turing-complete language founded by OsmineYT in 2019. The sense of making this language is simple: make an Turing-complete language first instead of irregular languages.
== Commands ==
Command 	Description
j<cell number>	jumps to cell
n 	next cell
p 	previous cell
a<number> 	assigns number to current cell
+ 	changes current cell state by adding 1
- 	changes current cell state by substracting 1
. 	prints an ASCII character from the value of current cell
, 	gets user's input and store it in current cell
{ 	If the current cell is equal to 0, move ahead to the next }
} 	If the current cell isn't equal to 0, move back to the previous {
(Statements "{" and "}" are maded by User:JonoCode9374.)
== Examples ==
Hello, World! program:
 j0 a72 . a101 . a108 . . a111 . a44 . a32 . a87 . a111 . a114 . a108 . a100 . a33 .
This prints "Hello, World!".
cat program:
 j0 , .
Remember it's a one-time cat.
== Implementation ==
A simple python interpreter
Category:Languages
Category:2019
Category:Turing complete
Category:Implemented
Cello

Cello is a superset of C99 which extends the language with garbage-collected objects, interface-driven polymorphism, and reflection. While every C program is a valid Cello program, idiomatic Cello is written like a embedded domain-specific language with its own syntax for declaring structs, allocating memory, and interacting with standard libraries. It is implemented as libcello, a portable C99 library which redefines C syntax to allow C compilers like gcc, clang, cl, or tcc to compile Cello.
== Examples ==
=== Hello World ===
 #include "Cello.h"
 int main(int argc, char **argv) {
 println("Hello %s!", $S("World"));
 return 0;
 }
== External links ==
* "A Fat Pointer Library", Holden 2015, the article which introduced the concepts underlying libcello
Category:2015
Category:Turing complete
Cells

If you want to learn most to everything about Cells then go to this document. Or you can see the side image which is the current website.
If you see "The End" then you are on the current version of Cells, but if you don't see it, it means that you are seeing it being edited.
Here are some commands so you can understand:
Command	Usage
(alpha)	Initiates the 'alphabet' command, number for letter.
(ascii)	Initiates the ascii value command.
(num) 	Initiates the number command
Here are some examples from the website. 
 (1,1)(_+,=_)
OUTPUT: 2
 (alpha)(8,=_)(5,=_)(12,=_)(12,=_)(15,=_)
 (ascii)(32,=_)
 (alpha)(23,=_)(15,=_)(18,=_)(12,=_)(4,=_)
OUTPUT: hello world
The End (for now).
The language is currently being implemented, and when it is on Github the link will be posted (somewhere) here.
==See also==
Check out the Hello World Page
3s0!an9 b0y
Category:Languages
Category:Joke languages
Category:Total
Category:Unimplemented
Category:String-rewriting paradigm
Category:Output only
Cellular

Cellular is a esoteric language based on two dimensional cellular automata, that works on a stream of data. It is executed on a cylindrical surface, where the top is fed with the input and the bottom represents the output. Execution finishes when the input is fully consumed. The width of the cylinder is n bits, depending on the size of the input and the output. 
The user can supply input, rules and an initial program to the interpreter. Program here means placements of the cells on the cylinder. 
The program and input are processed as classical game of life or as a CA with a different rule set. Every step output is read from the bottom of the cylinder and given back to the user. 
== Instructions ==
 Instructions
Prefix	Payload 	Size 	Description
r 	rule set as bits	9 bits	Multiple rules can be given
p 	program as bits 	n bits	The initial program, multiple lines can be given
s 	input stream 	n bits	The input, multiple inputs can be given
== Example program ==
Not very useful, but it gives an example. 
 r:000100000
 r:001100000
 p:00000000
 p:00001010
 p:00101000
 s:11100111
 s:11100111
 s:11100111
 s:11100111
 s:11100111
This creates a streaming processor that processes 8 bits of data. p sets up the initial playing field. The first r is the ruleset for cells in state 0, aka dead. They will transition to state alive if they have 3 neighbors. The second r is for cells with state 1. 2 and 3 neighbors keep them alive. 
And finally an s is send every step to the top in the order given, above the first program line. 
Implementation 
Category:Languages
Category:Implemented