nyuuzyou/wikis huggingface dataset:
Colambda

Colambda is an esoteric programming language designed by User:Zzo38 in 2010 as a sort of coprocessor for Unlambda programming. When Colambda must be loaded, it must be a program file containing one or more Unlambda programs which can be numbered, and one or more files of arbitrary data, which can be numbered. One main Unlambda file is numbered zero, and is the file when starting the program. You can run multiple threads, and there is a storage of INTERCAL registers shared with all threads. Each thread of Unlambda codes has its own memory and input/output.
The Unlambda program must send commands as output, which are processed by Colambda, and receives input for the results of commands.
These are commands that can be used:
* 0 - output bit zero
* 1 - output bit one
* ? - receive character of input as eight bits 0 and 1 (or . if EOF)
* ~dxy - read x and y and use select operator, stored in d
* $dxy - read x and y and use interleave operator, stored in d
* ?d - read d and use unary XOR, stored in d
* &d - read d and use unary AND, stored in d
* Vd - read d and use unary OR, stored in d
* Ndxy - read x and y and use NAND operator, stored in d
* _dx - read x and store in d
* *x - receive value of x
* Sd - stash x
* Rd - retrieve x
* id - ignore x
* rd - remember x
* ox - send x to output
* ydx - get binary data from stream x and store in array d, first reallocating array to correct size (data stored 8 bits in each cell)
* Ydx - same as above but as many bits as possible in each cell of the array
* + - increment value of register :1
* - - decrement value of register :1
* Bx - get binary data from stream x send to Unlambda program as 0 and 1
* bx - get binary data from stream x send to Unlambda program as bytes characters
* ad - reallocate an array, using values of .1 .2 .3 for number of elements each dimension, if one of these is zero, that is the end of the dimensions
* =dx - create subprogram thread of program numbered x, and store the subprogram thread ID number in d
* !x - switch to subprogram x
* Mx - make Colambda execute commands from characters of byte stream x, until stream is end
* mx - send characters of stream x to output
Source/destination operands can use a character followed by the 0 and 1 for sixteen bits:
* # - literal number value
* . - 16-bit register
* : - 32-bit register
* , - 16-bit array (uses .1 .2 and so on for subscript numbers)
* ; - 32-bit array (uses .1 .2 and so on for subscript numbers)
* / - same as previous operand (no bits)
* P - number of thread switched out of (no bits)
* p - number of current thread (no bits)
As well as 0 and 1 for bits, you can also use these abbreviations:
* q - 0000
* Q - 00000000
* k - 1111
* K - 11111111
* d - 00000001
* j - 100
Category:Languages
Category:2010
Category:Unimplemented
Cold Hard Chess

Cold Hard Chess is a programming language which looks like chess notation. 
==Instructions==
Cold Hard Chess operates on a grid on 64 registers a1-a8, b1-b8, ..., h1-h8, all initialised with 0.
To modify the register values, the six chess pieces are used:
 
Piece 	Syntax	Instruction
Pawn 	xy 	Sets x to y.
Knight	Nxy 	Sets x to x plus y.
Rook 	Rxy 	Sets x to x minus y.
Bishop	Bxy 	Sets x to x times y.
Queen 	Qxy 	Sets x to x divided by y, rounded down. Sets y to the remainder.
King 	Kxy 	If x equals y, skip the next instruction.
Pieces marked 'y' may have an 'x' before them. This is a capture, or a constant in CHC. Here is the table of constants for all pieces:
 
 	a 	b 	c 	d 	e 	f 	g 	h
1	0 	1 	2 	3 	4 	5 	6 	7
2	8 	9 	10 	11 	12 	13 	14 	15
3	16 	32 	48 	64 	80 	96 	112 	128
4	144 	160 	176 	192 	208 	224 	240 	256
5	0 	-1 	-2 	-3 	-4 	-5 	-6 	-7
6	-8 	-9 	-10 	-11 	-12 	-13 	-14 	-15
7	-16 	-32 	-48 	-64 	-82 	-96 	-112	-128
8	-144	-160	-176	-192	-208	-224	-240	-256
Category:Languages
Category:Unimplemented
Category:2024
Collab

Collab is a collaborative esolang.
Do not modify other's commands!
== Commands ==
Command	Description
# 	Start the program
$ 	End the program
: 	Push 0 to the front of the Deque
; 	Inject 0 to the back of the deque
+ 	Increment the value at the front of the deque, works like brainfuck + if data is a tape
- 	Decrement the value at the front of the deque, works like brainfuck - if data is a tape
* 	Move the value at the bottom of the deque to the top, if the deque is a tape, move the tape pointer right
"" 	Push the literal string within the quotation marks to the deque
k 	Turn the deque into a tape, with cells 0 - n initialized to the values in the deque from back to front. The pointer is initialized to the location of the front of the deque
l 	Turn the tape into a deque
q 	Copy the next two characters and append them to the end of the code. The characters are still run after the q command runs (for example, q+k appends +k to the code, increments tbe front of the deque, and turns the deque into a tape).
< 	Move the tape pointer left. If the data is a deque, Move the value at the top of the deque to the bottom
o 	Output the string at the top of the deque. If data is a tape, output the current cell's value as a number
s 	Run the string at the top of the deque as code
? 	pop the top value of the deque, and skip that many commands if the second from top (which is now the top) of the deque or the current cell is not zero
. 	Skip next command if top of stack or current cell is 0
[ 	Go to the command before the matching ]
] 	Go to the command after the matching [
i 	Take a number from user input and push it to the deque
n 	NOP
a 	Pop the top two values and preform lunar addition on them.
m 	Pop the top two values and preform lunar multiplication on them.
^ 	Duplicate top two values of the deque
& 	Line comment
\ 	push a newline character
==Examples==
===Hello World===
#"Hello, World!"o
===Truth-machine===
#i[:kol$:+:++?][:+kol]
===99 bottles of beer===
::+++++++++++k[*+++++++++<-.]*- & get 98, leaving a 0 behind it
[+
kol" bottles of beer on the wall,"o\o
kol" bottles of beer."o\o
"take one down, pass it around"o\o
k-ol" bottles of beer on the wall"o\o\o
-.]+ & end loop if top of stack is 1
"1 bottle of beer on the wall"o\o
"1 bottle of beer."o\o
"take one down, pass it around"o\o
"no bottles of beer on the wall"
==Computational class==
Collab is Turing-complete, as the Turing-complete subset of Underload :()^ is equivalent to the Collab commands ^""s
Category:Languages Category:User Edited Category:Cell-based Category:Deque-based
Collatz sequence

The Collatz sequence, also called the Hailstone sequence, is a sequence of numbers relevant to the Collatz conjecture, which theorizes that any number using this algorithm will eventually be reduced to 1. The conjecture's truth is supported by calculations, but it hasn't yet been proved that no number can indefinitely stay above 1.
==Formal definition==
To get a Collatz sequence from a number, if it's even, divide it by two, and if it's odd, multiply it by three and add one. Continue the operation on the result of the previous operation until the number becomes 1.
==Pseudocode Example==
 function collatz(n)
 while n > 1
 show n
 if n is odd then
 set n = 3n + 1
 else
 set n = n / 2
 endif
 endwhile
 show n
==Example of a Collatz sequence==
Collatz sequence of 25:
 25
 76
 38
 19
 58
 29
 88
 44
 22
 11
 34
 17
 52
 26
 13
 40
 20
 10
 5
 16
 8
 4
 2
 1
==See also==
Collatz function
==External resources==
Collatz conjecture on Wikipedia
Category:Program forms
Collide

Collide is an esoteric programming language invented by User:A that features balls inside a sandbox that maps its edges.
==Example source code (this is not yet documented)==
Put balls like this into this sandbox, where this sandbox's edges include the length as 3 balls wide and the width as 2 balls wide.
 1 
2 3
Now, move the balls like this:
* Choose the ball on row 2, column 3; move the ball left, where the force of this ball is infinity.
* Choose the ball on row 2, column 1; move the ball up, where the force of this ball is infinity.
==Syntax==
# If two balls collide each other with the opposite direction, halt the program.
# If two balls subsequently push each other in the same direction, halt the program.
# The sandbox has a mysterious mechanism that automatically maps its edges without affecting its force.
# If a ball pushes another ball that was set to be moving infinitely, the ball will push the ball in its direction without affecting the direction of the ball being pushed. (Use Remember directions! to enable it)
Here is what the program above will do:
:Step 1
 1
23
:Step 1.5
21 
 3 
:Step 2
21 
3 
:Step 2.5
31 
2 
:The ball 2 maps from the top to the bottom, which pushes ball 3 up. All of ball 2's forces are now transported to ball 3.
:Step 3
21
3
:Now the program has fell into an infinite loop.
Another example program:
Put balls like this into this sandbox, where this sandbox's edges include the length as 3 balls wide and the width as 2 balls wide.
1 2
 
Now, move the balls like this:
* Choose the ball on row 1, column 1; move the ball right, where the force of this ball is infinity.
* Choose the ball on row 1, column 3; move the ball down, where the force of this ball is infinity.
Process:
 1
 2
 1
 2
:Bam! now it has fell into an infinite loop.
Category:Languages
Category:2019
Category:Unimplemented
Colonoscopy

Colonoscopy is a joke esoteric programming language created by Dom Davis. It is identical to Brainfuck, except that the instructions are constructed of semi-colons and braces (;, {, and }) and each command is terminated with a ;. It represents another in a long line of trivial Brainfuck command substitutions. As such, it is a member of the TrivialBrainfuckSubstitution family of programming languages. It's creation was in reaction to the partial, or complete lack of semi-colons in many languages, and jokes about hiding all the braces in languages that use them. Colonoscopy is designed as a final resting place for these unloved characters. 
==Commands==
Brainfuck	Colonoscopy 	Description
> 	;} 	Move the pointer to the right
< 	;{ 	Move the pointer to the left
;;} 	Increment the memory cell under the pointer	
;;{ 	Decrement the memory cell under the pointer	
. 	;;;} 	Output the character signified by the cell at the pointer
, 	;;;{ 	Input a character and store it in the cell at the pointer
[ 	{{
|Jump past the matching }} if the cell under the pointer is 0	
] 	 	
Note: each command must be followed by a ; in a Colonoscopy program.
==Hello, world! program==
 ;;};;;};;;};;;};;;};;;};;;};;;};{{;;};;;};;;};;;};;;};{{;;};;;};;;};;};;;};;;};;;};;};;;};;;};;;};;};;;};;{;;{;;{;;{;;;{;}};;};;;};;};;;};;};;;{;;};;};;;};{{;;{;}};;{;;;{;}};;};;};;;;};;};;;{;;;{;;;{;;;;};;;};;;};;;};;;};;;};;;};;;};;;;};;;;};;;};;;};;;};;;;};;};;};;;;};;{;;;{;;;;};;{;;;;};;;};;;};;;};;;;};;;{;;;{;;;{;;;{;;;{;;;{;;;;};;;{;;;{;;;{;;;{;;;{;;;{;;;{;;;{;;;;};;};;};;;};;;;};;};;;};;;};;;;};
==External resources==
* Colonoscopy home
Category:Brainfuck equivalents
Category:Cell-based
Category:Joke languages
Category:Turing complete
Category:Implemented
Category:Low-level
Category:2016
Category:Brainfuck derivatives
Category:Languages
Color Scheme

Color scheme is a color and stack based language built up on a grid of many cells. Each cell can be divided into more than one color. Different series of colors mean and effect the program in a different way. For example O-LB(Orange-Light Blue) adds 0 top the top of the stack.
== Examples ==
=== Hello World! ===
This is and example of a Hello World! program that prints out 'Hello World!'. A link the preview it in the editor is here.
=== Truth Machine ===
This is an example of a Truth-machine program that written in color scheme. If you put 0 as the input it will just say '0', if you put 1 as the input it will forever say '1'. A link the preview it in the editor is here.
=== Cat ===
This is an example of a Cat which outputs the input. A link to preview it in the editor is here.
=== Fibonacci Sequence ===
This is an example of a Fibonacci Sequence in color scheme. A link to preview it in the editor is here.
=== Factorial ===
This is an example of a factorial program written in color scheme. A link the preview it in the editor is here.
=== Print <3 in the shape of a <3 ===
A link to preview it in the editor is
here.
== Cells ==
=== Control ===
 Control
Cell	Action
 	Stop.
 	Next line.
 	Continue.
=== Input & Output ===
 Input & Output
Cell	Action
 	Output top stack item as a number. (Removes top stack item)
 	Output top stack item as a character. (Removes top stack item) (\n:0, SPACE:1, a-z:2-27, A-Z:28-53)
 	Output top stack item following ASCII value. (Removes top stack item)
 	Clear the output.
 	Ask for input then add it to the top of the stack.
=== Stack Manipulation ===
 Stack Manipulation
Cell	Action
or 	Increment top stack item.
or 	Decrement top stack item.
 	Reset to default stack.
 	Clear the stack.
 	Reverse the stack.
... More information on site.
Category:Languages Category:Non-textual Category:Stack-based
Column

Column is an esoteric programming language developed by Dominicentek. It's code is executed column by column in a text file, rather than line by line like in a typical programming language.
== Instructions ==
 Column instructions
Instruction	Syntax 	Description
var 	<string : variable name> <value : var value> 	Defines a variable
print 	<value : printed value> 	Prints a value to console
user 	<string : variable name> 	Defines a variable with user input as a string
if 	<value : left hand value> <operator : (= != < > <= >=)> <value : right hand value>	If condition is true, execute a code block
else 	 	If the above IF instruction returns false, execute this code block instead
function 	<string : function name> 	Defines a function
call 	<string : function name> 	Calls a function
label 	<string : label name> 	Defines a label
goto 	<string : label name> 	Goes to a label
add 	<string : variable name> <value : value> 	Adds a value to a variable
sub 	<string : variable name> <value : value> 	Subtracts a value from a variable
mul 	<string : variable name> <value : value> 	Multiplies a value in a variable
div 	<string : variable name> <value : value> 	Divides a value in a variable
mod 	<string : variable name> <value : value> 	Modules (gets division reminder) a value in a variable
toint 	<string : variable name> 	Converts a string variable into an integer
tostr 	<string : variable name> 	Converts an integer variable into a string
end 	 	Ends a code block, if not in a code block, it exits the program
exit 	 	Exits program
=== Argument types ===
String argument type can be anything. Terminated with a space.
Value argument type, if its a number, its an constant integer. If its a string wrapped in double quotes are strings that can contain spaces. Otherwise it's a variable.
== Examples ==
=== Hello World ===
p
r
i
n
t
"
H
e
l
l
o
W
o
r
l
d
!
"
=== Truth Machine ===
utipeeelpg
sofrxnlaro
ei iidsbit
rnint eeno
 tnt lt
i p l
niu0 l1o
pnt o o
up o p
tu= p
 t
 0
=== Fizz Buzz ===
utvlavvmmipeipeiipeepige
soaadaaoofrnfrnffrnnrfon
eirbdrrdd id id iddi td
rn e tn fn tfn nao 
 talatftfht it hit tm 
i m mhihir v rv op 
nioporvrve" e" eea "ur 
pnurueeeeeF B e m \ni 
upnine e i =u !o ntn 
tutnt a 5=z z !=u " t 
 t t am3 z 0z = n < 
 0 1mo 0" " 0t 
 ou 0 i 
 un n 
 nt p 
 t u 
 t 
== Interpreter ==
Download
==See also==
* Tiltedc
Category:Languages
Category:2021
Combientièm

Combientièm (from "combientième", the French word for "whichth", i.e. "which number in sequence") is an esoteric programming language inspired by Forth, created by Tanner Swett in 2013. A Combientièm program consists of a sequence of Unicode characters.
== Semantics ==
A mode is either Interp or Comp.
A Combientièm interpreter has the following pieces of state. The mode flag is a mode, initially Interp. The dictionary consists of a map from (Unicode character, mode) pairs to strings, initially mapping every pair onto the empty string. The current definition pointer is a (Unicode character, mode) pair, initially (猫, Interp). Finally, the continuation is a string of Unicode characters, initially the entire program.
The current definition is the string that the dictionary maps the current definition pointer onto.
Each step of the program's execution consists of removing the first character from the continuation (or exiting, if the continuation is empty) and performing its interpretation semantics if the mode flag is Interp, or its compilation semantics if the mode flag is Comp.
For any Unicode character x, if the dictionary entry for (x, Interp) is a non-empty string, then x's interpretation semantics consist of prepending the string to the continuation. If the dictionary entry for (x, Comp) is a non-empty string, then x's compilation semantics consist of setting the mode flag to Interp, prepending R to the continuation, and then prepending the string to the continuation.
The following characters have the following semantics, unless their semantics are determined by the above paragraph:
* N, interpretation semantics: remove the first character from the continuation (call it x), set the current definition pointer to (x, Interp), set the current definition to the empty string, and set the mode flag to Comp.
* M, interpretation semantics: the same as above, except that the current definition pointer is set to (x, Comp).
* R, interpretation semantics: set the mode flag to Comp.
* D, compilation semantics: set the mode flag to Interp.
* L, compilation semantics: remove the first character from the continuation and append it to the current definition.
For any Unicode character x, if x's interpretation semantics are not determined by any of the above, then the interpretation semantics of x consist of doing nothing. If x's compilation semantics are not determined by any of the above, then the compilation semantics consist of appending x to the current definition.
== Computational class ==
Combientièm is probably Turing-complete or something.
Category:Languages
Category:2013
Combinational logic

Combinational logic is a computational model that has less computational power than a Finite-state automaton. Boolean circuits are combinational logic models. This computational model only preserves the current value of an operation and does not retain its history (in definition). It does not even have memory, in contrast to a Finite-state automaton which can use its states as memory.
==Definition==
Boolean algebra is an example of a combinational logic model. (In short, boolean algebra is can be represented as: boolean addition, +; boolean multiplication, •; boolean negation, ¬). They do not take any other values except for true and false.)
A combinational logic model contains only pure functions (i.e. functions that only use their parameters without mentioning non-parameter values or mutable parameter values; their return value is the same for the same arguments; max(x,y), which returns the maximum value between x and y, is an example of this. This is analogous to mathematical functions. Examples of them can be seen in the subsection.). A combinational logic model should at least contain pure functions of the present input only, and in definition, combinational logic does not require historical values to be preserved.
===Examples===
==== Pure functions ====
These are pure C functions:
ceil(x): returns the ceiling of a number
min(x,y): returns the smaller number between x and y
tan(x): returns the tangent of a number
==== Impure functions ====
These functions try to obtain values from a non-parameter:
int reta() {
 return a;
}
void dec() {
 static int x = 3;
 x=x-1;
}
void incx() {
 x=x+1;
}
void hello() {
 printf("Hello\n");
 /* This tries to obtain the value of the string "Hello",
 * which is obviously not a parameter of the hello function.
 */
}
void input() {
 int a;
 scanf("%d",&a);
 /* This tries to obtain a string from the console,
 * which is not a parameter of the function.
}
These functions try to access the value of a modifyable parameter:
void incp(int *p) {
 ++*p;
}
void ret(int *q) {
 return *q;
}
==Computational power==
Combinational logic has a small but not insignificant computational power; many of the circuits used in computers (e.g. adders, subtractors, multiplexers) are implemented in boolean algebra, a model of combinational logic. A mathematical expression is a combinational logic model; however, a reverse-polish notation expression might have more computational power than combinational logic, as it might use the stack as part of the storage.
==External links==
Wikipedia page
Category:Computational models
Combined() Task() Force()

Combined() Task[] Force{} or just Combined Task Force is a esolang by User:Yayimhere based on the hierarchy of operations in arithmetic
== memory ==
Combined() Task[] Force{} has these things:
* 4 equations
* 1 variable
* 3 arrays
* a pointer pointing to a function
the 4 equations are:
* z^{x}\equiv \sqrt{y}
* z\times x- y \ge y\mp z\left\lceil \frac{x}{\left\lceil \frac{x}{z} \right\rceil} \right\rceil
* z + x\le z-y
* x\times z \le\left\lfloor z\frac{x}{y} \right\rfloor
the variable is n which can be incremented decremented and used as a number argument. and the 3 arrays are:
* x
* y
* z
this is how the arrays update each iteration of the program:
* find a solution more than the last one for the equation pointed to for x, y, and z
* append this solution to the end of the array
this is my longest memory section lol
== the stack ==
you know the hierarchy of operations in arithmetic? its represented as a trangle. but here when i say stack i mean the triangle since you could use a stack to represent it. like if the triangle was:
 /\
 /()\
 /----\
 / .... \
 /--------\
 / + - \
then the stack would be:
 |+------+|
 || () ||
 |+------+|
 |+------+|
 || .... ||
 |+------+|
 |+------+|
 || +- ||
 |+------+|
 \--------/
so when i say that stack this is what i mean
== commands ==
 Caption text
command 	description
(body)number	do body when the numberth solution for current equation is found. if not in these braces the commands will just be done before any of the other logic
{operator} 	apply operator to n. operator can be + and - and its obvious what they do to n. increment by 1 and decrement by 1
= 	halt
<body>array 	if the last element of array is 0 do body
: 	pop the top of stack and move to the bottom. this is the main command lol
; 	switch the pointer to next function(the order is as they are ordered in the list of them)
[array] 	delete the last element of array
array| 	append user input(as a number) to array
the program loops until no more solutions can be found
Category:Languages Category:Stack-based
Combining Diacritics

͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͖͖̼ͪͪ͋ͪ͋͋͋͋͋͋͋͋͋ͪͪ͋ͪͪ͋͋ͪ͋ͪ͋͋ͪͪ͋͋͋͋͋ͪͪ͋͋̎̐̀́̀̂̌́̀́̎̚
is an esolang created in 2023. It uses too many diacritics, a bit like a really high Northern Sámi speaker.
== Syntax ==
=== Delimiters ===
* The whole program is surrounded by a pair of ̎
* Instructions are separated by ͖
* The arguments of a function are surrounded by ̀ and ́.
* Strings are surrounded by ̂ and ̌.
=== Strings ===
Strings are very simple: all you need to do is convert them to utf-8, convert the resulting hex to ternary, and encode like this:
* 0 becomes ͋.
* 1 becomes ͪ.
* 2 becomes ͓.
For example, "Hello World!" is ͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓ͪͪ͋ͪ͋͋͋͋͋͋͋͋͋ͪͪ͋ͪͪ͋͋ͪ͋ͪ͋͋ͪͪ͋͋͋͋͋ͪͪ͋͋ (not including the string delimiters).
=== Functions ===
All operators are functions, comprised of a name followed by an argument list.
Below is a list of functions:
* The initialization function ̐
* The end function ̼
* The print function ̚
* The function ҈, which takes in a string of X-SAMPA and applies High German Consonant Shift to the entire thing, and also (BONUS FEATURE!) turns all the vowels into random clicks.
== An example program ==
With all you've learned, the following program should make perfect sense:
 
͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͓͖͖̼ͪͪ͋ͪ͋͋͋͋͋͋͋͋͋ͪͪ͋ͪͪ͋͋ͪ͋ͪ͋͋ͪͪ͋͋͋͋͋ͪͪ͋͋̎̐̀́̀̂̌́̀́̎̚
To learn what it does, just turn your computer upside-down to read the answer key. It's totally not a prank to get disgusting keyboard skank on your face or something.
(actually, it prints "Hello World!")
Category:Languages Category:Output only