nyuuzyou/wikis huggingface dataset:
Twoee

Twoee because Thue isn't bad enough. This is not 100% backwards compatible. We have "improved" it.
==Design Aims==
===Implemented===
This is a comment (any text without an operator)
Yes twoee has comments
Replace a with b
a::=b
Replace a with inputed text
a::=:::
Replace a with b and output c
a::=b~~~c
Replace a with inputed text print c
a::=:::~~~c
This will define the data string
;;=a
===Unimplemented===
Proper implementation of literal and non literal operators
i.e. not have such a hacky fix for making ~~~ run after :::
==Operator list==
===All possible operators=== 
====Definition Operators====
 This defines a command
 ::=
 This defines the data string
 ;;=
====Control Operator====
 This tells the interpreter to take an input from the user
 :::
 Prompted input
 ~::Prompt
 This outputs the text following it (text is treated as a literal)
 ~~~
==Example Code==
===This proves that our design aims have been met===
This is the exmaple Twoee File.
It should output:
[whatever you typed first]
You replaced d with e!
[what ever you typed second]
You replaced f with the string you typed!
[What ever you typed]
b[whatever you typed second]e[whatever you typed second][you final input]
a::=b
c::=:::
d::=e~~~You replaced d with e!
f::=:::~~~You replaced f with the string you typed!
g::=~::Add your input?
;;=acdfg
===Hello World!===
a::=Hello
b::= World
;;=ab
===Some notes on execution===
This does not chose a random possible substitution and run it, instead it will always run the first possible substitution. Therefore the order they are defined in will set their precedence.
There are a few structural changes to how files are laid out as well compared to Thue. For example the data string is no longer defined as whatever comes after a line with only ::= on it but as whatever follows the ;;= operator. All operators are 3 characters long.
==Road Map==
* Add file input and output
* Have a single variable that is equal to the data string
==External resources==
A Python interpreter is available on GitHub.
Category:Languages Category:String-rewriting paradigm Category:2018 Category:Turing complete Category:Implemented
Twoface

Twoface is an esoteric programming language created by user:Tastyl. It's programs are supposed to look like lists of faces.
ABANDONED Please delete!
== Instruction Set ==
Face	Name 	Description
:) 	push 	Pushes a number to the stack. The number pushed is based on how many ')'s the face has. (":))" would push a 2)
:( 	pop 	Pops the top number off of the stack.
:D 	add 	Pops the top two numbers off of the stack, and pushes the sum back on.
:o 	subtract 	Pops the top two numbers off of the stack, and pushes the difference back on. (top number - bottom number)
:O 	mult 	Pops the top two numbers off of the stack, and pushes the product back on.
:p 	divide 	Pops the top two numbers off of the stack, and pushes the quotient back on. (top number / bottom number)
:P 	modulo 	Pops the top two numbers off of the stack, divides them, and pushes the remainder back on. (top number / bottom number)
:> 	dup 	Duplicates the top number on the stack.
:< 	reverse 	Reverses the stack.
:^ 	equals 	Pops the top two numbers off of the stack, and if they are equal, skips the next n number of lines where n is the amount of '^'s in the face. (e.g. :^^^ would skip the next 3 lines)
=) 	not equal	Works like equals, but skips lines if they are not equal. (e.g. =))) would skip the next 3 lines)
>:) 	greater 	Works like equals, but skips lines if the top number is greater than the bottom. (e.g. >:))) would skip the next 3 lines)
>:( 	lesser 	Works like equals, but skips lines if the bottom number is greater than the top. (e.g. >:((( would skip the next 3 lines)
:-) 	printa 	Pops the top number off of the stack, and prints out its ASCII value.
:-( 	printn 	Pops the top number off of the stack, and prints it out.
xD 	reada 	Reads input from the user, and pushes its ASCII value to the stack.
XD 	readn 	Reads input from the user, and if it's numeric, pushes it to the stack. If not, it ignores it.
:] 	goto 	If there are enough lines in the program, goes to the line number added. (e.g. :]]] would go to line 3)
:[ 	empty 	Empties the stack.
-_- 	halt 	Halts the program.
Typefuck

Typefuck is developed by Steve Abel.
Typefuck is a Brainfuck-based language with C types as command.
== Commands ==
Command	Meaning (in full name)	Brainfuck equivalent	Description
I 	Integer 	> 	Move the pointer to the right
F 	Float 	< 	Move the pointer to the left
D 	Double 	+ 	Increment the memory cell at the pointer
L 	Long 	- 	Decrement the memory cell at the pointer
S 	Short 	. 	Output the character signified by the cell at the pointer
C 	Character 	, 	Input a character and store it in the cell at the pointer
B 	Boolean 	[ 	Jump past the matching V if the cell at the pointer is 0
V 	Void(No type) 	] 	Jump back to the matching B if the cell at the pointer is nonzero
== Examples ==
=== Hello, world ===
DDDDDDDDBIDDDDDDDDFLVIDDDDDDDDSIDDDDDDDDBIDDDDDDDDDDDDFLVIDDDDDSDDDDDDDSSDDDSIDDDDDDDDBIDDDDDFLVIDDDDSLLLLLLLLLLLLSFFFFDDDDDDDDDDDDDDDSIISDDDSLLLLLLSLLLLLLLLSIIDS
=== 99 bottles of beers ===
Too long.
=== Rickroll ===
TTTToooooooo lllloooonnnngggg....
=== A+B ===
T o o l o n g a n d i t o n l y s u p p o r t 1 - d i g i t A + B .
== See also ==
* Brainfuck
* Hanzifuck
* Mariofuck
* Numberfuck
* Brainchina
== Implementation ==
I really don't write at here ANYMORE.
== Categories ==
Category:Languages
Category:Turing tarpits
Category:Low-level
Category:Cell-based
Category:Implemented
Category:Brainfuck equivalents
Category:Brainfuck derivatives
Category:2024
Category:Turing complete
Typespam

Typespam is a language created by TheZipCreator. 
It's a cell-based language similar to Brainfuck but it has some important changes.
1. The tape storing the cells is called the "chain" not the tape.
2. The chain doesn't store integers, instead it stores instances (Explanation at here)
3. The loops work differently they aren't really "loops".
==Commands==
Command	Description
_ 	Initialize the instance under the pointer
^ 	Move up the chain
v 	Move down the chain
c 	Set the instance to a char
i 	Set the instance to an integer
{ 	Set the instance to the char/integer after this command
| 	Set a marker with the name of the next character in the file
} 	Jump to the pointer with the name of the next character in the file if the instance under the pointer is nonzero
- 	Display the value of the currently selected instance
# 	Get one key of input and put it into the current instance
==Instances==
An instance is a character or an integer.
==Examples==
===Hello World===
 _c {H-{e-{l--{o-{ -{W-{o-{r-{l-{d-
===Cat program===
The following implements an infinitely repeating cat program using markers:
 _ c |A #- }A
==Interpreter==
* Common Lisp implementation of the Typespam programming language.
==Compiler==
Not finished yet. Will be soon.
Category:Languages Category:Cell-based Category:2017 Category:Implemented Category:Unknown computational class
Typing

Typing refers to how a language treats the concept of data types. There are different ways to treat it. Some languages call their type systems "strongly typed" but disagree as to what that means. Similarly, a variety of different systems are derided as "weakly typed". Therefore it's better to use more descriptive terms.
Variable typing means that the language associates a type to each variable, and the values placed in it must first be converted to that type. Examples include BASIC, Fortran, C, and Java.
Value typing means that the language associates the types to values, and a variable has no inherent type. Examples include PHP, Javascript, Python, and SQLite.
Operation typing means that values have no type, and the operations used determine what type the value is treated as. Examples include Forth, scrip7.
Single typing is the case where only one type of value is supported, so the distinctions above are obviated. Examples include Brainfuck, Befunge, and many other esolangs.
There are other ways too.
UBFIM interpreter

This is an interpreter for Ultimate BF instruction minimalization!, written in Basic by User:Wh1teWolf:
 DIM tape(1200)
 ptr=0
 b=0
 f=0
 lol=0
 REPEAT
 INPUT "" a$
 b=0
 ptr=3
 REPEAT
 b=b+1
 
 
 
 IF b>=999 THEN
 IF tape(ptr)=1 then b=0
 ENDIF
 
 
 
 
 IF MID$(a$,b,1)="<" THEN
 IF ptr>0 THEN ptr=ptr-1
 ENDIF
 
 
 
 
 
 IF MID$(a$,b,1)="(" THEN
 ptr=ptr+1
 IF tape(ptr)=1 THEN tape(ptr)=0 ELSE tape(ptr)=1
 
 IF tape(ptr)=0 THEN
 b=b+1
 ENDIF
 ENDIF
 
 
 
 
 
 
 IF tape(2)=1 THEN
 tape(2)=0
 lol=0
 IF tape(4)=1 THEN
 lol=1
 ENDIF
 IF tape(5)=1 THEN
 lol=lol+2
 ENDIF
 IF tape(6)=1 THEN
 lol=lol+4
 ENDIF
 IF tape(7)=1 THEN
 lol=lol+8
 ENDIF
 IF tape(8)=1 THEN
 lol=lol+16
 ENDIF
 IF tape(9)=1 THEN
 lol=lol+32
 ENDIF
 IF tape(10)=1 THEN
 lol=lol+64
 ENDIF
 IF tape(11)=1 THEN
 lol=lol+128
 ENDIF
 IF lol>0 THEN
 PRINT CHR$(lol)
 ELSE
 
 
 FOR f=4 TO 11
 tape(f)=0
 NEXT
 
 
 f=0
 
 
 REPEAT
 f=INKEY(1)
 UNTIL f<>-1
 
 
 PRINT CHR$(f)
 
 IF f>=128 THEN
 tape(11)=1
 f=f-128
 ENDIF
 IF f>=64 THEN
 tape(10)=1
 f=f-64
 ENDIF
 IF f>=32 THEN
 tape(9)=1
 f=f-32
 ENDIF
 IF f>=16 THEN
 tape(8)=1
 f=f-16
 ENDIF
 IF f>=8 THEN
 tape(7)=1
 f=f-8
 ENDIF
 IF f>=4 THEN
 tape(6)=1
 f=f-4
 ENDIF
 IF f>=2 THEN
 tape(5)=1
 f=f-2
 ENDIF
 IF f>=1 THEN
 tape(4)=1
 f=f-1
 ENDIF
 ENDIF
 
 ENDIF
 
 
 
 IF MID$(a$,b,1)="!" THEN
 IF tape(ptr)=1 THEN b=0 ELSE b=1000
 ENDIF
 
 
 UNTIL b>=1000
 a$=""
 b=0
 UNTIL FALSE
==See Also==
*Ultimate bf instruction minimalization!
Category:Implementations
UBLANG

UBLANG(Unusable language) is esolang by User:ChuckEsoteric08.
==Commands==
+	Increment accumulator 1
-	Decrement accumulator 1 if it isn't 0. If it is 0, back to start of program
0	set accumulator 1 to 0
*	increment accumulator 2
/	like -, but for accumulator 2
1	set accumulator 2 to 0
.	Print accumulator 1
;	Print accumulator 2
==Examples==
===Infinity loop===
 .-
===Counting from 1 to infinity===
 +./
===Counting from 0===
 .+/
===Print 1 infinitly===
 +.-/
===Print ASCII values for "HI"===
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+.
===Print ASCII values of "Hello, world!"===
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 ++.+++++++++++++++++++++++++++++.+++++++..+++.--
 ---------------------------------------------------------
 --------.------------.++++++++++++++
 ++++++++++++++++++++++++++++++
 +++++++++++++++++++++++++++++++++++++++++++.--------.+++.------.--------.--------
 ------------------------
 -----------------------------------.
==See also==
*BackStart - language that compiles to UBLANG
*Tapelang - other language that compiles to UBLANG
*UBLANG++ and MUUBLANG - UBLANG extensions
*+*- - similiar language
==External resources==
Scratch interpreter
Category:Languages Category:Unknown computational class Category:Implemented Category:Output only Category:2022
UBLANG/MUUBLANG

MUUBLANG(More useful unusable language) is an extension of UBLANG that allow initial values and speical "Goto" value
==Changes==
You need to input values of both accumulators and "Goto" value
===Goto value===
"Goto" value is a value that is used for decrementing operations. Instead of going to start of the program if accumulator is zero it goes if accumulator is equal to "Goto" value
==External resources==
* Scratch interpreter
Category:Languages Category:Implemented Category:2022
UBLANG/UBLANG++

:
UBLANG++ is an extension of UBLANG created in beginning of may 2022 on purpose of making Turing-complete version of UBLANG(if it is not Turing-complete)
==What is changed==
added accumulator 3 for going to arbitary place if zero. > and < will increment and decrement it. Every goto command are goto command specified by accumulator3(0-indexed) and that symbol need to be any symbol that are not valid command. It is possible to use command 2 
which sets accumulator 3 to zero.
- and / are now will goto only if they followed by !. Commands ( and ) will skip next command if accumulator 1 is zero and if not zero. [ and ] are same, but for accumulator 2.
==External resources==
* Scratch interpreter
Category:Languages Category:2022 Category:Implemented
UClang*

UClang* is a little endian esoteric language created by User:RSG4908 that uses Unicode letters to represent instructions.
__TOC__
== Instructions ==
Notes: 0xA0-0xB3 are reserved for instructions. To get values beyond A0, you must use load instructions alongside with increment instructions or addition instructions.
List of instructions
Instruction	Description 	Notes
0xA0 	Set the accumulator to the value after the instruction 	
0xA1 	Output corresponding character in the accumulator 	
0xA2 	Take input from the command line. 	
0xA3 	Compare accumulator with the value after the instruction	A3 25 should compare the accumulator to 0x25
0xA4 	Bitwise AND with the accumulator 	
0xA5 	Bitwise OR with the accumulator 	
0xA6 	Subtract with value after the instruction 	
0xA7 	Addition with value after the instruction 	
0xA8 	Increment the accumulator 	
0xA9 	Decrement the accumulator 	
0xAA 	Reset the accumulator 	Sets the accumulator to 0x00.
0xAB 	Branch to "label" if not equal 	
0xAC 	Branch to "label" if equal 	
0xAD 	Logical shift right 	
0xAE 	Logical shift left 	
0xAF 	No operation 	
0xB0 	Arithmetic shift left 	
0xB1 	Arithmetic shift right 	
0xB2 	Places a "label" 	All labels must have a number assigned to it.
0xB3 	Jump to "label" 	
== Example programs ==
=== Hello world (34 bytes) ===
A0 48 A1 A0 65 A1 A0 6C A1 A0 6C A1 A0 6F A1 A0 20 A1 A0 77 A1 A0 6F A1
A0 72 A1 A0 6C A1 A0 64 A1 AA
== Implementations ==
* C++ implementation
Category:Languages
Category:2020
Category:Implemented
Category:Low-level
Category:Usability unknown
Category:Unknown computational class
Category:Binary
UDL

UDL, or Ultra-dynamically Dimensional Language, is a multi-paradigm language created in 2022 by User:Shadow Kestrel. Its data structure principles are largely inspired by Python, although its 'dimensionally rebellious' program structure is inspired by Dimensifuck and Befunge. Unlike a true n-dimensional array, UDL stores its data in 'spaces', which are effectively equivalent to dictionaries.
== Structure ==
UDL stores all data in spaces. Spaces are formally defined as objects containing:
* a map, of which all the names are of the same immutable type
* a pointer, of the same type (pointer)
* the previous value of the pointer (prev)
* an anonymous function to be applied to the pointer (step)
The values of the map may be any object. An "object" is defined as any instance of a class, including built-in classes such as Integer and, quite importantly, Space. Spaces act as asynchronous generator functions by deferring execution.
== Behaviour ==
At any given time, a single space is 'active'. The interpreter reads the value of the map at pointer, then executes that depending on the type. If the value is a space, the active status is transferred to the space. If the value is a string containing a single printable ASCII character, an action is taken per the table below. Otherwise, no operation is taken. Then, step is applied to pointer
character	action
+ 	replaces self with map[prev] + map[step(pointer)] as defined by prev's addition behaviour
- 	replaces self with map[prev] - map[step(pointer)] as defined by prev's subtraction behaviour
d 	replaces self with map[prev]
S 	replaces self with a subspace of the active space, as determined by map[step(pointer)][see below]
i 	replaces self with the entirety of stdin
o 	pushes map[prev] to stdout
r 	replaces self with map[pointer] of the space at map[prev]. If map[prev] is not a space, acts as d.
w 	replaces map[prev] of the space at map[prev] with map[step(pointer)]. If map[prev] is not a space, noop.
w 	replaces pointer of the space at map[prev] with map[step(pointer)]. If map[prev] is not a space, noop.
s 	replaces step of the active space with map[prev].
@ 	apply step to pointer, then transfer the active status to the parent space. If executed in the root space, end execution.
== Writing programs in UDL ==
UDL code
Category:Languages Category:2022
UGGA

UGGA
 
The programming language is made of 5 arrays and each array has 30k slots.
That means there are 150K slots in total.
Online Interpreter
Syntax:
 ! (Go up onto the next array (s1 -> s2))
 % (Go down (s2 -> s1))
 [ (Right)
 ] (Left)
 @ (Output slots value onto the console)
 = (Get user input and set the slot to answer)
 : (Increment current slot by 1)
 - (Subtract current slot by 1)
 & (Output the stack's characters to the console)
----------------------------------------
SAMPLE:
 [h@[e@[l@[l@[o@[ @[w@[o@[r@[l@[d@
(this prints hello world to the screen)
-----------------------------------------
THIS LANGUAGE WAS PROGRAMMED IN PYTHON
Category:Languages Category:Implemented
ULSAL

ULSAL (ultlang's stack apiolanguage) is a heavily wip stack-based programming language by User:Ultlang.
__TOC__
== types ==
each item of the stack has one of these types:
* mrk / marker
* str / string
* num / number
* fnc / function
== commands ==
command 	arguments	function
` 	0 	pushes a marker to the stack
0123456789	0 	pushes the respective integer to the stack as a num
' or ´ 	varies 	concatenates items on the stack until a marker is hit. if all components are nums, the result is a num, otherwise it is a str. this, along with both alphabetic characters and spaces pushing themselves, makes `string example' the way to express strings.
+-×÷ 	2 	executes the operation on the two top numbers on the stack (95- returns 4). if any of the arguments is not a number, bees may occur, along with apioforms.
² 	1 	pushes the top item twice
ⁿ 	2 	pushes the top item [floor of second from top item value] times. if that value is not a number, bees could arise, followed by beeoids.
⌁ 	1 	"splits" the top item on the stack. this has varying behavior depending on the type and characteristics of the item:
* str: pushes each character of the string as a separate string
* integer num: pushes the prime factorisation of the number, smallest to largest, with an additional -1 in case it is negative 
* non-integer num: pushes the floor and then the fractional part of the number
· 	0 	does nothing (as opposed to the space, which does ¬nothing)
[…] 	bees 	pushes anything between the brackets as a fnc. works as matching brackets, not the first ] after the [: a[b[c]] should make the stack a: str; b[c]: fnc.
note that as opposed to `…', what is between brackets doesn't get executed, thus `88+a' → 16a: str, whereas [88+a] → 88+a: fnc.
ε 	1 	executes the code in the top stack item. if it's not a function item, bees will happen, and apioids might too.
ᵋ 	2 	executes the code in the top stack item [floor of second from top item value] times. if it's not a number or the top item is not a function, bees can be expected to take place, and apēs melliferæ could as well.
ℓ 	0 	pushes the stack length as a number
σ 	2 	swaps the last two items of the stack
any other 	0 	pushes the character to the stack as a str
== implementations ==
there are approximately "0" implementations of ulsal. sina ale li utterly trolled
Category:Stack-based
Category:Unimplemented
Category:Languages
UM8

UM8 a virtual machine created by User:Palaiologos for the Esolang Reverse Engineering Contest. The contest has finished in July 2020.
It contains 13 instructions ranging from 0x0 to 0xd. The original interpreter will take ASCII hexadecimal input from stdin (in uppercase). If it encounters something else than [0-9A-D] it will stop taking input and proceed to execution.
The machine contains 3 registers: A, B and C. The instruction sets permits self-modification of the program buffer, implying the program buffer can also be used as a tape for data storage or just modifying code in general.
== Instruction set (credit: Gibson) ==
The instruction reference is written as some pseudo-code.
* a, b, c are the registers
* pc is the program counter
* [expr] points at (expr) in the program buffer
* ; are comments/notes from me
0 -> exit()
1 -> if (b) a = c
2 -> swap a, c
3 -> a = ~(b&c) ; NAND gate
4 -> putchar(b)
5 -> b = getchar()
6 -> swap a, b
7 -> a = [pc+c+1]
8 -> [pc+a+1] = b
9 -> a = [++pc]
A -> pc = b, [pc] = c
B -> a = !a ; logic NOT
C -> a >>= 1
D -> a <<= 1
NOTE Due to the way the interpreter is implemented, A jumps to b+1 and not b. However, [b] will still be set to c.
== Example Programs ==
=== Cat ===
154906A
Here is a commented disassembly to understand it better:
1 | if (b) a = c ; "dummy" instruction
5 | b = getchar() ; get character from stdin
4 | putchar(b) ; prints it
90 | a = 0
6 | a, b = b, a ; sets b to 0
A | pc = b, [pc] = c ; jumps to 1, modifying the "dummy" instruction.
=== Hello World ===
9169BDD6496D2163D2163D2163D216364962163DD2163DD64962163D
D2163DD64962163DDDD216364952163D2163DD6498DD6495D2163DDD
216364962163DDDD21636497DD2163D2163D64962163DD2163DD6496
D2163D2163DD6498D2163D21636495D64
Explainations here.
=== Cat halting on EOF ===
942986A649629D516A
=== Truth machine ===
56649C891232616369129AD1690A
== Implementations ==
The original implementations from User:Palaiologos are available here.
User:Matthilde's reverse-engineering writeup and C99 implementation is available in this git repo.
Category:Implemented
Category:Self-modifying
UNITE

UNITE is a pretty small esolang with a little to no purpose.
==Overview==
UNITE only consists of two commands, which are explained in the table below.
 Caption text
Header text 	Header text
unite x with y	Connects x and y with a space as a separator and stores them in memory.
print 	Prints whatever is in memory.
The "unite" command overwrites the memory with its output.
===Hello, World!===
Here's a simple "Hello, World!" program written in UNITE:
 unite Hello, with World!
 print
==Interpreters==
Here's an example of an interpreter in Python 3. The interpreter takes the code from a file.
 try:
 with open("code.txt") as f:
 code = f.read()
 except:
 print("Error in loading \"code.txt\"; file might not exist. Press any key to exit...")
 input()
 code = code.split("\n")
 uniteout = ""
 for line in code:
 if line.lower().startswith("unite"):
 uniteout = " ".join(line.replace("unite ", "").replace(" with ", "||||====").split("||||===="))
 elif line.lower() == "print":
 print(uniteout)
 input("\nCode has finished running. Above is the output. Press any key to exit...")
Category:Languages Category:Joke languages Category:2021 Category:Implemented Category:Unusable for programming
UPE

UPE, or Unary Python Esolang, is a language/extension of python that just makes your life impossible, to use UPE, write your program in Python3, then replace every character in the program with a three digit number containing that character's ASCII value, then stick all those character numbers back to back and add a 1 at the beginning to create a real number.
Then, convert that number to Unary. For example, a program that does nothing but "pass" would be 1,112,097,115,115 zeroes.
Hello World program:
1,112,114,105,110,116,040,034,072,101,108,108,111,044,032,119,111,114,108,100,033,034,041 zeroes
CAT Program:
1,112,114,105,110,116,040,105,110,112,117,116,040,034,034,041,041 zeroes
Infinite loop while doing nothing program:
 1,119,104,105,108,101,032,084,114,117,101,058,010,032,032,032,032,112,097,115,115 zeroes
Quine program:
1,035,081,117,105,110,101,032,112,114,111,103,114,097,109,010,105,109,112,111,114,116,032,111,115,044,032,115,121,115,010,119,105,116,104,032,111,112,101,110,040,111,115,046,112,097,116,104,046,097,098,115,112,097,116,104,040,115,121,115,046,097,114,103,118,091,048,093,041,044,032,034,114,034,041,032,097,115,032,102,058,010,032,032,032,032,112,114,105,110,116,040,102,046,114,101,097,100,040,041,041 zeroes
Interpreter Shell implementation here.
==See also==
* Unary
Category:Languages Category:Implemented Category:Turing complete Category:High-level