nyuuzyou/wikis huggingface dataset:
E62qpodb593

E62qpodb593 is an esolang made by AlexIsOK using the license Unlicense.
== Instructions ==
This language uses simple instructions:
Name 	Character
Start a loop 	e
Copy value at pointer to clipboard 	z
Increment value of stack at pointer 	q
Decrement value of stack at pointer 	p
Output value of stack at pointer to standard output	o
Move pointer to the right 	d
Move pointer to the left 	b
Set value at pointer to clipboard 	2
End loop 	3
Increment value at stack if lower than clipboard 	6
Decrement value at stack if lower than clipboard 	9
Go up five values (same as qqqqq) 	y
Go down five values (same as ppppp) 	k
GOTO the HOME address (usually 0) 	5
Set the value of the stack at pointer to 0 (NUL) 	0
Set the value of the stack at pointer to 64 (@) 	t
== Looping ==
The amount of times to loop is stored in the pointer address 4, meaning that the maximum times you can loop is 127. The language does NOT support nested loops.
== Examples ==
=== Hello World ===
The current shortest version of outputting "Hello, World!" made by AlexIsOK is 72 bytes.
tqqqyoyyyyyypoyqqooqqqoztkkkkotkkkkkkppotyyyyyppo2oqqqokpokkqqotkkkkkkpo
Broken down:
 tqqqyo #set the pointer address of pointer#0 to 67 (H) and output
 yyyyyypo #e
 yqqoo #ll
 qqqo #o
 z #copy to clipboard
 tkkkko #,
 tkkkkkkppo #space
 tyyyyyppo #W
 2 #paste 'o' to stack value
 o #output 'o'
 qqqo #r
 kpo #l
 kkqqo #d
 tkkkkkkpo #!
=== Alphabet ===
To print out capital letters A through Z, you can use ddddyyyyydteqo3.
Broken down:
 dddd #goto address to set amount of times to loop
 yyyyy #set the value of address 4 to 25.
 d #move to the right one
 t #set the new address value to 64 (@)
 e #start the loop
 qo #increment and output (A) is after (@)
 3 #end loop
== Implementations ==
The original implementation is in Java, which can be found here.
The same repository also hosts an implementation for JavaScript and C++.
EDE

EDE (Esolang Defenition Esolang) is an esolang that every program defines an interpreter.
== Brainfuck interpreter ==
 define a pointer
 define b string-ascii
 ----------
 > moves a forward on b
 < moves a backward on b
 + increases b at spot of a
 - decreases b at spot of a
 , replaces b at spot of a with input
 . puts b at spot of a in output
 [ goes to ] if b at spot of a is 0
 ] goes to [ if b at spot of a is !0
== Deadfish interpreter ==
 define a number
 ----------
 i increases a
 d decreases a
 s squares a
 q outputs a
 ----------
 if a=256, a=0
 if a=-1, a=0
== Truth machine interpreter ==
 ----------
 0 outputs 0
 1 outputs 1
 ----------
 when output 1, output 1
== Conway's game of life interpreter ==
 ----------
 ----------
 o touching 4o is b
 o touching 7b is b
 b touching 3o 5b is o
 ! ruletype=ca-moore !
== my-new-esolang.txt interpreter ==
 define a accumulator
 define b temp
 define c boolean
 ----------
 P outputs rotate25 lowercase
 I input to a
 C input boolean to c
 { rotate1 a character
 >b- if a is b
 <b: if c is b
 ) goes to (
Category:Turing completeCategory:UnimplementedCategory:LanguagesCategory:2024Category:Meta-languages
EGL

EGL (Esoteric Gridding Language) is a two-dimensional fungeoid esoteric programming language designed by User:Sato.
==Commands==
Cmd 	Meaning
, 	Separates dimension values
: 	Begins the program
> 	Go right
< 	Go left
^ 	Go up
v 	Go down
_ 	Reflect position over x
|	Reflect position over y
% 	Reflect position over origin
x 	Input
+ 	Increment
- 	Decrement
( 	Start loop
) 	End loop
= 	Output value
# 	Output grid
==Structure==
An EGL script begins with the grid's dimension settings, which are in the format x,y.
:Example: 10,10 will set the grid dimensions to 10 by 10.
After the dimensions are set the program begins with a colon.
:Example: 10,10: will produce an empty grid with 10 boxes along the x axis and 10 boxes along the y axis.
Transport operators are utilized in order to traverse throughout the grid. They are >, ^, <, v, _, |, and %.
:Example: 10,10:v>>_ will set the current position to row 9, column 3.
Arithmetic operators are utilized in order to manipulate an element's value.
:Example: 10,10:v>>_++ will set the element at row 9, column 3 equal to 2.
Communication operators are utilized in order to interact with the client.
:Example: 10,10:v>>_++= will output 2.
:Example: 10,10:v>>_x will set the element at row 9, column 3 equal to a user defined value.
:Example: 10,10:v>>_++# will output the following grid:
 |0|0|0|0|0|0|0|0|0|0|
 |0|0|0|0|0|0|0|0|0|0|
 |0|0|0|0|0|0|0|0|0|0|
 |0|0|0|0|0|0|0|0|0|0|
 |0|0|0|0|0|0|0|0|0|0|
 |0|0|0|0|0|0|0|0|0|0|
 |0|0|0|0|0|0|0|0|0|0|
 |0|0|0|0|0|0|0|0|0|0|
 |0|0|0|0|0|0|0|0|0|0|
 |0|0|2|0|0|0|0|0|0|0|
Loops begin with an open parenthesis, (, and end with a close parenthesis, ). The code within the parentheses will continue to be executed until the element that the loop was declared on is equal to 0.
:Example: 10,1:++(>+++++<-) will set the element at 2,1 equal to 10.
==External resources==
* More information and an online interpreter can be found at detain.me .
Category:Languages
Category:2012
Category:Cell-based
Category:Unknown computational class
Category:Two-dimensional languages
Category:Unimplemented
Category:Low-level
EGSHEL

EGSHEL (the Extensible Golfing Scripting High Efficiency Language) is a highly extensible pseudoesoteric stack-aware object-oriented scripting language in development by intended partially for golfing, but which can also be implemented in more useful circumstances as a 'real' scripting language, and which can be built upon and used for almost anything.
== Modes ==
EGSHEL implements two main modes, Concise (designed for golf) and Verbose (designed for readability and ease of use). In Concise, variables may only be uppercase A-Z, and builtins are bound to lowercase a-z. Most operations in this mode only take a few characters, though still far more than stack-oriented golfing languages. In Verbose, most builtins don't exceed 3 characters, and the preferred syntax changes. Concise code may be run in Verbose mode (the parser's default) but not the reverse. 
== Syntax & Grammar ==
EGSHEL has access to a few unique and interesting features:
Operator	Example 	Explanation
0-9 	A3 	variable names cannot contain numbers 0-9 and if there's no assignment operator this must be Concise, thus A is 3.
@ 	B@AC 	defines B as a listener on A and C concatenated, such that when A or C's values change, B's value is automatically updated
~ 	C2~B 	defines C as B's 3rd history index, aka what B was 3 values ago
- 	- comment	single line comment delineator
To decrease character counts, EGSHEL eliminates most delimiting grammar and punctuation, instead preferring semicolons or newlines to (for example) close strings.
== Examples ==
=== Hello, World! ===
Concise: (15 bytes)
 v'Hello, World!
Verbose: (18 bytes)
 vsb'Hello, World!'
Verbose mode prefers close single and double quotes and verbose statements. Whitespace, however, is still unneeded.
=== 99 Bottles of Beer ===
Concise: (91 bytes)
 A"Take one down, pass it around" on the wall," bottles of beer*99;B@~2AC@~1A".;{:A:vBC2~A,-A
 2~A 1~A ~A A
 A"Take one down, pass it around" on the wall," bottles of beer*99; -| define A as all the constructs we need, one after another
 B@~2AC@~1A".; -| make B listen on a chronoconcatenation of A and its 2 previous values; make C listen on A and its most recent value
 {:A:vBC2~A,-A -| for I in A: print B, print C, print A's oldest value, decrement A
==External resources==
* GitHub
Category:Languages
Category:2015
Category:Golfing language
Category:Unimplemented
EINE

EINE means 1 in German, as opposed to NULL, which means 0.
==Instructions==
EINE has all the instructions in NULL, but unlike NULL, it has one dimension.
2 	Select the next queue (wrapping around).
3 	Select the previous queue (wrapping around).
5 	Output the byte at the front of the selected queue (NUL if the queue is empty). NUL is '\0' (ASCII character 0).
7 	Input one byte and replace the value at the front of the selected queue with it; or, if the selected queue is empty, enqueue the value there. It is currently undefined what to do when EOF has been reached.
11	Subtract the byte at the front of the selected queue (0 if the queue is empty) from y. If this makes y less than zero, y is set to 0.
13	Add the byte at the front of the selected queue (0 if the queue is empty) to y.
17	Add y mod 256 to the byte at the front of the selected queue, or enqueue y mod 256 there if the queue is empty.
19	Remove the byte at the front of the selected queue (use 0 if the queue is empty) and enqueue it to the rear of the next queue (wrapping around).
23	Remove the byte at the front of the selected queue (use 0 if the queue is empty) and enqueue it to the rear of the previous queue (wrapping around).
29	Remove the byte at the front of the selected queue.
31	Enqueue y mod 256 at the end of the selected queue.
37	If the selected queue is empty or the byte at the front of it has a value of 0, divide x by its smallest prime factor and multiply y by that number.
41	Switch the values of x and y.
43	End the program.
The instructions loop for every 14th prime number, meaning, for instance, 47 is equivalent to 2.
Instructions are prime numbers, and are separated by spaces.
==Examples==
These examples are factorized from the NULL programs.
===Hello, World!===
 3 3 3 17 31 73 127 139 167 227 277 283 283 311 389 449 449 463 491 491 571 631 643 653 719 751 823 907 941 947 1019 1031 1033 1039 1103 1163 1237 1303 1381 1481 1553 1613 1657 1667 1709 1753 1847 1867 1867 1877 1993 1993 2063 2113 2207 2281 2297 2311 2377 2437 2477
Note that because this esolang is 1D,
 3 3 3 17 31 17 5 13 31 17 5 11 11 19 17 5 5 13 29 29 17 5 11 17 3 17 5 2 13 17 5 11 13 17 5 29 17 5 31 29 17 5 19 29 2 17 5 11 11 19 17 17 5 31 17 5 13 19 3 31 5
Also works.
===Cat program===
 7 59 103
===Truth Machine===
 7 59 71 97 139 151 227 227 251 263 307 331 383 397 463 523 607
==Implementations==
The following is an EINE converter to NULL in Python, by User:None1. It requires the sympy package.
from sympy import isprime,primepi
k=list(map(int,input().split()))
z=2
r=1
p=1
for i in k:
 w=primepi(i)%14
 while p%14!=w:
 z+=1
 if isprime(z):
 p+=1
 r*=z
print(r)
And a NULL to EINE converter, makes use of EINE being 1D:
from sympy import factorint,primerange,primepi
k=factorint(int(input()))
p=list(primerange(0,44))
for i,j in k.items():
 for l in range(j):
 print(p[(primepi(i)-1)%14],end=' ')
Category:Languages Category:2024 Category:Implemented
ELIP/Unlambda

:
The ELIP Unlambda project is implemented using the Order preprocessor library. Order is a Lisp-like functional language, similar to Scheme (it even has call/cc, force and delay!) so it would be a good base for the Unlambda interpreter. Order's variables match the regex pattern 8[A-Z], or 8[A-Z][A-Z0-9] if "lib/ext_sym.h" is included. The combinators are implemented as Order lambda functions. They all begin with 6, and 6dot(string) is the .x output operator.
#include <order/interpreter.h>
#define ORDER_PP_DEF_6i			\
	ORDER_PP_FN(8fn(8A,		\
		8A			\
	))
#define ORDER_PP_DEF_6v			\
	ORDER_PP_FN(8fn(8A,		\
		6v			\
	))
#define ORDER_PP_DEF_6k			\
	ORDER_PP_FN(8fn(8A,		\
		8fn(8B,			\
			8A		\
	)))
#define ORDER_PP_DEF_6s						\
	ORDER_PP_FN(8fn(8A,					\
		8fn(8B,						\
			8fn(8C,					\
				8ap(8ap(8A,8C),8ap(8B,8C))	\
	))))
#define ORDER_PP_DEF_6dot(arg)			\
	ORDER_PP_MACRO(8fn(8A,			\
		8chain(				\
			8put(8(arg)),		\
			8A			\
	)))
#define ORDER_PP_DEF_6r				\
	ORDER_PP_FN(8fn(8A,			\
		8chain(				\
			8put(8(*NEWLINE*)),	\
			8A			\
	)))
#define ORDER_PP_DEF_6c			\
	ORDER_PP_FN(8fn(8A,		\
		8call_cc(8A)		\
	))
The combinators are complete, but there is no automatic translation from Unlambda into a form that can be used by the C preprocessor. This makes it a reduction instead of a true interpreter. Input is still not yet implemented, but can be done using a sequence of symbols as the source. The 6d function is not yet implemented, but it will probably use the 8delay builtin.
Category:Implementations
ELVM

ELVM is a compiler infrastructure (similar to LLVM) for esoteric (and some non-esoteric) languages. It can be used to compile C to many esoteric and other languages. An online demonstration can be found here.
ELVM is similar to LLVM but dedicated to esoteric languages. This project consists of two components - frontend and backend. Currently, the only frontend we have is a modified version of 8cc. The modified 8cc translates C code to an internal representation format called ELVM IR (EIR). Unlike LLVM bitcode, EIR is designed to be extremely simple, so there's more chance we can write a translator from EIR to an esoteric language.
Some backends include:
* Brainfuck
* Befunge
* Unlambda
* Whitespace
* Turing Machine
* Python
* Javascript
* C
* ... And many others!
Contributions, such as adding features (e.g. bit operations), adding backends, and others, would be welcome!
==Internals==
* Harvard architecture, not Neumann (allowing self-modifying code is hard)
* 6 registers: A, B, C, D, SP, and BP
* Ops: mov, add, sub, load, store, setcc, jcc, putc, getc, and exit
* Psuedo ops: .text, .data, .long, and .string
* mul/div/mod are implemented by _builtin*
* No bit operations
* No floating point arithmetic
* sizeof(char) == sizeof(int) == sizeof(void*) == 1
* The word-size is backend dependent, but most backend uses 24bit words
* A single programming counter may contain multiple operations
Category:Compilers
Category:Implementations
EML

EML stands for English-based Meta Language which is invented by User:A. It was created to help beginners to understand the syntax of a language without special help.
==Examples==
===Describe EML.===
Syntax is Syntax, is, ,, and English
English is a language that originates from England. In this case, it is a sentence written in the language of international communication used to describe the syntax of EML
is is an English word used to show equivalency. In this case, it can also show whether a syntactic item contains another syntactic item in EML via using ,.
, is an English punctuation used to describe a list of items. Here it can normally be used as a punctuation mark in English.
Category:Meta-languages
Category:2019
Category:Languages
ENTMPL

ENTMPL (for Easy Numeric Turing Machine Programming Language) is a very concise and obfuscated language for programming Turing machines, designed by Abraham Karplus. It simply consists of a list of nonnegative decimal integers and asterisks, separated by one or more whitespace characters. Comments may be included in parentheses.
== Machine ==
The Turing Machine is a single tape (infinite in both directions), finite symbol count, finite head state count machine with IO being the initial and final states of the tape. The initial head state is 0, and the tape is initially filled with zeroes to the left of the tape head, and the input under and to the right of the tape head (with the rest of the tape to the right after the input filled with zeroes). Zeroes may not occur in the input, and output is read from the starting position of the tape head to the right until a zero is reached.
== Program ==
The first two numbers in the program are the number of different tape symbols and the number of head states, respectively. The number of symbols or states may be replaced by an asterisk, indicating that it should be determined by the highest value in the source code (or input, for tape symbols). When a specific number in specified, all symbol or state numbers are taken modulo it. Following these two numbers are any quantity of five-tuples of numbers, each representing a rule.
=== Rules ===
The five numbers in a rule have the following meaning:
* Initial Tape Symbol
* Initial Head State
* Resultant Tape Symbol
* Resultant Head State
* Direction
Multiple rules may not have the same initial tape symbol and head state. A direction of 0 indicate left and 1 indicates right. Some or all of numbers in a rule may be replaced by single asterisks, with varying meanings. As an initial symbol or state, the asterisk is a wildcard, matching anything. As a resultant symbol or state, it indicates no change, and as a direction it indicates halting the program.
== Examples ==
=== Cat ===
 ( CAT ) * (Determine # of tape symbols from input.) 1 (Only one head symbol needed.)
 (First rule:) * (Whatever first tape symbol is,) 0 (the head state will be zero,) * * (so keep both) * (and end the program.)
=== Wolfram's 2,3 Machine ===
 (WOLFRAM 2,3) 3 2
 0 0 (->) 1 1 (R) 1
 0 1 (->) 2 0 (L) 0
 1 0 (->) 2 0 (L) 0
 1 1 (->) 2 1 (R) 1
 2 0 (->) 1 0 (L) 0
 2 1 (->) 0 0 (R) 1
Category:Languages Category:Turing complete Category:Unimplemented Category:Low-level Category:2011
EOF

EOF is a symbol indicating the end of a file. Since a source file is finite in length, EOF is the last symbol in most source files of esoteric languages, though this symbol usually isn't mentioned in the specification.
For example, Brainfuck defines 8 commands. EOF can be considered a 9th command meaning "end the program", but it's left out of the specification.
Some languages do not need EOF. For instance, Unlambda and Iota always have one more function primitive than apply operator (` or *), so there are only as many symbols in those languages as mentioned in their specifications.
==EOF as metadata==
Many esoteric programming language enthusiasts argue that EOF is not a symbol, but merely one way of expressing the length of a file, which is metadata. Indeed, it is possible to implement esoteric programming language interpreters and compilers by checking the length of the source file before loading it, rather than testing for an EOF symbol.
There exist languages that don't have an EOF symbol, such as languages using an image as source code. There are also two-dimensional textual languages, which, if the logic that EOF is a symbol is accepted, surely have two extra symbols: EOF and newline. Metadataists point to this apparently absurd situation as evidence that EOF should not be treated as a symbol. Thus, 1L really has only two symbols, and Unary only one.
Category:Concepts
EPL

EPL is an "enfiladal transzigular" programming language created by Hakware in 2007. It is based on the works of Project Xanadu and on Befunge and assembly language. It is intended to be the executable format for the experimental OS Project XANA.
EPL consists of nine instructions (though a few more are planned to be added), all of which are a single ASCII graphics character with an ASCII code between 0 and 65. The instructions are chosen to represent the actual operation when viewed in the x86 text console, though most higher-level fonts display them entirely differently. An EPL program is constructed of a number of documents (like files) in a xanalogical database system like XU88 (Udanax Green) or XANA. Each document's title consists of the instruction followed by any text. Only the first character of the title, the first link, and the first transclusion matter. The document itself, the rest of the title, and the rest of the links and transclusions are ignored. The first link points to another document which contains the data structure that constitutes the source operand, and the first transclusion points to another document which contains the data structure that constitutes the destination operand. By using the 3span of said pointers, one can pass the pointed-to data through other EPL code before interpreting the current instruction. Looping is done via the CHUG instruction.
Because EPL is nonlinear, it must be edited with a transzigular editor such as ZigZag, GZZ, FenFire, or Project XANA's Z2 interface.
==External resources==
* Project XANA
** The official EPL documentation
** Documentation on the Enfilade
** Documentation on transpointers and transclusions
* Wikipedia's entry on the Enfilade
* The Project Xanadu webpage (with various explanations)
EPL Main

EPL Main is a high-level assembler written in D by Timofeyka. EPL Main can be used as a regular language(like the same C), for osdev, it is useful in performance-critical moments, the development of microcontrollers.
EPL Main cannot be called a complex language. It is quite lightweight, unlike other assembly languages.
Implemented: - Basic commands(assignment, addition, subtraction, working with variables/functions, comparisons, etc.); - Libraries for developing operating systems.
==Hello, world Program for Windows==
 extern printf ExitProcess
 
 sect data
 string hello "Hello, world!"
 
 sect text
 gfunc main
 printf hello
 ExitProcess 0
 return
==External resources==
* Official website
* Official Discord-server
* GitHub repo
Category:Languages Category:Implemented
ESC!

ESC! is an esolang created by User:Ractangle
==Syntax==
Command	Action
\$...\ 	Makes a string and push it into the stack
\^...\ 	Appends an interger to the stack
\&...\ 	Duplicates the n th value on the stack
\*...\ 	Prints the n th value on the stack
(code)\	If the top value on the stack equal to the n th element on the stack, then do code. Otherwise skip the conditional
; 	Command spliter
\: 	Halt program
\. 	Start program
==Examples==
===Hello, world!===
 \. ; \$Hello, world!\ ; \*\ ; \:
Category:Languages Category:Stack-based Category:2024 Category:Unimplemented Category:Total
ESON

ESON is an Esoteric Knowledge Representation Format designed to be so easy to parse it melts Nazis' faces and burns out their eyes. The acronym "ESON" actually isn't an acronym, because it doesn't stand for anything. The language features Reverse Polish Notation and numeric literals in many bases.
== Design ==
ESON is a stack-based language for encoding a generalization of JSON-like data in a simple way. It allows for Lists, Sets, Tuples, Maps, Ordered Maps, Symmetric Maps, Binary Trees, General Trees, and optionally graphs. Being a stack-based language, the commands are almost entirely procedural. It is not Turing-complete, nor is Turing completeness even applicable to it, the same way TCness is inapplicable to XML.
== Lexing and Parsing ==
Lexing ESON can be done by simply splitting it by spaces. Parsing is done with a FOR loop iterating through the commands and executing them.
== Commands ==
Command 	Meaning
/[0-9_]+/ 	Push an integer (_ meaningless, can be used to separate digit groups)
/0b[01_]+/ 	Push an integer encoded in binary (_ meaningless, can be used to separate digit groups)
/0q[0-3_]+/ 	Push an integer encoded in quaternary (_ meaningless, can be used to separate digit groups)
/0o[0-7_]+/ 	Push an integer encoded in octal (_ meaningless, can be used to separate digit groups)
/0x[0-9a-fA-F_]+/	Push an integer encoded in hexadecimal (_ meaningless, can be used to separate digit groups)
/[0-9](\.[0-9]+)?	Push a float
/"[^\s]*/ 	Push a string delimited by the " and a space. Spaces encoded with %20, newlines with %0A, tabs with %09, vertical tabs with %0B and percent signs with %25.
/\(,*\)/ 	Create a tuple with len(com)+1 items by popping those items from the stack.
[] 	POP an integer n, POP n items, PUSH the list composed of those items in the order they were popped.
{} 	POP an integer n, POP n items, PUSH the set of those items
{:} 	POP an integer n, POP n 2-tuples, PUSH a dict mapping each first item in a 2-tuple to its second item
[:] 	POP an integer n, POP n 2-tuples, PUSH an ordered dict mapping each first item in a 2-tuple to its second item
{<=>} 	POP an integer n, POP n 2-tuples, PUSH a symmetric dict mapping each item in the pairs to their partner in a symmetric dict
_ 	PUSH a binary tree with no nodes.
.. 	POP an item, POP a 2-tuple of binary trees, PUSH a binary tree with the item at the root, with the trees as the left and right subtree respectively.
... 	POP an item, POP a list of ordered trees, PUSH an ordered tree with the item at the root, leading to the other trees as subtrees.
*:* 	POP a list of 2-tuples where the first part of the tuple is an item and the second is a set of integers, PUSH a directed graph, where each vertex contains an item, and points to the vertices whose list indices were contained in the corresponding set.
*<=>* 	POP a list of 2-tuples of items and sets of integers, PUSH an undirected graph, where each vertex contains an item, and joins to the vertices whose list indices were contained in the corresponding set.
==See also==
*MESON
Category:Declarative paradigm
Category:Stack-based
Category: Languages