nyuuzyou/wikis huggingface dataset:
Wsad

wsad (say /wˈsæd/) is a brainfuck derivative, that uses only 4 characters.
==Commands==
Every command consists of two characters in , for example: is equivalent to the command in brainfuck.
It is case insensitive.
First character\Second character	w 	s 	a 	d
w 	brainfuck + 	brainfuck - 	brainfuck [ 	brainfuck ]
s 	brainfuck , 	brainfuck . 	brainfuck < 	brainfuck >
a 	Input an integer and store it in current cell	Output current cell as integer 	If current cell is not 0, jump to the matching	If current cell is 0, jump to the matching
d 	Halt 	Set current cell to random integer in 0-255	Break a loop (by and or and ) 	Jump to the start of program
==Examples==
===Truth Machine===
 awaswaaswd
===Cat program (never terminates)===
 swssdd
===Hello World===
It is just translated from brainfuck.
 wwwwwwwwwwwwwwwwwasdwwwwwwwwwasdwwwwsdwwwwwwsdwwwwwwsdwwsasasasawswdsdwwsdwwsdwssdsdwwwasawdsawswdsdsdsssdwswswssswwwwwwwwwwwwwwsssswwwwwwsssdsdsssawssssasswwwwwwsswswswswswswssswswswswswswswswssssdsdwwsssdwwwwss
======
 wwwwwwwwas
===Random uppercase letter===
It is just translated from Random Brainfuck.
 sddssdsdwwwwwwwwwwwasawwwwwwwwwwsdwswdsawwsawasdwssdwwsawasdwdsdwasawwsdwswdsasawasawdsdwswdsdsdsdwwwwwwwwwwwwwwwwwasawwwwwwwwwwwwwwwwsdwswdsawwss
===Infinite loop===
 aaad
or simply:
 dd
==Turing completeness==
Since it has all the commands in brainfuck, wsad is Turing complete.
==Interpreter==
* Official interpreter in C++, an error (an unmatched bracket, using a break outside a loop, accessing cells outside the tape) is not ckecked, so it causes undefined behavior, use to separate program and input
Category:Languages
Category:Turing complete
Category:Brainfuck derivatives
Category:2023
Category:Implemented
Wutlang

Wutlang, or Wut is an esoteric language inspired by Brainfuck, created by Madeline Miller (Me4502) in 2016. Whilst the syntax is similar, there are no guarantees that programs written in Brainfuck will run in Wutlang.
The biggest additions in Wutlang, are the inclusion of a Stack, and basic network and file IO.
==Commands==
The following commands exist in the Wutlang specification.
Command	Description
< 	Takes the cursor back one spot.
> 	Takes the cursor forwards one spot.
. 	Output current heap cell to current output as character. Default output is console.
, 	Set current heap cell to current input. Default input is console.
+ 	Increases current heap point.
- 	Decreases current heap point.
[ 	Open loop. Skips past ']' if 0 at heap.
] 	Close loop. Returns to '[' when found.
^ 	Push current input to stack.
V 	Drop current input from stack to heap.
$ 	Open network connections on localhost at port specified as characters until 0. After the 0, the length should be specified as a raw number. Cursor will be on length afterwards.
@ 	Set network stream as input.
! 	Set network stream as output.
% 	Close network stream.
~ 	End server.
& 	Open file connections. Filename is characters until 0. Advances the cursor.
o 	Set file as output.
i 	Set file as input.
p 	Clears file.
e 	Closes file streams.
c 	Set console as output.
r 	Set console as input.
# 	Comment character. This line is a comment. Supports inline comments.
: 	Dump heap.
==External resources==
* Wutlang reference implementation on GitHub
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
Category:Turing complete
Category:Cell-based
Wymaewyha

Wymaewyha stands for When You Make An Esolang When Your Half Asleep
It is a brainfuck deteritave by User:Yes that was probably made when he was half asleep.
It is what it sounds like.
==Commands==
wake up start program
go back to sleep end program
drink water brainfuck +
lie on bed brainfuck -
type brainfuck <
delete brainfuck >
bracket means brainfuck [ or ] depending on whichever is used first
say brainfuck .
hear brainfuck ,
==Implementations==
So far, no implementations have been made, because the creator wants to go back to sleep.
Category:Languages Category:Unimplemented Category:Brainfuck derivatives Category:Cell-based Category:Low-level
WysiScript

WysiScript is a programming language in which programs are formatted (rich) text, and that completely ignores the characters in the input, caring only about their formatting. The language was created for the April Fool conference SIGBOVIK 2017. 
Detailed description and specification and an implementation of the language is found at . 
Category:Languages
Category:2017
Category:Non-textual
Category:Turing complete
Category:Implemented
X

X is a language invented by a fictional character appearing here in the XKCD web comic. This comic could be considered the formal specification for the language but for the fact that it is rather incomplete. As such, what we have functions more as a definition for a class of languages that share the following properties:
* All variables are named x.
* It is possible to define at least two different variables but every different variable must differ in the font of the name x.
Category:2020
Category:Joke languages
Category:Stubs
Category:Languages
X(y)

X(y) is a language created by User:A for a simpler form of Function x(y).
==Syntax==
To start a function:
 x()
Or:
 x(y)
Or it can have as many arguments as you like:
 x(a b c d e f g)
To do math (must use spaces before and after the operator used) (+, -, *, or /, here + is shown), and there are only infix operators:
 a + b
Math in X(y) is BEDMAS by default, but you can also uses parentheses for grouping, so the following:
 a + b * c
would evaluate to a + (b * c), but for (a + b) * c:
 (a + b) * c
To do comparison (must use spaces before and after the operator used) (<, >, <=, =>, ==, or !=, here == is shown):
 a == b
Ternary (spaces allowed before/after the { or }):
 condition{valueIfTrue valueIfFalse}
To call a function:
 x()
Or:
 x(y)
Or with as many arguments as the function takes:
 x(a b c d e f g)
To call a function recursively:
 {y}
To return (default return value is 0):
 -> a
==Examples==
===Hello, World!===
 helloWorld() -> "Hello, World!"
===Cat===
 cat(x) -> x
===Absolute value function===
 abs(n) -> (n < 0){0 - n n}
===Factorial function===
 factorial(n)
 -> (n < 2){1 n * {n - 1}}
=== FizzBuzz ===
/ is integer divison.
main(n)
-> (n != 100){((fizz(n) + buzz(n)) == ){[n] [fizz(n) + buzz(n)]} {n + 1} ["Fizz
"]}
fizz(n)
-> ((n / 3) * 3 == n )<"Fizz", "">
buzz(n)
-> ((n / 5) * 5 == n)<"Buzz", "">
=== Fibonacci sequence ===
fib(acc, num) -> fib(num, num + acc)
Category:2020 Category:Languages Category:Unimplemented Category:Turing complete
X-D

x-D is a programming language based on smileys, created by tejeez in 2007.
== Syntax and specification ==
Every command consists of eyes, mouth and if needed, a nose and another eyes. The eyes determine the pointer to use, the nose the number of repetitions and the mouth the actual command. Some commands, such as adding of two numbers, take two pointers and thus have four eyes. The eyes can be 8, x, ;, :, or %.
The number of repetitions or the number to be subtracted or added is determined by the nose. Without any nose, it's 1 and any letter in the nose adds something to it. . means 38416, ^ 2744, _ 196, ~ 14 and - 1.
I'm currently so lazy that I just copy the list of different commands from a comment in the source of the interpreter:
 # begin and end a comment
 > increase (without nose, increase by 1 - longer nose increases more)
 < decrease
 ) begin loop (if 0, jump to the instruction after the end of the loop)
 ( end loop (if not 0, jump to the instruction after the beginning of the loop)
 } begin loop (if 0 or less, jump to the instruction after the end of the loo)
 { end loop (if over 0, jump to the instruction after the beginning of the loop)
 D move the pointer forward in the memory
 | move the pointer backward
 P output to stdout (or file)
 E read from stdin
 N zero
 * end the program
 Four-eyed instructions taking two pointers:
 @ second pointer = first pointer (second pointer to the same place with the first)
 $ *second = *first (copy the number)
 O *second = *first + *second (add)
 C *second = *first - *second (subtract)
 S *second = *first * *second (multiply)
 F *second = *first / *second;
 *first = *first % *second (divide with remainder)
 B second pointer = second pointer + *first (move the pointer)
 for example, :8O sums the numbers pointed by : and 8 and puts the result at 8
Any other character (such as a space or newline) is simply ignored, but comments should be begun and ended with # to prevent them from being mistaken as commands.
== Hello World! ==
 ;-~~~~~> ;P ;~~> ;P ;------> ;-P ;--> ;P ;D ;~~---> ;P ;| ;~~< ;----> ;P
 ;~---------> ;P ;--> ;P ;-----< ;P ;-------< ;P ;D ;> ;P ;~< ;-------< ;P
Or shorter:
 ;-~~~~~>;P;~~>;P;------>;-P;-->;P;D;~~--->;P;|;~~<;---->;P;~--------->;P;-->;P;-----<;P;-------<;P;D;>;P;~<;-------< ;P
== See also ==
* Emoticon
== External resources ==
An interpreter written in C
Category:Languages
Category:Implemented
Category:Turing complete
Category:2007
X-script/Examples

Here is some X-script example.
= Hello, world! =
 print("Hello, world!")
== By output file ==
 print("Hello, world!", file = "test.out") # If the file doesn't exist, X-script will automatically create it.
 print("", end = "", file = "CON")
= Truth Machine =
var bool x = bool(parseInt(input()))
if x == False:
 print(0)
else:
 forever:
 print(int(x)) # When outputting a logical value type as an integer, 0 is used for false and 1 for true.
= A+B problem =
var int a, b = parseInt(input()), parseInt(input())
print(a + b)
= Roll dice =
from random import *
var int a = parseInt(input("How many dice do you want to roll?"))
var int b = parseInt(input("Please enter the number of faces per dice:"))
var table c = []
for x in range(0, a):
 c.push_back(randint(1, b))
print(c)
= 99 bottles of beer =
var string s = 5 / 0
print(s)
X.so

X.so is a stack-based, esoteric programming language created by User:AnotherTest.
The X in the name comes from extensible, and the so extension refers the to the shared object files that the X.so interpreter may dynamically load as a form of plugins.
== Syntax ==
The language has a rather minimal syntax which can be described by the following BNF definition (terminals are marked in bold):
 call := id | id . call
 literal := int | real | string | char | call
 stmnt := literal stmnt | ε
 body := block body | stmnt
 block := $ id ( body )
 program := block EOF
Whitespace (consisting of tabs, newlines and spaces) is ignored.
== Semantics ==
Integer, real, string and char literals are pushed on the stack when they are encountered. When a call instruction is encountered, the execution continues in the body of the called routine.
There are only 2 build in routines: Include and Exclude. Import loads the shared object files dynamically with as the name the the top-most stack item. This item should be a string. For example, "X" Import will load ./libX.so. This allows calling routines called X.*. Exclude unloads so files. At the end of execution, all included plugins are automagically excluded.
The execution begins in the "Main" routine. This routine must be in the root routine, which is often given the name of the program. This entry point may also be an indirect child of the root routine.
== Standard plugin: XCore ==
The XCore plugin (generally stored as libX.so on the filesystem) contains the language core functionality. It includes various important features, such as: Pop, If, Add, Subt, Mult, Div, Show, etc.
To allow if-statements, the XCore plugin contains the X.so interpreter. Because of this, XCore supports reflection.
== Completing the language: HELP ==
The HELP is used to complete the language: it adds comments and allows a function-call like notation for calls.
The x.help file contains the following directives:
 # \!([a-zA-Z_][a-zA-Z0-9_]*\s*(\.\s*[a-zA-Z_][a-zA-Z0-9_]*)*)\(([^\)]*)\) := \3\s\1
 # \/\*.*?\*\/ := \s
 # //.*?\n :=
== Computation class ==
The computational class of X.so depends highly on the plugins included. XCore currently does not provide a Turing complete system.
== Examples ==
=== Hello, world! ===
 /**
 * Hello world in X.so.
 */
 $HelloWorld (
 $Main(
 !Include("X")
 !X.Show("Hello, world!\n")
 )
 )
After preprocessing by HELP:
 $HelloWorld (
 $Main(
 "X" Include
 "Hello, world!\n" X.Show
 )
 )
=== Cat ===
 $Cat (
 $Main (
 !Include("X")
 !X.Show(X.Ask)
 )
 )
After preprocessing by HELP:
 $Cat (
 $Main (
 "X" Include
 X.Ask X.Show
 )
 )
== External resources ==
* https://github.com/AnotherTest/X.so
* https://github.com/AnotherTest/XCore
Category:Languages
Category:2012
Category:Implemented
Category:Stack-based
X:

X: is an esoteric programming language created by User:A which further minimizes 123. 
== Instructions ==
The pointer begins at location 0. The program is executed in a loop, and only terminates if the end of the program is reached. All bits start at the value 0.
Instruction	Description
X 	Move left if input is 0. Move right if input is 1.
3 	Specifies a jump symbol. If the pointer is below 0, do nothing. If the current bit is 1, skip back to either the previous jump symbol or the start of the program. If the current bit is 0, skip forward to either the next jump symbol or the end of the program.
Category:Languages
Category:Unusable for programming
Category:Low-level
Category:Brainfuck derivatives
Category:Cell-based
XAH

= XAH =
=== (pronounced ehcks-Aahh) ===
== A library-based language with 3 commands built into the standard library: ==
 List of Commands in the Standard Library
Name	Status 	What it does
! 	Required 	initialize the program
@ 	Not Required	print out whatever is inside the @ and ;
# 	Required 	end the program
== examples: ==
 !
 @hello world;
 #
prints hello world 
 !
 @im a banana;
 #
you know what it does. 
_____________________________________
== Other Libraries ==
Category:Languages
XBF

XBF is a Brainfuck variant.
These are the commands:
* [ ] + - < > , . is same as brainfuck
* ; : is for alternate I/O (error on standard CLI)
* 0-9 A-F moves the low nybble of the value in current cell to the high nybble and then sets the low nybble to the value that you put depending on the command character
* # does a external command numbered by the value of the current cell (error on standard CLI)
* ? insert a cell with value zero
* ! delete a cell
* ( ) move pointer number of spaces according to W register
* X Y Z are registers storing a pointer, set the register to current pointer
* x y z retrieves the registers, set pointer
* W is a register storing a byte, this command sets the register
* w retrieves the value stored in the register
* & value at pointer is set to value at pointer NAND value of W register
These commands work on a line by themself:
* ' makes a label
* '' is a comment
* ^ goto a label
* ^= conditional goto label if value at pointer is equal to W register
* ^< conditional goto label if value at pointer is less than W register
* ^> conditional goto label if value at pointer is greater than W register
* ^! conditional goto label if value at pointer is not equal to W register
* ^; conditional goto label if value at pointer is equal to value at Z register pointer
* ^^ go back to line after last command executed goto label (it only stores one back, not a stack)
* | sets attributes of this file, in the format name=value (ignored on standard CLI)
Category:Languages
Category:Brainfuck_derivatives
Category:2007
XD

XD is an esolang created by User:None1. It is a brainfuck equivalent.
==Commands==
An interpreter of XD randomly decides which brainfuck command to interpret for every XD command.
==Examples==
===Cat===
The program has a very little chance chance to cat.
 XDXDXDXDXD
===Hello World===
The program has a very little chance to print Hello World!
 XDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXDXD
==Computational class==
It is uncomputable, yet Turing complete. XD
==Usablilty==
XD is very useful when you wrote a brainfuck program and don't want others to know it.
==See also==
* Brain:D
Category:Languages
Category:Uncomputable
Category:Joke languages
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Unusable for programming
XERO

XERO (the name being the amount of use you'll get out of this language before giving up) is an esolang by User:BoundedBeans which aims to be as annoying as possible, achieved through required nested try-catch blocks, a strange tritwise operation, and dynamically sized tape.
==Tape==
The tape is a tape of trits, but it is not infinite. The pointer must be at least three tiles away from the top (yes, we're using up and down, not right and left). If the pointer is any further right than that, Error 0 is thrown and the pointer is moved to the bottom cell for the catch block. If the pointer falls off the bottom, Error 0 is thrown and the pointer is moved to the bottom cell for the catch block. The tape initially starts out as empty, meaning you'll need three nested levels of try-catch to even run the program.
The pointer can be moved up with ^, and down with v.
==Tritwise operation==
The only tritwise operation takes three inputs and gives one output.
Inputs are ordered bottom to top. 
This is the table of the first two inputs. First input is on the top.
 0 1 2
 0 2 2 0
 1 1 2 1
 2 0 0 1
The third input follows these conditions:
* If it is 0, use the table above without any changes.
* If it is 1, put the table upside down, without horizontal perspective reverse.
* If it is 2, swap 1s and 2s.
Additionally, if all inputs are 2, throw error 1, in addition to giving the normal result of 2.
If errors 1 and 0 happen at the same time (due to all three arguments being two and the pointer ending up too high), throw error 0.
The tritwise operation effectively replaces the arguments with the result, meaning you lose two cells in the process. The pointer is moved to the result's position.
The tritwise operation can be performed with !
==I/O==
Two commands:
 $ - outputs the trit as a bit of an ascii character (2 is treated as 1)
 # - inputs a bit and converts it to a trit
==Try-catch==
Try-catch is the thing that makes this entire language usable. A try block searches for errors, and if it finds one, breaks and sends control to the catch block. However, if the try block does not throw an error, the catch block runs as if it was error 2. A catch block starts by moving the pointer to the bottom, and then adds the error id to the top of the tape. After the catch block ends, the top trit is removed. The error can be used like any other trit, though it can't be directly accessed without additional nesting since that would require moving the pointer too high. 
Try-catch syntax is:
 {trycode|catchcode}
However, none of the language so far allows for looping or infinite resizing of the tape. The @ command recurses the innermost try-catch block if the current cell is not 0. This can go to as many levels as desired. Every new recursion is treated as a completely separate nested try-catch block, meaning a higher level can catch the errors thrown by a lower level's catch block, and every level adds an additional trit to the top. This accomplishes looping/conditionals as well as expanding the tape arbitrarily, allowing for potential Turing-completeness. 
==Examples==
I don't even know how.
Category:Languages
Category:Cell-based
Category:2022
Category:Unimplemented
XMLfuck

XMLfuck would simply be an implementation of brainfuck using XML, allowing simple universal transport of brainfuck programs, without the need for complex encodings, as well as allowing it to be processed with a single XSLT to pretty-print or even execute the program.
==Tokens==
XMLfuck, being brainfuck, needs only a very minimal set of tags to be fully functional. Proposed tags are:
* <fuck bits="" wrap="" signed=""></fuck> the root element.
* <tapes></tapes> similar to the head section in XHTML, can only exist once and contains configuration parameters.
** <tape name="" type="" length="" start="" /> defines a tape.
* <ptrinc /> and <ptrdec /> for > and <
* <inc /> and <dec /> for + and -
* <print /> and <read /> for . and ,
* <while></while> for [ and ]
Naturally, matching while loops are enforced by the XML spec. No XMLfuck program with unmatched opening and closing while tags is valid XML, and thus is also invalid XMLfuck. Additionally, the work already done by XML parsers can make looping far easier to code in the interpreter.
All of the basic instructions carried over from brainfuck allow the use of a tape attribute, which corresponds to the <tape /> with the corresponding name, and all but while allow for a by attribute, which simply repeats an instruction that many times, a form of run-length encoding.
<print /> will additionally accept a type attribute, one of "default" (&0xFF and print as a character) "numeric" (print as a base-10 number) and "string" (treat consecutive cells as characters and print until null is hit)
for the root element, bits, wrap, and signed specify cell size, defaulting to "8", "Y", "N". if wrap is no, 255 + 1 = 255 for an unsigned 8-bit cell.
for <tape />, if name is omitted this is the default tape, type can be omitted or "default" (infinite tape), or be "wrap", "pos" (extends to +inf), "neg" (to -inf), or "finite", length only applies to wrap and finite, start only applies to finite. Simulation starts set to the closest valid cell to zero.
==See also==
* RDF-fuck
Category:Brainfuck derivatives
Category:Turing complete
Category:Languages
XOṘ Mạchịne

XOṘ Mạchịne is an OISC based on the XOR operation invented by User:A. It is an open question on whether this machine can simulate every logic gate with two parameters.
==Exclusive-Or reference==
A	B	Result
1	1	0
1	0	1
0	1	1
0	0	0
==The Program Execution Process==
Input two bits, where the first bit represents a, and the second bit represents b. After processing the program, output whether a is larger than b. If that is true, output 1. Otherwise, output 0.
There is only 1 constant available. That is the constant 1, which represents the bit 1.
a represents the bit a, and b represents the bit b.
For every two commands, e.g. ab, a XOR b is done and is stored in a.
==Example programs==
===a AND (NOT b)===
===(NOT a) AND b===
abbabb
===NOT (a XOR b)===
aba1bb
===Output 0===
aa
===Output 1===
bbaaa1
===a XOR b===
abbb
===a===
bb
===NOT a===
bba1
===NOT b===
aa1
===b===
b1aa1
===a AND b===
b1
===a NOR b===
a1
==C Implementation==
#include <stdio.h>
int main(int argc, char*argv[]) {
	FILE *fp=fopen(argv[1],"r");
	char code[99999];
	int c;
	for(int i=0;(c=fgetc(fp))!=EOF;i++)
		code[i]=c;
	char a,b;
	char s[3];
	scanf("%s",&s);
	a=s[0]-48;
	b=s[1]-48;
	//debug
	for(int i=0;code[i]!='\0';i+=2) {
		if(code[i]=='a'&&code[i+1]=='a')
			a ^= a;
		else if(code[i]=='a'&&code[i+1]=='b')
			a ^= b;
		else if(code[i]=='a'&&code[i+1]=='1')
			a ^= 1;
		else if(code[i]=='b'&&code[i+1]=='a')
			b ^= a;
		else if(code[i]=='b'&&code[i+1]=='b')
			b ^= b;
		else if(code[i]=='b'&&code[i+1]=='1')
			b ^= 1;
		
	}
	printf("%d",a>b);
	return 0;
}
Category:2019
Category:Languages
Category:Implemented
Category:OISC
Category:Finite state automata
Category:Total
XPML17

XPML17 is a programming language created by User:actuallyallama in 2017. It was designed because the creator hates XML, so he decided to make a programming language based on that.
The main implementation is available on github, and it also shows the example programs and standard functions.
Hello, world!
 <program>
 <main>
 <print literal="Hello, World!"/>
 </main>
 </program>
99 bottles of beer
 <program>
 
 <main arg0="int">
 <while l="arg0" op=">" rlit="1">
 <print var="arg0" literal=" bottles of beer on the wall, "/>
 <print var="arg0" literal=" bottles of beer."/>
 <print literal="&#10;Take one down, pass it around, "/>
 <do l="arg0" op="-" rlit="1"/>
 <print var="arg0" literal=" bottle"/>
 <if l="arg0" op="!=" rlit="1">
 <print literal="s"/>
 </if>
 <print literal=" of beer on the wall.&#10;"/>
 </while>
 <print literal="1 bottle of beer on the wall, 1 bottle of beer.&#10;Take one down, pass it around,&#10;We're out of beer!"/>
 </main>
 </program>