nyuuzyou/wikis huggingface dataset:
Deklare

Deklare is a language invented by User:A where variables are initialized before they are declared.
==Quick reference==
* a=b Says that the name a has the same value as the name b.
* a=123 The name a has the same value as the name 123.
* 123=123 Says that the number 123 is going to evolve into being equal to the number 123.
* 123=a Says that the number 123 is going to evolve into being equal with a.
==Example==
a=b=c # a, b, and c are the same value.
d=e=f # d, e, and f are the same value.
a=d # a and d are the same value.
d=123 # d is 123. Therefore everything else is 123.
Another example
a=123 # a is the value 123
b=c # b should be the value of c
c=a # c should be the value of a (which is 123).
== The arithmetic system ==
Obviously, without any operators other than the assignment operator, programs literally can't do anything. So here are some examples:
3 = b + 3 # We know that b+3 is equal to 3, but we don't know whether this is true or not.
b = 2 # This returns 0 because this value does not fullfill the above expression.
# There are quite a few of them: + - * / % = > < |
== Challenge: loop over a few values ==
How do we do looping in Deklare? Well, that presents the real status of Deklare: everything is guessed.
So in this expression:
a = 2 + 2
# 2 could have evolved into any value, therefore we need something to limit the step down.
# The only possible evolution is by adding with 2.
# + is (kind of) a shorthand of |+, which means (evolve into) (adding with), so technically Deklare only has one dyadic operator.
# So = is a shorthand of |=, which means (evolve into) (being equal to).
# The expression returns the status of the evolution, so b=a means b should evolve into being equal to a.
# 3 = a + 3 means 3 will evolve into a + 3.
# So in this program:
(a = a) + 3 + 1
# (we use parens to group operators) means that a will either evolve with a + 3 or a + 1.
# So let's try to solve our problem. In order to count up forever starting from 1:
a = 1
# Great! We've set our initial value! Now we'll try to define what we should do in each iteartion:
(a = a) + 1
# The only possible evolving is by adding with 1. So what is our destination?
a | -1
# a must evolve into -1 by adding 1 forever, which is obviously impossible. Therefore this loops forever.
# Here is the full program (with printing):
a = 1
a | -1
p(a = a) + 1
== Solve our equation ==
(3 + 4) = (x * (2 + 3))
p(x)
== Add two numbers ==
# O only has one possible evolution method: input plus ord 'A'.
o=i+ord'A'
== Compare two letters ==
# Possible evolutions of input:
(i = i2) | (p"Same"
q) | (p"Different"
q) # q is the quitting nilad
# If i is going to evolve into being equal with i2, print same.
# (The true symbol is defined to evolve into any symbol.)
# (However, the false symbol is defined to evolve into none of the symbols.)
# No evolution specifiers, so this prevents those values from evolving.
Golfed:
(i=i2)|(p"Same"q)|(p"Different"q)
== Implementation(s) ==
I am currently trying to implement the language. The interpreter will be added as soon as possible.
Category:2019
Category:Languages
Category:Unimplemented
Category:Declarative paradigm
Category:Cell-based
Delambda

Delambda is a successor to Unlambda created by User:Shadow Kestrel in 2022. Its syntax and semantics are largely identical to Unlambda, except for the removal of intrinsic functionality from .x functions, removal of the c, e, @, ?x and | functions, and the addition of the o function. This makes the core of Delambda an effectively pure implementation of the SKI combinators with other terms being defineable therein. Additionally, the standard i/o streams are encoded in UTF-8 as opposed to being left unspecified.
== The o function ==
I/O is handled by the o function. If the program evaluates to an expression of the form ``oAB then an action is taken depending on A, then B is applied to the result. For example, ``o`ki`s`ki would read one character from the standard input (corresponding to `ki). Supposing the character read were ě (UTF-8 code c4 9b) then execution would resume as ``s`ki``<cons><church numeral 0xc4>``<cons><church numeral 0x9b><nil>.
Any values taken or given as a "list" are defined with <cons> = ``s``s`ks``s`kk``s`ks``s`k`si``s`kki`k``s`kki; <nil> = `sk
The functionality of ``oAB is as follows:
A 	Behaviour
``.x.y.z 	Writes "zyx" to stdout
k 	Reads the entirety of stdin and returns it as a list of lists (per character, final character deepest) of church numerals (bytewise, LSB deepest). Returns <nil> upon failure.
`ki 	Reads a single character from stdin and returns it as a list of church numerals (bytewise, LSB deepest). Returns <nil> upon failure.
`kx 	If x is a list of church numerals forming a valid UTF-8 character, returns a .x function for that character. Else, returns v
s 	Returns a church numeral, whose binary form denotes the capabilities of the implementation. Any form of `sx or ``sxy is reserved for such functionalities.
Any other term not of the form ``sAB	Error and terminate
=== Implementation-specific functionality ===
A Delambda implementation is not required to implement all these functions, as some may not be available in the parent language.
==== File I/O ====
Available if `os bit 0 (LSB) is 1. From path ``si.
A 	Behaviour
``sii 	Reads from a file, prompting user for choice. Returns a list containing the file name (list of bytes, ASCII) and raw data (list of bytes), or <nil> if it fails.
``si`kx 	Reads from file x, assuming x is a valid sequence of ASCII .x functions. Returns the raw data of the file as a list of bytes or <nil> if it fails.
``si``sif 	Writes the list of bytes f to a file, prompting user for choice. Returns k, or `ki if unsuccessful.
``si`s`kxf	Writes the list of bytes f to file x, assuming x is a valid sequence of ASCII .x functions. Returns k, or `ki if unsuccessful.
==== Basic Canvas ====
Available if `os bit 1 is 1. From path ``s`k.
A 	Behaviour
``s`kxy 	Creates a new canvas of width x and height y, and returns an actionless function corresponding to it.
``s`kCv 	Destroys canvas C and returns k or `ki in the event of failure. Note that losing all references to a canvas without destroying it is undefined behaviour and should be avoided.
``s`k``sxy`sCl	Draws pixel (x,y) with colour l on canvas C, returning C. (A colour is a list of three church numerals less than 256 representing RGB)
DeleteScript

DeleteScript is a very funny esolang created by User:None1, any DeleteScript program deletes itself.
==Intepreters==
Interpreters of DeleteScript is usually live in your OS ('del' in Windows and 'rm' in UNIX-based systems), but if you want, these are some other interpreters.
===C===
#include<stdio.h>
int main(int argc, char *argv[]){
 remove(argv[1]);
 return 0;
}
===Python===
 import os,sys
 os.remove(sys.argv[1])
==Running DeleteScript by yourself==
In Windows, you can run a DeleteScript program manually by selecting it in the explorer and press shift+delete, then press enter or the Y key.
If the program disappears, you have run it successfully.
===Another method===
# Select the program and the press Delete, then press Enter or Y. If program appears in Recycle Bin, then you've been compiled it.
# Find the program in Recycle Bin and press Delete, then press Enter or Y. If program disappears, then you've executed it.
This may also work in Linux, or MacOS.
Category:Languages
Category:Joke languages
Category:No IO
Category:Unusable for programming
Category:2023
Category:Total
Category:No-code esolang
Deliver

This page is in developing
Deliver is a language that runs on a tape of stacks, it's created specifically for a game jam.
As the name suggest, it's created in the theme of Delivery.
== Some Concept ==
Each Pile is a stack, there's at least 2560 piles. Each stack at least can contain 256 numbers.
Your Position is a number, automatically mod by the number of piles.
Your Package is a number, which you can use as a register
A Routine is a function, though you cannot pass value to it or get a return value from it
A Circuit is a library.
== Syntax ==
The language runs line by line, and can be split into multiple files(in the sense of the language, circuit).
Each line is a command belongs to the following list:
 Command list
Command	Functionality
Move d 	Move by the distance of d, where d is either a number, TOP, or PACKAGE
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Delta

Delta is an esolang made by TJC games that is meant to be a valid language.
I don't have a runtime yet because I don't know how to make one in Java and I don't know anything from the C branch.
I literally only have my thoughts.
== Data structure ==
 Data structure
Primitivity	 	 	 	 	
Level 0 	Any (Just any type) 	Type (A specific type) 	 	 	
Level 1 	Bit (1 bit) 	Array (A list of values) 	Code (Some code in Delta) 	 	
Level 2 	Byte (8 bits) 	Dict (2 tables and a lot of functions)	2DArray (A 2D array) 	 	
Level 3 	DWord (2 bytes) 	QWord (4 bytes) 	OWord (8 bytes) 	XWord (16 bytes) 	
Level 4 	Float (Decimal number) 	Int (Integer) 	ASCII (ASCII char) 	Uni (Unicode char) 	Colour (A colour)
Level 5 	String (A table of Unicode characters)	Point2 (2D point) 	Point3 (3D point) 	Image (A 2D array of colours)	TriNum (<latex>(a+bi+c\epsilon)</latex>)
Level 6+ 	Triangle (3 points) 	Polygon (Lots of triangles) 	Polyhedron (Lots of Polygons)	 	
== Gimmick ==
The main gimmick of Delta is that no variable can begin with the letter D. This might be a weird restriction, but this is because, if you try to do so, it will affect the change in the variable. This updates on the call of Delta().
This also means that trying to get a variable beginning with d will get the change in the variable between the last two calls of Delta().
A QoL change I will also make is that, if a line contains one variable, the output of the line is assigned to that variable.
Category:Languages Category:Ideas
DeltaHello

DeltaHello is a joke language. DeltaHello instructions:
*H: Print "Hello, world!"
*Q: Quine
*9: Print "99 Bottles of Beer"
*S: Say "hello, world"
*+: Increment the accumulator
*C: Print accumulator value
==See also==
*HQ9+
==Implementations==
*DeltaHello source code
Category:Joke languages
Category:Unusable for programming
Delta Salein Å

Delta Salein Å, DSA or δဆå is a programming language created by Ultlang. It uses a 3x3x3 cube and three registers for data storage.
Commands:
[tba]
Hello world:
 άδဆåω၇၂ǫω၁၀၁ǫω၁၀၈ǫω၁၀၈ǫω၁၁၁ǫω၃၂ǫω၁၁၉ǫω၁၁၁ǫω၁၁၄ǫω၁၀၈ǫω၁၀၀ǫω၃၃ǫ
Multiplication:
 άδဆåω[NUMBER_1]ŀШω[NUMBER_2]ŀЩq¢ŗώШ↓ŗώЩ↓ŗŀШω၂ŀЩ-ώЦ→ŗŀЩ+ώШŀЩ↑ŗώЩq$1άδနůŀЦάδဆåŀЩ+άδနůώШάδနåŀЦάδတåŀЩ+ώШάδတůŀШάδတåŗʆ§1άδနůø
Category:LanguagesCategory:2021Category:Cell-basedCategory:Output only
Deltaplex

Deltaplex is an esoteric programming language developed by Lode Vandevenne. It was designed to be the successor of Gammaplex. Deltaplex code is to be read from a PNG image that is decoded into a 32-bit RGBA buffer. The main reason for this is not because it's funny to read code from an image, but because this is the best way to store textures in code. Deltaplex supports 3D graphics, hence the need for textures.
==Features==
Currently, the following features are mentioned in the specification:
*Two stacks: an integer stack and a floating point stack
*Pushing numbers read from code pixels
*Stack operations
*Program flow on the 2D code image
*2D graphics
*3D graphics: drawing of different types of OpenGL primitives
*Texture mapping
*Mouse and keyboard input
*Basic math
*Matrix and vector math
*Self modifying code
*Strings
==Interpreter==
There is an official interpreter available, that uses OpenGL as API. 
==Older idea==
Initially, it was planned to make the language support:
*Audio, where you're able to store audio files in the RGB data.
*Saving data to the harddisk, in a special optional chunk in the png image only used by deltaplex.
*2D and 3D graphics.
*A simple GUI.
*Advanced mathematics, including matrix, vector and complex math.
*Realtime keyboard and mouse input.
However, some of these features didn't make it into the current specification.
==See also==
* Gammaplex
* Omegaplex
* Zetaplex
==External resources==
* Specification and interpreter source code
Category:Languages
Category:Unknown computational class
Category:Two-dimensional languages
Category:Implemented
Category:Non-textual
Category:High-level
Category:Self-modifying
Category:2006
Delvs

Delvs(pronounced /delve-iss/) is a Brainfuck extension similar to Brainfuck++ designed in February 2013 by User:L8D. The primary purpose was to combine many other Brainfuck derivitaves like Brainfuck++ and Boolfuck, and the language(and Interpreter) are still in development.
==Instructions==
Delvs currently has 10 additional instructions.
Command	Description 	Pseudo Code
: 	Cast current cell's value to string and print 	printf("%hhd", *p);
; 	Read number set from stdin and store in current cell 	scanf("%hhd", p);
# 	Read following cells as null-terminating string for filename, then if current cell is not 1, open file for reading, or if 1, open file writing	f = fopen(p + 1, p == 1 ? "w" : "r");
` 	Read next char from file stream and store in current cell 	*p = fgetc(f);
! 	Write current cell's value to file stream 	fputc(*p, f);
" 	Move bit to the right once 	b <= 0 ? b = 7 : b--;
' 	Toggle/flip bit and move bit to the right once 	*p ^= (1 << b); b <= 0 ? b = 7 : b--;
\ 	Comments out rest of line 	while(*c++ != '\n');
@ 	Prints out surround cell values in a formatted way. Basically a breakpoint for debugging 	printf("%hhd : %hhd : %hhd : %hhd : %hhd", *(p - 2), *(p - 1), *p, *(p + 1), *(p + 2));
$ 	Sleeps the current cell's value in seconds 	sleep(*p);
==To do==
*implement a working socket system
*implement an stdout flushing system
*implement runtime args
*implement namespaces (separate arrays of 30000 chars)
*(maybe) implement better way to divide
*implement full integers
==External resources==
* Full implementation of a Delvs interpreter written in C by Delvs's creator
Category:Languages
Category:Brainfuck derivatives
Category:Cell-based
Category:Turing complete
Category:Turing tarpits
Category:Implemented
Category:Low-level
Category:2013
Demlang

Category:2025
Category:Joke_languages
Category:Languages
Category:Unimplemented
Demlang is an object-oriented joke language created by User:Cocosbeans in 2025. The concept of the language is that any data created in a file, including variables/values, objects/classes, and functions, can only be accessed in the scope in which they are defined. Therefore, scopes serve as "object permanence".
= Concept =
Demlang was created to make it feel as though the computer has "dementia" and lacks object permanence. Values and objects in Demlang are only accessible in the same scope they are defined in, and scopes can be defined as any block of code that is put between two curly braces. Nested scopes cause data to be forgotten from memory if the nested scope is evaluated; if the nested scope is never evaluated (i.e. it has a condition that fails), memory will persist.
 {
 let x = (int) 5;
 let y = (int) 10;
 
 if (false) {}
 
 //x and y are not forgotten because the if statement fails
 let z = (int) x + y;
 
 if (true) {}
 
 //x, y, and z no longer exist in memory
 let a = (int) z; //error
 }
Due to how scopes work, classes can never be used because their fields are always forgotten after declaration and can't be initialized. This also applies to functions, where despite having the ability to return a value, it cannot be used.
= Etymology =
The name Demlang is short for dementia language. The language was originally supposed to be based around how babies do not have object permanence until a few months into infancy, but Babylang is already an existing name.
= Syntax =
The syntax of Demlang is modeled after C#. Its libraries are PascalCased and its primitive features are named the same as they are in C# (e.g. int, string, ushort).
== Libraries ==
Libraries can be imported with the use command. This imports the source file of the library. Specific classes and functions can also be imported without importing the rest of the file. Libraries follow the pattern of Folder1.Folder2.File::BaseClass::Subclass:function.
 use Core; //import all std features
 use Math.Alg; //import the algebra library in the math folder
 use Math.Trig::Trig; //import the trigonometry class in the trig file
 use Math.Calc::Calc:GetDerivative; //import the getderivative function in the calculus class
These libraries can be accessed by simply naming which imported class to be used:
 let f = (Alg.Expr) Alg.GetExprFromStr("3x^2+2x-6");
 let fprime = (Alg.Expr) GetDerivative(f);
This page is a WIP.
Demons

==Demons==
Demons is a Esolang with one byte large instructions natively, and it is intended to be able to run *Any* file it is given, churning out a output or a crash.
===Basic opcodes===
* 00 | No-op
* 01 | Move pointer up one
* 02 | Move pointer down one
* 03 | Shift value under pointer up one
* 04 | Shift value under pointer down one
* 05 | Add the current value under pointer and the value under the address specified by the next n bytes (Interpreter dependent)
* 06 | Subtract current value under pointer and the value under the address specified by the next n bytes (Interpreter dependent)
* 07 | Multiply the current value under pointer and the value under the address specified by the next n bytes (Interpreter dependent)
* 08 | Divide the current value under pointer and the value under the address specified by the next n bytes (Interpreter dependent)
* 09 | Print the current value under the pointer to the stream (STDOUT)
* 0A | Put the input from the stream into the value under the pointer (STDIN)
* 0B | Clear the stream (STDIO)
* 0C | Jump n many spaces from current location
* 0D | Jump n many spaces from the entrance point
* 0E | Compare the current value under the pointer to the value under the address specified by the next n bytes (Interpreter dependent), if they are not equal, skips the next operation
* 0F | Compare the current value under the pointer to the value under the address specified by the next n bytes (Interpreter dependent), if the first one is not larger, skips the next operation
* 10 | Compare the current value under the pointer to the value under the address specified by the next n bytes (Interpreter dependent), if the first one is not smaller, skips the next operation
* 11 | Test if the current value under the pointer is nonzero, if so, skips the next operation
* 12 | Test if the current value under the pointer is non negative, if so, skips the next operation
* 13 | Ends the program
* 14 | IF block, defined like IF (Statement) {Demons code}
* 15 | Begins statement block
* 16 | Tells the statement of success
* 17 | Tells the statement of failure
* 18 | Ends the statement block and begins the code block
* 19 | Ends the code block
* 1A | WHILE Block, defined like WHILE (Statement) {Demons code}
* 1B | Waits the amount of ms stated by the current value under the pointer
* 1C | jumps back to pointer value of 0 (the one for the interpreter's beginning of demons mem segment) 
* 1D | Stores the value from n in the code, based from the entrance point
===Demons Memory management===
Demons has a memory management system similar to brainfuck, a infinite number of values on a 'tape',
===Printing===
Demons handles all characters in the ansii character set
===Interpreters===
None yet, the language is purely theoretical for now
===Sample code===
None, yet again
Category:Languages Category:Unimplemented
Depend

Depend is an esolang created by User:PythonshellDebugwindow.
==Overview==
Depend is based around events. Events can have any amount of dependencies, which are other events.
==Syntax==
Each line takes the form of a series of two or more strings of alphanumeric characters and underscores. The first two are separated by a dash and greater-than sign, and the rest are separated by commas. Alternatively, a line can be just one such string followed by a dash and greater-than sign.
==Semantics==
Each line symbolizes an event whose ID is the line's first string. The rest of the line's strings are that event's dependencies, which are other events (given as IDs). If the event has no dependencies, then it can finish immediately; otherwise, it has to wait until all its dependencies have finished. It is undefined behaviour if an event has itself or an undefined event as a dependency. Empty dependencies (the empty string) are ignored.
==Examples==
===Infinite loop===
 1->2
 2->1
===Truth-machine===
Replace ? with your input.
 0->
 1->2
 2->?
==External resources==
* Interpreter on GitHub
Category:Languages Category:2020 Category:Implemented Category:Unknown computational class Category:Usability unknown Category:No IO
DerpScrp

DerpScrp, not to be confused with similarly named languages, is an esoteric programming language invented by User:A that is created in 2019 influenced by the syntax of DerpText.
==Syntax==
Commands have one or more parts containing text, all separated by a command ending character. Variables can consist of zero or more characters, but not all are allowed by the syntax of every command. The varN or textN of a command cannot contain the command ending character because it ends the text. 
==Semantics==
There is a console output string(A), a text string(B), and a command string(C). There is an infinite number of variables, all initially set to the empty string. The text string is set by the user before the program starts and can be empty. The command string is the program and commands are deleted from the beginning of the string as they are processed. The whole console output string will be outputted constantly, waiting 0.5sec and clearing the screen in every step.
==Commands ==
Command 	Operation
&text& 	Appends text to the output console.
=string=string2= 	Exchanges string1 with string2. If string2 is a constant, then string1 will be set to that constant.
>string>constant>	Remove all occurences of constant in the string string.
<string<constant<	Keep all occurences of constant in the string string.
+text+ 	Append text to the program (text can be both strings or constants).
==Examples ==
&Hello&
Outputs "Hello" to the console. (Appends Hello to A)
=A=B=
Exchanges B with the value that the pointer A is pointing to (i.e. the output console)
=A=123=
Change the output of the console to 123. (A constant cannot be swapped to represent A, so it is kept as-is.)
>A>12>
Remove all occurences of 12 in the output console.
<A<12<
Keep all occurences of 12 in the output console.
+A+
Append the contents of the output console to the program.
Category:2019
Category:Unimplemented
Category:Languages
Category:Self-modifying