nyuuzyou/wikis huggingface dataset:
Esoteric computer

Esoteric computer could be a computer that runs esoteric operating system on an esoteric processor?
Or maybe this could be called an esoteric computer? 
Or maybe a quantum computer or something similarly strange qualifies?
If "A computer is a device that can be instructed to carry out sequences of arithmetic or logical operations automatically via computer programming", then an Esoteric computer is a device that carries out its operations esoterically, or via esoteric programming.
Category:concepts
Esoteric data structure

An esoteric data structure is a data structure designed to be strange and different from other data structures. It may or may not serve a special purpose, or it may just be for fun. Esoteric data structures are useful because they provide new ideas for bases for programming languages.
== Example ==
Esoteric data structures can take the form of many things. For example, a data structure proposed by User: Areallycoolusername is called the "arch". It's based off of a deque. It's essentially a deque that has been twisted into a circle. Elements in this circle can be pushed on and popped off, but not without changing the surrounding elements in the arch.
== Potential Use ==
Esoteric data structures could provide new ideas for the esolang community, supplementing, or completely replacing the use of other common data structures such as the stack, queue, and deque. It would help further deviate esolangs from their practical counterparts. They can also be the data structures used to implement and execute esoteric algorithms. 
== See also ==
* :Category:Data Types and Structures, a list of esoteric data types and structures
* History (programming language)
Category:Concepts
Esoteric processor

Esoteric processors may exist only as thought experiments, or perhaps experimental processors could be counted as esoteric. If it is useful and in some sense or in some kind of computation better than previous processors, it probably can't be classified as esoteric. It could mean 2 things: It is (1) optimized to run some esoteric programming language or (2) implemented in some strange way. For every esolang, there is theoretically an esoteric processor.
In case 2, what features could an esoteric processor have? Trinary numbers, analog computing instructions, physical random number generator, instruction for division by some arbitrary number(7,13,100,12345), asynchronous operation, 7-bit bytes, 25-bit numbers, adjustable length numbers, etc.
A third definition could be that it is designed to run an esoteric operating system, whatever that is. Then there would be an esoteric computer.
Possible esoteric processor: Processor/1 ??
==Examples==
* Larry class of processors
==See also==
*AttoASM
*List_of_ideas#Ideas_related_to_esoteric_operating_systems.2C_esoteric_processors_and_esoteric_computers
==External links==
http://opencores.org
Category:Concepts
Español

Español is a language inspired on English but is in Spanish.
== Examples ==
=== Print "Hello World" ===
The next program prints "Hello World"
 Este programa envia a la consola el texto "Hello world"
=== Cat program ===
The next program does the Cat program
 Leer la pagina en esta wiki sobre "Cat program"
 Este programa simula ese programa.
=== Simulate a Turing machine ===
The next program simulates a Turing Machine
 Leer la pagina sobre la Maquina de Turing en Wikipedia.
 Este programa simula la Maquina de Turing y empieza en el estado cero.
== Proof that "Español" is uncomputable ==
Obviously Español is uncomputable, it can solve the Halting Problem:
 Ver un video sobre el problema de desicion.
 Resolver ese problema.
Category:Joke languages Category:Uncomputable Category:2020 Category:Languages Category:Unimplemented
Essays/A Defence of Brainfuck Derivatives

An essay by User:Hppavilion1
== Introduction ==
Sometimes, I just feel like playing Devil's Advocate. Brainfuck Derivatives are, indeed, a plague on the Esolang community. We have too damn many of them! But what if this wasn't a bad thing? What if BF derivatives are actually useful? This essay aims to study what the good parts of over-deriving brainfuck.
== Categorization of Derivatives ==
There are a number types of Brainfuck derivative. This section will categorize them. It should be noted, however, that a Brainfuck derivative can fall into more than one category.
=== Minimization ===
Brainfuck is, as it is, pretty minimal. However, some people aren't cool with that. They try to make it more minimal, which pretty much defeats the purpose of brainfuck being minimal but still usable.
==== Minimization at the Expense of Computational Class ====
Particularly bad derivatives of brainfuck minimize so far that they lose computational class and become sub-Turing.
=== New features ===
I'm pretty guilty of making these as-is. Some brainfuck derivatives attempt to take brainfuck and add features that aren't necessary to be Turing Complete, such as adding networking support.
=== Mixins ===
I've made one of these myself too. Brainfuck derivatives sometimes aim to mix brainfuck with another language, producing "Befuck" or "Brainbolge".
=== Unique Ideas ===
Every once in a while a Brainfuck derivative is created which adds something entirely new and unexpected. These are defended in the section "An Existing Base".
== Conclusion ==
Category:Concepts
Etcha

Etcha is an esoteric programming language designed by Chris Pressey sometime in or around February of 2009. It is a variation on BitChanger, and it also has only four instructions. Instead of a tape, program state is stored in an unbounded 2-dimensional playfield of bits. Instead of a tape head, Etcha has a turtle which obeys three commands: move forward one cell, turn right 90 degrees, and toggle pen state (up or down). The pen is an "XOR pen" which, when down, toggles the state of a cell whenever the turtle leaves that cell. The initial state of the pen is down. Each time the turtle turns 360 degrees, i.e. every 4th time the command to turn right is executed, the pen state is toggled (from up to down or vice versa.)
==Instructions==
Command	Mnemonic	Effect
+ 	FD 	Move forward one cell
> 	RT 	Turn right 90 degrees
[ 	WHILE 	Same as in BitChanger
] 	WEND 	Same as in BitChanger
==Example==
The Etcha program
 >+++>+++>+++>+++>[+]>>>>+
produces the following drawing:
 #####
 # 
 # 
 ### 
==Computational class==
Etcha is Turing-complete because BitChanger is Turing-complete, and BitChanger programs can be trivially translated to Etcha programs. Start the Etcha program with >>>> to initially lift the pen. Then:
 BitChanger becomes Etcha
 < >>>+>>>>>
 } >>>>>+>>>
 [ [
 ] ]
==See also==
* Zame
==External resources==
* 
Category:Languages
Category:Brainfuck derivatives
Category:Turing complete
Category:No IO
Category:Implemented
Category:2009
Eternity

Eternity is esolang concepted by user:Jabutosama. It could be maybe one of the most useful languages in the world, but has one meaningless problem which makes it just useless. 
It has clear, robust and beautiful syntax:
Hello world
 exc{prntscrn['hello world!']}
Brainfuck Interpreter
 bfint[code{insert code}exc:lib[]}]
World Of Warcraft Copy
 exc_vget{wwo[copyprogrm]ping:worldofwarcraft.com,test_conn,downld}
The language has nearly infinite applications in all fields where computer science reaches its wings. It is only a shame that it is not so widely known. A subtle note is that every program takes infinite time to compute. 
A eternity interpreter exists on the #esoteric char and here created by by the user user:CallowaySutton
Category:LanguagesCategory:Joke languagesCategory:UncomputableCategory:2015
Etl

Etl (pronounced like "nettle" without the n) is an esoteric programming language for transforming expressions. It stands for "Expression transformation language".There are three data types in Etl: pairs, varaibles and operators. Pairs are pairs of the said datatypes.
Pairs are written with parenthesies and arguments seperated by spaces. Operators start with a ! which is 
followed by any sequence of non-whitespace characters. Variables are all other sequences of characters.
Here is an example:
 (hello (((!0) foo) bar))
Programs are written as a set of replacement rules and a list of expressions to apply the rules to. Here is the syntax and how they work:
 rule swap (!S (a b)) -> (b a)
 (!S ((!S (a b)) c))
which outputs (c (b a)).
The general syntax for rules is:
 rule <name> <pattern> -> <replacement>
where <name> is replaced by a string of the name of the rule (currently there is no use for the name, one 
will be added in the future), and <pattern> and <replacement> are replaced by expressions.
=== Rule application process: ===
First we do a process called pattern matching which may or may not yield a mapping between the dummy names and actual expressions called "bindings".
For example when we match the expression (!S (a (b c))) against the pattern (!F (a b)) we get no match because the operator `!F`
doesn't have the same name as the operator in its place in the expression. However if we have the exprssion `(!S (x (y z)))` it matches 
producing the following bindings:
 {
 "a": x
 "b": (y z)
 }
Now that we have those bindings we can produce a different expression. That's what the replacement part of the rule is for.
Say that we have a rule
 rule swap (!S (a b)) -> (b a)
and an expression
 (!S (x (y z)))
Our rule is applied recursively outside-in.
So first the program generats the outermost bindings:
 {
 "a": x,
 "b": (y z)
 }
Then the language takes the replacement expression and replaces every instance of "a" and "b" with the corresponding binding.
In the end of evaluation our expression we end up with
 ((y z) x)
=== Undefined behaviour ===
What happens when you have two conflicting rules? What happens when there are variables in the replacement expression not found in the pattern?
I don't know! Experiment and have fun. This shouldn't be defined in the specification of the language because I am too lazy to research it.
=== Using the repl ===
Currently the programming language is only available as a repl. To exit it simply type `bye`.
== Example programs ==
 
=== reversing a linked list ===
 rule r1 (!R ((x y) (z))) -> (!R ((x) (z y)))
 rule r2 (!R (!0 x)) -> (x)
 (!R (((((!0 a) b) c) d) !0))
 
outputs:
 ((((!0 d) c) b) a)
=== SKI ===
Ski to show it is turing complete.
 rule S (((!S x) y) z) -> ((x z) (y z))
 rule K ((!K x) y) -> (y)
 rule I (!I y) -> (y)
 
Category:Functional paradigm
Category:String-rewriting paradigm
Category:Meta-languages
Category:2023
Category:Turing complete
Category:Languages
Euclid

The Euclid programming language is a stack-based / tape-based / befunge-like language created by User:TARDIInsanity. The program remembers which of a fixed set of states (spijmg) it is in, and as it comes across any instruction symbol, it performs some action based on the combination of state and symbol.
s - perform operations on the stack
p, i, j - perform operations on the program pointer, which always points to cells in the 2d program array.
i - (on finding an instruction) pop a value off the stack. if it is zero, ignore the instruction. unconditionally change state to p.
j - (on finding an instruction) perform the operation. change state to i.
m - perform operations on the memory array, which is a 1-dimensional finite tape initialized to all zeroes. Some memory instructions interact with the stack (mainly ^ which pushes the current cell and v which pops and writes from the stack)
g - perform an alGebraic operation on values from the stack. nearly all possible instructions pop two values from the stack, and most push one result value back. The instruction / represents divmod, with the following additional constraint: divmod(x, 0) = (0, x).
any of the ten digits 0-9 and the first six letters a-f (hexadecimal) are instructions.
the symbols ? = < > ^ v / ` | - x + are also instructions.
every instruction has a defined behavior for every mode.
the ` character is allowed as a substitute for the backslash character.
The creator's implementation of this language can be found here github.com/TARDIInsanity/Euclid.
Further documentation about the program's behavior is defined in the doc file. Usage notes for the implementation can be found in the readme file.
A simple truth machine implemented in Euclid:
 g86xmv^s+g-ivm|p+
 vp/m< 
 |||||||p>m|||||||
A simple "hello, world!" program:
 g3bxaaxc9x4abx+1abx+9abx+..pv
 vpx89+xaa1x9cx9c+xba1x4bx48g<
 >s|||||||||||||p+
Non-category features to note:
-Imperative paradigm
-Deterministic
-Not quantum, concurrent, reversible, or self-modifying.
-Has console IO
-Not in the list of known derivatives (partially derivative of befunge)
-Text-based code input
-Unsure about the theme or lack of a theme
Category:Languages
Category:2022
Category:Cell-based
Category:Stack-based
Category:Usability_unknown
Category:Push-down_automata
Category:Two-dimensional_languages
Category:Implemented
Category:Low-level
Eul

Eul is an esoteric programming language, created by User:Backspace. It has been desinged to be short and percise. It is a stack-based language.
=Naming=
Eul's name comes from words "eu", meaning "good" in latin, and "l", contradiction of word "language". It means "good language".
=Memory=
The only data structure in Eul is its single stack. This stack supports basic operations, such as push and pop, as well as other operations, including arithmetic operations, number to string conversion and others. Every item of stack is a 32 bit integer.
=Operators=
operator	what it does 	
~ 	Pops the first element. 	
[ 	Pops last element and pushes it to top. 	
] 	Pops the first element and pushes it to bottom. 	
+ 	Pops first two elements and pushes their sum. 	
- 	Pops first two elements, substracts them, and pushes result. 	
* 	Pops first two elements, multiplies them, and pushes result. 	
/ 	Pops first two elements, divides the second by the first, and pushes result. 	
% 	Pops first two elements, divides the second by the first, and pushes remeinder. 	
> 	Pops first two elements and pushes 1 if the second is greater, 0 if not. 	
< 	Pops first two elements and pushes 1 if second is smaller, 0 if not. 	
= 	Pops first two elements and pushes 1 if they are equal, 0 if not. 	
& 	Pops first two elements, performs logical and on them, and pushes result. 	
 	 	Pops first two elements, performs logical or on them, and pushes result.
$ 	Adds label at current location. 	
? 	If second element on stack is not 0, then jump to the label indicated by the first element of stack (indicates the number of label). Also, pop the first element. 	
! 	Pops the first element, performs logical not on it, and pushes result. 	
: 	Duplicates the first element. 	
_ 	Swaps first two elements. 	
# 	Pops first element, converts each of its digits into their UTF-8 values, and pushes these values. Basically, converts interger into string. 	
@ 	Pops specified number (by the value of first element) of elements, reads them as digits, and pushes all digits together to form an integer. Basically, converts string to interger. Also pops first element.	
. 	Used as a separator between to integer literals. Pushes an integer when coming directly after it, does nothing otherwise. 	
; 	If used at the beginning of program turns debugging mode on. 	
=Computational Class=
Eul has stack roll operations, which put the first item on stack to the back of stack or the last item on stack to the front. These operations (probably) make the language Brainfuck equvalent, thus Turing complete.
=Example programs=
* Hello World
 Hello, World!
* Cat
 
(empty program)
* Quine
 this is quine
 it is also quine
 a
* Print all ASCII characters
 0.0$~:1+:126<0?~
==External resources==
You can learn more about Eul at GitHub.
Eval

Eval is a stack-based esolang by User:PythonshellDebugwindow.
==Memory==
Eval uses two stacks, the left stack and the right stack, as well as a stack pointer, which can point to either of the stacks at any one time. The stacks can hold strings and integers.
==Syntax==
Eval programs are made up of characters, each one representing a command, except in stringmode and charmode, where characters are pushed to the current stack until another " is reached.
==Commands==
Normal mode commands (pop/push X means pop/push X from the current stack):
Command	Meaning
~ 	Switch the stack pointed to by the stack pointer
` 	Push 1 if the stack pointer is pointing to the left stack, else push 0
^ 	Pop A, push A, push A again
0 	Push 0
+ 	Pop A, push A + 1
- 	Pop A, push A - 1
* 	Reverse the current stack
? 	Pop A, skip the next instruction if A is falsy (0 or the empty string)
! 	Pop A, evaluate A as Eval code
" 	Toggle stringmode
' 	Same as ", but double quotes are prepended and appended to the resultant string
. 	Pop A, output A
; 	Pop A
= 	Pop A, push A to the non-current stack
In stringmode, a string variable res is initialized to the empty string. Then for each character c, the ` backquote character appends the " double quote character to res, the " double quote character exits stringmode, and all other characters append themselves to res. When stringmode is exited (or on EOF if stringmode is not ended), res is pushed to the current stack.
==Examples==
===Hello, World!===
 "Hello, World!".
===Infinite loop===
 "^!"^!
===Truth-machine===
Replace the second 0 (bolded) with 0+ for input 1.
 "0+.^!"^0?!0.
==Implementations==
A Python interpreter by User:Bangyen.
Category:Languages Category:2020 Category:Stack-based Category:Implemented
Eve

Eve is an event oriented language, which uses a stack for its computations. The only method of control flow is starting events. Events are kept in a queue, and events are run in the order in which they are popped out. Note that any new events will have to wait for all previous events to be run. Execution stops when the event queue is empty. All instructions in Eve are one character long, and any arguments to an instruction must follow it directly.
== Instructions ==
Instruction	Arguments 	Effect
0-9 	None 	Push the number onto the stack.
: 	Name of event 	Defines an event with the given name. Note that event names are one character long.
; 	None 	Ends an event definition.
+ 	None 	Adds the top two stack elements together, and pushes the result.
- 	None 	Subtracts the top two stack elements, and pushes the result.
* 	None 	Multiplies the top two stack elements together, and pushes the result.
/ 	None 	Divides the top two stack elements, and pushes the result.
% 	None 	Mods the top two stack elements, and pushes the result.
& 	None 	ANDs the top two stack elements together, and pushes the result.
 	None 	ORs the top two stack elements together, and pushes the result.
! 	None 	NOTs the top element of the stack.
= 	None 	Pushes true or false depending on whether or not the top two stack elements are equal.
> 	None 	Pushes true or false depending on whether or not the first value popped is greater than the second.
< 	None 	Pushes true or false depending on whether or not the first value popped is less than the second.
I 	None 	Pushes the ASCII code of the next char of input.
O 	None 	Pops a stack element, and prints it as a char.
$ 	None 	Duplicates the top stack element.
@ 	Name of event to queue	Enqueues the event given.
? 	Two events 	Pops from the stack. Enqueues the first event if the value is true, the second if the value is false.
== Examples ==
=== Cat ===
 :LI$01-=?ELO;:E;@L
Or, printed nicely
 :L I $ 01- = ?EL O ;
 :E ;
 @L
==== Explanation ====
 :L
Define an event named 'L' (it stands for Loop).
 I
Get a char of input.
Stack: <char>
 $
Duplicate it; One copy to maybe be printed, one copy to compare with EOF.
Stack: <char> <char>
 01-
Stack: <char> <char> -1
Push EOF (-1). There are no negative numbers in Eve, so we have to subtract from zero.
 =
Compare the char with EOF.
Stack: <char> <char == -1?>
 ?EL
Queue up the event E (for End) if the char equals EOF, requeue L otherwise. Note that this is not a branch! Flow continues to the end of the event.
Stack: <char>
 O
Print the character.
Stack: (empty)
 ;
End the definition of 'L'.
 :E ;
Define an event named 'E' that does nothing. This will be queued up as an exit to the program.
 @L
To start, queue up 'L'.
EvenOdd

I realized that even and odd numbers can be thought as 0 and 1, so I can make logic gates, or as I call them, parity gates
== And ==
 a*b
 this is an and because look
 even even: 2*2=4, even
 even odd: 2*3=6, even
 odd even: 3*2=6, even
 odd odd: 3*3=9, odd
== Xor ==
 a+b
 this is an xor because look
 even even: 2+2=4, even
 even odd: 2+3=5, odd
 odd even: 3+2=5, odd
 odd odd: 3+3=6, even
== Nand ==
 you can use the stuff I shown to make an nand gate
 1+(a*b)
 you could probably break this apart to figure this out
== The actual structure ==
 def a(some symbol)b: (some code) or def (some symbol): (some code)
 this defines a gate
== And and Not ==
 def a&b: a*b
 def !a: a+1
 def a@b: !(a&b)
Everett

= Everett =
A universe branching programming language by Atze van der Ploeg .
Everett is a new turing-complete, general purpose programming 
language that allows you to express your ideas simply and 
concisely. 
== Syntax ==
Everett has just one type of statement, namely 
"fromPlatonic ;". This powerful statement converts
what you want to make (i.e. something in the Platonic "idea" world)
into a sub-program that does just that.
An Everett program consists of multiple lines, each being 
one of the following:
* An empty line
* A comment, starting with '%'
* A statement
Spaces are not allowed! Except for the space between fromPlatonic and ; which is mandatory. Spaces after % are allowed.
== Semantics ==
In the many-worlds-interpretation of quantum mechanics 
there is actually not a single universe, but there is a
universe for each outcome of a quantum system. Since the
universe is a really big quantum system, this means that
time branches (infinitely?) many times per nanosecond, and
each possible outcome yields a new universe. 
Everett exploits these time-branching properties of the
universe to create the easiest, most powerful programming language ever. It does this by getting truly random bits
from http://random.irb.hr/ These bits are the result of
quantum measurements, and hence for each possible outcome
there is a universe. In this way, there is always a universe
where your idea is manifested into an executable (*). In this way,
Everett uses the same sort of idea as the Infinite monkey theorem
== Examples ==
File Hello.evr
 % The infamous "Hello world" example
 fromPlatonic ;
File Fallout10.evr
 % A somewhat larger example: A really cool game
 fromPlatonic ;
 fromPlatonic ;
 % Don't forget to clean up:
 fromPlatonic ;
File AI.evr
 % A virtual friend that does your chores and passes the turing test
 fromPlatonic ;
 fromPlatonic ;
 % Gain consciousness
 fromPlatonic ;
 % Implement Asimov's three laws
 fromPlatonic ;
 fromPlatonic ;
 % Below : Give meaning to everything
 fromPlatonic ;
 fromPlatonic ;
 fromPlatonic ;
 fromPlatonic ;
 fromPlatonic ;
-------------------------------------------
Usage :
# Get a login at http://random.irb.hr/
# Download the source code here (Currently only for Linux and Mac)
# Untar the archive and type cd Everett; ./make
# Run compiler by : everett user pass program.evr
# The resulting binary is in the same directory as the source, and has the same name (without .evr).
Example:
 > everett atzeus '********' AI.evr 
 Cheering up the monkeys...
 The monkeys are typing....
 Done! Try it out to see if this is the lucky universe!
 > ./AI
 Killlllll meeeeeeeeee
Category:Implemented
Category:Languages
Category:High-level
Category: Joke languages
(*) : If your idea is manifestable in a binary of 35 Mb or less