nyuuzyou/wikis huggingface dataset:
NONE

NONE is an esoteric programming language created in 2023. It can output letters, numbers and special characters and is inspired on other esoteric languages like Brainf*ck.
==Syntax==
NONE works with 14 allowed characters: + - c p n s m ( ) _ ^ v x t
The syntax of NONE works with an index that is set to zero at the beginning. It can be increased or decreased:
NONE	Description
++ 	Increases the index by 1
-- 	Decreases the index by 1
+v 	Increases the index by 5
-v 	Decreases the index by 5
+x 	Increases the index by 10
-x 	Decreases the index by 10
+t 	Increases the index by 20
-t 	Decreases the index by 20
v stands for 5, x for 10 and t for 20.
===Print===
The letter that has the current value of the index as a position in the alphabet can be output with Print (p). So if the index is 1, the letter will be "a" or if the index is 26, the letter will be "z".
===Clear===
With Clear (c), the index can be reset to 0
===Whitespaces===
Whitespaces can be made with _
===Capitalized letters===
Letters can be capitalized by putting ^ before Print (p)
===Numbers===
Numbers can be written by writing n() and putting a number as a NONE index between the parentheses. +x and +t are not allowed. It will be output immediately even without print
===Special characters===
Special characters can be written in the same way as numbers, only s() must be written instead of n()
NONE 	character
s(++--) 	_
s(++) 	.
s(++++) 	!
s(++++++) 	?
s(+v--) 	,
s(+v) 	:
s(+v++) 	(
s(+v++++) 	)
s(+v++++++) 	@
s(+v++++++++)	#
===Mathematical characters===
Mathematical characters can be written in the same way as numbers and special characters, but with m()
NONE 	character
m(++--) 	$
m(++) 	+
m(++++) 	-
m(++++++) 	*
m(+v--) 	/
m(+v) 	=
m(+v++) 	%
m(+v++++) 	^
m(+v++++++) 	<
m(+v++++++++)	>
==Examples==
A few examples written in NONE
===Hello World!===
A Hello World program in NONE:
+x----^pc+vp+v++++pp++++++p_+v++++++^p-v------p++++++p-v--pc+v--ps(++++)
===NONE===
„NONE“ in NONE code:
+x+v--^p++^p--^pc+v^p
==Weblinks==
*Source code
*Online Interpreter
*NONE Generator
Category:Implemented Category:Output only Category:Total Category:Unusable for programming
NOPQ

NOPQ is an extension of NOP (esolang) by User:None1.
==Commands==
Other than the command NOP, this esolang has an additional command QUINE, which prints QUINE. This allows the language to have non-empty quines.
==Example Programs==
===Quine1===
 QUINE
===Quine2===
 QUINE
 QUINE
==Interpreter==
===Python===
while 1:
 try:
 a=input()
 except:
 break
 if a=="NOP":
 pass
 if a=="QUINE":
 print(a)
==See also==
* NOP (esolang)
Category:Languages
Category:Total
Category:Output only
Category:Unusable for programming
Category:Implemented
NOPQRST

NOPQRST is a programming language designed to do nothing. It is a push-down automaton.
== Instructions ==
NOPQRST operates on an unbounded stack of values.
As the name of the programming language says, NOPQRST only uses the letters N, O, P, Q, R, S and T. 
There are 5 data types in NOPQRST:
The null data type is represented by the letter N. It occurs on stack underflows.
There are also 'quining constants' that represent the whole source code (Q), regular expressions (R), strings (S) and types of other values (T).
So here are the instructions:
 N - push the null value onto the stack
 O - do nothing.
 P - print the top value of the stack to standard output.
 Strings are printed as normal, regular expressions are converted to strings first (without the //),
 types and null values print nothing, and quining constants print nothing because they are technically not strings).
 Q - push the quining constant onto the stack.
 R - push an empty regular expression onto the stack.
 S - push an empty string onto the stack.
 T - Unless the stack is empty, pop a value and push its type.
== Examples == 
Print an empty string:
 SP
Push 10 nulls onto the stack:
 NNNNNNNNNN
Self interpreter:
 
Interpreter in Python:
 
or:
 pass
Category:LanguagesCategory:Joke languagesCategory:Unusable for programmingCategory:Push-down automataCategory:Implemented
NOP (esolang)

:Not to be confused with the NOP instruction.
NOP is an esolang created by User:None1, and it is the world's third Nihilistic language (the first two are Nil and APLWSI).
==Commands==
There is only one command, which is NOP, which does nothing, other strings are ignored.
==Example Programs==
===Do Nothing===
 NOP
===Do Nothing 2===
 NOP
 NOP
===Do Nothing 3===
 12343
 45445
===Quine===
===Self Interpreter===
In fact, any program in this esolang is a self interpreter.
==Interpreters==
===Python Interpreter which is also a JavaScript Interpreter which is also a Brainfuck Interpreter===
===More elaborate Python interpreter, but unfortunately it is incompatible with other languages===
while 1:
 try:
 x=input()
 except:
 break
 if x=="NOP":
 pass
===Another Python interpreter===
 while 1:input()
Category:Languages
Category:Unusable for programming
Category:Nope. derivatives
Category:Total
Category:Joke languages
Category:Low-level
Category:No IO
Category:Implemented
Category:No-code esolang
NOR Machine

NOR Machine is an esolang made by Unname4798.
== Command ==
Two commands only:
 [number] push [number]th bit of user input into the stack
 n pop two top bits, push NOR of two top bits
After all instructions have been done, output all bits from top to bottom from the stack to the console.
== Examples ==
NOR gate:
 0 1 n
NOT gate:
 0 0 n
OR gate:
 0 1 n 0 1 n n
AND gate:
 0 0 n 1 1 n n
Category:Languages
Category:2025
Category:Stack-based
NOT A PROGRAM

It is unknown whether an interpreter exists or even the name of this programming language, but I wrote some programs in it (a long time ago, I can't remember what for!)
==Examples==
A program which does not copy its input to its output:
NOT A PROGRAM =NOT '[ This program does not copy input to output ]|
:MIDDLE
oo(copy 3 211/23: come from)
next back (l2)] +3=?
r=*4$r.8D8.s.s/SA\\-->>>9@
subsdump
dump#
ex.example.o.mal_object
IF BEGIN
Another example, which has an unknown use:
)rewind:12
- re: d(copy 3: back: *):d=$.$S-a?(4%++5+)
ts
C
k& se i@start.mal_object /] }exit
to: k aw
IF;
*em
l 3:|; JIS.util $: *em
' ^start.start^start^() (3//1/?) \n
outer 9
~(come from ) (4%?) | ~(record"0)
"
"EXPONENT
oe.example2
Category:Languages
Category:Joke languages
Category:Usability unknown
Category:Unknown computational class
NPFuck

NPFuck is a Brainfuck derivative made by Cortex designed to be as hard to implement as possible.
== How to write an NPFuck program ==
First, write the number of memory cells (in base 52) using this calculator and these digits:
sAPraEm37eCjd0z24R1KIcTixqbH5pNJfVvQX9gwknZhUDLuyFl8YBOoGMWtS6
Then, append the @ character if the code is being run on a day of the week after Wednesday, otherwise prepend #$ and append ([)]
== Commands ==
Character	What it does
< 	Move the memory pointer left if the first argument of the interpreter function is not a function that always returns 1, otherwise become Unlambda.
> 	Move the memory pointer right.
 	Increment the cell under the pointer by 3i+√5 if preceded by an ampersand. Otherwise, increment by 2.
_ 	Decrement the memory cell under the pointer by 1.5.
+ 	Increment the memory cell under the pointer by the value of the first 11 bits of the kernel space of the user's machine as a binary number.
# 	Quad-palindromize.
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Category:Languages Category:Unimplemented Category:Cell-based
NRSRSSOMN

NRSRSSOMN (Nameless Random String-Rewriting Systems Scribbled On Math Notebook) are a collection of string-rewriting systems created by User:EzoLang. They are presented here in a loose time/feature order.
== NRSRSSOMN-0 (< and >) ==
In the most basic form, there are only 2 commands: < and >. < copies into the new string the symbol to its left, except if it is in the leftmost position of string, in which case it does nothing. > works the same as <, but copies from right instead. From this it is pretty trivial to see that that all NRSRSSOMN-0 programs will terminate, and the maximum amount of memory used will never exceed that of the seed string. This level can be easily simulated by the one-dimensional CA W184, in fact, they are essentially the same.
== NRSRSSOMN-1 (<, > and x) ==
Same as NRSRSSOMN-0 but also adds one additional command, x. When run, it will append the symbols from both its sides to the next string. NRSRSSOMN-1 programs that run infinitely are easy to construct, for example xx, xx< and >xx<. Also, most non-halting patters in NRSRSSOMN expand, thus it cannot be simulated with a Bounded-storage machine and if author is not wrong, shows that NRSRSSOMN is at least in the level of PDA computationally.
== NRSRSSOMN-2 (<, >, x and |) ==
Again, old commands stay the same. | makes symbols operating on it act like the entire rest of line - including the | itself - is one symbol to be copied. For example, >|> would copy |> to the output. Author is pretty sure NRSRSSOMN-2 has higher computational class than NRSRSSOMN-1, but cannot prove it. At least there are more interesting patters in it.
== NRSRSSOMN-3 (<, >, x, | and ()) ==
Brackets act kinda like | but they are effective to only one direction, from "outside" to "inside". On the other direction, the brackets are just skipped over like they didn't exist. Also, the effect of brackets doesn't necessarily last until the end of line, but can be terminated by single bracket that "closes" the brackets. Brackets don't need to be balanced, thus the > in >(a(b)c) only copies (a(b).
== NRSRSSOMN-4 (<, >, x, |, () and []) ==
Square brackets function the same as normal ones, except that they need to be balanced. Thus > in >[a[b]c] will copy [a[b]c], while in >(a(b)c) the c) part would be left off. With these, x can be implemented as [<>], making it redundant but kinda nice syntactic sugar.
Category:String-rewriting paradigm
Category:Unimplemented
Category:2014
NTFJ

NTFJ is a minimalist language created by User:Conor O'Brien. It originally had four commands: NAND, TRUE, FALSE, JUMP. These were the basis for its name. The language operates on a stack by manipulating bits and integers.
NTFJ has 13 commands:
Command	Name 	Explanation
| 	NAND 	Pops two values A and B and pushes A NAND B; if A and B are both bits, it pushes 1-(A&B); otherwise, it pushes 255-(A&B).
~ 	FALSE 	Pushes 0 to the stack.
# 	TRUE 	Pushes 1 to the stack.
^ 	JUMP 	Pops n, jumps to the nth command.
@ 	BYTE 	Pops eight values V1...V8 and pushes the number V1*(2^7) + ... + V8*(2^0) OR, if V1 > 1, pushes the bits in that number.
( 	PEEK 	If the top value of the stack is 0, jumps to the next ).
) 	ENDPEEK 	Closes a ( command.
$ 	DROP 	Drops the top value of the stack.
: 	DUP 	Duplicates the top value of the stack
/ 	LENGTH 	Pushes the number of items in the stack.
{ 	ROTATE 	Pops N; shifts the stack and pushes it to the front N times.
} 	REV ROTATE	Pops N; pops from the stack and unshifts it N times.
` 	DEBUG 	Displays the program's state.
The normal logical operators are representable in NTFJ:
* Logical negation is :|: (A NAND A) = NOT (A AND A) = NOT A.
* Logical conjunction (and) is |:|: NOT (A NAND B) = NOT NOT (A AND B) = A AND B.
* Logical disjunction (or) is :|#}:|#{|. #} and #{ simply poke around the stack and focus on B and </code>A</code> respectively. (NOT A) NAND (NOT B) = NOT ((NOT A) AND (NOT B)) = A OR B.
== Computation class ==
It is thought that NTFJ is Turing Complete, as it bears a remarkable resemblance to Etre.
== Minification ==
One can begin to remove some commands from NTFJ. The following commands are superfluous ` *.
# is equivalent to ~~|, or 0 NAND 0.
$ is equivalent to ~|:||, which converts the top of the stack into 1, then negates it into 0, then NAND's the resulting value. A NAND 1 = A, so the top value is ignored.
Thus, the following 9 commands are left:
 | ~ ^ @ ( ) : { }
@ is needed to jump, and : is needed to produce more values on the stack.
Category:2016
Category:Implemented 
Category:Languages
Category:Unknown computational class
NULL

NULL is a programming language in zero dimensions. Programs in it are single positive integers of arbitrarily large size.
==Runtime environment==
The environment available to a NULL program consists of three queues of bytes, initially empty, and two arbitrarily large integer variables, x and y. x is set to the program, while y is set to 1.
Then x is divided by its smallest prime factor, y is multiplied by the same, and the instruction corresponding to the prime factor is executed.
==Instructions==
2 	Select the next queue (wrapping around).
3 	Select the previous queue (wrapping around).
5 	Output the byte at the front of the selected queue (NUL if the queue is empty). NUL is '\0' (ASCII character 0).
7 	Input one byte and replace the value at the front of the selected queue with it; or, if the selected queue is empty, enqueue the value there. It is currently undefined what to do when EOF has been reached.
11	Subtract the byte at the front of the selected queue (0 if the queue is empty) from y. If this makes y less than zero, y is set to 0.
13	Add the byte at the front of the selected queue (0 if the queue is empty) to y.
17	Add y mod 256 to the byte at the front of the selected queue, or enqueue y mod 256 there if the queue is empty.
19	Remove the byte at the front of the selected queue (use 0 if the queue is empty) and enqueue it to the rear of the next queue (wrapping around).
23	Remove the byte at the front of the selected queue (use 0 if the queue is empty) and enqueue it to the rear of the previous queue (wrapping around).
29	Remove the byte at the front of the selected queue.
31	Enqueue y mod 256 at the end of the selected queue.
37	If the selected queue is empty or the byte at the front of it has a value of 0, divide x by its smallest prime factor and multiply y by that number.
41	Switch the values of x and y.
43	End the program.
The instructions loop for every 14th prime number, meaning, for instance, 47 is equivalent to 2.
==Examples==
===Hello, world!===
This 170-digit number prints the words Hello, World!.
 18090462148251759497492444420325028573004825667450262208483921113691874262881209
 11270348382658758112435115975300629489467941484939334913482219468626524471028850
 8550347259
===Cat program===
This 5-digit number is a cat program. Note that its behavior on end of file is undefined.
 42539
===Truth-machine===
 461190218321951113117134453091156860683
==External resources==
* 
* NULL interpreter in Python, with mirror in the Esoteric File Archive
* NULL interpreter in Rust
==See also==
* EINE, one-dimensional NULL.
Category:Zero-dimensional
Category:Implemented
Category:Low-level
Category:Queue-based
Category:Languages
Category:Non-textual
Category:Unknown year
NUMBRS++

NUMBRS - Two-dimensional made in Scratch esolang by ChuckEsoteric08.
This Esolang have this name because most of Commands in this language is numbers
==Commands==
 1 - Set Direction to 90
 2 - Set Direction to -90
 3 - Set Direction to 180
 4 - Set Direction to 0
 5 - change accumulator by 1
 6 - change accumulator by -1
 7 - input number and push it to the stack
 8 - Pop from top of the stack(As a letter from table) 
 9 - Push accumulator to the stack
 0 - Set accumulator to 0
 / - Back to start of the program
 \ - Go to End of the program
 ? - if acc<top of the stack go to previous command
 ! - End Program
 (space) - Split Lines(because your program need to be written in one line, interpreter split it)
==Examples==
===Cat program in one line===
 1782
===Infinity Loop(in one line)===
 13 24
===Infinity Loop(in multiple lines(you don't need to add spaces after pasting to interpreter))===
 13 
 24
===Forever add 1 to accumulator===
 152
===Print "A"===
 598!
==Turing Completeness==
Maybe.
==Table==
 ABCDEFGHIJKLMNOPQRSTUVWXYZ !,.()1234567890@#$%^&*-_=+/\
==Exterenal Resources==
Scratch interpreter
Category:Languages Category:Two-dimensional languages Category:Implemented
NUMPAD

NUMPAD is a programming language designed by Kevin Albrecht in 2002. While not explicitly esoteric, it is fairly unusual. Arbitrary streams of letters are valid NUMPAD programs; each is interpreted a number as if it were keyed in on a telephone number pad.
==External resources==
* NUMPAD - The Telephone Number Pad Language
* Interpreter download
Category: Languages
Category: Implemented
Category: 2002
N Bits, N2^(N-1) Bytes

N Bits, N2N-1 Bytes is an attempt at a _ Bits, _ Bytes esolang that can increase its amount of bits per command over time, made by User:PkmnQ. It starts out with 2 bits for a command, but contains an "expand" command that expands the amount of bits per command. Its expansion command is also vaguely inspired by Finite-state mach... wait, WHAT!?.
== Control Flow ==
If the program is empty, it halts immediately. Otherwise, the program is looped infinitely, so the program 01101 is ran as 011010110101101.... This is true even if it splits between a command and an argument, or even inside a command/argument.
== Initial Commands ==
Bits	Name	Description
00 	EXP 	EXPands the language, redefining commands based on the current memory units (e.g. If the language is currently at 3 bits and the first three memory units are 000001 010011 100101, 0000 is defined as running 000 001, 0001 is defined as running 010 011, and 0010 is defined as running 100 101.) The current expansion buffer is erased and used as the new program. Control does not return to the original program after the expanded program halts.
01 	INC 	Takes a memory quarter as an argument and INCrements it.
10 	JMP 	Takes a memory quarter as an argument, and if the memory quarter is 0, JuMPs forward to after the next JuMP command and its argument, otherwise doing nothing.
11 	BUF 	Takes a memory quarter as an argument and appends its bits to the expansion BUFfer.
== Memory ==
Memory is entirely made up of bits, which can either be divided into 4 quarters of 2nn bits for INC, JMP, and BUF, or into 2n+1 units of 2n bits for EXP if n is the amount of bits each command has. In total, there are 2n+2n bits, or 2n-1n bytes of memory. For example, for 3 bits, memory is split into units like this:
 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000
And this is how it is split into quarters:
 000000000000000000000000 000000000000000000000000 000000000000000000000000 000000000000000000000000
=== After Expansions ===
Memory is transferred between expansions based on units. Each unit has 2 0's prepended to it making the first half, and the latter half of units are filled with all 0's. For example, from 2 bits to 3 bits:
 abcd efgh abcd efgh abcd efgh abcd efgh
 00abcd 00efgh 00abcd 00efgh 00abcd 00efgh 00abcd 00efgh 000000 000000 000000 000000 000000 000000 000000 000000
Category:Languages Category:Unusable for programming Category:Unknown computational class Category:No IO Category:Unimplemented
N Refine

N Refine is an OISC esolang by User:PythonshellDebugwindow.
==Syntax and Semantics==
Each N Refine program is a series of unbounded space-separated integers. Each command takes up two of these integers; let's call these integers A and B. If A is 0 (notwithstanding number redefinition), then the program jumps to position 2B, as each command takes up two integers. If A is nonzero, however, a random number is then picked from \{0, 1\}: if the number is 0, then it redefines the number A to be the number B; if the number is 1, then it redefines the number B to be the number A.
==Example: infinite loop==
 0 1 0 0
==Computational class==
Unknown; numbers can be used for storage, but storage is probabilistic, and all jumps are absolute.
==External resources==
* An interpreter on GitHub
Category:Languages Category:2020 Category:Implemented Category:OISC Category:Nondeterministic Category:Probabilistic Category:No IO Category:Unknown computational class Category:Usability unknown
Nagawooski

Nagawooski, also called nagawooski, is a trivial bf substitution created by User:PixelatedStarfish for giggles. The programming language is named for a nonsense word coined in a season 5 episode of Big Mouth. 
==Command Table==
Command	Substitute	Description
> 	na 	Move the pointer to the right
< 	ga 	Move the pointer to the left
+ 	woo 	Increment the memory cell at the pointer
- 	ski 	Decrement the memory cell at the pointer
. 	an 	Output the character signified by the cell at the pointer
, 	ag 	Input a character and store it in the cell at the pointer
[ 	oow 	Jump past the matching ] if the cell at the pointer is 0
] 	iks 	Jump back to the matching [ if the cell at the pointer is nonzero
==Hello World==
 
 woowoowoowoowoowoowoowoooownawoowoowoowoooownawoowoonawoowoowoonawoowoowoonawooga
 gagagaskiiksnawoonawoonaskinanawoooowgaiksgaskiiksnana
 annaskiskiskianwoowoowoowoowoowoowooananwoowoowooannanaangaskianga
 anwoowoowooanskiskiskiskiskiskianskiskiskiskiskiskiskiskiannanawooannawoowooan
Category:Brainfuck equivalents Category:2021 Category:Languages
Nah

Nah is a turing complete esolang made by User:Robotosaurus6502 on December 23 2024, It's stack base and has normal memory that can be accessed using the Get and Set commands, This was created as a joke in the esolang channel on the Truttle1 discord server.
== Commands ==
The number a "Nah"s before a per "Yeah" determines the number, So
 Nah Nah Nah
 Yeah
 Nah Yeah
would be come
 3, 1
Here's the list of commands
 Commands
Number	Name 	Definition
0-9 	Push 	Pushes 0-9
10 	Add 	Pops two values, Adds them, And then pushes the result
11 	Subtract 	Pops two values, Subtracts the first one from the second one, And then pushes the result
12 	Delete 	Deletes the top value
13 	Swap 	Swaps the top two values
14 	Duplicate	Duplicates the top value
15 	Output 	Pops a value and then outputs it as a Unicode character
16 	Input 	Takes a character from the user and pushes it as a Unicode value
17 	Jump 	Pops a value and jumps to it zero base
18 	Positive 	Pops a value and pushes 1 if it was greater than 0, Else pushes 0
19 	Zero 	Pops a value and pushes 1 if it equaled 0, Else pushes 0
20 	Negative 	Pops a value and pushes 1 if it less than 0, Else pushes 0
21 	If Skip 	Pops a value, And skips the next command if it equaled 1
22 	Set 	Pops two values, And then Sets a address in memory addressed by the first value to the second value
23 	Get 	Pops a value, And then uses that value as a address to get a value from memory
== Example programs ==
=== Cat program ===
 Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Yeah
 Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Yeah
 Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Yeah
 Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Yeah
 Yeah
 Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Yeah
 Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Yeah
 Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Nah Yeah
== Notes ==
This page was made in a Rush so there's not much
Category:Turing complete Category:2024 Category:Stack-based Category:Unimplemented
Nairb

Nairb is a brainfuck derivative by User:Ivancr72.
==Overview==
2 new commands, : (print decimal) and = (set to zero). And some commands have a optional numeric argument.
For example, +>5 equals to +>>>>>.
 +4=6+: --> 7
 :72 --> H
==Documentation==
Here.
==Interpreter==
It's WIP, but feel free to make your own.
Category:Languages
Category:Brainfuck derivatives
Category:Works-in-Progress
Category:2017