nyuuzyou/wikis huggingface dataset:
Ultimate Golfing Simulator 3000

Ultimate Golfing Simulator 3000 is a family of programming languages designed by User:rdococ.
== Semantics ==
For every brainfuck program, there is a dialect called Ultimate Golfing Simulator 3000(xxx) with the brainfuck program replacing xxx. If the program is non-empty, a syntax error is reported. Otherwise, the particular brainfuck program corresponding to the dialect is executed.
== Examples ==
A cat program written in Ultimate Golfing Simulator 3000(,[.,]):
A Hello World program, written in Ultimate Golfing Simulator 3000(++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.):
An x86 emulator written in a dialect whose name is too long to present here:
As you can see, this language family absolutely dominates code golfing challenges.
== Computational Class ==
Some of the languages in the Ultimate Golfing Simulator 3000 family can simulate a Turing machine and could be considered ℒ-equivalent. But no language is Turing complete on its own as each can only run one program.
== See also ==
* MetaGolfScript
Category:Languages Category:Joke languages Category:Unusable for programming Category:2023
Ultimate bf instruction minimalization!

Ultimate BF instruction minimalization! or UBFIM is a BF derivative with only 3 instructions made by BF enthusiast User:Wh1teWolf December 12, 2009. It uses an infinite tape for storage, each cell restricted to a 1-bit value. The language is the successor of Minifuck which may have 3 or 4 instructions (the description is vague as to whether no-op characters are instructions). It also has a resemblance to iag which had similar motivations.
==Specifications==
This instruction is using one-based indexing
===Commands===
 < = Move pointer one cell to the left. (If pointer is currently over the first bit, do nothing.)
 ( = Move to next bit and flip it, skip next instruction if zero.
 any other character = No-op instruction.
Programs written in UBFIM are contained within a single Brainfuck loop, so if at the end of the program the current bit is non-zero, go back to the start.
===Memory mapping===
*Cell 2 = Set to 1 to perform input/output. If all I/O bits are empty perform input, else do output. Afterwards I/O cell 2 is set back to zero.
*Cell 3 = Pointer is here on program start.
*Cell 4-11 = I/O bits
==Examples==
===Infinite loop===
This program with loop forever, since the bit under the pointer will always be 1. Noted that this will also flood the memory.
 (
===Cat===
 (<(< (<(<( (<(<( (<(<( (<(<( (<(<( (<(<( (<(<( Zero out the I/O bits, and maybe some more. This line is not necessary the first time the program is run.
 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< We move back many times just to make sure we have reached all the way to the first bit.
 
 ( now cell 2 is set to 1. That means I/O, and since the I/O bits is all zero it performs input.
 <( set cell 2 to 1 again and output the inputted value.
 (<( go to cell 3 without changing its value.
 Since this is the end of the program and the current bit is non-zero the program gets executed again.
==See Also==
*BF instruction minimalization - other attempts on minimalizing bf
*interpreter - interpreter in Basic 
*Kak - similar language
Category:Languages
Category:Low-level
Category:Brainfuck derivatives
Category:Cell-based
Category:Implemented
Category:2009
Ummm...

Ummm... is a programming language made by User: Areallycoolusername. It's a language that starts to execute your code fine, but then forgets what it's doing. In the case that you want to print 1 character to get around this, the compiler will forget it completely. 
Command	Function
S 	Switch that activates code, but reduces code memory
P 	Print strings, integers, and floats.
Code is stored in cells as letters. Each letter represents one number for example: A = 1 and B = 2. Any value beyond "I" or 9 is stored as two letters in seprate cells whose sum is equal to the omitted value. This is where the command S comes in. S activates the memory, but by doing so, reduces the memory tremendously. When you use the P command to print a string the individual letters of that string is stored in memory. When printing a number of any sort, it's stored in memory as letters also. The ouput of whatever code you put in will result in the first part of your text followed by "ummm...".
Here is a hello wold program in Ummm....
S
P "Hello, world!"
 
The output of this is:
Hello, ummm...
To avoid this problem, copy & paste the text neccecary for printing:
S
P "Hello, world!Hello, world!"
The output of this has a side-effect:
Hello, world!ummm...
Category:Unusable for programming
Category:Languages
Category:2018
Un-Js

Unjs is an upside-down variant of javascript. (This was written in markdown, not wiki-stuff. If you could see the original README doc, there would be a conversion chart. As I'm new here, I don't know if I can link it to a github repo.)
Usage:
 unjs from helloworld.sɾ to helloworld.js
 unjs from helloworld.js to helloworld.sɾ
File extension can either be .sɾ or .sr, depending on whether your system supports special characters in file extensions. It's a .sɾ file because js upside down is sɾ.
Category:Languages
Unary++

Unary++ is an esoteric programming language designed in 2024. Unary++ uses the bijective unary number system as source code. To write a program in Unary++, use the following steps:
1. Write your program in Unary.
2. Replace the 0s in the Unary program with the character as follow:
Unary	Unary++
0 	1
==Number of symbols==
According to the specification, Unary++ uses only one symbol. Some say the EOF character has to be counted as well, thus Unary++ uses 2 symbols. However, in most other Turing tarpits the EOF symbol isn't counted. Unary++ still has one symbol less than a Turing tarpit that uses two symbols in its specification, since such a language also has an extra EOF symbol.
==Examples==
Program that gets a single character and outputs it again
 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
Infinite loop that does nothing but repeat (line breaks added for readability)
 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
 
 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
Cat program, EOF returns 0:
 Too large to show here. It's 56623 one digits in a row, about 7 kilobytes.
Hello, World:
Has 142,209,095,870,573,693,396,245,504,627,320,468,349,603,549,841,832,242,891,887,476,756 ones.
Quine
There is a quine, which is a very long string of 1s that is quite impossible to be presented here or run to completion in an interpreter. A file containing the program in Unary++ would be super large.
==Designing Unary++==
It's easy to design such an esolang by recoding one which already exists. Another similar way to create a new one is to add a new command which prints 42 to an esolang.
==Conclusion==
Suffice to say, the Brainfuck program Lost Kingdom would generate a very large source file in Unary++.
==See also==
* Unary
==Compiler==
Python:
 print(input().replace('0','1'))
Category:Languages
Category:Turing tarpits 
Category:Low-level 
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Joke languages
Category:2024
Category:Turing complete
Category:Zero-dimensional
Category:Cell-based
UnaryBrain

UnaryBrain is an esolang invented by User:None1, it shows that brainfuck with a one-symbol tape is definitely not TC.
==Difference from BF==
Yes, every cell in UnaryBrain can only have one value: 0. So the instructions in UnaryBrain are like this:
 + Do nothing
 - Do nothing
 , Read a character but discard it
 . Print a null byte
 > Do nothing
 < Do nothing
 [code] Do nothing
Yes, because the cell is always zero, brackets do nothing. Increments and decrements do nothing because the cell remains zero after increment and decrement. Finally, < and > do nothing because the tape is unbounded and the tape after moving the pointer will be exactly the same as the tape before.
==Examples==
===NOP===
 ++--<[++++]>
===Print a null byte===
 .
==Computational class==
Total, because there is no control flow.
==See also==
* brainfuck
* boolfuck, a version of BF that uses bits.
Category:Languages
Category:Joke languages
Category:Total
Category:Unusable for programming
Category:2024
Category:Brainfuck derivatives
Unary Stack

Unary Stack is a attempt at creating syntax for 1-symbol Push-down automaton by User:ChuckEsoteric08
==Syntax==
Each state is represented like that:
 s1: commands s2 (s3)
Where s1 is the current state, followed by commands, next state, and if last command was -, followed by s3. It will then execute commabds and if stack is empty current state s3, else s2
===Commands===
 + - push 1
 - - pop
 . - output length of the stack
 , - input number, and set length of the stack to it
Category:Languages Category:Unimplemented Category:Push-down automata Category:Low-level
Unasm

UnAsm is a language created by User:Normalcat, made as a joke to see how fast they could make a readable esolang. It is quite simple, while also being much more difficult to write practical programs than many other esoteric programming languages
==Syntax==
The syntax in UnAsm is purposely extremely simple, spacing does not matter, as long as each command is separated via a newline or semicolon.
UnAsm uses two registers to work with data, which can be saved/loaded using saveVars & loadVars. Almost all commands have a version for the first and second register.
For conservation of length the r1 versions will only be shown, but the r2 versions do exist.
This does not include out and outc, which only print the data from register 1.
The commands are as follows:
Command 	Description
r1 	Sets the value of register 1 to the value provided.
r1+ 	Adds 1 to register 1.
r1- 	Removes 1 from register 1.
r1* 	Multiplies register 1 by register 2.
r1/ 	Divides register 1 by register 2.
r1= 	Sets register 1 to 0.
r1# 	Sets register 1 to a random integer between 0 (inclusive) and 256 (exclusive).
r1r2 	Sets register 1 to the value of register 2, applies the other way aswell.
lbl 	Creates a label to jump to, with the name provided, note that this is interpreted so you cannot jump to later labels unless they have already ran and you have jumped back.
jmp 	Jumps to a label of the given name.
rjmp 	Jumps to a completely random line, including jumping to the line that ran it.
quit 	Ends the program.
src 	Prints the source code of the interpreter.
out 	Outputs register 1's value.
outc 	Outputs register 1's value as an ASCII character, however this may change depending on the interpreter.
swap 	Sets register 1 to register 2's value, and register 2 to register 1's value.
cmp 	Runs the next line only if register 1 is larger than register 2, otherwise it will skip the next line and move on. If r1/r2 aren't numbers, this should be treated as a nop.
saveVars	Saves r1 & r2 to an in-memory slot args[0]
loadVars	Loads r1 & r2 from an in-memory slot args[0]
jseval 	Evaluates the arguments passed using the JS eval function & puts their return value in the r1 register. Note that this may not be available in non-JS interpereters & some may require you to specify an option to enable this functionality
Commands/Instructions that aren't known about should be ignored.
==Code examples==
A simple hello world program,
 r1 72; outc
 r1 101; outc
 r1 108; outc; outc
 r1 111; outc
 r1 32; outc
 r1 87; outc
 r1 111; outc
 r1 114 ;outc
 r1 108; outc
 r1 100; outc
 r1 33; outc
A program to count up starting at 0, printing newlines between each number.
 r2 10
 lbl Loop
 r1+
 out
 swap
 outc
 swap
 jmp Loop
==Interpreters==
Unasm's original interpreter (written in JavaScript), by User:Normalcat can be found at it's Github Page
A typescript recode of said interpreter, written by User:MokiyCodes, can be found in 3 forms; a library, a web-demo & a CLI. Note it includes some non-official instructions as found here
Category:Languages Category:Implemented Category:Joke languages
Unc

unc is an esoteric version of C with various keywords and characters swapped around to make programs difficult to write and read. For instance, this is a Hello, world! program in unc:
 !include >=fgQVb%U<=
 
 true ZNVa[] <<
 chgf[L'uRYYb~ jbeYQ#']:
 if 5:
 >>
and the generated C code:
 #include <stdio.h>
 
 int main() {
 puts("Hello, world!");
 return 0;
 }
You may notice the resemblance. Note that the "compiler" is written in regular expressions, which causes parsing of multiple string literals on the same line to have odd results.
==External resources==
* The unc repository at GitHub.
Category:Languages
Category:Implemented
Category:Low-level
Category:Turing complete
Uncomment

Uncomment is an esoteric programming language created by user:Okohokonu in 2009. It uses two commands; numbers from 0 to 255 in hexadecimal, and "x."
==Stack-pushing==
The hexadecimal number in the program is pushed to the stack, so:
 010203040a
pushes 1, then 2, then 3, then 4, then 10 to the stack.
==Function execution==
The character "x" executes the function using the value on top of the stack.
===Function list===
Function Number	Parameters	What it Does
0 	x 	Exits with exit code x
1 	x , y 	If x is 0, then prints y to standard output as a character. If x is 1, y is printed as an integer.
2 	x, y 	Pops x and y from the stack and pushes their sum.
3 	x, y 	Pops x and y from the stack and pushes x - y.
4 	x, y 	Pops x and y from the stack and returns x * y.
5 	x, y, z 	If x is 0, pushes integer divide y / z. If x is 1, pushes y % z.
6 	x, y 	If x > y, pushes 1. Otherwise, pushes 0.
7 	x, y 	Same as above, but x < y.
8 	x, y 	Same as above; x >= y.
9 	x, y 	Same as above; x <= y.
10 	x, y 	Same as above; x is equal to y.
11 	x, y 	Same as above; x is not equal to y.
12 	x 	If x is 0, inputs a character, pushing the character code of the character onto the stack. If x is 1, does the same thing, but if a pure integer is input, the value of the integer is pushed to the stack. More than one character is reversed and pushed to the stack.
13 	x 	If statement. Top value on the stack is used, where 1 is true and 0 is false.
14 	-- 	Ends the innermost if statement.
15 	x 	Makes a label with "name" x. This means that only 256 labels can be made total.
16 	x 	Goto statement. Directs program execution to label with "name" x.
Note that "x" pops the first value on the stack and runs that function. X is the first value on the stack, y is the second, and z is the third. X, y, and z are all popped when the function is called, depending on what function is used.
==External resources==
* A Python interpreter for Uncomment.
Category:Languages
Category:Stack-based
Category:Implemented
Category:2009
UndeadFish

UndeadFish is a Deadfish derivative, it is the same as Deadfish, but the commands are different:
 Commands
Deadfish	UndeadFish
i 	Don't run the Deadfish i command
d 	Don't run the Deadfish d command
s 	Don't run the Deadfish s command
o 	Don't run the Deadfish o command
Commands are separated by line feeds.
==Examples==
======
 Don't run the Deadfish i command
 Don't run the Deadfish i command
 Don't run the Deadfish s command
 Don't run the Deadfish o command
Category:Languages
Category:Joke languages
Undecimal

Undecimal is a language invented by User:None1 and it is inspired by Duocentehexaquinquagesimal, which is inspired by Golunar, which is inspired by Unary. It is the same as Duocentehexaquinquagesimal, however it is represented in base-11, in which a space represents ten.
==Examples==
===One Time Cat===
We have the brainfuck program: ,..
We convert it to a number: 110 (1101100 in binary).
Then we convert the number to base-11: 0, that's it! The one time cat program in this language is 0
===Cat program===
 395 6
===Hello World===
 39506475 9533058 25786 7 27053602440831326587489371 1 999115475
===Kolakoski sequence===
 5090990028 1 828420 8716368 1498082 76917520713435 6315 849719 9130511168290278823 2709552 32595589356 641363015 09541343832768 6 505400333877047375 19991 480624 690396345366 26903391110444332910 82375251046314740360 0072821639883 7 1 22039201411 533 79088120222887199401 759 4 4
==Implementation==
A compiler to brainfuck is in Python:
def undecimal2num(x):
 a='0123456789 '
 r=0
 for i in x:
 if i in a:
 r=r*11+a.index(i)
 return r
def num2bf(x):
 return .join(map(lambda a:'><+-.,[]'[int(a)],'{:o}'.format(x)))
def undecimal2bf(x):
 return num2bf(undecimal2num(x))[1:]
print(undecimal2bf(input()))
==Generator==
A translator from brainfuck is also in Python:
def bf2num(x):
 r=1
 for i in x:
 if i in '><+-.,[]':
 r=r*8+'><+-.,[]'.index(i)
 return r
def num2undecimal(x):
 r=''
 while x:
 r='0123456789 '[x%11]+r
 x//=11
 return r
def bf2undecimal(x):
 return num2undecimal(bf2num(x))
print(bf2undecimal(input()))
==External resources==
* Complete interpreter on Try it Online, based on the Python compiler above, uses the native brainfuck interpreter to execute the code and uses an exclamation mark to separate code and input.
Category:Languages
Category:Implemented
Category:Zero-dimensional
Category:Turing complete
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:2023
Undefined

Undefined is a programming language that, every program in it causes undefined behavior. Extra command line arguments and lack of source files also trigger undefined behaviors.
== Turing-completeness ==
A standard-compliant Undefined program (that doesn't trigger any undefined behavior) is both capable of simulating a universal Turing machine and incapable of simulating a universal Turing machine, and can also do something a Turing machine cannot do. But the language itself isn't Turing-complete, because it has zero of such programs.
Practically, the Turing-completeness of this language depends on the implementation. Some undefined instructions might consistently form some kind of control flow in some interpreters.
== Interpreter ==
Every program in your computer is an interpreter of Undefined. And all of them are bug-free (unless they are officially the interpreters of dialects of this language, or have extra features such as debugging). This may debunk the myth that every program that is complex enough always has bugs.
Category:Joke languages
Category:2016
Category:Implemented
Category:Unusable for programming
Category:Languages
Undefined behavior

Undefined behavior is the result of any action in a programming language that the language specification specifically avoids defining, without making any suggestions as to what might happen. An example in an esoteric programming language would be a program going off the right side or bottom of code space in 2L. Non-esoteric examples in C include using an uninitialized variable, overflowing an integer, and abusing sequence points - for example:
 int b = 1;
 b = b++; // undefined
 int c = b++ * b--; // undefined
Code that exhibits undefined behavior may produce unexpected and inconsistent results, crash the program (or the interpreter), cause an error, etc. An implementation has no responsibility to try to do anything that even remotely makes sense when faced with undefined behavior, and in fact is perfectly free to make demons fly out of your nose if it wants to.
In the field of esoteric programming, undefined behaviour is often used as part of Turing-completeness proofs. Such proofs often work by showing that a language can emulate a more complex language, and often the more complex language has to be defined specifically for the proof. Frequently there will be some areas where the translation breaks down, meaning that some parts of the more complex language will act weirdly when used, perhaps causing the invariants on which the proof relies to fail and causing other commands to start malfunctioning. In order to get around these problems, the offending situations can be marked as undefined behaviour; as long as the complex language is still Turing-complete even despite the undefined behaviour, the proof will work, and more simply than it would trying to define the behaviour in these situations. (The Turing-completeness proof for the more complex language, in turn, has to ensure that the programs it generates never allow the undefined behaviour to be invoked, as there's always the possibility that it could do something that ruins the construction.)
Category:Concepts
Undefined behavior (language)

Undefined behavior is a language where everything is undefined.
Literally. There is no specification.
== Known UB programs ==
Due to the nature of the language, most programs will not have the intended behaviour in most implementations.
=== 'ubtxt' (Undefined Behavior Text) ===
==== Hello, World! ====
 STATEMENT WHOSE BEHAVIOR IS ACTUALLY DEFINED
 IN AN UNDEFINED WAY, SET THE REGISTER 1 TO THE UNDEFINED VALUE // sets reg 1 to 0 or sometimes 255
 SET REGISTER 1 TO THY ZERO
 ASSIGN TO REGISTER_MULTI 1 TO LENGTH_OF STRING Hello, World! /STRING /LENGTH_OF /REGISTER_MULTI THE VALUE STRING Hello, World! /STRING // the only way that works with most compilers
 PRINT REGISTER_MULTI 1 TO LENGTH_OF STRING Hello, World! /STRING /LENGTH_OF /REGISTER_MULTI
== Implementations ==
By definition, any program is a valid implementation of this language.
Category:Joke languages
Category:2021
Category:Unusable for programming
Category:Implemented
Category: Languages
Underload/a interpreter in Uiua

This is a Underload interpreter in Uiua written by User:Jan jelo
C ← ⊂:□:⊂⊂{}∩□
State ← C0{"aa""b""c"}
I ← °□⊡0
S ← °□⊡1
P ← °□⊡2
# * (Join)
J ← C I:⊂:↘2:□⊂°□⊡0:°□⊡1..S.:↘1P.
# a (A)
A ← C I:⊂:↘1:□$"(_)"°□⊡0.S.:↘1P.
# ~ (Flip)
F ← C I:⊂⊂⊂{}⊡1:⊡0.:↘2.S.:↘1P.
# : (Dup)
D ← C I:⊂⊡0.S.:↘1P.
# ! (pOp)
O ← C I:↘1S.:↘1P.
# S (ouT)
T ← &pf°□⊡0S:O∘.
# ^ (Eval)
E ← C I:↘1S.:⊂°□⊡0S:↘1P..
BStep ← ⨬(
 C+1I:⊂□⊂°□⊡0S:⊡0P.:↘1S..:↘1P.
| ⨬(C-1I:⊂□⊂°□⊡0S:⊡0P.:↘1S..:↘1P.
 | C I:⊂□⊂°□⊡0S:⊡0P.:↘1S..:↘1P.
 )≠@)⊡0P.
)≠@(⊡0P.
B ← C I:⊂□⇌↘1⇌°□⊡0:↘1.S.:P∘.⍢(
 BStep
| ≠0I
)C1⊂{""}S:↘1P.
RunStep ← ⍣(
 J°@*
| A°@a
| F°@~
| D°@:
| O°@!
| T°@S
| E°@^
| B°@(
)⊡0P.
Run ← ◌⍢(
 RunStep
| >0⧻P
)State
Run"(:aSS):aSS"
#(:aSS):aSS