nyuuzyou/wikis huggingface dataset:
Next

Next is an esolang invented by User:Hakerh400 in 2023.
== Overview ==
In this esolang it is possible to see what the value of a variable will be in the future, based on the assumption that the result is equal to the current value of the variable.
This is a functional language. All variables are global and they can be referenced by names (strings). Values of variables are unbounded signed integers, initially 0.
Builtin functions:
* get_var name - Get the current value of the variable whose name is name
* set_var name val - Assign integer val to the variable whose name is name
* next name n - Get the value of the variable name after exactly n assignments (to any variables)
Standard arithmetical operators are supported (+ - * / < <= > >= == /=), as well as if-then-else statements.
Note that next name 0 is equivalent to get_var name.
== I/O format ==
Input and output are integers. The main function is main. The entire computation is performed inside the Nxt monad, which is just a continuation monad transformer whose inner monad is a state monad.
== Example ==
 main inp = do -- The main function
 set_var "x" 5 -- Assign 5 to the global variable "x"
 x <- next "x" 1 -- Get the value of "x" after 1 assignment (it's 12) <--------------\
 set_var "x" (x + 7) -- "x" is now 19, but it would be 12 if the result of next was 5 ---/
 return x -- This returns 12 because the value of the local constant x is 12,
 -- but the value of the global variable "x" is now 19
== Implementation ==
* Implementation in Haskell
Category:Languages
Category:2023
Category:Turing complete
Category:Functional paradigm
Category:Implemented
Ni

Ni is an esoteric programming language influenced by brainfuck. The name Ni comes from Nicaragua. Created by User:DeybisMelendez.
== Language Overview ==
Like brainfuck, Ni operates on a tape containing cells, cells can store 64-bit integers.
The cells are pointed by a head, the head can move from left to right or jump to a cell directly.
There is also a clipboard where you can store data from one cell and insert any other.
== Commands ==
Command	Description
> 	Move the head to the right
< 	Move the head to the left
+ 	Increment the targeted cell
- 	Decrement the targeted cell
@ 	Reads the first character, converts it to its ASCII number and stores it in the pointed cell
. 	Print the number stored in the targeted cell
! 	Print the ASCII equivalent of the number stored in the pointed cell
# 	Set a hexadecimal number in the pointed cell
? 	Copy the number of the pointed cell
= 	Stores the copied number in the pointed cell
* 	Converts the number of the pointed cell to 0
$ 	Moves the spindle to the cell indicated with a hexadecimal number
[] 	(While) Loop that continues execution if the pointed cell is not equal to 0
{} 	(For) Loop that executes the instructions the number of times that the memory of the pointed cell indicates
() 	(if) Executes the set of instructions if the pointed number is equal to the clipboard
/ 	Ignore the rest of the line
== Examples ==
=== Hello World! ===
 #48!#65!#6c!!#6f!#20!#57!#6f!#72!#6c!#64!#21!#a!
=== Cat program ===
 +[@!#a!]
=== Truth-machine ===
 @>#30[<->-]<.[.]
=== Fibonacci ===
 #a>>+.<<!>>>>#1f{<<?>=<<[>>+<<-]>?<=>>?<=.<<!>>>>}
=== Factorial ===
 #0 /Insert the number to calc, #0 prints 1, #9 prints 362880, etc.
 (+.*)[?>=-[-<{>{<+>}<}>]<.*]
== Computational class ==
Ni is Turing-complete, as ><+-@![] correspond directly to brainfuck's ><+-,.[].
== External resources ==
Official Github page of Ni
Online Interpreter
 
Category:Languages Category:2020 Category:Implemented Category:Cell-based Category:Turing_complete Category:Brainfuck_derivatives Category:High-level
NiceLanguage

This is a language I quickly assembled yesterday,then painfully debugged today.
Implementation https://replit.com/@imcute-aaaa/NicerLanguage 
Notepad++ highlighting https://replit.com/@imcute-aaaa/NicerLanguage#test/nl.xml 
An expression is wrapped in either "(" ")" or "" ";",and "{" "}" is used to indicate a block.(i.e command ring if you use Snap!)
A function is called by putting its name,then a set of parameters.,No using , to delimit.
Strings and numbers are the same in python,except you cannot use single quotes to make strings.
"return" is used like a function,and it can return from a {}(returning from no {} would halt the program)
Lambda is spelled lamda due to it being a keyword in python.
A name mustn't start with a number,be equal to "return",or contain one of " \t\n(){}\";"
A list is made by converting a block containing the list items(just list the expressions making the list,and not add a delimiter) using the "[]" function.
The following functions require block inputs(i.e command slot if you use Snap!,if you really do,it should be immediately obvious why the following functions need block inputs,except the [] function)
* ?:
* loop
* []
* lamda(only the second input)
You can load either python modules or NiceLanguage modules.Use the loadpy or the loadnl.They both take in a single input.
You can also load stdlib modules by loadpy "../lib/stdlib/stdnl"; then stdload 31; 31 loads all of them,and 0 loads none.It is like a bitflag.(normally you would start your program with loadpy "../lib/stdlib/stdnl";stdload 31;)
You make a nl module by defining variables into the global context.(i.e same way as making python modules in a python environment)
You make a python module by using @__context__.define or __context__.invoke.Try to not make global variables and mess up with stuff.
Challenge:Make a HOF module,and a drawing module!
Nightmare

Nightmare is a language created by Otesunki (talk).
 = intro =
 
 nightmare is inspired by malbolge, ndball, brian & chuck, 
 asciidots, and coding job interviews
 nightmare progs are placed within an N dimensional grid,
 where each dimension has a length of 2.
 
 programs have anywhere between 1 and 10 balls[1], each having a specific start point,
 end point, direction, and key[2].
 
 each ball also doubles as a storage unit, containing a binary tree.
 
 on every tick, every ball executes the current instruction[3], encrypts it[4],
 updates its key[5], and goes forward one cell in it's current direction[6]
 
 = format =
 
 each line begins with (, followed by a list of
 comma seperated (with spaces) balanced ternary numbers (T01),
 followed by a ) and a space, and then finally the cell's value.
 
 = instruction reference =
 
 after decrypting, mod 128:
 
 ins | desc
 -----+-------------
 $ | swap branches
 | result: new tree
 # | invert the tree
 | result: new tree
 + | construct a new tree, where the old tree is the left branch,
 | and the right branch is empty
 | result: new tree
 - | traverse down to the left branch of the tree,
 | but remember the other branch
 | result: the right branch of the tree
 ^ | undo -
 | result: new tree
 ? | if the current tree is empty, set the next ball's key to the current ball's key
 | result: current tree
 , | stdin, as an ASCII value, as a surreal number, as a binary tree
 | result: new tree
 . | same as , but the other way around
 | result: current tree
 n/a | segfault
 
 1 - take the RIPEMD-320 hash of the program, mod 10, plus 1
 2 - take each (total amount of balls*2)th character from the source code, and hash.
 start from (ball num) with SHA-512 for the start point,
 (ball num + 1) with SHA-512 for the end point,
 (ball num + 0) with Whirlpool for the direction[2.1],
 and (ball num + 1) with Whirlpool for the key.
 2.1 - take the start point, find all directions that dont segfault,
 use the hash mod that amount to pick
 3 - in order:
 - goes forward in it's direction
 - finds the instruction it's on
 - decodes it
 - decrypts it using ECC with the ball's current key
 4 - new = AES(key, old)
 5 - take the result of the instruction, tack on the current ball's key,
 use the whole thing as the public key for RSA,
 and encrypt the ball's key with it to form the new key
 6 - if any ball goes out of bounds anywhere other than
 its predetermined end space, segfault
 7 - trees are hashed by first converting them 
 into <LEFT:RIGHT> format, then hashing that text.
Category:Languages
Category:Unimplemented
Category:Multi-dimensional languages
Category:Unknown computational class
Category:Usability unknown
Category:Self-modifying
Category:2022
Nikud

Nikud is an esoteric stack-based programming language based solely on the Hebrew Niqqud diacritics by Github user bary12.
Because Niqqud diacritics are combining characters, Nikud programs are typically one character wide. Other characters can be present, but they are ignored by the interpreter.
==Examples==
The following code (336 characters, 672 bytes) outputs Hello, World!
ֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֲֳֳֳֳֳֳֳֳֳֳֳֳֳֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָ
==External resources==
* Github repo and specification
* Try it online
* Wikipedia article on Niqqud diacritics
Category:Stack-based
Category:Implemented
Category:2018
Nil

Nil is the world's first Nihilistic programming language. Essentially, it parses commands of any complexity, and then ignores them.
==Examples==
Here is the traditional Nil program:
 I wandered lonely as a cloud.
A more practical program:
 Please, give a NOP if life is either meaningful or not meaningful.
The shortest known Nil quine:
==Implementations==
One of the most widely deployed Nil interpreters is true, which is shipped as standard with many popular operating systems including GNU/Linux and Mac OS X. The traditional Nil program above (wordsworth.nil) can be invoked thus:
 true wordsworth.nil
Alternatively, since the language syntax allows the use of 'shebang' lines, Nil programmers may wish to adopt the following convention to make their programs directly executable:
 #!/usr/bin/true -w
 I wandered lonely as a cloud.
 ./wordsworth.nil
Notice the use of the -w option in the above example, which turns on compiler warnings; novice Nil programmers are strongly encouraged to make use of this feature. There is also a scratch interpreter:
and a C/C++ interpreter:
int main(){
 return 0;
}
and a Befunge interpreter:
 ,_@
and a Python interpreter:
 pass
and an even shorter Python interpreter:
, which is also the shortest possible Python program. In fact, it works on many other languages (e.g. JavaScript, brainfuck) as well. It is even a self interpreter, but that isn't surprising because any program is a self interpreter. However, this one is the shortest possible.
==Bootstrapping==
Incredibly, despite not being Turing-complete, the Nil language is expressive enough to implement an interpreter for itself, much more concisely than many 'proper' languages can. The example presented here is a simple implementation, but using advanced compression techniques Nil developers have been able to produce working interpreters in as little as 0 lines of code.
 #!/usr/bin/true -w
 My mother had a Flit gun
 'Twas not devoid of charm
 A bit of Flit
 Shot out of it;
 The rest shot up her arm
This can be seen to run any Nil program successfully, including our example programs from above:
 > ./nil_interpreter.nil wordsworth.nil
 > ./nil_interpreter.nil quine.nil
==External resources==
* Nil interpreter (Online) 
* Online client-side Nil interpreter without JavaScript
* Nil website
Category:Languages
Category:Joke languages
Category:Implemented
Category:Unusable for programming
Category:Total
Category:Finite state automata
Category:Nope. derivatives
Category:No-code esolang
Nile

Nile is a declarative stream-processing language designed to implement graphics-compositing toolkits like wikipedia:Cairo (graphics) with a minimum of code. While not strictly a golfing language, Nile was developed as part of the STEPS project at VPRI, which focused on implementing an operating system using relatively little code and relatively many languages.
== Examples ==
The following program implements the syntax `x ~ y` for computing the average of two numbers:
 (a : Real) ~ (b : Real) : Real
 (a + b) / 2
Category:2009 Category:Declarative paradigm Category:Implemented
Nimi pali

nimi pali is a language in toki pona.
==Commands==
toki! is the command you put to start the program.
mi tawa is the command you put to end the program.
o toki e is the print command, for example:
 o toki e ni: Hello, world!
would print "Hello, world!"
o kalama is the input command, that saves the input to the accumulator.
o toki e nanpa retrieves the memory cell of that number and puts it to the accumulator.
toki ni li awen saves the accumulator to the memory. An example:
 o kalama
 toki ni li awen
 o kalama
 toki ni li awen
 o kalama
 toki ni li awen
 o kalama
 toki ni li awen
 o toki e nanpa wan tu
 o toki e toki ni
would ask the user for input four (tu tu) times, and outputs the third (wan tu) memory cell.
toki ni li ante la[] acts like BF's square brackets.
==Examples==
===Hello World===
 toki!
 o toki e ni: Hello, world!
 mi tawa
===Cat===
 toki!
 o toki e ni: o kalama
 mi tawa!
===Truth machine===
 toki!
 o kalama
 toki ni li ante la[
 o toki e toki ni
 ]
 o toki e toki ni
 mi tawa
==Notes==
* The accumulator can hold strings.
Category:LanguagesCategory:2023Category:PseudonaturalCategory:Cell-basedCategory:Unusable for programming
Nine

Nine (Next Line) is an esoteric programming language, created by User:CMinusMinus.
==Instructions==
Instruction 	Action
#VAR.VAL 	VAR = VAL ("_" is replaced with a space)
#VAR+<value>	VAR += <value>
#VAR-<value>	VAR -= <value>
#VAR.* 	VAR = user-input
$VAR$ 	Call a variable
>TEXT 	Print Text
>TEXT* 	Print Text without \n
>$VAR$ 	Print Variable
>$VAR$* 	Print Variable without \n
! 	One line down
end 	End program
B) 	if A = B, one line down
(A%B) 	if A % B = 0, one line down
; 	Begin of a comment, have to be at the start of a line
~INSTRUCTION	Run a command once (Then ignored in main-loop)
A program is running infinitely, until the "end" command.
With this, you are able to easily run a while loop.
Every instruction got no spaces, so its possible to write those next to each other, separated with a space, for example:
 >Hello,_World!
 end
becomes
 >Hello,_World! end
==Examples==
===Hello, World!===
 >Hello,_World! end
===FizzBuzz===
 ~#num.1 #num+1 >$num$
 ($num$%3) >Fizz
 ($num$%5) >Buzz
 ($num$%15) >FizzBuzz
===cat===
 #i.*
 >$i$
===Fibonacci numbers===
 ~#a.0 ~#b.1
 >$b$
 #c.$a$ #a.$b$ #b+$c$
===Swapping the Words "Good" and "Bad" ===
 #word.*
 ($word$|Bad) >Good end
 >Bad end
==External resources==
* GitHub repository
Category:Languages
Category:2019
Category:Turing complete
Category:Implemented
Nine-hundred-eleven

nine-hundred-eleven is a memorial language of 9/11. it was made on 9/11/2024, but uploaded to esolangs on 9/29/2024
== commands ==
 food and water - increments cell at pointer by one
 tower 1 - moves pointer backwards
 tower 2 - moves pointer forwards
 goodbye, fallen americans. :( - brainfuck [
 we will miss you ): - brainfuck ]
 america! - clears cell at pointer
==See also==
* Brainfuck minus -
Category:Languages Category:Pseudonatural Category:2024 Category:Cell-based Category:Brainfuck derivatives Category:Low-level Category:No IO Category:Unimplemented Category:Turing complete Category:Turing tarpits
Nndstojmp

nndstojmp is short for nand, store, jump. It is an OISC that takes 4 parameters. Parameters a and b are the 2 memory bytes which are nanded and the result is stored in memory location c. After this, you jump to memory location d. Location 0 in a or b is input, in c is output, and in d is end program.
==Instructions==
Given the instruction pattern
 a b c d
the effect of parameter values can be summarized in the following:
Parameter	Effect if zero 	Effect if non-zero
a 	Contributes the left NAND operand as the byte at the memory location a. 	Queries the user for a byte as the left NAND operand.
b 	Contributes the right NAND operand as the byte at the memory location b.	Queries the user for a byte as the right NAND operand.
c 	Stores the NAND-combined a and b bytes in the memory location c. 	Prints to the standard output the NAND-combined a and b bytes.
d 	Moves the memory pointer to the memory location d. 	Halts the program immediately.
==Examples==
===Hello, World!===
This program outputs the ASCII character codes comprising the message “Hello, World!”
 53 54 0 5
 53 55 0 9
 53 56 0 13
 53 56 0 17
 53 57 0 21
 53 58 0 25
 53 59 0 29
 53 60 0 33
 53 57 0 37
 53 61 0 41
 53 56 0 45
 53 62 0 49
 53 63 0 0
 255 183 154 147 144 211 223 168 141 155 222
===Interactive NAND===
The following program repeatedly queries the user for two bytes, which are subsequently NAND-combined, ere the result is printed to the standard output.
 0 0 0 1
==Interpreter==
* Common Lisp implementation of the nndstojmp programming language.
Category:Languages
Category:2022
Category:Cell-based
Category:OISC
Category:Unknown computational class
Category:Implemented
Category:Low-level
No.

No. is a Python- or C- or JavaScript- or Text-interpreted, joke programming language created by Vulture001. The sole purpose of the language is to deny the user the command. There is no legal program, as each command returns the same output
==Code examples==
===Hello, World! program===
This is impossible.
===Quine===
 No.
(Really, this is a quine; I'm not saying no to doing a quine.)
==Interpreters==
This is the original interpreter, written in Python.
 res = 'No.'
 while True:
 c=input("no>")
 if "yes" in c:
 print(res)
 else:
 print(res)
This is also a valid interpreter written in Python.
 while True:
 input('no>')
 print('No.')
Here is an interpreter in JavaScript:
function interpret(program){
 console.log("No.");
}
And another interpreter in Text:
 No.
dolfins grace! :D
 >".oN"^^^<
Lua 
 while true do
 io.write("no>")
 local x = io.read()
 io.write("
 ")
 print("No.")
==External resources==
* Interpreter on Github 
* Another interpreter made by DanielE (talk) 21:03, 12 March 2022 (UTC)
==See also==
* Nope.
Category:Languages
Category:Joke languages
Category:Implemented
Category:2020
Category:Total
Category:Finite state automata
Category:Unusable for programming
Category:Nope. derivatives
Category:No-code esolang
No.js

No.js is a joke esolang invented by User:None1, it is like JavaScript, except that prints out instead.
==Examples==
===Hello, World!===
 is unusable, yet you can still use :
 console.warn("Hello, World!")
If you are using browser JS, you can even use :
 alert("Hello, World!")
If you are using Node.js, you can also use 
 process.stdout.write("Hello, World!")
See? There are many ways to output besides 
===No. interpreter===
 console.log("any text can go here")
==Interpreter in JavaScript==
 k=console.log
 console.log=function(){k("No.")}
 eval("<program>") // program goes here
==Computational class==
Turing complete, because JavaScript doesn't need I/O to be TC.
Category:Languages
Category:Joke languages
Category:2024
Category:Implemented
Category:Turing complete
Category:Esoteric subset
No.pe.

No.pe. is a joke programming language inspired by Nope. and No.. Its purpose is to create a Nope. derivative that doesn't allow a quine.
==Syntax==
If the program is exactly "Nope." (without the quotes), the output is "No.". Otherwise, the output is "Nope."
==Examples==
===Nope. Interpreter===
 Hello World!
===No. Interpreter===
 Nope.
===Quine===
This is impossible.
==Interpreters==
Written in Python:
 if input() == 'Nope.':
 print('No.')
 else:
 print('Nope.')
==See also==
* Nope. without a quine
Category:Languages Category:Joke languages Category:2024 Category:Unusable for programming Category:Total Category:Output only Category:Nope. derivatives Category:Implemented
NoCode

NoCode is an esoteric programming language written by User:Dominicentek. It doesn't have any source code.
== How it works ==
This programming language has no syntax. It depends on the interpreter of what program it wants to run.
It can choose between those following programs:
* Hello World
* Truth Machine
* Cat Program
* Fizz Buzz
* 99 Bottles of Beer
* Factorial
* Quine
* Infinite counter
== Programs ==
=== Hello World ===
Prints out the phrase "Hello, World!"
=== Truth Machine ===
Takes input from the user. If it's a 0, it prints 0 and terminates. If it's a 1, it prints 1 indefinitely
=== Cat Program ===
Takes input from the user and prints it out
=== Fizz Buzz ===
Works like a counter. It outputs numbers from 1 to 100. However, if a number is divisible by 3, it gets replaced with "Fizz". If it's divisible by 5, it gets replaced with "Buzz", if it's divisible by both 3 and 5 (15), its replaced with "FizzBuzz"
=== 99 Bottles of Beer ===
It prints the lyrics to the song 99 Bottles of Beer
=== Factorial ===
Takes input from the user as a number. That number is then multiplied by every possible non-decimal numbers less than the number and bigger than 0.
=== Quine ===
Prints the program source code. Since there is no source code, this program does nothing.
=== Infinite counter ===
Counts up indefinitely with step size of 1
== Interpreter ==
Download
=== Arguments ===
* --hello-world (-h) - Executes Hello World
* --truth-machine (-t) - Executes Truth Machine
* --cat-program (-c) - Executes Cat Program
* --fizz-buzz (-fb) - Executes Fizz Buzz
* --99-bottles-of-beer (-b) - Executes 99 Bottles of Beer
* --factorial (-f) - Executes Factorial
* --quine (-q) - Executes Quine
* --infinite-counter (-i) - Executes Infinite counter
Category:Languages Category:Implemented Category:Zero-dimensional Category:Unusable for programming Category:No-code esolang
NoSubject

NoSubject is a pseudonatural esolang where every sentence has no subject. It is invented by User:None1.
There is an accumulator, which is a reference to a variable. It is undefined behavior to access data using the accumulator before setting it to a reference of an existing variable. Variables store unbounded signed integers.
==Commands==
 makes A
Define a variable named A, initially zero. If the variable already exists, do nothing.
 is A
Let the accumulator be the reference of A.
 adds by A
Add the accumulator by A.
 speaks
Print the accumulator as an integer.
 talks
Print the accumulator as an ASCII character.
 listens
Read an integer and store it into an accumlator.
 hears
Read an ASCII character and store it into an accumlator.
 negates itself
Negate the sign of the accumulator.
 becomes integer/A
Let the data pointed by the accumulator become the value of an integer or another variable.
 disappears
Delete the variable at the accumulator.
 jumps to integer/A
Jump to line specified by the integer or variable. First line is line 0.
 stops
Stop.
 jumps to integer/A using integer/B
If integer/B is nonzero, the line specified by integer/A is jumped.
 says "string"
Prints the string.
==Examples==
===Hello, World!===
 says "Hello, World!"
===Cat program===
 makes A
 is A
 hears
 talks
 jumps to 1
===Truth machine===
 makes A
 is A
 listens
 speaks
 jumps to 2 using A
===A+B Problem===
 makes A
 is A
 listens
 makes B
 is B
 adds by A
 speaks
==Errors==
There are two cases that cause errors: Jumping out of bounds and deleting non-existent variables. If one of these two errors occur, the program prints fuck and terminates.
Category:Languages
Category:Joke languages
Category:Pseudonatural
Category:2024
Category:Unimplemented