nyuuzyou/wikis huggingface dataset:
Comun

Comun is a stack-based imperative toy language created by drummyfish. The author was inspired by Forth and describes the language as "something in between Brainfuck and C" that will hopefully be actually usable. The language became self-hosted in March 2024.
Comun works on compile-time allocated arrays made integers of various sizes, as well as compile-time allocated single pointers into these arrays. The pointers are mutable, but you can't have arrays of them, so if you want an array of pointers you have to use indexes and pointer arithmetic instead.
Four types of integers are supported: native (the unsigned int C type of the host), 8-bit, 16-bit, and 32-bit. These types don't mix, each array has a definite type and you aren't allowed to access it using any other types. With the exception of a type conversion operator, every built-in works on just one type that all its arguments and results share. 
The built-in operations are stack-based, popping arguments and pushing results onto a stack; however, the stack is just a normal array like any other, you can make the stack pointer point into any array or access the stack with pointers like you can access any array. There are shortcuts to read or write the top ten elements of the stack.
Control constructs are similar to traditional C: named functions, if conditionals, if/else conditionals, while loops, all of these with any length of code in their body, as well as a command to break out of the innermost loop, and one to return out of the innermost function.
==Examples==
===Hello, World!===
This example pushes values 0 (string terminator), 10 (newline) and an ASCII string and subsequently uses the built-in string-printing function.
0 10 "Hello, World!" -->
===Factorial===
The following example prints the factorial (computed recursively) of numbers from 1 to 10. The most complex part is actually the number printing function which does not exist in the language itself.
factorial:
 ?'
 $0 -- factorial *
 ;
 ^ 1
 .
.
printNum:
 0 ><
 @'
 $0 10 % "0" + ><
 10 /
 .
 ^
 -->
.
10 @'
 11 $1 - factorial printNum # C equivalent: printNum(factorial(11 - i))
 10 -> # newline 
 --
.
==External links==
* Documentation and source code of a self-hosted interpreter and an interpreter written in C
Category:2022 Category:Languages Category:Implemented Category:Stack-based
Condit

Condit is an esoteric programming language by Paul E Collins from 2001. All statements of Condit are conditional, taking the form:
 when condition then actions
When a program is run, all statements are checked in order, and those with true conditions are run. Then execution starts from the top of the program again, unless no conditions are true, in which case the program halts.
See Talk:Condit to go in-depth on how Condit works
==Examples==
The linefeed at the end of the examples are MANDATORY
===Truth-machine===
 when a=0 then set i=1 set a=1
 when i then put i
 when i=0 then put i set i=2
 
===Hello, world!===
 when a=0 then set a=1 put "Hello, world!"
==External resources==
*An interpreter on tio.run
*An interpreter in Python
Category:Languages
Category:Turing complete
Category:Implemented
Category:2001
Conditional Bee

Conditional Bee(CBee) is a minimalization on Conditional brainfuck by User:ChuckEsoteric08
==Commands==
 )
increment cell and move pointer to the right
 -
decrement cell
 (
move pointer to the left and goto matching } if zero
 }
NOP, but needed to be associated with (
==Translation to and from CBF==
From CBee to CBF
CBee	CBF
) 	+>
- 	-
( 	<{
} 	}
Translation from CBF to CBee
CBF	CBee
+ 	)(}
> 	-)
< 	(}
{ 	-)(
} 	}
- 	-
==1-bit version==
It deletes - and ) is flip bit instead of incrementing
Category:Languages Category:Turing complete Category: Turing tarpits Category:2022 Category:Cell-based Category:Unimplemented Category:Low-level Category:Brainfuck derivatives Category:Reversible computing
Conditional brainfuck

Conditional brainfuck (CBF) is a brainfuck variant discovered by User:Orby in May of 2020.
==Model==
CBF uses a tape of n-bit wrapping cells which is unbounded on the right. There is a tape head which points at one cell at a time. CBF programs run in an implicit loop.
==Commands==
CBF uses five commands. The conditional structure {} replaces the looping structure [] found in brainfuck. Input and output are optional and not specified as part of the language standard.
Command	Description
+ 	Increment the current cell
- 	Decrement the current cell
> 	Shift the tape head right
< 	Shift the tape head left
{ 	If the current cell is zero, jump to the first instruction after the matching }
} 	NOP, but must be associated with a matching {
==Implicit loop==
There are several flavors of CBF which depend on how the implicit loop is defined. The following table outlines the entry and exit conditions of the current cell for the implicit loop according to the flavor. If the entry condition is not met on the current cell, then the program never executes. If the exit condition is not met on the current cell, then the program loops.
Flavor 	Entry 	Exit
Regular CBF 	Non-zero	Zero
Reversible CBF 	Non-zero	Non-zero
Inverted Reversible CBF	Zero 	Zero
Inverted Regular CBF 	Zero 	Non-zero
=See also=
*Brainfuck
*Reversible Brainfuck
*Conditional Bee
Category:Languages
Category:Reversible computing
Category:2020
Category:Low-level
Category:Brainfuck derivatives
Category:Turing complete
Category:Cell-based
Category:Turing tarpits
Category:Unimplemented
Confusia

Confusia is the most complex esolang I can come up with.
==Start program==
To start the program, you have to type 2763 a random amount of times in a row, and copy and paste is not allowed. If you get it wrong, the random amount changes and the file is cleared.
==Keys==
Keys are random numbers from 1 to 100. Every command has a key randomly generated from a seed the command number and the time added together, which is then modded to fit in 100. If you get the key wrong, the file is replaced with a PNG image of Glamrock Freddy from Security Breach with a blue pixel in the corner.
==Cheating the key==
If you put ê instead of 3 in the 7th 2763, every key will be 5.
==Print==
Print prints a BF file that prints a Deadfish x file that prints what you put in it.
Category:Languages Category:Output only
Confusing

This is a very confusing programming language. The commands don't do what you think they do.
 
Instruction	What it ACTUALLY does (not what you think it does)
12'34 	The number literals do NOT make sense. 0 actually means 9, 1 means 8, and so on. And the decimal point isn't even a decimal point. So the above example pushes 87.65.
"..." 	Pushes the ascii codes of everything inside, WITH BITWISE NOT APPLIED. So "a" actually pushes "\x9E".
- 	Add top two elements.
+ 	Subtract.
/ 	Multiply.
* 	Divide.
^ 	Modulo.
% 	Power.
) 	Start codeblock.
( 	End codeblock.
W 	If top of stack is zero, then [next codeblock].
I 	While top of stack is zero, do [next codeblock].
n 	Input character into stack.
C 	Output top of stack as number.
c 	Input number into stack.
N 	Output top of stack as character. (MODULO 255 FIRST!)
$ 	Duplicate top of stack.
; 	Pop top of stack.
\ 	Dup the second stack item (over).
 	Swap top two stack items.
X, Y 	Pop from main stack and push to the corresponding storage stack. (Finally something that makes sense.)
x, y 	Pop from storage stack and push to main stack (WARNING: x actually pops from Y and vice versa)
! 	Negate top stack item.
_ 	Logical not stop stack item.
< 	Pop a and b, push 1 if a>b, and 0 otherwise.
> 	<, but with less than.
. 	Pushes ascii code of the next character (remember the decimal point?)
P 	Get. Pop x, pushes ascii code of command x. Empty cells are equal to -1, not 0, so be VERY careful.
G 	Put. Pop x and y, replace xth command with y.
E 	If followed by a codeblock, defines a function for the next character. Else, calls that function.
F 	End the program.
L 	Clear the stack.
X 	Push stack length.
U 	Move bottom stack value up.
D 	Move top stack value down.
Category:Languages
Category:Joke languages
Category:Stack-based
Connery

Connery is an esoteric programming language created by Will Cipriano in 2020. It is a experimental lisp-like interpreted programming language that has error messages themed after Sean Connery.
==Computational model==
Connery is a AST walker that is composed of S-Expressions and Q-Expressions. S-Expressions or symbolic expressions are evaluated as soon as they are encountered, while Q-expressions are evaluated whenever they are called. It contains a number of simple builtins as well as a standard library containing several general purpose functions. It supports Integers, Floats, Strings, and Lists.
==Sample programs==
Here's the traditional "Hello World!" in Connery:
 (print "Hello World!")
The following program returns what highlander should be chosen by Juan Sánchez-Villalobos Ramírez to be mentored:
 (def {highlanders} (list "Connor MacLeod" "General Katana" "Rachel Ellenstein" "Methos"))
 (fun {there_can_only_be_one highlander} {!= -1 (caseless_find highlander "MACLEOD")})
 (eval (filter there_can_only_be_one highlanders))
This program toggles the caterpillar drive in the Red October:
 (fun {toggle_caterpillar_drive caterpillar_drive_status} {
 if (caterpillar_drive_status)
 {False}
 {True}
 })
== Error Messages ==
Errors in Connery are pronounced with a Scottish lisp, often making them difficult to understand.
Here's what happens when you pass a String into is_leap_year:
 is_leap_year requiresh a number ash input!
Or when you try to divide by zero:
 Divishion by zero
==External resources==
* Connery Docs and Language Reference
* Connery on GitHub
Category:Languages
Category:Turing complete
Category:Functional paradigm
Category:Implemented
Category:High-level
Category:Self-modifying
Category:Thematic
Consequential

Consequential is a language created by User:Xanman12321 which is a variant of Brainfuck, however each command does something unwanted.
= Instructions =
Command	Description
> 	Decrement the previous cell and move the pointer right.
< 	Set the current cell to zero and move the pointer left.
+ 	Increment the current cell and move the pointer left twice.
- 	Decrement the current cell and increment the previous and next cell.
. 	Output an ASCII character signified by the current cell's value modded with 96 plus 32 and move the pointer right until the current cell is zero.
, 	Stores the standard input in the cells in front of and behind the current cell
[ 	Changes the previous cell to four and jumps to the matching ] if the current cell is zero.
] 	Changes the cell four ahead to the current cell value floor divided by two and jumps to the matching [ if the current cell is not zero.
==Examples==
===Print letter “A”===
This program utilizes the output character code translation formula in order to print the character “A” by setting the current cell value to 32, which is converted to the number 65 during the output operation, thus yielding the desired ASCII letter:
 +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>>
 +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> +>> .
===Cat program===
The following source code implements an infinitely repeating cat program that, however, outputs the translated characters without correction — input and output will perforce vary:
 <,>.<[<,>.<]
==Interpreter==
* Common Lisp implementation of the Consequential programming language.
Category:Languages
Category:Brainfuck derivatives
Category:Unknown computational class
Category:Usability unknown
Category:2018
Category:Implemented
Constant

In some esolangs like brainfuck and Deadfish, there are no literals, so you have to generate values yourself. Programs that do this are sometimes known as constants. Some esolangs have their constants listed in a page or a section, so that they (the constants) can be used easily.
==See also==
* Brainfuck constants
* Deadfish/Constants
* BracketOnly#Constants
* 1/Constants
* Befunge/Constants
* Python is Magic/Constants
Category:Concepts
Category:Program forms
Constantinople

Constantinople is a language created by Nathan van Doorn. It is named as such because he had Istanbul, not Constantinople stuck in his head.
In Constantinople, memory is stored in a list, the first element of which is another list, filled with 0s. The rest of the list is filled with 0s.
There are two datatypes, the list, and the bit, which can either be 0 or 1. Lists are infinite and lazily evaluated.
==Syntax==
 replace m with n replaces whatever's at m with n
 repeat n starts a repeat block, which repeats the commands to the corresponding end command while n evaluates to 0
 end ends a repeat block
 in n replaces n with a bit from input
 out n outputs the bit n.
 head n returns the first element of n
 tail n returns everything but the first element of n
 nand m with n returns m NAND n. m and n
Brackets (i.e. "(" and ")") are used to change evaluation order, and clarify what's an input to what.
The head and tail of a bit are the value of the bit. When a list is used in nand, repeat, or out, the first element of the list is used instead.
head, tail, and nand may only be used in an argument context. replace, repeat, in and out must not. (The ... in repeat is not an argument context.)
If an argument is missing, it is assumed to be the main list.
==Examples==
===CAT===
 repeat tail
 in head
 out
 end
==External resources==
* Constantinople compiler in Haskell
Category:LanguagesCategory:2011Category:ImplementedCategory:High-level
Constructible

Constructible is an esolang invented by User:Hakerh400 in 2025.
== Overview ==
Constructible is the same as Imprecision, with the additional square root operation. Square root of a negative number is undefined behavior. Square root is represented as the prefix unary operator √ whose priority is higher than multiplication.
The name "Constructible" comes from the fact that rational numbers are not enough for implementing this language. Instead, we need constructible real numbers (the smallest field extension of the rationals that includes the square roots of all of its positive numbers).
== Example ==
 halt = 2 - input
 input = √input
 output = output + 1
== Computational class ==
If Imprecision is Turing complete, then Constructible is Turing complete as well. However, it is hard to say whether adding square root the the list of available operations improves the chances of being Turing complete.
== Implementation ==
* Implementation in Haskell (depends on constructible-0.1.2)
Category:Languages
Category:2025
Category:Unknown_computational_class
Category:Implemented
Container

Container is an esoteric programming language created by User:Por gammer. The language models a finite set of nonnegative integers (denominated "containers") that evolve and effect each other through rules determined by the source code of a Container program.
==Syntax==
Valid Container expressions are composed of a head and a body, describing the behaviour of one container:
 name[=value]:
 x1 conditionA
 x2 conditionB
 x3 conditionC
 ...
In the 'head' of the expression, the container is named and (possibly) assigned an initial value, which must be a nonnegative integer. If none is given, it is set by default to zero. In the body of the expression a set of instructions defines the effect of other containers (called "contributions") on the current one. If the condition is met, its corresponding value is added to the container. Valid conditions are of the form:
 ContA>=ContB
 Container>=Constant
 Container<=Constant
The IN, PRINT, OUT, EXIT and empty ("") containers are used for special purposes.
==Execution==
At each execution step, the value of every container is updated synchronously. So, for example, if we define A as:
 A:
 -10 B>=1
 +3 W>=1
And the previous values for A,B,W were 2,0,1, we would know that the new value for A is 5. In case of a negative result, the container is set to zero. So if B=1 A would be 0, not -5. Contributions from the container itself and multiple contributions from the same container are allowed.
The PRINT container has the effect of printing the ASCII character corresponding to the last 7 bits of the OUT container every time it changes its value from zero to nonzero.
The program keeps a FIFO (read: First In First Out) queue of all the keys pressed by the user. Changing the value of the empty container from zero to nonzero has the effect of removing one item from the queue, and setting the IN container to its ASCII value (with EOF returning 0).
The EXIT container has the effect of closing the program if changed, with error code equal to its final value.
==Examples==
===Hello, world!===
Program by User:Bangyen:
 A:
 +1 EXIT>=1
 
 PRINT:
 +1 PRINT<=0
 -1 PRINT>=1
 
 OUT:
 +72 A>=0
 -115 A>=2
 +93 A>=4
 -100 A>=6
 +103 A>=8
 -173 A>=10
 +114 A>=11
 +0 A>=12
 +99 A>=14
 -194 A>=16
 +205 A>=18
 -214 A>=20
 +106 A>=21
 +0 A>=22
 -59 A>=24
 
 EXIT=1:
 -1 A>=24
==Implementations==
A Python interpreter by User:Bangyen.
Category:Languages
Category:Implemented
Context.js

== Warning ==
If you love semicolons and lots of typing, you'll hate this language.
If you want to type as little as possible, write code that's clean, understandable, and radically minimal, and to let the computer to figure what you mean, read on.
== Example ==
Which one do YOU find easier to read, type, understand? Be honest.
=== Javascript ===
105 chars
(each indent counts as one char)
greetByName('Jack')
function greetByName(sName) {
 if (!sName) {
 console.log ('Hi');
 }
 else {
 console.log ('Hello, ' + sName);
 };
 };
=== contextual, proposed: ===
36 chars
greetByName'Jack'
greetByName
 ! Say
 'Hello ' sName
 'Hi' 
The contextual version has strong typing and locally-scoped variables.
Full explanation
== context ==
This is a proposal for a new programming language, or meta-language, designed for radical brevity plus human-readability. Think CoffeScript or Clojure without all the cruft.
i'm seeking serious developers who are interested in creating a practical, useful language. This is for brave souls who have the courage to completely discard baggage of existing language syntax and practices. 
Emphasis on practical. This isn't a joke language, or an academic experiment. It's meant to make js programming simpler and easier for real-world js coders. 
== A Better Javascript ==
Why javascript? Because we hate javascript, but it's ubiquitous and we have to use it. We're tired of the timid evolution of javascript. We want to invent a new javascript, written as if we could go back in time and do it right the first time, from scratch. 
There's near-zero desire to make it "easy for existing js developers to understand." If someone wants to use this language, they will have to learn it. 
Also, near-zero desire to make it "easy for beginner programmers". This isn't an educational language, it's intended for professional work. It's expected that users are already proficient in at least one language, and understand general programming concepts. 
We hope contextual.js will inspire other radically-sparse languages.
Context.js is a temporary name for the project; the name may change later to something simpler. Can also be called context.js or contextual.
== How it Feels ==
What's the programmer-experience of programming context.js? It should feel intuitive, light, and quick. Once the language rules are understood, it should be a pleasure to code context.js. Let's stop telling the computer things it should be able to figure out with far fewer characters.
== Another Example ==
=== JS: ===
157 characters
var home =
 {
 cit : "Boston"
 };
home.city = function(aCity)
 {
 if (arguments.length)
 this.cit = aCity;
 else
 return this.cit;
 };
=== CONTEXT: ===
59 characters
home
 City "Boston"
 .toLowerCase
 'City: ' .
== github ==
https://github.com/contextual-project/contextual.js
== Discussion ==
Various folks discussed this topic here, but most of them missed the point. If your response is "Just use C", then you're missing the point.
Category:Languages
ContinuousEquation

ContinuousEquation is an esoteric programming language invented by User:Zzo38. Program flow runs by continuous equations rather than by discrete steps.
Each line is the x and y position of the command, in numerator and denominator form a/b or in decimal form, and the command at that position. You can do repeated commands by replacing x and/or y with a range and step (low;high;step) for example (0;1;1/10) or (10;;4), so you are allowed to omit low or high if you want, but not both. But there is no use making x negative because program flow doesn't go negative. Comments start with # at beginning of line.
Program starts at x=0 and current function f(x)=0 and it runs continuously forward to find a command that the equation y=f(x) touches to execute.
The commands are:
 R a restart at x=0 and set current function to a.
 F a Set current function to a.
 o a Output the number (or ASCII character) a. You can put multiple parameters to output multiple numbers/characters.
 ! Continuation of previous line. Do not type x and y position again.
The functions are:
 numbers Numbers are indicated by the number in decimal form (with .) and another . at end.
 + a b Add a and b together.
 - a Negative a.
 * a b Multiply a by b.
 / a b Divide a by b.
 % a b Modulo a by b, always returns positive if b is positive.
 | a Absolute value of a.
 q a Round a down to a integer toward negative infinity.
 < a b Choose a or b whichever is less.
 > a b Choose a or b whichever is greater.
 x Variable of function, invalid outside of function definition.
 f a Current function of a, evaluated at time of command execution.
 X Evaluate x coordinate of current command (immediate).
 Y Evaluate y coordinate of current command (immediate).
 I Input a number (or ASCII character) (immediate, at time of command execution). You can't do more than once per command.
 z Shortcut for number zero.
 ' Follow by a ASCII character to use the number that corresponds to it. Only valid in character I/O mode.
Example of a command line:
 3.25 (-5;5;0.5) R>z+-1..f+x1..
There are no irrational numbers, program execution ends when current function is set to something that is always undefined or if program flow runs past all commands, or if you prove that no more commands will be reached.
== Examples ==
Cat program (assumes EOF is negative):
 0 0 FI
 1 (0;;1) oY
 2 (0;;1) Rz
Program to square the input number:
 0 0 F*I<xz
 1 0 o*f-1..f-1..
"Hello, world!" program:
 0 0 o'H'e'l'l'o',' 'w'o'r'l'd'!
Beer program (uses UNIX newline):
 2.9 0 F99..
 (1;5;2) (10;99;1) o+'0q/Y10..
 (2;6;2) (1;99;1) o+0%Y10..' 'b'o't't'l'e's' 'o'f' 'b'e'e'r
 2.5 (1;99;1) o10..10..
 4.5 (1;99;1) o' 'o'n' 't'h'e' 'w'a'l'l10..
 7 (1;99;1) o10..'T'a'k'e' '1' 'd'o'w'n',' 'p'a's's' 'i't' 'a'r'o'u'n'd10..
 8 (2;99;1) R+-1..Y
 8 1 o'N'o' 'm'o'r'e' 'b'o't't'l'e's' 'o'f' 'b'e'e'r' 'o'n' 't'h'e' 'w'a'l'l'.
Category:Languages
Category:2007