nyuuzyou/wikis huggingface dataset:
URSL

URSL is an esoteric programming language created by user:David.werecat which has a stack, queue, tape, memory array and ten registers.
== Instructions ==
During these examples, numbers 1-9 represent a register argument. There are 10 registers, numbered 0 through 9. The number of the register is used as the argument. Also during the examples, a series of underscores (eg. ___) represents that there is a code block inside the instruction.
Instruction	Description
a12 	1 = 1 + 2
b1 	If 1 >= one hundred and twenty eight, set 1 to two hundred and fifty five; otherwise set 1 to zero
c1 	1--
d12 	1 = 1 / 2
e12 	1 = 2
fo1___? 	If 1 is not zero, execute the enclosed code block
fz1___? 	If 1 is zero, execute the enclosed code block
g12 	Swaps 1 and 2
h12 	1 = 1 modulo 2
i1 	1++
j1 	Jumps 1 instructions ahead
k1 	Dequeue a value from the queue and store it in 1
lo1___/ 	Loops the enclosed code block while 1 is not zero
lz1___/ 	Loops the enclosed code block while 1 is zero
m12 	1 = 1 * 2
n12 	1 = 1 and 2
o12 	1 = 1 or 2
p1 	Pop a value from the stack and store it in 1
q1 	Enqueue 1 in the queue
r1 	Read a character into 1
t 	Terminates the program
u 	Push the value of 1 into the stack
v1__- 	Set 1 to the numeric value enclosed in the code block
w1 	Write character 1 to the console
x12 	1 = 1 xor 2
y1 	Cycle the registers 1 times
z1 	Set 1 to zero
|< 	Move the tape left
|> 	Move the tape right
|^1 	Write 1 to the tape
|v1 	Read a value from the tape and store in 1
&12 	Read a value from memory address 2 and store in 1
*12 	Write a value 1 to memory address 2
# 	Beep
~ 	Clear the console
% 	Throw an error
$ 	Sleep for one second
\___\ 	An infinite loop
@ 	Break from an infinite loop
!1 	Write integer 1 to the console
All spaces, tabs, newlines and ;'s are treated as whitespace. Comments are not possible.
== Examples ==
=== CAT Program ===
 \r0w0\
=== Hello, world! ===
 v072-w0v0101-w0v0108-w0w0v0111-w0v044-w0v032-w0v0119-w0v0111-w0v0114-w0v0108-w0v0100-w0v033-w0
== External resources ==
* Visual Basic .NET interpreter and sample programs
Category:Languages
Category:2012
Category:Turing complete
Category:Implemented
Category:Cell-based
Category:Stack-based
Category:Queue-based
USERA

USERA, or User:A is simple and great language maded by User:OsmineYT and dedicated to User:A.
== Commands ==
Command 	Short description
a <ASCII codes of letters>	displays text
aa 	clears the screen
a+a <number1> <number2> 	adds two numbers
a-a <number1> <number2> 	subtracts two numbers
== Examples ==
Print Hello, World!:
 a 72 101 108 108 111 44 32 87 111 114 108 100 33
The following prints “Hello, World!” by adminiculum of the addition (a+a) and subtraction (a-a) instructions:
 a a+a 70 2 101 108 108 111 a+a -100 +144 32 87 111 114 108 a-a 150 50 33
==Interpreter==
* Common Lisp implementation of the User:A programming language. Please note that, intended to be executed inside of a simple console, the display clearing command aa has been realized in terms of an adjustable number of newlines output to the screen in order to simulate the content's purging via shifting outside of the visible area.
Category:Languages Category:2019 Category:Output only Category:Implemented
U (PrySigneToFry)

:This page is related to one of User:Ractangle's unfinished esolangs: U.
I used ChatGPT to make this except some command is added by myself and all program is written by myself.
== Command ==
# U: Push 0 onto the stack.
# D: Pop the top value from the stack.
# L: Duplicate the top value of the stack.
# S: Swap the top two values on the stack.
# C: Clear the stack.
# i: Increment the top value on the stack by 1.
# d: Decrement the top value on the stack by 1.
# +: Pop A and B from stack and push A+B.
# -: Pop A and B from stack and push A-B.
# s: Pop A and B from stack and push B-A.
# m: Pop A and B from stack and push AB.
# v: Pop A and B from stack and push quotient of A/B.
# Q: Pop A and B from stack and push quotient of B/A.
# M: Pop A and B from stack and push remainder of A/B.
# W: Pop A and B from stack and push remainder of B/A.
# O: Pop the top value from the stack and then print it as number.
# o: Pop the top value from the stack and then print it as character.
# I: Get user input and push it onto the stack.
# l: Get user input and push its Unicode onto the stack.
# !: Pop the top value from the stack. Push 1 if it's 0, push 0 otherwise.
# >: Pop A and B from the stack. Push 1 if A>B, push 0 otherwise.
# <: Pop A and B from the stack. Push 1 if B>A, push 0 otherwise.
# =: Pop A and B from the stack. Push 1 if A=B, push 0 otherwise.
# 0123456789: Push that number onto the stack.
# "": Everything in quote is a default character. it will push their Unicode onto the stack from left to right.
# R: Reverse the stack.
Programs are a sequence of the above commands. Each command is executed in order, manipulating the stack accordingly.
== Example Programs ==
===Simple ones===
 U
Should push a 0
 48+U*
Should push 4 and 8, add them together and multiply that by 0
 "sEf"Rooo
should output "sEf"
===Basic ones===
==== Hello, world! ====
"Hello, world!"
R
oooooooooooo
==== A+B Problem ====
II+O
== Author ==
The original creation of this programming language is actually User:Ractangle, but he just created the profile and threw it aside (NOTE FROM User:Ractangle:The reason why i threw User:Ractangle/U aside is because i had no ideas on it's concept). So I see that page has only profile.
== Category ==
Category:Languages Category:2024Category:Generated by AI
U (Ractangle)

U is an esoteric programming language created by User:Ractangle based on mostly bf
==Syntax==
===Commands===
 CMD ACTION
 > Move the cell pointer right
 < Move the cell pointer left
 : Duplicate the cureent cell's value to the cell next to it
 + Increment the current cell
 - Decrement the current cell
 . Output the current cell's value as an ASCII charecter
 , Output the current cell's value as an Interger
 * Multiplyies the two cells together
 / Divides the two cells togeteher
 s Sum of the two cells
 d Difrence of the two cells
 ? Prints the cells and the current position of the pointer
==Implementation==
"this was made a really while ago. managed to find it using the \"Everything\" tool"
#CMD ACTION
#> Move the cell pointer right
#< Move the cell pointer left
#: Duplicate the cureent cell's value to the cell next to it
#+ Increment the current cell
#- Decrement the current cell
#. Output the current cell's value as an ASCII charecter
#, Output the current cell's value as an Interger
#; Creates a newline in the code
#* Multiplyies the two cells together
#/ Divides the two cells togeteher
#s Sum of the two cells
#d Difrence of the two cells
#? Prints the cells
c,a,ce,p,t=[],0,[0]*5,0,0;print("py-U")
for i in input("code:"):c.append(i)
print(c)
while len(c)>0:
 if c[0]==">":p+=1;c.pop(0)
 elif c[0]=="<":p-=1;c.pop(0)
 elif c[0]==":":t=ce[p];p+=1;ce[p]=t;p-=1;c.pop(0)
 elif c[0]=="+":ce[p]+=1;c.pop(0)
 elif c[0]=="-":ce[p]-=1;c.pop(0)
 elif c[0]==".":print(end=chr(ce[p]%256));c.pop(0)
 elif c[0]==",":print(end=ce[p]);c.pop(0)
 elif c[0]=="*":p+=1;t=ce[p];p-=1;ce[p]=t*ce[p];p+=1;ce[p]=0;p-=1;c.pop(0)
 elif c[0]=="/":p+=1;t=ce[p];p-=1;ce[p]=ce[p]//t;p+=1;ce[p]=0;p-=1;c.pop(0)
 elif c[0]=="s":p+=1;t=ce[p];p-=1;ce[p]=t+ce[p];p+=1;ce[p]=0;p-=1;c.pop(0)
 elif c[0]=="d":p+=1;t=ce[p];p-=1;ce[p]=t-ce[p];p+=1;ce[p]=0;p-=1;c.pop(0)
 elif c[0]=="?":print(ce);c.pop(0);print(f"Currently pointing at {p}")
Category:Languages Category:Cell-based Category:Brainfuck derivatives Category:Output only
Uack

Uack is an esolang made by User:PythonshellDebugwindow.
==Memory model==
An arbitrary-length stack.
==Datatypes==
Datatypes are function (which always take an integer as their argument and return an integer) and arbitrary-size unsigned integer.
==Syntax==
The program is made up of a series of function calls. Where F is a function and X is an integer, then the Python code F(X) would be written like:
 XF
But as a special case, the Python code F(G(X)) (where G is also a function) would have to be written like:
 FXG
==Integers==
The only integer available at the start of the program is Z, representing 0; all other integers have to be constructed by the programmer.
==Functions==
Function	Effect
N 	Nop; return 0
P 	Return its argument plus one
H 	Push its argument to the stack; return its argument
O 	Pop stack, return the popped value
K 	Peek stack, return the peeked value
T 	Print its argument with a newline; return its argument
B 	Break from the outermost function if its argument is zero; return 0 if it broke from the function or 1 otherwise (can change outermost return)
Popping or peeking when the stack is empty returns -1; this is the only way to get a negative integer.
==Examples==
Push 3 to the stack:
 HPZPP
Push 4:
 PPZPPH
Category:2020 Category:Languages Category:Unimplemented Category:Total Category:Stack-based
Udage

Udage is an esoteric programming language primarily designed by User:Gs30ng, originally presenting what the author calls the "pattern programming paradigm."
==Abstract==
The core concept of the language is that no specific word or character is assigned to represent an instruction, but rather a pattern of characters is: if there is a Udage program with, say, the character A and you replace all A's with B's, the source code will still do exactly same thing (unless, of course, B has already been used in the original code, which would result in a collision which may change the meaning of the code drastically). All kinds of characters (in implementation, probably just all Unicode characters) can be used to write the source code: even MIDI audio or digital images.
==Language overview==
Note: this language is still being specified. This section describes version 0.22 specification.
In the language there is a memory space called udage, consisting of all the symbols available and a tape.
The tape is a linear memory space with unbounded cells, each containing a bit value, 0 or 1. Udages are a sort of pointer which moves on the tape and reads/writes bit values, so each udage has a pointer value that represents which cell it is on currently. Initially all bit values and pointer values are 0.
In the beginning all udages point to cell 0, which is a special value meaning it points to itself. If there are 256 symbols, the udages initially point to 256 different cells, although they all have a pointer value of 0.
The term "udage" (pronounced yer-da-gee) is from Korean word "여닫이" (Yeodaji), which refers to a door with a hinge. This is inspired by the peculiarity of the variable: it can represent 0 or 1, analogous to a door being open or closed, and it can point to a cell on the tape (every door leads to somewhere else).
=== Instructions ===
Syntax 	WHAT IT DOES
A 	changes bit value.
AABC 	changes pointer value.
AAAB...CCC	executes repeatedly while condition is met.
AAAA...A 	inputs/outputs.
The whole specification translated in English is available on http://gs30ng.exca.net/udage/specification 
==See also==
There are also some languages that have been inspired by Udage:
* Trigger
* Glypho
==External resources==
* 
* 
* PyUdage: implementation of Udage in Python by User:Tokigun
Category:Languages
Category:Cell-based
Category:Turing tarpits
Category:Implemented
Category:CJK
Category:Pattern-based
Category:2005
Udymts

Python gets kinda boring, simple English words and not a lot of fun. Udymts is a simple enhancement to python. Shift every alphabetical character of your code by 5 (think ceaser cipher) and you turned boring python into udymts!
== Python Vs Udymts ==
Boring Python:
 print("hello world")
Amazing Udymts:
 uwnsy("mjqqt btwqi")
== Syntax ==
The syntax is basically python code files encrypted with a ceaser cipher. The idea being to encrypt nothing bu alphabetical characters, ensuring that upon decoding its valid python code that is executed via the python interpreter.
== Output ==
The CLI's eval invokes the python code by decoding and then calling python interpreter via rust bindings. IO should occur normally.
== CLI ==
Unlike python's basic CLI, udymts compiler is rust. #RustEvangalism 
The cli can do the following:
* encode: turn bland python into udymts
* decode: compile udymts into python
* eval: directly eval your udymts
=== Evaling text ===
 udymts eval --text [code]
=== Evalling File ===
 udymts eval --file [abolute/relative path]
== Installation ==
TODO
== Compiler ==
Repo has installation instructions
Compiler + Cli
Category:Languages
Category:Turing complete
Category:Implemented
Category:Joke languages
Category:2021
Category:High-level
Uf

" " string
 % include
 ' ' char
 num number
 ID ID
 \ \ comment
 ` ` asm
 id id
:.
 ( ) while
 : ; function
 [ ] loop
 { ~ } if
:.
 ! store (word)
 # dup
 $ swap
 & and
 * mul
 + add
 , load (byte)
 - sub
 . store (byte)
 / div
 < lt
 = eq
 > gt
 ? pick
 @ load (word)
 ^ xor
 _ drop
 | or
under construction ...
UglyBF

UglyBF is an esoteric language based on brainfuck with a 6 instructions set, exchanging the octuple operations of its inspiration by an inversion switch, while contributing to augmented compactness via a duplication operator.
==Commands==
\ inverts the effect of the following command, where as the * duplicates the coming operation's effect.
The instructions are the following:
Command	Effect if not inverted 	Effect if inverted
+ 	Increment the memory cell at the pointer. 	Decrement the memory cell at the pointer.
> 	Move the pointer to the right. 	Move the pointer to the left.
. 	Output the character associated with the current cell. 	Input a character and store its code in the same.
[ 	If the cell at the pointer equals zero, jump forward past the matching \[. 	If the cell at the pointer does not equal zero, jump back past the matching [.
\ 	Invert the effect of the following command. Doubling operations (*) are ignored and passed through.	Invert the effect of the following command. Doubling operations (*) are ignored and passed through.
* 	Double the effect of the following command. Can be chained for accumulation. 	 
+, >, [ and . have the same effect as in Brainfuck.
By harnessing the potential of the \ instruction, the four brainfuck commands not explicitly assigned to a separate token in UglyBF may be activated:
UglyBF	brainfuck equivalent
\+ 	
\> 	<
\. 	,
\[ 	]
The * command doubles the effect of the following command, it's the only command that cannot be inverted.
If you want to duplicate the effect of an inverted command, you have to write \ before the first *. The following examples should demonstate this concept:
 *+ = ++
 **+ = ++++
 ****+ = ++++++++++++++++
 \**+ = ---- 
==Examples==
===Juxtaposing brainfuck and UglyBF===
The brainfuck code
 ,++[->++<]>[<+>-]<.
becomes the UglyBF program
 \.*+[\+>*+\>\[>[\>+>\+\[\>.
===Printing “BF”===
The UglyBF program
 ******+*+.>******+**+++.
writes the text “BF”.
===Hello, world!===
The following program prints “HELLO WORLD”:
 ******+***+.\*+\+.**+*++..*++.>*****+.\>***+.\***+.*++.\**+\*+.\***+.
===Cat program===
An infinitely repeating cat program is implemented in the following:
 \..[\..\[
==Interpreter==
* Common Lisp implementation of the UglyBF programming language.
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:2011
Category:Implemented
Uhaa So Bouncy

Uhaa So Bouncy is an esolang created by User:Yayimhere based on an discussion on IRC. in Uhaa So Bouncy you have two "machines". one is called "left", and the other one "right". they are both "trampolines". if you dont know what that is see semantics
== syntax ==
a program is made up like this:
 A VoidLang without input program for left |one for right
 ---------------------------------------------+--------------
 The next one for left |next for right
 
the last line must be:
 ---‹^›---
where ‹^› is centered with the pipes(|). all the code on the left side is enqueued to lefts queue with the first one being the first enqueued, and the same with the right side for rights queue.
== semantics ==
as you see we cant have real commands. but it works like a machine kinda. first dequeue the first element of left's queue, and right's queue, and see if the VoidLang programs halts(or gives an error), then based on what left and right says, we do some actions:
 left: right: action:
 yes yes append left's program to right's and enqueue the result to both left and right's queue
 no yes enqueue left's program to right's queue
 yes no enqueue right's program to left's queue
 no no discard the program's
Category:Languages Category:Queue-based Category:2024
Uhidklol

uhidklol: a no whitespace asm-like language.
== language documentation ==
=== instructions ===
* i [var] = input data in var
* o [reg] = output data in reg
* c [reg] [value] = set reg to value
* j [line] = jump to line
* a [value] [var] = add value to already existing value in var
* s = same but substract (same syntax)
* m = same but multiply (same syntax)
* d = same but divide (same syntax)
* q = quit program
=== registers ===
* $var = variable store
* $ath = arithmetic operations
* $ds1-4 = data store 1-4, these are basically buffers
=== other info ===
* the "value" arg in any instruction can also be a register (and therefore also a variable)
* variables are automatically stored in register $var, up to 16 different variables of 4 bytes each (that means 4 characters max, "varname" is a placeholder, its too long to be a valid one)
* the output of the instructions a s m d is automatically stored in $ath
* every register is the same size, that means, 64 bytes
* whitespace = line end
* there can only be 1 instruction per line, and every line that isnt commented out must be an instruction
* arguments must be separated from each other by a comma, but never the first (or only) arg from the instruction.
* each instruction MUST be separated with whitespace. it can be any type of whitespace as long as its in the ascii table
* to encode whitespace in strings, it goes like if it were an url: %20 = space, %0A = newline, %09 = tab
* when referring to any variable, it must be preceded by a dot. they dont need to be declared (being similar to how basic treats them, where any string ending with "$" becomes a variable). if theres a %20 between the dot and the following part of the string, this rule wont apply
* each new (not comment) line MUST begin with a line number. line numbers must NOT skip numbers, be in base 16, the letter part MUST be uppercase and be preceded by #
* instruction/register names MUST be lowercase, % encoding MUST be uppercase if it includes a letter
* every argument is case sensitive
* uhidklol CANT handle any code pages nor unicode, its just plain ascii
* preceding any string with @ turns it into a comment until next instance of @ (this is the only instruction/symbol that admits not % encoded whitespace, including newlines)
* preceding with ! any of the special characters # $ . ! @ , % escapes them. wont apply to any whitespace character
* the default value of any variable is 0 (duh)
== example programs ==
=== hello world ===
#1c$ds1,hello%20world #2o$ds1
=== infinite loop ===
#1a0,.varname #2j#1
=== cat ===
#1i.varname #2o$var
Ulilang

==commands==
 ulilang |code
 ---------------
 0,l |goto l
 1,l |l:
 2,x,y,l |if x==y{goto l}
 3,x,y,l |if x>y{goto l}
 4,x,n |x=n
 5,x,y |x=y
where
l is a goto label
x and y are variables
n is a literal
===io===
there is none
==examples==
===truth-machine===
 4,0,0
 4,input,0(or 1)
 2,0,input,skipper
 1,loop
 0,loop
 1,skipper
===logic gates===
 4,0,0
 4,1,1
 4,2,2
 4,gate,0(or any number in between 1 and 3 inclusive)
 4,in1,0(or 1)
 4,in2,0(or 1)
 2,gate,0,not
 2,gate,1,and
 2,gate,2,or
 2,in1,0,xorb
 2,in2,0,xorc
 4,out,0
 0,ret
 1,xorb
 5,out,in2 
 0,ret
 1,xorc
 4,out,1
 0,ret
 1,not
 2,in1,0,notb
 4,out,0
 0,ret
 1,notb
 4,out,1
 0,ret
 1,and
 2,in1,0,andb
 5,out,in2
 0,ret
 1,andb
 4,out,0
 0,ret
 1,or
 2,in1,0,orb
 4,out,1
 0,ret
where out is the output
Category:Languages
Category:Turing tarpits
Category:No IO
Ulioisc

ulioisc is a OISC where u have 2 work bit-level
==command==
 m t [j0,j1]
means:
set m to t,then jump to j0 if the line is off (if its on jump to j1)
(if ulioisc jumps to somewhere undefined then it halts)
===extra syntax===
====labels and short form====
 a:m t [j0,j1]
means:
the program can jump 2 this line by using a
 m t j
means:
 m t [j,j]
 m t
 ...
means:
 m t nl
 nl:...
and
 m t
 l:...
means:
 m t x
 x:...
====# and &====
 #0
means:
off
 #1
means:
on
and
 &l
means:
line l
====exit condition====
if the program does not know what 2 do it crashes
==examples==
===truth machine===
 input &dp
 dp:&dp &dp [exit,dp]
==
Category:Languages
Category:No IO
Category:OISC
Category:2023
Ulsl

ulsl (short for unnamed life searching language) is a language made for searching cellular automata made by User:Tommyaweosme.
== Commands ==
 r [rule] - changes rule
 s - runs soup
 ml [list] - makes list
 mv [variable] - makes variable
 f [list] - puts results in list
 d [list] - removes duplicates
 i [variable] - saves user input into variable
 l [amount] - repeats things that many times
 o [list or variable] - outputs list or variable
 c [list] - uploads to catagolue
== Cat ==
 mv cat
 i cat
 o cat
== Search life ==
 r b3s23
 ml results
 l 10000000
 s
 f results
 c results
== Hello World ==
 o "Hello, world!"
== Usual search program ==
 mv rule
 mv soups
 i rule
 i soups
 r rule
 ml results
 l soups
 s
 f results
 c results
Category:Languages
UltimateBinary

UltimateBinary is a joke language, Brainfuck derivative created in 2023 by User:Sanya. The programm writed in it can seem like a random collection of ones and zeros. The commands in UltimateBinary can be long like 10000000 for input or short like 1 for next cell. For interpreter commands are zeros separated by 1. But to convert programm from Brainfuck to UltimateBinary you need to change > to 1, < to 10, etc.
==Commands==
 Commands Equivalents
Brainfuck	UltimateBinary	Description
> 	1 	Move to the right cell
< 	10 	Move to the left cell
+ 	100 	Increment current memory block value by 1.
- 	1000 	Decrement current memory block value by 1.
[ 	10000 	Start loop
] 	100000 	Go to start loop if current cell value isn't 0
. 	1000000 	Print current cell value as an ASCII char.
, 	10000000 	Read charachter and write its ASCII-code into current cell.
==Interpreter==
===Java===
import java.util.*;
public class q {
    public static void main(String[] args) {
        Integer[] array = new Integer[30000];
        Scanner scanner = new Scanner(System.in);
        List<Integer> loop = new Stack<Integer>();
        String input = //String for compile;
        String[] arr = input.replace(" ","").replace("\r\n","")
                .split("1");
        int pos =0;
        for (int i=0;i<array.length;i++) array[i]=0;
        for (int i=0;i<arr.length;i++){
            switch (arr[i]){
                case "" -> pos++;
                case "0" -> pos--;
                case "00" -> array[pos]++;
                case "000" -> array[pos]--;
                case "0000" -> ((Stack<Integer>) loop).push(i);
                case "00000" -> {
                    if(array[pos]!=0)i=loop.get(loop.size()-1);
                }
                case "000000" -> System.out.print(Character.toChars(array[pos]));
                case "0000000" -> array[pos]=(int)scanner.next().charAt(0);
            }
        }
    }
}