nyuuzyou/wikis huggingface dataset:
DSL

= Work in Progress! =
DSL, or Damn Small Language, (Pronounced like Diesel) is a programming language created to be as small as possible, and to be usable for as many code golf challenges as possible.
== Data Structures ==
DSL has a tape big 100000 cells and a stack, big 256 cells.
A cell can hold a single data type (i.e. Integer/Character/Float), an array of such, or a structure.
=== Structures ===
In DSL structures can be created to contain multiple values, even of different types.
== Commands ==
DSL's commands are stored as 8-bit or 16-bit words in a file; because of the sheer quantity, they are grouped into classes.
=== Class A Commands ===
These command do something with the stack and/or its values.
They are:
Bits 	Mnemonic 	Description
010tttvv	PUSH t, v 	Pushes new value of type T with default value V.
011tttvv	OVERWRITE t, v	Overwrites the value on the top of the stack with a new value; see PUSH.
1000tttt	PUSHZ t 	Pushes new value of type T with an empty array, 0, or an empty string, depending on the type.
000tttvv	INSERT t, v 	Acts like PUSH, but instead inserts the new element into the element currently on top of the stack if it is an an array.
001nnnnn	INDEX n 	If the element on top of the stack is an array, it pushes its nth element.
10010000	INDEXW 	Pops an integer from the stack, indexes an array in the top of the stack with the popped integer, and pushes the resulting value.
100101nn	SWAP n 	Swaps the element on top of the stack with the nth element.
=== Types ===
A 3-bit type value can be translated into a type using this table:
 	x00 	x01 	x10 	x11
0x	Int 	String 	Float 	Structure
1x	Int Array	String Array	Float Array	Structure Array
=== Default Values ===
Depending on the type, there is a different table of default values:
 	00 	01 	10 	11
Int 	1 	256 	100 	-1
String	"A"	"a" 	" " 	"\x80"
Float 	0.1	3.14	2.71	6.28
Category:Languages Category:Golfing language Category:Cell-based Category:Stack-based Category:Works-in-Progress
DUCK

Duck is a joke language made by user:Hurricane996. The result is based on the interpreter, not the code. When you write an interpreter, any program does whatever the interpreter writer wants. Duck interpreters are named by what they do.
== Hello World ==
Any program you want, provided you are using the hello-world Duck interpreter
==Quine==
Any program you want, provided you are using the quine Duck interpreter
==99 Bottles==
Any program you want, provided you are using the 99-bottles Duck interpreter
Category:Joke languages Category:Languages
DWIM

DWIM (Do-What-I-Mean) is a joke esolang invented by User:Ttulka. It features only a single instruction dwim that executes whatever the programmer has in mind.
DWIM is inspired by the hacker jargon expression of the same name, which implies correcting any mistakes the programmer has made and ensuring the code does the right thing.
== Computational class ==
DWIM can theoretically perform all computational tasks, making it Turing-complete. However, an interpreter for DWIM would need to read the programmer's mind, which is currently an uncomputable challenge.
With the development of artificial superintelligence and nanotechnology, this issue might eventually be solved, potentially demonstrating that DWIM is indeed computable and highly useful.
== Examples == 
Solving any popular problem in DWIM is very easy:
=== Hello, world! ===
 dwim
=== 99 bottles of beer ===
 dwim
=== Quine ===
 dwim
=== Fibonacci sequence ===
 dwim
=== Factorial ===
 dwim
=== Cat program ===
 dwim
=== Mandelbrot set ===
 dwim
=== Bootstrap ===
 dwim
=== Truth-machine ===
 dwim
=== Infinite loop ===
 dwim
=== Palindrome ===
 dwim
== Software development ==
It is also possible and fairly easy to build more complex software in DWIM:
=== Brainfuck compiler ===
 dwim
=== Perl interpreter ===
 dwim
=== Java virtual machine ===
 dwim
=== Linux kernel ===
 dwim
=== Windows 95 ===
 dwim
=== Castle Wolfenstein ===
 dwim
=== AlphaGo ===
 dwim
=== Google search engine ===
 dwim
=== Bitcoin ===
 dwim
=== Internet ===
 dwim
== External resources ==
* DWIM in the on-line hacker jargon file
Category:Languages Category:Joke languages Category:Uncomputable Category:Unusable for programming Category:2024 Category:Pseudonatural
DZZZZ

DZZZZ is an esoteric programming language invented by User:Zzo38. He has forgotten when, but the interpreter source's datestamp suggests that it was in 1994 or earlier.
All program flow is diagonal.
==Examples==
This program turns the input backwards and then outputs it.
 
 @ 
 o 
 - @ | 
 . | - 
 . v
 . ?
This program types out the entire alphabet.
 
 $ | | . |
 $ @ o . . - ? |
 $ = = = - @ < @
 $ * * = = = $ $ - - @
 * * * = @ $ $ $ $ @
 * = @ $ $ $ $ -
 = @ $ $ @
 = @ @
 = @ @
 | = - @
 @ = @ @
 - - @
 . @ @
 _~ @ @
 @ . @ @
 - , @ @
 @ @ @ @
 @ | @
 __@_~_________________________
 |
 
==External resources==
* http://zzo38computer.org/esoteric/dzzzz/ Implemented in QBASIC
Category:Languages
Category:Two-dimensional languages
Category:Unknown year
Category:Implemented
Danica

Danica is a programming language made by User:Oklomsy
Danica uses a Python Interpreter which can be found further down this page.
== Input System ==
Danica is special, It uses F's instead of readable words.
Letters won't be encoded by the interpreter, the developer has to do it manually.
Each letter is seperated with a space
a = f
b = ff
c = fff
d = ffff
e = fffff
f = ffffff
g = fffffff
h = ffffffff
i = fffffffff
(And so on.)
== Syntax ==
Danica has five commands
Print, Compare, Read, Greater and Small
Print prints to the console, and compare checks if two strings are equal, read reads a file and prints it to the console, Greater checks if something is greater than and smaller does the opposite. 
They all must be encrypted, check the Input System section for more information.
== Programs ==
Hello World Program:
 ffffffffffffffff ffffffffffffffff ffffffff ffffffffffffff fffffffffffffffffff hello world!
== Interpreter ==
New Interpreter: here (Recommended)
Old Interpreter: here (Not Recommended)
Category:Joke languages
Category:2020
Category:Languages
Daniel B. Cristofani

Daniel B. Cristofani is a known brainfuck programmer in esoteric circles. He has won several brainfuck programming competitions and written several very space-optimized brainfuck programs. In his own words, he is:
:Interested in ultra-minimalistic foundations for complex behavior (e.g. the brainfuck programming language, cellular automata, go). ( 3.8.2007)
He has also invented the Wait and egaharjb languages.
==External resources==
*daniel b cristofani, his web page
*some brainfuck fluff, his brainfuck page
Category: People
Darmok

Darmok is a programming language based off of the episode of Star Trek by the same name. It is based entirely on metaphor and references to folklore and mythology. The syntax is yet to be defined, but will likely be very vague, with many ways to write the same thing (reflecting the variety of myths that could be referenced).
The language will be largely dependent on libraries to define what different patterns mean. The libraries will map phrases to actual code to be executed when they are called. Phrases may come with arguments, but it is required that they be optional (with a logical default.)
Here is an example of what the code might look like:
 From the legend of Jesus from TheBible: //Import the library %libir%/TheBible/Jesus.ext
 Shout from the mountain tops "Hello, world!" //Print "Hello, world!"
This is, of course, just an early speculative example. Also, not as metaphor-filled as the final code would be.
Darmok is an open language, meaning anyone is permitted to contribute to this page (which is the primary specification.)
This page needs to be cleaned up.
Category:Languages
Category:Thematic
Dash-end

dash-end is a simple programming language using some unicode characters
It has a programm counter and walks down the lines and executes their code
==Commands and Syntax==
Code 	Meaning
øN X 	appends / overwrites a line with the number N with the statement X
¡V X 	(statement) sets variable V to the expression X
¢V 	(expression) the content of the variable V
N 	(expression) the float N
-þ 	(statement) exits the programm (requiered)
¤N 	(statement) go to the line N
--# V 	(statement) prints the value of the expression V
#-- 	(expression) float input
? A B N	(statement) goes to the line number N if expression A is equal to expression B
==Examples==
Truth machine:
 ø10 ¡a #--
 ø30 ? ¢a 0 50
 ø30 ? ¢a 1 35
 
 ø32 -þ
 ø35 --# ¢a
 ø40 ¤35
 
 ø50 --# ¢a
 ø60 -þ
==Implementations==
interpreter written in V
Category:LanguagesCategory:Implemented
Dashes

Dashes is an esoteric programming language created by User:DigitalDetective47 where all instructions are comprised of dashes. It canonically uses the extension .dash for scripts.
== Memory ==
There are two main memory locations that programs can access. One of these areas is the stack, which can contain an arbitrary number of integers of arbitrary size. If the program attempts to pop from the stack when it is empty, the program crashes. The stack starts empty. The other is the tape, which is infinite in both directions and can contain integers of arbitrary size. It starts filled with 0s. The tape head is a location on the tape, and the current cell is the cell that the tape head points to.
== Commands ==
Commands are executed in order, except for the horizontal bar and horizontal line extensions, which exhibit the same flow behavior as a while loop in most typical languages.
 All commands
Character	Name 	Code point	Description
- 	Hyphen‐minus 	U+002D 	Push 1 to the stack.
‐ 	Hyphen 	U+2010 	Get a character of input from the user and push its Unicode value to the stack. Push −1 if the input stream is exhausted.
‑ 	Non‐breaking hyphen	U+2011 	Pop the top value from the stack and print its Unicode character. If the value is less than 0 or greater than 1114111, crashes the program.
‒ 	Figure dash 	U+2012 	Pop the top value from the stack and discard it.
– 	En dash 	U+2013 	Move the tape head one cell left.
— 	Em dash 	U+2014 	Move the tape head one cell right.
― 	Horizontal bar 	U+2015 	Pop the top value from the stack. If it is 0, jump forward past the matching horizontal line extension.
⁃ 	Hyphen bullet 	U+2043 	Pop the top value from the stack, add the value of the current cell, and push the sum to the stack.
− 	Minus sign 	U+2212 	Negate the top value of the stack. If the stack is empty, the program crashes.
⎯ 	Horizontal line extension 	U+23AF 	Jump backward to the matching horizontal bar.
⸺ 	Two‐em dash 	U+2E3A 	Pop the top value from the stack and write it to the current cell.
⸻ 	Three‐em dash 	U+2E3B 	Push the value of the current cell to the stack.
All other characters are treated as comments. The program terminates without error once the end of the source code is reached.
== Examples ==
=== Infinite loop ===
 -―-⎯
=== Cat program ===
 ‐⸺-⁃—⸻–-⁃―⸻‑‒-—⸻–⎯―‐⸺-⁃—⸻–-⁃―⸻‑‒-—⸻–⎯⎯
== Computational class ==
It is possible to convert any brainfuck program into a Dashes program, making Dashes Turing-complete.
 brainfuck to Dashes
brainfuck command	Dashes equivalent expression
< 	–
> 	—
+ 	-⁃⸺
- 	-−⁃⸺
. 	⸻‑
, 	‐⸺
[ 	⸻―
] 	⸻⎯
== Implementations ==
* Official interpreter
Category:LanguagesCategory:2021Category:Cell-basedCategory:Stack-basedCategory:Turing completeCategory:ImplementedCategory:Low-level
Dat is Dis

Dat is Dis (DiD)- is a version of Dis created by User:ChuckEsoteric08 which has infinite memory.
==Changes==
Now each address contains unbounded amount if trits, all of which are initially 0. Each conmand would only access a finite amount of trits, number of which is diffirent for each interpreter. That number should be in range from 10 to 11111. After every fifth instruction is executed, that number is then multiplied by 15
Category:Languages Category:Unknown computational class Category:Unimplemented
Data

Data is a programming language i made that uses only json-like data and dot notation to make logic
== The Two Things ==
=== Data ===
Data is lazy evaluated
 a = {val: "hi", op: "hello", other: "idk", these: "names don't matter until you use dot notation"}
 b = {some: "thing", yay: "ok"}
=== Dot ===
 a = {thing: "yay"}
 a.thing #yay
 not = {
 true: false
 false: true
 }
 true = {
 val: true
 not: false
 and: {true: {true: true, false: false}, false: {true: false, false: false}}.(this.val)
 }
 false = {
 val: false
 not: true
 and: {true: {true: true, false: false}, false: {true: false, false: false}}.(this.val)
 }
 true.and.true #true
 not.true #false
Category:Languages Category:Total Category:Unusable for programming
DataComs

This is a language that has data in the command space, here’s how it works
== How ==
There are commands that can edit the code
 WRITE $3 SUCCESS
 NOOP N N
 !the line above this will turn into “SUCCESS N N”
There are ones that read
 OUTPUT $3 N
 HI N N
 !this outputs “HI”
And more
 RUN $2 OUTPUT
 $1 N N
 !this outputs “RUN”
Category:Languages
DateFuck

DateFuck is an esolang designed by John Ohno (User:Hakware) in 2007 for use in creating text-based dating sims and text adventures. It is probably Turing-complete, and consists entirely of printing, xor, and implied jumps. It contains no instructions, and has no data storage, save from the program counter itself. Despite this, it is capable of being used to create rather complex programs. It is also interactive, with each jump requiring user input, though it would be possible to pipe two such programs into one another in order to create one self-sufficent program.
It was rewritten in 2010 with some semantic modifications, forming DateFuck-2.
==README for DateFuck-2==
 DateFuck is a programming language designed for writing text-based dating sims.
 It is not useful for much else.
 
 Syntax:
 
 There is one internal variable, initially set to one. Each non-indented line
 is a line of dialogue/info. Labels are numbers representing the state necessary
 to go to that piece of dialogue, followed immediately by a colon. It is in
 hexadecimal. Indented lines are options, preceeded with labels which are xor'd
 with the internal state variable if that option is chosen. The list of options
 terminates at the next non-indented label.
 
 Example:
 
 1:What do you want to say?
 2:Hello World!
 5:Hello Sailor!
 1:Exit
 3:Hello World!
 3:Exit
 4:Hello Sailor!
 4:Exit
==README for the original DateFuck== 
 DateFuck is a programming language designed for writing text-based dating sims.
 It is not useful for much else.
 
 Syntax:
 
 There is one internal variable, initially set to zero. Each non-indented line 
 is a line of dialogue/info. Labels are numbers representing the state necessary 
 to go to that piece of dialogue, followed immediately by a colon. It is in 
 hexadecimal. Indented lines are options, preceeded with labels which are xor'd 
 with the internal state variable if that option is chosen. The list of options 
 terminates at the next non-indented label.
 
 Example:
 
 0:What do you want to say?
 	1:Hello World!
 	2:Hello Sailor!
 	0:Exit
 1:Hello World!
 	1:Exit
 2:Hello Sailor!
 	2:Exit
== Status ==
There is a compiler available, which works. One known bug, however, is the fact that every program must start with an empty line. It compiles to C.
== Notes ==
It has been brought to light recently that DateFuck code is in fact valid YAML, despite YAML not being capable of interpreting the structure as it exists in DF or compiling it to C. This may make it possible for future DF compilers to use a YAML parser as a frontend, though that is not really necessary as the FLEX parser in the existing compiler is a mere 47 lines at time of writing.
== External resources ==
* DateFuck compiler tarball (link broken, tarball lost)
* DateFuck-2 compiler tarball
Category:Languages
Category:2007
Category:Implemented
Category:Unknown computational class
Dathanna

Dathanna (Irish for "colors") is an esoteric programming language for Apple II emulators.
== Rationale ==
Most classic computers from the 1980s have emulators so old code can run on modern hardware. Many of these emulators
support running as quickly as possible, often several orders of magnitude faster than
the original machine. Dathanna takes advantage of this speed to make tolerable an implementation that would otherwise
be far too slow on the original hardware.
Dathanna is featured in Chapter 16 of the book Strange Code: Esoteric Languages That Make Programming Fun Again (No Starch Press, 2022).
== Language Description ==
Dathanna programs are constructed from pairs of colored blocks stacked one on top of the other. The top color specifies the command
and the bottom a modifier for that command. Programs are arranged on the screen and execute from left to right, top to bottom. 
Arithmetic operations use a stack with colors doing double-duty as commands or numbers. The stack supports floating-point numbers
but only the integers 0 through 15 can be pushed on the stack directly.
== Commands ==
Commands are a top color with the lower color a modifier.
 
Value	Color 	Top 	Bottom
0 	black 	HALT 	Terminate program (any)
1 	magenta 	PUSH 	push number to top-of-stack (TOS) (any)
2 	dark blue 	INPUT 	number to TOS (orange)
 	 	 	character to TOS (light green)
3 	purple 	COMPARE	< (gray 1)
 	 	 	<= (medium blue)
 	 	 	> (light blue)
 	 	 	>= (brown)
 	 	 	= (orange)
 	 	 	<> (gray 2)
 	 	 	(r c -- ) branch (purple)
 	 	 	(r c f -- ) if (aquamarine)
4 	gray 1 	STACK 	dup (magenta)
 	 	 	drop (dark blue)
 	 	 	swap (purple)
 	 	 	rot (gray 1)
 	 	 	over (medium blue)
 	 	 	nip (light blue)
7 	light blue 	PRINT 	TOS as number (orange)
 	 	 	TOS as character (light green)
9 	orange 	MATH 	+ (black)
 	 	 	- (magenta)
 	 	 	* (dark blue)
 	 	 	/ (purple)
 	 	 	ˆ (dark green)
 	 	 	sqrt (gray 1)
 	 	 	sin (medium blue)
 	 	 	cos (light blue)
 	 	 	tan (brown)
 	 	 	abs (orange)
 	 	 	exp (gray 2)
 	 	 	log (pink)
 	 	 	int (light green)
 	 	 	rnd (yellow)
 	 	 	atn (aquamarine)
 	 	 	mod (white)
12 	light green	STORE 	( v idx -- ) (any)
13 	yellow 	FETCH 	( idx -- v) (any)
14 	aquamarine 	PUTV 	TOS to var number (any)
15 	white 	GETV 	var number to TOS (any)
== Examples ==
=== Hello, world! ===
=== Random Pi ===
=== Gnome Sort ===
== Computational class ==
Like Befunge-93, Dathanna programs are restricted to one screen. Therefore, Dathanna is not Turing complete.
== Implementations ==
* Official interpreter, disk image, and documentation
Category:LanguagesCategory:2022Category:Cell-basedCategory:Stack-basedCategory:Implemented
David Madore

David Alexander Madore, born on 3rd August 1976, is a French mathematician. He designed the following languages:
* Legasm
* SIMPLE (preprocessor)
* Unlambda
* Юᓂ곧⎔
* Amicus
* Amicus Severus
* Hyperamicus
* (0) and its extensions (1), (2), (3), (0) with arrays, (1) with arrays, (2) with arrays and (3) with arrays, all documented in the (0) article.
He has won IOCCC 2012 by writing clear non-obfuscated code.
==External resources==
*David Madore's personal home page
Category:People
David Morgan-Mar

David Morgan-Mar is a true hero in the esoteric programming language community. Well, not really, but he is responsible for the following languages:
* BIT
* Chef
* Haifu
* HQ9++
* Ook!
* Petrovich
* Piet
* Whenever
* ZOMBIE
He also writes the webcomics Irregular Webcomic!, Darths & Droids (with his friends) and Planet of Hats.
==External resources==
* DM's Home Page
* DM's Esoteric Programming Languages
* Irregular Webcomic!
* Darths & Droids
Category: People
Daydream

Daydream is an esoteric programming language invented found by User:Hakerh400 in 2022.
== Overview ==
Let A be an infinite list of natural numbers. The initial (0-th) element is 1. The n-th element is equal to the sum of all previous elements that are not divisible by n.
Source code consists of a single natural number n. The output are the first n elements of sequence A, separated by spaces. Input is ignored.
== Background ==
The author saw the specification of this language in a dream. Despite the language being useless, the author decided to document it anyway.
== Terms of the sequence ==
Access Daydream/Terms to see the first 100 terms of the sequence.
== Implementation ==
Since the language is pointless, here is a pointless implementation in Haskell:
 i = id
 k = const
 (#) = flip
 infixr 9 #
 infixr 9 !
 f g = g (f g)
 (!) a b c = a c (b c)
 t a b c = if a then b else c
 
 main=getLine>>=(putStrLn.unwords.map show.f(((take.fromIntegral)#).
 ((map.(((#).((!)(t.(>0)).(((!).((#)((.).((sum.).filter.((>0).).
 (mod#)))))#i)))#1))#[0..]))).(read::String->Integer)
Category:Languages
Category:2022
Category:Implemented
Daydream/Terms

:Go back to Daydream
 1
 0
 1
 2
 4
 8
 16
 32
 8
 72
 144
 288
 72
 648
 1296
 2592
 816
 5184
 888
 12072
 24144
 48288
 96576
 193152
 72
 386376
 772752
 1535784
 3081288
 6162576
 12325152
 24650304
 11979040
 61279648
 121399352
 243958648
 487906928
 975823336
 1463740632
 3415388192
 6818797344
 13649573728
 27252928136
 54552075592
 109104151184
 218208302368
 436416604736
 872833209472
 1738803338336
 3484469757280
 6968939514560
 13937877869176
 27875756898296
 55751513796592
 111501563842832
 223004591436016
 444277119807496
 890286302679528
 1780572605359056
 3561145210718112
 7122290421436224
 14244580842872448
 28266157094308880
 56755318780053776
 92135488081524896
 205646125641632448
 411292251283264896
 822584502566529792
 1616902848037590760
 3262071853170650344
 6524143706341300688
 13048287412682601376
 26096574823901451752
 52193149649266654504
 104329432478189411512
 208715731776722720520
 391334878275646810520
 808766341829092251560
 1617532683658184503120
 3235065367316369006240
 1617504407047668943360
 8087635141678943205488
 16175178147871268636432
 32350448431230618797760
 64700896862461191376200
 129401765458765334662840
 258803559169749885765384
 517607118353437649399944
 1035191402203903104247480
 2070014304032502754701064
 4140211227211504435027912
 8280631170154785592776344
 16561262283554252405498912
 33122524623863823591051600
 66245049247727647182103200
 132490098495444840954934560
 66212697334845513740732640
 331192894325745649059873600
 592032880089434279943986648
 1254418668740925578063733848
Category:Examples