nyuuzyou/wikis huggingface dataset:
Xt

Xt is every Brainf**k derivative, on account of its odd syntax.
The name looks a little like ><+, part of the brainf**k syntax.
== Syntax ==
An Xt source code file (.xt or .txt extension) consists of lines of eight characters each:
 ><+-.,[]
 ++[>+<-]
The odd numbered lines contain descriptions of brainf**k derivatives, with the eight characters replacing the >, <, +, -, ., ,, [, and ] characters respectively. The even numbered lines contain fragments of a program written in this language.
Using the same character across more than one odd-numbered line is a syntax error and the interpreter should loudly correct the user. However, it is not an error to use the same character more than once within one line.
The first line with less than 8 characters terminates the program.
== Execution ==
The even lines are executed like a brainf**k program, with the characters redefined by the line above. If two commands are represented by the same character, the leftmost one in the definition is executed. When the end of the line is reached (or a loop sends execution to another line) the next even line will be run, and the characters will be redefined again.
== Computational Class ==
Technically, Xt is trivially Turing-complete due to it being descended from brainf**k. However, the constantly dwindling supply of commands means that there is an upper limit on how long a program can be.
This is no different from any regular computer, though. At the very least, the finite size of the observable universe puts an upper limit on how big your program can be.
== Example Program ==
Hello World I stole from the brainf**k page:
 qqaaaaaa
 aaaaaaaa
 eepeeebb
 beppppbe
 oouuuuuu
 uuouuuou
 rfllllll
 llrlffff
 yyjhhhhn
 hnyjyjyh
 zxcvvvbm
 zzcbxmxv
 gggdsddk
 kggsgddd
 iittwwww
 wttttttt
 11223333
 33222311
 00000000
 0.......
The periods in the last line pad it out to eight characters so the program doesn't stop short. They are not mapped to any command and work as no-ops.
==See also==
* TrivialBrainfuckSubstitution
Category:Languages Category:Cell-based Category:Low-level Category:Turing complete Category:Brainfuck derivatives
Xtrod

Xtrod was User:Ractangle's attempt to minimise the Brainfuck instructions
==Instruction minimise==
 ><+-,.[] The standard bf set
 ><+-![] Merged I/O into one command (0 for output, anything else for input)
 (<-![] Merged + and >
 (<-!| Skips an instruction if zero. Otherwise jump to the nearest |
The final table should look like this:
Symbol	Action
( 	Mover the pointer to the right and Increments the previous cell
< 	BF move pointer left
- 	BF decrement cell
! 	I/O, gets output if not zero, gets input if zero
 	Skips an instruction if zero, go to the nearest if not zero
Oh and don't worry, you can wrap the cell pointer in Xtrod
==See also==
* BF instruction minimalization - other attempts at BF minimalization by other people
Xuki

xuki is an esolang created by User:Ractangle from a form in the trutle1's discord server
==Syntax==
 the while statement
 the array
 grabs an element from the array spefied by it's argument
 place the grabbed element to the array spefied by it's argument
 input
 duplicate
 prints an array
 repeat a command n times
 declaration/bitwise not
==Examples==
===A+B Problem===
 y![1]=.* x![1]=.* x!=[]:(^x vy) &(y)
Category:Languages Category:Unimplemented Category:2024
Xyz

Xyz is a programming language that uses letters
== How it works ==
 it translates the letters a-z to 1-26, and letters A-Z to 27-52,
 the commands are split into 8 letters, 1-3 are instruction. 4-8 are data
=== Instructions ===
 aab - nop
 aac - set the reference var to the next 5 letters, aka the data part, the name for it is ZZZ, ZZ is the name, Z is the determining part
 aad - define the next 2 letters as a var,
 the 3rd letter in the data part is the "determine if it is a var or a data" thing, B means it is a var
 aae - start a function where the next 2 letters is the name,
 the 3rd letter is the "determine if it is a var or a data" thing, C means it is a function,
 the input is two letters long, the first letter being the name, the second letter being the determiner,
 use D for function inputs, function inputs are 1 letter long, 2 if you include the determining part
 aaf - end the function, all data spots are unused
 aag - run the function which is the next 3 letters, with inputs which are 1 letter long,
 the reference var, aka the return var, will be taken out of the function after finishing
 aah - output the next 5 letters
 aai - halt, all data spots are unused
 aaj-ZZZ - a comment
=== Hello world ===
 aahhello
 aahworld
 aaiaaaaa
=== Forever loop ===
 aaeFOCaa
 ZZZFOREV
 ZZZERSTA
 ZZZRTaaa
 aagFOCaa
 ZZZRUNAG
 ZZZAINaa
 aafaaaaa
 ZZZENDFO
 ZZZREVER
 aaqFOCaa
 ZZZRUNaa
Category:Languages
Xⁿxₙ

xⁿxₙ is a minimalist esolang inspired by underload. it was created by User:Yayimhere
=== memory ===
memory is stored in a tape starting with only one cell containing the letter A. the tape is circular so going to the end of the tape will bring you back to the start
=== syntax ===
Command : current tape - future tape (future program) direction pointer moved
: description
----
[ : x - ([x) *
: put the current cell symbol into the code after the command and delete the cell
y] : x - x, y (]) *
: delete x and store it in tape
> : x - x (>) >
: ignore following command and go left on tape(
1 : x - x (1) <
: > but it goes right on tape
$ : x, y - xy ($) *
: concatenate the the current cell onto the front of the cell to the right of it
( : x, y - x, x, y (() *
: copy all the cells to the right of the pointer, to the right(including whats under the pointer)
) : x, y, z - x ( )yz ) *ª
: delete everything right of the pointer and place it in front of the command
^x : x - x (^x) *
: if the current cell is equal to the symbol following the ^ delete the following command. this skips x
P : x - x (P) *
: print the current cell to STOUT
| : x - x (|) *
:skip following command
{ : x - ({x) *
: [ but it moves left on tape
here x, y, z are placeholders and in commands they are single chars
=== examples ===
hello world:
 |H]|e]|l]|l]|o]|,]| ]|W]|o]|r]|l]|d]|!]> $$$$$$$$$$$$$P
=== turing completeness proof ===
translation from Underload(only :()^ which is still TC):
 the stack starts with a A in it which is not accessible
 : -> 1 (space needed)(
 ^ -> {
 (x) -> |x]
 (xyz) -> 1|x]|y]|z]> (space needed) then $ repeated as many times as the length of the string
so the infinite loop (:^):^ becomes:
 1|(]|1]|{]> $$$1 ({
also only these commands are needed now!!:
 {1|](>$
which are all pretty simple i think
Category:Languages
Y/N

Y/N is an incomplete esolang made by User:Cortex. The only keywords are yes and no. Commands are started with yes[commandname]yes and terminated with no[commandname]no.
== Commands ==
Command	What it does
yes no 	Sets the accumulator (?) to a number (indicated by number of yes's, for example: yesyes noyes yes yes yes yes yes yes yes noyes nono would return 7.
yes yes	Prints the accumulator as an ASCII character; similar to * in +-=*/!&#
no no 	Increments the accumulator by 1
no yes 	
no u 	Destroys PC
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Y/Y

Y/Y is an esolang created by User:Yayimhere. The only thing is known about this esolang is that it has an interpreter generated by AI and the language being stack-based.
==data==
there is an stack(self.data = []), a register(self.code_ptr = 0), and something called data which is defined as the length of the stack minus 1(self.data_ptr = len(self.data) - 1)
==Syntax==
:The information is not fully done yet. You can contribute on adding more syntax info here
 prints every element on the stack
 Gets user input and pushes it to the stack
 turns the top value on the stack into a binary number
 set stack index self_ptr to the following single number digit and skip it and another character
Other characters are pushed into the stack
, and haven't been syntaxed yet
==Examples==
===Cat program===
 ;&
===Hello, world!===
 Hello, world!&
==Interpreter==
* Python interpreter
Category:LanguagesCategory:Stack-basedCategory:ImplementedCategory:2024
Y/λ

Y/λ is a minimalist esolang made to be really simple
== syntax ==
all the simple syntax of Y/λ
 syntax
symbol	description
Y 	push what was at the code pointer location before this command was encountered onto the stack
L 	push what was at the data pointer before this command was encountered onto the stack
: 	pop the top of the stack and replace what's at the code pointer location with that object
; 	pop the top of the stack and replace what's at the code pointer location with that object
( 	go to the corresponding ) if there are one or more ΢'s on the stack
) 	go to the corresponding ( if there are no ΢'s on the stack.
O 	pop the top of the stack and output it. if the top of the stack is a number output as a number and/or if its a string thats on top of the stack print it as a string
# 	push the following symbol onto the stack as a number instead of a string
+ 	pop the top two numbers specifically of the stack and add them and push the result. goes in the order: highest number on the left
- 	negate the top value on the stack
^ 	make the data pointer go to the symbol before this one
> 	reverse the whole stack
any symbol thats not a command will just be ignored but still existing so the code pointer can be at them and they can be added to the stack
the code pointer moves from left to right until it gets to the end of the code
the data pointer does not move unless told to(by the ^ command)
YAASEL

YAASEL (Yet Another Another Stack-Based Eso-Lang) is a Stack-Based Programming Language featuring 15 individual Instructions, it was created by Felix Eckert (user:Bertrahm). 
It is partly inspired by Brainfuck. It currently has a Web-Implementation written in Java-Script and a Java Implementation. The Source Code of both can be found on the YAASEL Github Repository.
==Language Overview==
YAASEL has a Stack consisting of bytes and a single-byte buffer or stash. 
 Instructions
Instruction Character	Instruction Name	Description
> 	Larger Than 	Checks if the top of the Stack is larger than the second to top.
< 	Smaller Than 	Checks if the top of the Stack is smaller than the second to top.
= 	Equal To 	Checks if the top of the Stack is equal to the second to top.
: 	Jump Point 	A Point for the Program to Jump Back To
! 	Jump Back 	Jumps to last Jump Point
$ 	Stack Empty Exit	Exits if Stack is Emtpy
& 	Merge 	Adds top of Stack with the current value of the Buffer/Stash
+ 	Increment 	Increments top of Stack by 1
- 	Decrement 	Decrements top of Stack by 1
# 	Void 	Voids the top value of the Stack
' 	Stash 	Stashes the top value of the Stack to the buffer
" 	Push Stash 	Pushes the value from the stash/buffer to the stack
* 	New Value 	Creates a new entry in the stack
~ 	Input 	Gets input from the user and writes it to the stack
% 	Print 	Prints the value on top of the stack encoded in ASCII
===== Notes =====
The Conditionals (>, <, =) place the top value of the stack to the left of the operator and the second-to-top to the right.
If a comparison is true, the program will continue on from that point, if not, it will jump back to the last Jump Point or start
of the program.
Stashing a Value will remove it from the stack. Loading the Stash/Buffer to the stack will create a new entry in the stack.
== Examples ==
This example prints out "HELLO WORLD!" with a new-line.
 * Create new Entry in Stack for operation
 Increment up to a Base Value for Printing Hello World
 ++++ Start with 4
 ' Stash
 " Copy Stash
 & Merge 8
 ' Stash
 " Copy Stash
 & Merge 16
 ' Stash
 " Copy Stash
 & Merge 32
 ' Stash
 * New Stack Entry (We want to keep the 32, as it is the SPACE character)
 " Copy Stash
 & Merge 64
 ++++++++ 72 (H)
 %
 --- 69 (E)
 %
 +++++++ 76 (L)
 %%
 +++
 % 79 (O)
 "%# 32 (Space)
 ++++++++ 87 (W)
 %
 -------- 79 (O)
 %
 +++ 82 (R)
 %
 ------ 76 (L)
 %
 -------- 68 (D)
 %
 "+% 33 (Exclamation)
 #* ++++++++++ % 10 (LineFeed)
This is the reverse-cat program written in YAASEL
 ~ Get User Input
 : Jump Point
 % Print Top Value
 # Void
 $ Exit if Stack Empty
 ! Jump Back
== External Links ==
* Source Code for a YAASEL implementation in Java
* YAASEL Web Implementation
Category:Languages
Category:2022
Category:Implemented
Category:Stack-based
YABALL

YABALL is a language inspired by Brainfuck, invented by Jannis Harder in 2005. Its aim is to add a more obscure code flow to Brainfuck. YABALL has a 2-dimensional code flow and 2 different flow modes. It's an acronym for Yet Another Brainfuck A Like Language. By an impossible accident the name YABALL has the same pronounciation as the Polish word for a cheap apple wine.
==Commands==
Normal-mode commands:
 Command Description
 + Increment the current cell.
 - Decrement the current cell.
 > Move to the next cell.
 < Move to the previous cell.
 [ If current cell is 0 nop, else go down.
 ] Go up and change to reverse-mode.
 , Input to the current cell. (see Misc Input & Output)
 . Output the current cell. (see Misc Input & Output)
 ? Change to reverse-mode.
 ^ Go up.
 v Go down.
 @ Quit the program. (Current cell is the exit code)
Reverse-mode commands:
 Command Description
 ! Change to normal-mode.
 9 Go up.
 6 Go down.
All other commands are nop.
==Modes==
There are two different modes, which have their own command-set:
===Normal-mode===
The normal-mode is for calculations, input/output and code flow. In normal-mode the current command is executed and the program-pointer moves right. (E.g. + is: Increment the current cell and go right)
Note: ] switches in reverse-mode so it moves left and not right
===Reverse-mode===
The reverse-mode is for Loops and code flow. It acts like the normal-mode but moves left after the current command.
==Code flow==
The code filled with spaces, until all lines have the same length. If the program-pointer reaches the right end of a line, it wraps to the left of the next line. If the program-pointer reaches the left end of a line, it wraps to the right end of the previous line. The last line wraps to the first and reverse.
The use of mode switching and wrapping is a sign for good YABALL coding style.
==Misc==
===Cell size===
The cell size is 16 bit
===Input & Output===
Input returns -1 on EOF. 
Output outputs a byte to stdout if the current cell is less than 256. If the current cell is less than 512, the value-256 is written to stderr. 512 closes stdout and 513 closes stderr. Values from 514 to 32767 inclusive are reserved for future extensions. Other values may be used for anything.
==Examples==
Cat (mode switching):
 !,+[@
 !-.]?
Cat (wrapping):
 ,+[@
 -v
 ^ .
==Computational class==
YABALL is Turing-complete as there are two ways converting a Brainfuck program into a YABALL program.
==External resources==
* by Jannis Harder, written in Ruby.
Category:Languages
Category:Cell-based
Category:Turing tarpits
Category:Turing complete
Category:Implemented
Category:Two-dimensional languages
Category:Brainfuck derivatives
Category:2005
YASBE

YASBE, also known as Yet Another Stack-Based Esolang, (pronounced yahs-bee) is, well, another stack-based esolang. Much like Double, this was made by Lim95 in around an hour, though not live. The language was inspired by someone in the Truttle1 Discord Server known as TARDIInsanity.
 YASBE Commands
Command 	Token	What it does
Push 	0 	Pushes the value after it to the top of the stack.
Pop 	1 	Pops the top value on the stack off. If the stack is empty, end the program.
Copy 	2 	Copies the top value on the stack.
Flip 	3 	Flips the stack.
Add 	4 	Adds the top two values of the stack and pushes the result to the top.
Subt 	5 	Subtracts the top two values of the stack and pushes the result to the top.
Mult 	6 	Multiplies the top two values of the stack and pushes the result to the top.
Div 	7 	Divides the top two values of the stack and pushes the result to the top.
Char 	8 	Prints the ASCII character of the top value of the stack.
Value 	9 	Prints the top value of the stack.
CGet 	10 	Gets the ASCII value of a character entered and pushes it to the top of the stack.
IGet 	11 	Gets the value entered and pushes it to the top of the stack.
Jump 	12 	Jumps the code pointer to the value specified.
CondJump 	13 	Jumps the code pointer to the first value if the top of the stack is not equal to the value of the stack at the index specified.
Break 	14 	Ends the program.
CondBreak	15 	Ends the program if the top value of the stack is not equal to the value of the stack at the index specified.
Swap 	16 	Swaps the top and bottom values of the stack.
Pushback 	17 	Pushes the value to the back of the stack.
Debug 	999 	Prints out the stack.
==== Example Programs ====
Hello, World!
push 72 char push 101 char push 108 char push 108 char push 111 char push 44 char push 32 char push 119 char push 111 char push 114 char push 108 char push 100 char push 33 char
Truth-machine
iget value condjump 1 0
Category:Implemented Category:2022 Category:Turing complete Category:Stack-based
YATDEL

YATDEL (Yet Another Two-Dimensional Esoteric Language) is, obviously, a two-dimensional stack-based esoteric language created by User:HecknTarnation. Code is executed starting at an S. The pointer, then, moves right and continues to execute code. This language supports multiple files, called Abstracts.
==Instructions==
Opcodes 	Description
S 	Where the first pointer starts, should be present on the first abstract.
E 	When executed, it will terminate the current pointer's execution.
Q 	Exits the program.
T/t 	Creates a new Pointer that continues in the creating pointer's direction. The creating pointer has its direction set according to the direction rule/rule 2.
 	for verticle.
</>/^/v 	Sets the pointer's direction to left/right/up/down.
( 	Stores the next set of characters into the pointer's stack as a number representing an ASCII character, this will occur until a matching ) is found. The characters will be in reverse order on the stack (first character in = last character on the stack).
# 	Same as (, but for a singular number instead. Goes until a matching # is found.
p 	Pops the top value from the pointer's stack.
+/-/*/d/% 	Adds/Subtracts/Multiples/Divides/Modulo the top value and the next value from the pointers stack, then pushes the result to the stack.
I (capital i)	Gets input from the users and, if it is a number store it in the pointer's stack. Otherwise, it stores the string character by character in the same way ( does.
O/o 	Outputs the top value from the pointer's stack as a character/number.
\ 	Mirror (Right <-> Down, Left <-> Up)
/ 	Mirror (Right <-> Up, Left <-> Down)
@ 	Replaces a character on the current abstract. (first value on stack = x, second = y, third = character)
& 	Pushes a random number between 0-100 to the stack.
? 	Moves the pointer in a random direction.
$ 	Makes the pointer wait a specified number, the top value from the stack, of milliseconds.
! 	Duplicates the top value from the stack.
C/c 	If the pointer's top stack value is positive the pointer will have its direction set according to direction rule/rule 2, else direction rule 2/rule 1 (doesn't pop stack)
~ 	Makes the top value of the stack negative.
' 	Goes down one Abstract in the list.
" 	Goes down a specified number (top value in the stack) of Abstract down in the list.
==Abstract Files==
This language's code is written in files called Abstracts. These files are stored into a list that can be navigated individually by each pointer. The first file in the list should start with an S. When traveling between Abstracts, a pointer's position and direction will be preserved.
==Direction Rule==
Current Direction = New Direction
Rule 1:
* Left or Right = Down
* Up or Down = Left
Rule 2:
* Left or Right = Up
* Up or Down = Right
==Examples==
===Hello World===
 S(Hello World)=======>C==========\
 O| E
 ^< 
===Multi-File Hello World===
 S(Hello World)='
 ===============>=====>C==========\
 O| E
 ^<
==External Resources==
* YATDEL Interpreter Github Page
Category:Languages Category:Stack-based Category:Two-dimensional languages Category:Implemented
YNTDAE

Work In Progress.
YNTDAE (You Need To Describe An Esolang) is an esoteric programming language.
== Syntax ==
 a: b b b b b b b b -> c c c c c c c c, d d d d d d d d -> e e e e e e e e;
 
 f: g g g g g g g g -> h h h h h h h h;
Wildcards are * and are only allowed on the first tape of the tape pair. Use # for one-line comments.
The input is the first tape in the tape pair. 
It changes to the second tape in the tape pair.
Other characters output the tape.
Category:LanguagesCategory:Works-in-Progress
YO DAWG

YO_DAWG is an esolang with first-class esolangs.
YO_DAWG started as a vague idea Chris Pressey had, probably in the summer of 2012. He placed it on the wiki as a collaborative project in the hopes that someone could come up with a workable design for it.
==Goals==
In YO_DAWG, esolangs are "first-class objects", which implies things like:
* You can create new esolangs at runtime.
* You can pass an esolang to an esolang.
* You can return an esolang from an esolang.
YO_DAWG is probably stack-based, and there are probably instructions to:
* push a new esolang onto the stack
* pop two esolangs off the stack; pass the first to the second; and push whatever esolang is returned back on the stack.
Data types: obviously, the fundamental data type is the esolang. There should be some built-in constants for common esolangs: brainfuck, False, Befunge, Underload, etc. The names of these constants should probably match the names of their entries on this wiki. Possibly with one-letter abbreviations for the most commonly-used esolangs. And of course, there is a constant YO_DAWG.
There might be other data types. The obvious choice for another data type is the program, because then our esolangs will have something to run. But let's not rush to confusion here: in YO_DAWG, esolangs take and return other esolangs, not programs. And a program is only a description of an esolang. There could be an operation to create an esolang from a description of the esolang. But esolangs should still take and return other esolangs directly -- not just their descriptions.
Let's assume for now that descriptions are out of the picture. Then YO_DAWG can only work on esolangs which themselves work on esolangs. This poses a small problem: up until now, all known esolangs (besides YO_DAWG, that is) do not themselves work on esolangs. To reconcile this, we would need to make up some new esolang-based esolangs for YO_DAWG to work on. For example, we could have:
* I_herd_you_like_brainfuck (a variant of brainfuck where the tape cells contain esolangs)
* I_herd_you_like_Underload (a variant of Underload where strings are strings of esolangs)
* ...and so forth.
Category:Ideas
Category:Languages