nyuuzyou/wikis huggingface dataset:
Correct Syntax Error

A language that has a well-defined syntax, but the semantics are that any program that has correct syntax will result in a Correct Syntax Error. 
However, a program that has only invalid syntax will do something. This something should not be well-defined, and undocumented. 
Its up to the implementation of the interpreter or compiler to determine what to do with incorrect syntax. The more
incorrect syntax, the more your program will do. It probably won't do what you want it to do, but programming in any language
is like that in my experience. 
==Example==
The syntax of the language could be the same as C. But any valid C is rejected by the compiler.
So this code:
 #include <stdio.h>
 void main () {
 printf("Hello Word.\n");
 }
will result in a Correct Syntax Error (from line 1 through line 4).
But illegal C, for example:
 #stdio.h
 =voidmain))
 99print('Hello World[--
 '
 23
might print Hello World, or do something else entirely. But it won't throw any correct syntax errors. 
== Implementation ==
The reference implementation of the interpreter/compiler is full of syntax errors.
== Another idea ==
The actual code that's executed depends on the error message -- maybe something like brainfuck, but with an opcode per ascii character, and it's run from the error output of the compiler. Maybe it *is* brainfuck, and each character spat out by the compiler is mod 8. Can use #ifdef to check which compiler is being run and generate error message accordingly.
== Related ==
The Ↄ language
Category:Ideas
Cortex language 3

Cortex language 3 is a general term for an esolang, named after and defined by Cortex operationally defined as "any languge where ;' creates a truth machine, and all popular problems with a dedicated Esolang article (non-quine-related) can be implemented in three or fewer characters, all of which only using thirteen or fewer distinct characters."
==Languages following these specifications==
* Cortex language 3A, a Turing-complete Cortex language 3 which uses only 9 distinct characters
Category:2020
Category:Usability unknown
Category:Unknown computational class
Category:Unimplemented
Category:Low-level
Cortex language 3A

Cortex language 3A is an esolang by User:PythonshellDebugwindow that follows the specifications of a Cortex language 3.
==Memory model==
Cortex language 3A uses a tape of 16 arbitrary-size unsigned integers. The current cell is the cell pointed to by the cell pointer. The cell pointer wraps around the tape.
==Syntax==
Same as brainfuck, e.g. each character is its own command that takes no arguments and returns no value. The one exception to this rule is the ; command, whose result depends on the following character(s).
==Commands==
Command	Effect 	
& 	Increment the current cell 	
' 	If the current cell is zero, jump to the matching : 	
* 	Square the current cell 	
~ 	Increment the cell pointer 	
$ 	Decrement the current cell (raises an error if cell == 0) 	
: 	If the current cell is nonzero, jump back to the matching ' 	
[ 	Output the Unicode character of the current cell 	
] 	Input an unsigned base-3 integer to the current cell 	
; 	Command After 	Popular problem to run
& 	Print "Hello, World!" exactly like that 	
' 	Truth-machine 	
* 	ROT13 encode/decode user input 	
~ 	Nth number in the Fibonacci sequence where N = base 10 user input	
$ 	Interpret brainfuck where the program is inputted by the user 	
: 	Interpret Deadfish where the program is inputted by the user 	
[ 	Bootstrap for program = user input 	
] 	FizzBuzz until 100 	
; 	Command After 	Popular problem to run
& 	Cat program 	
' 	99 bottles of beer 	
* 	Factorial of base 10 input number 	
~ 	Digital root of base 10 input number 	
$ 	Infinite loop 	
: 	Run a looping counter from 0 to infinity 	
[ 	Mandelbrot set 	
] 	Disan Count for base 10 input number 	
; 	Fibonacci sequence 	
All others are ignored. Sequences like ;X and ;;X are also ignored.
==Examples==
Hello, World!:
 ;&
Truth-machine:
 ;'
Cat:
 ;;&
ROT13 encoder/decoder for user input:
 ;*
And so on.
==Turing-completeness==
Through prime factorization of the tape, as well as unbounded looping using ' and :, Cortex language 3A is Turing-complete.
Category:Languages Category:Turing complete Category:2020 Category:Cell-based Category:Unimplemented
Count counters

Count counters is a programming language that uses counters that count after a certain number of firings to do stuff
= Things you want to know =
== Instructions ==
"*" always counts
 * >returns 1,1,1,1,1,1,1,1...
"(n)" counts every n times
 (2) >returns 0,2,0,2,0,2...
"[n)" uses the counter on the [ side to count every times it does that n
 (2)[4) >returns 0,2,0,2,0,2,0,6,0,2,0,2,0,2,0,6...
"(n]" does the same thing but on the ] side
 (2](2) >returns 0,2,0,4,0,2,0,4...
"@" adds 1 at the start
 @ >returns 1,0,0,0,0,0,0,0...
"?n>" acts like [ but it activates if the count is the number
 (2)[3)?5>1) 0,2,3,2,0,6,0,2,3...
"<n?" acts like ?n> but like ]
 (1<5?(3](2) 0,2,3,2,0,6,0,2,3...
"<n>" count up by n
 <2> 0,2,4,6,8,10,12...
">:n:" repeat this in a single count n times
 *>:4: 4,4,4,4,4,4,4,4...
":n:<" same thing but other way
 :4:<* 4,4,4,4,4,4,4,4...
Category:Languages Category:2024 Category:Unknown computational class Category:Unimplemented
Countdown

Countdown is a Esoteric programming language.
Countdown was made to Mix rhymes, random numbers and abbreviations into commands.
Made in 15 minutes, the OCT is the REAL countdown. 
The code is here:
 global stack
 stack = [0 , 0, 0]
 print("Hello! This is the countdown translator!!")
 print("countdown is easy to learn: it has 6 functions. It is unknown programming language.")
 print("This countdown is reacheable through python shell")
 def LTTS(di):
 global stack
 stack = di
 def pop():
 print(stack)
 def h():
 print("Hello World!")
 def P21_23(args):
 print(args)
 def MullBull(first, second):
 print(first * second)
 def TPT():
 print(2+2)
EXAMPLES
 MullBull(2,2)
100
 LTTS(100)
 pop()
Category:Languages
Category:Implemented
Category:Output only
Category:Finite state automata
Category:Unusable for programming
Counter minus

Counter minus is language by User:ChuckEsoteric08 inspired by The Waterfall Model.
==Semantics==
Counter minus has:
*Fixed number of registers
*A trigger
Counters incrementing until at least one of them reaches number that is chosen by user. After that, trigger is runned that decrements other counter also chosen by user.
==Syntax==
Programs written like that
 1, 2, 3, 4...;255;12;2
1, 2, 3, 4... are registers that incremented. 255 are number that will cause trigger to run, 12 are how many times register will be decremented, and 2 register which will be decrmemented. After trigger is runned, do next line. Program is stuck in an infinite loop
Category:Languages Category:Unknown computational class Category:Unimplemented
Countercall

Countercall is an esoteric programming language created by :User:ais523 in 2017. The only data storage is formed of one (global) counter, and the procedure call stack.
== Syntax ==
A Countercall program consists of a sequence of procedure definitions. Each is on its own line, and consists of an identifier (the procedure's name), a colon, and a sequence of commands (each of which is a procedure name, or + or -). Commands are separated by whitespace. Run length encoding is permitted on + and - by appending a decimal number to them, e.g. +12 is equivalent to + + + + + + + + + + + +.
Any line of the source code that contains no colons is treated as a comment, and ignored.
== Semantics ==
The program starts by running the procedure named main, and with the counter set to 0. The + and - commands change the value of the counter (it stores integers of unbounded size and can be negative in addition to positive or zero, e.g. running -4 with the counter at 1 will set it to -3). Running an identifier will call the procedure with that name in a loop, a number of times equal to the value of the counter at the moment the loop started. (That is, changing the value of the counter after the loop starts running will not change the number of remaining iterations of the loop). Attempting to run a procedure a zero or negative number of times does nothing.
Procedures follow normal rules for returning and recursion, i.e. a procedure returns after the last command in it completes, and after a procedure returns the program will continue with the next iteration of its loop, or with the next command if the loop has finished. When the original call to main returns, the program exits.
== Computational class ==
Countercall has enough data storage to make it possible that it's Turing complete, although it (intentionally) doesn't follow any of the standard patterns. (For example, it might be possible to use the height of the call stack as one counter, and the counter itself as a second, in order to make a Minsky machine.) However, it seems potentially hard to keep control of the program when the counter gets large (as it necessarily must – the language is just a push down automaton if the counter is kept bounded), due to any attempt to call a procedure necessarily running it a large number of times. As such, the computational class is currently unknown; the author suspects it is Turing complete, but that this may be hard to prove.
== See also ==
* Vein
Category:Languages
Category:Stack-based
Category:Usability unknown
Category:Unknown computational class
Category:No IO
Category:Unimplemented
Category:Low-level
Category:2017
Counterlang

Counterlang uses counters to do stuff
= The stuff =
== Counter ==
 count a #make a a counter initialized as 0
 a1 #add 1 to counter of a
 a-2 #add -2 to counter of a
 a2 #add 2 to counter of a
 aa #add a to counter of a (double)
 aa #double
 aa #double a is 16 now
 a- #reset a to 0
== Print ==
 .1 #prints 1
 ,65 #prints A
== Goto ==
 !2 #loop
 !1 #loop
== End ==
 : #end
 count thisisnotexecuted
 thisisnotexecuted100
 .thisisnotexecuted
==Syntax==
An Extended Backus-Naur Form (EBNF) description shall be adduced for the language:
 program := { innerLine } , [ lastLine ] ;
 innerLine := lineContent , newlines ;
 lastLine := lineContent ;
 lineContent := padding , [ command ] , [ comment ] ;
 comment := "#" , { character - newline } ;
 command := initCommand
 | addCommand
 | subtractCommand
 | resetCommand
 | printCharCommand
 | printNumCommand
 | jumpCommand
 | haltCommand
 ;
 initCommand := "count" , spacing , counterName ;
 addCommand := counterName , operand ;
 subtractCommand := counterName , "-" , operand ;
 resetCommand := counterName , "-" ;
 printCharCommand := "," , operand ;
 printNumCommand := "." , operand ;
 jumpCommand := "!" , operand ;
 haltCommand := ":" ;
 
 operand := unsignedInteger | counterName ;
 unsignedInteger := digit , { digit } ;
 counterName := letter , { letter } ;
 
 padding := { space } ;
 spacing := space , { space } ;
 newlines := newline , { newline } ;
 newline := "\n" ;
 space := " " ;
==Examples==
===Counting Up===
The following program perpetually counts up from inclusive zero (0):
 count upCounter
 .upCounter
 upCounter1
 !2
==Interpreter==
* Common Lisp implementation of the Counterlang programming language.
Category:Languages
Category:Output only
Category:2024
Category:Implemented
Counting Calculus

= Counting Calculus =
==== Note: this is not finished yet! ====
A programming language of which the primary way of doing mathematical calculation is by counting the amount of α-conversions done in a lambda-calculus expression.
An example of such an expression:
 (λy.λx.yx)(λx.x)
Counting Calculus works with expressions that were fully β-reduced. The example above would become:
 λx.(λx.x)x
Now the language α-converts the expression into this:
 λx0.(λx1.x1)x0
Next, the language counts all of the variables with the same base (e.g. x). The only variable in the example above is x, and there are exactly 4 of xs.
After the replacement is completed, the compiler/interpreter change all of the xs to 4s:
 λ40.(λ41.41)40
Finally, the language removes all of the λ symbols and replaces the dots with +s:
 40 + (41 + 41)40
Now we have a mathematical expression, the result of which is 9 (1 + [4 + 4] * 1 = 9)
Category:Works-in-Progress Category:Languages
Countup

Countup
Countup is a version of Countdown with some major differences.
Example:
 STVS("Abcdef")
 Out(11+23434435)
 Out("")
The Sturing_Machine-2017 is a easy version of a programming language implementable in Countup, or Countdown, if you please.
 RAMP()
 PRINPUT()
 INPUTEQ("INT")
 INPBIN()
 TAPE(INT)
 LAPE()
 TAPEEQ(101011)
 PRINTLN("TurinGo!")
 I implemented it but I need YOU to make a
 implementation which supports these 2 examples,
 or make a example yourself!
Category:Languages
Category:Unimplemented
Category:2017
Cpy

cpy (from memcpy) is a Turing tarpit designed by User:ZippyMagician.
==About==
cpy is composed of instructions, separated by lines. These instructions come in the form 
 X <op> Y
, where X and Y are numbers and op is one of the following:
Op 	Description
-> 	Move [X] into [Y] and decrement if X > Y, else increment
<->	Copy [X] into [Y]
<- 	Jump to line X if [Y] > 0
Memory cells 0 and 1 are reserved. Writing a value to 0 will output the value and then clear that address, and moving from one will give a byte of STDIN (whether this is the ASCII code or a number is implementation defined). If this cell is cleared via a mov operation, it will be replaced with the next byte or a 0-byte if there is no more input. Memory is in the form of unsigned 8-bit numbers, initialized to 0. The maximum size of memory is undefined, but recommend to be at least 216 cells. All characters besides numbers and operators are ignored
==Programs==
===Cat program===
 1->3
 3->2
 2<->0
 0<-2
==Computational Class==
cpy can be proven Turing complete by translation of Szewczyk notation for Minsky machine, which is a proposed notation for a minimalistic Minsky Machine syntax, such as the following program
 1 -1
 1 1
 1 1
Translation can be accomplished as follows:
 3 <- 3
for each X -1
 X+4 -> X+4
for each X Y (# = line# 0-indexed)
 #+2 <- X+4
 Y+offset+1 <- 3
 X+4->2
 2<->X+4
where offset must be calculated at translation time, such that it jumps to the start of the Yth command (which may or may not be the Yth line + 1, depending on whether the X Y command was used or not). Once finished, a transpiler written in Rust can be found Here.
==Interpreter==
* Common Lisp implementation of the cpy programming language.
Category:Languages
Category:Turing complete
Category:Turing tarpits
Category:Cell-based
Category:Implemented
Category:2021
Crabrave

CrabRave is a brainfuck-inspired esolang that uses emojis instead of more standard characters. It was created by the Crablang project, a community-run fork of Rust. The name is presumably inspired by the EDM song Crab Rave by Noisestorm.
=== Source Code ===
The interpreter project can be found here.
Category:Languages Category:Implemented Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Cell-based Category:Low-level Category:Turing complete Category:Turing tarpits Category:Thematic
CrashFunge

CrashFunge is an esoteric programming language of the fungeoid paradigm which is, in fact, esoteric for a fungeoid. It is based on the principal of having no operators, but instead having all instructions be of two types:
# Direction changes (constant, variable, or augmented)
# Mode switches
Operations are performed by modifying the modes of instruction pointers and, as the case may be, crashing them together.
Category:Languages Category:Multi-dimensional languages Category:Unknown computational class
Crazy

Crazy is an esolang created by User:Vulture001. The language is based off of Python, and it uses reverse alphabet strings to print characters.
==Code examples==
===Hello, World program===
 kirmg(s + v + o + o + l + xln + yoz + d + l + i + o + w + vcx)
Output:
 hello, world.
===Name program=== 
 name = qmkfg(m + z + n + v + xlo + yoz)
 kirmg(name)
Output: 
 name: john
 john
===99 bottles of beer program===
 for beer in range(99, 0, -1):
 if beer > 1:
 kirmg (beer, y + l + g + g + o + v + h + yoz + l + u + yoz + y + v + v + i + yoz + l + m + yoz + g + s + v + yoz + d + z + o + o, beer, y + l + g + g + o + v + h + yoz + l + u + yoz + y + v + v + i)
 if beer > 2:
 suffix = str(beer - 1) + yoz + y + l + g + g + o + v + h + yoz + l + u + yoz + y + v + v + i + yoz + l + m + yoz + g + s + v + yoz + d + z + o + o + kvi
 else:
 suffix = "1" + yoz + y + l + g + g + o + v + yoz + l + u + yoz + y + v + v + i + yoz + l + m + yoz + g + s + v + yoz + d + z + o + o
 elif beer == 1:
 kirmg ("1" + yoz + y + l + g + g + o + v + yoz + l + u + yoz + y + v + v + i + yoz + l + m + yoz + g + s + v + yoz + d + z + o + o + yoz + "1" + yoz + y + l + g + g + o + v + yoz + l + u + yoz + y + v + v + i)
 suffix = m + l + yoz + n + l + i + v + yoz + y + v + v + i + yoz + l + m + yoz + g + s + v + yoz + d + z + o + o + vcx
 kirmg (g + z + p + v + yoz + l + m + v + yoz + w + l + d + m + xln + yoz + k + z + h + h + yoz + r + g + yoz + z + i + l + f + m + w + xln, suffix)
 kirmg ("--")
Output: 
 99 bottles of beer on the wall 99 bottles of beer
 take one down, pass it around, 98 bottles of beer on the wall
==Dictionary==
Letter 	Crazy letter
a 	z
b 	y
c 	x
d 	w
e 	v
f 	u
g 	t
h 	s
i 	r
j 	q
k 	p
l 	o
m 	n
n 	m
o 	l
p 	k
q 	j
r 	i
s 	h
t 	g
u 	f
v 	e
w 	d
x 	c
y 	b
z 	a
print 	kirmg
input 	qmkfg
(blank character/space)	yoz
, 	xln
. 	kvi
! 	vcx
: 	xlo
Category:Languages
Category:Unimplemented
Category:Turing complete
Category:High-level
Crazy Layered Memory

Crazy Layered Memory (a.k.a. clm) is a data structure that uses layers and cells to store data.
==Layers==
Each layer contains any number of layers and cells, as well as one index-cell and a active-cell.
The index-cell is stored at index -1 of its layer and contains the index that is currently accessed at this layer.
The active-cell is stored at index -2 of its layer and stores, whether this layer is the active layer (if not, functions affect the layer below this one)
==Cells==
are located inside of layers and contain the actual data
==Functions==
Function 	Description
insertLayer	inserts a new layer after the current element
insertCell 	inserts a new cell after the current element
delete 	deletes the element referenced by the index-cell
next 	changes the index-cell by 1 (if index is greater than or equal to the length of the layer it loops around to -1)
previous 	changes the index-cell by -1 (if index is less than -1 it loops around to the last elemnt of the layer)
down 	if the current element is a layer, enter that layer
up 	exits current layer if possible
length 	returns the length of the current layer (excluding index- and marker-cell)
==Usage in esolangs==
Currently, clm is only used by one esolang, clml, it is previously categorized in Category:Clm-based, but that category was deleted because it only contains one esolang.
Category:Data Types and Structures
CreativeScript

CreativeScript is a esolang made by Mihai Popa. It's the "succesor" of mLang. While mLang reads 1 line only from arguments, CreativeScript reads the full program from a file!
== Macro List ==
There are only 4 macros. This is the list:
 Macro list
Macro	What it does
say! 	Prints a line of text
set! 	Sets a variable to a value
add! 	Adds two numbers
out! 	Prints a variable
== Note ==
The file extension for CreativeScript (*.cs) should not be confused with C# files. They are not the same.
== Examples ==
=== Hello, world! ===
say! Hello, world!
=== Number 5 ===
set! hello 5
say! The number is:
out! hello
=== XKCD Random Number ===
set! xkcd 4
say! The number is:
out! xkcd
=== A+B Problem ===
add! 5 10 z
out! z
Replace 5 and 10 by the numbers you want to add.
== Interpreter ==
Is in Batch!
Run it as follows:
CreativeScript.bat hello.cs
Replace "hello.cs" with the name of the program you want to run. 
@echo off
for /F "tokens=1,2,3,4* delims= " %%a in (%1.cs) do (
 if %%a EQU say! (
 echo %%b %%c %%d
 )
 if %%a EQU set! (
 set %%b=%%c
 )
 if %%a EQU add! (
 set /a %%d=%%b+%%c
 )
 if %%a EQU out! (
 echo echo %%%%b%%% >> tmp.bat & tmp.bat & del tmp.bat
 )
 if %%a NEQ say! if %%a NEQ set! if %%a NEQ out! if %%a NEQ add! (
 echo E01: Macro not valid.
	echo Backend expection: %%a
	echo ^^
	echo ^| [HERE]
 )
)
==See also==
* CreativeScript v2
Category:Languages
Category:High-level
Category:2024
Category:Implemented
Category:Total
Category:Unusable for programming
Category:Output only
CreativeScript v2

An update to CreativeScript by Unname4798.
== Commands ==
 say! a print string a
 set! a b set variable a to b
 add! a b c add a and b
 sub! a b c subtract a and b
 mul! a b c multiply a and b
 div! a b c divide a and b
 mod! a b c modulo a and b
 out! a print variable a
 in! a set variable a to user input
== Examples ==
=== Hello world ===
 say! Hello world!
=== XKCD Random Number ===
 say! 4
=== A+B Problem ===
 in! a
 in! b
 add! a b c
 out! c
Category:Languages Category:Unusable for programming Category:Total Category:Unimplemented
Cree

Cree# is a C#-like imperative language by Jon Corbett, which allows programming in Cree keywords using Cree concepts and metaphors. In addition to this language, Corbett's PhD research has led to his Indigenous Coding Framework, a work-in-progress that will help other Indigenous communities bring to computation not only their languages but their cultural logic and values. 
==Language Features==
===Keywords===
 miyâhkasike, tisamân, smudge – the smudge command
 âcimowin, âtayôhkan – indicators for identifying/protecting story elements
 mînisiwat, maskihkîwiwat – variable declarations
 pipon, pipona, pipohki, awasipipon, mêsakwanipipon – winter(s) (loops)
 tahtwâw – each time
 awa, ôma – this and that
 sîpiy – river (if)
 kikway – what (if)
 kîsipayiw – end/terminate
 pîkiskwêw – say/talk (print/output text)
===Operators (verbs)===
 asiwahew – populate [as in a variable]
 pîhciyihk – inside/contents
 akihtam – count something
 takwastâw – add
 mistahi- (as a prefix morpheme) – makes something bigger, increase by 1
 kâwôtinikêwin – subtract
 –osis or –si (as suffix) – makes something smaller reduces something by 1
 tâpiskôc – make something equal or same as something
 -wa and -wak – suffixes that pluralize a noun (making it an array)
 x – ends a statement (this is not a lowercase x it is a syllabic that looks like a lowercase x and is used as a full stop)
===Actors===
Common entities that are in stories and cannot be used as generic “noun” variable assignments
 wîsahkecâhk – (Raven, trickster, a legendary spirit)
 maskwa – bear
 cihcipistikwân– a legendary spirit
 cahkâpes – a legendary spirit
 wîhtikôw – windigo
 môswa – moose
 mahihkan – wolf
 amisk – beaver
===Numbers===
The actual words for each number are reserved (there are 104)
 makikway – null/zero, literally “not something”
 mihcecis; mihcet; mihcetinwa – fairly many; many; numerous
 misi- - a prefix for describing a massive amount of something
 akihtâson – literally means “a number”; used in conjunction with syllabic numerals to separate text syllabics from numbers such as:
 newinwa napewak ([there are] four men)
 ᐊᑭᐦᑖᓱᐣ lᐅ ᓇᐯᐘᐠ ([they] number 4 men)
==More Info==
* Interview with Jon Corbett about the project
==See Also==
* Wenyan
* قلب
Category:Languages 
Category:Turing complete
Category:Pseudonatural
Category:Thematic
Crop

:
Crop is a 2D esolang invented by User:None1.
==Syntax==
=: Starting point, the farmer starts moving here.
<>v^: Barrier, if the farmer attempts to go onto a barrier, it moves back and set the direction as the direction of the barrier.
.: NOP
+: Read a character from standard input, and output the same.
Other: Just print.
The farmer's initial direction is right.
==Example Programs==
Cat Program: 
 >=+<
Endless loop:
 >=<
Print A infinitely:
 >=A<
2D version:
 >=Av
 A..v
 >.A<
 <<<<
Crash horribly:
 =.
Note that a Crop program never terminates, so it cannot print Hello World.
Category:Languages
Category:Unusable for programming
Category:Thematic