nyuuzyou/wikis huggingface dataset:
Dorklang

Dorklang is an esoteric programming language created by James Smith.
Each dorklang program has access to a 64-bit unsigned integer known as the current value, which is automatically set to 0 when the program begins. There are also two stacks available for storage, but only one of these is set as the current stack at any one time.
For full documentation, please see the Github repository for the language's main interpreter, which is written in Go.
== Examples ==
=== Printing the Alphabet ===
{ SET CURRENT VALUE TO TWENTY-SIX, THE NUMBER OF LETTERS IN THE ALPHABET }
/+[']+
{ BEGIN LOOP, SAVING DECREMENTED COUNTER VALUE }
<-:
	{ SET CURRENT VALUE TO NINETY, THE UNICODE/ASCII VALUE OF 'Z' }
	+(/)[']+
	{ LOAD COUNTER VALUE, SAVE IT AGAIN, SO IT CAN BE REUSED, THEN SUBTRACT IT FROM NINETY }
	[;:]
	{ PRINT THE UNICODE/ASCII CHARACTER AT THE CURRENT VALUE }
	!
{ RESTORE SAVED COUNTER VALUE AND JUMP BACK TO THE START OF LOOP IF IT IS GREATER THAN ZERO }
;>
The example above prints all of the letters of the English-language alphabet to the console (in sequential order from A to Z).
The comments between the braces explain how the code works.
=== Hello, World ===
(')!
[+*+$:]!
(+ +^*)-! !
(+*+):!
~++^$$:[++*][++/]!
;:/!
;:++[++/]!
$;!
+(+)+!
--+!
/+!
The example above prints a friendly greeting to the console.
=== Summing All Integers Between 1 and 1,000,000 ===
(/)('/)^^ii:%++!!
The example above calculates the sum of every integer between one and a million inclusive, then prints the result to the console.
The program begins by setting the current value to 100, using a sequence of commands.
The ^^ command is then used to cube it, making it equal a million.
The ii command fills the currrent stack with a range of integers from 1 up to the current value exclusive.
The : command pushes the current value to the current stack, so that the range becomes inclusive.
The important work is done by the %++ command, which sums all of the values in the current stack and assigns the result to the current value, which is finally printed to the console by the !! command.
Category:2023
Category:Imperative_paradigm
Category:Implemented
Category:Languages
Category:Push-down_automata
Category:Stack-based
Category:Turing complete
Dot-Peachy

Dot-Peachy, or, simply, DTP, is an esoteric programming language created by AlexUI in 2023. The main idea is that its syntax is mostly made out of symbols that look like letters or words. It can call and print variable values by writing their ID, which is based on their order of declaration.
==Language overview==
Dot-Peachy is still in development. It follows a typical syntax format, but it uses its own symbols and has some special syntax declarations. All lines of code must end in ¤. The following are the basic commands or "keywords":
Command	Description 	Type
¤ 	Line-breaker 	Basic syntax
, 	Variable declaration separator 	Basic syntax
; 	Argument separator 	Basic syntax
(, ) 	Function argument-enclosing parentheses	Basic syntax
«, » 	Literal encloser 	Basic syntax
.: 	Integer declarator 	Declarator
.∿ 	String declarator 	Declarator
:* 	Print function 	Standard function
== Interpreters ==
DTP interpreter
Category:Total Category:Implemented Category:Output only Category:Unusable for programming
DotSF

DotSF is a stack based esoteric programming language created by user:ArthroStar11 that was heavily inspired by brainfuck, Befunge, with a few elements derived from Intercal.
== Data Structure and Syntax ==
DotSF uses single character commands read from left to right.
DotSF's only data structure is a stack of 32 bit integers with a maximum depth of 30000, a feature inspired by brainfuck's character cell count.
== Commands ==
Math
* 0~9: push the corresponding integer onto the stack
* +: pops A then B off the stack then pushes A+B onto the stack
* -: pops A then B off the stack then pushes A-B onto the stack
* *: pops A then B off the stack then pushes A*B onto the stack
* /: pops A then B off the stack then pushes A/B onto the stack
* %: pops A then B off the stack then pushes A(mod)B onto the stack
* _: pops top value off stack then pushes two copies of the value onto the stack
I/O
* . takes input as an integer
* , takes input as a character
* : pops the top value and outputs it as an integer
* ; pops the top value and outputs it as a character 
Flow Control
* [ and ]: [ pops the top value off the stack if the popped value is 0, skips to the next ] otherwise continues as normal
* A~Z: defines a label
* a~z: jumps to the corresponding label when reached, jumping to the same label more than 1000 times in a row throws an error.
Tip Command
The tip command, "$" has no function within the program but is necessary to include as the interpreter, known as "Agatha" wants compensation for it's work. This feature was inspired by Intercal's "PLEASE" command.
the tip command should make up at least 1/10 of the source code but not more than 1/5.
* Note that your source contains one invisible tip command by default
** Also note that this means a source of less than 5 Bytes will always throw an error
== Sample Programs ==
Prints "HI"
 98*_;1+;
Truth Machine
 .A__[:b$Ba]:
counts down from 99 to 1 (99 bottles of beer w/o lyrics)
 0A1+_92+9*1+-_[:a]$
==External Links==
Link to ArthroStar11's interpreter (C++ source)
== See Also ==
EXDotSF, a backwards compatible extension developed by User:Rudolph4268
Category:Languages
Category:2021
Category:Stack-based
Category:Implemented
Category:Low-level
Category:Unknown computational class
Dots

The Dots programming language is a language that only uses the characters ., :, and ;. 
==Syntax==
A Dots program is mainly composed of dots, colons, and semicolons, imposing the structure within which the arguments are evaluated.
A series of dots (.) introduces and identifies the command, while the colon (:) serves to designate a following argument. Every instruction terminates in an imperative semicolon (;).
The following Extended Backus-Naur Form (EBNF) specification shall imbue the syntaxis' stipulations with enhanced stringency:
 program := { command | padding } , halt , padding ;
 command := halt | print | defineVariable ;
 halt := ".;" ;
 print := ".." , ( identifier | stringLiteral ) , ";" ;
 defineVariable := "..." , ":" , identifier , ":" , stringLiteral , ";" ;
 stringLiteral := { character - ";" } ;
 identifier := identifierChar , { identifierChar } ;
 identifierChar := character - ( whitespace | reservedSymbol ) ;
 reservedSymbol := "." | ":" | ";" ;
 padding := { whitespace } ;
 whitespace := " " | "\t" | "\n" ;
==Commands==
All programs must be ended with the end program command and all commands must end with a semicolon.
Command	Arguments	What it does 	Pattern
. 	0 	End a program. 	.;
.. 	1 	Print to the screen. The argument must either be an already defined variable name, in which case its content is inserted, or an arbitrary character sequence, except for the semicolon (;), to be employed ipsissima verba. 	..:variableOrText;
... 	2 	Define a variable, the name of which derives from the first argument, and its value from the second. The name must be an identifier comprised of one or more graphical characters, except for ., :, ;, or whitespaces; the value may be any character sequence barring the semicolon (;).	...:variableName:content;
==Examples==
===Hello World!===
This is the hello world program in this language:
 ..:Hello World!;
 .;
===Hello, World! Using Variables===
This program employs a variable in order to print the message “Hello, World!”:
 ...:greeting:Hello, World!;
 ..:greeting;
 .;
==Interpreter==
* Common Lisp implementation of the Dots programming language.
Category:Languages Category:Implemented Category:Total Category:Unusable for programming Category:Output only Category:2020
Dotsscript

DotsScript is a JavaScript interpreter that makes your JavaScript code much simpler by making the whole code using 2 characters only, the . and the ᱹ character.
== Installation ==
The interpreter is available through npm and yarn under the name dotsscript
 npm i -g dotsscript
Or
 yarn global add dotsscript
== Usage ==
You can use DotsScript by importing the library in your JavaScript file:
 import 'dotsscript';
 
 // Your code here
Or you can use it straight from the command line without importing 'dotsscript'
 dot index.ds
== Example ==
Here is an example of how you can use DotsScript:
 ᱹ.ᱹᱹ.ᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ
 .ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹ.ᱹᱹᱹᱹᱹ.ᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ
 .ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹᱹᱹᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹᱹᱹᱹᱹ.ᱹᱹᱹ.ᱹᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹ
 .ᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹᱹᱹᱹ.ᱹᱹᱹ.ᱹᱹᱹᱹᱹᱹ.ᱹ.ᱹᱹᱹ
 .ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ
 .ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹ.ᱹᱹᱹᱹᱹᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹᱹ.ᱹᱹᱹ.ᱹᱹᱹᱹᱹᱹ.ᱹᱹᱹᱹᱹᱹᱹᱹᱹᱹ.ᱹ
This code is equivalent to the following code:
 console.log('Hello, World!');
As you can see, the code is much simpler and do not contain any characters that can confuse you.
== Documentation ==
The global object ᱹ is the main object that you can use to access the DotsScript API. It contains the following properties:
Property 	Description
ᱹ 	Execute the code and returns a new ᱹ object
ᱹᱹ 	Lower-case letters from a to z
ᱹᱹᱹ 	Upper-case letters from A to Z
ᱹᱹᱹᱹ 	Numbers from 0 to 9
ᱹᱹᱹᱹᱹ 	Special characters *+,-./
ᱹᱹᱹᱹᱹᱹ 	Special characters !"#$%&'()
ᱹᱹᱹᱹᱹᱹᱹ 	Special characters []^_`
ᱹᱹᱹᱹᱹᱹᱹᱹ 	Special characters :;<=>?@
ᱹᱹᱹᱹᱹᱹᱹᱹᱹ	}~
After accessing the desired group, enter ᱹ n times as the property name to access the desired character where n is the index of the character in the group.
For example, to access the character f, you can use the following code:
 ᱹ.ᱹᱹ.ᱹᱹᱹᱹᱹᱹ
This will add the character f to the code and will return the ᱹ object so you can continue chaining the characters.
After you finish chaining the characters, simply add a .ᱹ at the end of the chain to execute the code. This will execute the code and return a new ᱹ object so you can continue writing the code.
Note: After each execution, the code will reset so you can start a fresh new code.
== Links ==
* GitHub Repo: github
* NPM: npm.js
Dotsy

A system created by Quadril-Is, initially written down in Samsung Notes.
== Period (.) ==
Flip the bit at the current position.
== Comma (,) ==
If bit is 0, move to the right. If bit is 1, move to the left.
== Semicolon (;) ==
Execute the period and the comma at the same time.
== Colon (:) ==
Jump to code position at first byte.
Category:Languages
Dotter

Dotter is a stack-based esoteric language.
==Commands==
* ..............[ascii]: pushes ascii as a character to the end of the stack.
* .............[ascii]: pushes ascii as a character to the beginning of the stack.
* ............: prints stack to the console.
* ...........: prints stack to the console but reversed.
* ..........: prints last character of stack to the console.
* ..........: prints first character of stack to the console.
* .........: deletes last character of stack.
* ........: deletes first character of stack.
* _: indicator for next command.
==Installation==
# Download Python 3.9
# Download the 'main.py' file from the github repository
# Run python3 [main.py file path] [(optional)code file path]
==Hello world! program==
 ..............72_..............101_..............108_..............108_..............111_..............32_..............119_..............111_..............114_..............108_..............100_..............33_............
Category:Output onlyCategory:Unusable for programmingCategory:LanguagesCategory:2020Category:ImplementedCategory:TotalCategory:Stack-based
Down the Mountain

Down the Mountain is an esolang made by Joaozin003, in which the code is a mountain for a ski to slide down.
== Syntax ==
There is no syntax. Indentation doesn't matter. For example, if your program looks like this:
 S
 x y
 y.x.
or this:
 Sxyy.x.
it won't matter. Just remember that the former is recommended since the code is laid out in a full binary treehttps://en.wikipedia.org/wiki/Binary_tree#Properties_of_binary_trees.
== Pre-execution steps ==
Before the code is run, these steps are performed:
# Remove all whitespace;
# Pad .s until the code has 2^n-1 characters, where n is any integer.
== Commands ==
All commands not listed here act as lifts.
=== Ski movement ===
By default, the ski always moves left.
 S: Where the ski starts. If there are more than one of this command or 0 of this command, the program raises an exception.
 #: Is used to block the current path of the ski, making it move the other way. If there are walls in both directions, the program halts.
 _: If the current memory cell is 0, move right, otherwise move left. If there is a wall after this command, it is interpreted as a '.'.
 ^: Jump back to the beginning of the program, moving in the current direction.
=== Memory ===
The memory is a tape which is infinite in both directions. Memory cells are unbounded signed integers.
These commands interact with memory or the pointer in some way other than I/O.
 +: Increments current memory cell.
 -: Decrements current memory cell.
 >: Moves the pointer right 1 cell.
 <: Moves the pointer left 1 cell.
 0: Sets current memory cell to 0.
=== I/O ===
All exceptions are output in STDERR, not STDOUT.
 i: Takes a character from input and stores its codepoint in the current memory cell.
 o: Outputs the current memory cell as a character. If the character is out of bounds for Unicode, then immediately halt and raise an exception.
== Lifts ==
All commands not specified above are lifts.
When the ski reaches a lift, these steps happen:
* Is there another lift with the same character?
** If yes, then pick randomly from one of those lifts and go to that lift.
** If no, then continue sliding.
== Examples (TODO) ==
=== Non-terminating cat program ===
 Sio#^^#
Ungolfed:
 S
 i o
 #^^#
== Computational class ==
While not proven yet, it may be possible to write a brainfuck interpreter (and probably is), making this language Turing-complete.
== External resources ==
Category:Languages Category:Thematic Category:Unimplemented
Draft:Bosh

Bosh, created by User:Icecream17, contains a hodgepodge of features just randomly added together.
== BaseCollection Class ==
A BaseCollection represents a bunch of values
Here in this specification, the empty BaseCollection looks like <<>>, with any values separated by commas: <<1,2>>
== Property Class ==
A property has two parts, a name and a value.
Spec-wise it looks like 
Variables are defined as properties of the global object
== BaseMap Class ==
A map is a collection of properties
== BaseObject Class ==
BaseObjects have two maps called properties and internal properties.
Spec-wise, properties are shown like: thing.property, while internal properties are shown like: thing.property
When a property is a function, it's called a method.
== BaseSequence Class ==
represents ordered BaseCollection
== BaseData Class ==
represents a sequence of bytes
== Integer Classes ==
Drawfuck

Yet another brainfuck derivative, by User:Actuallyallama.
Rather than outputting ASCII characters, it outputs a 256x256 image. By default, the image is a blank white canvas.
It also has a few extra values: R, G, B, X, and Y.
Most of the commands are the same as brainfuck, with a few additional commands.
Command	Description
r 	Set R to the current memory cell value.
g 	Set G to the current memory cell value.
b 	Set B to the current memory cell value.
x 	Set X to the current memory cell value.
y 	Set Y to the current memory cell value.
. 	Set the pixel at X,Y in the image to a new colour R,G,B.
n 	Subtract 1 from Y. (North)
s 	Add 1 to Y. (South)
e 	Add 1 to X. (East)
w 	Subtract 1 from X. (West)
Example:
 +[+>+[+r<gb>y.]<x]
will produce this output:
 .x+[>y+[.y+]<x+]
Gives you a totally black image.
An interpreter has been written by User:Dtp09 on December 23rd, 2021, and hosted here.
Another interpreter has been written by User:None1 in Python, on October 27, 2023, it updates the image per 1000 instructions and allows you to save the image.
Category: Languages
Category: Cell-based
Category: 2016
Category: Brainfuck derivatives
Category: Graphical Output
Category: Implemented
DrawkcaB

== Concept ==
drawkcaB (pronounced draw-cab) is a programming language concept by user:Maxsteele2.
drawkcaB would, as might be expected, be written backward (excluding comments).
There is a drawkcaB version of every single language ever created. These are differentiated by adding the reversed name of the normal language to the end of drawkcaB. They are basically just a reversed version of the language.
drawkcaB version of Python: drawkcaB nohtyP
C++: drawkcaB ++C
drawkcaB: drawkcaB Backward --this is forward, though
== Examples ==
=== Hello, World! ===
==== drawkcaB 3 nohtyP ====
 )"!dlroW ,olleH"(tnirp
==== drawkcaB ++C ====
 ;"!dlroW ,olleH" << tuoc::dts
=== Truth-machine ===
==== drawkcaB 3 nohtyP ====
 )(tupni = i
 :'0' == i fi
 )i(tnirp
 :'1' == i file
 :eurT elihw
 )i(tnirp
==== drawkcaB ++C ====
 ;i >> nic::dts
 { )"0" == i(fi
 ;i << tuoc::dts
 { )"1" == i(fi esle }
 { );;(rof
 ;i << tuoc::dts
 }
 }
== Implementations ==
user:Ehulinsky created a compiler here: http://anothersitemadewith.weebly.com/drawkcab.html
Category:Concepts Category:Implemented
Dreadfish

Dreadish is an input-only language based on Deadfish, and is the first of its type.
== Commands ==
 u input
 i increment
 d decrement
 s square
 v switch with second counter (unless second counter is 0 unless first time)
 ( repeat amount of times of second counter (second time closes)
== Limit ==
The "limit" is 256, but there are workarounds like this:
iiiisis
This makes 289. You can also get a glitch 256 using input.
== Glitch 256 ==
The glitch 256 is unable to be changed into an input, incremented, or decremented. It can only be squared. This makes a normal 65536.
=== Methods ===
The only known methods are these:
* squaring -4
* input 256
== A+B problem ==
 uvu(vidi(
Category:LanguagesCategory:Input onlyCategory:Unusable for programmingCategory:Unimplemented
Drift

Drift is a procedural, "stack-based" programming language created by Harald Sorenson in 2017. The main premise of the language is where every variable is a stack (filo) or queue (fifo) of positive integers.
==Language Syntax==
===Declaration Keywords===
* filo will declare a first-in-last-out stack.
* fifo will declare a first-in-first-out stack, also known as a queue.
===Destruction Keywords===
* del will destroy a variable, and will allow it to be redeclared.
===Variable Operators===
* Pushing: . will push onto the stack.
* Popping: ~ will return and remove the top/bottom of the stack.
* Peeking: ^ will return the top/bottom of the stack.
* Get Size: ? will return the size of the stack.
===Logic Keywords===
* if and else statements, along with else if statements.
* loop with break for looping.
* lbl and goto operators with ret token to return to goto call.
===I/O Keywords===
* print will print to stdout.
* println will print to stdout with an appended newline.
* char and int keywords to define how to print.
* cin will get the first character of user input.
* sin will get a line of user input.
* nin will get a number from user input.
===Arithmetic===
* All arithmetic must be placed within arithmetic blocks ()
* Operators currently functional include: +, -, /, *, and %.
===Strings===
* "..." to create a string literal, only supported when pushing to a variable.
* '... to create a character literal, only supports one character.
===Misc===
* One-line comments are declared with a \ token.
==Examples==
===Hello, World!===
 fifo str."Hello World!\n"
 
 loop {
 if ?str > 0 {
 print char ~str
 }else {
 break
 }
 }
===Reverse Cat===
Note: filo could be replaced with fifo to make this a normal cat program.
 filo input.sin
 
 loop {
 if ?input = 0 {
 print char '\n
 input.sin
 }
 
 print char ~input
 }
===Fibonacci Sequence===
 filo fib.0
 fib.1
 loop {
 println int ^fib
 filo tmp.(~fib)
 filo sum.(^tmp + ~fib)
 fib.(~tmp)
 fib.(~sum)
 del tmp
 del sum
 if ^fib > 100000 {break}
 }
===Label/Gotos===
 filo arg
 lbl pstr
 loop {
 if ?arg = 0 {break}
 print char ~arg
 }
 print char '\n
 ret
 
 arg.sin
 goto pstr
===Conditional Loop===
 filo num.nin
 if ^num = 0 {
 exit
 }else loop if ^num > 0 {
 if ^num = 0 {
 break
 }
 println int ^num
 num.(~num-1)
 }else {
 println int ^num
 }
===Deadfish Interpreter===
See here or here.
==External Links==
* Drift Interpreter Github
* Drift Documentation Index
Category:Languages 
Category:Stack-based
Category:2017
Category:High-level
Category:Implemented
Driftdown

Driftdown is an esolang created by User:Tommyaweosme.
== Mechanics ==
Bits go down until they reach one of four things.
 X
If a bit drifts down onto an X, it flips. A 0 turns into a 1 and a 1 turns into a 0.
 S
If two bits drift on each side of it, they switch places. A 01 turns into a 10, and a 11 turns into a 11.
 A
If two bits drift on each side of it, the and gate happens and the A releases a bit according to the and gate.
 N
If a bit drifts down onto an N, it splits on two sides of it.
A "v" can represent an input bit.
== Scripts ==
=== Or gate ===
 v v
 X X
 A
 X
=== Unfinished adder ===
This is not finished.
 v v
 N N
 S
 A X X
 A
 X
Dropsort

Dropsort is a highly efficient, one-pass esoteric algorithm for sorting that always returns a properly sorted list.
== Description ==
Dropsort goes through the list dropping items from the list that are out of place. This may seem undesirable, but the reader is urged to remember that lossy algorithms like this are well-accepted in computer science; for example, the JPEG algorithm.
== Algorithmic description ==
(In this description, list indices start at 1.)
* For each item x in the range from 2 to the length of the list
** If item x of the list is less than item x-1 on the list
*** Drop item x from the list
* Return the list
Category:Concepts