nyuuzyou/wikis huggingface dataset:
Dbfi

Dbfi is a brainfuck self-interpreter written by Daniel B. Cristofani and described in detail in . This is the shortest known brainfuck self-interpreter and possibly the shortest self-interpreter amongst all imperative languages. Note that a big part of dbfi code is devoted to ASCII decoding, comment handling, and avoiding undefined behaviour. Removing this would reduce the size to nearly half.
Dbfi inspired Clive Gifford to write the fastest Brainfuck self-interpreter (since dbfi is the shortest, but not the fastest) . Its compressed version is
 >>>>>+[->>++>+>+++++++[<++++>>++<-]++>>+>+>+++++[>++>++++++<<-]+>>>,<++[[>[->>
 ]<[>>]<<-]<[<]<+>>[>]>[<+>-[[<+>-]>]<[[[-]<]++<-[<+++++++++>[<->-]>>]>>]]<<]>[
 -]+<<[--[[-]>>->+<<<]>>[-<<<<[>+<-]>>>>>>+<]<<]>>[-]<<>>>[<<<+>>>-]<<<]>>>+<<<
 <[<<]>>[[<+>>+<-]+<-[-[-[-[-[-[-[->->>[>>]>>[>>]<+<[<<]<<[<<]<]>[->>[>>]>>[>>]
 <,<[<<]<<[<<]]<]>[->>[>>]>>[>>]<-<[<<]<<[<<]]<]>[->>[>>]>>[>>]<.<[<<]<<[<<]]<]
 >[->>[>>]>>[>>]<<-<<[<<]<<[<<]]<]>[->>[>>]>>[>>]+[<<]<<[<<]]<]>[->>[>>]>>[>>]<
 [>+>>+<<<-]>[<+>-]>>[<<+>>[-]]+<<[>>-<<-]>>[<<+>>>>+<<-]>>[<<+>>-]<<[>>+<<-]+>
 >[<<->>-]<<<<[-<<[<<]<<[<<]<<<<<++>>]>>[-<<<<<<[<<]<<[<<]<]>]<]>[->>[>>]>>[>>]
 <[>+>>+<<<-]>[[<+>-]>>[-]+<<]>>[<<+>>>>+<<-]>>[<<+>>-]<<[>>+<<-]+>>[<<->>-]<<<
 <[-<<[<<]<<[<<]<<<<<+>>]>>[-<<<<<<[<<]<<[<<]<]>]>[<+>-]<<<<<<[>>+<<-[->>->>+[>
 >>[-<+>>+<]+<-[-[[-]>[-]<]>[-<<<+>>>]<]>[-<<<->>>]>[-<+>]<<<<[>>+<<-]>>]<<<<<<
 ]>>[-<<+[>>>[-<+>>+<]+<-[-[[-]>[-]<]>[-<<<->>>]<]>[-<<<+>>>]>[-<+>]<<<<[<<+>>-
 ]<<]]]>>>>>>>]
Below is relative comparison of time to run a simple program with a stack of two self-interpreters.
Lower SI	Upper SI	Time
cgbfi 	cgbfi 	9.1
cgbfi 	dbfi 	7.0
dbfi 	cgbfi 	35.0
dbfi 	dbfi 	21.3
Here cgbfi stands for Clive Gifford Brainfuck Interpreter. Time is given in seconds, which does not matter, because only relative values are important.
The second line shows faster result because DBFI is shorter than CGBFI, and this outweighs the speed benefit of the faster self-interpreter used in the second level in the stack of interpreters. The short program used for the comparison is
 >+>+>+>+>++<[>[<+++>-]<<]> [>+>+<<-]>[-]>.!
and the interpreter bff4.c.
Dbfi also inspired people to make brainfuck interpreters in other esolangs (like StegFuck and Factor) since it is very short.
Category:Brainfuck
Category:Implementations
Dbondb

Dbondb is an esoteric programming language created by User:Sideshowbob.
Dbondb is derived from Dartmouth BASIC, the first BASIC, which was introduced in 1964. Hence the name, "DB or not DB" (that is the question), with the acronym Dbondb.
Is it still BASIC? Is it an example of making a practical language less practical? Or is it an example of putting more effort into the name than the language?
Variables are lower-case a to z. Data-type is string (treated as float by arithmetic operations)
Statements are separated by semi-colons.
==Commands==
Statement 	Purpose
c[text]; 	comment
d; 	beginning of the data section
e; 	end execution
g[label]; 	go to the label
gs[label]; 	call a subroutine at the label
?[var][label]; 	if var is true (non-zero) go to the label, else go to the next statement
i[var]; 	interactive input, assigned to var
l[text]; 	label - target for gosub, goto or if
s[var1][const or var2];	assigns const or var2 to var1
+[var1][const or var2];	adds const or var2 to var1, assigns sum to var1
-[var1][const or var2];	subtracts
*[var1][const or var2];	multiplies
/[var1][const or var2];	divides
^[var1][const or var2];	exponentiates
_[var1][const or var2];	concatenates (strings)
pa[ascii code]; 	prints an ASCII character - e.g.9, 10, etc.
ps[text]; 	prints a literal string (no quotes)
pv[var]; 	prints the value of var
r; 	returns from a subroutine
r0; 	restores the data pointer to its original location
r[var]; 	reads the next data item, assigns it to var
==Examples==
===Hello, world!===
psHello, World!;pa10;e;
===Factorial===
psNumber;in;scn;-c1;l;*nc;-c1;?cl;pvn;pa10;e;
===Fibonacci sequence===
psHow many;ic;sa0;sb1;l;sf0;+fa;+fb;pva;pa10;sab;sbf;-c1;?cl;e;
===Area of a circle===
psRadius;ir;sar;*ar;*a3.14159;pva;pa10;e;
===99 bottles of beer===
sn99;l;pvn;ps bottles of beer on the wall, ;pvn;ps bottles of beer.;pa10;psTake one down, pass it around, ;-n1;pvn;ps bottles of beer on the wall;pa10;?nl;e;
==Implementation==
DBonDB interpreter for Windows
Category:Languages
Category:Implemented
DcScript

dcScript is an esoteric language created by Daaloul Chiheb on September 2011.
It is designed to be useful but is minimalistic and is hard to code with it for big projects.
== The language instructions ==
The language is constitued by a large set of instructions (for an eso' language). There are around 40 instructions in it.
The language supports integers, strings and arrays (of integers and strings). It supports statements such as conditions too but has no direct way to support loops except a label system (: and call).
== Example ==
Here is a dcScript program that prints "Hello the World !" on the screen :
===== Hello the World program =====
:sysprtn "Hello the World !"
:wait
:quit
===== Factorial =====
:[NO ERRLOG]
:title "Factorial - dcScript implementation"
:int fact
:int cpt
:int n
:int c
:fac:
:defi fact 1
:defi cpt 2
:start:
:ifmin cpt n
:mult fact cpt
:addi cpt 1
:call start
:ifend
:ifeql cpt n
:mult fact cpt
:addi cpt 1
:call start
:ifend
:sysprt "x! = "
:dspvar int fact
:sysprtn ""
:_start:
:sysprt "Entrez le x = "
:getstream int n
:ifeql n -1
:call end
:ifend
:call fac
:end:
:sysprtn "x! = 1"
:sysprtn "Press any key to continue..."
:wait
:quit
== Implementations ==
There is currently a single implementation of this language and is the official one which is not finish yet.
It is downloadeable from here.
The source code can be found here.
== Turing completeness ==
The language is supposed to be Turing complete but no proof was made.
Category:Languages Category:Implemented
De Bruijn indexing

De Bruijn indexing is a technique used to remove names from lambda calculus terms, replacing them with De Bruijn indices. The resulting terms have trivial wikipedia:alpha equivalence, making them simpler to manipulate at the cost of increased cognitive overhead. De Bruijn indexing was introduced by wikipedia:Nicolaas Govert de Bruijn in 1972.
M’colleague Bob Atkey once memorably described the capacity to put up with de Bruijn indices as a Cylon detector, the kind of reverse Turing Test that the humans in Battlestar Galactica invent, the better to recognize one another by their common inadequacies. ~ Conor McBride
== Idea ==
Recall that lambda calculus only has three constructors: abstraction, application, and variable lookup; and consider closed terms for now. Due to lexical scoping, every variable lookup is always scoped: there is a lambda-binder somewhere above the variable which introduces its scope. For example, here's the identity function:
 λx.x
But also, here's the identity function:
 λy.y
These are quite similar in the sense that they are alpha-equivalent: we can transform one term into another by renaming variables in a scope-respecting manner. It turns out that any scope-respecting renaming must preserve the number of lambda-binders above the variable. The De Bruijn index is merely that number.
== Notation ==
The following notation is common throughout the community and wiki.
Closed terms consist of lambda, parentheses, and numeric indices. Traditionally, as long as there are fewer than ten layers of lambda, application is denoted by parentheses and juxtaposition. For example, the following lambda calculus term:
 λx.λy.(xy)
Is notated as the following term with De Bruijn indices:
 λλ(21)
Sometimes it can be nice to add whitespace for readability:
 λλ(2 1)
And some authors will remove outermost parentheses:
 λλ21
=== Conventions ===
Should De Bruijn indices start at 0 or 1? De Bruijn used 1-indexing, but many computer scientists working today use 0-indexing. In general, authors will note their convention and often justify it as well, as is the case in De Bruijn 1972.
== Examples ==
The identity function:
 λ1
The K combinator:
 λλ2
The S combinator:
 λλλ((31)(21))
== See Also ==
* wikipedia:De Bruijn index
* De Bruijn 1972, which introduced the concept
Category:Before 1993
Category:Concepts
Dead

Dead constitutes a cell-based esoteric programming language designed by User:Ilaylevy, using a single character to represent its operations.
==Architecture==
Dead programs operate on an infinitely expanding tape of integer-valued cells, the currently active instance is referenced by a mobile pointer.
==Data Types==
Only integer numbers, signed and unbounded in their magnitude, participate in a program.
==Commands==
Dead is a language that uses only 1 character to do a certain action:
 Commands
Symbol	Action
p 	Prints the value of the current cell
a 	Adds one to the current cell
s 	Subtracts one from the current cell
i 	Asks the user for an input
l 	Moves left one cell
r 	Moves right one cell
==Examples==
===Counter===
A program printing “1234” will look like this:
 apapapap
===Cat program===
A one-time numeric cat program comprehends
 ip
==Interpreter==
* Common Lisp implementation of the Dead programming language.
Category:Low-level 
Category:Cell-based 
Category:Implemented 
Category:Languages
Category:2021
Category:Total
Category:Unusable for programming
DeadIFsh

DeadIFsh is an esolang by User:ChuckEsoteric08 derived from Deadfish.
==Commands==
In addition to Deadfish commands, DeadIFsh has following commands:
Command	Operation
[ 	start of while-not-0 loop
] 	end of while-not-0 loop
( 	start of while-0 loop
) 	end of while-0 loop
{ 	start of if-bigger-than-0 statement
} 	end of if-bigger-than-0 statement
< 	start of if-0 statement
> 	end of if-0 statement
==Examples==
===Countdown===
Counts down from ten to inclusive one:
 iiiiiiiiii[od]
===Infinite Byte Range Printer Using Nested Loops===
Perpetually prints the integers from zero through inclusive 255:
 (oi[oi])
===Infinite Byte Range Printer Using Conditional===
An alternative approach to the perpetual printing which outputs the integer numbers in the range [0, 255]:
 oi[oi<oi>]
==Interpreter==
* Common Lisp implementation of the DeadIFsh programming language.
Category:Languages Category:Push-down automata
DeadPig

DeadPig is a version of the language Pig, where the pig has unfortunately died.
==Usage==
DeadPig follows the same syntax rules as Pig, You write the title of the text file you want to make, write PIG, then write the contents of the text file. However, the pig has died, so the program will ignore your desired contents and write "Your pig has unfortunately died. Please try again."
==Various Programs in DeadPig==
===Cat Program===
DeadPig cannot create the Cat program because it is output only.
===Quine===
DeadPig cannot create a Quine either.
However, if one ignores case, then DeadPig can create a Quine-by-error, or a false Quine, with the code
 Your PIG has unfortunately died. Please try again.
This creates a file named "Your " with the text "Your pig has unfortunately died. Please try again.".
==Interpreter==
Written in Python.
def deadpig(code):
 assert type(code) is str, "ERROR: Code must be a string."
 assert "PIG" in code, 'ERROR: Code must contain "PIG".'
 file_name, _ = code.split("PIG", 1)
 file = open(file_name, "w")
 file.write("Your pig has unfortunately died. Please try again.")
 file.close()
==The Pig Series==
The Pig series is a a series of programming languages that are all based on Pig.
The languages are Pig, SickPig, DeadPig, and QuinePig.
Other languages based on Pig are DeafPig and ExtendedPig.
Category:Languages Category:Output only Category:Unusable for programming Category:Joke languages Category:Total Category:Implemented
DeadSimple

DeadSimple, originally named R U DS for Are You Dead Serious?, is an simple, total, output-only esoteric programming language created by Zackery Mowrer in 2018. The current name comes from the fact that the language is "dead simple" to program in.
Being a total programming language, it is not Turing-complete.
== Syntax ==
There are only four instructions. These instructions operate on an integer variable and thus somewhat simulate a integer stack (although no stack is used internally).
* _: Resets to 0
* +: Increments by 1
* -: Decrements by 1
* S: Prints the current value in its Unicode representation
All other characters, including lowercase s, are silently ignored and can thus be used as comments.
== Example ==
Here is a Hello World program written in DeadSimple:
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++S # H
 +++++++++++++++++++++++++++++S # e
 +++++++SS # ll
 +++S # o
 _
 ++++++++++++++++++++++++++++++++++++++++++++S # ,
 ------------S # space
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++S # w
 --------S # o
 +++S # r
 ------S # l
 --------S # d
 _
 +++++++++++++++++++++++++++++++++S # !
 _
 ++++++++++S # newline
This program can also be written as a one-liner:
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++S+++++++++++++++++++++++++++++S+++++++SS+++S_++++++++++++++++++++++++++++++++++++++++++++S------------S+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++S--------S+++S------S--------S_+++++++++++++++++++++++++++++++++S_++++++++++S
== External Resources ==
* Github page for the interpreter I wrote using C# and .NET Core.
Category:Low-level 
Category:Implemented 
Category:Languages
Category:2018
Category:Output only
Category:Total
Deadbird

Deadbird is a Deadfish derivate by User:ChuckEsoteric08
=Additions=
Instead of having a single accumulator, Deadbird has 4 accumulators. It adds following commands to Deadfish:
 n - moves to the next accumulator, wrapping
 c - outputs as a character
 g - inputs a character
 z - sets accumulator to zero
 f - skip next command if accumulator is zero
 (x/y) - define function x (can be only a single character) as y. Allows recursion
Category:Languages Category:Turing complete Category:Turing tarpits Category:Unimplemented
Deadfih

Deadfih is an esolang based on Deadfish.
==Instructions==
It's just Deadfish without the S instruction, so:
 Caption text
instruction	meaning
i 	Increment
d 	Decrement
o 	Output as character
It follows the deadfish acc==-1 || acc==256 tradition.
==Examples==
print 'A':
 iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiio
==See also==
* eafh
==Implementation==
The following interpreter has been implemented in the programming language Common Lisp:
 (defun interpret-Deadfih ()
 "Launches the Deadfih interpreter, which perpetually queries the
 standard input for a line of code, evaluates the same, and repeats
 the process, returning in the case of an abortion no value."
 (let ((accumulator 0))
 (declare (type integer accumulator))
 (loop do
 (format T "~&>> ")
 (finish-output)
 (let ((user-input (read-line)))
 (declare (type string user-input))
 (loop for token of-type character across user-input do
 (case token
 (#\i (incf accumulator 1))
 (#\d (decf accumulator 1))
 (#\o (format T "~c" (code-char accumulator)))
 (otherwise (format T "~%")))
 (when (or (= accumulator -1) (= accumulator 256))
 (setf accumulator 0))))))
 (values))
Python:
 def interpret(code):
 code = list code
 x = 0
 for char in code:
 if char == 'i':
 x += 1
 elif char == 'd':
 x -= 1
 elif char == 'o':
 print(x)
Category:Accumulator-basedCategory:Deadfish derivativesCategory:2024Category:TotalCategory:LanguagesCategory:Esoteric subset
Deadfish "self-interpreter"

Deadfish "self-interpreter" is a small Deadfish extension that supports interpreting Deadfish.
==Syntax==
Accumulator b is equivalent to Deadfish's accumulator, whereas accumulator a stores one character.
Instruction	Description
a 	input accumulator a
i 	increment accumulator b
d 	decrement accumulator b
s 	square accumulator b
o 	output accumulator b
j 	jump back to the start of the program
: 	if the character after : is equal to a, interpret that character, else, skip it.
==Example programs==
===Deadfish interpreter===
 a:i:d:s:oj
==="Truth-machine"===
For input 0, input 0, then 0. For input 1, input i, then j, then 0, then j, then repeat inputting 0j.
 a:ioa:j
== Implementations ==
=== Python ===
Implementation by User:JonoCode9374 and User:HungKhanh0106
acc = 0
input_acc = 0
 
def run(program):
 global acc, input_acc
 ip = 0
 while ip < len(program):
 if acc == 256 or acc < 0: acc = 0
 if program[ip] == "j": ip = 0; continue
 elif program[ip] == "i": acc += 1
 elif program[ip] == "d": acc -= 1
 elif program[ip] == "s": acc *= acc
 elif program[ip] == "o": print(acc)
 elif program[ip] == ":" and ord(program[ip + 1]) == input_acc: run(chr(input_acc)); ip += 2; continue
 elif program[ip] == "a": try: input_acc = ord(input(">"));except: continue
 ip += 1
while True: source = input(">> "); run(source)
==See also==
* Deadfish
Category:Languages
Category:2019
Category:Implemented
Category:Finite state automata
Category:Unusable for programming
Category:Deadfish derivatives
Deadfish 2

Deadfish 2 is a superset of Deadfish made by User:M654. As well as an accumulator, Deadfish 2 has a string which can be set using the input command.
== Commands ==
Deadfish 2 has nine commands, five of which are new.
Command	Description
i 	Increment the accumulator.
d 	Decrement the accumulator.
s 	Square the accumulator.
o 	Output the accumulator.
O 	Output the string.
c 	Output the accumulator as a character.
n 	Set the accumulator to 0.
r 	Read input and store it in the string.
h 	Halt the program
== Examples ==
=== Hello world! ===
This program prints "Hello world".
 iisiiiisiiiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiciiiiiiicciiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddcddddddddciiicddddddcddddddddch
=== Cat program ===
This program reads the input and copies it to the output.
 rOh
== Interpreter ==
* The official Deadfish 2 interpreter can be found at GitHub here .
* An interpreter written in C can be found here
Category:Languages
Category:Implemented
Category:2016
Category:Total
Category:Unusable for programming
Deadfish 3

Deadfish 3 is a superset of Deadfish 2 invented by User:A. As well as an accumulator, Deadfish 3 has a string which can be set using the input command.
== Commands ==
Deadfish 3 has twelve commands, three of which are new.
Command	Description
i 	Increment the accumulator.
d 	Decrement the accumulator.
s 	Square the accumulator.
o 	Output the accumulator.
O 	Output the clipboard.
c 	Output the accumulator as a character.
n 	Set the accumulator to 0.
r 	Read input and store it in the clipboard.
h 	Halt the innermost clipboard-pasted program enclosing the program counter (halts the whole program if there is no such program).
"xx" 	Copy the characters xx to the clipboard; this is assumed as one command.
@ 	Paste the content of the clipboard after this command.
: 	Execute the next command if the accumulator is 0.
== Examples ==
=== Hello world! ===
This program prints "Hello world".
 iisiiiisiiiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiciiiiiiicciiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddcddddddddciiicddddddcddddddddch
=== Cat program ===
This program reads the input and copies it to the output.
 rOh
===Truth-machine approximation===
This program remotely approximates the workings of a truth-machine by employing clipboard-pasted code segments and recursion in the same.
In order to operate correctly, the user must simulate a truth-machine input of 0 by issuing no input, or a value of 1 by committing a single i command. Please heed that in Deadfish 3 implementations which realize subprogram executions via recursion a stack overflow is very probable.
 "Please input 'i' to simulate '1', otherwise nothing: " O d r@ "iod@" :@ no
==Interpreter==
* Common Lisp implementation of the Deadfish 3 programming language.
Category:Languages Category:Implemented
Deadfish Joust

Deadfish Joust is a deadfish-based game created by User:A, consisting of two contestants who 
attempt to modify an accumulator to make the accumulator as close to their value 
as possible. It has the lowest learning curve compared to other programming games, 
as even BF Joust has at least 8 instructions, and Deadfish Joust only has 4 
instructions.
==Contest==
The two contestants are given a random number between 0 and 255. There will be
no such cases like two contestants have the same number. The goal of this contest 
is to make the resulting program set the accumulator to the random value that the
contestants are given.
==Typing==
The contest consists of two people typing a Deadfish program. Each person can't see
what the other person is typing. Once a person clicks run (,or types a run command, 
if the joust server is console-based), they cannot change their program anymore.
When the two contestants are done, the computer merges two of the programs together.
Take aaaaaaa and bbbbbbb as an an example. The computer will do this:
ababababababab
If code a is shorter than code b (and vice versa), such as aaaaa and bbbbbbb, the computer will not do anything else to the extra part.
Take this as an example:
a=12345
b=asdfghj
ab=1a2s3d4f5g
Then, the program will be executed, and the computer will check whether the 
resulting accumulator value is closer to contestant a's number or contestant b's 
number. If the result is closer to whatever contestant's number, then that 
contestant wins.
==Instructions in deadfish Joust==
The instructions in deadfish Joust is less than the usual set of deadfish 
commands. These are:
i: increment the accumulator
d: decrement the accumulator
s: square the accumulator
q: square root the accumulator, making sure that the accumulator is an integer
The output instruction is unneccecary, as the computer will not check the output.
o is a no-op, similar to other instructions.
==Implementation==
This is an incomplete server for this game (contestants can see what the other is typing):
import random
import math
anm=random.randint(0,255)
bnm=random.randint(0,255)
print("Contestant a, you are given:",anm)
print("Contestant b, you are given:",bnm)
a=input()
b=input()
c=""
for i in range(min(len(a),len(b))):
	c=c+a[i]+b[i]
print(c)
print("---Deadfish execution! Please wait...---")
ac=0
for i in c:
 print(i, ":", ac)
 if ac==256 or ac==-1:
 ac=0
 elif ac==-1:
 ac=255
 elif i=='i':
 ac+=1
 elif i=='d':
 ac-=1
 elif i=='s':
 ac*=ac
 elif i=='q':
 ac=int(math.sqrt(ac))
print(i, ":", ac)
print(ac%256)
if abs((ac%256)-anm)<abs((ac%256)-bnm):
	print("Contestant a wins!")
else:
	print("Contestant b wins!")
Category:2019
Category:Programming games
Category:Languages
Category:Implemented