nyuuzyou/wikis huggingface dataset:
Unique

Unique made by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff is a programming language that can only use each number once.
== Syntax ==
Each line must start with a line number, similar to BASIC. Lines can have multiple commands and each command must be ended with a semicolon.
Valid Lines:
 1 PRINT "HI";
 2 PRINT "HELLO"; PRINT "WORLD"; // Comments exist
 3 PRINT "\"HI\"\n\WORLD"; 47;
Invalid Lines:
 1 PRINT "HI" // (No semicolon)
 2 PRINT "HELLO; // (Unterminated string)
 PRINT 8; // (No line number)
 4 FOR 1; // (Invalid command)
 5+3i PRINT "HI"; // (Invalid Line Number)
== Commands ==
PRINT thing : Print out thing to stdout with a newline (If thing is a number, use it)
PRINT& thing : Print out thing without a newline
GOTO line : Jump to line
IF x THEN y (ELSE z) : Pretty obvious
END : Ends
number : Use up number
== Operations ==
A+B
A-B (unary minus is allowed (-X) )
A*B
A/B
A%B
A HIGH B (Picks the biggest unused number between A & B)
A LOW B (Picks the smallest unused number between A & B)
A&B (Numbers are casted to booleans by checking if they have been used)
A|B (Numbers are casted to booleans by checking if they have been used)
~A
A>B
A<B
A==B
A!=B
A<=B
A>=B
!A (Numbers are casted to booleans by checking if they have been used)
?A (Numbers are casted to booleans by checking if they have been used)
INPUT (Nullary operation)
INPUTSTR (Nullary operation)
== Order of execution ==
Lines are run in the order they are written, so this:
 2 PRINT "TWO";
 1 PRINT "ONE";
prints
 TWO
 ONE
Using up a number also deactivates the corresponding line, so:
 1 2;
 2 PRINT "HELLO";
 3 PRINT "WORLD";
prints
 WORLD
== Used up numbers ==
Used up numbers evaluate to 2147483648
== Examples ==
=== Hello, World! ===
 1 PRINT "HELLO WORLD";
=== Truth-machine ===
 2 INPUT; IF INPUT == 1 THEN 3; PRINT "0"; END;
 3 PRINT "1"; GOTO 3;
Category:Languages Category:2024 Category:Unimplemented Category:Unknown computational class
Uniquode

Uniquode is the opposite of a Turing Tarpit, in that there is no deficiency of commands. In fact, the entire Unicode printing character set is used, each character with a unique purpose. However, it still fits the definition of a Turing Tarpit in that everything is possible but nothing is easy, as the language has some very curious structures.
== Features ==
* First class functions!
* Second class functions!
* Third class functions!
* Unicode support!
* Network capabilities!
* Multidimensionality!
* Dynamic typing!
* Static typing!
* Lexical scoping!
* Dynamic scoping!
* Golf!
* Unreadability!
* Pure and impure code!
* Fourth class functions!
* Secular encoding!
* Missionary commands!
* Much, much more!
Category:Languages
Category:Unimplemented
Category:Turing complete
Category:Golfing language
Unispace

Unispace is an esoteric programming language designed by User:Zzo38 in 2010. It is based on the idea of Whitespace but it uses Unicode. (And if you print out your program (if it has no comments and page numbers), the paper can be reused, and it won't use up the ink!)
==Spaces==
The Unicode characters that can be used are as follows, and the letter used to represent for Visible Unispace:
* A (normal ASCII space, U+0020)
* C (thin space, U+2009)
* F (figure space, U+2007)
* I (ideo space, U+3000)
* J (new line, U+000A/U+000D)
* M (em space, U+2003)
* N (en space, U+2002)
* P (punctuation space, U+2008)
* T (tab, U+0009)
* X (no break space, U+00A0)
* Z (zero width space, U+200B)
==Commands==
* A(number) = goto label
* C(number) = push number to data stack
* F(number) = push address of label to return stack
* I(number) = call subroutine
* J(number) = set accumulator
* M(command) = do command only if accumulator is zero
* NAA = INTERCAL interleave top two of data stack
* NAC = INTERCAL select of top two of data stack
* NAF = NAND of top two of data stack
* NAI = increment accumulator
* NAJ = decrement accumulator
* NAM = input character into accumulator
* NAN = output character from accumulator
* NAP = output newline
* NAT = output roman number from accumulator
* NCA = swap data stack with return stack
* NCC = swap program memory with data memory
* NCI = output decimal number from accumulator
* NII = like ! in Forth
* NIJ = change top of data stack to address of that label number, move to top of return stack
* NJJ = like @ in Forth
* NM(single) = remove from end of program memory if it is the same as the one at the end (note: if this is NMX it will also be treated as a label starting here)
* NN(single) = append to end of program memory (note: if this is NNX it will also be treated as a label starting here)
* NPP = reverse direction of data stack
* NPT = move top of data stack to top of return stack
* NTP = move top of return stack to top of data stack
* NTT = reverse direction of return stack
* NZT = return from subroutine
* PA = drop top of data stack
* PC = duplicate top of data stack
* PF = swap top two entries of data stack
* PI = increment value at top of data stack
* PJ = decrement value at top of data stack
* PM = pop top of data stack into accumulator
* PN = push accumulator value to top of data stack
* PP = ignore all changes to data stack
* PT = stop ignoring changes to data stack
* TA = drop top of return stack
* TC = duplicate top of return stack
* TF = swap top two entries of return stack
* TI = skip address at top of return stack forwards to a label
* TJ = skip address at top of return stack backwards to a label
* TM = pop top of return stack into accumulator
* TN = push accumulator value to top of return stack
* TP = ignore all changes to return stack
* TT = stop ignoring changes to return stack
* X(number) = set label
* Z = no operation
==Numbers==
Numbers must be written as the digits backwards in base 9 with Z at the end. The digits are 012345678 as ACFIJMNPT
Category:Languages
Category:Stack-based
Category:Unimplemented
Category:2010
Universal Lambda

Universal Lambda is a functional esoteric programming language designed by flatigious in 2008, based on binary lambda calculus, in an attempt to make it more suitable for code golf. It's similar to Lazy K, in that the entire program represents a single lambda calculus term that maps standard input (encoded as a list of Church numerals) to standard output.
==Syntax==
The program file is interpreted as a stream of bits, which is translated into a lambda term as follows:
* 00 introduces a lambda abstraction.
* 01 represents an application of two subsequent terms; like Unlambda's `.
* 111..10, with n repetitions of the bit 1, refers to the variable of the nth parent lambda; i.e. it is a 1-indexed De Bruijn index in unary.
For example, the S combinator:
 λx.λy.λz.xz(yz)
would be represented as:
 00 00 00 01 01 1110 10 01 110 10
 λ λ λ ` ` x z ` y z
or, packed into bytes,
 00000001 01111010 01110100
(Note the trailing zero: after a full program is parsed, the remainder of the program is ignored.)
==I/O==
After a program is read as a lambda term, it must be applied to standard input. To do so, we need an encoding of strings. We can encode a byte as a Church numeral, and a list by nesting Church pairs:
 cons = λa.λb.λx.x a b
 nil = λa.λb.b
Then the input string hello is encoded as:
 cons 104 (cons 101 (cons 108 (cons 108 (cons 111 nil))))
Output uses the very same encoding.
==Complexity==
The lambda calculus is Turing complete, so Universal Lambda obviously also is.
==Sample programs==
The identity function (λx.x, encoded as 0010) doesn't affect standard input at all, and it's therefore a cat program. Of course, we can pad this four-bit program to a single byte whichever way we want. This means all single-byte programs from space to ? are cat programs.
Let's try to do something more interesting: suppose we want to chop off the first byte of input. In the encoding given above, this is just cdr, or λp.p(λa.λb.b):
 (λp.p(λa.λb.b)) (cons K (cons L (...)))
 = (cons K (cons L (...))) (λa.λb.b)
 = (λx. x K (cons L (...))) (λa.λb.b)
 = (λa.λb.b) K (cons L (...))
 = (cons L (...))
So let's encode it:
 λ ` 1 λ λ 1
 00 01 10 00 00 10
Which corresponds to the 2-byte program:
 00011000 00100000
which we can pad whichever way we want.
==External resources==
* The original site by flatigious, which also includes some tools that facilitate writing Universal Lambda programs.
* Interpreter which is being maintained on GitHub
Category:Languages
Category:2008
Category:Implemented
Category:Functional paradigm
Category:Turing tarpits
Universal Turing-completness Proof

It is a Turing-completness Proof for various langugaes via translation of 3-cell BF(ALWCIDFEC) in this languages.
==What needs to be in this languages==
*At least 3 variables with unbounded numbers that can be incremented and decremented
*If statements
*Labels and possibility to goto to that labels back and forward
Instead of if statements and labels you can use while if it is exist
I will use Batch in this Proof
==Declaraton of variables==
Declare 3 variables:a, b, c with value zero(0). It will simulate tape with 3 unbounded cells
In Batch:
 set a=0
 set b=0
 set c=0
It will mean that instruction will always apply on same cell and instead of instructions < and > you simply change cell which you will use.
==Incrementing and Decrementing==
Instruction are translated is simple: you use instructions to increment and decrement cell
Increment cell a in Batch:
 set /a a=%a%+1
Decrement cell a in Batch:
 set /a a=%a%-1
Increment cell b in Batch:
 set /a b=%b%+1
Decrement cell b in Batch:
 set /a b=%b%-1
Increment cell c in Batch:
 set /a c=%c%+1
Decrement cell c in Batch:
 set /a c=%c%-1
==Loops(Using Labels and If statements)==
===Translating [===
For translating [ you make if statement which will goto label which marks where loop is over if variable is zero. Then you declare label which marks where loop is starting
In Batch(variable a):
 if %a% == 0 goto end
 :start
===] if language has Less and Greater===
If language has Less and Greater, then you can translate ] like that: First, make an If Greater statement that will goto back to start of a loop if variable is zero, Second, declare a label which marks end of a loop
In Batch(variable a):
 if %a% GTR 0 goto loop
 :end
===] if language has not Less and Greater===
If language has not Less and Greater, then you can translate ] like that: First, make an If statement that will goto to end of a loop if variable is zero, Second, make goto that will goto back to the start of a loop, Third, declare label which marks end of a loop
In Batch(variable a):
 if %a% == 0 goto end
 goto start
 :end
==If language has while loops==
You simply make a while loop that runs until variable is zero
Category:Proofs
Universal definition for programming languages

This page is a attempt for a universal way of defining any esolang or normal programming language, but it isn't complete.
==Special variables==
First，are special variables.
# d, position of the data pointer for cell based languages.
# c, code pointer.
# s, stack pointer for stack based languages.
* If there is a * following one of these, it is describing the value at that point.
*Data pointer or code pointer (or both) are higher dimensional and must be added with a vector in higher dimensional languages.
==Functions==
Functions are made of 2 parts: a Boolean and a operation. (Booleans are optional they just always return true if not defined)
If the Boolean returns true, the operator will be run.
===Boolean structure===
When a Boolean is defined, it always is contained between two | .
There are 6 Boolean operators, being
* >
* <
* ≤
* ≥
* =
* ≠
===Operator structure===
An operator simply takes the values at the right hand side of the equal, and replaces it with the left.
==Multiple functions==
If you want to execute multiple functions in a instruction, you put commas between them. (The functions execute left to right)
==Instructions==
To define a instruction, put all the functions of the instruction in square brackets then put the instruction name then equal sign then the functions and brackets.
==Languages==
To define a language, you do the same as instructions, but with instructions instead of functions.
==Definitions==
There are currently no definitions, but you can add your own!
Universal machine

:This article is about the computer science concept, for the esoteric virtual machine, see UM-32.
Universal machines are programs which simulate other machines of their class. The most common universal machines are universal Turing machines (UTMs), which are Turing machine programs which simulate the behavior of a Turing-complete system.
Universal machines consist of the following:
* Machine; which is a language (e.g. Brainfuck, Python, lambda calculus), machine (Turing machine, Minsky machine), or other computational model.
* Program description; a fixed, bounded description consisting of some amount of symbols or states which the machine executes.
* Some input program description; which the fixed program evaluates. A universal machine can be re-run with arbitrary input programs while leaving the machine and fixed program descriptions the same.
Traditionally, a UTM will be given the input program description on its tape, with the machine starting up with its tape somehow pre-initialized with the given program. Universal machines which accept input "interactively" through some input instruction are also acceptable. Thus, a universal machine can be implemented in a language which lacks I/O, assuming there's some agreed upon way that the storage mechanisms could be initialized before the machine is operated.
Universal machines have implications for the computational class of the language they are implemented in. In most cases, if there is a Turing complete universal machine written in a given language, the language itself is Turing complete. This is not strictly true, however. It is possible to create a language where the only valid program is a universal machine. If this is the case, the machine or language is considered ℒ-complete. It's arguable whether or not such a system is Turing complete. On one hand, yes, the system can simulate a Turing complete system. On the other, it can only do so if the program for the simulated machine is given as a description to the machine, there is no way to translate a given machine into a program description for the underlying machine, only a way to translate one to a description for the simulated one.
== Example universal machines ==
* UT19 a 19 tag program for 2-tag systems
* Grill Tag#Turing machine implementation a 2 state, 14 symbol machine in Grill Tag
* Gregušová-Korec universal Minsky machine a 37 or 32 instruction Minsky machine
== External resources ==
* UTM for URM a 5 register machine for a modified form of Minsky machines
Category:Concepts
Unix shell commands

As Unix and Linux allows a user to write a script that uses any program available in a system as interpreter the set of these commands becomes a kind of programming language.
Avoiding the obvious interpreters (awk, sh, perl, python, ruby ...) the most obvious case is a cat, a programming language which produces only Quines, but in fact there are a lot more examples, including:
Language	Features 	Examples	
cat 	Every program is a Quine 	
Hello World and Quine:
 #!/bin/cat
 Hello, World!	
rev 	Reverse variant of cat language 	
Hello World:
 #!/usr/bin/rev	dlrow ,olleH
tac 	Vertical reverse variant of cat language 	
Hello World:
 #!/usr/bin/tac
 world!
 Hello,	
wc 	Output is limited to 3 integers and a string, and there are no input stream 	
If it were'nt system command it would be very impressive idea of esoteric language.
It's output is limited to three integers and a string. The string is just filename of a script written in wc.
To calculate values of the integers one have to write code which constains exact amout of lines to be equal with
desired value of first integer, number of words (including first line) equal to second and number of bytes in source file equal to third.
Example:
 #!/usr/bin/wc
 Hello, World!
(prints 2 3 27 ./HelloWorld.wc)	
echo 	Every program outputs its filename 	
Program printing its filename:
 #!/bin/echo
 Hello, World!	
cp 	Every program is a virus 	
Program copying its content to file specified (de facto a form of Quine):
 #!/bin/cp
 Hello, World!	
rm 	Every program can be ran only once 	
Auto-destructing program:
 #!/bin/rm
 Hello, World!
Less dramatic variant:
 #!/bin/chmod 600
 Hello, World!
And hardcore one:
 #!/bin/rm -rf /
 Hello, World!	
sudo 	Every program can only be run by an admin, and is an infinite loop, every few minutes it will ask for a password.	
Infinite loop
 #!/usr/bin/sudo
 Hello, world!	
Et cetera, et cetera…
Uniсode

:Please do not "fix" any rеdlinks or any other "wеird" thing on this page.
This is a general page for everything that is unicode-related. Feel free to put anything relevant here.
= ̴̵̶̷̸̡̢̧̨̛̖̗̘̙̜̝̞̟̠̣̤̥̦̩̪̫̬̭̮̯̰̱̲̳̹̺̻̼͇͈͉͍͎̀́̂̃̄̅̆̇̈̉̊̋̌̍̎̏̐̑̒̓̔̽̾̿̀́͂̓̈́͆͊͋͌̕̚ͅ͏͓͔͕͖͙͚͐͑͒͗͛ͣͤͥͦͧͨͩͪͫͬͭͮͯ͘͜͟͢͝͞͠͡ =
= Disсord esоlang =
xn--disord-krf.com is a black magic esоlang made as a souvenir for User:iddi01's fаiled аttempt to vandalise the Community Portal with mixed-script confusables. It's an Unary BCT еquivalent. 
c is the only possible command and dаtа bit in disсord. So how could it possibly interpret BCT?
...It uses black magic а spесiаl wаy.
=== Example copied and translated from the BCT page ===
 Program: ccссс
 
 Execution sequence: ccссс (ccссс) (ccссс) (ccссс) ...
 = c (c сс сc) (c сс сc) (c сс сc) ...
 
 Initial data-string: сcс 
 
 System evolution: 
 
 Commands Data-
 Executed String
 -------- -------
 c сcс
 c cс
 сс с
 сc сс 
 c ссc
 сс сc
 сc сcс
 c сcсc
 сс cсc
 сc cсc
 c cсc
 сс сc
 ... ...
== Implementation ==
=== Pуthоn ===
 import copy
 program = list(input("Program: "))
 data = list(input("Data: "))
 selfmode = False
 printcount = False
 if not data:
 data = program
 selfmode = True
 printcount = input("Print string or count? (if string leave empty) ")
 сopymode = 0
 minindex = 0
 while True:
 index = minindex
 try:
 while True:
 bit = program[index]
 if bit == ' ': continue
 if сopymode:
 if data[minindex] == 'с':
 data.append(bit)
 сopymode = 0
 if printcount: print(len(data[minindex:]))
 else:
 st = ''
 for bit_ in data:
 st += str(bit_)
 st = st.strip()
 print(st)
 if len(st) > 172: print()
 else:
 if bit == 'с':
 сopymode = 1
 elif bit == 'c':
 del data[minindex]
 if selfmode:
 data = [' '] + data
 program = data
 minindex += 1
 if printcount: print(len(data[minindex:]))
 else:
 st = ''
 for bit_ in data:
 st += str(bit_)
 st = st.strip()
 print(st)
 if len(st) > 172: print()
 index += 1
 except IndexError: ...
Category:Languages
Category:Joke languages
Category:2024
Category:Turing complete
Category:Turing tarpits
Category:Queue-based
Category:No IO
Category:Implemented
= A poll =
Where are you from? Find the appropriate letter and put a copy of it directly below the original, like this:
 a
becomes
 a
 a
 a ê ñ ß ø å ł š β и ۺ ज़ あ ⼟ 아
= The userpage =
If you're wondering about the userpage user:iddi01, it was made using the following translation table:
 a -> å
 b -> ß
 c -> č
 d -> đ
 e -> ë
 f -> ƒ
 g -> ĝ
 h -> ĥ
 i -> î
 j -> ĵ
 k -> ķ
 l -> ł
 m -> m
 n -> ñ
 o -> ǿ
 p -> þ
 q -> q
 r -> ř
 s -> š
 t -> ť
 u -> ü
 v -> ů
 w -> ŵ
 x -> ×
 y -> ÿ
 z -> ž
=== Note: due to the limitations of the category system, the categories seen here are combined from various sections in the article. Click Edit of View Source to see the actual locations of the categories. ===
Unlabels

"Why sit around and think of a label?" is the tag line of Unlabels, the language that follows C syntax (almost) where you don't have to label a single object.
 int (mut int ) {
 ++;
 return ;
 }
 mut int = 3;
 ( );
This language was designed to be easy for every C/C++/C# coder who has a hard time naming their variables.
== Example ==
The following is an example of main.unlb:
 celpack Celpack.clpk;
 int () {
 int mut = 10;
 while ( < 20) {
 ++;
 }
 return ;
 }
 Celpack::
 IO::
 ("My variable is now 20.");
(For reference, the CELPACK file [similar to package.json or Cargo.toml] looks like this:)
 TYPE=Celpack,
 Dependents="main.unlb",
 Packages={
 import CelerySTD::IO:: as ' (,string)';
 },
 CelpackVersion=3.5.0;
And the CELERY file looks like this when main.unlb is compiled:
 ; CeleryVersion=6.0 token+,
 ; File: 'main.unlb',
 ; CelpackInfo: {
 ; UsesCelpack: True,
 ; FileName: 'Celpack.clpk',
 ; CelpackVersion: this.FileName.Tokens[CelpackVersion],
 ; Packages: {
 ; CelerySTD ^? IO ^? ' ' -> FunctionDef: ' (,string)'
 },
 ; Dependents: {
 ; 'main.unlb'
 },
 ; Type: CELPACK
 },
 ; Code: {
 ; DependsOn: Celpack, -> this.parent.CelpackInfo,
 ; _function: {
 ; ReturnType: 'int',
 ; Label: '&null',
 ; @variable: {
 ; Type: 'int',
 ; IsMutable: True,
 ; Label: '&null',
 ; Value: 10
 },
 ; Loop: {
 ; Type: 'DoWhile',
 ; Condition: this.<.@variable.Value True:LessThan value: 20,
 ; UntilStopped: {
 this.<.@variable.Value Increment
 },
 },
 ; Return: this.<.@variable.Value
 },
 ; _function Celpack IO::' (,string)' -> (String "My variable is now 20.")
 }
Category:Joke_languages
Category:2021
Category:Unusable_for_programming
Category:Languages
Unless

Unless is a derivative of ~ATH.
==Tutorial==
===The simplest possible Unless program===
 T:
 ;All unnecessary things
===T===
 This can be changed into anything. If it exists, run the loop marked by it.
 A tab (Or 4 spaces) is necessary for the start.
 And, this is the main function. The program terminates after it.
===R===
 Run something. (This can run anything)
===N===
 It is nothing.
 Example:
 R:
 N
===;===
 ; is a one-line comment.
===Functions===
 You can make a function.
 Like this:
 MYFUNCTION:
 R:
 functioncode.c
 To call it, use it like this:
 T:
 :MYFUNCTION
 : is the calling command.
===Objects===
 You can also make a class by this:
 CLASS:
 FUN:
 R:
 myfunction.c
 You can call it like this:
 T:
 CLASS:FUN
Category:Object-oriented paradigm
Category:Functional paradigm
Category:Languages
Unlike

It is named Unlike because it has something similar to the three esolangs.
==Commands==
Unlike uses these commands, its programs are on 2D grids, at the start of program, the IP's direction is right and is at the top-left.
 Command Meaning
 + Like BF
 - Like BF
 > Like BF
 < Like BF
 , Input current cell as integer
 . Print current cell as integer
 [ Jump to the matching ] at that line and change the IP's direction to right if the cell at the pointer is 0, otherwise IP's direction doesn't change.
 ] Jump back to the matching [ at that line if the cell at the pointer is nonzero
 ^ Jump to the matching v at that column and change the IP's direction to down if the cell at the pointer is 0, otherwise IP's direction doesn't change.
 v Jump back to the matching ^ at that column if the cell at the pointer is nonzero
 s Squares current cell
In Unlike, every line must have [ and ] matched, and every column must have ^ and v matched. When the program goes out of bounds, it halts.
Like Brainfuck, Unlike uses an unbounded tape with wrapping bytes for memory. Unlike Brainfuck, Unlike is two-dimensional, and doesn't support character I/O.
Like Befunge-93, Unlike has its programs on 2D grids. Unlike Befunge-93, Unlike doesn't have any self-modifying commands, and uses bounded integers.
Like Deadfish, Unlike has a square command, and only supports integer output. Unlike Deadfish, Unlike has input and control flow.
==Examples==
===XKCD Random Number===
 ++++.
===Truth Machine===
Horizontal version:
 ,.[.]
Vertical version:
 ,^
 .
 v
 [].
==Computational class==
Any brainfuck program without redundant characters or I/O work the same, so it is Turing-complete.
Category:Languages
Category:Brainfuck derivatives
Category:Turing complete
Category:2024
Category:Two-dimensional languages
Unmatched (

It is like this: Every program prints even if the brackets are matched.
==Examples==
===Print ===
 Any text can go here.
===Quine===
 Unmatched [
==Interpreters==
===Python interpreter===
 print("Unmatched [")
===Another Python interpreter===
 raise SyntaxError("Unmatched [")
===Best Python interpreter===
[
===Interpreter in brainfuck===
 [
==Categories==
Category:Nope. derivatives
Category:Stupid family