nyuuzyou/wikis huggingface dataset:
Nothing

The Nothing is an esoteric programming language designed for bug-free programming.
=== Design philosophy ===
In the current software industry focus lays on solving complex problems by using complicated algorithms. The language "Nothing" was created to shift this focus from complex problems towards the expectations of the programmer and the user. This way even the most complicated programming challenges swiftly disappear as if they never have existed before. Basically, the main strengths of the language "Nothing" are:
* to create bug-free and portable software
* to shift focus from complex technical solutions towards the expectation of the programmers and users
=== Program structure ===
Nothing has a very simple and straightforward structure. It is a typeless language which does not use any of the known programming constructs like loops, choices and the like. It is the only language which can be considered 1GL, 2GL, 3GL, 4GL and 5GL all at the same time.
=== Example of a Nothing program implementing "Hello world" ===
Note: if the output does not meet the expectation of a "hello world"-program, this does not necessarily mean the Nothing program has a bug. The programmer primarily is supposed to contemplate on his expectations, and has to accept that a Nothing program always is bug free.
=== Compilers interpreters ===
A Windows graphical IDE here.
A compiler implementation in BASH Shell Script can be found here.
DIY Nothing Interpeter here
=== Quine ===
A Quine is very easy to implement. As a matter of fact, each Nothing program is a Quine by itself. Also all Nothing programs have a palindromic nature.
=== Advantages ===
* It is very easy to learn.
* All Nothing programs are guaranteed bug-free.
* Sizes of executables are extremely small.
* The only language which is compatible with all hardware platforms.
* Most existing compilers and interpreters can also run Nothing programs.
* Compared to other languages Nothing offers superior performance.
=== Disadvantages ===
* A known disadvantage is the amount of time it may take to adjust one's expectations of a Nothing application appropriately. The acceptance by users and programmers typically is time-consuming and sometimes does not happen at all.
* As Nothing programs may not have visible output, this often leads to the false assumption that the program does not work correctly. However all Nothing programs work correctly by design of the language.
* Nothing programs are hard to distinguish from one another. Most Nothing programmers therefore use unique and descriptive filenames.
=== Nothing and the real world ===
Programs created with the Nothing language seem to be rare, however, as Nothing applications have no output it is almost impossible to identify their success rate. Therefore, it can safely be assumed that Nothing applications are in fact wider spread than currently can be observed. It is expected that the amount of implementations in the Nothing language will increase dramatically in the near future.
Nothing Website
Category:Languages Category:Implemented Category:Joke languages Category:Unusable for programming Category:Total Category:Zero-dimensional
Nouse

In nouse the direction of the control flow depends on the current size of the stack. The nouse virtual machine consists of a ring of bytes and a stack of bytes. Execution continues as long as the instruction ring is not empty, and begins at instruction 0 with an empty stack.
==External resources==
* Nouse documentation (salvaged from Geocities)
* Perl implementation
Category:Languages
Category:Implemented
Category:Stack-based
Category: Unknown computational class
Category: 2001
Novice

Novice is an esoteric programming language designed by Keymaker in 2007. It's a Turing-complete language based on string-rewriting and jumping to labels. For any string-rewriting to happen, there must exist a label that's identical to the part that rewrites something. There's an unbound memory string, and it, as every other line, must have at least one character. Replacing empty string with something or something with empty string isn't allowed. The memory string may not feature any '=' or '-' characters, and a line that's not label may feature only one, but not both.
For example, the following
 e
 abc=e
searches 'abc' from the memory string, if it's found and if there exists label 'e' (which does in this example), then 'abc' is replaced in memory string with 'e', and the line pointer jumps to label 'e'. Also, there may not exist two identical labels, but lines that aren't labels may be identical.
If a line isn't label, it has one '=' or '-'. They work as described above, and their only difference is that lines with '-' also print out the right part, in case a matching label is found. For example
 a-Hi!_*
 Hi!_*
will print 'Hi!' with a new-line if label 'Hi!_*' is found in the program and 'a' in the memory string. 'a' in memory string will also be replaced with 'Hi!_*'. There are special characters to allow printing new-lines and '=' and '-' and '_', and they are (in same order) '_*', '_a', '_b', and '__'.
The very first line in the program is the initial state of memory, and it's not count as a program line, so the first line 'aa' wouldn't work as a label 'aa'.
One proof of its Turing-completeness is the following program, http://yiap.nfshost.com/esoteric/novice/bbf.nvc, which is a binary brainfuck interpreter, and thus shows through simulation that Novice is Turing-complete.
==External resources==
* Novice page (specs, programs, and interpreter)
Category: Turing tarpits
Category: String-rewriting paradigm
Category: Low-level 
Category: Languages
Category: Output_only
Category: Implemented 
Category: 2007
Ns

Currently in progress of writing an interpreter for a high-level programming language called ns. User:Nmcassa
==Syntax==
This language is like python and lua, because it is dynamically typed and also because it is written like English
Also there are no tabs and no encapsulating characters (except "" for strings) (at this point in dev). Expressions don't support PEMDAS (because of the lack of ()). So loops and ifs declare how many lines below 'belong' to them for example this if statement is holding the two lines underneath it:
 if 2 => i > 5
 var item = i
 print item
==Interpreter==
on github
Ns2dL

Ns2dL is a esolang made for the sake of making a 2d land that does NOT use a stack. Ns2dL uses a a list because yes. Oh also its made by Yayimhere
==memory ==
memory is stored in a list. There is also a buffer that stores indexes for the list. 
== Syntax ==
Ns2dL has a few commands:
 Caption text
Symbol	Meaning
! 	append the following number onto the list
$ 	set the two buffer value to the two first value of the list
+ 	add whats at the index of first buffer value onto the value with the index of the second buffer value and append that to the list
- 	subtract the value at the index of the first buffer value from the index at the second value and append that to the list
 	go down if the value at the first index is more than the one at the second index else go up
Y 	copy the code pointer into the cell above and to the right of this command and to the top left
Ø 	delete the value at the index of the first buffer value
, 	output the value at the first index as a ascii char
. 	append user input as a ascii char
* 	, But with output as a number
Ns2DdL uses befunge arrows to move around
Category:Languages Category:Two-dimensional languages
NullScript 1

NullScript 1 is an esoteric programming language invented by User:A. It is a subset of NullScript 2 and inspired by NullScript 2.
== Commands ==
These are NullScript 1's 8 commands:
tcell group	tcell group
, 	Print the current cell as a character
meta group 	meta group
< 	Move the cell pointer left.
> 	Move the cell pointer right.
* 	Push the current cell to the parameter queue
' 	Take the value from the parameter queue and put it into the current cell
math group 	math group
jump group 	jump group
{ 	If the current cell is 0, jump to the next }. If there is none, jump to the end of the program.
=== Implementation notes ===
* When a , is executed on a cell outside of the range of 0 to 127, it is undefined behavior.
* When < would push the cell pointer below zero, the cell pointer wraps around to cell 255. Likewise, if > would push the cell pointer above 255, the cell pointer wraps around to zero.
* When the parameter queue is empty and a command requires a value from the queue, the value is received from input.
* If there is division by zero, the behavior is undefined.
== Examples ==
===Cat program===
The following numeric cat program repeats until the user inputs a value of zero:
 ',{',}
== Interpreter ==
* Common Lisp implementation of the NullScript 1 programming language.
Category:Joke languages
Category:2019
Category:Cell-basedCategory:ImplementedCategory:Low-level
Category: Languages
Null program

The null program is the unique program of zero length. It is a valid program in many languages; in some of these languages, it is even a quine, in that it produces itself as output. (But if a zero-length program is used as a quine, it would be probably be considered a cheating quine!)
In the language Homespring the message "In Homespring, the null program is not a quine." is printed and the program exited, in case one runs the null program/quine.
In languages where input is appended to the source code, the null program is a self-interpreter.
The null program (submitted as a quine) won IOCCC in 1994 for "Worst abuse of the rules." A new rule was added the next year that a program must be at least one byte in length.
Category: Program forms
Null string

The null string (sometimes called the empty string) is the string with zero length, thus containing nothing.
The null string can be considered a null program, and in many languages it is also what is output when the null program runs. It is also used as a special value in some languages based on the string-rewriting paradigm, such as PROLAN/M.
Common ways to represent a null string include two quotes ("") or, common in academia, the epsilon character (ε) or lambda characters (λ). 
==See also==
*:Category:String-rewriting paradigm
*Wikipedia article on strings
Category:Concepts
Nulla

Nulla is Latin for 'zero'. Nulla is a one dimensional stack-based programming language created by User:TheCanon2. Nulla files have the .huh extension. It can be said that Nulla has zero valid symbols, for the entire program is in the file name and not in the actual file.
==Decoding==
Nulla filenames are read using a modified Base-64 encoding in which "+" and "/" are replaced with "-" and "_" respectively. The bits are then grouped into triades.
The first triade points to a file's position in a series of files. 0b000 is the first file, and then the position increments One can have up to eight files for the same program. The remaining triads are the code.
==Commands==
Opcode	Symbol	Action
000 	PSZ 	Pushes 0 to the stack
001 	POP 	Pops the top of the stack
010 	OUT 	Outputs the top of the stack as Unicode
011 	PSH 	Pushes one character of Unicode input to the top of the stack as a number
100 	INC 	Increments the top of the stack.
101 	DEC 	Decrements the top of the stack
110 	[ 	Jumps to its corresponding 111 if the top of the stack == 0
111 	] 	Jumps to its corresponding 110 if the top of the stack != 0
==Examples==
===Cat===
Ga4.huh
When converted, becomes:
000 110 011 010 111 000
Decoded:
0 [PSH OUT] PSZ
The PSZ is superfluous, but it still gets read.
===XKCD Random Number===
AkkY.huh
When converted, becomes:
000 000 100 100 100 100 011 000
Decoded:
0 PSZ INC INC INC INC OUT PSZ
The final PSZ is superfluous.
===Print all of Unicode===
Eyn.huh
When converted, becomes:
000 100 110 010 100 111
Decoded:
0 INC [OUT INC]
===Flip input===
AmfN0v.huh
When converted, becomes:
000 000 100 110 011 111 001 101 110 100 010 001 101 111
Decoded:
0 PSZ INC [PSH] POP DEC [INC OUT POP DEC]
Category:Joke languages
Category:Stack-based
Category:2024
Category:Languages
Category:Push-down automata
Category:Low-level
Category:Unimplemented
Nullary

Nullary is an esolang created by User:occular.
== History ==
The language was conceived in May 2016, as a possible answer to the question "What would be next step along from the Unary language (or other 0-dimensional languages)?".
== Description ==
Nullary is a computer language that takes no user input. A correct implementation of Nullary takes no program and no parameters from the user.
Upon launch, a Nullary implementation takes note of the elapsed time since the epoch (in the current timezone) measured in microseconds (denoted T).
Convert T into base 1 (unary). Execute this as input to the Unary or Progressive Unary esolangs.
If Nullary doesn't output something exciting in a quick enough time, you can turn off your computer.
== Practicality ==
Needless to say, Nullary isn't a very practical language. It may be of use to time travellers with a warped sense of humour, or those of a very patient disposition.
== Language Variant: Nullary+ ==
Instead of using Unary, translate T into base 8 and use it as Brainfuck input. This variant has the advantage of not having the input parsing delay that Unary/Progressive Unary has.
== See Also ==
* Seed
* Wait, which this is essentially a dialect of.
Category:Languages Category:2016 Category:Unusable for programming Category:Unimplemented Category:Zero-dimensional
Number-code

== Examples ==
This is a truth machine.
0 8 (9 10 1) 111 2 1111 3 4 2 0 11 3 4 4 6
111 2 1111 3 4 2 0 11 3 4 4 1 02 6 03 01
== Syntax ==
Cmd	Description
0 	Sets current cell to 0.
1 	Adds 1 to the current cell.
2 	Next cell.
3 	Previous cell.
4 	Multiply cell value by next cell value.
5 	Divide, same as multiply.
6 	Coverts current cell value to ASCII and prints it.
7 	Converts a value into a variable, the name is the integers after the 7.
8 	Ask the user for input, if not an integer, it will print an Error, the output is put into the current cell.
9 	User's output.
01 	Ends program.
02 	Repeats the value in-between 02 and 03
03 	Ends 02 and repeats.
04 	Current cell value.
== If and conditionals ==
All conditionals must be enclosed in brackets.
If the conditional is true, it must skip to the next line.
Cmd 	Description
10 	Is equal to
11 	Is greater than or equal than
12 	Is less than or equal than
13 	Is True
14 	Is False
100 	Set all cell values to 0.
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
== Errors ==
If no 01 in program:
You forgot to end the program, unless you want this to run forever.
If NaN, undefined, or null values are in the program:
Did you forget to check your code again? :)
If there are unknown characters:
Nice code, are you too used to symbols? Heh heh.
If 9 is used and 8 was never used:
Did you ask nicely?
If 6 is used and value is undefined:
I don't think blank is a proper piece of code.
Number-encoded Bitwise Cyclic Tag

Number-encoded Bitwise Cyclic Tag is variant of Bitwise Cyclic Tag by User:ChuckEsoteric08 which was created to implement BCT in register-based languages like TLIJMMWTRAMCBICHWTPITCSIBCTII, Sreg or EsoBASIC.
==How it works==
To convert Bitwise Cyclic Tag to Number-encoded Bitwise Cyclic Tag you should do this 2 (or 3) steps:
# Reverse Program and Data strings
# Append 1 to the beginning of each string
# (optional) Convert both strings to base-10 numbers
Category:Languages Category:Turing complete
Number-rock

Number-rock is a programming language where each program consists of a series of definitions. It is not allowed to mention any one after it is defined, nor can a definition include mentioning itself (but a function can indirectly call a function defined above it).
Data types are natural numbers and pure functions (which take one input and one output). Types are allowed to be polymorphic, but a value always has a type (which is sometimes unknown).
The significant characters are: 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ:.;,=^[]() and all others are ignored, except that lowercase letter is treated the same as uppercase, and that # begins a comment which ignores everything up to the next line break.
Each definition must consist of: name(args): statements; result. The (args) and/or statements; can optionally be omitted.
The arguments are a list of variables with commas in between which specifies the arguments to the function. If there is more than one, it is done by currying.
The possible statements are:
* var=value; Writes the value to the variable. Variables are local to each function and must be defined in this function before being used (if in the args, it is implicitly defined). You can have multiple variables with commas, to write the same value to each. Or, you can put commas on both sides, meaning the number of variables and number of values must be equal; all expressions are evaluated and then you write the results to the variables.
* expression; The statement must include a variable name somewhere, with an equal sign after the variable name. Causes the result to be written to that variable.
* count[statements]; Evaluate the count expression, and then execute the statements inside of the block by exactly that many times. The last statement is allowed to omit the semicolon at the end if wanted.
* var=count[statements]; Same as: var=count; var[statements];
* var[statements]=value; Same as: var[statements]; var=value;
The possible expressions are:
* var Read value of a variable, or a function defined after the current one if there is no such variable.
* var= Only allowed in one kind of statement; see above.
* number A natural number in decimal format.
* func(args) Call a function with specified arguments (if more than one, does currying). The function can be any expression, and arguments can be any expressions, with commas in between. If it is not a function, then the result is always going to be zero.
* ^expr The successor of a natural number. If it is a function, it makes the new function by passing the successor of whatever argument is passed to the new function as the argument to the old function.
== Extensions ==
=== Halting oracle ===
=== Interactive I/O ===
=== Throw/catch ===
== Examples ==
FIBO(N): X,Y=0,1; N[PLUS(X=,Y); X,Y=Y,X]; X.
COMPOSE(F,G,X): F(G(X)).
EQUAL(X,Y): NOT(PLUS(MINUS(X,Y),MINUS(Y,X))).
NOT: MINUS(1).
TIMES(X,Y): A=0; X[PLUS(A=,Y)]; A.
MINUS(X,Y): Y[PRED(X=)]; X.
PLUS(X,Y): Y[^X=]; X.
PRED(X): A,B=0; X[B[^A=]=1]; A.
CONST(X,Y): X.
SUBST(X,Y,Z): X(Z,Y(Z)).
CHURCH(X,Y,Z): X[Y(Z=)]; Z.
UNCHURCH(X): X(SUCC,0).
SUCC(X): ^X.
Category:LanguagesCategory:2015Category:Unimplemented
Number2D

Number2D is esoteric programming language by User:ChuckEsoteric08 that uses ONLY numbers!
==Commands==
Command	Description
1 	If the current direction is right, set it to down; if it is left, set it to up; If down, set it to right; if up, set it to left.
2 	If the current direction is right or down, set it to left; otherwise, if left or up, set it to right.
3 	Flip the current bit and move the cell pointer one step right.
4 	Move the cell pointer one step left.
5 	If the current bit equals 0, skip the next instruction.
6 	Gather the next 8 bits, commencing from that under the cell pointer, interpret these as an unsigned byte value, the current cell value furnishing the most significant bit (MSB), and output the character whose ASCII code corresponds to the same.
0 	Immediately stop the program.
If the instruction pointer (IP) is outside of the program's bounds, then wrap its trajectory around and continue from the opposite side.
==Examples==
===Example 1===
 1
 21
 0
It will set the direction to down, set the direction to left, then up. Because the IP is outside of the program, it moves back from the down side, then the program stops.
===Example 2===
This shows how to make control program flow:
 3510
 4
 3
 0
It flips a bit and moves the cell pointer to the right. Because the bit is zero, the direction is not set downwards, hence the program halts.
Let's add 4 after 3
 34510
 4
 3
 0
It flips a bit and moves pointer to the right. Then it sets the direction to down, because current bit is not 0. It will move pointer to the left and flip it, then the program stops.
===H===
Outputs "H"
 334334333433433434444444460
==Computational class==
It is Turing-complete, because you can translate it to BitChanger, but with output
BitChanger	Number2D
} 	3
[ and ] 	Changing directions. Example of it above
< 	4
==Interpreter==
* Common Lisp implementation of the Number2D programming language.
Category:Languages Category:Turing complete Category:Turing tarpits Category:Two-dimensional languages Category:Output only Category:2022 Category:Implemented
NumberPankackes

==NumberPankackes==
NumberPankackes is a stack-based esoteric programing language.
==Commands==
 1X: pushes X to the stack (you must have a colon at the end of the command)
 2 coppys the top of the stack and pushes it
 3 flips the stack
 4 pushes user input to the stack
 5 pops the top value of the stack and adds it to the value below it
 6 pops the top value of the stack and prints it
 [ sets the start of a loop (you cant have loops in each other)
 ] returns to the start of the loop
==Example programs==
===cat program===
 46
this program takes user input then prints it
===top poper===
 [1-1:5]5
this program pops the top value of the stack
by subtracting 1 from it until it's zero, 
pops it and adds it to the value below it
===stack printer===
 310:3[6]
this prints and empties the stack by
fliping it, pushing a zero, fliping it again and finaly poping and printing the top value until it's 0
===interpreter download===
https://github.com/TinyGuy32/NumberPankackes
Category:Languages
Number Seventy-Four

Number Seventy-Four is a string-rewriting esolang by User:PythonshellDebugwindow.
==Memory==
Number Seventy-Four uses an unbounded datastring, initially empty, with the alphabet {0, 1, H}. The program is run in an implicit loop which ends only when the first character of the datastring is H. At the end of the program, the datastring is output.
==Commands==
Each character is one command. Characters not listed here are undefined behaviour.
Character	Command
0 	Prepend 0 to the datastring
1 	Prepend 1 to the datastring
H 	Prepend H to the datastring if the first character in the datastring is 0
==Example: Truth-machine==
Replace ? with your input.
 ?H
==Implementations==
A Ruby interpreter and Lean interpreter by User:Bangyen located here.
Category:Languages Category:2020 Category:Implemented Category:String-rewriting paradigm Category:Output onlyCategory:Finite state automata
Number factory

:Not to be confused with Number Factory.
Number factory is an esolang by user:tommyaweosme
== Commands ==
 - path
 | path
 / path
 \ path
 > diode/bridge
 < diode/bridge
 ^ diode/bridge
 v diode/bridge
 1-4 number starting place
 a add
 m multiply
 o(n) output as letter (n)st
 p(n) output as number (n)st
 q(n) output as ascii (n)st
== Constants ==
At Number factory/constants.
== "Hello" program ==
 4---\>------\
 a----o2 |
 1---/ /-v---/
 | | 
 3-----a>v---v-o1
 v || 
 | |\
 | |a|
 o5-a----<|--o4
 o3
Number factory/constants

q is where output is
1
 1q
2
 2q
3
 3q
4
 4q
5
 4a1
 q
6
 4a2
 q
7
 4a3
 q
8
 4m2
 q
9
 4m2
 aq
 1
10
 4a1
 mq
 2
11
 4a11
 m-a
 2 q
12
 4m3
 q
13
 4m3
 aq
 1
14
 4a3
 mq
 2
15
 4a1
 mq
 3
16
 4m4
 q
17
 4m4
 aq
 1
18
 4a2
 mq
 3
19
 4a21
 m-a
 3 q
20
 4a1
 mq
 4
21
 4a3
 mq
 3
22
 4a1
 m-m2
 2-aq
23
 4a1
 m-m2
 23aq
24
 4a2
 mq
 4
25
 4a1
 mq
 4a1
26
 4a1
 /m4
 |4a2
 \-aq
100
 5a2
 m
 5a2
Number hyperlist

Number hyperlist is a data type I invented which improves on the length of number then the number list thing, aka 112123123, which would be 1, 12, 123
== The stuff different about it ==
 0 usually just does nothing in the other thing I was refering about, but I will make it do stuff
 if you put 0 then 2, then it will contain 2 list items,
 the list items contain the number of things in it, then the stuff in it,
 which will be in the length number then number format
 example
 022111221314
 this would be [[1, 2], [3, 4]]
 this would be useful for cloud variables in scratch when you need lists in lists to be transported between computers