nyuuzyou/wikis huggingface dataset:
XRay

XRay is designed by PSTF. It is for expanding HQ9+.
== Requirements ==
# No uncomputable command.
# No joke command.
# No command longer than 100 character.
# If your program includes the arguments, then they must marked with bold or italic.
== Command Table ==
 Command Table
Command 	Meaning
H 	Print "Hello, world!".
A 	A+B Problem.
h 	Halt the program.
0 	Do nothing.
Q 	Print the source code of program.
!========[lang]SomeCode!========THE END	Do the script with lang language between two boundaries.
q 	Quit program.
FB 	Do FizzBuzz.
; 	Seperates the commands.
9 	Print the lyrics to 99 bottles of beers.
><+-,.[] 	Every character is a command and same as Brainfuck. Until the last character, no semicolons to seperate them.
#c=d 	Defines variable c to d.
E 	Sets the accumulator's value to A2, where A is the accumulator's value.
 	Sets the accumulator's value to √A, where A is the accumulator's value.
== Example ==
=== Hello, world! ===
H;
== See also ==
HQ9+
HQ9+ with headers
== Categories ==
Category:Languages Category:2024 Category:High-level Category:Unimplemented
XS

XS is an obfuscated programming language, devised by Mark Carter, which is based on XML.
XS has two commands: <print> and a for loop.
<print> does the obvious: prints what is between the <print> tag and </print> tag.
The for loop uses the <for> tag, which has the attributes "var" "from" "to" and "step". "var" is rather superfluous as this is never used again. From is the initial value of var and to is the ending value. Step is the increment of var.
Note: XS is possibly a joke.
Also note: There is some dispute as to whether XML is possibly a joke.
==External resources==
* 
==See also==
* XSM
Category:Languages
Category:Unknown year
Category:Total
XSVL

XSVL (eXecutable Symbolic Value Lang) is a minimalist language similar to brainfuck where the syntax is swapped around a bit.
There are only 10 cells.
Symbol	Description
+ 	Increments a cell value.
- 	Decrements a cell value.
> 	Moves to the right cell.
< 	Moves to the left cell.
. 	Prints a cell value corresponding to its ASCII code.
: 	Prints a cell's numerical value.
0 	This character represents any 0-9 numerical digit.The current cell will be multiplied by the specified number.
== Examples ==
=== Hello, World! ===
 +89.0+554+.0+934..+++.>67++.0+84.0+52+8-.<.+++.0+934.0+554.0+84+.
=== XKCD Random Number ===
 +4:
=== 0 Interpreter ===
 Hello :D
== Language history ==
26/08/21 @ 17:32 CST Cell quantity dropped to 10
26/08/21 @ 20:14 CST Response to character , was removed
== Implementation ==
Official C# interpreter by threesodas (zip file)
Category:Implemented
Category:Low-level
Category:Languages
Category: 2021
XTW

Pronounced eks-too-whack, XTW is the successor of TEWNLSWAC.
There is a brainfuck implementation in XTW to proof turing-completeness: https://github.com/zserik/zxtw/blob/master/examples/bf.xtw
== Syntax Differences ==
From 	To 	Description
c <label> <optional: arguments in parentheses> 	<label> ( <optional: arguments> ) 	call function beginning at label,
the different handling of syntax for "no arguments" is needed
to distinguish between call (<label>) and expand (<variable>).
c: <type> <expression> 	c <type> <expression> 	casting operator
<label> : <optional: a <arguments> ; /optional> <body> r;	f <label> <optional: arguments> { <body> }	function definition
=== new Syntax elements ===
Operator 	Compat Levels 	Description
Unary operators 	Unary operators 	Unary operators
i 	3 (string) → 5	load a plugin
Binary operators	Binary operators 	Binary operators
~ 	3 → 0 	check for type equality
Variables within the namespace ::l:: (or l::, if you are still in global namespace) are local to the current function invocation and will be reset to the values they hold before the function call, when the function returns.
=== new Variable Assign Commands ===
==== Unary ====
Command	Description
= a 	assign the next command line argument to a variable and shift it
Category:Languages Category:Implemented Category:High-level Category:Object-oriented_paradigm Category:2017
XUS

XUS is a set esolang made by User:Yayimhere to modify some sets
== data ==
data is stored in sets. a set CAN have copies inside in XUS. a set can be stored as a variable like this: 
 = A {}
this will set A to the set {}. this set cannot contain anything else than other sets. when a operation is used on a set the set updates to the new set
== operators ==
there are 3 operators:
* X will take the following set and add the empty set to it
* U add whats the current set it set to into the following set
* S add the empty set into the most nested part of the set and delete the least nested object
to loop if the current set is not the empty set like this:
 ()
there is a single extension:
* Y print the following set
== examples ==
looping counter. using {} instead of *:
 = counter {}
 X Counter
 (X Counter Y Counter)
Category:Languages
X bottles of beers, take y down, x and y are in Real Numbers Set

x bottles of beers, take y down, x and y are in Real Numbers Set is a program designed and implemented by PSTF.
This is the ADVANCED version of 99 bottles of beer. It receives two real number as input and assign them to x and y, and then print these lyrics(x and y has precision of 3 decimal digit, end if x≤0): 
x bottles of beer on the wall,
x bottles of beer.
Take y down and pass it around, 
x-y bottles of beer on the wall.
x-y bottles of beer on the wall,
x-y bottles of beer.
Take y down and pass it around, 
x-(2×y) bottles of beer on the wall.
--snip--
Thus you may see this stupid lyric:
Take 5.283 down and pass it around, 
-4.229 bottles of beer on the wall.
== Implementations ==
=== Python ===
x = float(input())
y = float(input())
while x > 0:
 print(f"{x} bottles of beers on the wall, \n{x} bottles of beers. \nTake {y} down and pass it around, \n")
 x -= y
 print(f"{x} bottles of beers on the wall. \n\n")
print(f"""
No more bottles of beer on the wall, 
no more bottles of beer.
Go to the store and buy some more, 
{x} bottles of beer on the wall.
""")
=== C++ ===
#include<bits/advc++.h>
using namespace std;
string unit = "bottles";
long double x, y;
int main()
{
	printf("Please input: ");
	cin >> x;
	printf("Please input again: ");
	cin >> y;
	system("cls");
	for (long double i = x; i > 0; i -= y)
	{
		if(i==1.0)
		{
			unit="bottle";
		}
		else
		{
			unit="bottles";
		}
		cout << fixed << setprecision(3) << i << " " << unit << " of beer on the wall, \n";
		cout << fixed << setprecision(3) << i << " " << unit << " of beer. \n";
		cout << "Take " << y << " down, pass it around, \n";
		cout << fixed << setprecision(3) << i - y << " " << unit << " of beer on the wall.\n\n";
		Sleep(50);
	}
	cout << "No more bottles of the beers on the wall, \n";
	cout << "No more bottles of the beers. \n";
	cout << "Go to the store and buy some more, \n";
	cout << fixed << setprecision(3) << x << " bottles of the beers on the wall.";
	return 0;
}
=== ！中文 ===
以“请输入初始数值：”作为提示输入 x 。
以“请输入\“增量\”：”作为提示输入 y 。
将 i 初始化为 x 。
清空屏幕。
重复执行以下代码直至 i 不大于 0 ：
{
 输出“%1 bottles of beers on the wall, \n%1 bottles of beers.\n”。%1将被 i 替代。
 将 i 减去 y 。
 输出“Take %1 down and pass it around,\n %2 bottles of beers on the wall.\n\n”。%1将被 y 替代，%2将被 i 替代。
}
输出“No more bottles of beers on the wall, \nNo more bottles of beers. \n”。
输出“Go to the store and buy some more, \n%1 bottles of beers on the wall.”。%1将被 x 替代。
== See also ==
99 bottles of beer
== Categories ==
Category:Program forms
X strike

X strike is an esolang created by User:Infinitehexagon. It has 4 commands and a keyword used for separating arguments.
Category:LanguagesCategory:2023Category:Cell-basedCategory:Turing completeCategory:ImplementedCategory:Turing tarpits
==Commands==
Command	Description
X!×a 	Increment the cell under the memory pointer by a then shift the memory pointer right.
x!×a 	Decrement the cell under the memory pointer by a then shift the memory pointer left.
X×a×b 	Goto line a if the cell under the memory pointer equals b. Lines are enumerated commencing with the number one (1).
x^a×b×c	Store decimal input into cell a and output cell b if cell c is nonzero. If any of the arguments are below 0, they get skipped.
==Programs / Example Programs==
===Hello world===
 X!×72
 x^-1×0×-1
 X!×101
 x^-1×1×-1
 X!×108
 x^-1×2×-1
 X!×108
 x^-1×3×-1
 X!×111
 x^-1×4×-1
 X!×32
 x^-1×5×-1
 X!×119
 x^-1×6×-1
 X!×111
 x^-1×7×-1
 X!×114
 x^-1×8×-1
 X!×108
 x^-1×9×-1
 X!×100
 x^-1×10×-1
===One Time Cat===
 x^0×0×-1
===Repeating Cat Program===
This cat program perpetually queries for a number and outputs the same:
 x^1×1×-1
 X×1×0
===XKCD Random Number===
X!×4
x^-1×0×0
===Truth Machine===
 x^0×-1×-1
 x^-1×0×-1
 X×2×1
===Modulo program(n mod 256)===
 x^0×-1×-1
 X!×0
 x^1×-1×-1
 X×7×-1
 X!×1
 x!×0
 X×5×256
 x^-1×1×-1
 
==Computational class==
Language is Turing-complete. It can be proven by translating brainfuck with GOTO commmands into it. Note that it assunes that argument for X!×a and x!×a could be zero, even though it is probably Turing-complete even with restriction that they could only be positive. Initialize tape:
 X!×0
+ command is translated like that:
 X!×1
 x!×0
- command is translated like that:
 x!×1
 X!×0
> is:
 X!×0
< is:
 x!×0
Jump to line a if cell is zero:
 X×a×0
==Interpreter==
* Common Lisp implementation of the X strike programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
X vs. Y

X vs. Y is a very simple esolang by User:Yayimhere
== memory ==
memory is stored in variables. they are defined like this:
 x y
this sets x to the signed binary number y
== syntax ==
 Caption text
symbol	written	description
! 	x ! y 	if x is more than y set y to 0, if they are equal set x to x + y, and if y is more than x set x to 0
# 	# x 	goto line x
- 	- x 	decrement x by 1
/ 	/x/A 	if x is non-0 do code A
Category:Languages
Xand

Xand is a programming language that is a OISC, x, y, z -> x = ((x xor y) and z)
== Not ==
 (a)
 a, 1, 1 #a will be negated, 0 to 1, 1 to 0, numbers turn into binary, 4 -> 100, 8 -> 1000
== And ==
 (a, b)
 a, 0, b #a and b will be combined, 1, 1 -> 1, else 0
== Nand ==
 (a, b)
 a, 1, 1
 a, 0, b #a will turn into (!(a&b))
== Or ==
 (a, b)
 a, 1, 1
 b, 1, 1
 a, 0, b
 a, 1, 1
== Nor ==
 (a, b)
 a, 1, 1
 b, 1, 1
 a, 0, b
== Shift ==
 (a, b)
 c, 1, 1
 c, 0, a
 a, 0, 0
 a, 1, 1
 a, 0, b
 b, 0, 0
 b, 1, 1
 b, 0, c
=== Shift 3 ===
 (a, b, c)
 d, 1, 1
 d, 0, a
 a, 0, 0
 a, 1, b
 b, 0, 0
 b, 1, c
 c, 0, 0
 c, 1, d
=== Cut Shift ===
 (a, b)
 a, 0, 0
 a, 1, b
 b, 0, 0
== Set ==
 (a, b)
 a, 0, 0
 a, 1, b
= Implementation =
 #python
 import sys
 try:
 inpu = open(sys.argv[1]).read()
 varibs = {"0": False, "1": True}
 if sys.argv[1][-5:len(sys.argv[1])] != ".xand":
 raise ZeroDivisionError("error for file type")
 for inputs in inpu.split("\n")[0][1:-1].split(", "):
 varibs[inputs] = bool(int(input("input for "+inputs)))
 def doline(line):
 inp = line.split(", ")
 varibs[inp[0]] = (varibs[inp[0]] ^ varibs[inp[1]]) & varibs[inp[2]]
 for lines in inpu.split("\n")[1:]:
 doline(lines)
 del varibs["0"]
 del varibs["1"]
 for varib in varibs:
 print(varib+": "+str(int(varibs[varib])))
 except IndexError:
 print("You have not included the input file")
 except ZeroDivisionError:
 print("You have used the wrong file type, .xand is the file type")
 except FileNotFoundError:
 print(f"The file '{sys.argv[1]}' does not exist")
Category:Languages Category:OISC Category:Implemented
Xaxa

Xaxa is a language derived from BF made by User:ChuckEsoteric08.
==Commands==
Command	Meaning
> 	move pointer to the right and increment cell under the pointer
- 	decrement cell under the pointer
< 	move pointer to the left
? 	skip all commands until next ! if zero
^ 	back to command n, where n is value of cell under the pointer
. 	output cell
, 	input number and store it in cell
==Examples==
===Infinity loop===
 >^
===Cat program===
The following program provides an infinitely repeating cat program. Please note that upon each iteration a new cell is appended to the program's memory, thus incurring upon it the contingency to exhaust the executing machine's storage.
 ,.>^
===Truth-machine===
The source code below realizes a truth-machine:
 ,?><>-.<>^!
==Interpreter==
* Common Lisp implementation of the Xaxa programming language.
Category:Languages Category:Unknown computational class Category:Cell-based Category:Implemented
Xdi8 aho fHL mA

Remember that I used old-Shidinn language. If you want to get a new-Shidinn language script, please put it on 〇改希顶转写器.
Xdi8 aho fHL mA is an Esolang invented by PSTF. It based on an artifical language which calls "Shidinn". For more details of Xdi8, please goto https://wiki.xdi8.top/wiki/Shidinn Wiki: Main_Page.
== Commands ==
Straight to the point, the commands must write in ！中文, and then put it on Shidinn Translator.
== Programs ==
THERE ARE A LOT OF PROGRAMS. THEY ARE IN xdi8 aho f꜕刀 m∀/Nʎ ߔʎd hβ8 s∀ꝇ.
== For more detail ==
https://wiki.xdi8.top/wiki/希顶维基:首页
== Categories ==
Category:Languages
Category:2024
Category:Unimplemented
Category:High-level
Category:Pseudonatural
Xdi8 aho fHL mA/NV FVd hB8 sA5

Main page: Xdi8 aho fHL mA
== Hello, world! ==
 c3q DA “wi8o ti2 dde AHL zY.”.
== A+B Problem ==
 dAi rAH viT Vga 4rz8 su6H, c3q DA tiaf Vm8 de ofie.
== x bottles of beers(Take y down) ==
NiT “iq8 c3q rAH ul AtY su6H VH6:” zo1 wE ti68 HuTH c3q rAH x .
NiT “iq8 c3q rAH \ “H3d bliT \”:” zo1 wE ti68 HuTH c3q rAH y .
jT i ul AtY fia wE x .
Eq8 k3 pi8p mAp.
zu3 kiY HuaH x8H NiT xa dY sma H6 HY i bA da yA ·0·:
{
 c3q DA “① bottles of beers on the wall, \n① bottles of beers. \ n”. ① jT bi1u i tia dY.
 jT i jYE qA y .
 c3q DA “Take ① down and pass it around, \n② bottles of beers on the wall.\n\n”. ① jT bi1u y tia dY, ② jT bi1u i tia dY.
}
c3q DA “No more bottles of beers on the wall, \nNo more bottles of beers. \n”.
c3q DA “Go to the store and buy some more, \n① bottles of beers on the wall.”. ① jT bi1u x tia dY.
== Fizzbuzz ==
D3 ·1· NV H6 c3q DA FLH ·1000· . dVH yA mV Vga su6H fHL n, yu6H:
rA gio n FT 7io ·3· = T, De c3q DA “o”.
rA gio n FT 7io ·5· = T, De c3q DA “4a”.
Vd2 sE, rA gio n t3 HoH sE ·3· ofie ·5· de biVV su6H (NiY n FT 7io ·15· = ·0·), c3q DA “o4a”.
pia De, c3q DA n de VH6.
== Others ==
 NiY jT FV8 DA, ki8 iq8 FY2 FY1.
== Categories ==
Category:Examples
Xeroxer

Xeroxer is an OISC by User:Pro465. it has only one command:
cpyjmp len, offset | (copy the instructions at the address ip-len..ip (exclusive)
to the end of the program, then jump to ip + offset + 1)
at the start, ip=0, and the interpreter starts executing the first command. when there are no more commands to execute, the program stops.
if the current command requires copying n commands, where n > ip, it is Undefined behavior.
== Properties ==
* Since it is an OISC, the instruction can be made implicit, and programs would simply consist of lists of numbers.
* Since all the operations happen to the program itself, there is no distinct place for data.
* It is known to be able to simulate a superset of Echo Tag, and thus to be Turing-complete.
* It can also simulate tag systems directly.
== Extension ==
because cpyjmp 0, 0 does nothing, implementations may optionally provide output using the previous instruction's len argument encoded as unicode code point when they encounter this.
for example, 
0 1
65 0
0 0
should if implemented, print the character 'A'
== Examples ==
=== Truth machine (kind of) ===
(Note: uses output extension specified above) 
since Xeroxer with output extension has no Input, we need another route. the following program has input in its first instruction as its jump argument. by default, it outputs 0 before halting. change the first line to 0 2 to observe an infinite loop of 1s. 
0 1
0 0
0 2
0 5
48 0
0 0
0 4
1 1
49 0
0 0
3 0
not using output extension:
0 0
0 3
0 1
1 0
1 0
== See also ==
* Echo Tag
* Footsteps
* ResPlicate
* SMITH
== External Links ==
* reference implementation in Github
Category:2023
Category:No IO
Category:Turing complete
Category:Turing tarpits
Category:Languages
Category:Implemented
Category:OISC
Category:Self-modifying
Xeroxer/translate.rs

:
the following code simulates a superset of Echo Tag in Xeroxer, thereby proving the latter's turing-completeness:
fn main() {
 let productions = &[[false, false], [false, true]];
 let input = &[true, false];
 let prog = prod(productions, input);
 println!("{:?}", prog);
}
const S: usize = 21;
fn prod<const N: usize>(p: &[[bool; N]], inp: &[bool]) -> Vec<(usize, usize)> {
 let n = S * N;
 let rlen = n + 7;
 let mut res = vec![(0, rlen * p.len() + 2)];
 for r in p.iter().copied().rev() {
 rule(&mut res, r, p.len());
 }
 assert_eq!(res.len() - 1, rlen * p.len());
 for c in inp {
 bitconv(&mut res, *c, rlen, n, p.len());
 }
 res
}
fn rule<const N: usize>(v: &mut Vec<(usize, usize)>, r: [bool; N], p: usize) {
 let prev = v.len();
 let n = S * N;
 let rlen = n + 7;
 v.extend_from_slice(&[(0, rlen * (p - 1) - 2), (0, n + 3), (S, 0), (0, n)]);
 {
 let prev = v.len();
 for b in r {
 bitconv(v, b, rlen, n, p);
 }
 assert_eq!(v.len() - prev, n)
 }
 v.extend_from_slice(&[(n, 5), (n + 4, 11), (rlen * (p - 1) - 1, rlen + 16)]);
 assert_eq!(v.len() - prev, rlen)
}
fn bitconv(v: &mut Vec<(usize, usize)>, b: bool, rlen: usize, n: usize, p: usize) {
 v.extend_from_slice(&[
 (S, 0),
 (0, S - 2),
 (b as usize * (n + 7), 6),
 (S, 0),
 (0, 3),
 (S, 0),
 (0, rlen * p + 2),
 (0, rlen * (p - 1) - 2),
 (3, 0),
 (6, 0),
 (n + 16, 4),
 (0, 2),
 (n + 4, 11),
 (rlen * (p - 1) - 1, rlen + 16),
 (2, 0),
 (4, 0),
 (rlen * p + 16, 3),
 (0, 1),
 (rlen * (p - 1) - 1, rlen + 16),
 (1, 1),
 (3, 1),
 ]);
}
Category:Proofs
Category:Implementations
Xigxag

Xigxag is a simple string-copying automaton designed by Chris Pressey in 2001, but not released until 2007.
==Execution==
A Xigxag configuration is a finite string of < and > symbols. On each transition, every symbol in the string is checked; if the symbol is <, everything to the left of that symbol is copied into the next configuration, and if the symbol is >, everything to the right of that symbol is copied into the next configuration. Substrings are copied into the next configuration left to right.
Along with the definition of the automaton and the release of a Perl script that implements it, Chris Pressey has given a proof that Xigxag has exponential growth for all but a finite number of initial configurations.
Although Xigxag is so simple that it is extremely unlikely that it is Turing-complete, it is also difficult to construct a proof showing that it is not.
===Periodic patterns===
The following are the only periodic patterns, found by searching all strings of length 7 or shorter. Chris Pressey has proved that all longer strings grow exponentially. Periodic patterns are configurations which eventually return to the initial one (in all the below cases, immediately).
* the empty string
* <<<
* >>>
* <><>
* <<<>>>
==External resources==
* Xigxag project at Cat's Eye Technologies
Category:Languages
Category:Implemented
Category:Unusable for programming
Category:Unknown computational class
Category:2001
Xjansk

Xjansk is a stack-based esoteric programming language under construction by DanielE (talk). It uses the following commands:
 Commands in Xjansk
command 	description
x 	cheks if top value of the stack is 0 or not. If it is 0, the pointer skips the next command.
k 	lets the code between k and k[space] loop forever.
j 	gets input from user and translates the characters to their corresponding ASCII values.
j[space] 	same as j, but only 1 character
nj 	same as j[space], but only numbers
n[space] 	adds top 2 values
nn[space] 	subtracts top value of value beneath it
nnn[space] 	multiplies
nnnn[space] 	divides
s 	prints top value
s[space] 	prints top value as an ASCII value.
s[space][space]	pops top value
a 	duplicates top value
a[space] 	places bottom value on top of the stack
(number) 	pushes that number on top of the stack
(char) 	pushes that character on top of the stack
== Program examples ==
====Hello world====
Simple version:
 72s 101s 108as s 111s (NOT correct and must be updated)
==== Cat program ====
 jka xs 
This should probably work as a cat program.
====Truth machine====
 njxks
This should (again) probably work as a Truth machine. nj takes one character as input from the user. If it is 0, it prints that character and ends. If it is 1 or not 0, it will print itself forever with the k command.
====square====
 njannn s 
More information follows.
Category:2022
Category:Languages
Category:Stack-based
Xo

Xo is an esoteric programming language created by Nax.
It's computational class is Bounded-storage machine as it has a strictly limited memory allocation.
== The XVM ==
Xo runs on a virtual machine. The official virtual machine is called XVM and can be downloaded here .
The XVM is a 8 bit machine with a 16bit virtual address bus. It features 4 registers and one flag.
Category:Languages
Category:2013
Category:Implemented
Category:Brainfuck derivatives
Xponent

Xponent is a esoteric programming language where instead of writing individual parts in your code to symbolize different instructions, you have to instead represent the program and its instructions
unlike my other esoteric programming language, ooh, Xponent has only 1 instruction. whirl might be impressive for having only 2 instructions, but Xponent has one. such an absurd amount of commands to work with wouldn't make any sense. because what instruction can make up one whole language?? well I found a work-around for this language:
 Instructions (or instruction)
Character	Description
x 	add one to the program identifier and execute the program when every x has been compiled
allow me to explain.
the "program identifier" is the number which represents the program and its instructions.
in other words, the program identifier is basically the combination number of the sequence of instructions.
these "sub-instructions" work as normal. and have basic uses:
 Sub-instructions
Number	Description
0 	do absolutely nothing
1 	increase value
2 	decrease value
3 	print value
4 	print value as ascii character
5 	store value for future use
6 	get previously stored value. does not remove or unset stored value (stored value defaults to 0)
7 	get input and set value to its ascii number (only takes the last character)
8 	store value and set value to stored (flip value and stored value)
9 	print source code (I didn't really know what to put here tbh)
it's hard to explain exactly how the program combination is calculated. but don't worry. its deterministic. its also not intended to be hard t figure out.
== Hello world program ==
 hell no
== Quine ==
its actually not that hard
 xxxxxxxxx
== Additional details ==
there's probably a lot of things I left out :/
== Implementations ==
 I'm working on it
Category:Languages Category:Total Category:Unusable for programming