nyuuzyou/wikis huggingface dataset:
Dual tape ez

dual tape ez is a simple tape machine. Every cell holds an instruction and a number.
== About ==
About 	
Author 	Charles McMarrow
User 	User:Ch44d
Conceived	8/18/2021
Birthday 	10/30/2021
Official Interpreter
pip install dual_tape_ez
https://github.com/cmcmarrow/dual_tape_ez
== Instructions ==
Name 	Instruction	Description
Halt 	h 	Stop the program.
Out Number 	n 	Outputs the number from item_1.
Out Character 	c 	Outputs the number as a UTF-8 character from item_1.
In Number 	i 	Read number from console into item_1. Falls back to 0 if error.
In Character 	o 	Read UTF-8 character from console into item_1. Falls back to "\0" if error.
Add 	a 	item_1 = item_2 + item_1
Subtract 	s 	item_1 = item_2 - item_1
Jump 	j 	pc = current value in memory
Jump Dynamic 	k 	pc = value from memory address in item_1
Jump Zero 	z 	pc = item_1 if item_2 == 0
Jump Greater 	g 	pc = item_1 if item_2 >= 0
Read 	r 	item_2 = item_1; item_1 = current value in memory
Read Dynamic 	t 	item_2 = item_1; item_1 = value from memory address in item_1
Read Dynamic Instruction 	y 	item_2 = item_1; item_1 = value from memory instruction address in item_1
Write 	w 	current location in memory = item_1
Write Dynamic 	e 	value from memory address in item_1 = item_2
Write Dynamic Instruction	d 	value from memory instruction address in item_1 = item_2 if item_2 is a valid instruction
NOP 	. 	No operation performed.
== Registers ==
Register	Description
pc 	Holds the current program counter. At program start pc is set to the label "@". If Label "@" is not present an error will be thrown.
item_1 	Set to 0 at program start.
item_2 	Set to 0 at program start.
== Memory ==
A single memory cell holds two items, instruction and data. The default instruction value is "." and the default data value is 0. Memory range is negative infinity to infinity.
== Syntax ==
Syntax
NUMBER | CHARACTER | COMMENT] [COMMENT]) | COMMENT | "") NEWLINE}
<LABEL> ::= "@" {Any UTF-8 Character excluding white space}
"x"
<COMMENT> ::= "#" {Any UTF-8 Character excluding NEWLINE}
<NEWLINE> ::= "\n"
<CHARACTER> ::= "c" (Normal UTF-8 Character)
<NUMBER> ::= An Integer
== Sister Language ==
dual_tape
== Programs ==
=== truth-machine ===
 @ i # Truth Machine
 r @zero
 z
 @one_loop r 1
 n
 j @one_loop
 @zero r 0
 n
 h
=== Hello World ===
 @hello_str . cH # Hello World
 . ce
 . cl
 . cl
 . co
 . 32
 . cW
 . co
 . cr
 . cl
 . cd
 . c!
 . 10
 . 0
 
 @ r @ptr
 t
 t
 r @exit
 z
 r @ptr
 t
 t
 c
 r @ptr
 t
 r 1
 a
 @ptr w @hello_str
 j @
 @exit h
Category:Implemented
Category:Languages
Category:Turing complete
Category:Cell-based
Category:Self-modifying
Category:Low-level
Category:2021
DubDubMachine

DubDubMachine is a esoteric programming language created in 2019 by ThisIsTheFoxe for a WWDC Scholarship application, hence it's name. It's goal is to show how much fun end exitement esolangs can bring - especially to newcomers.
==Language overview==
DubDubMachine operates on an array of (normally 8) memory cells, also referred to as the tape. Each cell is initially set to zero. There is a pointer, initially pointing to the first memory cell. There are 20 (originally 19) Emoji which are interpreted as commands. Every other character is ignored and treated like a comment.
===Commands===
Command 	Description
0️⃣-🔟 	Those 11 Emoji are used to represent numbers in DubDubMachine.
🎙 	IN: (not part of the original implementation) Reads a character from an input and writes is ASCII code into the current cell
🎉 	OUT: Prints out the value of the current cell as ASCII character
👍(followed by a number x) 	INC: Increments the current memory cell by x
👎(followed by a number x) 	DEC: Decrements the current memory cell by x
👉(followed by a number x) 	FWD: Moves the pointer forwards by x
👈(followed by a number x) 	BCK: Moves the pointer backwards by x
🤟 	IF: Jumps past the matching 🤘 if the current cell is 0
🤘 	EIF: Jumps back to the matching 🤟 if the cell under the pointer is NONzero
🤯 	END: Terminates the program immediately
===Related===
According to the author the commands where influenced by the language l33t. However, many esoteric programming languages use similar low-level commands.
The related Emoji also where chosen to represent their actions, which is also common in esolangs (e.g. brainfuck: + = 👍)
The Emoji for IF / EIF and END where influenced by the theme of WWDC19. 
==Examples==
===Cat program===
🎙🤟🎉🎙🤘🤯
===Truth-machine===
Based on the brainfuck example.
👉3️⃣🎙🎉👉🤟🤟👎1️⃣👉1️⃣👍1️⃣👈2️⃣👍👉1️⃣🤘👉1️⃣👎1️⃣🤘👈3️⃣🤟👈2️⃣🤘👉1️⃣🤟🎉🤘🤯
===WWDC===
Probably the first program to ever been written in this language by the author. It prints the string "WWDC".
👍🔟👍7️⃣ init cell 1 with 17
🤟 loop start
👎1️⃣ decrement x
👉1️⃣
👍5️⃣ add 5 to cell 2
👉1️⃣
👍4️⃣ add 4 to cell 3
👉1️⃣
👍4️⃣ add 4 to cell 4
👈3️⃣ back to cell 1
🤘
👉1️⃣
👍2️⃣ add 5 to cell 2
🎉🎉 print cell 2 two time
👉1️⃣🎉 print cell 3
👉1️⃣
👎1️⃣🎉 subtract 1 form cell 4 and print it
🤯 The End ^-^
==Computational class==
DubDubMachine would be Turing-complete with an infinite amount of memory. However, since it's defined by it's small memory of eight 8bit cells it is not entirely. 
Category:Low-level 
Category:Cell-based 
Category:Implemented 
Category:Languages
Category:2019
Category:Brainfuck_derivatives
Category:Thematic
Duck

Duck (Deque stack) is an esoteric language by User:ChuckEsoteric08.
==Specification==
Duck has two stacks and accumulator. One stack is made out of integers (called "IntStack") and other from 1-byte deques (called "Staque").
Commands:
Command 	Description !
[abc] 	Push abc to Staque
0 	Push 0 to the IntStack
1 	Push 1 to the IntStack
+ 	Pop two elements from IntStack, a and b and push b+a to IntStack
- 	Pop two elements from IntStack, a and b and push b-a to IntStack
? 	Input string and push it to Staque
& 	Input string and push it to IntStack
!x 	Declare label x (label name could be only 1-character long)
@x 	Goto label x
"x"abc" 	If accumulator is x execute abc
abc|xyz} 	If accumulator is n execute abc, else execute xyz
abc|xyz) 	If accumulator is not n execute abc, else execute xyz
.x 	Push character x to the top of top element of Staque
,x 	Push character x to the bottom of top element of Staque
: 	Duplicate top element of IntStack
< 	Copy bottom of top element of Staque to Accumulator and delete it
> 	Copy top of top element of Staque to Accumulator and delete it
; 	Copy top element of IntStack to Accumulator and delete it
^ 	Push Accumulator to the top of top element of Staque
v 	Push Accumulator to the bottom of top element of Staque
$abc$x$y$	Repeat abc until top of IntStack will be x and Accumulator will be y
~ 	Swap top two elements in Staque
' 	Push Accumulator to IntStack
= 	Output Accumulator
\n\abc\ 	if accumulator is n execute abc
*n*abc* 	if top of IntStack is n execute abc
\n\abc\ 	if top of IntStack is not n execute abc
%abc%x% 	repeat abc until top of IntStack is x
`abc`x` 	repeat abc until Accumulator is x
#comment#	Comment
==Examples==
===Truth Machine===
 &:;{0|=|`=`0`}
===Hello World===
 [Hello, World!]`<=`!`
===Cat===
There should be . at the end of an input
 ?`<=`.`
===Reverse Cat===
There should be . at the begining of an input
 ?`>=`.`
===Brainfuck interpreter===
It has 9 cells which can have value from 0 to 9. You can change number of cells by adding or removing zeroes between [ and ]
Version with comments is here
 [000000000]?!c<^"+"@+""-"@-"","@,""."@."">"@>""<"@<""["@[""]"@]""!"@!"@c!+~<v'1+~@c!-~<v'1-~@c!,~&;v~@c!.~<v=~@c!>~<^~@c!<~>v~@c![~<v~{0|0$\[\1+\\]\/0/1-/\$0$]$@c|@c}!]~<v~(0|0$\]\1+\\[\/0/1-/\$0$]$@c|@c)!!
Category:Languages Category: Unimplemented Category:Turing complete Category:Stack-based Category:Deque-based
Duh

duh is an experimental deterministic cell-based esolang created by User:~blu256 written just for fun.
== Etymology ==
duh stands for "duh is an esolang (duh!)".
== Features and quirks ==
* 2D memory block of preconfigurable size plus one register (additional memory cell);
* Wide character support;
* Seeking to specific positions in instruction file via instructions;
* Several flavours of directional/numeric goto statements instead of using functions/labels;
* Value manipulation done entirely by incrementing/decrementing and performing binary left-shifts/right-shifts by one.
== Instructions ==
Type 	Instruction 	Description
Value 	Increment cell value by 1	
 	 	
Decrement cell value by 1	 	
 	< 	Left-shift value by 1 position
 	> 	Right-shift value by 1 position
 	\ 	Reset cell value to 0
 	* 	Replace value with random from 0 to current value
 	~ 	Swap cell and register values.
Memory pointer 	( 	Previous memory cell
 	) 	Next memory cell
 	' 	Jump to cell 0
Seeking 	@ 	Go to the position/instruction specified by cell value
 	^ 	Seek forward by number of instructions specified by cell value
Jumping 	| 	Just an instruction marker. Useful in conjunction with the following instructions.
 	_ 	Jump to the first marker to the left
 	= 	Jump to the first marker to the right
 	$ 	Jump to the n-th marker, according to cell value
Conditions 	& 	If cell value is 0, skip next instruction
 	’ 	If cell value is 0, exit
I/O 	: 	Read one wide character from stdin and store in current cell
 	; 	Print current cell value as a character to stdout
* Every other character must be ignored, so they can be used in comments or to add a hashbang (#!/usr/local/bin/duh).
* In comments, prefer lower-case letters. Uppercase letters may be used for debugging functions (this is up to the interpreter).
* Syntax may change. The main source of documentation is the official README file.
== Implementations ==
* blu.256's "official" Duh interpreter (on GitHub). Examples are included.
Category:Languages Category:Implemented Category:Cell-based
DukkTap

DukkTap is an esoteric programming language that acts like a piece of duck tape. It's inspired by an idea in the idea list section of esolang.
==Commands==
DukkTap has 7 commands.
Command 	Function
Unroll 	Unrolls tape roll, ready to be cut.
Cut 	Cuts a piece of tape off the roll.
Stick 	Sticks ripped tape onto table, ready for scribbling.
Scribble 	Use a marker to scribble on the piece of tape.
Self-Stick	Makes a tape ring.
Unstick 	Unstuck from surface.
Throw-Away	Throws the tape away.
When you Unroll the tape, it is ready to be cut. Once cut, you stick it to a surface of your choosing or you can stick it to itself to make a ring (code Loop). Once stuck, you can scribble (code) on it. Then, when you're done, you can Unstick it, and throw it away (runs the program).
==Examples==
Here's how you scribble hello world on it.
Unroll
Cut
Stick to wall
Scribble "Hello, world!"
Unstick
Throw away
Here is a ring program (loop).
Unroll 
Cut
Stick to self
Scribble "DukkTap for sale. Was $2 now $1."
Throw Away
You don't Unstick the ring unless you don't want to have a ring (loop) forever. You can make remarks about the tape (comments) by scribbling on the surface of your choice.
Category:Cell-based
Category:2018
Category:Languages
Category:Output only
DumbScript

This is an esoteric programming language made in C# by Doomguy0505.
Hello World
O|--< @--- str
O|--< 1+1=2 int
O|--<_IS_>--|O @--- zzz str "Joo suck monkey balls!"
O|--<_IS_>--|O 1+1=2 zzz int 20
x*y=x*y zzz 10 int
[blah_blah_blah] >>>> str
[blah_blah_blah] >>>> int
patience anakin
===Spec===
*O|--< (type) (varname)
**Creates a variable
**[type] can be "1+1=2" (double), "@---" (string), "<><><><>" (byte), "#,#,#" (double array), "@---,@---,@---" (string array), "*<><><><>,<><><><>,<><><><>" (byte array)
*O|--<_IS_>--|O (type) (access-style) (varname) (value)
**Sets a variable
**[access-style] can be zzz (constant) or >>>> (variable)
**[value] is a quoted string "this\nis\na\nstring" for strings and a number for doubles eg. 10
*[blah_blah_blah] (access-style) (value)
**Writes out to the console
*x+y=x+y (access-style) (value) (varname)
**Adds value to the variable
*x*y=x*y (access-style) (value) (varname)
**Multiplies the variable by the value
*x/y=x/y (access-style) (value) (varname)
**Divides the variable by the value
*x\y=x\y (access-style) (value) (varname)
**Integer divides the variable by the value
*x^y=x^y (access-style) (value) (varname)
**Powers the variable by the value
*x|y=x|y (access-style) (value) (varname)
**Does a bitwise or on the variable by the value
*x&y=x&y (access-style) (value) (varname)
**Does a bitwise and on the variable by the value
*x<<y=lshift (access-style) (value) (varname)
**Does a left bitshift on the variable by the value
*x>>y=rshift (access-style) (value) (varname)
**Does a right bitshift on the variable by the value
*x-xor-y=x-xor-y (access-style) (value) (varname)
**Does a bitwise eXclusive OR on the variable by the value
*!x=!x (varname)
**Does a bitwise NOT on the variable
*if (access-style) (varname) (line)
**If the variable is not 0 then the interpreter will skip to the specified line
*N0-W41
**Exits
*<!>
**Prints "We got j00 now sneaky cow!\007", making a beep
*patience (jedi name)
**Waits for user input, depending on the jedi name on how it does
**[jedi name] can be "anakin", "obi-wan" or "yoda"
***anakin is impatient so he waits for you to press one key
***obi-wan is patient so he waits for you to press enter
***yoda is very patient so he waits for you to press enter 100 TIMES!
*moo
**Shows the secret cow that feeds the program fresh milk
===Download===
Source Code 
Executable 
Category:Languages
Dumb self-modifying language

Dumb self-modifying language is a very dumb self-modifying language by User:None1.
==Commands==
It is brainfuck, but with one extra command:
x	Modifies the program into ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
==Examples==
===Hello World===
 x
===Cat Program===
 ,[.,]
==See also==
* brainfuck
* Hello World
Category:Languages
Category:Joke languages
Category:Brainfuck derivatives
Category:Turing complete
Category:2023
Category:Unimplemented
Category:Self-modifying
Dumbf*ck

Dumbf*ck is a Brainfuck-derived esoteric programming language, announced by Cliff L. Biffle on April 24, 2001. 
It uses 8-bit cells and has the following 7 commands:
 < Moves pointer one cell to the RIGHT
 > Moves pointer one cell to the LEFT
 / Cell value is rotated right 3 times 
 . Low-order bit is flipped
 , Outputs cell value
 ' Inputs cell value
 ? If the low-order bit of the cell at the pointer is set, continue execution at the previous `?', otherwise continue at the next `?' 
==Examples==
Prints "Hello":
 ././/////,<.////././.,/.///////.,,.///./////,
==Implementation==
An implementation was written by Eyob Tsegaye on September 13, 2015. Interpreter can be found here.
==Status==
Dumbf*ck was announced on the Esolang mailing list. The author described the language's title as "tentative", and due to reader response took suggestions for modification of the looping construct (which unfortunately makes half of the code unreachable). Neither a final title nor an officially declared new looping construct were ever announced, although several variants were discussed on the mailing list.
User:Ihope127 decided to "fix" this language, to make the following:
 < Moves pointer one cell to the left
 > Moves pointer one cell to the right
 / Cell value is rotated right once
 ! Low-order bit is flipped
 . Outputs cell value
 , Inputs cell value
 ? If the low-order bit of the cell at the pointer is set, reverse execution direction
==External resources==
* Mailing list announcement
Category:Languages
Category:2001
Category:Cell-based
Category:Unknown computational class
Category:Brainfuck derivatives
Category:Implemented
Category:Low-level
Dumpster Fire

An interpreter can be found here
A language designed so you can light a dumpster fire.
Made by Vortetty
==Overview==
Instruction 	Description
find <container name> 	Finds a container to burn
open <container name> 	Opens found container
write <page number> <message> 	Writes a note in your journal
toss <page number> <container name>	Tosses note on specified page into opened container
burn <container name> 	Burns opened container
close <container name> 	Closes opened container, it cannot be reopened after this
==Examples==
===Hello World===
 find dumpster
 open dumpster
 write 1 Hello, World!
 toss 1 dumpster
 burn dumpster
 close dumpster
Dunka!

Dunka! is an esoteric programming language made by User: Areallycoolusername in 2006.
The name comes from the incorrect spelling of the German word "danke" in a club penguin chat. There are six commands in the language. And those are "D, U, N, K, A, and !".
Command	Function
D 	Prints a value
U 	Uses a value
N 	nullifies a value.
K 	Kills process (used to end loops)
A 	Asks for user input
! 	Insert value and marks value
The Dunka! language is cell-based, and utilizes ASCII decimal codes. It also has two extra codes called 30 and 03 to start and end loops. Kill process is only here to end infinite loops. E asks for user input and can only accept strings and integers in their ASCII format. N nullifies or deactivates a value, since there is no delete command. U uses a value and is also used by D to print a value. All arithmetic symbols are in ASCII format. You insert values by just typing the ASCII code. D prints a value given to it by U. And ! inserts a value. U can be used right after a ! command for easier use. Here's a hello world program in Dunka! 
! 72-101-108-111-32-119-114-100 U
D 72-101-108-108-111-32-119-111-114-108-100
Programs are easier to write than it looks in this language.
Duocentehexaquinquagesimal

Not to be confused with 256.
Duocentehexaquinquagesimal is a language by User:Makonede. It is a derivative of Golunar, which itself is a derivative of Unary, which itself is a derivative of BF. It operates in nearly the same way as Golunar, except that the number is given in Base256, or duocentehexaquinquagesimal. This language uses 05AB1E's SBCS and base conversion system to encode programs.
=Examples=
==Hello, World!==
 1Ƶ¸ñ=öu¯2–sε`;ÈùˆζT¿āΔIÈ3Wÿ»
==Cat==
 ßD
==Truth-machine==
 RÃ
==Reverse cat==
 ;&Oo
==Adder==
 3Σª;â
==Primality tester==
 7 ÇÇW∞DćƒΣZ;ndž“~3¦€`н¸k
==Infinite loop==
 2º
==Screamer==
 2ïÛ∞è¥₁Ú
=Interpreter=
An interpreter in Zsh can be found at Try it Online. The header and footer do all the work, the Duocentehexaquinquagesimal code goes in Code, and the input to the code (if any) goes in Input.
=Generator=
A BF to Duocentehexaquinquagesimal converter in 05AB1E can also be found at Try it Online. BF code goes in Input, and the generated code will be in Output.Category:LanguagesCategory:Turing tarpitsCategory:Brainfuck derivativesCategory:Brainfuck equivalentsCategory:Low-levelCategory:2021Category:Turing completeCategory:ImplementedCategory:Cell-based
D♭♭

== Introduction ==
In music, there are a couple rare marks known as "Double flat" and "Double sharp". While a sharp or a flat raises or lowers the pitch half a tone, respectively, double flats and double sharps raise or lower the pitch one full tone. Since D is one full tone above C, D double flat IS C. Therefore, the language D♭♭ IS C as well.
=== Pronunciation ===
D♭♭ is pronounced "Dee double flat."
=== Examples ===
Hello World:
#include <stdio.h>
int main() {
 printf("Hello, World!");
 return 0;
}
Quine:
main(a){printf(a="main(a){printf(a=%c%s%c,34,a,34);}",34,a,34);}
FizzBuzz:
#include <stdio.h> 
 
int main(void) 
{ 
 int i; 
 for (i=1; i<=100; i++) 
 { 
 if (i%15 == 0) 
 printf ("FizzBuzz\t"); 
 else if ((i%3) == 0) 
 printf("Fizz\t"); 
 else if ((i%5) == 0) 
 printf("Buzz\t"); 
 
 else // print the number 
 printf("%d\t", i); 
 
 } 
 
 return 0; 
}
Cat:
#include <stdio.h>
int main(void) 
{
 char name[20];
 fgets(name,20,stdin);
 printf(name);
 return 0;
}
== See also ==
* B sharp
Category:Languages
E

E is an object-capability language designed by Mark S. Miller in 1996 and implemented at Electric Communities by a team including Miller, Dan Bornstein, Chip Morningstar, and Douglas Crockford in 1997. It is notable for refining the unification of objects, capabilities, and actors pioneered by Joule; in E, a reference to an object is a capability to send messages to that object, and every object may be invoked asynchronously like an actor. E also introduced the concept of E-ordering of messages.
== Hello World ==
The hello-world of object-capability languages is the following example, called "Simple Money" in Capability-based Financial Instruments but often unofficially called "The Mint".
 def makeMint(name) :any {
 def [sealer, unsealer] := makeBrandPair(name)
 def mint {
 to __printOn(out) :void { out.print(`<$name's mint>`) }
 to makePurse(var balance :(int >= 0)) :any {
 def decr(amount :(0..balance)) :void {
 balance -= amount
 }
 def purse {
 to __printOn(out) :void {
 out.print(`<has $balance $name bucks>`)
 }
 to getBalance() :int { return balance }
 to sprout() :any { return mint.makePurse(0) }
 to getDecr() :any { return sealer.seal(decr) }
 to deposit(amount :int, src) :void {
 unsealer.unseal(src.getDecr())(amount)
 balance += amount
 }
 }
 return purse
 }
 }
 return mint
 }
== Running E ==
Grab a pure-Java tarball like E-purej-0.9.3d.tar.gz from erights.org and extract it to a directory of your choice. Install a JRE (Java runtime environment) and also rlwrap. Then open a shell in the extracted directory and run:
 $ rlwrap ./rune
 ?
You should get a "?" prompt. Try some arithmetic:
 ? 1 + 1
 # value: 2
== Related Links ==
* wikipedia:E (programming language)
* the E homepage, an important archeological dig site
* Miller 2006, Mark S. Miller's thesis "Robust Composition", which contrasts E with Java and explains how to safely load code
Category:Implemented Category:1996 Category:Turing complete
E++

E++ is a language made by me. It is a joke language. It is a copy of E (eeEee).
AAAAAAAAAAAAAAAAAAAAAAAAAAA:
 EAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEAEAAEAEEEA
Thanks, and bye.
Category:Joke languages
Category:Languages
E-language

Elang is an Esolang developed by Wu Tao.
== Intro ==
Elang is a programming language that supports programming based on Chinese, fully visualized, and cross-mainstream operating system platforms, and supports programming tools that support full use of API, COM, DLL, OCX components, various mainstream databases, various utilities and other resources. Yi Language has a self-developed high-quality compiler, in addition to supporting the visualization of interface design, but also supports the real-time visualization of program flow, there are more than 40 support libraries, users can use it to meet almost all Windows programming needs.
== More detail ==
For more detail, please goto Elang Website.
== Categories ==
Category:Languages Category:Before 1993 Category:CJK