nyuuzyou/wikis huggingface dataset:
DoFor

==DoFor==
DoFor is an esoteric programing language.
It is special because it uses the same command for input, output and variables.
se also: https://esolangs.org/wiki/BullScript
==Commands:==
 Commands
Command 	Use
DO Action Type Value_FOR Variable;	does Action using Value (that has the type Type) to variable
IF(C){CODE}; 	does CODE if C is true
LABEL X; 	sets the label X
GOTO X; 	goes to the label X
===Actions:===
a command for reference:
DO [Action] [Type] [Value]_FOR [Variable]
(Just to clarify, the square brackets are not supposed to be around 
the variable names and values in your code,
it's just so you don't get confused when reading my instructions)
 SET sets [Variable] to [Value]
 ADD adds [Value] to [Variable]
 IMPORT imports the variable with the name [Value] from the BullScript file with the name [Variable]
===Types:===
a command for reference:
DO [Action] [Type] [Value]_FOR [Variable]
 INT sets/adds [Value] to [Variable] as an integer
 STR sets/adds [Value] to [Variable] as a string
 VAR sets/adds the variable with the name [Value] to [Variable]
 CON sets [Variable] to the boolean value of [Value] (there is DO SET CON VAR1=VAR2_FOR C; and DO SET CON VAR1<VAR2_FOR C;)
===Outputing:===
To give output you save your data to the
variable OUTPUT. when there is data in the variable OUTPUT
it will be printed and the OUTPUT variable will become empty again
===Inputing:===
to get input you do it like this:
 DO Action Type INPUT_FOR Variable;
the input will be taken as the type you put in the place of Type.
==Example programs:==
===cat program===
 LABEL LOOP;
 DO SET STR INPUT_FOR OUTPUT;
 GOTO LOOP;
a cat program takes input and prints it out again
===truth machine:===
 DO SET INT INPUT_FOR IN;
 DO SET INT 1_FOR Check;
 DO SET CON IN=Check_FOR C;
 IF(C){
 LABEL LOOP;
 DO SET INT 1_FOR OUTPUT;
 GOTO LOOP;
 };
 DO SET INT 0_FOR OUTPUT;
a truth machine checks if the input is a 1 and if it is
it outputs ones forever and if it's 0 it outputs a single 0
==functions:==
===creating a function:===
 DO SET INT 1_FOR DONE;
 DO SET INT 2_FOR CHECK;
 DO SET CON DONE<DONE_FOR C;
 LABEL FunctionName;
 IF(C){
 
 your code here
 
 DO SET CON DONE<DONE_FOR C;
 DO ADD INT 1_FOR DONE;
 GOTO CALL;
 };
all you need to do is replace "your code here"
with the code that you want in the function
and FunctionName with the name you want your function
to have.
===using a librairy:===
in the libExample.BS file:
 ¤h65#
 ¤hello10#
in the DoForExample.txt file:
 DO IMPORT VAR h_FOR libExample.BS;
 DO SET VAR h_FOR OUTPUT;
the output:
 11
===calling a function:===
 LABEL CALL;
 DO SET CON DONE<CHECK_FOR A;
 IF(A){
 DO SET CON DONE=DONE_FOR C;
 GOTO FunctionName;
 };
 DO SET INT 1_FOR DONE;
all you need to do here is replace FunctionName with the name
of the function you want to call. if your function uses any variables
then you should probably define them in the IF(A) code block
===interpreter download:===
https://github.com/TinyGuy32/DoFor
Category:Languages Category:Implemented
DoWhileFuck

==Commands==
DoWhileFuck operates on an array of memory cells, each initially set to zero. There is a pointer, initially pointing to the first memory cell. The commands are:
Command	Description
> 	Move the pointer to the right
< 	Move the pointer to the left
+ 	Increment the memory cell at the pointer
- 	Decrement the memory cell at the pointer
. 	Output the character signified by the cell at the pointer
, 	Input a character and store it in the cell at the pointer
[ 	Do nothing
) 	Jump back to the matching [ if the cell at the pointer is nonzero
==Examples==
===Cat program===
 [,.)
===Infinite loop===
 +[)
Category:Languages
Category:Joke languages
Category:Brainfuck derivatives
Category:2023
Category:Unimplemented
Do loop until failure

Do loop until failure, or a D-LUF loop is a form of esoteric control flow in programming languages which is essentially a do..while loop where the condition is whether or not an exception is raised in the body. This provides an esoteric method of design, where one must intentionally crash the script to exit a loop.
== Meaning ==
Do loop until failure loops are, essentially, while loops without a condition. The while loop repeats until the code in its body throws an exception.
=== Crash Handling ===
Crashes are handled similarly to a Pythonic TRY statement; they don't terminate, or even get thrown.
== Examples ==
An example of a language supporting the D-LUF loop is the esoshell Getchl, which comes bundled with the Walrus Operating System. Getchl contains a command, @, named REDUCE, which repeatedly executes the previous command until it fails. Some examples of this loop's usage are:
* +@ (add-reduce): Sum the stack, leaving only the sum of all items on the stack on the stack. This can be done with any operation.
* $@ (drop-reduce): Clear the stack
* ,@ (input-reduce): Get input character and push on stack until EOF.
== Implementations ==
In Python:
 while True:
 try:
 doSomething()
 except:
 break
Ideal:
 do {
 doSomething();
 } until fail
== See Also ==
* Do loop until failure or condition else
Category:Language constructs Category:Concepts
Do loop until failure or condition else

Do loop until failure or condition else is an esoteric language construct and form of loop that is REALLY complicated. In the loop, there are two bodies (the main body and the else body) and two conditions (a cap condition and the main body itself.)
== Meaning ==
Consider the D-LUF|C-E (that's a really complicated acronym) loop here:
 do {
 x = doSomething();
 } until failure or x>5 else {
 doSomethingElse();
 }
This is a really complicated loop. What it means, essentially, is to run a do..while loop where the condition is the success of the body OR a secondary condition. If the secondary condition activates before the main condition, then the else loop is activated (alternatively, it could be the failure condition triggering the 
else loop. Not sure which to make it.)
== See Also ==
* Do loop until failure
Category:Language constructs Category:Concepts
Do my esolangs even have meaning anymore or am i just part of an infinite factory making brainfuck clones until the end of eternity

Do my esolangs even have meaning anymore or am i just part of an infinite factory making brainfuck clones until the end of eternity is an esolang by User:Tommyaweosme. It's commands are all numbers
== Commands ==
 10 - crazy operation on current 27, third then fourth
 11 - crazy operation on current 27, fourth then third
 12 - crazy operation on current 27, fourth then second
 13 - crazy operation on current 27, fourth then first
 20 - crazy operation on current 27, first then second
 21 - crazy operation on current 27, first then third
 22 - crazy operation on current 27, second then third
 23 - crazy operation on current 27, third then second
 30 - crazy operation on current 27, third then first
 31 - crazy operation on current 27, second then first
 32 - crazy operation on current 27, first then fourth
 33 - crazy operation on current 27, second then fourth
 4 - add one to current 27
 44 - subtract one to current 27
 5 - next 27
 55 - previous 27
 6 - nop
 80 - [
 81 - ]
 88 - output alphabet (27 is space)
 89 - input alphabet (27 is space)
== How it works ==
 55 - previous 27
 565 - next 27 x 2
A 27 is a cell + has 4 parts.
You convert the 27 to base 3 to see its 4 parts.
The crazy operation puts the result in the seen areas of the 27.
A then D in the Malbolge table.
== HI ==
 4641088488
Category:LanguagesCategory:Turing completeCategory:2024Category:Cell-based
Do nothing

Do nothing is a very simple esolang created by User:Evylah.
== Code execution ==
An interpreter takes in the code, and does absolutely nothing. Does not print anything, write a file, and cannot take input. This language solves the Halting Problem and thus is not Turing-complete.
== Examples ==
=== Do nothing ===
This is basically just one big no-op.
=== Quine ===
Obviously I had to do a quine at some point. The code is 0 bytes, it outputs 0 bytes.
== Implementation ==
An implementation must accept Do nothing code.
=== Python 3.x ===
 code = input("Code? ")
 def parse(code):
 pass
 parse(code)
=== ><> ===
 >i:01-=?v00.
 >0r>?v;
 ^ <
=== Do nothing ===
Since Do nothing requires to take in code, a self-interpreter is not possible.
=== brainfuck ===
 ,[,]
Takes all code until a 0 is provided. LF on input end will not work.
=== -Output ===
 i~
Category:Languages Category:Joke languages Category:No-code esolang Category:Total Category:Implemented Category:Unusable for programming Category:Implemented Category:2024
Do while true

Do while true is an esolang, where every line is an expression.
==Syntax==
There is a stack.
Every line is an expression in postfix notation (1$2$- equals -1) and evaluated from left to right ($72$o$105$o-No prints Hi! and equals -33).
The intepreter first does that line and get the evaluated value, and then runs it until the evaluated value is 0.
Every negative or 0 value is treated as 0, else they're treates as 1.
Notes:
* the syntax sugar $abc$ means the number abc.
* #x means argument x.
* EOF returns -1, and the integers are unbounded.
 Caption text
Command	Descriprion
i 	gets input, evaluates to input.
N 	change the sign of #1
o 	output #1 and returns it
1 	returns a 1
> 	returns 1 if #1>#2 else 0
~ 	returns 1, discards #1
: 	duplicate and return top of stack
< 	push #1 onto the stack and returns #1
- 	returns #1 - #2
! 	returns and discards top of the stack
@ 	anything beyond that is a comment
S 	swaps top two stack elements, returns 0
^ 	rotate the stack up, returns a 0
= 	pop a list of numbers ending with 0 off-stack. convert them to strings. defines function number #1 to be the converted string as DWT code. returns #1
Z 	run function #1. returns #1.
h 	halt. "returns" 0.
==Examples==
===Hello, World!===
 $72$o$101$o$108$o$108$o$111$o$44$o$32$o$87$o$111$o$114$o$108$o$100$o$33$o------------~1-
===Truth-machine===
 i<~1-
 :o$48$-
===Cat program===
 io
===Self intepreter===
 i<:-^-|1-~
 1=1Z-h-
 
===Prime checker===
requires integer input.
 TBD
Category:2024Category:LanguagesCategory:Unknown computational classCategory:Stack-basedCategory:Unimplemented
Dog

Dog program is made like a normal day that a care taker would do with/for the dog.
Hello World:
 Day 1
 Awake
 food Recipe "hello world"
 Bowl food
 Eat food
 Outside
 Walk
 Poop food
 Run
 Inside
 Sleep
 EndOf Day 1
Category:Languages Category:2020 Category:Unimplemented Category:Unknown computational class Category:Usability unknown Category:Thematic
Dogescript

Dogescript is a language created in 2013 by Zach Bruggeman. It is nothing more than a syntax-replacement for Javascript to make it read like the internal monologues of memetic Shiba Inus.
 
==External resources==
* Dogescript spec
* Dogescript homepage
* Dogescript example code
* Explanation of 'Doge'
* Dogescript Game of Life
* 
Category:Languages
Category:2013
Category:Implemented
Category:Thematic
Doggo

Doggo is an esoteric programming language created by stysan. The idea was to recreate Logo programming language in funny and creative way: you don't get an error, when after turtle down you type brr. That's it!
== Commands ==
There are 7 commands in this language.
Comments are wrote like this:
 --- comment
 go
Example 	Output
forward 100 	Turtle goes forward by 100px.
backward 100	Turtle goes backward by 100px.
to 50 70 	Turtle goes to x: 50 and y: 70.
 turn
Example 	Output
left 45 	Turtle rotates left by 45 degrees.
right 90	Turtle rotates right by 90 degrees.
 turtle, pen (it doesn't matter)
Example	Output
up 	Pen up, you can't draw.
down 	Pen down, you can draw.
color 	Sets pen/turtle color.
hide 	Hides turtle: you can't see it.
show 	Shows turtle: you can see it struggling.
 fill
Example	Output
color 	Sets fill color.
start 	Starts fill.
end 	Ends fill.
 label
Example 	Output
Hello World!	Types "Hello World!" at turtle's position.
 ishowspeed
Example	Output
0 	Makes turtle real fast - this works on turtle.speed(number) in Python.
== Examples ==
Hello World
 label Hello World!
== Interpreter ==
Click this link: github.com/stysan/doggo
=== Categories ===
Category:Languages Category:Implemented Category:Total Category:Graphical Output
Dolfins grace

dolfins grace is an esolang that is like swimming.
==commands==
 > dolfin (moves through water, starts off going right)
 / mirror
 \ mirror
 | split
 - split
 ? puts user input into stack
 ! dolfin treats it like "/" if top is 0, goes through if not 0.
 - push a-b (always no pop unless otherwised specified)
 + push a+b
 * push a*b
 ` push a/b
 % push a%b
 " toggle stringmode from befunge
 ; dolfin goes random direction
 = duplicate top stack value
 ( rotate top 3 clockwise
 ) swap top 2
 # is . in befunge
 $ is $ in befunge
 ^ is , in befunge
 & pushes thing at a,b. if out of bounds, pop all of the stack and immediately end the program
 _ puts a at b,c (without popping anything)
 < dolfin eater
 0-z put alphanumeric character on stack
 { diode (dolfin gets stabbed if coming in from left)
 } diode (same as above but for right)
 ' 180 reflector
 [ dolfin treats it as "/" if the top 2 of stack are not same, otherwise it goes through
 A-Z portals
 @ put over a portal to make it unenterable
== hello world ==
 @ <
 >"dlrow olleh"A^!A
 
== truth machine ==
 <
 #
 0@
 >?!A1#A
== very fun video game ==
 >0\@ /"ERULIAF"^^^^^^^<
 \A+1?+[A
== aaaaaaaaa ==
 @
 >aA^A
== random number ==
=== xkcd ===
 >4#<
=== true ===
 /^<
 1
 >;2^<
 3
 \^<
=== sols rng ===
 /^<
 1
 >;1^<
 3
 \^<
== the kids choice awards ==
 @
 >S"slime"^^^^^S
== "fun" with portals ==
 >A
 <<<
 <A<
 <<<
 your surrounded now arent you dolfin
== calculator ==
 /$$??`#W
 /$$$$$??*#W
 /$$$$$$$??-#W
 /$$$$$$$$$$$??+#W
 S?1[$2[$3[$4[$$??%#W @
 @ /WS
 >"five function calculator"A^!A
== fibonacci ==
 @
 >A01+($((=#A
Category:Languages Category:Two-dimensional languages Category:Stack-based
Domino

Domino is a Turing complete programming language based on dominoes.
====Examples====
A or gate:
| | | 
 | | |
| | |
A XOR:
| | | |
 -
 -
The I combinator:
| | |
===Computational class===
In theory, S & K are easy to make.
===Records===
The only programming language outside in the real world. The Most popular esolang. 
===Implementations===
Go buy a pack of dominoes!
Don't

Don't was a very powerful esolang by User:Cortex that had only three commands
== Commands ==
Command	What it did
H 	Print "Hello, World!"
? 	Teleport the user's device to a landfill in Dubai.
G[] 	Delete Don't from existence.
Unfortunately, someone ran the G[] command in one of their programs while testing an interpreter, causing the language to be removed from everybody except the creator's memory, and it was rendered impossible to implement.
== Implementation ==
Despite of the rendering User:A insanely implemented Don't. This implementation requires two files and works only under Microsoft Windows:
/*do.c*/
#include <stdlib.h>
int main() {
 system("del dont.c");
 system("del do.c");
 system("del dont.exe");
 return 0;
}
/*dont.c
 *Inputs 1 command per line
 *No right served
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main() {
 char inp[30];
 while(1) {
 scanf("%s",&inp);
 /*In fact, an implementor could have
 *implemented burning up the user's 
 *computer and killing the user, but
 *it is way too risky to implement that.
 */
 if(strcmp(inp,"G[]")==0) {
 /*This theoretically deleted Don't
 *from existence via deleting every
 *Don't file and sources and leaving
 *do.exe alone(it certainly does not)
 *contain any "Don't" definitions.
 */
 system("start do.exe");
 return 0;
 } else if(inp[0]=='H') {
 printf("Hello, world!\n");
 } else if(inp[0]=='?') {
 /*Impossible, unless the device is a robot.*/
 printf("Your device is too heavy to be carried to Dubai\n");
 }
 }
 return 0;
}
Category:2019
Category:Languages
Category:Implemented
Donald Knuth

Donald E. Knuth is a legend who is writing the bible The Art of Computer Programming. Programming languages connected to him include:
* He designed the MIX (Knuth) computer and the MIXAL assembler to give example programs in the bible.
* He desgined the newer MMIX computer and the MMIXAL assembler to replace MIX.
* He designed Gb_gates RISC to build a CPU from individual logic gates.
* He didn't design PL/MIX.
* He popularized an earlier computational model called 1.1.
He is also an INTERCAL programmer.
Category:People
Dont

Dont is an esolang made by Yetyetty1234567890 in 2024. (Yes this is my first esolang to do this)
==Commands==
The first command is DONT. DONT will take the number after it and then prohibit it from being used on that line.
The second is ADD. ADD adds.
The third is SUB. SUB subs. (First number - second number)
The fourth is DUP. DUP will duplicate a value on a line backwards. (So like ADD 2 3 DUP 3 will make it 3 ADD 2 3)
The fifth is DUL. DUL will duplicate the previous line backwards and then run that line. (Like DUP)
The sixth is NOP. NOP.
The seventh is LOOP. LOOP loops the operations after it infinitely until the operation gets DONT'd
The eighth is INPUT. Inputs ASCII. (Is the input of a instruction.)
The ninth is OUTPUT. Outputs ASCII.
==Examples==
Examples:
===Hello, World!===
OUTPUT 72
OUTPUT 101
OUTPUT 108
OUTPUT 108
OUTPUT 111
OUTPUT 44
OUTPUT 32
OUTPUT 87
OUTPUT 111
OUTPUT 114
OUTPUT 108
OUTPUT 100
OUTPUT 33 
===Truth Machine===
DONT SUB INPUT 48 LOOP OUTPUT ADD 0 49
OUTPUT 48
Category:Languages Category:2024 Category:Unknown computational class
Doors

Roblox Doors but Esolang
== Info ==
 Doors is a 2d esolang that has three rows, the game, and the info for the rooms, and more info
 If you don't know what Roblox Doors or Floor 2 The mines is, immediately leave this and play it before you get spoilers
 here are some empty lines so you don't get spoilers
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 done
== Commands/Entities ==
 r - rush, has no info, adds one to the player, aka, deaths = the value of the player
 a - ambush, has an info, adds the value of _ to the player
 _
 h - halt, has no info, stops the program
 s - screech, has no info, reverses the player, so the player goes backwards, unless it was backwards, then it goes forward
 v - void, has an info, makes the player teleport to door the value of _
 _
 S - seek, has an info, waits _ seconds
 _
 f - figure, has two infos, if the value of the player is the value of _, it continues, else it goes to door the value of -
 _
 
 -
 g - guiding light, has no info, subtracts one from the player
 c - curious light, has an info, subtracts the value of _ from the player
 _
 t - timothy, has no info, outputs the value of the player
 e - eyes, has no info, sets the value of the player to the input
 d - dupe, has two infos, if the value of the player is the value of _, the player goes to door the value of -, else it continues
 _
 
 -
 j - jack, has no info, the player goes to door the value of the player
 G - glitch, has an info, sets the value of the player to the value of _
 _
 b - blitz, from the hunt update, has no info, swaps the players value and blitz value
 l - lookman, from the hunt update, has an info, swaps the players value and the _th value in lookmans infinite list
 _
 h - haste, from the hunt update, has an info, teleports to door _
 _
 D - dread, from i forgot update, has two infos, sets door _ to - 
 _
 -
 b - gloombats, from mines update, has a info, defines a register called _, if that register already exists
 , swap players value and register value
 _
 i - giggle, from mines update, has a info, delete door _
 _
 r - grumble, from mines update, has a info, goto the _th grumble door
 _
== Examples ==
=== Cat ===
 etv
 1
=== Counter ===
 rtv
 1
=== Truth machine ===
 ec fGthGtv
 4170 1 8
 note by BestCoder: you can do this:
 csomething else
 4
 1
 instead of:
 c something else
 41
 now does not work because i updated figure and dupe
=== If ===
 ! sets it to ascii mode
 
 !efGtvft
 44 74
 88 9
 
 6
=== Hello world ===
 !G tctattatG ta tctatctct
 104 3 7 3 32 87 8 3 6 8
== last thing ==
you can write stuff like this
 eyes
 timothy
 haste 0
 #this is infinite cat
== External resources ==
* Doors [CLASSIC❗] interpreter, in Python (to whoever made this, thank you, and good job, it looks good) (also update it)
Category:Languages
Category:Thematic
Category:Finite state automata
Category:Implemented
Category:2024
Doreq

Doreq is a OISC interpreter of the same named instruction.
==Basic==
Each doreq instruction has 8 memory address operands.
 A B C X Y Z J K
If the value at memory address C is positive then value of memory address A and B will be added together, otherwise B will be subtracted from A. The result of the previous operation will be assigned to memory address X, value at memory address B will be passed onto memory address Y and C will have its sign inverted and then passed onto memory address Z. If the value at memory address X is equal to 0 then jump to address J otherwise jump to address K. If the address to jump is equal to -1 then halt. Because each value has its own address the instructions are 8 addresses long.
==Examples==
This example will count down from 10 to 0 and then halt.
 8, 9, 10, 11, 12, 13, 14, 15,
 10, 1, -1, 8, 9, 16, -1, 0,
 99
The first instruction from address 0 to 7, checks the value of address 10. The value is -1 so address 11 will be assisgned the result of address 9 subtracted from address 8, address 12 will be assigned the value of address 9 and address 13 will be assigned the value of address 10 but sign inverted which is +1. The value at address 8 is not equal to 0 so a jump will be made to address 15 which has a value of 0 so back to address 0.
The example below is an extension of the one above and results in the sum of 9+8+7+6+5+4+3+2+1 being assigned to memory address 17
 8, 9, 10, 11, 12, 13, 14, 15,
 10, 1, -1, 8, 9, 16, -1, 24,
 99, 0, 1, 98, 0, 0, 0, 0,
 17, 8, 18, 24, 25, 19, 14, 20
==An Interpreter==
This is an interpreter for Doreq written in Javascript
 var memory = []
 var program_counter = 0
 var A, B, C, X, Y, Z, J, K
 while (program_counter >= 0) {
 A = memory[memory[program_counter]]
 B = memory[memory[program_counter+1]]
 C = memory[memory[program_counter+2]]
 X = memory[memory[program_counter+3]]
 Y = memory[memory[program_counter+4]]
 Z = memory[memory[program_counter+5]]
 J = memory[memory[program_counter+6]]
 K = memory[memory[program_counter+7]]
 if (C >= 0) {
 memory[X] = A+B
 } else {
 memory[X] = A-B
 }
 memory[Y] = B
 memory[Z] = -C
 if (memory[X] === 0) {
 program_counter = J
 } else {
 program_counter = K
 }
 }
This next interpreter is 200% more woke and uses ternary operators to rekt the one above and is absolutely useful as an example!
 var memory = []
 var program_counter = 0
 while (program_counter >= 0) {
 memory[memory[memory[program_counter+3]]] = (memory[memory[program_counter+2]] >= 0) ? memory[memory[program_counter]]+memory[memory[program_counter+1]] : memory[memory[program_counter]]-memory[memory[program_counter+1]]
 memory[memory[memory[program_counter+4]]] = memory[memory[program_counter+1]]
 memory[memory[memory[program_counter+5]]] = -memory[memory[program_counter+2]]
 program_counter = (memory[memory[memory[program_counter+3]]] === 0) ? memory[memory[program_counter+6]] : memory[memory[program_counter+7]]
 }
Category:Languages
Category:Cell-based
Category:Turing complete
Category:Low-level
Category:Self-modifying
Category:OISC