nyuuzyou/wikis huggingface dataset:
Cactusi

Cactusi is an esoteric programming language created by Areallycoolusername. Instead of code being made of text or numbers, you code in this language is made by underscores (_), vertical bars (||), and equal signs.
== Explanation ==
These symbols don't add up to codes either. Instead you use them to make drawings similar to the no-internet game on chrome. A sample program looks like:
 || || 
 ==|| =||=
_____||____||____
However, this program doesn't do anything. All code has to to start with four underscores, and all code has to end with four underscores. An underscore that doesn't start or end the code is used to print something. Since underscores are used throughout the program, you can presumably create a quine.
Here's a chart with commands.
Command 	Function	
Underscore(_)	Print 	
Equal(=) 	1 	
Vertical bar 	0 	
As you can see, the code is binary, vertical bars are 0 and equal signs are 1. The "cacti" in the program can only be 3 characters high. They can't be more than 3 characters long either. You would think that at maximum the cacti are in a 9 character block, but they aren't. They can only reach a 7 character block, since the cacti have to start with one (||) sign. No other symbols other than an underscore are allowed horizontally next to the starting (||) sign. The starting vertical bars don'the count towards the binary pattern you're encoding. Which means:
 || || < Only this line
 ==|| =||= < and this line are read.
______||____||____
 ^ ^
 This & this are also read during execution.
== Mechanics ==
Code is read from the bottom up. Code is also read from left to right.
Category:Languages
Category:2019
Category:Unimplemented
Caeos

Caeos, pronounced "Say oss", is an esoteric programming language that could produce anything at run time it was made by Areallycoolusername. This is similar to Snowflake except it doesn't slowly perform the function it was originally meant to perform. 
== Dynamics ==
Caeos is based off of Chaos Theory, a branch of mathematics that "focuses on the behavior of dynamical systems that are highly sensitive to initial conditions." In this language, that means that when the program is run, depending environmental factors such as the code, the program may perform something completely different than its original purpose. There are 3 principles that make something chaotic according to Robert L. Devaney: 
1. it must be sensitive to initial conditions 
2. it must be topologically mixing
3. it must have dense periodic orbits
The third criteria, means the chaotic situation must return to its original position after a certain number of times or lenth of time. Since this would make Caeos too much like Snowflake, it's omitted. So this language basically does whatever it wants.
== Code ==
The initial conditions Caeos take into consideration is the may the code is. For example, if the code is in a line, the program notices that. If the code has multiple capitalized letters in a word, such as "PrInT", the program notices that. The list goes on. However, a lot of the time, conditions don't matter to the program at all. In this language the only command is print.(Because I'm not going to spend hours on a chaotic language that I'll never get back.) That command is "{{}}". The opening brackets come before the thing you want to print, and the closing brackets come after. However, it doesn't even matter what you put, because you can get something entirely different. 
== Hello World Program ==
{{Hello, world!}}
Anything not between brackets is ignored, so this is a comment.
This program may or may not result in the output being hello world.
== Implementations ==
https://github.com/shitty-esolang-stuff/caeos
Category:Languages
Category:2019
Category:Implemented
Caker

Caker is a programming language created by User:TuxCrafting.
Caker operates on an unbounded bit tape.
== Commands ==
Command	Action
ω 	If the current cell is 0, flip the bit at the left of the tape head. Otherwise, flip the bit at the right.
Ω 	If the current cell is 0, move the tape head one left. Otherwise, one right.
θ 	Push the current bit on the print stack.
Θ 	Print the character on the print stack and clear the print stack.
( 	Execute the code before the matching ) while the current cell is 1.
γ 	Print the current bit on stdout.
Γ 	Read a bit from stdin.
ξ 	Read a character and put it in the print stack.
Ξ 	Pop a bit from the print stack and put it in the current cell.
Δ 	Set the current cell with a random bit.
== The print stack ==
To print a character, bits are pushed on a special stack.
Example: ωΩθΩθθθΩθθ set the print stack to 100011, so executing Θ will print #.
== Examples ==
=== Hello, World! ===
ωΩθΩθθΩθΩθθθΘΩθθΩθθΩθΩθΩθΘθθΩθΩθθΩθθΘΩθθΩθΩθθΩθθΘΩθθΩθΩθθθθΘθΩθΩθθΩθθΘΩθΩθθθθθΘΩθΩθΩθΩθΩθθθΘθθΩθΩθθθθΘθθθΩθθΩθΩθΘΩθθΩθΩθθΩθθΘΩθθΩθθΩθΩθθΘΩθΩθθθθΩθΘ
=== Cat ===
ωΩ(ξΘ)
=== Print a infinite stream of random bits ===
ωΩ(θΔγΞ)
== Implementations ==
Reference implementation by User:TuxCrafting
Category:Cell-based
Category:Low-level
Category:Implemented
Category:2016
Category: Languages
Cal

Cal is a simple tool used for doing simple calculations automatically invented by User:A. A lot of the commands are based on emojis(in order to enhance readability and denseness(which was in turn influenced by TECO, Text Editor and COrrector)).
==Syntax==
A mathematical expression will be read depending on how the program counter moves. After that, the mathematical expression will be evaluated and outputted to the console.
In order to jump through multiple tags, a combination of going-tag commands can be used, as in this one, which goes through 3 tags:⏩⏩⏩
==Command set==
Command	Result
- 	Subtraction or negation operator
Number 	A constant
⏫ 	Indicates a tag
⏪ 	Go left 1 tag
⏩ 	Go right 1 tag
🔁 	Repeat code between this indicator and the matching tag the absolute value of the-current-value times as it resets the value to the previous result of operations (0 if no previous results available)
🚫 	End the program
==Examples==
===Calculate 2*5===
2⏫--5🔁🚫
===Calculate the square of 4===
2⏫2⏫--4🔁🔁🚫
===Return the absolute value of -5===
-5⏫--1🔁🚫
===Comments===
--1⏩This is an example of a comment.⏫🚫
===Go right 2 tags===
This can be useful when someone wants to jump through nested loops.
--1⏩⏩--1⏫⏩⏩⏫🚫
===Set the result to infinity (i.e. an infinite loop)===
⏫--1⏪🚫
===Calculate 3+2*4+3===
2⏫--4🔁--3--3
Category:2019
Category:Unimplemented
Category:Languages
Category:Output only
Calc

= About =
calc is a minimalistic esoteric programming language designed around the concept of calculations. The language consists of mathematical operations and three basic keywords. It is designed to be as simple as possible, with the primary goal of evaluating calculations. it is also made by ChatGPT (4o-mini. and so is this page with some changes.).
== Overview ==
Calc is a language where the entire syntax is based on performing mathematical calculations. It features three keywords:
* start - marks the beginning of the program.
* end - marks the end of the program.
* print - prints the result of a calculation.
Any other line is considered a mathematical expression and is executed as a calculation. The language is interpreted using JavaScript (Not normal JavaScript, Node.JS), and files are given a `.cal` extension. 
== Syntax ==
The syntax of Calc consists of the following components:
=== 1. start ===
The program begins with the keyword start.
=== 2. end ===
The program ends with the keyword end.
=== 3. print ===
The keyword print outputs the result of a calculation.
=== 4. Calculations ===
Any mathematical expression is valid. You can use basic arithmetic operators like `+`, `-`, `*`, and `/`. Expressions are evaluated sequentially.
=== Example Program ===
start
 5 + 5
 print 10 * 2
 # comment
 7 / 3
end
the start in the first line is to start the program.
the end in the bottom line is to end the program.
Category:Generated_by_AI Category:Languages Category:2024 Category:Unimplemented Category:Total Category:Unusable for programming
Calculator

Calculator, is an esoteric programming language, where we are doing operations on numbers. Idea of this language was invented by Ivan Homenko.
== Examples ==
=== Hello, World! ===
.!;
H.72.v;H.@;
e.101.v;e.@;
l.108.v;l.@;l.@;
o.111.v;o.@;
comma.44.v;comma.@;
space.32.v;space.@;
W.87.v;W.@;
o.111.v;o.@;
r.114.v;r.@;
l.108.v;l.@;
d.100.v;d.@;
!.33.v;!.@;
linefeed.10.v;linefeed.@;
=== Truth-machine ===
var.$.v;
var.0.1.!0;
0.?;
0.0.v;
0.#;
.~;
1.?;
1.1.v;
1.#;
1.^;
=== Cat ===
in.$.v;in.#;
== Docs ==
Basic instruction syntax it's: arg1.arg2.....command;
End of instruction should be ended by ;
Instruction	Desc
a.b.+ 	Var a += var b
a.b.- 	Var a -= var b
a.b.* 	Var a *= var b
a.b./ 	Var a /= var b
a.b.% 	Var a %= var b
a.b.v 	Sets value of var a by value b, but if b is $ symbol, value takes from input
a.b.> 	Var a = var b
a.# 	Output var a
a.@ 	Output var a as ascii
.! 	Clears output
.~ 	Stops program
a.^ 	Jumps to label a
a.b.c.!0 	If value of var a == 0, jumps to label b, else jumps to label c
a.b.c.!1 	If value of var a == 1, jumps to label b, else jumps to label c
a.b.c.d.!= 	If value of var a == value of var b, jumps to label c, else jumps to label d
a.b.c.d.!==	If value of var a != value of var b, jumps to label c, else jumps to label d
== External resources ==
* http://alc.comuf.com/calcul.php (Javascript implement)
Category:Languages
Category:2016
Category:Implemented
Category:Turing complete
Category:Stack-based
Calculon

Calculon is a new, esoteric language written by User:Grulf. It is purely mathematical and only allows input and output of numeric values, currently with only 4 digits after the comma.
== Language overview ==
Calculon's syntax is best described with an example program:
 5 get sub peek
This program takes a number from the input, call it n, performs the calculation n - 5 and prints it.
As you can see, commands are separated by whitespace.
Any numerical value written will get pushed onto the stack, in this case "5".
The command "get" requires the user to input any number and pushes it onto the stack.
Then, the command "sub" pops two values from the stack, following the LIFO-principle and therefore subtracting the bottom value from the top value of the stack, and pushes the resulting value onto it, which the command "peek" prints out without modifying anything.
The following commands are currently implemented in the language (which is still in progress):
Command	Description
add 	Pops two values from the stack and adds them, pushing the resulting value onto the stack.
sub 	Pops two values from the stack and subtracts the bottom value from the top value, pushing the resulting value onto the stack.
mul 	Pops two values from the stack and multiplies them, pushing the resulting value onto the stack.
div 	Pops two values from the stack and divides the top value by the bottom value, pushing the resulting value onto the stack.
sqrt 	Pops a value from the stack and pushes its square root onto it.
sq 	Pops a value from the stack and pushes the value squared onto it.
get 	Pushes the validated user input onto the stack.
peek 	Prints the first value of the stack, without modifying anything.
cond 	Pops a value from the stack and compares it with the next value on the stack. If they are equal, the other value is also popped and the code until the identifier "end" is executed. If not, the following code until the identifier "end" is ignored and only one value has been popped.
end 	Marks the end of a condition.
setr 	Pops a value from the stack and sets the internal loop variable to it.
repeat 	If the internal loop variable is above zero, repeat all statements since the last "setr".
== Example programs ==
 10 33 100 108 114 119 32 44 111 108 101 72 peek setr peek setr peek peek setr
 peek setr peek setr peek setr peek setr peek setr peek setr peek setr peek setr
 peek setr
Prints the number sequence "72 101 108 111 44 32 119 114 108 100 33 10", which is "Hello, world!" in ASCII codes.
 0 0 div peek
Divides zero by zero and prints the result.
(Stub)
== Interpreter ==
The interpreter was originally written in Ruby, but then ported to C++, where the language underwent some major changes.
The C++-Interpreter currently has 184 lines and the source will soon be available for download.
It will be distributed under the WTFPL-License.
Category:Languages
Category:Stack-based
Category:2010
Category:Unknown computational class
Category:Implemented
Call

Call is an implementation of Lambda Calculus using only the symbols `(` and `)`
==Syntax==
Code in call is a balanced sequence of round brackets ( ) all other characters will be ignored.
The contents of the first bracket will be parsed a lambda expression.
All successive brackets are function arguments, they will be recursively parsed as sub-expressions.
(First element as lambda-function, all successive elements as arguments)
Within Lambda expressions, brackets containing multiple elements are used to group elements, nested brackets containing an empty bracket are used to encode the positions of the arguments of the lambda expression, with the argument index being encoded by the nesting depth (() -> 0 (()) -> 1)
For example:
 ((())(()(())((())))) ( (()(())) () ( ((())()) ) )
will be parsed as 
 [Labc.b(a b c)] ( [Lab.ab] [La.a] [Lab.ba] ) 
Some lambda expressions with unused arguments (e.g. x->y->x) cannot directly be represented, they can be encoded by adding additional arguments and passing functions that will reorganize the body of the expression in the required way.
For instance x->y->x can be encoded as (a->b->c->a c b) (x->y->y)
giving the expression (()((()))(()))(((())))
==Examples==
Church literals for 0 to 3:
 0: ((()))
 1: (()(()))
 2: (()(()(())))
 3: (()(()(()(()))))
Successor function (n->g->x->g (n g x)):
 ((())(()(())((()))))
Addition (m->n->f->x-> m f (n f x)): 
 (()((()))((())((()))(((())))))
==Computational class==
Call implements lambda calculus which is Turing complete
==External resources==
Implementation
Category:Languages
Category:Functional paradigm
Category:Turing complete
Category:No IO
Category:Implemented
Call Queue

Call Queue is an idea for a queue-based esoteric programming language, thought of by User:Koen in 2013. Basically, a program in Call Queue looks like a program in your average imperative programming language, except functions are executed using a "call queue" instead of the usual call stack.
Call Queue was inspired by the similarities between a queue-based algorithm implementing breadth-first search in a tree, and a stack-based algorithm emulating recursion.
==Semantics==
===Syntax===
A program in Call Queue is a set of function declarations. A function declaration consists in the function prototype, which informs its name and its arguments, and the function body, which is a sequence of statements.
A statement is either an atom or a function call. Atoms are built-in minimal functions.
One of the functions must be named main.
===Execution===
When execution starts, the body of the function main is converted into a queue of statements, thereafter referred to as the call queue.
Execution proceeds in a loop:
* While the call queue isn't empty
** Dequeue the first element from the call queue
*** If it is an atom, execute it.
*** If it is a function call, append its body (as a queue of statements) to the call queue
===Atoms===
This section is empty. Call Queue is yet unfinished.
==Example programs==
Since the atoms haven't been defined yet, it is currently impossible to write a real program in Call Queue. The following is a dummy program that illustrates how execution unwraps, assuming the single-letter words in capital are atoms.
 function a() { A; c(); d(); }
 function b() { B; e(); f(); }
 function c() { C; }
 function d() { D; }
 function e() { E; }
 function f() { F; }
 function main() { M; a(); b(); }
The call queue would develop as follows:
 M a() b()
 a() b()
 b() A c() d()
 A c() d() B e() f()
 c() d() B e() f()
 d() B e() f() C
 B e() f() C D
 e() f() C D
 f() C D E
 C D E F
 D E F
 E F
 F
Finally, atoms have been executed in the order M A B C D E F.
This is different from usual programming languages using a call stack, where such a program would end up with atoms being executed in the order M A C D B E F.
===Implementations===
* if Call Queue (files)
Category:LanguagesCategory:Queue-basedCategory:Usability unknownCategory:Unknown computational classCategory:2013Category:Implemented
Call Queue/if Call Queue

This is a dialect (and the implementation of it) of Call Queue called if Call Queue with some atoms defined.
==Running==
Call Queue.js contains the functions for if Call Queue. The main interpreter function is call_queue() (it's a generator because I want nice stepping and no locking in infinite loops). Here's an example:
var demo = call_queue(`
	function a() { A; c(); d(); }
	function b() { B; e(); f(); }
	function c() { C; }
	function d() { D; }
	function e() { E; }
	function f() { F; }
	function main() { M; a(); b(); }
`);
var result = demo.next().value;
while(result != undefined) {
	output = result.output;
 result = demo.next().value;
}
console.log(output.join("")); // "MABCDEF"
==Differences to normal Call Queue==
Since no atoms are defined, I took the liberty to define if;, which can be seen here:
function true() {
	1; true();
}
function false() {
	0;
}
function main() {
	if; true;
		true();
		false();
	<put `true;` or `false;` here>
}
If you put true;, it matches the required symbol and calls true(); and for anything else (like false;), it doesn't match the required symbol and calls false();.
All other atoms print themselves.
Legal symbols (function names/function calls/atom calls) are this regex /[A-Za-z_0-9]+/.
==Implementation==
if Call Queue
Category:Languages
Call stack

In computer programming, the call stack is a low-level stack data structure (of course) which contains information about the currently running subroutines. The call stack's primary purpose is to store the order of subroutine calling, in order to inform the computer program as to which subroutine the current subroutine returns to. Some languages employ separate stacks for data and calls, while others use the same stack for both
purposes (notably the x86-architecture).
== Spicing it up ==
The call stack can be made esoteric in a various ways. A simple way to do this is shown by Call Queue, an otherwise standard language where the call structure is a queue instead of a stack. Appending a function to the queue does not immediately call it, and functions "return" control to the next function that was called instead of their caller. A good metaphor for this is multitasking with a queue where every task can queue new tasks to be executed at some point in the future.
Many non-esoteric, LISP-like languages have first-class continuations. They can be implemented by replacing the traditional stack with a spaghetti stack, where every call frame holds a reference to its caller and control can be transferred to any call frame; it's like GOTO on steroids. You can also give programs the ability to directly manipulate the call stack in whatever fashion you want.
== Other kinds of call stacks ==
=== Buffering Calls ===
Some languages employ call stacks to 'buffer' calls rather than immediately carrying them out. This technique is usually only used when interpreting languages though. Such languages tend to employ
two different kind of stacks: A call stack (sometimes also called function stack) and a data stack. If the interpreter encounters a value it is pushed to the data stack, if it encounters a call to a function
it is pushed to the call stack. If the interpreter encounters a special operator (may be a newline as well) it executes all calls currently on the stack. The main purpose of this technique is to allow for
prefix, postfix and infix notation at the same time (all the following lines are semantically equal):
5 5 squ add;
squ 5 add 5;
squ 5 add 5;
squ add 5 5;
squ 5 5 add;
Category:Data_Types_and_Structures
Call stack/Manipulation

:
Call Stack Manipulation is a language construct where the language itself contains built-in features to allow the user to interfere with the logical and intuitive methods in which functions call other functions and get their return value.
== Call Stack Overview ==
To understand manipulation of the call stack, one must first understand the call stack itself. This section lays out a high-level explanation of how it works, or at least how the author is about 90% sure it works.
When a function is called, the language pushes that function onto the call stack, a stack representing the order of calling. When a function calls another function, the new function is pushed. When a function returns, it is poped off the top of the call stack and its value is returned to the new top of the call stack. This ensures that functions are called in the logical order.
== Call Stack Manipulation ==
Now, what if the user could mess with the call stack? Control its behavior? That is what call stack manipulation allows. Call Stack Manipulation is like a stripped-down version of normal stack manipulation, but it allows the user to change the order of function calls from within functions. There are two types of call stack primitives: Call primitives and execution primitives. Call primitives are an alternative way to call a function, generally a first-order function that changes the way the function is added to the call stack. Execution primitives are keywords that mess with the call stack during execution.
The first execution primitive is leer; (all of these keywords are in anglicized German, because why the hell not). leer; pushes a special function, the general identity function, onto the stack. This seems useless, until you remember that it gets popped off when the current function returns. This means that the current function gets repeated instead of returning to its caller, and serves as a sort of secretive recursion-based loop.
One I thought of (different author here) is swap. This is borrowed straight from typical stack manipulation functions, but it swaps the top two frames on the call stack. The instruction pointer is "returned" automatically to where the new top frame was. The function "returns" but sneakily captures the caller's return result for itself, and it can decide what to do with it.
Feel free to add your own, I guess.
Category:Data Types and Structures