nyuuzyou/wikis huggingface dataset:
Unnamed

Unnamed is a language designed to make manipulating grids and other 2D structures much easier. It uses a series of commands and setup statements to generate an output. This page will be expanded as the feature set improves.
== Overview ==
An Unnamed program starts of with defining the size of the matrix, followed by a series of arguments, followed by the actual code. All whitespace is ignored while parsing.
== Setup ==
Each item in the setup is separated by a :. An example is:
 8,10:F:
This will create a matrix with the dimensions of 8x10 and with the arguments F.
=== Sizes ===
They're three ways to specify the dimensions of your matrix.
==== NxM Matrixes ====
Creating an NxM matrix is probably the most self-explanatory. You simply replace N and M:
 N,M:
==== NxN Matrixes ====
These are also very similar to the previous method, replace N with the desired size:
 N,N:
==== Auto / Arbitrary length ==== 
If case you don't really know what size your program will need to be, you would use this. An example is if you were to specify the size later in the program, or expand the matrix later. This can be done by inserting a question mark:
 ?:
=== Arguments ===
Various arguments will result in different program and output formatting and behavior. Arguments are placed together and then followed by a colon. An example is, if you were to use two arguments, a and argument b, it would look like:
 ab:
If you were to have no arguments, it would be as simple as:
 :
Note: some arguments such as f and F are almost always used in order for each column to line up.
Argument	Description
f 	Left-aligns each cell
F 	Right-aligns each cell
Category:Languages
Category:Unknown computational class
Unnecessary

Unnecessary is a programming language from 2005 by Keymaker where the existence of a program file is considered an error. The valid Unnecessary program file extension is 'unn'. However, if there is no program file, the interpreter or compiler can work normally and perform a nop.
The language was designed to be easy to learn and implement. It was also part of the design to make the language very simple to program in.
Storing all your Unnecessary programs takes less than a bit of space, and distributing programs is fast and easy.
An Unnecessary interpreter must check if the program file exists and then do the following:
*If the file doesn't exist, run NOP and end the program execution successfully.
*If the file exists, report an error and terminate immediately.
A compiler should make the language it compiles to perform only nop and nothing else; but naturally only if the Unnecessary program file is not found.
Every working program is the null program and a quine.
==Example==
Run file 'example.unn' with your Unnecessary interpreter. (Note: First make sure there isn't a file called 'example.unn'. If there is, remove it before executing (or change to a different directory).)
==Interpreter==
In case you use a UNIX system and do not have an Unnecessary interpreter, UNIX systems have a similar program built in – use the command test ! -e to activate it (followed by filename). However, if the file does exist it will fail silently instead of reporting an error, so it is not perfect, but it is close enough in case you don't care about the error messages.
If you like errors, you can use this slightly more complex command: test ! -e example.unn || echo "Error: File exists" (substitute example.unn with your file).
==External resources==
* The official Unnecessary page
* The official Unnecessary interpreter written in Python
* Another Unnecessary interpreter written in Ruby
* A third Unnecessary interpreter, written in Java
Category: Languages
Category: 2005
Category: Joke languages
Category: Unusable for programming
Category: Non-textual
Category: Zero-dimensional
Category: Implemented
Category: Total
Category: No IO
Category: No-code esolang
UnnumericJS

UnnumericJS is an esolang create by User:None1 and inspired by MangularJS and JSFuck. It is JavaScript, but if your program includes digits (the characters 0~9), the program raises a syntax error.
==Examples==
===Hello World===
 console.log('Hello World')
===Truth Machine===
function truth_machine(input){
 if(input==!+!!){
 while(!){
 console.log(!+!!);
 }
 }else{
 console.log(!!+!!);
 }
}
Since JavaScript has no input, UnnumericJS also has no input, so you have to pass !!'' for 0 and !'' for 1 to the truth_machine function.
===Raise a syntax error===
 0
==Interpreter in JavaScript==
function unnumericjs(code){
 for(let i of '1234567890'){
 if(code.includes(i)){
 throw new Error('Syntax error');
 }
 }
 eval(code);
}
==Turing completeness==
We can use !!+!! for 0 and !!+! for 1, and therefore we can represent any number. Using String.fromCharCode, we can represent any string, and finally, we can use eval to run any JavaScript code. As a brainfuck interpreter is written in JavaScript, JavaScript is Turing complete, so UnnumericJS is also Turing complete.
Category:Languages
Category:Esoteric subset
Category:Turing complete
Category:2023
Category:Output only
UnnumericPy

UnnumericPy is an esoteric programming language created by User:Marina and inspired by UnnumericJS. It is an equivalent to Python, but if the code has any digits it will raise a syntax error.
==Examples==
===Hello world===
 print("Hello World")
===Cat program===
 i = input(">>>")
 print(i)
===Truth machine===
a=input(">>> ")
if a==str(int(False)):
 print(int(False))
elif a==str(int(True)):
 while True:
 print(int(True))
else:
 raise Exception
Here, int(False) and int(True) are used for 0s and 1s.
A shorter one that doesn't use number literals (int(False) and int(True)):
a=input(">>> ")
if int(a):
 while ' ':
 print(a)
else:
 print(a)
===Syntax error===
 0
==Interpreter==
===Python===
 def unnumericpy(code):
 for i in range(10):
 if str(i) in code:
 raise SyntaxError("syntax error")
 exec(code)
== Expressiveness ==
All of Python can be expressed in UnnumericPy.
=== Literals ===
We replace integer, floating-point, and complex literals first. The integers can be generated from arithmetic on -1, 0, and 1. The literals True and False can be used as 0 and 1. -1 is constructed as ~0. They can also be constructed from the integer constructor:
 int() # 0
 ~int() # -1
 -(~int()) # 1
The floating-point numbers are generated as ratios of integers using the true-division operator. The special cases do not require digits:
 float("nan")
 float("inf") # and float("-inf") or -float("inf")
Complex numbers are built using their constructor instead of literals.
=== Names ===
Next, we recover the ability to access names containing digits. To access a local or global, use the string constructor and string concatenation to build the name as a string, then use it as a key on the corresponding scope dictionary. For example, to access the local name "x2":
 locals()["x" + str(-(~int() + ~int()))]
This generalizes to imports as well, since package names are passed as strings. For example, to import the standard-library module "sqlite3":
 from importlib import import_module
 three = -(~int() + ~int() + ~int())
 sql = import_module("sqlite" + str(three))
==Turing completeness==
Because all of Python is still expressible, UnnumericPy is trivially Turing-complete.
Category:Languages
Category:High-level
Category:Implemented
Category:2023
Category:Turing complete
Category:Esoteric subset
UnoScript

UnoScript is a stack-based, interpreted language inspired by the UNO card game.
It aims to be as general-purpose and usable as possible while meeting the constraint that any sequence of UNO cards can be interpreted as an UNO program.
== Language description ==
=== Symbols ===
A standard UNO card game comes with cards of the following types:
* Color cards in red, yellow, green and blue, each with a digit between 0 and 9
* Skip cards
* Reverse cards
* Draw Two cards in red, yellow, green and blue
* Wild Draw Four cards
* Wild cards
An UnoScript program consists of a sequence of these cards, with the original UNO cards mapped to the strings:
* Color -> [rygb][0-9]
* Skip -> skip
* Reverse -> reverse
* Draw Twp -> draw2
* Wild Draw Four -> draw4
* Wild -> wild
=== Resources ===
The language specifies an internal stack capable of holding Color, Draw Two, Wild Draw Four and Wild card types.
This internal stack is used to perform operations.
The language also specifies an array of length 40 capable of holding any card type. Each Color card can be used as an index into the array.
=== Execution model ===
UnoScript is interpreted in a similar manner to a Turing machine, where the program source can be pictured as symbols printed on a tape. The interpreter head begins with the first item. Based on its value and the top value of the stack, the head can choose to manipulate the stack or card array, and then must move to the right or left.
In order to meet the constraint that any sequence of UNO cards be valid, the language makes provisions to handle out-of-bounds resource access, e.g. reading the top value of an empty stack will return a Wild card.
=== Sample program ===
The following "hello world" program is taken from the examples provided by the interpreter. It will print "Hello world" to standard out, followed by a new line.
 # ( -- \ndlrow olleH )
 y1y0
 r1r0r0
 y1y0y8
 r1r1r4
 y1y1y1
 r1r1r9
 y3y2
 r1r1r1
 y1y0y8
 r1r0r8
 y1y0y1
 r7r2
 # ( \ndlrow olleH -- )
 draw2g2
 draw2g2
 draw2g2
 draw2g2
 draw2g2
 draw2g2
 draw2g2
 draw2g2
 draw2g2
 draw2g2
 draw2g2
 draw2g2
=== Interpreter ===
Currently, the only interpreter for UnoScript is implemented in C++ and flex.
== External links ==
* UnoScript source
* UnoScript specification
Category:Languages
Category:Stack-based
Category:Implemented
Category:Output_only
Category:Thematic
Category:2020
Unpseudorandom

Unpseudorandom is a language based on Unrandom, which provides a seed for generating brainfuck code randomly. However, in Unpseudorandom, the randomness is constrained to make meaningful programs more likely, and thus easier to construct. For example, Unrandom can generate ][, an invalid brainfuck program, unlike Unpseudorandom. Unpseudorandom code always ends in a ., never follows + or < with - or > respectively, and vice versa, and always generates [ and ] in pairs. It never follows a [...] block with another, and never generates a program with just a ..
A valid program consists of an string that the host language natively recognises as a single integer, which is used to seed the pseudorandom number generator. The code transpiles to brainfuck.
Whether the language is Turing complete depends on the random number generator used by the implementation. Speaking of implementations, here's a reference transpiler in Python 3.
Transpiler from Unpseudorandom to brainfuck
import random
def generate(seed, log_func=lambda *s: None):
 commands = [_left, _right, _up, _down, _in, _out, _around, _stop]
 random.seed(seed)
 code = ["@"]
 #replace @ symbols with more code
 while "@" in code:
 log_func(*code)
 where = code.index("@")
 new = random.choice(commands)("".join(code[:where]))
 code[where:where+1] = new
 code += "." #code that is after the last output of program is redundant
 log_func()
 return "".join(code)
#commands:
def _left(previous):
 if previous.endswith(">"):
 # >< is redundant
 return "@"
 return "<@"
def _right(previous):
 if previous.endswith("<"):
 # <> is redundant
 return "@"
 return ">@"
def _up(previous):
 if previous.endswith("-"):
 # -+ is redundant
 return "@"
 return "+@"
def _down(previous):
 if previous.endswith("+"):
 # +- is redundant
 return "@"
 return "-@"
def _in(previous):
 return ",@"
def _out(previous):
 return ".@"
def _around(previous):
 if previous.endswith("]"):
 # [...][...] is redundant
 return "@"
 return "[@]@"
def _stop(previous):
 if previous.endswith("["):
 # [] is redundant
 return "@"
 if previous == "":
 # no empty programs
 return "@"
 return ""
if __name__ == "__main__":
 seed = input("Enter seed:").strip()
 while seed.isnumeric():
 print(generate(int(seed), log_func=print))
 seed = input("Enter seed:")
==Examples==
An example program is 2333, it becomes <,+,,., which reads three characters and prints the last.
Category:Languages
Category:Brainfuck derivatives
Category:2020
Category:Implemented
Category:Cell-based
Category:Zero-dimensional
Category:No set computational class
Unrandom

Unrandom is an esoteric programming language by User:InCrIpTiOn that uses an integer to randomly generate BrainFuck code.
==Syntax==
An Unrandom program is represented with a single integer that acts as the seed for a Random Number Generator. The length of the generated code is length of the original integer (in characters, e.g: 23423 = 5). Every compiled character is a random number between 0 and 7 inclusively, which is the index of the BrainFuck character.
==Compilation==
The output of the code is dependant on the RNG used. This example uses the python library Random, and outputs (not runs) the brainfuck code.
 import random
 def run(x):
 random.seed(x)
 instructions = ['>','<','+','-','.',',','[',']']
 brainfcode = [instructions[random.randint(0,7)] for _ in str(x)]
 code="".join(brainfcode)
 return code
==Examples==
Due to the nature of the language, it is unsure whether it is possible to determine the output of the code. For this reason, there are no example programs.
However, an example of valid code would be 19, which results in "><", which does nothing.
==See also==
*Unpseudorandom
Category:Languages
Category:Brainfuck derivatives
Category:2020
Category:Works-in-Progress
Category:Unimplemented
Category:Joke languages
Category:Zero-dimensional
UnreadabIe

UnreadabIe is an esoteric programming language made by User:A. It is a substitution of Unreadable. (" is substituted by ˈ.)
== Commands ==
The commands are:
'X 	Print X as a Unicode character and return X.
'ˈˈX 	Return X + 1.
'ˈˈˈ 	Return 1.
'ˈˈˈˈXY 	Do both X and Y and return what Y returned.
'ˈˈˈˈˈXY 	Do Y while X is not 0 and return the last result.
'ˈˈˈˈˈˈXY 	Set variable number X to Y and return Y.
'ˈˈˈˈˈˈˈX 	Return the value of variable X, or 0 if the variable has never been assigned.
'ˈˈˈˈˈˈˈˈX 	Return X - 1.
'ˈˈˈˈˈˈˈˈˈXYZ	If X is not 0 do Y else do Z. Return what Y/Z returned.
'ˈˈˈˈˈˈˈˈˈˈ 	Return a single Unicode character which has been read from stdin, or -1 if stdin is exhausted.
Category:Joke languages
Category:2019
Category:Unimplemented
Category:Turing complete
Category:Turing tarpits
Category: Languages
Unreadable

Unreadable is an esoteric programming language made by User:TehZ. As the name hints, it is made specifically to be unreadable.
== Alphabet ==
The only characters are " and '. With a font where " looks like '' (such as Arial; see " compared to ''), it is like programming in Whitespace; you cannot tell what you are doing. No spaces or newlines are allowed.
== Syntax ==
The syntax is:
 command = ' "+ command*
As you can see, the syntax is really simple and unreadable.
== Commands ==
The commands are:
'"X 	Print X as a Unicode character and return X.
'""X 	Return X + 1.
'""" 	Return 1.
'""""XY 	Do both X and Y and return what Y returned.
'"""""XY 	Do Y while X is not 0 and return the last result.
'""""""XY 	Set variable number X to Y and return Y.
'"""""""X 	Return the value of variable X, or 0 if the variable has never been assigned.
'""""""""X 	Return X - 1.
'"""""""""XYZ	If X is not 0 do Y else do Z. Return what Y/Z returned.
'"""""""""" 	Return a single Unicode character which has been read from stdin, or -1 if stdin is exhausted.
== Limits/bounds ==
There are no max values, and no bounds in this language.
== Computational class ==
Unreadable is Turing complete because it is possible to convert a brainfuck program to Unreadable:
*Reserve the first variable as the tape pointer.
*Make +/- increment/decrement the variable it points to.
*Make >/< increment/decrement the pointer.
*Make [] become a loop that checks for the variable that the first variable points to.
*Make . print the variable the first pointer points to and make , read input into that variable.
== Interpreters ==
* Command-line interpreter by User:Marinus (written in Python).
* Esoteric IDE that supports Unreadable (GitHub)
Category:Turing tarpits
Category:Implemented
Category:2010
Category:Languages
Category:Joke languages
Category:Turing complete
Category:Functional paradigm
Category:Nested
Unsquare

Unsquare was named after Dave Brubeck's Unsquare Dance. Unsquare Dance is unusual in rhythm, and so is the esolang.
==Instructions==
Command	Meaning
O 	Push 0.
I 	Push 1.
A 	Pop the top of the stack into the accumulator.
S 	Swap the top 2 items of the stack.
+ 	Add 2 to the accumulator.
- 	Subtract 2 from the accumulator.
x 	Multiply the accumulator by 2
P 	Push the accumulator.
o 	Output the top of the stack. (Note: This does not discard the top of the stack.)
i 	Wait for user input, then push it onto the stack.
> 	If the accumulator is 0 or 1, jump to the corresponding <.
< 	If the accumulator is not 0 nor 1, jump to the corresponding >.
==Examples==
===Hello, world!===
Note: This was made before multiplication.
 OA++++++++++++++++++++++++++++++++++++oIA++++++++++++++++++++++++++++++++++++++++++++++++++oOA+++++++++++++++++++++++++++++++++++++++++++++++++++ooIA++++++++++++++++++++++++++++++++++++++++++++++++++++oOA++++++++++++++++++++++o------oIA+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++o----oOA+++++++++++++++++++++++++++++++++++++++++++++++++++++++++o---o----o
===Cat program===
 iA>PoiA<
===Truth-machine===
 ioAx>Io<
== Implementations ==
A Ruby interpreter and x86 assembly compiler (written in Python) by User:Bangyen.
Category:LanguagesCategory:ImplementedCategory:Stack-based
Untotal Array Changer

Untotal Array Changer is a version of Array Changer with a single new command
== new command ==
this new command is:
 (P) where P is a program
treat P as a single command
== infinite loop i think but its incomplete and a proof of concept idk ==
 F(some code that makes byte always be more than 0)
Category:Languages
Category:Low-level
Category:2024
Category:Unimplemented
Category:Output only
Category:Unusable for programming
UpDown

UpDown is a programming language made on 30 December 2022 by User:IdfbAn. UpDown has 26 variables for every letter in the English alphabet (A-Z), and 3 commands: up, down, and print. The values of all the variables are 0 by default. ; is used like in regular programming languages such as C++.
== Commands ==
Command 	Description
up <variable> x 	Increments the value of the specified variable by x.
down <variable> x	Decrements the value of the specified variable by x.
print <variable> 	Outputs the specified variable's value as the corresponding ASCII character.
(e.g. if the value of O is 79, print O will output O)
If the value of a variable (e.g. X) is either lower than 0 or higher than 255, print X will output Error! Value of X too low or Error! Value of X too high depending on the value of X.
== Hello, World! ==
 up A 72; print A;
 up B 101; print B;
 up C 108; print C; print C;
 up E 111; print E;
 up F 44; print F;
 up G 32; print G;
 up H 87; print H;
 print E;
 up I 114; print I;
 print C;
 up J 100; print J;
 up K 33; print K;
== UD++ ==
UD++ is an extension to UpDown. It adds the ability to declare your own variables, and 1 new command, var, to do so.
=== The new command ===
Command 	Description
var <name of variable>	Declares a new variable. Value is automatically initialized to 0.
=== Example ===
This should print "fr"
 var first_letter;
 var second_letter;
 
 up first_letter 102;
 up second_letter 114;
 
 print first_letter;
 print second_letter;
If you are implementing UpDown, implementing UD++ is optional.
== External resources ==
* ASCII Table
==Interpreter==
* Common Lisp implementation of the UpDown programming language.
Category:Languages
Category:2022
Category:Implemented
Category:Unusable for programming
Category:Output only
Category:Total
UponThem

== UponThem ==
* A language based on the hit game Among Us
* Loosely based on https://github.com/toc8730/amonguscpp
=== internal variables ===
int loop = 0;
=== Instruction ===
Instruction 	Function
LOBBY 	the main function of a program
MEETING 	void (used for functions)
VOTE 	return
SUS 	()
SUSSY(color) 	removes 1 from an int
VENTED(color) 	adds 10 to an int
SUSSYBAKA 	;
TASK 	() {
WHO 	{
WHERE 	}
COMPLETED 	}
BECAUSE 	if
UNLESS 	else
ACCUSE 	prints whatever follows the instruction
IGNORE 	prints a new line
PLAYER(color, value)	assigns value to the variable named color
OPEN_DOOR 	(
CLOSE_DOOR 	)
OXYGEN 	while
STUPID 	<
BIG_BRAIN 	>
MELTDOWN 	increases the internal variable `loop` by 1
MELTDONW_TIMER 	returns `loop`s value
IMPOSTER 	!=
USERNAME 	std::string
SIMONSAYS 	std::cin >>
DOWNLOAD_TASK(path) 	takes a path and returns a string of the file's content
> The value of color is typically used for a name of a variable
=== Truth Machine ===
 LOBBY TASK
 PLAYER(cyan, 0) SUSSYBAKA
 OXYGEN OPEN_DOOR 1 CLOSE_DOOR WHO
 BECUASE OPEN_DOOR cyan IMPOSTER 1 CLOSE_DOOR
 SIMONSAYS cyan SUSSYBAKA
 UNLESS WHO ACCUSE cyan SUSSYBAKA IGNORE SUSSYBAKA WHERE
 WHERE
 VOTE 0 SUSSYBAKA
 COMPLETED
Category:Languages Category:Implemented Category:Thematic
Upsilon (Archived)

Upsilon is an esoteric programming language that replaces all values returned from a function with procedure out-parameters.
== Overview ==
Upsilon has constructs named outvars, which are parameters that pass values out of a subroutine, rather than into it.
assign x, 3. [x is the outvar]
print x. [3]
Here, a subroutine named assign utilizes an outvar, and assigns it the value 3. Then, the outvar is printed. You also see comments in the square brackets, and that periods end instructions.
The syntax for creating your own subroutines is straightforward:
square outvar a, b:
	multiply c, b, b. [c := b * b]
	assign a, c. [a := c]
back.
Here, you also see that back, as opposed to return, is used to return to the caller. All subroutines, even for primitive operations, use outvars to return values.
Here is another example:
factorial outvar result, a:
	equal isZero, a, 0.
	subtract x, a, 1.
	if isZero:
		assign result, 1.
	else:
		factorial result, x.
	end.
back.
if: (else:) end is a special form.
Category:Languages
Urban Müller

Urban Dominik Müller is the creator of the brainfuck programming language, and consequently quite a famous person in the Esolang community. He is apparently not involved with esoteric programming any more, though.
In 1992 he created the Aminet Archive, a huge archive of freeware, shareware and open source software (including the original brainfuck distribution), images, music and other multimedia for the Amiga, which was at one time the largest software archive on the internet. He is the author of XPK compression package for the Amiga, and the Amiga version of CSH (the Unix C Shell).
He now works for search.ch, a Swiss search engine.
== See also ==
* Urban Müller/Tamedia TX 2017 Transcript
==External resources==
* Urban Müller's talk about Brainfuck (video) at Tamedia TX 2017
* 
Category:People
Category:Brainfuck
UsableSeed

UsableSeed is a language based on Seed. Programs only contain two instructions - length and random seed, separated by a space. To execute a UsableSeed program, the seed is fed into a Mersenne Twister random number generator, and the randomness obtained is converted into a string of length bytes, which will be base64-decoded and executed by an 05AB1E interpreter.
==Computational class==
Since standard 05AB1E is Turing-complete, UsableSeed is Turing-complete too.
==Running programs==
Here is the Python 3.0 script that converts seed programs to 05AB1E:
 import random
 import base64
 program="780 983247832" ##Place program here
 program=program.split()
 length=int(program[0])
 
 random.seed(int(program[1]))
 chars="".join(map(chr,range(32,127)))+'\n'
 prog="".join([chars[int(random.random()*96)] for i in range(length)])
 
 print("Your program:\n----------------------------------------\n", base64.decodestring(prog), "\n----------------------------------------\n")
This script was tested in two different computers to make sure it produces the same results. Other implementations MUST do so.
Category:Zero-dimensional
Category:Languages
Category:Turing complete
Category:Implemented
Category:2019