nyuuzyou/wikis huggingface dataset:
EsoKit/EsoKit.ek.math.mm

:
EsoKit.ek.math.mm, also known as the Material Measurements library, is a library in the EsoKit centred around doing measurement calculations in the form of material lists of objects ([metre(), metre(), metre()] is 3 metres), as opposed to just named values.
== Old Description ==
:This is from before it was incorporated into the EsoKit
Material Measurements is an esoteric library/API for Python (and, if you feel like porting it, other languages) that provides a way to convert between and use measurements of time, space, etc. in metric, imperial, and FFF in an alternative fashion to the usual system for programming.
== Principle ==
Instead of having a function that accepts a floating point quantity, a measurement for that quantity, and something to convert to, such as:
 convert(15, 'feet', 'metres')
Or a BUNCH of functions that each convert from a value and a type to a new system, such as:
 convertToMetres(3, 'feet')
or worst of all, a thing that converts measurement a to measurement b, such as:
 metresToFeet(3)
Or possibly any other system of converting measurements, Material Measurements accepts lists of quantities of things. This allows mixed measurements, and it is intuitive for some people. Here is an example in Python:
 from MaterialMeasurements import *
 dist = foot()*3
 
 convert(dist, metre)
This has the limitation that half feet don't work, but for that, inches can be used, like so:
 from MaterialMeasurements import *
 dist = [foot()*15, inch()*6]
 
 convert(dist, metre)
Anything that can be expressed in traditional units can be expressed in Material Measurements. Furthermore, entirely new units can be expressed in the system, for example acceleration:
 accelerationSpeed = (5*kilometre())/(second()**2)
EsoKit/EsoKit.nsi.io

:
EsoKit.nsi.io is an EsoKit nonstandard interface designed to allow languages such as brainfuck that are severely limited in their capabilities, to the degree of being able to do nothing to interact with extra-program things beyond input and output, to do things like socketry and file IO. Generally, EsoKit.nsi.io will need to be built in to the interpreter, as languages like brainfuck that are limited to this degree tend to lack library support.
== Interaction ==
To interact with EsoKit via EsoKit.nsi.io, data needs to be sent to the standard output to trigger an event, and return values are sent to the standard input as requested with a null terminator. This means that, if an EsoKit function is called in brainfuck that returns the string "walrus", the next six calls to , (brainfuck's getch() command) will return "w", "a", "l", "r", "u", and "s" in that order. The next call to , will return \0 (the null terminator) to alert to the program that the return string is over.
Messages are passed in the following manner:
* When the EsoKit.nsi.io layer is told to print, it first checks if the character it is told to print is a < (ASCII 0x3C) AND that it is not in "escape" mode. If so, it flips on a boolean putting it into "checking" mode.
** Once in checking mode, it stops printing until it encounters the > character (ASCII 0x3E) while not in escape mode.
*** Once it has finished the <...> string, it lexes it. It does this by splitting it by the first : (ASCII 0x3A) and then splitting the second value by spaces that are NOT enclosed in unescaped quotes.
*** It then passes the string arguments to the proper function, as indicated by the string before the :
* Else, if it encounters a backslash and is not in escape mode, it enters escape mode.
* Else, if it is in escape mode or the character is not a special character, it prints the character and sets escape mode to off.
=== In other words... ===
An "execution string" is a string in the code that is delimited by a <. and a > These can be escaped by backslashes to not start or terminate an execution string, and backslashes can be escaped by other backslashes. An execution string is a command, a colon, then a set of arguments separated by spaces. These arguments can contain spaces if delimited by double quotes. Double quotes can be escaped by backslashes, which can be escaped by backslashes, and so on. Strings can contain special characters, such as newlines, simply by putting them between the quotes (just like in LISP).
== Commands ==
Commands are the things before the : in an execution string. They are typically of the form lib.sublib*.command, but can technically be anything. They are followed by a colon, then by space-separated quotable/escapable arguments.
== EsoKit.nsi.io.err ==
EsoKit.nsi.io.err is a variation on EsoKit.nsi.io that is nearly identical in every way, save for one minor difference: messages are passed to the interface through the stderr as opposed to the stdout. Otherwise, they are indistinguishable.
EsoLogic

EsoLogic is an esoteric formal logic created because eso is fun.
== Operators ==
EsoLogic has the standard operators from most formal logics, in a typable format. These include (which are primitive depends on who's defining):
* φ&ψ: "φ and ψ"- logical conjunction
* φ|ψ: "φ or ψ"- logical disjunction
* ~φ: "not φ"- logical negation
* φ->ψ: "if φ then ψ"- implication
In addition, it borrows some things from other logics. For example, Temporal logic:
* Xφ: "Next"- φ holds at the next state
* Gφ: "Global"- φ holds at all future states
* Fφ: "Final"- φ has to hold at some point
* φUψ: "Until"- φ has to hold until ψ does, and can hold beyond.
* Hφ: "Historically"- φ has been true in the past
Fuzzy logic:
* Truth variables can have "degrees of truth" that are any real number such that 0≤n≤1
Epistemic logic:
* Kτφ: "τ knows φ"- Agent τ knows that φ is true
* Bτφ: "τ believes φ"- Agent τ believes that φ is true
Communication epistemic logic:
* Tτ,υΦ: "Tells"- τ tells υ that Φ (if υ trusts τ, then υ now knows/believes φ) (fails if ~Kτφ)
Deontic logic:
* Oτφ: "It is obligatory that τ φ"
* Pτφ: "It is permissible that τ φ"
* Fτφ: "It is forbidden that τ φ" (note that there's an operator collision here with Future)
And more stuff, when it is thought of.
Category:Concepts
EsoPy Framework

EsoPy Framework is a language/framework made by User:ce2lo. It provides a Python template for building esoteric programming languages. It includes a lexer and an interpreter, and a runner that ties everything together.
== Specification and instructions ==
There are the instructions of the default language within the framework:
 <VALUE> + <VALUE> Addition, also works with <VARR>.
 <VALUE> - <VALUE> Substraction, also works with <VARR>.
 <VALUE> * <VALUE> Multiplication, also works with <VARR>.
 <VALUE> / <VALUE> Division, also works with <VARR>.
 <VARR> = <VALUE> Assignation, also works with <VARR>.
 @ Text Comment a line.
 GOTO <LINE> Jump to a specific line <LINE> in the code.
 GOIF <LINE> <VARR> Jump based on the value of a variable. If the value of <VARR> is 0, the
 program jumps to the line <LINE>.
 INPUT <VARR> Input during runtime and store this input in <VARR>.
 PRINT <VARR> Print the content of <VARR>.
 END Terminate the program.
Since this project provides a Python template for building esoteric programming languages, the user can define its own esoteric programming language, the user can modify the keywords and symbols dictionaries to change the corresponding attributs. But he can also modify the special_characters list to include any special characters that he want to be use as variables names.
 keywords = {"PRINT":"PRINT", "GOTO": "GOTO", "GOIF": "GOIF", "INPUT": "INPUT", "END": "END"}
 symbols = {"=":"=", "+":"+", "-":"-", "*":"*", "/":"/", "(":"(", ")":")", "@":"@"}
 special_characters = ["?", "!", ">", "<", "@", "&", "|", "^", "~", "%", "$", "#", "_", "`", ":", ";", ",", ".", "[", "]", "{", "}", "\\", '"', "'"]
== Default examples ==
=== Hello World ===
 @ Simple Hello World program
 var = "Hello World"
 PRINT var
 END
=== Cat Program ===
 @ Simple Cat program
 INPUT a
 PRINT a
 GOTO 1
== Different versions of Fibonacci example ==
In this section, three different versions of the same program have been developed in different syntaxes to show how the framework works.
=== Example 1 (Default) ===
 @ Fibonacci sequence
 i = 0
 j = 1
 INPUT counter
 PRINT j
 k = i + j
 i = j
 j = k
 counter = counter - 1
 GOIF 12 counter
 GOTO 5
 END
=== Example 2 (Confusing) ===
 @@@ Fibonacci sequence
 & +-+ 0
 $$ +-+ 1
 >>> #
 <<< $$
 : +-+ & --- $$
 & +-+ $$
 $$ +-+ :
 # +-+ # +++ 1
 ??? 12 #
 !!! 5
 ...
=== Example 2 (Verbose) ===
 // Fibonacci sequence
 firstValue is 0
 secondValue is 1
 writeIn counter
 show secondValue
 tempoValue is firstValue plus secondValue
 firstValue is secondValue
 secondValue is tempoValue
 counter is counter minus 1
 ifZeroJumpTo 12 counter
 jumpTo 5
 finish
==Framework==
* EsoPy Framework (GitHub) Python template for building esoteric programming languages
Category:2024
Category:Languages
Category:Turing complete
Category:Implemented
Esofish

by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
Deadfish with one instruction: r
R runs the remaineder of the program as the accumulator.
For example,
 iissdr `Hello, World!`
runs `Hello, World!` as a 15 program, so it prints Hello, World!
It is turing complete because it can run 35, which is Turing-complete
Category:Turing complete Category:Joke languages Category:Languages Category:2024 Category:Unimplemented Category:Deadfish derivatives
Esolang Quality Rating System

NOTE: Still needs a lot of work......
====Base Score====
Type 	Base Score
Completely Original	60
Derivation 	55
Subset 	45
Carbon Copy 	0
====Talk Page====
Type 	Base Score
No comments 	-20
<5 comments 	-10
>=5 comments	0
====Computational Class====
Computational Class	Add
Proven 	+10
Assumed 	-10
Unknown 	-20
====Implementations====
Note: This only applies to computable esolangs.
Implementations	Add
None 	-20
<3 	+0
>=3 	+10
====Examples====
Examples	Add
None 	-20
<3 	-5
>=3 	0
>5 	+10
You can add anything -5 to 5 based on discretion
Esolangs

Esolangs is a joke language designed by User:RocketRace.
Hop between any program in any language on esolangs.org!
== Syntax ==
An Esolangs program consists of sequentially executed program calls of the following syntax:
 language<program>
Any special characters (<, >, =, -, and any whitespace) within the language name must be escaped with backslashes (\). Angle brackets within programs must be escaped as well. Double backslashes yield a single escaped backslash.
Valid languages are all esolangs on esolangs.org that are categorized with "Languages" and "Implemented".
The output of each program call can be piped to other languages as programs, using the `=>` syntax, or called once more if the output is a valid language:
 brainfuck<-.> => Malbolge
 ///<\\/\\/\\/><>
Pipes can be combined indefinitely. <> calls can also be chained indefinitely. 
Note that languages that are piped into don't require <> to call.
The script can be in multi-line.
== I/O ==
Program input (not the programs themselves) must be in binary, encoded to text if necessary. 
Thin pipes leading nowhere are redirected to stdout:
 Whitespace< > ->
Unsourced thin pipes are drawn from stdin:
 -> brainfuck<+[,.]>
There may be only one of each per line, and they must reside at the end and start of the line, respectfully. 
A program's output may be treated as another program's input:
 Babalang<baba is you> -> Rui<:1>
== Computational class ==
It's got to be Turing-complete, admit it. Proof by hand-waving.
== Examples ==
=== Cat program ===
 ->
=== Hello, world! ===
 brainfuck<+[--\>-[\>\>+\>-----\<\<]\<--\<---]\>-.\>\>\>+.\>\>..+++[.\>]\<\<\<\<.+++.------.\<\<-.\>\>\>\>+.>
Another one:
 Stuck<>
Readable: 
 Python<
 print("Hello, world!")
 >
Category:Languages
Category:Joke languages
Category: Unimplemented
Category:Turing complete
Category:Uncomputable
Esolangs.org

Esolangs.org is an esolang which can be any or all esolangs. It has no specific anything (apart from a few built-in instructions) and may do anything any other language can, as long as it exists on esolangs.org. 
== About Program ==
This page is a valid Esolangs.org program.
== Format ==
A program is formatted like a wiki page, starting with an infobox proglang template, then a short summary of it's purpose. The contents of the template and the introduction can be whatever.
At least two categories are required, the first being anything more specific about the program itself, such as dependencies or performance, the last being the actual code to run, wrapped in a <pre> tag, tag or indented with a single space.
Anywhere within the program must be at least one category assigned to it. It does not matter where it is or what the category is (if it even exists), there just has to be one.
An example would be:
<nowiki>
{{infobox proglang
|name=Example
|author=Person
}}
Example is a program example.
== Example Category ==
Meta category talking about itself.
== Program ==
<pre><nowiki>
[[brainfuck]]
{{Load|brainfuck}}
+++++[>+++++++<-]>.
</nowiki></pre>
[[Category:Examples]]
</nowiki>
== Instructions ==
While the instructions used within an Esolangs.org program are defined by the esolangs used, there are built-in ones in place to even begin doing so.
Instruction 	Wiki 	Description
[[<page>]] 	References the page with the name <page> as a link.	Initializes the language. Does not have to be an esolang.It still has to be a valid page. Whatever a non-esolang page does is up to interpretation.
{{Load|<page>}} 	Uses the Load template. 	Starts interpreting the following text as the language. If a previous language was already loaded, they both interpret at the same time.Assuming the code is properly structured. Interpretation happens from and to the start and end of any instance of valid code within the language.
{{Clear}} 	Uses the Clear template. 	Stops interpreting any actively interpreting languages, all future text will be ignored unless a new language is loaded.
[[File:<file>]] 	Displays a file, like an image. 	Loads a fileDoesn't have to be a valid uploadable file. <file> is the path to a file. as if it were text, for languages that use non-textual programs.
<nowiki> ... </nowiki> or <pre> ... </pre>	Doesn't apply wiki formatting to text. 	Makes code plaintext, disallowing interpreting.
<!-- ... --> 	Comment. 	A comment.
== Program ==
<nowiki>
[[HQ9+]]
{{Load|HQ9+}}
Q
{{Clear}}
</nowiki>
Category:Meta-languages Category:Languages Category:Uncomputable Category:2024 Category:Turing complete
Category:Examples
Esolangs (irc)

esolangs is an IRC bot maintained by fizzie that supports the official esoteric languages community IRC discussion channel. It usually uses the nick "esolangs". It performs four functions.
* It logs all activity on the channel. These logs are published on the web.
* It notifies the channel about all edits to this wiki.
* For a short time while the channel was moving from Freenode IRC network #esoteric to the Libera IRC network #esolangs it forwarded messages between the channels on the two networks.
* Since 2024-08, it also answers questions about esoteric languages, looking up the answer on the esoteric languages wiki.
== External resources ==
* GitHub repository
Category:People
Esolasagna

Esolasagna is an esolang based entirely on Garfield quotes.
== Syntax ==
The code is divided into days, starting on any day, and halting on Monday. All commands must be in uppercase.
== Commands ==
 All Commands
EAT YOUR HEART OUT, (person). 	Selects a variable.
NICE TOUCH. 	Increments the selected variable.
I'M NOT OVERWEIGHT, I'M UNDERTALL.	Decrements the selected variable.
FEED ME. 	Changes the selected variable to the user input.
I HATE MONDAYS. 	Outputs the selected variable.
Category:Languages Category:Joke languages Category:Pseudonatural Category:Unimplemented Category:Total Category:Unusable for programming Category:2024
Esomachine

Esomachine is a cell-based esolang that has an accumulator and it's based on the game Human Resource Machine.
== Memory ==
Memory is an infinite tape but every cell is locked which means they can't be modified, to modify a cell you need to unlock it first.
== Syntax ==
The syntax of a command is very simple, they are like this:
 <instruction>[<parameter>,<parameter 2>](linebreak)
:In <instruction> you put the instruction
:In <parameter> you put the parameter that the instruction uses
:If the instruction uses two parameters, you put the comma and in <parameter 2> you put the second parameter
:(linebreak) means that you need to put a line break
=== Example ===
 hi[34]
=== Comments ===
The syntax of a comment is
 \<comment>
:In <comment> you put the comment
== Commands ==
Instruction 	Parameter/s 	Does
INDEX_STATE 	<0 or 1> <number> 	Sets the cell specified by the second parameter to locked or unlocked
:0 makes it locked
:1 makes it unlocked
INDEX_SET 	<number> <address> 	Sets the cell specified by the parameter one to the parameter two
HANDS_CONLANG	<+ or - or / or *> <number> 	Does an operation specified by the first parameter, using the accumulator as the left operand and the second parameter as the right operand
HANDS_JUMP 	<NEGATIVE/POSITIVE/ZERO/DONTCARE> <number>	Jumps to a line of code specified by the second parameter, the first parameter is the jump type which are:
:NEGATIVE
::Jumps if the accumulator is negative
:POSITIVE
::Jumps if the accumulator is positive
:ZERO
::Jumps if the accumulator is zero
:DONTCARE
::Jumps because yes
HANDS_EXPECT 	 	Gets a character input and stores its ASCII code into the accumulator
OUTPUT 	<number> 	Outputs the ASCII character associated with the value of the cell specified by the first parameter
== Using hand ==
When a parameter uses a number or an address you can put HANDS instead of a number or an address, that means that instead of using a number or an adress it will use the value that is holding the accumulator.
== Using indirect addressing ==
When a parameter uses a number or an address you can surround it with brackets, now that means that instead of using the number, it will use the value of the cell specified by that number in brackets.
== Examples ==
=== Truth-machine ===
 HANDS_EXPECT[] \line 1
 INDEX_STATE[1, 1] \line 2
 INDEX_SET[1, HANDS] \line 3
 HANDS_CONLANG[-, 48] \ The ascii value of 0 \line 4
 HANDS_JUMP[ZERO, 8] \line 5
 OUTPUT[1] \line 6
 HANDS_JUMP[DONTCARE, 6] \line 7
 OUTPUT[1] \line 8
=== Cat program ===
An infinitely repeating cat program constitutes the following:
 HANDS_EXPECT[]
 INDEX_STATE[1, 1]
 INDEX_SET[1, HANDS]
 OUTPUT[1]
 HANDS_JUMP[POSITIVE, 1]
==Interpreter==
* Common Lisp implementation of the Esomachine programming language.
Category:Thematic
Category:Cell-based
Category:Languages
Category:Implemented
Esonaldo

Esonaldo Pereira
This is an esolang based on the lyrics of the brazilian singer Ednaldo Pereira.
It's currently only interpreted in python.
It has the following commands:
Esonaldo command 	python equivalent
hi respondeu 	print(hi)
hi disse: "hello" 	hi = "hello"
Number is the brother 	number = 0
String is the sister 	String = ""
Number pergunta: say a number 	Number = input("Say a number")
Number vale nada 	Number = 0
Number vale tudo 	Number = 1
Number vale 42 	Number = 42
X vamos viver em igualdade com Y 	X = Y
X e Y é igual ao que, Z? 	z = x+y
X, entre Y e Z, qual é a diferença?	x = y-z
X what is the brother, y ou z? 	if y>z: 
 y = 1
else:
 y = 0
X what is the sister, y ou z? 	if y<z:
 y = 1
else:
 y = 0
X fale o que quiser com Y 	if str(y) == str(z):
 y = 1
else:
 y = 0
is good 	Python doesn't have this, but it'll print the name of a variable
voce quer ser tudo X
e não é de nada	if x == 1:
eu não vou parar de mesclar
enquanto X assim continuar	while x == 1:
== github ==
link to the github page: esonaldo
Category:Languages Category:Implemented Category:Thematic Category:Pseudonatural
Esoteric Awards

:Note: this article is a work in progress; it is known to be incomplete, and is probably inaccurate to boot. You can help by expanding and correcting it.
The Esoteric Awards, called the Essies for short, are a competition, originated by Ben Olmstead, designed to test the skill of esoteric programmers, through either design of or programming in esoteric programming languages.
==2001==
The first Esoteric Awards were held in 2000, but the deadline kept getting pushed back until it became 2001. The contest organizer was Ben Olmstead; judges included John Colagioia. The categories included:
* Best New Esoteric Programming Language
* Best Language Implementation in an Esoteric Programming Language
The entries included:
* Sorted!
* Hunter
* 'N-DCNC
* (definitely others)
The winner was Sorted!, by Gerson Kurz.
==2002==
The Second Ennuial Esoteric Awards were held in 2002. The contest organizer was John Colagioia. The categories included:
* Most Entertaining New Turing-Complete Toy or Language
* Best Treatment of a Mainstream Programming Language as an Esoteric Programming Language
* Iron Programmer
The entries included:
* Choon
* Clunk
* GraNoLa/M
* Kayak
* Lazy K
* NICE
It is not known if a winner was picked.
Source: 
==2003==
It is not known if the Essies were held in 2003.
==2004==
The Esoteric Awards were held again in 2004. The categories included:
* [Best] Turing-equivalent Language
* [Best] Under-Turing-equivalent Gimmick
* [Best] Program in an Esoteric Programming Language
* Anything Goes
It is not known if any entries were submitted. It is likewise not known if a winner was picked.
Source: 
==2006==
The 2006 Esolang Contest was organized from this wiki in 2006, in somewhat the same spirit as previous essies. Like most of the others, it foundered.
Category:Competitions and Events
Esoteric Operating System

The Esoteric Operating System (or EsoOS) is the placeholder name for an esoteric OS proposed on the #esoteric IRC channel by User:CakeProphet. While the OS is intended as a thought experiment, it should also be useful and perhaps even a contender for OSes like Linux. 
If you're interested in discussing and implementing such an OS, discuss it, for example, on the talk page.
==See also==
*List_of_ideas#Ideas_related_to_esoteric_operating_systems.2C_esoteric_processors_and_esoteric_computers
*Esoteric_Operating_System/File_System
*Esoteric linux distribution
*Auxiliary operating system sub-os
*Pikobrain
Category:concepts
Esoteric Topics in Computer Programming

Esoteric Topics in Computer Programming was an article on the Cat's Eye Technologies website that explained different concepts in Esoteric Programming, such as quines, polyglots, tarpits and paradigms.
The article has however, together with some other Cat's Eye Technologies pages, disappeared off the site, and can now only be visited on the Wayback machine.
==External resources==
* 
Category:Concepts
Esoteric algorithm

An esoteric algorithm is a strange, confusing, or humorous algorithm that deviates from traditional algorithmic concepts in some way. An esoteric algorithm may be overly complicated, have unneeded results, or be just plain bonkers. An esoteric algorithm may be dependent on (accepting, returning, or using intermediately) an esoteric data structure.
== Example ==
The definition of an Esoteric algorithm is very broad, which allows for endless algorithms fulfilling it. Take the Hazard Algorithm, proposed by User: Areallycoolusername as an example. It's optimized for use with the Esoteric data structure he proposed, called the "Arch".
It's an algorithm for calculating the first few digits in the "Hazard Integer Sequence" (also devised by Areallycoolusername), all the prime numbers in the Unlucky Number Sequence, multiplied by 3.
The algorithm starts by storing a user-defined amount of numbers in the Unlucky Sequence in the Arch. Then, the primes in the set are separated, multiplied by 3, and then put in the Arch, replacing the original Unlucky numbers in the process.
== Potential Use ==
Esoteric algorithms can be used to create new esoteric programming languages in general. For example, you can create an algorithm that gives you random keywords or characters for a new esoteric programming language depending on the contents of a string of integers given as input. As said before, the possibilities are endless, and therefore, it can help break the loop of monotonous languages, such as the brainfuck derivatives.
Category:Concepts