nyuuzyou/wikis huggingface dataset:
Ndeql

Ndeql is a non-deterministic variation on Sceql thought of by User:Koen as a continuation of the Knight Shuffling Tower idea. Just like Sceql, it provides a single queue of bytes as the only form of memory available to programs. However, that queue has a particularity: it goes with n variables, holding one byte each, which all act as its front element. For every "pop" operation, one of the n variables is selected: it is used as the front value, then replaced with the next value in the queue.
Just like Sceql, the queue in Ndeql can only grow and never shrink: data can never be removed from it once enqueued into it. Initially the queue is empty, and there are 3 variables, each holding a 0.
==Instructions==
Instruction	Instruction	Description
? 	RAND 	Create a new variable, initially holding a 0.
= 	NEXT 	Select one variable. Enqueue the byte it holds. Dequeue a byte and store it in that variable.
- 	DEC 	Select and decrement one variable (wrapping).
_ 	INC 	Select and increment one variable (wrapping).
\ 	BEGIN 	Select one variable, and skip to the instruction after the matching END if it is zero.
/ 	END 	Go back to the corresponding BEGIN.
! 	GROW 	Enqueue a new zero byte.
& 	INPUT 	Read a byte from stdin and enqueue it (0 for EOF).
* 	OUTPUT 	Select a variable. Write the byte it holds to stdout, then enqueue it. Dequeue a byte and store it in that variable.
==Computational class==
Sceql was Turing-complete. Ndeql's non-determinism creates fundamental problems:
*Variables start out as zero.
*When a variable is zero, there is a nonzero probability that it will not be changed, but will be selected for all \ commands, leading the program to halt without further iteration.
There is therefore no way to guarantee that a program will complete an arbitrary large computation.
==See also==
* Sceql, the deterministic language Ndeql is based on.
* Knight Shuffling Tower, a similarly nondeterministic queue-based language.
==External resources==
*Interpreter in C.
Category:Languages
Category:Nondeterministic
Category:Probabilistic
Category:Queue-based
Category:Unknown computational class
Category:Implemented
Category:Low-level
Category:2012
Near-Brainfuck

Near-Brainfuck is not an example of near turing machines, but instead user:tommyaweosmes take at trying to understand it.
== commands ==
 +
 -
 <
 >
 } face near-pointer to right
 | face near-pointer to middle
 { face near-pointer to left
 .
 ,
 [
 ]
== near-ponter ==
the near-pointer follows the pointer.
in its right, position, all +-.,[] commands apply to the cell to the pointers direct right.
}+ on this case:
 0156
 ^
would result in this:
 0157
 ^
 ^
the second row is the near-pointer, and it always stays in the same place relative to the regular pointer.
doing } will do it to the right, | will align it to the center, and { will do it to the left.
i believe you understand but here is a table anyways:
 { : 123
 ^
 ^
 | : 123
 ^
 ^
 } : 123
 ^
 ^
== ascii loop ==
as with tradition, i will show an ascii loop using at least one of the new features:
 {+[|+.{]
this abuses the near-pointer to point at an always-1 value to loop, while pointing back to the always-increasing value to print.
therefore, unlike some of my other ascii loops, this prints infinitely.
this CAN be recreated in brainfuck by this:
 >+<[>+.<]
but its really not that fun and also everyones sick and tired of seeing the same 8 god-damn symbols over and over
Category:Languages Category:Cell-based Category:Brainfuck derivatives
Neat

Neat is an esolang created by User:HellishBro. It was meant to be a language with no loops.
===Language===
Neat program uses a Python 3 interpreter to run, which is obvious because the whole language is programmed on it.
This language is small, and program it doesn't require new lines.
The language is on update 1.0.0, which is the start of it. User:HellishBro is planning to make the next update, 1.0.1, to be the update to add file recognition.
===Syntax===
Inspired by brainfuck, this programming language also uses number storage. With similar commands to brainf, this programming language have a cell memory, a pointer.
This is a list of Neat code:
 
 + // add one to current cell
 - // subtract one from current cell
 < // move pointer to the left, if index is -1, auto-adjust to 0
 > // move pointer to the right, if index is length of cell memory, add one more digit to the memory
 ! // print the Unicode of the current cell to the screen
 ? // take one single character from keyboard and set current cell to Unicode of it.
 @ // add 30 to current cell
 # // add 10 to current cell
 $ // set current cell to 0
 // this is a space. Generate random number between 0 and 100
 . // print the current cell to the screen
===Code===
This programming language is now on GitHub, with the link 
Category:Languages Category:Implemented Category:Total Category:Unusable for programming Category:Cell-based
Negate

Negate is an esolang idea by osminee where every value is either false or true (0 or 1, respectively).
== Introduction ==
In Negate there are following data types:
Type 	Code example 	Description
Bit 	b my_bit: !. 	Defines a variable with a value of either 0 or 1.
Array	a char_a: (!-!!-!-!-!-!-!-!!).	Defines an array consisting of bits.
== Main syntax ==
Negate's main logic is about logical operators. For example, when you write !!, it means that you are negating a false value (essentially applying a NOT to the value), so it produces true.
Another example would be to perform a logical conjunction (AND) on two bits:
b result: &[!-!!].
Here the value returned to result will be false.
=== Variables ===
As shown earlier, Negate does contain variables. You can define a variable like this:
<variable type> <variable name>: <value>.,
where:
* <variable type> - type of the variable (b for bit, a for array),
* <variable name> - name of the variable (obvious),
* <value> - desired value.
Neoff

Neoff (Pronounced “Knee off”/niɔf) is an esolang created by User:RainbowDash.
Neoff has 1 stack and an array of cells.
The stack acts as a stack of points that you can "travel" to, meaning that whenever a point is called off the stack the program counter is set to that point like a GOTO command. As for the array of cells it works as ram.
</br>
Please note the following. Line numbers are indexed at 1, however the addresses are indexed at 0. Code indents do nothing in this coding language except for making the code look pretty, however new lines are needed. </br>
</br>
There are 4 types of variables:</br>
* Number - 8 bit constant </br>
* Address - 8 bit </br>
* Text - No Bit Restriction. (Only used for outputting text)
* Point - Basically like a Label in BASIC. Points are used to save line numbers and traverse to them.
Some commands need to be specified on which variable type needs to be used for example:
 Disp Text Hello world // Hello World
 Disp Address 0 // Prints value at address
 Disp Number 5 // Prints number 5
 
==Instructions==
Instruction 	Explanation 	Variable type
Poke # 	Sets the memory pointer to # 	Num/Addr
Set # 	Sets the the memory cell at the pointer to # 	Num/Addr
Inc # 	Increments the memory cell at the pointer by # if no arguments are passed it increments by 1 	Num/Addr
Dec # 	Decrements the memory cell at the pointer by # if no arguments are passed it decrements by 1 	Num/Addr
Comefrm # 	When the program counter equals # or point jump to the line number of this instruction ; Comefrom	Num/Addr/Point
Goto # 	Sets program counter to # or point 	Num/Addr/Point
If # 	If the memory cell at the pointer is not equivalent to # then skip the next line 	Num/Addr
Display 	Outputs a variable, if its an Address it will be outputted in ASCII 	All
Input 	Reads a character and puts the corresponding character into the memory cell at the pointer 	*
Point [Name] 	Sets a point 	*
Push [Point Name]	Pushes a point to the "travel stack" 	*
Delete 	Deletes the top point of the stack 	*
Travel 	Pops a point off of the stack then goes to the line number of the point 	*
// 	Comment 	*
==Code examples==
===Hello World===
Display Text Hello World
===Truth Machine===
Poke Number 0
Input
If Number 0 
 Display Number 0
Comefrom 7
If Number 1 
 Display Number 1
Comefrom 4
This is a legacy code so the goto commands don’t use points
===Deadfish===
Poke Number 0 // Instruction address
Input 
Push Loop // This point will be traveled to after an instruction gets completed
If Number 105 // Increment
 Push Increment
 
If Number 100 // Decrement
 Push Decrement
 
If Number 115 // Square
 Push Square
If Number 111 // Output
 Push Output
Travel // Execute selected instruction
Point Increment
 Poke Number 1
 Inc
 Travel
Point Decrement
 Poke Number 1
 Dec
 Travel
Point Square
 Poke Number 2
 Set Address 1
 Poke Number 3
 Set Address 1 
 Poke Number 1
 Inc Address 2 
 Poke Number 3
 Dec 
 If Number 0
 Goto 40
 Goto 33
 Travel
Point Output
 Poke Number 1
 Display Address 0
 Travel
Point Loop
 Goto 1
Category:2024
Category:Cell-based
Category:Languages
Category:Stack-based
Category:Turing complete
Category:Unimplemented
NestFuck

NestFuck is a language that uses pairs of nested brackets to execute brainfuck instructions. It uses 3 characters as follows:
Character	Function
( 	Increase nest level
) 	Decrease nest level
. 	Execute instruction
Any character other than these is ignored and considered a comment
Each nest level 0-7 maps to a brainfuck instruction:
Brainfuck command	Nest level	Description
> 	0 	Move pointer to the right
< 	1 	Move pointer to the left
+ 	2 	Increment the memory cell under the pointer
- 	3 	Decrement the memory cell under the pointer
. 	4 	Output the character signified by the cell under the pointer
, 	5 	Input a character and store it in the cell under the pointer
[ 	6 	Jump past the matching ]/7 if the memory cell under the pointer is 0
] 	7 	Jump back to the matching [/6 if the memory cell under the pointer is nonzero
Brackets must be balanced in the program. There are two ways of programming in NestFuck. Simple is where you close all brackets after every command, e.g. ((.................)) ((((.)))). Compact is where you only open and close brackets as necessary, making the program a lot smaller, but very difficult to write and read, e.g. ((.................((.))))
=== Examples ===
Hello World!:
Simple:
 ((..... ...))((((((.)))))).((....))((((((.)))))).((..)).((...)).((...)).((.))(....) (((.)))(((((((.))))))).((.)).((.)).(((.)))..((.))((((((.)))))) (.) (((((((.)))))))(.)(((.)))(((((((.)))))))..((((.)))).(((...)))((((.))))((.......))((((..))))((...))((((.))))..((((.))))(.)(((.)))((((.))))(.)((((.))))((...))((((.))))(((.....)))(((.)))((((.))))(((........)))((((.))))..((.))((((.)))).((..))((((.))))
Compact:
 ((........((((.)))))).((....((((.)))))).((..)).((...)).((...)).((.)....((.((((.))))))).((.)).((.)).(((.)))..((.((((.))))).((((((.)))))).((.((((.)))))))..((((.)))).(((...(.)).......((..))...((.))))..((((.))).((.(.))).(((.))...((.)......(.)........(.))))..((.((.)))).((.((.))))
As you can see, compact is horrible to read.
=== Interpreters ===
An interpreter can be found in the GitHub repository for NestFuck, along with extended information
Category:Languages
Category:2020
Category:Cell-based
Category:Brainfuck derivatives
Category:Turing complete
Category:Low-level
Category:Implemented
Nested one input functions

Nested one input functions is a programming language that uses one input functions
== Functions ==
 a:
 b:
 ^b b
 <hi<hello
 !this returns hi hello
 !the functions are defined by their inputs, ^ is the previous input function, 
 !the ^b refers to the a in the upper function, < runs the previous function
 !with this input, the <hi inputs hi into a and results in:
 !b:
 ! hi b
 !then the <hello inputs hello into this resulting function and it results in hi hello
 !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in !! makes a comment, in 
 !, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a comment, it makes a commentv
== Examples ==
=== Mockingbird ===
 a:
 a a
=== Identity ===
 a:
 a
=== Constant ===
 a:
 b:
 ^b
=== Opposite of Constant ===
 a:
 b:
 b
== One more thing ==
 !since this is invalid
 a:
 b:
 a
 !you can do this
 a:
 a:
 ^a
 !this is the true function
 !or this
 a:
 a:
 a
 !this is the false function
Nesting lines on big complicated trees and definitely not inspired by a conlang i made sometime

nesting lines on big complicated trees and definitely not inspired by a conlang i made sometime ago is a esolang made by Yetyetty1234567890.
nesting lines on big complicated trees and definitely not inspired by a conlang i made sometime ago or NLOBCTADNIBACIMSA is as its name implies, about nesting functions.
Here are some basic functions:
* not() - not()
* be() - be()
* out() - out ascii
* in() - in ascii
Here are some complex functions:
* take() - similar to be, but it spawns two copies for every entry in the same order.
* combine() - combines 2 lists by adding each value (combine(be(2,1),be(3,2)) = be(5,3))
* trace() - id of the number in list (returns 0 if isn't in list (be(2,3,1,trace(3) = be(2,3,1,2) be(2,trace(1)) = be(2,0))
* loop() - loop a n amount of times
* dont() - dont do something
* disp() - display a pixel at c,x,y (colour,x,y) (to display multiple use multiple c,x,y's (disp(16711680,1,2,65280,3,4)) (displays using hex code (written in decimal)))
* intr() - sets an interrupt # milliseconds from previous interrupt end and moves to running interrupts' position
* add() - adds a new entry containing everything below # layers above the add()
* wait() - pause (milliseconds) all things in the layer of the wait() that are params or reduce to params 
Parameters:
* inf - inf
* # - a number
* c - a char
==Example==
power of 2 calculator with delay of 1s
combine(be(wait(1000), 0, be(dont(wait(1000)), 1)), add(2),add(2) ,dont(combine(intr(1000)),intr(1000)))
Category:Languages
Nestplate

Nestplate (from the combination of the words nest and template) is a language invented by User:GDavid to solve the problem that C++ templates are sometimes too readable. It's inspired by (()).
==Syntax==
The syntax of nestplate can be described as follows:
 program ::= body
 struct ::= (name) (argumentdefinitions) (body)
 argumentdefinitions ::= ((name))
 argumentdefinitions ::= ((name) ())
 argumentdefinitions ::= ((name) (argumentdefinitions))
 argumentdefinitions ::= argumentdefinitions argumentdefinitions
 argumentdefinitions ::=
 body ::= (struct)
 body ::= (using)
 body ::= body body
 body ::=
 using ::= (name) (value)
 value ::= (name) (arguments)
 value ::= ((value) (name))
 value ::= ((name))
 arguments ::= (value)
 arguments ::= arguments arguments
 arguments ::=
 name ::= (name)
 name ::= name name
 name ::=
Notes:
* value ::= (name) (arguments) is name<arguments> in C++
* value ::= ((value) (name)) is typename value::name in C++
* argumentdefinitions ::= ((name)) is typename name in C++
* argumentdefinitions ::= ((name) ()) is typename ... name in C++
* argumentdefinitions ::= ((name) (argumentdefinitions)) is template<argumentdefinitions> typename name in C++
* Everything else should be possible to guess from it's name, if not, feel free to ask what it means on the talk page
==Example code==
 struct zero {
 }
 
 template<typename v>
 struct box {
 using value = v;
 }
is
 (()()())((())(((()())))((()(((()()))))))
in nestplate
Category:LanguagesCategory:Turing completeCategory:No IOCategory:Low-level
Network Headache

Network Headache is an esoteric programming language invented by User:Zzo38.
The purpose of this programming language is that all variables are shared with all Network-Headache programs running, everywhere. Every step (a fixed amount of time), a list of all running programs is made, ordered randomly, and one step is executed of each program, in that order. Variable names are all uppercase letters, nothing else. Numbers are infinitely long non-negative integers.
== Operators ==
* a-b: Subtraction, absolute value
* a*b: Multiplication
* a$b: INTERCAL mingle
* a~b: INTERCAL select
* a?: (a) XOR (2a). So binary [10010111]?=[110111001] (like INTERCAL)
* (a): Value of a, used to control precedence.
* Numbers are in base ten, variable names can be used anywhere numbers can.
== Commands ==
* SET a=b: Sets the value of variable a to b.
* IN a: Reads input, and stores it in variable a.
* OUT a: Outputs a.
* SKIP: Skips a command in the next program which will execute a step. Wastes its turn, and its line.
* LABEL a: Labels the current location as number a.
* DO a: If the label a exists, push the current location to stack and go to a.
* FORGET a: Works like INTERCAL forget command.
* EXIT: Works like INTERCAL DO RESUME #1. If the stack is empty, ends program execution.
==External resources==
* Network Headache in the file archive (contains implementation, but you have to run the server yourself; the old server is gone)
Category:Implemented
Category:Languages
Category:Unknown year
Category:Nondeterministic
Category:Low-level
Category:Unknown computational class
Neucomp

Neucomp is short for Neumann stiled Computer
==Examples for a Computer==
===Add 2 and 2===
 Let 1 2
 Let 2 2
 ALU 1 2 + 3
 Out 3
Outputs 4
Cmds
Intruction 	Description
Let a b 	Let a in memory equal b
ALU a b operation d	Let d in memory equal a operation b
In a 	Accept input into a
Out a 	Output a in numbers
If a operation b 	If a operation b equals true then read intrutions in If 
until end
Prt a 	Prt a’s ASCII value
Go a 	Goto line a
Val a 	Value at a
Halt 	End program
End 	End If
# 	Comment
==Hello World==
 Let 1 72 #H
 Let 2 101 #e
 Let 3 108 #ll
 Let 4 111 #o
 Let 5 32 # 
 Let 6 87 #W
 Let 7 114 #r
 Let 8 100 #d
 Prt 1
 Prt 2
 Prt 3
 Prt 3
 Prt 4
 Prt 5
 Prt 6
 Prt 4
 Prt 7
 Prt 3
 Prt 8
===Explenation===
Hello World into ASCII is
 72 101 108 108 111 32
 87 111 114 108 100
==cat==
 Let 1 1
 Let 2 2
 ALU 2 1 + 2
 In Val 2
 If Val 2 = 10
 Go 9
 End
 Go 3
 Let 2 2
 ALU 2 1 + 2
 Prt Val 2
 Go 10
Input H i enter
Output Hi
===Explenation===
ALU adds 1 to var2
Go 3 is a loop
If breaks the loop
==Truth Machine==
 In 10
 Let 0 0
 Let 1 1
 If 10 = 0
 Out 10
 End
 If 10 = 1
 Out 10
 Go 8
 End
 Go 4
Neural Brainfuck

Neural Brainfuck is an attempt to create a language so that, analog neural networks can be implemented within it. All programs run within an implicit infinite loop. The tape extends infinitely in both directions (left and right) and contains cells with real numbers.
Instructions:
Instruction	Explanation
< 	Move tape pointer left
> 	Move tape pointer right
$ 	Push cell to stack
% 	Pop from stack to cell
W 	Random real value from 0.0 to 1.0 into cell (primarily for randomized weights)
+ 	Pop two values, add them together and push the result
* 	Pop two values, multiply them together and push the result
s 	Pop value, run it through implementation-defined activation function, and push the result
i 	Input into cell (input is ordered, depends on program and i/o interface to neuralbf program)
o 	Output from cell (closer to interrupt rather than output)
Computational Class:
I'm not sure.
Category:Cell-based Category:Stack-based Category:Unknown computational class Category:Total Category:Brainfuck derivatives Category:Languages
Nevermind

Nevermind is a simplistic programming language made by User:OfficialCraftCGame in 2021. It uses commas (,) to separate arguments. There is no escape character so to add a comma in text, you must substitute the comma with *44. To use a variable as an argument in a function, start the variable with the letter $. To add an integer to another integer, use +. For concatenating string, use double plus signs ++.
== Functions ==
 Functions in Nevermind
Code 	Description 	Syntax 	Example
print 	Outputs text to the screen. Can have more than 1 argument 	print,output 	print,Hello*44 World!
input 	Gets input from the user and stores it in a variable called answer. 	input,prompt 	input,How are you?
make 	Creates a variable 	make,name,value 	make,variable1,1234
if 	An if statement. Checks if a is either greater than, equal to, or less than b.	if,a,[== / > / <],b	if,$variable1,==,1234
endif 	Ends the if statement 	endif 	endif
loop 	Loops the code inside x times. 	loop,x 	loop,10
endloop	Ends the loop 	endloop 	endloop
== Code Examples ==
=== Hello World ===
This is a "Hello, World!" code example:
 print,Hello*44 World!
the output is:
 Hello, World!
=== Truth Machine ===
An infinite loop is currently unable to be made in Nevermind, which means a Truth Machine is not possible to be created.
=== Calculator ===
An example of a calculator written in Nevermind
input,a: 
make,a,$answer
input,b: 
make,b,$answer
input,operation: 
make,operation,$answer
if,$operation,==,+
 make,final,$a,+,$b
 print,$final
endif
if,$operation,==,-
 make,final,$a,-,$b
 print,$final
endif
if,$operation,==,*
 make,final,$a,*,$b
 print,$final
endif
if,$operation,==,/
 make,final,$a,/,$b
 print,$final
endif
== Implementations ==
* A Python interpreter by User:Bangyen.
* Another Python interpreter made by User:OfficialCraftCGame
Category:Languages Category:Total Category:Implemented Category:2021
NewFuck

:Canceled -User:DmilkaSTD
NewFuck is another brainfuck derivative.
The operations changes everytime you make a new project.
== Possible operations ==
Brainfuck operation	Possible operation	Possible operation	Possible operation
< 	4 	a 	l
> 	6 	d 	r
+ 	8 	^ 	/
- 	2 	v 	\
[ 	{ 	( 	¿
] 	} 	) 	?
. 	" 	e 	¬
, 	# 	@ 	;
== Rules ==
You can't erase a part of code.
The interpreter can't tell you which operations you have in this projects.
== New commands ==
New operation	Description 	Possible operation	Possible operation	Possible operation
% 	Prints the number of the cell (not converting to a ascii character)	% 	% 	%
Z 	Ejemplo 	Ejemplo 	Ejemplo 	Ejemplo
7 	Ejemplo 	Ejemplo 	Ejemplo 	Ejemplo
_ 	Ejemplo 	Ejemplo 	Ejemplo 	Ejemplo
: 	Ejemplo 	Ejemplo 	Ejemplo 	Ejemplo
Category:Languages Category:Brainfuck derivatives Category:Cell-based
Newton

The newton language is simple.
We have an apple.
 @
This apple is launched by a tree.
 &
And if it passes by a mirror, it is reflected.
 _ |
 / \
When it passes by an inc
 +
it is incremented.
When it passes by a dec
 -
it is decremented.
When it passes by a print
 #
it outputs the ASCII of the number stored in it.
When it passes by an in
 $
it inputs a value and store in it.
==Example Programs==
===Cat program===
/#\
&
\$/
Category:Languages Category:Two-dimensional languages Category:Implemented