nyuuzyou/wikis huggingface dataset:
Noassign

Noassign is a language that (as it should be clear from the name) does not have the assignment operator. In spite of that, it has variables but not a stack or a queue.
== General syntax ==
The Noassign program is a set of lines. Each line is constructed such a way:
 [headings of loops]operator[operand1][operand2];operator[operand1][operand2];operator[operand1][operand2];...;
== Loops ==
A heading of a loop consists of the maximum value of the loop variable and the name of this variable. For example, 10i means that the line will be implemented 10 times and the variable i will have values from 0 to 9.
If a line has several headings of loops it means that the loops are inserted into each other. For example, 10i20j is approximately equivalent to C code for(i=0;i<10;i++)for(j=0;j<20;j++).
== Operators and their operands ==
=== Operators ===
+, -, *, /, % – arythmetic operators (addition, subtraction, multiplication, division and finding of remainder). Each of them has two operands going in the same order as in mathematic formulas.
&, | – bitwise AND and OR respectively, 2 operands.
! – bitwise NOT, 1 operand.
<, =, > – comparison, 2 operands.
: – output, 1 operand.
^ – one-way transfer inside the line, 1 operand (the number of the operator).
_^ – one-way transfer, 1 operand (the number of the line).
? – conditional transfer inside the line, 2 operands: the 1st one is the condition, the 2nd one – the number of the operator.
_? – conditional transfer, 2 operands: the 1st one is the condition, the 2nd one – the number of the line.
_ – repetition, returns its operand.
" – string operator.
Nock

Nock is a low level typeless esoteric functional programming language. It is created to host a slightly higher level typeless functional esoteric language called Hoon, which compiles to Nock.
==Specification==
 1 :: A noun is an atom or a cell.
 2 :: An atom is a natural number.
 3 :: A cell is an ordered pair of nouns.
 4 ::
 5 :: nock(a) *a
 6 :: [a b c] [a [b c]]
 7 ::
 8 :: ?[a b] 0
 9 :: ?a 1
 10 :: +[a b] +[a b]
 11 :: +a 1 + a
 12 :: =[a a] 0
 13 :: =[a b] 1
 14 :: =a =a
 15 ::
 16 :: /[1 a] a
 17 :: /[2 a b] a
 18 :: /[3 a b] b
 19 :: /[(a + a) b] /[2 /[a b]]
 20 :: /[(a + a + 1) b] /[3 /[a b]]
 21 :: /a /a
 22 ::
 23 :: *[a [b c] d] [*[a b c] *[a d]]
 24 ::
 25 :: *[a 0 b] /[b a]
 26 :: *[a 1 b] b
 27 :: *[a 2 b c] *[*[a b] *[a c]]
 28 :: *[a 3 b] ?*[a b]
 29 :: *[a 4 b] +*[a b]
 30 :: *[a 5 b] =*[a b]
 31 ::
 32 :: *[a 6 b c d] *[a 2 [0 1] 2 [1 c d] [1 0] 2 [1 2 3] [1 0] 4 4 b]
 33 :: *[a 7 b c] *[a 2 b 1 c]
 34 :: *[a 8 b c] *[a 7 [[7 [0 1] b] 0 1] c]
 35 :: *[a 9 b c] *[a 7 c 2 [0 1] 0 b]
 36 :: *[a 10 [b c] d] *[a 8 c 7 [0 3] d]
 37 :: *[a 10 b c] *[a c]
 38 ::
 39 :: *a *a
==See Also==
* Ax
==External resources==
* Urbit home
* Github page of Urbit
* Very old motivation documentation on Hoon and Nock
Category:Languages
Category:Implemented
Category:Turing tarpits
NohtyP

nohtyP is an esolang invented by User:None1, st is based on Python, but you use small endian numbers instead of big endian ones.
So, in nohtyP actually represents twelve:
 >>> 21+1
 31
Octal, hexadecimal and binary are the same:
 >>> 0b011+0b1
 7
That is all you need to know about this language.
Category:Languages
Category:Turing complete
Category:2023
Noid

Noid (previously PyText) is a language made by Zayne on April 22nd 2017 but promptly forgot about it. Noid is a substitution cipher.
== Commands ==
. a
! b
? c
, d
> e
< f
{ g
$ h
% i
^ j
& k
* l
( m
) n
- o
_ p
+ q
= r
` s
} t
" u
: v
; w
@ x
[ y
~ z
== Examples ==
Hello World!
$>**-;-=*,
sadly this only prints helloworld as Noid dosen't support upper-case and spaces
PyText
_[}>@}
Billow
!%**-;
mjpjn
(^_^)
Micheal Jordan
(%?$>.* ^-=,.)
== Story ==
One day, Zayne got bored and wanted to create an esotoric programming language. He grabbed a python Brainfuck interpreter and converted it into a new interpreter
He called this language PyText?!. but Noid is just pytext isn't it? WRONG!
PyText's commands were different. Zayne has now created himself a discord server about his stuff, with a Noid program repository! https://discord.gg/hV4YGPm
== Implementation ==
Zayne's amazing interpreter
 import os
 s = open(input("Run Script: "), 'r').read()
 s = s.replace('.', 'a')
 s = s.replace('!', 'b')
 s = s.replace('?', 'c')
 s = s.replace(',', 'd')
 s = s.replace('>', 'e')
 s = s.replace('<', 'f')
 s = s.replace('{', 'g')
 s = s.replace('$', 'h')
 s = s.replace('%', 'i')
 s = s.replace('^', 'j')
 s = s.replace('&', 'k')
 s = s.replace('*', 'l')
 s = s.replace('(', 'm')
 s = s.replace(')', 'n')
 s = s.replace('-', 'o')
 s = s.replace('_', 'p')
 s = s.replace('+', 'q')
 s = s.replace('=', 'r')
 s = s.replace('`', 's')
 s = s.replace('}', 't')
 s = s.replace('"', 'u')
 s = s.replace(':', 'v')
 s = s.replace(';', 'w')
 s = s.replace('@', 'x')
 s = s.replace('[', 'y')
 s = s.replace('~', 'z')
 print ("We have compiled your Noid input and got the result of: ")
 print (s)
== See also ==
* Text to Noid program
Category:2017
Category:Implemented
Category:Output only
Category:Unusable for programming
Noid/decompile

import os
 s = open(input("Run Script: "), 'r').read()
 s = s.replace('a', '.')
 s = s.replace('b', '!')
 s = s.replace('c', '?')
 s = s.replace('d', ',')
 s = s.replace('e', '>')
 s = s.replace('f', '<')
 s = s.replace('g', '{')
 s = s.replace('h', '$')
 s = s.replace('i', '%')
 s = s.replace('j', '^')
 s = s.replace('k', '&')
 s = s.replace('l', '*')
 s = s.replace('m', '(')
 s = s.replace('n', ')')
 s = s.replace('o', '-')
 s = s.replace('p', '_')
 s = s.replace('q', '+')
 s = s.replace('r', '=')
 s = s.replace('s', '`')
 s = s.replace('t', '}')
 s = s.replace('u', '"')
 s = s.replace('v', ':')
 s = s.replace('w', ';')
 s = s.replace('x', '@')
 s = s.replace('y', '[')
 s = s.replace('z', '~')
 print ("We have decompiled your Noid input and got the result of: ")
 print (s)
made by zayne
Back
Noida

Noida is a lame and simple esolang created by User:Saka. It is designed to be simple and easy to write an interpreter for.
Noida is short for "No idea" because I didn't know what to name it.
== Basics ==
In Noida, values are stored in variables. These values can be a string ([My String]) or an int (.3141).
Variables can be accessed using a dollar sign ($MyVar). Variable names cannot contain spaces.
Each instruction must be on it's own line and lines starting with # are comments. Instructions are of the form:
Intruction : Argument1 : Argument2 : etc.
Noida uses curly brackets ({}) as code blocks.
== Instructions ==
=== Instructions ===
Instruction 	Description
new : s 	New variable s (String).
set : v : a 	Set v (Variable) to a (Any).
print : a 	Print a (Any).
input : dt : v	Input to v (Variable) as dt (str/int).
if : c 	If c (Condition/Boolean; see below) execute the code block below.
repeat 	Repeat the code block.
done 	Terminate the program.
=== Booleans ===
Condition 	Description
same a b 	True if a = b, False otherwise.
greater a b	True if a is greater than b, False otherwise.
=== Misc. ===
Instruction 	Description
math a o b* 	Return integer a +;-;*;/ b.
join a b c d...*	Join strings a, b, c, d,...
*There can be no math operations inside math operations and no join operations in join operations.
== Examples ==
=== Hello, World! ===
 print : [Hello, World!]
=== Truth Machine ===
new : i
input : int : $i
if : same $i .0
{
	print : .0
	done
}
if : same $i .1
{
	print : .1
	repeat
}
=== CAT ===
 new : i
 input : str : $i
 print : $i
=== Nil ===
#The computer will always win.
new : n
new : i
new : c
set : $n : .12
print : [It's a fine day to play a game of Nil.]
print : [You go first, carbonface.]
{
 input : int : $i
 if : greater $i .3
 {
 print : [You cheater...]
 print : [You can't fool me with your strange inputs!]
 done
 }
 if : greater .1 $i
 {
 print : [You cheater...]
 print : [You can't fool me with your strange inputs!]
 done
 }
 set : $n : math $n - $i
 set : $c : math .4 - $i
 set : $n : math $n - $c
 print : [I'll take...]
 print : math .4 - $i
 print : [Current left:]
 print : $n
 if : same $n .0
 {
 print : [Boom I won!]
 done
 }
 repeat
}
== Interpreter ==
===Python===
Available on GitHub
Category:Languages
Category:2018
Category:Implemented
Noisett

Noisett is a minimalistic multi-agent middleware, where agents are tiny pattern-triggered peers. These agents are named "Nuts". When they receive a message, they can send other messages, if they're so inclined.
Each Nut is defined in its own text file (extension .nut), that looks like an INI file. A ".nut" file contains sections. Sections start with a name in square brackets, like this:
 example00.nut
 
 [MAIL]
 ...
 
 [LINK]
 ...
 
 [COPY]
 ...
 
 [PROG]	
 ...
		
The MAIL section contains incoming messages, it is the Nut's inbox. The LINK section keeps parts of the network topology. The COPY section is just a clipboard. The PROG section is where the behavior of the Nut is defined. It is possible to create additional sections programmatically.
If the PROG section of a Nut contains the following code...
 example01.nut
 
 [MAIL]
 [LINK]
 [COPY]
 [PROG]	
 * hey * > Hello world
		
... then this Nut will send "Hello world" every time it receives a message with "hey" in it. It's pretty straightforward. Triggers are simple glob patterns, and messages are public: this "Hello world" will always be sent to every Nut connected to this one.
There are no keywords in Noisett, only the following characters have special meanings:
 Noisett special characters list
 
 *	Wildcard
 |	End of line
 +	Check whether message matches an additional pattern
 -	Check whether message does not match a pattern
 
 >	Send a message
 <	Send a message to myself
 ^	Send a message to my Tables
 
 .	Rename myself
 
 [	Choose the current section (create it if needed)
 &	Add something to the current section
 ?	Check whether anything in current section matches a pattern
 !	Check whether nothing in current section matches a pattern
 %	Copy from current section everything that matches a pattern
 ]	Delete from current section everything that matches a pattern
 
 {	Create a topological link
 }	Delete every link matching a pattern
 
 _	Set vector filter pattern
 
 $x	Insert wildcard number x
 =	Insert my name
 @	Insert name of message sender
 €	Insert a pattern that matches everything in current section
 #	Insert name of next section
 §	Insert current section (in message) or clipboard (in section)
 ~	Insert a random element from current section
 "	Insert the following characters (escape)
 |	Insert an End of line
 
These special characters are either standalone or followed by their "arguments".
Some of them are conditions (namely + - ? and !) while some others express actions.
Code lines in the PROG section always start with a pattern. If the current message matches it, we just keep reading the line and executing actions until a condition fails (or until the end of line). Incoming messages are matched against every code line.
== External resources ==
More about Noisett
Category: Languages
Category: String-rewriting paradigm
Category: Turing complete
Category: Self-modifying
Category: Pattern-based
Category: 2015
Noit o' mnain gelb

noit o' mnain gelb is a two-dimensional probabilistic cellular automaton based on Brownian motion. It is heavily inspired by noit o' mnain worb, and it is named after that automaton and the German word for "yellow".
At any given time, the gelb universe consists of a two-dimensional grid. Every square of the grid has exactly one of six materials: rubber (#), metal (space), arsenic (,), boron (.), copper (+), or zinc (-). In addition, every square may or may not contain one object. The two types of objects are holes (^) and electrons (*).
Each tick, a random object is selected, and a random one of the eight adjacent squares is selected. Assuming the object is a hole, what happens is as follows:
* If the adjacent square is occupied:
** by a hole, nothing happens.
** by an electron, both the hole and the electron vanish.
* If the adjacent square is unoccupied, and made of:
** rubber or zinc, then nothing happens.
** metal, arsenic, or copper, then the hole moves into the square.
** boron, then the hole moves into the square if this would result in it being adjacent to an electron.
In any case, if the hole left an unoccupied copper square behind, and that copper square is adjacent to at least one unoccupied zinc square, then a new hole is created on the copper square, and a new electron is created on a random unoccupied zinc square adjacent to the copper square.
The behavior of an electron is the same as that of a hole, except with "arsenic" swapped with "boron", "copper" with "zinc", and (of course) "hole" with "electron".
The following ought to act like a diode, allowing electrons to pass from left to right (and holes from right to left) but not vice versa:
 ##################
 +- .....,,,,, +- 
 .....,,,,, 
 .....,,,,, 
 ##################
Normally, the only way for charge to move from one half of the diode to the other is for an electron on the left side to cancel out a hole on the right side. It's possible for an electron to migrate into the arsenic, or a hole into the boron, but ideally, they won't get very far before being canceled.
This one should act like an NPN transistor:
 ###################
 +- .....,..... -+
 .....,.....
 .....,.....
 #########,#########
 # #
If there are no holes entering the transistor at the bottom, then it is unlikely that any holes will be able to enter the arsenic in the center. Since there are no holes in the arsenic, it won't pass electrons, so current will not be able to flow from left to right or vice versa. If holes do enter the bottom, however, electrons will be able to pass across the arsenic. Of course, some holes will be consumed in the process; this transistor's gain may be so small that it is useless.
Category:LanguagesCategory:2012Category:Two-dimensional languagesCategory:Unknown computational class
Noit o' mnain worb

noit o' mnain worb, devised by Chris Pressey in 2000 and sometimes called "worb" for shorthand, is a two-dimensional probabilistic particle automaton based on Brownian motion. 
==Etymology==
The language was given a name intended to sound like mock Gaelic, while containing a "hidden message". There is no known correct pronunciation of this name.
==Syntax and Semantics==
The worb universe consists of several elements:
 (blank) Empty space
 # Wall
 . Bobule
 ><^v Diodes
 + Source
 - Sink
 ! Load
The "active ingredient" is the bobule; all other elements are passive and static. Bobules are created at sources and destroyed at sinks; they are otherwise conserved. Each tick, each bobule attempts to randomly either move into one of the 8 adjacent spaces, or to stand still. If it cannot move into the space that is randomly chosen because that space is not passable (i.e. that space is already occupied by a wall, bobule, diode, or source,) it stays still. As suggested by their name, diodes only allow bobules to pass through in one direction.
noit o' mnain worb is arguably an esoteric programming language which employs pressure as its main computational mechanism. There are, however, severe limitations involved which make constructing an actual program difficult. It is theoretically possible to design "transistors" or other switches, but in practice they tend to be extremely inefficient, with high leakage.
==External resources==
* 
* Csound plugin
Category:Languages
Category:Implemented
Category:Two-dimensional languages
Category:Nondeterministic
Category:Probabilistic
Category:Particle automata
Category:No IO
Category:2000
Non-specific assignment

Non-specific assignment is a rarely-used abstract concept in esoteric and traditional programming derived from algebraic inequalities and such that allows the programmer to, for example, set a variable x to every value except 5.
== Examples ==
The syntax of the basic (non-augmented) non-specific assignment operators will vary by language, but here's an example list:
Operator 	Meaning
x := 5 	(Traditional) Assign to x the value 5
x :< 5 	Assign to x all values less than 5
x :> 5 	Assign to x all values greater than 5
x :<= 5	Assign to x all values less than or equal to 5
x :>= 5	Assign to x all values greater than or equal to 5
x :!= 5 	Assign to x all values that are not 5
== Implementation ==
NSA can be accomplished by including 3 bits (8 possible combinations) of metadata for every variable assigned. These 3 bits contain a value telling the program what kind of definition that variable corresponds to. All arithmetic operations are simply performed on the value of the operator and the 3 metabits are left the same, and it should work normally. Relational operators are a bit more complicated, but can still be accomplished (though the syntax would get confusing)
== Actual usefulness ==
In violation of the Prime Directive of Esolangs, non-specific assignment could, in theory, actually be useful for representing algebraic inequalities or something.
Category:Concepts
NonSkip

NonSkip is a variant of FakeScript invented by User:ChuckEsoteric08.
== Changes ==
The commands are the same as FakeScript but with one small change:
Every time an instruction is executed, it will execute the argument as instruction. Example:
 print print input
It will print "print", then it will print "input" and then ask for input.
== External resources ==
* Scratch interpreter
Category:Languages Category:Implemented
Nondescript

Nondescript is a programming language by User:PixelatedStarfish. It is a genericized, stack-based, language designed such that it has a simple interpreter. It supports various stack operations with minimal syntax. Riveting, isn't it? It was created for the language Bedtime as a base language. Bedtime compiles to Nondescript.
==Commands==
Commands are simple integers separated by newlines. Arguments for a command are separated by a space.
 -1 - Comment. The '#' can also be a comment.
 0 - Print top of stack
 1 - Print ASCII value
 2 - Print top of stack as ASCII
 3 - Pop
 4 - Push [0 if no argument]
 5 - ADD V to value at top of stack [or 1]
 6 - Label L
 7 - GOTO L (Label) [or start]
 8 - GOTO L if 0 [or start]
 9 - Input. Singer char is default. Use argument 1 for an integer and 2 for a string.
 10 - Duplicate top and push [or push 0 if empty]
 11 - Shuffle Stack [unless empty]
 12 - Halt
 13 - No operation
 
Note that stack values range from 0 to 255. Adding 1 to 255 sets a value to zero.
==Program Examples==
===Hello World=== 
 1 72
 1 69
 1 76
 1 76
 1 79
 1 32
 1 87
 1 79
 1 82
 1 76
 1 68
or
 1 H
 1 E
 1 L
 1 L
 1 O
 1 32
 1 W
 1 O
 1 R
 1 L
 1 D
===Truth Machine===
 9 
 5 -48
 8 0
 6 1
 1 49
 # Can include a no op here
 7 1
 6 0
 1 48
===Random Number (1-10)===
 4 1
 4 2
 4 3
 4 4
 4 5
 4 6
 4 7
 4 8
 4 9
 4 10
 11
 0
==External Links==
*Interpreter
*Repl
Category:Languages Category:2021 Category:Stack-based Category:Implemented
None

is an esoteric programming language. does not even exist and compilers for cannot be created. Thus, is the easiest to learn and simplest language ever made. will always return the correct answer to its input, which in the case of a program must be.
== Example programs in ==
Below is an example program, which prints whatever you want to think.
== History and Legacy of ==
was the first ever programming language. It was accidentally created by [NAMELESS_CAVEMAN_000000003488245A] when they existed, causing the entire universe to become a compiler for. has since become a very famous programming language, and was mentioned in such works as the Bible and the Iliad.
Several attempts at creating compilers have been made, but none of them worked. One notable attempt to compile was a failed lightbulb prototype made by Thomas Edison, which sadly outputted False instead of.
Category:Languages Category:Joke languages
None,

None, is a esolang created by User:Ractangle
==Commands==
 Some, - Starts the program
 None, - End the program
 Maybe? - A condition command
 Possibly? - The action of the Maybe? command
 Sure - Ends the current Maybe? command
 So? - While loop
 <condition> Oh - Ends the While loop
 Yes <string> - Prints the string
 Uhh <math question> - Does a math operation
 Yeah <variable> - Prints a variable
 Say. <varname> <varval> - Creates a variable
 No - Gets user input
==Examples==
===Hello, world!===
 Some,
 Yes Hello, world!
 None,
===Truth-machine===
 Some,
 Say. i No
 Maybe? i==0
 Possibly? Yes 0
 Sure
 Maybe? i==1
 So?
 Possibly? Yes 1
 i==0 Oh
 Sure
 None,
===Deadfish implementation===
 Some,
 So?
 Say. a 0
 Say. n No
 Maybe? n==i
 Possibly? Uhh n + 1
 Sure
 Maybe? n==d
 Possibly? Uhh n - 1
 Sure
 Maybe? n==s
 Possibly? Uhh n * n
 Sure
 Maybe? n==o
 Possibly? Yeah a
 Sure
 Oh
 None,
Category:LanguagesCategory:2024Category:PseudonaturalCategory:Unimplemented
Nop

A nop (sometimes spelled no-op or noop) is an operation in a programming language that does nothing.
While nops are generally useless in most "serious" programming languages (except very low-level ones like machine language, where they can affect timing), they can come in very valuable in esoteric programming languages, often to allow an arbitrary effect at an arbitrary point.
For example, SMITH can only simulate loops by copying code forward, so nops can come in handy as padding. Many character-based languages, such as Brainfuck, consider unrecognized characters to be nops, which allows them to be used for comments (though in this case, they could just as well be considered as whitespace).
Nops are also indispensable in many two-dimensional languages, also as padding; some sort of padding is needed in many programs in order to cause the rows of the program to line up correctly (or the columns, depending on how you look at it). Two-dimensional languages typically consider spaces and any printable characters not otherwise defined to be nops. Exceptions include ADJUST, which has no valid nop instruction, and 1L_a, which has a nop instruction only when travelling rightwards or downwards.
In multithreaded languages, especially those that work in terms of program counters taking turns, nops are useful for timing purposes.
The term nop is also used to refer to any sequence of operations that, taken together, do nothing; for example, the sequence +- in Brainfuck. <> is usually a nop in Brainfuck, but would be illegal if the data pointer is on the first memory cell (workaround: ><); similarly, +- would be illegal in an 8-bit non-wrapping implementation that forbids incrementing 255, if the current cell is 255 (workaround: -+).
The No-op concept is very popular among esoteric programming languages. Several esolangs have been developed to only have no operation commands(under different concepts):
* APLWSI
* Ḃḻḁṇḳ
* Nothing
* Nil
* No-code esolang
* Unnecessary
Even some machine architectures unintentionally fall into this category:
* Swissen Machine
== See also ==
* Null program
Category: Concepts
NopLWSI

NopLWSI is a combination of Nope. and APLWSI, by User:None1. Its goal is to have no quine.
==Execution==
Non-empty programs do nothing. An empty program prints .
==Examples==
===Nope. interpreter===
==Interpereter==
===Python===
 print("" if input() else "Nope.",end="")
Category:LanguagesCategory:Joke languagesCategory:Output onlyCategory:TotalCategory:Unusable for programmingCategory:ImplementedCategory:2023