nyuuzyou/wikis huggingface dataset:
Yaren

Yaren is an esoteric programming language created by User:PythonshellDebugwindow.
==Overview==
Yaren was designed in an attempt to bring Befunge's < and > commands to brainfuck. In Yaren, control flow is done by changing the direction of the program counter. The language is named after the de facto capital of Nauru.
==Memory==
Yaren uses a left- and right-unbounded tape of one-bit cells, each of which is initially set to 0. A cell pointer points to the current cell.
By default, the program counter moves to the right; however, it can move either right or left.
==Syntax==
In Yaren, each character is its own command. The language has few commands:
* + toggles the current cell, and then increments the cell pointer.
* - decrements the cell pointer.
* [ jumps to its matching ] if the current cell is 0.
* ] does nothing, and simply serves as a partner for [.
* < causes the program counter to start moving to the left.
* > causes the program counter to start moving to the right.
When the program counter is moving to the left, the roles of the [ and ] commands are reversed.
Additionally, the following I/O commands can be implemented, although this is not required:
* , reads a byte from STDIN and writes it to the current cell and the 7 cells to its direct right, with the current cell getting the LSB.
* . takes the byte signified by the current cell, the cell to its right, the cell to that cell's right, and so on, and writes it to STDOUT (the bit at the current cell is the LSB).
All instances of [ and ] must be properly matched. All unrecognised characters are ignored.
==Examples==
These examples use the optional I/O commands.
===Hello, world!===
--+----+----.--+--+----+---+-.--+--+---+--+---..--+--+---+--+--+--+-.---+---+--+---.---+------.--+--+--+---+--+--+-.--+--+---+--+--+--+-.--+--+--+----+--.--+--+---+--+---.--+--+----+---.---+------+-.-----+---+--.
===Truth-machine===
 ,[>.<].
===Cat program===
 >+-[,.][+-]<
==External resources==
* Common Lisp implementation of the Yaren programming language.
* An interpreter written in Node.js
Category:Languages Category:2020 Category:Implemented Category:Unknown computational class Category:Cell-based Category:Brainfuck derivatives
Yayimhere-like esolang

Yayimhere-like esolang is an esolang created by User:Ractangle based on User:Yayimhere's esolangs
==syntax==
Variable declaration:
 Variable name » Value of that variable
 just stops the program
push A to stack. Lasts untill a newline in code or a goto:
pop from the stack:
move the element to the other stack:
Same thing as but requires the stack pointer to point at the other stack:
pop the element from the stack and print it and check if the stack is empty. If the stack is empty do an action:
conditional:
 ⁇ if condition, do Action else skip this command ﹝Action﹞
 creates a label (the label name must be a number in order of declaration from one to the last label declared)
 a goto statement. can be used as concatinating commands if the argument is not a number
 gets user input and pushes to the stack
 pops three top elements on the stack and checks if the first top element is 1. If it's 1. use the two poped elements do multiplication, else do division instead
 the command but the operations are plus and minus
moves the stack pointer to the other stack and vise versa:
==examples==
===Hello, world!===
 ⎵Hello, world! ⏎ ⎋ ⚐
===Truth-machine===
 i»⌨ ⏎ ⎵>i ⏎ ⁇ i&0 ﹝⏎1﹞ ⏎2
 ⚑1 ⎵0 ⏎ ⎋ ⚐
 ⚑2 ⎵1 ⏎ ⎋ ⏎2
Category:LanguagesCategory:2024Category:Stack-based
Ye Olde Alchemist

Ye Olde Alchemist is a esolang by User:Kingofthenerdz3. It is still an idea in development. Programs are are ancient alchemical recipes. It is influenced by Chef.
==How it Works==
First , write the names of ingredients.An ingredient is a variable.
Syntax:
"<value> <unit of measure> of <element_name> in its <state> "
Example
 
3 spoons of Orichalum in its liquid state.
Secondly , there is a list of equipment which are numbered .
Mixing bowls are for manipulating 2 or more variables.(-1 is output and 1 is input)
Stirrer - add the values of the variables.
Wok - changes state of elements from solid to liquid and liquid to gas
(Note that liquid - char , solid - float , gas - colour) 
User defined equipment is based on Anemone.Here , terms are equipment and elements.
Thirdly, write the recipe(aka main function).If certain stuff not in the list of ingredients are needed , you may use sub-recipes to prepare it.The order of recipe and sub-recipes DO NOT MATTER.
==Writing Recipes==
All these include built-in materials
"Heat <element_name> on a wok for hours."
This proportion of the element changes state.So if element x (solid) is heated for 2 hours , 2/10 of the value is put into a new variable with the name x_liquid,
"Empty pot <pot_no>"
Delete pot contents into oblivion.If its -1 , send the output to the console.IF there are colours , turn the nearest letter or number that colour.
At the end of the program the pot is automatically sent to the console.
"Fetch some <unit_measure> <value> of <new element_name>"
Fetch some data from the input and copy it to a variable. 
Ok fine it isnt complete yet but it would be good if anyone helps.
Category:Languages
Category:Works-in-Progress
Yea

Yea is an esolang by User:ChuckEsoteric08.
==Description==
It has one queue and one stack, both have their initial value and their element are one character long. it also have accumulator which is contain only 1 character and have its own initial value that can't be changed. Commands are seperated by newline. Elements, accumulator and argument(x) can be only y, e and a. Yea is case in-sensitive.
===Commands===
Command	Operation
yea.x 	Declare label x.
ya.x 	enqueue x to queue if its bottom element is equal to element on the top.
ay.x 	push x to stack if its top element is equal to bottom element of queue.
ye 	dequeue element on the queue.
ey 	pop element from stack.
aey 	reverse stack.
yay.x 	if top of the stack is equal to accumulator goto label x.
Category:Languages
yey.x 	if bottom of the queue is equal to accumulator goto label x.
Yeah!

Yeah! is an esoteric programming language that is basic. It is created by User:A. You can only implement fork bombs and initialize variables as its original value.
==Syntax==
This is a weak-typed esoteric programming language. Variables can be used without declaring.
Yeah! You die!	Implement a fork bomb. i.e. terminate the program.
Yeah! You die?	Set the variable "You die" as its original value.
==Implementations==
#include <stdio.h>
int main()
{
 char input[999];
 while(!strcmp(scanf("%s",&input),"Yeah! You die!"));
 while(1)
 fork();
 return 0;
}
Category:Languages
Category:2019
Category:Joke languages
Category:Unusable for programming
Category:Implemented
Yee

Yee is an esoteric programming language based off of the yee dinasour meme.
== Commands ==
 bah - cell 1
 bah bah - cell 2
 bah bah bah - cell 3
 ...
 baah - before "Ye..." (if no "bah"s are before it, use cell of last command)
 B(a=0,h=1) - replaces "baah" and sets current cell to binary number. (Ye... after it is nop)
 Yie - (nop)
 Ye - +
 Yee - -
 Yeee - .
 Yeeee - ,
 Yeeeee - [
 Yeeeeee - ]
 Yeeeeeee... - (nop)
== HI ==
 bah baah Yie
 Bahaahaaa Yee
 baah Yeee
 baah Ye
 baah Yeee
Category:Turing completeCategory:Joke languagesCategory:Brainfuck derivativesCategory:LanguagesCategory:Cell-basedCategory:Unimplemented
Yellow Four Code

Yellow Four Code is a language similar to Malbolge, based around being confusing and useless. The program is loaded into memory at the beginning.
==Base Four==
The number system is based around 8 Base4 bit memory cells. Each additionally is attached to an address.
*0 - Pointer - 8 bit
*1 - Instruction pointer - 8 bit (points to individual 4bits so memory is 213 traditional bytes in memory)
*2 - Input (when op2) / Output (when op1 exit on 33333333) - 8 bit. It holds the value of a register and the crazy operation still applies on getting and putting. Input overwrites the last 4 bits, though, with the ascii value.
*3 - Point to (relative to current location by addition) 
==Operation and Operands==
The operands are formed by repeating 3's ended by 0, 1, 2. Once you have two operands, suchas 33332, 31, 2, 330, you then perform the crazy operation
 op2
 0 1 2 3
o 0 2 3 1 0
p 1 1 0 2 3
1 2 0 1 3 2
 3 3 2 0 1
between bits of the operands as shown
op1 0 1 2 3 4 5 6 7
op2 1 7 4 6 3 0 5 2
and the result is stored in op1.
==Compiling==
A compiler is yet to be implemented; if someone does it, it'd be cool. Whether it is Turing-complete is yet to be answered.
Category: Languages
Category: Low-level
Category: Unknown computational class
Category: Unknown year
Category: Unimplemented
Yes.

Yes. is a programming language inspired by No..
==Instructions==
* Yes. - move pointer right 1 step
* Yeah. - move pointer left 1 step
* Yes! - add 1 to cell
* Yeah! - subtract 1 from cell
* Yup. - print cell as number
* Yup! - input number into cell
* Yup? - if cell is 0 input character, else output character
* Yes? - while cell is 0
* Yeah? - end while
* Yes... - push cell to stack
* Yeah... - pop stack and set cell to pop
* (Yup) - pop 2 from stack, add, set cell
* [Yup] - pop 2 from stack, multiply, set cell
* {Yup} - pop 2 from stack, subtract 1st-2nd, set cell
* <Yup> - pop 2 from stack, divide 1st/2nd, set cell
* Yup... - pop 2 from stack, modulo 1st%2nd (sign of 2nd), set cell
* Nope. - halt/quit (which one it does is implementation-dependent)
* Nope... - Never Gonna Give You Up
Category:Languages Category:Stack-based Category:Cell-based Category:2024 Category:Unimplemented
YesNoMaybeUnknown

YesNoMaybeUnknown is an esolang created by Cortex using quaternary digits (or quits). These 4 values are represented as:
* ? (unknown)
* 0 (no)
* ½ (maybe)
* 1 (yes)
Also, instead of cells, 1 simple accumulator, a stack, or even an interesting esoteric data structure, it uses 8192 accumulators. Yep. In addition, to prevent YNMU from contracting Unnecessarily Complex Print Statements Syndrome (UCPSS), it has strings as well as numbers and quits. 
== About the accumulators ==
At the start of the program, all accumulators are set to ? by default, except for the reserved ones. All accumulators can be changed, except for the reserved ones; the reserved accumulators serve to store certain data.
=== Reserved accumulators ===
Accumulator number	Name 	Description 	Type
100-120 	Input #1-20 	Input from the user. Can have up to 20 inputs. If no input is given in an input, its corresponding accumulator will have the value of ?.	String
2026 	Instruction Counter 	Can actually be edited. When edited, go forward in the program; like 🚨 in Emoji-gramming 	Number
8000 	Solely to annoy you.	It's always 7. 	Number
== Commands ==
I'll add this later
½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½
Category:Languages
Yo

=== Yo ===
Yo is a cell based language. There is an object called "Yo".
You can use it like that:
 Die Yo!
(This will terminate the program)
At first, a simple Hello, World Program.
 This is Yo!
 Yo uses the STD!
 Hey Yo give me STD!
 Ya. Print me something!
 "Hello World"!
 Yeah. This was Yo!
Note: This program is only valid, if you print only one thing.
 This is Yo!
 Yo uses the STD!
 At Cell 1 store me "Hello"!
 At Cell 2 store me "World"!
 Hey Yo give me STD!
 Ya. Print me 1 to 2!
 Yeah. This was Yo!
Now you can print more!
How to use mathematical functions:
 This is Yo!
 Yo can calculate!
 At Cell 1 store me 5!
 Goto Next Cell!
 Kewl. At this point store me 5!
 Hey Yo start the calculator!
 Ya. Add 1 to 2!
 Yeah. This was Yo!
Now, how can we print that?
 This is Yo!
 Yo can calculate!
 Yo uses the STD!
 Yo needs the casts!
 Wtf? I want cell 1!
 Goto Next Cell!
 Kewl. At this point store me 5!
 Yo move your ass!
 Kewl. At this point store me 5!
 Hey Yo start the calculator!
 Ya. Add 2 to 3!
 Hey Yo needs the casts!
 Ya. Cast me 2 to string!
 Hey Yo give me STD!
 Ya. Print me 1!
 This was Yo!
(Yo move your ass! is = Goto Next Cell!)
Loops:
 This is Yo!
 Yo uses the STD!
 Yo needs the casts!
 At Cell 1 store me 10!
 Yo move your ass!
 Omg. A loop with 1!
 Hey Yo give me STD!
 Ya. Inc the Cell 1!
 Hey Yo needs the casts!
 Ya. Cast me 0 to string!
 Hey Yo give me STD!
 Ya. Print me 0!
 Hey Yo needs the casts!
 Ya. Cast me 0 to integer!
 Die Loop!
 This was Yo!
(This prints the numbers 1 to 10.) (12345678910)
Note: 0 means the curent cell. But 1 means the Cell 1. Not the next cell.
If you want relative celladressing, use >1 for the next cell at the right side, or use <1 for the next cell at the left side.
Category:LanguagesCategory:Cell-basedCategory:Pseudonatural
Yo!nk

Yo!ink is a esoteric programming language made by User:mantita223 The language has very simple syntax, and with a bit of programming knowledge, anyone can use the language.
==Syntax==
The syntax is simple. Below is a chart showing what symbol does what.
Symbol	Effect
! 	+1
@ 	+2
# 	+3
$ 	+4
% 	+5
^ 	+6
& 	+7
* 	+8
To display a character, the line, when 9 is subtracted from it, must add up to that character's position in the alphabet.
Optionally, a semicolon ; can be used as a end-of-line separator, if you want to stuff multiple lines onto only one line.
==Hello World==
Hello World in Yo!nk is very simple. It is done like this:
*@&;
*@$;
*@*#;
*@*#;
*@*@$;
*@*@*@&;
*@*@*@@;
*@*@$;
*@*@&;
*@*#;
*@#;
*@*@*@^;
Notice how each line adds up to the character desired, using the chart above.
Category:Languages Category:Implemented Category:Total Category:Unusable for programming Category:Output only
Yoctofunge

Yoctofunge is a minimalization of a minimalization of Nopfunge. It is named after yocto, the smallest unit.
==Commands==
There are two commands:   and C,   is a NOP. When the IP hits a connected component (in 4 directions) of C's, it rotates clockwise.
Like Nanofunge, the infinite repeating part is said at the start.
==Computational class==
Turing complete, because it be translated from Nanofunge. Every command can be translated to a 15x15 grid.
First flip the program by the diagonal (right becomes down), then add these 2 lines at the start:
 C 
 
Then translate, C is:
 C C 
 CC CC 
 
 C C C 
 
 C C 
 C C 
 
 
 
 C C 
 
 C C 
 C C 
 
< is:
 C C C C CC
C C C 
 C C 
 C C C
 
CCCCCCCCCC C 
 
 
 
 
 
 
 
 
 
Both translations accept the IP downwards from the 7th column, upwards from the 11th column, leftwards from the 6th row, rightwards from the 2nd row:
 v
 C C C C CC
>C C C 
 C C 
 C C C
 
 CCCCCCCCCC C <
 
 
 
 
 
 
 
 
 
 ^
A space is translated to a 15x15 grid which consists of only spaces.
==See also==
* Nopstacle
Category:Languages
Category:No IO
Category:2024
Category:Unimplemented
Category:Turing complete
Category:Two-dimensional languages
Yoctostack

Yoctostack is an esolang made by User:Otesunki (talk) (and further whittled down by User:Quintopia (talk)) based loosely on Minsky machines and operates on a stack.
==Commands==
Command	Meaning
+ 	Increment the top of the stack, then pushes 0.
- 	If the top of the stack is non-zero, decrement it. otherwise (or if the stack is empty), branch.
% 	Swap the top two elements on the stack.
: 	If not branching, restart the program with the current stack.
All other characters are comments, and when the end of the program is reached, the IP goes back to the start.
== Turing completeness proof ==
First, start with a program written in Portable Minsky Machine Notation that uses 2 counters, for example:
 inc(1)
 inc(1)
 while (dec(1)) {
 inc(0)
 inc(0)
 inc(0)
 }
 [...]
Label it as state 1:
 (1) inc(1)
 inc(1)
 while (dec(1)) {
 inc(0)
 inc(0)
 inc(0)
 }
 [...]
Then, use the following table to convert the program into an FSA (combined with two registers)
Find 	Replace with
inc(0);	+-:
inc(1);	%+-:%
 dec(0);
 [code A]	
 if (dec(0)) {
 [code A]
 } else {
 [code A]
 }
 dec(1);
 [code A]	
 if (dec(1)) {
 [code A]
 } else {
 [code A]
 }
 (x) [code A]
 while([code B]) {
 [code C]
 }
 [code D]	
 (x) [code A]
 goto y
 (y) if ([code B]) {
 [code C]
 goto y
 }
 goto z
 (z) [code D]
(where x, y, and z are different numbers)
 if ([code A]) {
 [code B]
 }
 [code C]	
 if ([code A]) {
 [code B]
 [code C]
 } else {
 [code C]
 }
 (x) [code A]
 if ([code B]) {
 [code C]
 } else {
 [code D]
 }
 [code E]	
 (x) [code A]
 if ([code B]) {
 [code C]
 [code E]
 } else {
 [code D]
 [code E]
 }
 (x) [code A]
 if ([code B]) {
 [code C]
 } else {
 [code D]
 }	
 (x) [code A]
 if ([code B]) {
 goto y;
 } else {
 goto z;
 }
 (y) [code C]
 (z) [code D]
(where x, y, and z are different numbers)
 (x) [code A]
 if (dec(0)) {
 [code B]
 } else {
 [code C]
 }	(x) A-B:+%-%C:
 (x) [code A]
 if (dec(1)) {
 [code A]
 } else {
 [code B]
 }	(x) A%-%B:+%-C:
goto N;	+%-%, repeat +-: N times, :
Applied to the above example, produces:
 (1) %+-:%%+-:%+%-%+-:+-::
 (2) -+%-%+-:+-:+-:::+%-%+%-%+-:+-:+-:+-:::
 (3) +-:+-:+-:+%-%+-:+-::
 (4) [...]
Next, add the following 0 state:
 (0) +%-%+%-%+%-%:::
Now we can start writing the final program.
Count the total number of states (including 0) and write that many -s, followed by the same amount of :s, on seperate lines.
For the above example:
 -----
 :
 :
 :
 :
 :
Finally, write the code for each state, in backward order (0 on bottom, 1 above it, etc...).
 -----
 :[...]
 :+-:+-:+-:+%-%+-:+-::
 :-+%-%+-:+-:+-:::+%-%+%-%+-:+-:+-:+-:::
 :%+-:%%+-:%+%-%+-:+-::
 :+%-%+%-%+%-%:::
Category:Languages
Category:Imperative paradigm
Category:Turing complete
Category:Turing tarpits
Category:Usability unknown
Category:Unimplemented
Category:No IO
Category:2022
YoptaScript

YoptaScript is a language created by Semyon Gozman, Georgy Mkhitaryan and Mikhail Belozersky. It's JavaScript, but all on Russian foul language. This language doesn't insult anyone. It created to help gopniks to know how to programming.
File:Гопник.jpg|An example of gopnik
yopta.space- the site of YoptaScript
Category:Languages Category:Thematic Category:Pseudonatural Category:Thematic Category:Turing complete
You are Reading the Name of this Esolang

You are Reading the Name of this Esolang is an esoteric programming language invented by Chris Pressey on November 5th, 2007. It is based loosely on the language Spoon and is somewhat similar to the languages Brainhype and onoz. It was intended as an exploration of the design space of languages with undecidable elements such as Gravity and Banana Scheme. The problem of determining whether or not a given string of symbols is a well-formed You are Reading the Name of this Esolang program is undecidable.
==Pronunciation==
The name of the language is pronounced as an English speaker would pronounce "you are hearing the name of this esolang."
==Instruction set==
 0 Interpreted as in Spoon
 1 Interpreted as in Spoon
 [p] A subprogram: p is interpreted as a You are Reading the Name of this Esolang program.
 The subprogram is reduced to 1 if p halts, or 0 if p loops forever, on the input to
 the main program. The 0 or 1 is interpreted as in Spoon.
==Example==
 001000000[0010000000111001000011]11100100001[0]
The subprogram [0010000000111001000011] is equivalent to Brainfuck [-]+[], and thus loops forever on any input, so it is replaced by a 0. The subprogram [0] is a malformed Spoon program, thus assumed to halt immediately, so is replaced by a 1. The resulting program, 0010000000111001000011, is interpreted as a Spoon program. It simply loops forever.
==External resources==
* 
==See also==
* Spoon
Category:Brainfuck derivatives
Category:Languages
Category:Unimplemented
Category:Uncomputable
Category:2007
Category:Turing complete
Category:Turing tarpits
Category:Cell-based
Category:Low-level
You are in a brainforest

you are in a brainforest is a non-turing complete esolang that compiles into brainfuck. its only sole purpose is to make text adventures.
== commands ==
 out() - prints characters in brackets
 in - stores input as temporary variable
 if(?|) - do things between | and ) only if temporary variable is ?
 inc - adds 1 to temporary variable
 dec - subtracts 1 to temporary variable
== compilation to brainfuck ==
 out(?):
 (number of pluses as needed).[-]
 in:
 >,<
 inc:
 >+<
 dec:
 >-<
 if(?|!):
 >[>+>+<<-]>[<+>-]>(number of minuses as needed)>+<[>-<[-]]>[<<<!>>>[-]]
Category:Languages Category:Total Category:Unusable for programming Category:Unimplemented
You wait here

You will wait one second every wait command
== Commands ==
 print: prints the amount of seconds waited
 repeat[commands]: repeats the commands the amount of waited seconds,
 every iteration, wait -1 seconds, aka wait 0 but subtract one from the seconds waited
 wait: wait 1 second
 split: splits the amount of seconds in half, but then wait 1 second
 input: wait the number in the input seconds
 end: end the program
 rewind: rewind time, aka subtract 1 from time waited, but wait 0 seconds
 if[number][commands]: if the time waited equals number, then do commands
 tnirp: print negative time waited
 negate: negates the time waited
 define [name][inputs seperated by spaces][commands]: define command
== 3 program ==
 rewind
 rewind
 rewind
 negate
 print
Category:Languages
Category:Output only
Your

Your is a Turing complete esolang by User:Hex96. It contains 2 commands.
#Your: depending on the number of yours, it does a different task.
#You’re: SCREAMS AT YOU, THIS IS THE INTERNET!!
New line is not a command, it just seperates them, e.g.:
Your
Your Your would print Hello World and do a cat program.
==Examples==
===Hello World===
Your
===Cat program===
Your Your
===Reverse cat===
Your Your Your
===Truth Machine===
Your Your Your Your
===99 bottles of beer on the wall===
Your Your Your Your Your
===Self-interpreter===
Your Your Your Your Your Your
===Screamer===
You’re
==Interpreter==
* Common Lisp implementation of the Your programming language.
==See also==
* A very long language name that is very weird and yeah, this is your but its this
Category:Joke languages
Category:2019
Category:Implemented
Category:Languages
Your Pillows

Your Pillows , created by User:A,are esoteric programming languages directly based off pillows. It is somehow influenced by Beatnik. The name's case should be upper-case if this is at the start of a sentence; otherwise, it is lowercase.
==Syntax of your pillows==
Stanza Hello
(Hello is two syllables)
You also have your own pillow(s);
You also have your own [word].
A word can only contain lowercase letters, no hyphens or underlines,
must be findable on a dictionary (i.e. must exist), and must be syntactically valid.
There are no an, the, a, um, and uh's allowed in a word.
USA is invalid, because it contains upper-case letters.
an ant is also invalid, because it contains spaces.
upper-case is also invalid, as it contains hyphens.
Your pillows are
* based on syllables
* pillows to navigate through stanzas
* pillow to enter instructions
Too Noisy
Pillow Area
You also have your own pillows;
You also have your own too noisy.
==Instructions==
1 syllable = read input to the stack
2 syllables = output the top of the stack
3 syllables = pop the value on the top of the stack
4 syllables = push the value indicated in the next pillow to the top of the stack
5 syllables = switch the top of the stack to the bottom
Category:2019
Category:Languages
Category:Unimplemented
Category:Stack-based