nyuuzyou/wikis huggingface dataset:
NameError

NameError is an esolang created by Mihai Popa and inspired by foo : The term 'foo' is not recognized as the name of a cmdlet, function, script file, or operable program. Check the spelling of the name, or if a path was included, verify that the path is correct and try again. which is inspired by bash: foo: No such file or directory. It imitates another Python error which is also common for beginners - Name error.
==Command==
Every command is valid, and prints:
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
NameError: name '[command]' is not defined
==Interpreter==
===Batch===
@echo off
:bad
set /p x=^>^>^> 
echo Traceback (most recent call last):
echo File "<stdin>", line 1, in ^<module^>
echo NameError: name '%x%' is not defined
goto bad
===Python===
print('\n'.join([f' File "<stdin>", line 1\n {i}\n\nNameError: name \'{}\' is not defined'.format(i) for i in __import__('sys').stdin.read().split('\n')]))
===Another Python interpreter===
raise NameError(f"name '{}' is not defined".format(i) for i in __import('sys').stdin.read.split('\n'))
===A third Python interpreter===
 [command]
==See also==
* NameError without a quine
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:2024
Category:Implemented
NameError without a quine

NameError without a quine is an esolang made by Unname4798.
It is similar to NameError, except when you type this:
 Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 NameError: name '[command]' is not defined
It outputs:
 Traceback (most recent call first):
 File "<stdin>", line 1, in <module>
 JustAnError: Why did you imitate the NameError?
Category:Languages Category:Joke languages Category:Total Category:Unusable for programming Category:Output only Category:Unimplemented Category:2024
NameError without a quine with a quine

NameError without a quine with a quine is a derivative of NameError without a quine by User:Tommyaweosme.
when you type this:
 Traceback (most recent call first): 
 File "<stdin>", line 1, in <module>
 JustAnError: Why did you imitate the NameError? 
it outputs this:
 Traceback (most recent call first):
 File "<stdin>", line 1, in <module>
 JustAnError: Why did you imitate the NameError?
and every other command is the same as NameError without a quine
==See also==
* NameError without a quine with a quine without a quine
Category:Languages Category:Joke languages Category:Total Category:Unusable for programming Category:Output only Category:Unimplemented Category:2024
NameError without a quine with a quine without a quine

is a derivative of NameError without a quine with a quine by Unname4798
When you type this:
 JustAnError
It outputs:
 lol no quinz foryou
==See also==
* NameError without a quine with a quine without a quine with a quine
Category:Languages Category:Joke languages Category:Total Category:Unusable for programming Category:Output only Category:Unimplemented Category:2024
NameError without a quine with a quine without a quine with a quine

NameError without a quine with a quine without a quine with a quine is a language derived from NameError without a quine with a quine without a quine by user:tommyaweosme
when you type in this:
 lol no quinz foryou
it outputs:
 sercret quine code
and when you type in this:
 sercret quine code
it outputs
 sercret quine code
but when you type in this:
 secret quine code
it outputs
 take a look back at the original
and everything else works the same as in NameError without a quine with a quine without a quine
==See also==
* NameError without a quine with a quine without a quine with a quine without a quine
Category:Languages Category:Joke languages Category:Total Category:Unusable for programming Category:Output only Category:Unimplemented Category:2024
NameError without a quine with a quine without a quine with a quine without a quine

is an esolang by Unname4798. and a derivative of NameError without a quine with a quine without a quine with a quine. The titles are getting too long!
When you type this:
 sercret quine code
It outputs:
 secret quine code
==See also==
* NameError without a quine with a quine without a quine with a quine without a quine with a quine
* NameError without a quine with a quine without a quine with a quine without a quine with an iterating quine
Category:Languages Category:Output only Category:Joke languages Category:Unusable for programming Category:Total Category:Unimplemented Category:2024
NameError without a quine with a quine without a quine with a quine without a quine with a quine

NameError without a quine with a quine without a quine with a quine without a quine with a quine is a derivative of NameError without a quine with a quine without a quine with a quine without a quine by User:Tommyaweosme no, the language titles never got too long.
the only difference is entering
 lol yes quinz 4me
it outputs
 lol yes quinz 4me
Category:Languages Category:Output only Category:Unimplemented Category:Total Category:2024 Category:Unusable for programming Category:Joke languages
NameError without a quine with a quine without a quine with a quine without a quine with an iterating quine

NameError without a quine with a quine without a quine with a quine without a quine with an iterating quine is an esolang invented by User:None1.
It is NameError without a quine with a quine without a quine with a quine without a quine but if you type:
 secret quine code
It prints:
 Cut it out!
But if you type:
 Cut it out!
It prints:
 Fuck off!
But if you type:
 Fuck off!
It prints:
 Cut it out!
Category:Languages Category:Output only Category:Joke languages Category:Unusable for programming Category:Total Category:Unimplemented Category:2024
Nameless language

:Not to be confused with TLWNN.
The nameless language is an esoteric programming language which only uses the digits 1 and 0 in its source code, making it look like binary. It is based on brainfuck, but adds five additional commands, making it slightly easier for the programmer to perform common tasks.
== Language overview ==
Nameless language operates on an array of memory cells called a tape. There is a virtual pointer which starts off pointing to the first memory cell. Each of nameless language's commands are four digits long and are only made up of ones and zeros. The commands are:
Command	Description
0000 	Move the pointer to the right
0001 	Move the pointer to the left
0010 	Increment the memory cell under the pointer
0011 	Decrement the memory cell under the pointer
0100 	Output the character signified by the cell at the pointer
0101 	Input a character and store it in the cell at the pointer
0110 	Jump past the matching 0111 if the cell under the pointer is 0
0111 	Jump back to the matching 0110 if the cell under the pointer is nonzero
1000 	Add the next command's base 10 equivalent to the current cell
1001 	Subtract the next command's base 10 equivalent to the current cell
1010 	Randomly sets the current cell's value to either 1 or 0
1011 	Reset the current cell's value to 0
1100 	Reset the pointer to point at cell 0
The nameless language interpreter ignores any characters which are not a one or a zero so you can type comments and they won't have any effect on the program. It is worth noting that the command 0001 which moves the pointer to the left, will wrap around to the last cell if it is called when the pointer is over the left most cell of the tape.
== Example code ==
An example "Hello, World!" program written in nameless language:
 00100110001100110000001101100000000000100000001100110011001100110001000101110001
 00110011000100110011001101110000001101000000000000000010010000000000010001000010
 00100010011001000000011100010001000100010100001000100010010000110011001100110011
 001101000001000100110100000000000000000000100100
An example cat program which asks for five letters of input and then outputs them again:
 0101000001010000010100000101000001011100010000000100000001000000010000000100
== References ==
*
*
Category:2012
Category:Languages
Category:Brainfuck derivatives
Category:Joke languages
Category:Implemented
Category:Turing complete
Nandarin

Language by User:Whtspc, based on nand-logic like his earlier language ferNANDo
Programs are made up of 'words' separated by spaces. All words are false by default (when an unknown word is encountered a boolean variable is made with the name of the word and is set to false), except for words starting with character t. Words starting with character 't' are always true, words starting with a 'f' are always false. (even after 'nanding' the word! (Nanding such words will not result in error, but will be overruled by their default value)). Nandarin is an experiment to make poetic (meta-)programs. Nandarin is not turing-complete. 
== commands ==
 t x y z		- let x = y NAND z
 f t x		- print x
 f f t x y	- move program pointer to previous 'x'+1 if y is true
 f f f t x y	- move program pointer to next 'x'+1 if y is true
 f f f f		- halt
== sample programs ==
===Hello, World!===
 fernando two Helloworld
===Truthmachine===
replace the word input with 0 or 1,
 Truthmachine input f f
 f f f t ifzero 0 f f f t ifone 1
 f t INPUT_IS_NOT_EQUAL_TO_0_OR_1 f f f f
 ifzero f t 0 f f f f
 ifone f t 1 f f t ifone t
in the first line this input is set to true,
in the next line program pointer jumps to label depending on which value is set to true,
the third line tackles a wrong input, displays error message and halts,
the line starting with ifzero prints 0 and halts,
the line starting with ifone prints 1 and jumps back to this printing instruction (forever).
Golfed version (THIS PROGRAM ISN'T WORKING! WE'LL BE BACK!)
does not handle wrong input
replace i with 0 or 1
 t i f f f f f t a 0 b t 1 f f t b t a f t 0
== Computational class ==
Due to having fully general control flow and being able to represent any Boolean expression, the only thing holding Nandarin back from Turing-completeness is that it cannot store data anywhere other than a finite number of boolean variables. This makes it a finite state automaton (and in fact any finite state automaton that does not take input can be represented in Nandarin).
Category:Languages
Category:Finite state automata
Category:Output only
Nandypants

Nandypants is a dual-tape bitwise language that ended up, completely accidentally, being extremely similar to brainfuck. It was created by Nathan van Doorn.
There are two tapes, Tape a, and Tape b. These carry a bidirectionally unbounded number of cells, all bits initialized to 0. In this page, "a" shall refer to the bit pointed to in a, and "b" shall refer to the bit pointed to in b.
== Commands ==
 { Moves the pointer of Tape a leftwards
 } Moves the pointer of Tape a rightwards
 < Moves the pointer of Tape b leftwards
 > Moves the pointer of Tape b rightwards
 ^ Stores a NAND b in a
 v Stores a NAND b in b
 Any even number If this is the first occurence of that number, does nothing.
 Otherwise, if a NAND b equals 0, the program returns to the first occurrence of that number.
 Any odd number If this is the last occurrence of that number, does nothing.
 Otherwise, if a NAND b equals 1, the program advances to the last occurrence of that number.
 \ Adds a to the output stream
 / sets b to the next bit from the input stream
== Examples ==
=== Cat program ===
This is a "dirty" cat program, as, in addition to outputting the input, it also keeps a copy of it in both tapes. It does not handle EOF.
 0}/>v>^<<^>^\}^0
== Noryshorts ==
Noryshorts is a variation on Nandypants that uses NOR instead of NAND. NAND and NOR are both Universal Logic Gates, and so any of the sixteen binary logic gate can be synthesized using entirely NAND or NOR gates.
== Turing Completeness ==
It is possible to translate any Boolfuck program into a Nandypants program, hence Nandypants is Turing Complete. Noryshorts probably is, too.
 Boolfuck Nandypants Noryshorts
 + ^ >^<
 , >^>/^<<^ ^>>/^<^<
 ; \ \
 < { {
 > } }
 [ odd number even number > odd number even number <
 ] even number odd number > even number odd number <
Note: this also needs a single "v" at the beginning of the program.
The numbers in "[" should match the corresponding "]" but should otherwise be unique.
Category:LanguagesCategory:2011Category:Cell-basedCategory:Turing tarpitsCategory:Brainfuck derivativesCategory:UnimplementedCategory:Low-level
Nanofunge

Nanofunge, like Nopfunge, is a fungeoid. It's a 2D esoteric programming language base on 3 commands which is a "subset" of Befunge. The goal of it is to discover the minimum number of commands to make a direction-only language Turing-complete.
==Language Overview==
Nanofunge, like Nopfunge, is made out of a two-dimensional playfield which can have any size. The infinite repeating part's size is said at the start.
For example,
 5 5 3 3
 C
 C C<
 CCC C
 C<<C<
 C C
expands to
 C C C C C C C C C 
 C C< C< C< C< C< C< C< C< C<...
 CCC CC CC CC CC CC CC CC CC C...
 C<<C<<C<<C<<C<<C<<C<<C<<C<<C<...
 C C C C C C C C C C...
 CCC CC CC CC CC CC CC CC CC C...
 C<<C<<C<<C<<C<<C<<C<<C<<C<<C<...
 C C C C C C C C C C...
 CCC CC CC CC CC CC CC CC CC C...
 C<<C<<C<<C<<C<<C<<C<<C<<C<<C<...
 C C C C C C C C C C...
 CCC CC CC CC CC CC CC CC CC C...
 C<<C<<C<<C<<C<<C<<C<<C<<C<<C<...
 C C C C C C C C C C...
 CCC CC CC CC CC CC CC CC CC C...
 C<<C<<C<<C<<C<<C<<C<<C<<C<<C<...
 C C C C C C C C C C...
 CCC CC CC CC CC CC CC CC CC C...
 C<<C<<C<<C<<C<<C<<C<<C<<C<<C<...
 C C C C C C C C C C...
 CCC CC CC CC CC CC CC CC CC C...
 C<<C<<C<<C<<C<<C<<C<<C<<C<<C<...
 C C C C C C C C C C...
 CCC CC CC CC CC CC CC CC CC C...
 C<<C<<C<<C<<C<<C<<C<<C<<C<<C<...
 C C C C C C C C C C...
 CCC CC CC CC CC CC CC CC CC C...
 C<<C<<C<<C<<C<<C<<C<<C<<C<<C<...
 C C C C C C C C C C...
==Instructions==
Nanofunge has 3 instructions:
 Caption text
Command	Description
(Space)	NOP
< 	set direction to left
C 	turn clockwise
Program halts on 2 consecutive ineffective <'s (< when direction is already left)
==Computational Class==
Turing-complete, because it can be substituted from Nopfunge.
Nopfunge space and < are trivial.
halt:(4 empty lines before)
 
 
 
 
 C<<< 
 
 <<<<<< 
 C C
 CC CC
right:
 CC CC 
 C C 
 C C< 
 C C 
 CC<C 
 CC< CC 
 CC 
 C C 
 
up:(2 empty lines before)
 
 
 CC C CCCC
 C CC C
 CC< <C 
 C C 
 CC C 
 CC CC 
 
down:(1 empty line before)
 
 C C 
 C CC CC
 C C< C
 CC< <C 
 CCCC C 
 C CCC 
 
 
This proves that Nanofunge IS Turing-complete.
(All conversions accept the directions from the 5th row/column)
==See also==
* Yoctofunge, minimalization of Nanofunge.
Category:LanguagesCategory:2023Category:Turing completeCategory:Turing tarpitsCategory:Unimplemented
Narcissist

A narcissist (or Narcissus program) is the decision-problem version of a quine.
A quine, when run, takes no input, but produces a copy of its own source code at its output. In contrast, a narcissist reads a string of symbols from its input, and produces no output except a "1" or "accept" if that string matches its own source code, or a "0" or "reject" if it does not.
Chris Pressey independently came up with the concept of a narcissist in July or August of 2007. An almost identical (differing only in its accept/reject method) concept of an "inequ" was described by Jasvir Nagra in March 2005. It is not known if the idea is even older.
The concept was intended to simplify reasoning about User:Smjg's idea of a Quineless language (discussed on User talk:Smjg.) Defining a quine requires the definition of programs (as strings over some alphabet) in a programming language which is capable of producing strings (over the same alphabet) as output. Defining a narcissist, however, requires a definition of programs (as strings over some alphabet) which produce an "accept" or "reject" when given some input string (over the same alphabet.) This is much closer to the classical definition of Turing machines as they are studied in computability and complexity theory, as solvers of decision problems. It is hoped that the narcissist concept will allow results from computability to be more easily brought to bear on the idea of a Quineless language.
==See Also==
* Quine
* Bigot
== External resources ==
* by User:Keymaker
*Subleq OISC Narcissus by User: r.e.s. 
* by Jasvir Nagra
Category: Program forms
Nary

Nary (pronounced "enn-airy") is a programming language "skin" that was created by User:Conor_O'Brien. It's purpose is to be very successful at programs that have a source restriction (e.g. do not use any of character X). Nary is based off of the term n-ary, referring to something whose arity is n.
== Concept ==
Nary allows the user to use an arbitrary set of symbols for programming, of which the program only uses. Then, after the set is decided upon, a destination language and source is chosen and the source is encoded (from ASCII) into base N, where N = cardinality of symbol set. After, each number in base N is mapped to the symbol set. For example, a symbol set {g, h, q} would map each of "Hello" into base three padded ([02200, 10202, 11000, 11000, 11010]) then mapped to the symbol set ([gqqgg, hgqgq, hhggg, hhggg, hhghg]).
== Syntax ==
The syntax of Nary is quite simple, and is divided into two parts:
 
# The preamble
# The body
The preamble is defined to be the first "line"; the line can be defined in various ways, depending on the structure of the preamble. The most common is a space-delineated string containing the set, followed by a newline. This newline can be replaced by a duplicate of the last command. If there are no spaces, each command is assumed to be a single character.
The body is then mapped in the process described above.
== Generator and Implementation ==
RegExp.escape=function(s){return s.replace(/[-\/\\^$*+?.()|[\]{}]/g,'\\$&')};function pad(e,q,h=" "){return e.length>q?(e.concat(["."])).slice(-q-1,-1):q==e.length?e:pad([h].concat(e),q,h)}function nary(src,set){max="~".charCodeAt().toString(set.length).length;set=typeof set=="string"?set.split(""):set;return src.split("").map(function(chr){return pad(chr.charCodeAt().toString(set.length).split("").map(function(byt){return set[+byt]}),max,set[0]).join("")})}function toNary(program){set=[];b="";for(i=0;i<program.length;i++){g=program[i];if(g==" "){set.push(b);b=""}else if(g=="\n"||set[set.length-1]==b){set.push(b);break}else{b+=g}}if(set.length==1)set=set[0].split("");program2=program.slice(i+1,program.length);return program.slice(0,i+1)+nary(program2,set).join("");return nary(program,set).join("")}function fromNary(output){set=[];b="";for(i=0;i<output.length;i++){g=output[i];if(g==" "){set.push(b);b=""}else if(g=="\n"||set[set.length-1]==b){set.push(b);break}else{b+=g}}output=output.slice(i+1,output.length);max="~".charCodeAt().toString(set.length).length;for(var i=0;i<set.length;i++){output=output.replace(new RegExp(RegExp.escape(set[i]),"g"),i)}return output.match(new RegExp(".{0,"+max+"}","g")).map(function(e){return String.fromCharCode(parseInt(e,set.length))}).join("").slice(0,-1)}
To create an Nary program, one may opt for any easy way of doing this. In this case, you simply need to create your preamble, then type your program as normal. Set this result into a string (call it s), then call toNary(s). The result is your program.
To interpret an Nary program (call that p), simply call fromNary(p). Call the language that p was written in L. Then, the final result is written in Nary L.
Nathan van Doorn

Nathan van Doorn is an esolanger from England.
He has made the esolangs Brook, COMPLEX, Constantinople, Fueue, Luigi, MIBBLLII, Nandypants, Numberwang and Real Fast Nora's Hair Salon 3: Shear Disaster Download.
==See also==
*User:Taneb is Dr. Doorn's user page on this wiki.
Category:People
Natyre

Natyre is a minimal, one-instruction esolanguage by User:Keymaker. It is the author's attempt to simplify Minsky machines further. The language was invented in 2016 but published in 2017. The language is an Infinitely Branching Counter Machine, a term coined by the author to describe the fundamental difference between this type of new counter machine and the other kind. The main difference here is that Natyre 1.) has an infinite amount of branching conditions whereas ordinary counter machines mostly have only one (such as Minsky Machine's DEC instruction) and 2.) has only one kind of instruction.
==Program and execution==
A program consists of instructions (at least one required), and there is only one type of instruction.
 <identifier> <counter> <branch1> <branch2>
A description of an instruction consist of a unique identifier, a counter, and two branches (which are identifiers, which of course also must exist in the program).
Program execution begins in the first defined instruction. All counters are unbounded and initially 0. The system never halts.
An instruction is executed thus: The counter is increased by one. If the counter's new value is an event-number (see below), execution transfers to branch 2. Otherwise, which is a far more common case, execution transfers to branch 1.
Event-numbers (called such because they cause the other, rarer branching to happen) are numbers that appear according to a simple rule. There is an infinite supply of them, and each is larger than the previous. The first ten event-numbers are 1, 3, 6, 10, 15, 21, 28, 36, 45, and 55. Event-numbers can be generated easily: have integers q and n, both initially 0. Increase n by one, add n to q. Now q is the first event-number. Repeat (n=n+1, q=q+n). This sequnce can be found in OEIS: .
An example program:
 1 A 1 2
 2 B 1 1
At 1, counter A is increased. If it becomes event-number, execution moves to 2. Otherwise, execution moves to 1 (stays in the same instruction, in other words). If execution moved to 2, there counter B is increased. Execution moves to 1 whether B became event-number or not (because both branches point to instruction 1).
==Computatinal class==
The language is Turing-complete. A proof via Minsky Machine translation is offered on the page (see link below).
==External resources==
* Natyre page (thorough explanation of the language and MM translation, MM-to-Natyre translator, interpreter in Python)
Category: Turing complete
Category: Turing tarpits
Category: OISC
Category: Low-level 
Category: Languages
Category: No IO
Category: Implemented 
Category: 2017
Ndef++

Ndef++ is the successor to, and a strict subset of Ndef. It is the native machine language of the Matrix we currently live in.
Unlike its predecessor Ndef, for which any compiler in any language is valid, Ndef++ accepts only a finite (but very large) number of compilers as valid. However, which those compilers are is known only to a select group of 33rd degree freemasons who are sworn to silence.
Category:Languages