nyuuzyou/wikis huggingface dataset:
Diexponae

Diexponae is the first esolang in its computational class. It was made by User:BoundedBeans. It's not combinational logic, finite state, push-down, linear bounded, or Turing-complete, but something completely different. It is a Quadratic Bounded Automata.
==Syntax==
Symbols can be any number, and so can the state. The first line of the program should have five numbers. The first is the number of symbols, the second is the state, and the last three are the coefficients of a quadratic expression. The input size is plugged in into the expression to make the tape size, then the input is put directly to the right of the center, except if it doesn't fit there, in which case it will start on the left end. Input is taken as a number. If the program halts, the final state is outputted along with the full contents of the tape.
Each line should have a further five numbers, the first being the state, the second being the symbol, the third being the new state, the fourth being the new symbol, and the fifth being 1 for left, 2 for right, or 3 for halt. If a particular state/symbol combination cannot be found, the symbol and state are set to 1 and the pointer moves left.
==Examples==
Detect if the input is all ones:
Reaches the end of the string if true, outputs 2 if false
 2 2 0 1 0
 1 1 1 1 2
 1 2 2 2 3
 2 1 2 1 3
 2 2 2 2 3
Detect if the input is 1 2 3 4
Outputs 5 if true, 6 if false
 6 5 0 1 0
 1 1 2 1 2
 2 2 3 2 2
 3 3 4 2 2
 4 4 5 4 3
 1 2 6 2 3
 1 3 6 3 3
 1 4 6 4 3
 1 5 6 5 3
 2 1 6 1 3
 2 3 6 3 3
 2 4 6 4 3
 2 5 6 5 3
 3 1 6 1 3
 3 2 6 2 3
 3 4 6 4 3
 3 5 6 5 3
 4 1 6 1 3
 4 2 6 2 3
 4 3 6 3 3
 4 5 6 5 3
Category:Languages
Category:Unimplemented
Category:Cell-based
Dig

Dig is a language made by User:Emerald using a 2d grid, with a 3rd direction for the language’s namesake, Dig. It is inspired by Befunge-93 and ><>, but is no way related to DigFill, a similarly sounding language.
== Commands ==
There are 2 types of commands in Dig, Movement and Work. The main difference is that Work only can be executed underground, accessible by the dig command; meanwhile, movement is restricted overground.
=== Movement ===
Command	What it does
^ 	Points Mole up
> 	Points Mole right
' 	Points Mole down
< 	Points Mole left
# 	Rotates Mole to left when value beside it is 0, and right when 1. When it’s neither of those, keep straight.
$ 	Mole “digs” to the 3rd dimension, keeping its direction until it has moved the amount of tiles beside the $
@ 	Halt
=== Underground ===
Alpha-numericals and .,!?	When Mole passes over, memory is overwritten with value
% 	Overrides current value with space when 0, and newline when 1
= 	Overrides current value with a single character from user
~ 	Overrides current value with a single integer from user
: 	Outputs Value in memory then, replaces it with 0
+ 	Overrides current value with itself plus the number besides the +
- 	Overrides current value with itself minus the number besides the -
* 	Overrides current value with itself times the number besides the *
/ 	Overrides current value with itself divided by the number besides the /
; 	When Mole passes over, the “;” is given the Moles current value
Interpreters when faced with more than one value next to “#”, “$”, or “%” should prefer use up, right, down, left.
The mole is the pointer in the program, and starts from the top-left. It needs an arrow to guide its initial direction.
=== Memory storage ===
The Mole starts with a value of 0, but can be overwritten with 0-9 | a-Z
== Programs ==
=== Hello World ===
 >$H:e:l:l:$o:%:W:o:$r:l:d:!:@
 8 8 0 8
=== Cat (Never stops) ===
 >$=:'
 ^2 <
=== Truth Machine ===
 ' @
 :
 $1
 >$~;#
 2 >$+:'
 ^21 <
=== NAND Gate ===
A NAND gate by User:Bangyen.
 '2 > $~ >$ 1:@
 >$~;#@2 3
 > $~;#@2
 > $0:@
=== Boolean Function Conversion ===
A Python program by User:Bangyen to implement a given boolean function in Dig.
from inspect import signature
def convert(func):
 num = len(signature(func).parameters)
 total = 2 ** (num + 1) - 1
 lines = [ for _ in range(total)]
 pos = [total // 2]
 for j in range(num + 1):
 if j < num:
 for k in range(total):
 if k in pos:
 lines[k] += '>2$~;#@'
 else:
 lines[k] += ' ' * 7
 pos = [i + 2 ** (num - j - 1) for i in pos] + \
 [i - 2 ** (num - j - 1) for i in pos]
 for k in pos:
 lines[k] = lines[k][:-2] + '> '
 else:
 for k in range(2 ** num):
 arg_list = [0] * num + [int(i) for i in bin(k)[2:]]
 lines[k * 2] += f'>$3{func(*arg_list[-num:])}:@'
 lines[0] = '\ + lines[0][1:]
 return '\n'.join(k for k in lines).replace('> >', '> ')
For example, convert(xor) produces the code
' > $30:@
 > 2$~;#@
 > $31:@
>2$~;#@ 
 > $31:@
 > 2$~;#@
 > $30:@
== Interpreters ==
A Python interpreter by User:Bangyen.
A Lua interpreter by User:DeybisMelendez.
Category:LanguagesCategory:Two-dimensional languagesCategory:ImplementedCategory:2020Category:Cell-basedCategory:High-level
DigFiles

DigFiles is an esoteric programming language invented by User:Yamaserif.
==Specification==
* The folder will contain "0 or more folders" OR "0 to 1 file".
* The extension does not affect the processing.
* The ActionId is the order of execution in "ascending order in case of case-insensitive string comparison of ordinal numbers". (Corresponds to "StringComparer.OrdinalIgnoreCase" in C#.)
* The VariableId should be an integer value.
* The uninitialized variable value is a random number value from 0~99. (In this case, the calculation method of the random number value is not specified.)
（Note that '《' and '》' should not be written when actually filling in the form. ）
（The ".《arbitrary character》" can be omitted.）
folder name
notation 	meaning
《ActionId》.《arbitrary character》 	[Action block (definition)]A block of actions (executed in the same hierarchy in the order of the youngest action id)
《#ActionId》.《arbitrary character》 	[Action block (definition)]A block of actions (only executed in [Action block (call)]
file name
notation 	meaning
《Command》.《arbitrary character》 	[Action piece]Action
《%ActionId》.《arbitrary character》 	[Action block (call)]Calling action
File Contents
Multiple arguments separated by spaces (see "Command" for details)
When "《VariableId》" is an argument, the value set in the variable can be interpreted as "VariableId" by writing "《*VariableId》".
Command
Command	Variable 	Action
set 	《VariableId》 《value》 	assignment
copy 	《VariableId》 《VariableId》 	Copying Variables
in 	《VariableId》 	1 character input (utf-8)
out 	《VariableId》 	1 character output (utf-8)
loop 	《VariableId》 《VariableId》 《ActionId》 	Performs the specified action while the values of the two variables are not equal.
add 	《VariableId》 《VariableId》 	Add the second variable to the first variable
==Computational class==
This language is Turing-complete. Because Brainfuck's interpreter can be implemented.
==External resources==
*Github page
*interpreter
*example source(Hello,World!)
*example source(Brainfuck_interpreter)
Category:Languages
Category:2022
Category:Turing complete
Category:Implemented
Category:Non-textual
Dig 2

==NOT DONE==
Ima just go along with whatever I want for Dig 2, and steal from Dig.
==commands stolen from Dig==
Command	What it does
^ 	Points Mole up
> 	Points Mole right
' 	Points Mole down
< 	Points Mole left
# 	Rotates Mole to left when value beside it is 0, and right when 1. When it’s neither of those, keep straight.
$ 	Mole “digs” to the 3rd dimension, keeping its direction until it has moved the amount of tiles beside the $
@ 	Halt
=== Underground ===
Alpha-numericals and .,!?	When Mole passes over, memory is overwritten with value
% 	Overrides current value with space when 0, and newline when 1
= 	Overrides current value with a single character from user
~ 	Overrides current value with a single integer from user
: 	Outputs Value in memory then, replaces it with 0
+ 	Overrides current value with itself plus the number besides the +
- 	Overrides current value with itself minus the number besides the -
* 	Overrides current value with itself times the number besides the *
/ 	Overrides current value with itself divided by the number besides the /
; 	When Mole passes over, the “;” is given the Moles current value
Category:Languages Category:2020
Dig straight down like an idiot

Dig straight down like an idiot or DSDLAI is just Dig but you have 20% to 90% chance per program to fall into lava when using the dig command. Idiot.
==Example==
===Hello, world!===
>$H:e:l:l:$o:%:W:o:$r:l:d:!:@
 8 8 0 8
Side effect: 20% to 90% chance to cause an error because the digger is melted and vaporized.
==Implementations==
A Python interpreter by User:Bangyen.
Category:Languages Category:Implemented Category:Joke languages Category:2020 Category:Nondeterministic Category:Probabilistic
DigitDigitJump

DigitDigitJump is inspired from BitBitJump.
The VM operates on a string which contains digits and non-digits characters. Addresses are expressed in base 10, and usually space-separated. For example:
 123 4567 225 ABCDEFG 114
This string contains 4 addresses: 123, 4567, 225 and 114.
These addresses are addresses of characters in the string. For example, address 11 contains the character "5" of 225.
Addresses point to numbers which are made of several digits. Addresses don't have to point to the first character of a number. The number that corresponds to an address starts either at the address, if the address points to a digit, or at the next digit, and ends at the following non-digit character. Here is table showing what number you get depending on the address:
 Address Number
 ------- ------
 0 123
 1 23
 2 3
 3 4567
 4 4567
 5 567
 6 67
 7 7
 8 225
 9 225
 10 25
 11 5
 12 114
 13 114
 14 114
 15 114
 16 114
 17 114
 18 114
 19 114
 20 114
 21 114
 22 14
 23 4
Now, following the BitBitJump model of execution, each instruction is made of 3 addresses A B C. The character located at address A is copied to address B, then control jumps at address C.
An instruction should be able to modify its own jump address before jumping. Thus the copy operation must be completed before the jump address is read.
Even though it doesn't belong to the WordWordJump family, we'd need tables to do math. Sparse tables. For example
 Address Value
 ------- ----- 
 1XXYY0 XX + YY
 2XXYY0 XX - YY
 3XXYY0 XX * YY
 4XXYY0 XX / YY
 ... ...
If the result of an operation needs more than 9 characters, math addresses should end with 2 zeros (1 result every 100 character).
If there are only digits and white-spaces, it's the purest thing I can think of. Tao everywhere.
== See also ==
* BitBitJump
* ByteByteJump
Category: Cell-based
Category: Languages
Category: 2020
Category: Unimplemented
Category: Self-modifying
Category: OISC
DigitLang

== About DigitLang ==
DigitLang is a simple esoteric language by User:Arahis93.
== Syntaxis ==
There is only one command in the DigitLang. This is the number of the character in the ASCII table.
== How it work ==
When you enter the numeric number of a character in the ASCII table, the interpreter automatically translates its number into a character and displays it on the screen. And so it happens with every character.
== Code example's ==
Hello World example:
72 101 108 108 111 44 32 119 111 114 108 100 33
== Interpretators ==
Python 3.7 Interpretator: 
Category:Languages Category:Total Category:Unusable for programming Category:Output only Category:Implemented
Digital root calculator

A digital root calculator reads digits as input, calculates the digital root, and finally outputs the digital root digit (preferably with a UNIX newline). The digital root of a number is the reduction of the number to a single digit through repeated summing.
Writing a program to calculate digital root is useful for testing an esoteric programming language's overall performance and speed, as well as its functionality in input/output, memory, looping, and other things.
A digital root calculator is often quite easy to program, as well.
==Simple calculation==
Here's how the digital root is calculated for base 10:
Take any non-negative integer (can be zero as well). Add all of its digits together. If the result is bigger than 9, add all the digits of the result together to get another result. Continue this until the result has only one digit (0-9).
==Efficient calculation==
The digital root of n in a base b is equal to 1+((n-1) \bmod (b-1)). From this we can see that the digit root of a number can be calculated one digit at a time, by maintaining the digital root of the digits read so far. This is especially useful in languages without any built-in mathematical operators, such as Thue and Gravity.
==Example==
Digital root of 34758 is 9:
 Simple Efficient
 ------ ---------
 34758 1+(3-1)%9 = 3
 3+4+7+5+8 1+(3+4-1)%9 = 7
 7+7+5+8 1+(7+7-1)%9 = 5
 14+5+8 1+(5+5-1)%9 = 1
 1+4+5+8 1+(1+8-1)%9 = 9
 5+5+8 9
 10+8
 1+0+8
 1+8
 9
==See Also==
* Digital root calculator in Funciton
* Digital root calculator in Gammaplex
==External resources==
* Digital root calculator in Brainfuck
* Digital root calculator in Thue
* Digital root calculator in Gravity
* Digital root calculator in Revoledu (up to 65,513 digits)
* Digital root calculator in Malbolge
Category:Program forms
Dilemma

Dilemma is invented by User:A.
== Drafts ==
Maze language based on a searching algorithm (DFS) that does not remember the way it goes. There is still a mechanism available to make sure that the pointer doesn't go back to its previous position via blocking the previously went block and then removing the block once there is one instruction execution (4 turn-checks) away.
‼░░
└┬┘
█┼░
The direction priority is clockwise; i.e. it tries to go with a direction. If it fails, it turns right and tries again.
Atoms:
Atom █. This is where you start the maze. Direction is initially right. You also end the maze here by going back. 
Atom ┼. Direction splitter. You are allowed to pass through the current instruction direction, its reversed direction, and the direction above perpendicular. If you go through using a specific direction the direction will be deactivated, although you are still allowed to enter the cell.
Direction right: 
 ^
<─┴─>
Direction down: 
 ^
 ├─>
 v
Direction left: 
<─┬─>
 v
Direction up: 
 ^
<─┤
 v
Atom ░. NOPs, the PC is allowed to pass through in any direction.
Atoms └┬┘. Vertical direction splitter. Only allowed to pass through the pointed directions.
Atom ‼. PC is only allowed to pass through the opposite direction of the program counter.
Execution of this program
‼░░
└┬┘
█┼░
Executed:
█┼░┼┬┘░░‼░░┘┬└‼└┬┼█
a 12-byte program can compress a 19 byte program!
Category:Languages Category:2019 Category:Unimplemented Category:Two-dimensional languages
Dimensifuck

Dimensifuck is an esoteric programming language designed by Pikhq and avpx in 2006 that is based upon Brainfuck. Unlike "normal" programming languages, which can only flow in one dimension, going forward or back, Dimensifuck can flow in an infinite number of directions.
==Opcodes==
 + Same as in Brainfuck
 - Same as in Brainfuck
 > Same as in Brainfuck
 < Same as in Brainfuck
 . Same as in Brainfuck
 , Same as in Brainfuck
 = Increases dimension to be operated on.
 _ Decreases dimension to be operated on.
 ^ Starts moving positively on the dimension to be operated on if and only if the current cell is nonzero.
 v Starts moving negatively on the dimension to be operated on if and only if the current cell is nonzero.
==Addressing==
In Dimensifuck, the various dimensions of the code are expressed in a normal ASCII file by appending each line with a dimension address. One puts down the various addresses that the code is in for each dimension, each seperated by a period. First described is the y dimension, z dimension, and then all the dimensions above three.
An example:
 0.0___
 0.1___
 0.2___
 1.0___
 1.1___
 1.2___
 2.0___
 2.1___
 2.2___
The above would represent a 3x3x3 cube with the addressing scheme used in Dimensifuck.
==Examples==
===cat===
 0+=^ =vCat.
 1 _ _
 2 ^,.=vX
===Infinite adder===
 0+^+v
==External resources==
* Dimensifuck implementation 
* Python class that implements Dimensifuck (no longer points to anything useful)
* Small Python script that uses the above class. (no longer points to anything useful)
* The official specifications 
Category:Turing tarpits Category:Brainfuck derivatives Category:Implemented Category:Low-level Category:Languages Category:Cell-based Category:Multi-dimensional languages Category:2006
Diner

Diner is an Esoteric programming language created by User:Buckets in 2022, where you are at a Diner.
Commands 	Instructions
A number 1-9 	Pushes 1-9 on top of the stack.
Uh 	Adds the top two values.
Um 	Multiplies the top value with -1.
and 	Multiplies the top two values.
Also 	Swap the top two values.
, Extra pickles 	Duplicate the top of the stack.
, No cheese 	If = 1, then go to with Extra mayo, Else go to , One coffee on the side.
with Extra mayo 	Noop.
, One coffee on the side	Noop.
, Make it Bigger 	pops off the top of the stack and Prints it in ASCII.
Make It bigger 	pops off the top of the stack and Prints it in ASCII pushes a 0 on top of the stack.
A Romantic dinner 	Pushes the Input value to the top of the stack.
That's all. 	Ends the program.
Cat program:
 A Romantic dinner, Make it Bigger That's all.
"Hello, World!" Program:
 A number 8, A number 9 and Make It bigger A number 9, A number 1
 Uh A number 9, A number 1
 Uh and A number 1 Uh, Extra pickles, Make it Bigger
 A number 7 Uh, Extra pickles, Extra pickles
 , Make it Bigger, Make it Bigger A number 3 Uh, Make it Bigger A number 9
 , A number 2 Uh A number 4 and Make It bigger A number 8 Uh A number 4 and Make It bigger
 A number 9 Uh A number 6 Uh A number 2 and A number 1 Um Uh A number 3
 and Make It bigger
 A number 9 Uh A number 1 Uh A number 9, A number 2 Uh and A number 1
 Uh, Extra pickles, Make it Bigger A number 3 Uh, Make it Bigger
 A number 9,
 A number 3 and A number 4 and Make It bigger, A number 5 Uh, A number 5
 and A number 4 and Make It bigger
 A number 9, A number 2 Uh, Uh A number 3 and
 Make It bigger That's all.
Category:Languages
Category:Joke languages
Category:2022
Category:Stack-based
Dip

Dip is a stack-based Turing tarpit created by User:D. 
== Commands ==
Command	Behavior
0 	Push 0.
' 	Increment TOS.
; 	Pop TOS. Append it to the bottom of the stack.
( _b_ )	While loop. (See below)
=== While loop ===
* While (pop stack as N) != 0:
:* push N-1
:* run _b_ as dip code
== Examples ==
=== Predecessor ===
A plain (0) would pop the stack with a 0 input.
So we'll need to sneak a 0 value under the stack:
0;(;)
=== Add ===
This just does a bounded for loop, which increments the 2OS.
(;';)
=== Multiply ===
0; 0; (;(;';';;);0;;) ()()
== Computational class ==
Dip is Turing-complete. One way to demonstrate this is to compile The Waterfall Model to it.
We'll compile the following program to Dip:
[[10, 3, 3, 3],
 [ 1, 3, 0, 6],
 [ 2, 0, 6, 3],
 [ 3, 6, 3, 0]]
The waterclocks are named A, B, and C, respectively.
First, initialize the waterclocks:
0' 0 0'
This pushes C B A onto the stack.
Next, we use the following structure to simuate the outer infinite loop:
0' (() ... 0')
... is where we put the individual implementations of the waterclocks.
=== Compiling individual waterclocks ===
We use a ( ... ) loop to simulate an individual waterclock. Here, we simulate the second row of the program.
 (; 0' 0 ;; [;]
Walkthrough:
 (;
This shifts A-1 to the bottom of the stack. (Configuration: A C B)
 0' 0
Push the value of the flag (initially 1) and the preserved A counter, respectively. (Configuration: A C B _flg_ _A'_)
 ;;
Move the flag and the preserved A counter to the bottom.
 [;]
Use #_of_counters - 1 ;s to make A float to the top of the stack. (In this case, two ;s.)
For the rest of this implementation, [;] means #_of_counters - 1 ;s.
=== Inner loop 1: The flag & A' loop ===
Then, we use a repeat loop to 1) set flag to 0 and increment our preserved A counter, respectively:
 (; ()0; '; [;])
Here's a walkthrough of what each part does:
 (;
Decrement the value of A, and move it to the bottom of the stack.
 ()0;
() discards one value on the stack (i.e. decrements it until it's 0, after which the value is popped). Then we push 0, which sets our flag to 0. Last, we shift the value to the bottom of the stack.
 ';
Increments A', and shift it down.
 [;] )
#_of_counters - 1 ;s, to shift A to the top of the stack again.
=== Inner loop 2: The actual incrementing ===
This part is a bit trivial. We were left with the configuration
 C B A' _flg_
at the end of our previous loop, so we just need to repeat the incrementing process _flg_ times to simulate the full functionality of the zeroing trigger.
Since we're compiling the first waterclock, here's an implementation:
(;;;';)
Self-evident, so I won't explain it.
=== End of outer loop ===
We need to ensure that our outer loop is exitted after the conditional is done, so we do this:
 0)
To switch to the next waterclock (after which you can chain another waterclock implementation), use ;.
== External Resources ==
* Official Interpreter
Category:Languages
Category:2023
Category:Implemented
Category:Stack-based
Category:Turing complete
Category:Turing tarpits
Dir

dir is an esolang made by user:CCeriseGD in 2024 based around files.
== Programs ==
dir programs are directories with code and other files inside them. Commands start being executed from the file code.dir at the root of the directory.
== Syntax ==
Commands have the following format:
command [file1 ...] [>[>] outputFile]
Also, anything after a # is a comment, and empty lines are ignored.
For each line, the command will be called with the contents of the files passed to it.
File paths can only have alphanumeric characters and -_./. Additionally, there are special file names starting with $; a $ followed by a number (starting at 0) is an argument passed to the interpreter (so $0 is the first argument passed). $# is the amount of arguments passed (# here doesn't start a comment).
If a line ends with > outputFile, the output of the command will be written to the output file. If it uses >> instead, the output will be appended to the end of the file. Otherwise, the output will be written to stdout.
== Commands ==
=== cat <file1> ... ===
Concatenates all the files passed (any amount) and outputs the result.
=== cd <path> ===
If <path>/code.dir exists, goes to <path> and starts executing it, otherwise does nothing.
Note that cd some/path won't go to some/path/code.dir; it will read the file at some/path and use that as the path to go to.
=== rm <path> ===
Removes the file or directory at <path>, if it exists.
Like cd, rm some/path won't delete some/path; it will read the file at some/path and use that as the path to delete.
=== read ===
Prompts the user for input, then outputs that.
=== len <file> ===
Outputs the length of <file>. If the file doesn't exist, outputs -1.
=== head <size> <file> ===
Outputs the first <size> bytes of <file>.
=== tail <size> <file> ===
Outputs the last <size> bytes of <file>.
=== add <file1> ... ===
Outputs the sum of all the files passed (any amount).
=== sub <file1> <file2> ===
Outputs <file1> - <file2>
=== mul <file1> ... ===
Outputs the product of all the files passed (any amount).
=== div <file1> <file2> ===
Outputs <file1> / <file2>
=== eq <file1> <file2> ===
Outputs 1 if both files are the same, or 0 otherwise.
Note that the files will be parsed as numbers if possible, so if file1 is 1 and file2 is 1.0, eq file1 file2 will output 1.
=== lt <file1> <file2> ===
Outputs 1 if <file1> is less than <file2>.
=== gt <file1> <file2> ===
Outputs 1 if <file1> is greater than <file2>.
=== ord <char> ===
Outputs the Unicode codepoint for <char>.
=== chr <ord> ===
Outputs the Unicode character for codepoint <ord>.
== External resources ==
Github repo (implementation in Python and a few example programs)
Category:Languages
Category:2024
Category:Unknown computational class
Category:Implemented
Category:Self-modifying