nyuuzyou/wikis huggingface dataset:
Crowbar

Crowbar is an experimental programming language by User:nddrylliog that borrows some of the ooc syntax, adding rules which allow the implementation of low-level stuff from a high-level point of view.
== Function syntax ==
 name: func (arg1, arg2, ...) -> ReturnType {
 // body
 }
The -> ReturnType part is optional.
So is the (arg1, arg2, ...) part.
== Closure syntax ==
 callTwice: func (f: Func(Int)) {
 f(1)
 f(2)
 }
 
 callTwice(|x| x toString() println())
== Generics ==
 Container: class [Elem] {
 elem: Elem
 }
 
 c: Container[Int]
 c elem = 42
 
 c2: Container[String]
 c2 elem = "Blah"
== Rules ==
=== A simple rule ===
 fac: func (i: Number) -> Number {
 rule i > 0
 if(i > 1) i * fac(i - 1) else 1
 }
=== Quantifiers ===
 \A (decl | condition) = universal quantifier (ie. "for all <decl> such that <condition>")
 \E (decl | condition) = existential quantifier (ie. "there exists <decl> such that <condition>")
The | condition part is optional.
=== Sub-typing with rules (ie. narrowing types) ===
 Nat: cover from Number {
 rule \A (a: Nat | a >= 0)
 }
Alternative, shorter form:
 Nat: cover from Number {
 rule this >= 0
 }
== Nested types ==
 Array: class {
 size: Nat
 
 Index: cover from Nat {
 rule this < size
 }
 
 get: func (i: Index) -> Elem
 
 // ...
 }
== Examples ==
Incomplete code examples, more to come later:
 // Function syntax
 add := func (a, b) { a + b }
 add(3, 5)
 
 // Rule syntax!
 rule add(-a, b) == add(b, -a)
 
 // Covers can be re-used to create subtypes
 Nat: cover from Int {
 rule this >= 0
 }
 
 // Example of array data structure
 Array: class [Elem] {
 
 // Can't have a negative size, can have zero size
 size: Nat
 
 // dependent types
 Index: cover from Nat {
 rule this < size
 }
 
 // get	
 rule \A (i: Index)
 \E (e: Elem | get(i) = e)
 
 // add
 rule \A (i: Index, e: Elem)
 add(i, e) get(j) = match j {
 case j < i 		 => get(j)
 case j = i 		 => e
 case j < size + 1 => get(j - 1)
 }
 
 // append
 add(e) = add(e, size)
 
 // delete
 rule \A (i: Index)
 delete(i) get(j) = match j {
 case j < i 		 => get(j)
 case j < size - 1 => get(j + 1)
 }
 
 }
 
 List: class [Elem] {
 head, tail: Node
 
 Node: class {
 elem: Elem
 next, prev: Option[This]
 
 rule next prev = this
 rule prev next = this
 rule !\E head prev
 rule !\E tail next
 
 rule \A (e: Elem)
 add()
 }
 }
Category:2011
Category:Languages
Category:Unimplemented
Category:Unknown computational class
Cryptoleq

Cryptoleq is a language consisting of one, the eponymous, instruction, is capable of performing general-purpose computation on encrypted programs and is a close relative to Subleq. Cryptoleq works on continuous cells of memory using direct and indirect addressing, and performs two operations O_1 and O_2 on three values a, b, and c:
\begin{align}
\mathsf{Cryptoleq}\ a, b, c \qquad [b] &= O_1([a], [b])\ ; \\
\mathrm{IP} &= c, \ \mathsf{if}\ O_2([b]) \le 0 \\
\mathrm{IP} &= \mathrm{IP} + 3, \ \mathsf{otherwise}
\end{align}
where a, b and c are addressed by the instruction pointer, IP, with the value of IP addressing a, IP + 1 point to b and IP + 2 to c.
In Cryptoleq operations O_1 and O_2 are defined as follows:
\begin{align}
O_1(x, y) &= x^{-1}_{N^2}y \quad \bmod N^2 \\
O_2(x) &= \left\lfloor \frac{x-1}{N} \right\rfloor \\
\end{align}
where x and y are encrypted values based on a cryptographic parameter, N.
The main difference with Subleq is that in Subleq, O_1(x,y) simply subtracts y from x and O_2(x) equals to x. Cryptoleq is also homomorphic to Subleq, modular inversion and multiplication is homomorphic to subtraction and the operation of O_2 corresponds the Subleq test if the values were unencrypted. A program written in Subleq can run on a Cryptoleq machine, meaning backwards compatibility. Cryptoleq though, implements fully homomorphic calculations and since the model is be able to do multiplications. Multiplication on an encrypted domain is assisted by a unique function G that is assumed to be difficult to reverse engineer and allows re-encryption of a value based on the O_2 operation. G(x,y) equals to encrypted zero if the O_2 of the value Nm + 1 is equal or less than zero, m being the unencrypted x, or equals to the re-encrypted y otherwise. The multiplication algorithm is a top-down model that is based on addition and subtraction, uses the function G and does not have conditional jumps nor branches.
==External Resources==
*Cryptoleq: A Heterogeneous Abstract Machine for Encrypted and Unencrypted Computation
*Cryptoleq Resources Repository
Category:OISC Category:Languages Category:Implemented
Cscalls

An esoteric programming language that is made up of CS:GO callouts made in 2022 by User:nmcassa
==Overview==
Stack based w/ a hand that holds a variable to compare to, like the held piece in tetris. This is used w/ the save pls i have $_ command to offer a basic if statement then goto action. Interpreted in python, I have all the code here: https://github.com/nmcassa/cscalls (with the examples at the bottom).
==Syntax==
One at ___ 	Add var to stack
hacking istg pls report	Remove var at pointer
I'm loaded I can drop 	move up var stack
GRAB AWP 	move down var stack
Tagged ____ times 	move pointer to index
HELP ___ 	Label
Why is no one ___ 	goto
save pls i have $__ 	compare pointer and held, goto if truthy
What skin is that? 	set hand to pointer
Drop me AK 	get hand
YO INSPECT 	print hand
You see him 	look (peek)
team? 	input
PEEK 	print
WHERES MY TEAM 	print stack
==Examples==
====Hello World!====
 One at Hello World!
 PEEK
====Cat====
 team?
 PEEK
====Truth Machine====
 One at 0
 What skin is that?
 One at 1
 team?
 save pls i have $6
 Why is no one A
 PEEK
 Why is no one END
 HELP A
 GRAB AWP
 What skin is that?
 save pls i have $13
 Why is no one END
 HELP B
 PEEK
 Why is no one B
 HELP END
Category:Languages Category:2022 Category:Stack-based Category:Thematic Category:Pseudonatural Category:Implemented
Csigapuszi

Csigapuszi is a hungarian game of who can pinch the hardest,
Which leads this to raging so hard that Its just stupid to program in this esolang Benett0222
(Inspired by brainfuck and brainfuck+)
There is 4 different types of Csigapuszi(.cspur)
Csigapuszi codeR (.cspur)
Csigapuszi codeP (.cspup)
Csigapuszi code0 (.cspun)
Csigapuszi non incrypted (.cspu)
There are 2^16(65536) bytes
All of the bytes are set to 0
The maximum number that a byte can hold is 2^8-1(255)
Bytes can overflow for example:255+1=0 0-1=255
It doesnt have a lot of commands
“+ increment to byte”
“- deincrement to byte”
“> move pointer right”
“< move pointer left”
“g(#) goto byte #”
“v(#) gets val # to Memory for instence(not incryted): ?{v(0)≠v(1)}()”
“s(v1,v2) sets byte v1 to v2”
“?{con}(code) checks if “con” is true and executes “code””
“?{con}(code)!?(codeelse) checks if “con” is true and executes “code” else executes “codeelse””
“!(code) repeats “code” forever”
“!{repeat}(code) repeats “code” “repeat” times”
“:” ends line
“;” ends funcion
“goto(x,y,[R,G,B]) lets pixel goto x,y position and lets color be R,G,B”
First ever code written in Csigapuszi codeR
!R
+gsRUQ)sRWQmR
(EE?_
Q
!+R
(CC*_
QN
+gsRWQ)\mR
nvrR<y}}oX8ov}z!Q_
nvrRsRWQQ_
QN
QN
Same as
!(
?{v(0)=v(1)}(
>++<:
)
!?(
>—<:
);
?{v(1)=2}(
prt(Hello,World!):
prt(v(1)):
);
);
How to encrypt
E(a,b) turn “b” into binary and add all the numbers together in binary use the last number of the binary digit as the number shown in codeR under R (b is the number that the pointer is pointing to)
E(48,3)=>48,3=>48,11=>48,0=>85
ASCII character into Decimal
Decimal into encryptedDec 
codes work like this
#|1|2|3|4|5|6|7|8|9|0
0| Encrytionrow0
1| Encrytionrow1
codeR:
R|1|2|3|4|5|6|7|8|9|0
0|1|0|3|8|9|4|6|5|7|2
1|1|3|9|6|7|5|2|0|8|4
codeP:
P|1|2|3|4|5|6|7|8|9|0
0|4|5|6|7|8|9|0|1|2|3
1|7|5|8|2|0|3|6|4|9|1
code0 or codeN
N|1|2|3|4|5|6|7|8|9|0
0|0|9|8|7|6|5|4|3|2|1
1|8|1|6|9|4|7|2|5|0|3
Category:Languages
Css script

css script is a language created by Abdur-rahmaan Janhangeer from Mauritius to draw CSS shapes. It was created in an attempt to solve the monthly challenges of the creative club, Canada.
== Commands ==
command example :
 fill black
 rect 100 100 50 10
== File extention ==
.candy
== External resources ==
* Site
* Reference
* GitHub
Category:2018
Category:Output only
Category:Implemented
Category:Languages
Ctonia

Ctonia is an esoteric programming language by User:Zzo38 based on call/cc and stacks. There are variables, though.
== Commands ==
* alphanumeric characters are to write a variable name
* {} to create a block
* () for dealing with variables
* , remove variable name
* ^ duplicate
* _ discard
* $ swap
* ! call/cc
* . call/return value
* # write a numbers
* < input
* > output
* + add
* - subtract
* * multiply
* @ out string
* ; clear state, but keep the codes
* ~ debug
== Combinators ==
i
 {^{.}$-!$.};
k
 {^{.}$-!$!.};
v
 {v(^)$.};
Apply
 !$_
I haven't figure out s or others yet.
== Examples ==
Hello world:
 {Hello world!}@
== External resources ==
* http://zzo38computer.org/esoteric/ctonia/
Category:Languages
Category:2008
Category:Stack-based
Cube

==Cube==
Cube is an esoteric programming language made to emulate a 3D cube via a 2D text editor interface. The only files that can run Cube code end with extensions ".cube" and ".dewy".
===Example===
The following text file represents a simple example of Cube code:
2 ....
 . .
 .);.
..........
.( .v .1 .
. . .1 .
..........
 .>a.
 . .
 ....
 . .
 . .
 .... 
===Features===
- 2D representation of 3D coding interface.
- Code intuitively represents an unfolded cube
- Input/Output Functionality
- Is primarily run from two Stacks(Operation Stack and Char Stack)
- Special Functionality When Crossing Between Sides(Marked By Periods)
- One of the few languages that can be run from more than one extension(.cube and .dewy)
- Exclusively Coded in Python Meaning Source Code is Relatively Easy To Understand
===Building===
Requirements:
'''
- python version (>=3.0)
Supported Systems:
'''
- Windows 10/11
- GNU/Linux(Tested on Ubuntu 20.04)
Install Cube and Run Cube File
$ git clone https://github.com/EthanMuchnik/Cube-Language-Interpreter.git
$ cd Cube-Language-Interpreter/src
$ python3 CodeRunner.py
Then enter your .cube or .dewy file name when prompted
==Credits==
Ethan Muchnik - Implemented All Interpreter Code and Wrote Original Language Specification
Cynthia Wang - Wrote Original Language Specification
Almutwakel Hassan - Wrote Original Language Specification
Specification was developed in the Esoteric Programming Class in CMU.
Category:2022 Category:Total Category:Implemented Category:Multi-dimensional languages Category:Stack-based
CubeCode

CubeCode is an esoteric programming language created by Kurtis Dinelle and McConnell Wade and is based off of Rubik's cube notation and is very similar to brainfuck. Currently, both a web-based interpreter and a desktop compiler exist, written by the authors of the language.
==Commands==
F- Shifts to next byte
B- Shifts to previous byte
U- Increments current byte
D- Decrements current byte
R- Outputs current byte
L- Gets input into current byte
==Example==
The following outputs "RUBIK'S CUBE":
 uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuurf
 uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuurf
 uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuurf
 uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuurf
 uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuurf
 uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuurf
 uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuurf
 uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuurf
 uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuurf
 uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuurf
 uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuurf
 uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuur
==External resources==
* CubeCode web-based interpreter
* CubeCode compiler written in C
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Cuboid

Cuboid is created by User:Username1234 in Aug, 2022.
== Code Format ==
 +-----+
 / /|
 / / |
 / / |
+-----+ +
| | / 
| | /
| |/
+-----+
You can use |,/,-,+ to create a cuboid like the one on the top.
We define the length of the cube is 5 (the length of the - edges), the width is 3 (the length of the / edges) and the height is 3 (the length of the | edges). So, this cube represents the number 3×3×5=45, which is - in ASCII. So, you should print out -.
A programme contains lots of cuboids and none of them are overlapping. The programme must run left-to-right and up-to-down (for the cuboids).
== Example ==
=== Hello, World! ===
 +--------+
 / /|
 / / |
 / / |
+--------+ +
| | /
| | /
| |/
+--------+
 +-----------------------------------------------------------------------------------------------------+
 / /|
+-----------------------------------------------------------------------------------------------------+ +
| |/
+-----------------------------------------------------------------------------------------------------+
 +---------+ +---------+
 / /| / /|
 / / | / / |
 / / | / / | +-------------------------------------+ +-----------+
 / / + / / + / /| / /|
+---------+ / +---------+ / +-------------------------------------+ | / / |
| | / | | / | | | +-----------+ +
| | / | | / | | + | | /
| |/ | |/ | |/ | |/
+---------+ +---------+ +-------------------------------------+ +-----------+
 +----+
 / /|
 / / | +-----------------------------+ +-------------------------------------+
+----+ | / /| / /|
| | | +-----------------------------+ | +-------------------------------------+ |
| | + | | | | | |
| | / | | + | | +
| |/ | |/ | |/
+----+ +-----------------------------+ +-------------------------------------+
 +-------------------+ +---------+ +-----+ +-----------+
 / /| / /| / /| / /|
 / / | / / | / / | +-----------+ |
 / / + / / | / / | | | |
+-------------------+ / / / + / / | | | +
| | / +---------+ / +-----+ | | |/
| |/ | | / | | + +-----------+
+-------------------+ | | / | | /
 | |/ | | /
 +---------+ | | /
 | |/
 +-----+
== Implementation ==
Interpreter
Category:Languages
Category:Implemented
Category:2022
Category:Total
Category:Unusable for programming
Category:Output only
Category:Two-dimensional languages
Cupid

Cupid is a brainfuck derivative.
There are nine commands which are processed in two-character sequences. The command sequences are formed by using characters '<', '>', and '-'. Only difference, or rather, addition to brainfuck is that in Cupid it's possible to output the current state of the storage tape.
==Commands==
 >> input a byte to current cell
 << output the current cell as character
 -> move memory pointer one right
 <- move memory pointer one left
 >< increase the current cell
 <> decrease the current cell
 -< if the current cell is zero, jump to the corresponding >-, otherwise continue
 >- jump back to the corresponding -<
 -- output the current state of the storage tape
==Interpreter==
 #!/usr/bin/env ruby
 eval 'm=Hash.new(p=0);'+ARGF.read.gsub(
 /[-><][-><]|./,
 '->' => 'p+=1;',
 '<-' => 'p-=1;',
 '><' => 'm[p]+=1;',
 '<>' => 'm[p]-=1;',
 '<<' => 'putc m[p];',
 '>>' => 'm[p]=STDIN.getbyte if !STDIN.eof;',
 '-<' => '(',
 '>-' => ')while((m[p]&=255)!=0);',
 '--' => 'print p,",",m,"\n";')
==External resources==
* , featuring an interpreter
Category:Languages
Category:Cell-based
Category:Brainfuck derivatives
Category:Implemented
Category:Turing complete
CurSorn2

CurSorn2 is an esoteric programming language by User:David.werecat that works bitwise and has random behavior.
== Instructions ==
Instruction	Description
0 	Sets the current bit randomly and adds two bits of random memory
1 	Removes one bit of memory from a random location
Each executed bit is written to the console. At the end of each instruction set, a newline is written to the console. The program terminates when there is no memory left. The "random" nature of the language is undefined and changes over time and as the program executes.
==External resources==
* Visual Basic .NET interpreter and NO sample programs
Category:Joke languages
Category:2011
Category:Unknown computational class
Category:Implemented
Category:Unusable_for_programming
Category:Probabilistic
Category:Languages
Cursor

Cursor is a 2-dimensional esolang created by on Jan 10 2025 7:42 ET where you can control propertys of the cursor. (VERY WIP)
 Component Summarys
Symbol 	Name 	Summary
* 	Start 	Starts the program.
; 	Set Property To	Enters 'Set' Mode.
: 	If Property Is 	Enters 'If' Mode.
/ 	Exit 	Exits the current mode.
@ 	End 	Ends Program.
Example	Example 	Example
Example	Example 	Example
Example	Example 	Example
Example	Example 	Example
*;Cx,3/@
 
 
Output:
hello world
Cut

Cut is a joke language invented by User:A. Writing the shortest number in Cut is an interesting programming puzzle. The Python implementation was created by aryantech123.
==Syntax==
After the program is processed, the accumulator will be outputted. On the 1st instruction, the operations count by 1. On the 2nd instruction, the operations count by 2, and so on...
+: Count up by the current instruction number.
-: Count down by the current instruction number.
==Example programs==
1: +
2: +-+
3: +-+-+
4: ++-+
5: +--++
=== XKCD Random Number ===
 ++-+
=== Quine ===
 0
==C Implementation==
#include <stdio.h>
int main(int argc, char*argv[]) {
	FILE *fp=fopen(argv[1],"r");
	char code[99999];
	char c;
	for(int i=0;(c=fgetc(fp))!=EOF;i++)
		code[i]=c;
	int ac=0,q=1;
	for(int i=0;code[i]!='\0';i++,q++) {
		if(code[i]=='+')
			ac+=q;
		else
			ac-=q;
	}
	printf("%d",ac);
	return 0;
}
==Python implementation==
file = open()
code = file.readLine()
code += '~'
a=0
for i in range(0, len(code)):
 sym = code[i]
 val = i+1
 if(sym == '~'):
 break
 elif(sym == '+'):
 a += val
 elif(sym == '-'):
 a -= val
 else:
 continue
print(a)
== External resources ==
* A140358, a related sequence on OEIS.
Category:2019
Category:Joke languages
Category:Implemented
Category:Total
Category:Unusable for programming
Category:Languages
Cutw

Cutw is an esoteric programming language that is made out of cute characters.
==Commands==
 j - Move pointer right.
 i - Move pointer left.
 w - Puts input at cell at pointer.
 t - Outputs cell at pointer as ASCII.
 u - Branflake's [.
 c - Branflake's ].
 n - Increments cell at pointer.
 m - Decrements cell at pointer.
==Examples==
===Cat===
 wt
===hi===
 nnnnnnnnujnnnnnnnnnnnnnimcjtnt
==JavaScript interpreter==
function cutw(program,input){
 var stack=[];
 var matches={};
 var ip=0;
 var tape=[];
 var p=0;
 var output=;
 for(let i=0;i<1000000;i++){
 tape.push(0);
 }
 for(var i=0;i<program.length;i++){
 if(program[i]=='u'){
 stack.push(i);
 }
 if(program[i]=='c'){
 if(stack.length==0){
 throw new Error('c does not match u');
 }
 var mt=stack.pop();
 matches[mt]=i;
 matches[i]=mt;
 }
 }
 if(stack.length!=0){
 throw new Error('u does not match c');
 }
 while(ip<program.length){
 if(program[ip]=='n'){
 tape[p]=tape[p]+1;
 if(tape[p]==256) tape[p]=0;
 ip=ip+1;
 }
 if(program[ip]=='m'){
 tape[p]=tape[p]-1;
 if(tape[p]==-1) tape[p]=255;
 ip=ip+1;
 }
 if(program[ip]=='j'){
 p=p+1;
 if(p>=1000000){
 throw new Error('Pointer overflow');
 }
 ip=ip+1;
 }
 if(program[ip]=='i'){
 p=p-1;
 if(p<0){
 throw new Error('Pointer underflow');
 }
 ip=ip+1;
 }
 if(program[ip]=='w'){
 if(input==){
 tape[p]=0;
 }else{
 tape[p]=input.charCodeAt(0)%256;
 input=input.slice(1);
 }
 ip=ip+1;
 }
 if(program[ip]=='t'){
 output+=String.fromCharCode(tape[p]);
 ip=ip+1;
 }
 if(program[ip]=='u'){
 if(tape[p]==0){
 ip=matches[ip];
 }else{
 ip=ip+1;
 }
 }
 if(program[ip]=='c'){
 if(tape[p]!=0){
 ip=matches[ip];
 }else{
 ip=ip+1;
 }
 }
 if(!('nmwtucij'.includes(program[ip]))){
 ip=ip+1;
 }
 }
 return output;
}
==See also==
* Alphuck
Category:Brainfuck_equivalentsCategory:2023Category:LanguagesCategory:Turing complete
Category:Implemented
Cvlemar

Cvlemar is an esoteric programming language by User:Zzo38. A program is a map of lines connected to nodes. It does steps by sending each input node to all lines from that node, and sends output to the output nodes. If more than one number sending to a output node, all are added together. The syntax of each line is (in node) (out node) (command) (parameter)
Example:
 a b C 1
 b c M -1
 b d E 2
 c d A 0
 c f L 0
 d e E 1
 e f R 5
* C CONST = Put n to out node if in node is zero, otherwise out zero
* V VAR = n is initial value. Put old value to out node, set new value to in value.
* L LESS n = Output in value if is less than n, otherwise zero
* E EQUAL n = Output in value if is equal to n, otherwise zero
* M MULTIPLY n = Output n times in value
* A ARRAY n = Put value of ARRAY[n OR i] to output (o), then flip bit stored in array.
* R REGISTER n = Set stored value to (i * v + 1) MOD n, then send stored value to output. (No modulus if n=0)
==Examples==
XOR Gate is (takes 2 clock cycles):
 in1 st M 1
 in2 st M 1
 st out E 1
Category:Languages
Category:2005
Cyclic ACIDIC

Cyclic ACIDIC is a language made by User:Iconmaster that is a derivitive of the language ACIDIC. It is exactly the same as ACIDIC exept after each cycle, all the characters' codes in both stacks gets incremented by one, with '~' wrapping to ' '. This is done so that ACIDIC commands are mutable, making the possibility for more complex programs and making it much much harder to program in. Output is also easier, as you can possibly print out more than what are in the stacks in the beginning.
==See also==
* ACIDIC
Category:Languages
Category:Unimplemented
Category:2011
Cyclic Amplification System

Cyclic Amplification System is a language invented by User:A that multiplies an integer and adds the carry back to the number.
== Syntax ==
Cyclic Amplification System takes a number program and rule; they don't have to be in decimal form. They can be in the floating-point form.
In each process, Cyclic Amplification System multiplies the rule and the code, and it does a special mechanism to make the resulting string fit into its original digit. It adds the rightmost digits of the "carry" to rightmost digit to the code string and does carries to the code string, and it adds all of the digits from the leftmost digit to the rightmost digit until there are still numbers in the rule string and the code string has no more digits. The addition continues as the adding is mapped back to the rightmost digit and adding is still done. If the resulting number still cannot be fit into the original program length, the process is done again.
Cyclic Amplification System explicitly halts when the original digits in the program string reaches 0. For example, CAS halts when the original string is 123 and ends when the end string is 1111000 or 000; there are infinitely many possible ending strings that ends in 3 0's. This rule is trivial, as a halting program is trivially (essentially) a no-op program.
== An example ==
Base 10, program 444, rule 34.
=== Steps ===
The result for that computation is 15096. 15 will be added to 096, resulting in 111. It continues, and the process will be skipped.
== Another example for a computation that does many executions finitely ==
Base 10, program 99, rule 111
The result is 10989. 109 will be added to 89, resulting in 801. The 1 will be added to 801, resulting in 802. It still does not fit into the 2-digit boundary, so it becomes 10. Then, the rule applies again, and 10 becomes 1110. Then, the string becomes 21, and so on.
== Computational class ==
It is unclear what computational class it is. It is definitely at least a finite-state automata.
Category:Languages
Category:2019
Category:Unimplemented