nyuuzyou/wikis huggingface dataset:
Nope

: nope must always be bold like this: nope
nope is a Cell-based Turing complete esoteric coding language created by User:yayimhere (rewritten by User:RainbowDash). nope supports negative numbers, this allows for addition and subtraction. anything thats not a command will be ignored. there exists labels like in BASIC but they can only be numbers
In nope there is only 5 valid commands along with their arguments:
 nope's commands 
Commands 	Description 	Arguments
no_op 	Does nothing 	*
jl 	Jump to label if MP is less than or equal to zero	MP, LABEL
peek 	Prints out the value at MP 	MP
store 	Store VALUE at MP 	MP, VALUE
no:op_add	MP1 + MP2 = MP3 	MP1, MP2, MP3
= Tips =
*nope allows for subtraction whenever you add a negative number with another number. 
*you can GOTO labels by choosing a cell you always know is going to be 0 or less.
*you convert numbers outputted by the peek command to ASSCI for text output or to colors for image output
= Code Examples =
===Hello World=== 
store 0 72
peek 0
store 0 101
peek 0
store 0 108
peek 0
peek 0
store 1 111
peek 1
store 0 32
peek 0
store 0 119
peek 0
peek 1
store 0 114
peek 0
store 0 108
peek 0
store 0 100
peek 0
===Count down from 100===
store 0 -1 
store 1 1 
store 2 100
store 3 -100
:1
peek 2
no:op_add 1 3 3 
no:op_add 2 0 2
jl 3 1
This works because there is a negative version of the number that is being incremented, the program stops once that number is equal to 1.
While that is happening a positive version is being decremented and outputted giving you the output you see.
=Interrupters =
JavaScript - nope revised interrupter
function nope(inputPrgm){
 // Initialize Variables
 let memorysize = 3000
 let memory = new Array(3000).fill(0);
 inputPrgm = inputPrgm.toLowerCase();
 let words = inputPrgm.split(/[ \n/\\]+/);
 
 let i = 0;
 while (i < words.length) {
 switch(words[i]) {
 case "no_op":
 Function.prototype(); 
 break;
 case "store":
 memory[words[i+1]] = +words[i+2];
 i += 2
 break;
 case "jl":
 if(memory[words[i+1]] <= 0){
 i = words.indexOf(":" + words[i+2]);
 } else {
 i += 2
 }
 break;
 case "peek":
 console.log(memory[words[i+1]]);
 i += 1
 break;
 case "no:op_add":
 Function.prototype(); 
 memory[words[i+3]] = memory[words[i+1]] + memory[words[i+2]];
 i += 3
 break;
 }
 i++
 }
}
== turing completeness proof ==
this is a proof that nope is turing complete to translating to Minsky machine
notes:
* registers 1 and 2 are reserved for inc and dec
* n is a short term for n'th command(of the minsky machine). so for the thith command it would be n=5
* uses Short Minsky Machine Notation
so the program must start with:
 store 1 -1
 store 2 1
heres the translation:
 ℘xy
 |
 V
 :n
 jl y x
 no:op_add y 1 y
 --
 ℘y
 |
 V
 :n
 no:op_add y 1 y
the halt is not needed for turing completeness. so this proove's turing completeness of nope
== se also ==
* 401
Category:Turing tarpits
Category:Turing complete
Category:Cell-based
Category:Output only
Category:Languages
Category:Low-level
Nope!

Nope! is an esolang created by User:None1 and inspired by NULL-NONE-BF and !!Fuck, it is a Trivial brainfuck substitution.
==Commands==
Commands are separated by spaces.
==Examples==
===Hello World===
Nope! Nope! Nope! Nope! Nope! Nope! Nope! Nope! Nope. Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope! Nope! Nope! Nope! Nope! Nope. Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope! Nope! Nope! Nope. Nope. Nope. Nope! Nope! Nope! Nope! Nope. Nope. Nope. Nope! Nope! Nope! Nope! Nope. Nope. Nope. Nope! Nope! Nope. Nope. Nope! Nope. Nope. Nope! Nope. Nope. Nope! Nope. Nope. Nope! Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope! Nope! Nope. Nope. Nope. Nope! Nope! Nope. Nope. Nope. Nope! Nope. Nope! Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope! Nope! Nope. Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope! Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope! Nope! Nope! Nope! Nope! Nope! Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope! Nope! Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope! Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope! Nope! Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope! Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope! Nope! Nope! Nope. Nope. Nope. Nope. Nope. Nope!
===Cat program===
 Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope. Nope! Nope. Nope. Nope. Nope. Nope. Nope. Nope. Nope!
==Interpreter==
#!/usr/bin/ruby
eval 'm=Hash.new(p=0);'+ARGF.read
 .gsub(/Nope[.!]|./i,Hash.new{|_, k| (k.length>1)?k[-1]:; }).gsub(/\n/,)
 .gsub(/\.*!|./,
 '!' => 'm[p]+=1;',
 '.!' => 'm[p]-=1;',
 '..!' => 'p-=1;',
 '...!' => 'p+=1;',
 '....!' => 'm[p]=STDIN.getbyte if !STDIN.eof;',
 '.....!' => 'putc m[p];',
 '......!' => '(',
 '.......!' => ')while((m[p]&=255)!=0);'
 )
==Turing completeness==
Since any program in BF can be translated to Nope!, Nope! IS Turing complete.
==See also==
* Ook!
* !!Fuck
Category:Languages
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Turing complete
Nope...?

Nope...? is a esolang based on Nope. created by User:Yayimhere where it maybe is actually useable
== memory ==
yes Nope...? has memory. its a string and for everything that would be printed in Nope., is added to this string in Nope...?. and when nothing is added when a subprogram is ran, the first char of the string is deleted. the program will auto halt if this happens to a empty string
== syntax ==
Nope...? work alike nope but with some changes. first of all there are subprograms like this:
 first subprogram | second subprogram | third subprogram
a subprogram can add the following subprogram to the end of the list of subprograms by ending in :. and a sub program can have n index into the word by ending in [n] and theres a special argument *. it starts indexing at 2
== quirks ==
Nope...? has only a single self interpreter. its this one:
 anything can go here | anything can go here[6]
any other program with no special strings
== examples(very simple) ==
Infinite Loop:
 anything can go here: | anything can go here: | anything can go here:
set string length to 1 then 4 then 1 and so on
 anything can go here: | anything can go here[5]: | anything can go here[5]: | anything can go here[5]: | anything can go here:
Nope. with no quine

Nope. with no quine is an esolang created by User:Ractangle based on those "None. without a quine" esolangs. it's basicly Nope. with no quine. So that basicly means:
if you put "Nope." to the input. The interpreter will print:
 ‍
and if you put nothing to the input. The interpreter will print
 Nope.
And invisible characters are NOT allowed
== Example ==
=== Nope. ===
 Hello, world!
=== [OBJ] ===
 Nope.
=== Quasi Quine by using period in other language(Syriac, Urdu, etc.) ===
 Nope܂
=== Quasi Quine by using other language ===
 非也。
 いいえ。
 아니.
=== Quasi Quine by style script ===
 𝐍𝐨𝐩𝐞.
 𝘕𝘰𝘱𝘦.
 𝙽𝚘𝚙𝚎.
 Ⓝⓞⓟⓔ.
 ℕ𝕠𝕡𝕖.
 
Category:Languages Category:Unimplemented Category:Unusable for programming
Nope. without a quine

Nope. without a quine is a language made by User:SnakeyKing.
It is a Nope. derivative but there's no quine.
== Commands ==
There's no commands in this language, as it just rejects the program.
If the program is Nope. the output is lol no quine for you.
Otherwise, the output will be Nope.
== Example ==
=== Cheating Quine(I'm going to fool you with invisible characters, lol) ===
 ​Nope.
== Implementation ==
=== Python 3 ===
# Python 3
code = input('Nope > ')
if code == 'Nope.': print('lol no quine for you')
else: print('Nope.')
=== Batch ===
@echo off
set /p code=
if %code% EQU Nope. goto lol
goto nope
:lol
echo lol no quine for you
pause >nul
exit
:nope
echo Nope.
pause >nul
exit
=== C++ ===
#include<bits/stdc++.h>
using namespace std;
string com;
int main()
{
	cout << "Nope.(Without Quine) interpreter 3.01" << endl;
	 
	while(true)
	{
		printf("Nope >");
		getline(cin, com);
		if(com == "Nope.")
		{
			cout << "lol no quine for you\n" << endl;
		}
		else
		{
			cout << "Nope.\n" << endl;
		}
	}
	return 0;
}
== See also ==
* No.pe.
Category:Languages
Category:Joke languages
Category:Nope. derivatives
Category:2023
Category:Total
Category:Output only
Category:Unusable for programming
Nope. without a quine including cheating ones

Nope. without a quine including cheating ones is Nope. without a quine but the cheating quine does not work.
== how it works ==
every program prints nope unless the program has a nope. inside it will print:
 lol no quine for you. nope. no quine
== theres actually a quine lol ==
this is a quine:
 lol no quine for you. nope. no quine
==Interpreter==
Written in JavaScript.
function nwaqico(program)
{
 console.log(program.includes("nope.") ? "lol no quine for you. nope. no quine" : "nope");
}
Category:Languages Category:2024 Category:Unusable for programming Category:Output only Category:Total Category:Implemented
Normalcalc

Normalcalc, designed by User:Itoh Shimon in 25-26 November 2023 (JST) and appeared in 31 July 2024 (JST), is a purely functional esoteric programming language based on combinatory logic and monadic IO.
==Syntax==
 <program> ::= "`" <value> <value>
 <value> ::= "*" | "/" | "|" | "_" | "," | "." | <program>
==Operators==
Operator 	Description 	
` 	Function application operator 	
* 	Substitution function (the S combinator; takes three values and applies the result applying the first one to the third one, to the result applying the second one to the third one)	
/ 	Constant function (the K combinator; takes two values and returns the first one) 	
style="text-align:center"	 	Bind function (also called flatMap; takes a monad and a function that takes a value in that monad and returns a monad, and returns a monad)
_ 	Return function (also called pure and unit; takes a value and returns a monad containing it) 	
, 	Input function (takes a value, discards it, and returns a monad containing an input byte) 	
. 	Output function (takes an output byte and returns a monad containing an empty tuple) 	
# 	Line comment 	
Other characters are ignored.
==Specifications==
* Lazy evaluation (for fixed point combinators)
* Functions are curried.
* Normalcalc programs return a monad (also called procedure).
* Bytes are represented as Church numerals.
* Empty tuples are represented as identity functions (the I combinator; takes a value and returns it).
==Examples==
===no-op===
 `_/
Equivalent Haskell pseudocode:
 main = return const
===cat (for a single character)===
 ``|`,/.
Equivalent Haskell pseudocode:
 main = (>>=) (read1byte const) write1byte
full:
 -- builtin:
 import System.IO
 import qualified Data.ByteString as BS
 
 read1byte :: a -> IO Integer
 read1byte _ = do
 eof <- isEOF
 if eof
 then return 256
 else toInteger . BS.head <$> BS.hGet stdin 1
 
 write1byte :: Integer -> IO ()
 write1byte = BS.hPut stdout . BS.pack . (:[]) . fromIntegral
 
 -- program:
 main = (>>=) (read1byte const) write1byte
== See also ==
Other combinatory logic languages that support IO actions:
* Zot
* Hot
* Trivial
* Kiss
==External resources==
* The original implementation
Category:Languages
Category:Turing complete
Category:Turing tarpits 
Category:Functional paradigm
Category:Implemented
Category:2023
Normalized Fumber

This is a symbol based version of Fumber.
 
Symbol	Definition
> 	Move left on the tape
< 	Move Right
+ 	Add One to the selected cell
- 	Subtract One
. 	Output the selected cells number as an ascii value
, 	Input a single character
[ 	Jump past the next ] if the selected cell is 0
] 	Jump to the last [ if the cell is not zero
% 	Set the next character as it's ascii value in the current cell
That's it, just Brainflakes, but easer. (Go to Fumber for examples)
Category:Languages Category:Brainfuck derivatives Category:Turing complete Category:Unimplemented Category:Cell-based Category:Low-level
Nors

Nors is a Zero Instruction Set Computer created by Calvin Games on February 14, 2017. It is Turing complete because it is equivalent to a 2-tag system.
== Description ==
The computer state is a string of bits P.
P0 is the initial state.
If the first bit in Pn is 1 the computer halts and outputs the successive bits in Pn.
If the length of Pn is odd then 0 is added to the end of Pn.
The new state Pn+1 is the odd bits of Pn NOR the even bits of Pn.
The computer repeats this process until it halts.
== Programs ==
Hello World! (Outputs the ASCII code for the string "Hello, world!")
 Initial State:
 1 01001000 01100101 01101100 01101100 01101111 00101100 00100000 01110111 01101111 01110010 01101100 01100100 00100001
==Interpreter==
* Common Lisp implementation of the Nors programming language.
Category:Languages Category:Implemented Category:Turing complete Category:Output only Category:2017
NotBrainFuck

NotBrainFuck (or not brainfuck) is an extension of brainfuck by Jack Benson (User:Spleeshmicannon). It adds 8 new symbols to make it easier for beginners to get the hang of minimalist languages like brainfuck. It is also of course fully backwards compatible.
==Commands==
NotBrainFuck is the same as brainfuck and the interpreter is basically the original c interpreter written by Urban Müller with the additional implementation of the following commands.
Symbol	Description
* 	Multiply current cell by its neighbour to the right
x 	Multiply current cell by its neighbour to the left
/ 	Divide current cell by its neighbour to the right
\ 	Divide current cell by its neighbour to the left
l	Starts/ends a multiline comment (e.g. CODE/COMMENT HERE/CODE)
# 	Sets the cell to the value of the following symbol
^ 	Increments base (making +++ the same as ^^+)
v 	Decrements base
==External Links==
Github Page
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
Category:Turing complete
Category:Cell-based
Not The Main Worb/ntmw.py

:
 from collections import defaultdict
 import heapq
 import random
 import os
 import sys
 from time import sleep
 
 def load_file(filename):
 with open(filename) as f:
 phase1=True
 board={}
 sites=defaultdict(list)
 transmitmap={}
 x=0
 y=0
 width=0
 height=0
 for y,line in enumerate(f):
 line=line.rstrip("\r\n")
 if line=="#": 
 phase1=not phase1
 height=y
 continue
 if phase1:
 if len(line)>width: width = len(line)
 for x in range(0,len(line)-1,2):
 board[(x/2,y)]=[line[x],line[x+1]]
 if line[x+1]!=" ":
 sites[line[x+1]].append((x/2,y))
 if len(line)%2:
 board[(len(line)/2,y)]=[line[x]," "]
 else:
 if len(line)==0: continue
 if len(line)!=2: raise ValueError("Invalid transmitter-receiver pair on line %d: %s"%(y+1,line))
 if line[1] in transmitmap.values() or line[1] in transmitmap.keys() or line[0]==line[1]:
 raise KeyError("Receiver symbol on line %d was previously declared: %s"%(y+1,line))
 if line[0] in transmitmap.values() or line[0] in transmitmap.keys():
 raise KeyError("Transmitter symbol on line %d was previously declared: %s"%(y,line))
 transmitmap[line[0]]=line[1]
 if phase1:
 height=y
 return NTMW(board,sites,transmitmap,width,height)
 
 class NTMW:
 
 def __init__(self,board,sites,transmitmap,width,height):
 self.board = board
 self.sites = sites
 self.transmitmap = transmitmap
 self.width = width
 self.height = height
 
 def do_transmit(self):
 for transmitter,receiver in self.transmitmap.items():
 if (all([self.board[coord][0]=="." for coord in self.sites[transmitter]]) and
 all([self.board[coord][0]==" " for coord in self.sites[receiver]])):
 for coord in self.sites[transmitter]:
 self.board[coord][0]=" "
 for coord in self.sites[receiver]:
 self.board[coord][0]="."
 
 def move_bobules(self):
 priorityq = []
 newboard = {}
 for coord,contents in self.board.items():
 if contents[0]=="." and contents[1] not in self.transmitmap.keys():
 heapq.heappush(priorityq,(random.random(), coord, contents[0]))
 newboard[coord]=["." if contents[1] in self.transmitmap.keys() and contents[0]=="." else "",contents[1]]
 while priorityq:
 _ , coord, contents = heapq.heappop(priorityq)
 dx,dy = random.sample(xrange(-1,2),2)
 x,y = coord
 if (x+dx,y+dy) in newboard.keys() and not newboard[(x+dx,y+dy)][0]:
 newboard[(x+dx,y+dy)][0]=contents
 newboard[coord][0]=self.board[(x+dx,y+dy)][0]
 else:
 newboard[coord][0]=self.board[coord][0]
 for contents in newboard.values():
 if not contents[0]:
 contents[0]=" "
 self.board = newboard
 
 def print_board(self):
 os.system('cls' if os.name=="nt" else 'printf "\033c"')
 for y in range(self.height):
 print "".join(["@" if self.board[(x,y)][0]=="." else self.board[(x,y)][1] for x in range(self.width) if (x,y) in self.board.keys()])
 
 def run(self):
 try:
 while True:
 self.do_transmit()
 self.move_bobules()
 self.print_board()
 sleep(0.05)
 except KeyboardInterrupt:
 sys.exit(0)
 
 
 if __name__=="__main__":
 if len(sys.argv)<2:
 print "No NTMW filename provided to execute."
 sys.exit(0)
 ntmw = load_file(sys.argv[1])
 ntmw.run()
Category:Implementations
Not finite Ioop

Yeah, this esolang basically includes lots of ways to make not finite loops.
 [] This is a basic not finite loop. This loops everything inside forever.
 
 < This sends the cursor back to the begining of the program, making a not finite loop.
 
 ^ This send the cursor back to the previous *. making another not finite loop.
 
 @ When this command is run, then it'll run itself again, making a not finite loop.
 
 > This skips the next command. how is this a not finite loop? i have no idea. we hate this command.
==examples==
 [hello]
 hello<
 @what
 *hello^
 hello><<
Category:Languages Category:Joke languages Category:Unusable for programming Category:No IO
Not finite loop

Yeah, this esolang basically includes lots of ways to make not finite loops.
 [] This is a basic not finite loop. This loops everything inside forever.
 
 < This sends the cursor back to the begining of the program, making a not finite loop.
 
 ^ This send the cursor back to the previous *. making another not finite loop.
 
 @ When this command is run, then it'll run itself again, making a not finite loop.
 
 > This skips the next command. how is this a not finite loop? i have no idea. we hate this command.
==examples==
 [hello]
 hello<
 @what
 *hello^
 hello><<
Category:Languages Category:Joke languages Category:Unusable for programming Category:No IO
Not fish

not <>< is a esolang created by User:Yayimhere to be kinda like Black. the name comes from a discord chat where somebody said: Is it actually called "not ><>" or which he thought was really funny.
== how it works ==
the IP starts at the third row and thith collumn. a space is a NOP and any other char is what i will be calling a non-space. this is the format of the command description:
IP direction , list of non spaces(if its a space it must be followed by a !): (non-space direction(from perspective of pointer) [number of spaces away it is], other non space in same format,...) –(= if in both ways around and | if it mirrors) new pointer direction , list of non spaces:( new non space direction(from perspective of pointer))
: description
1 ↔ , ↗[1] = ↕ , ↗[1] 
: turn IP 90 degrees
2 → , ⤨ [1] | ↑ , ⤨ [2]
: push the non space to the right corners(combines with 3)
3 → , → [1] | ↓ , → [2]
: push the non space to the right(combines with 2)
4 → , ↙ [1] | ← , ↙ [1]
: turn the pointer direction 180(if its vertical)
4 ↓ , ↙ [1] = ↘ , ↙ [1]
: turn the pointer direction 180(if its vertical)
4 ↘ , ↙ [1], ↘! [2] = ↑ , ↓ [1], ↘ [2]
: turn the pointer direction 180(if its vertical)
if two non spaces lands on the same space the program will halt
== examples ==
infinite loop:
# #
Category:Languages Category:Two-dimensional languages
Notf

notf is a esolang based on not created by User:Yayimhere
== memory ==
memory is now stored in three stacks(!). the first one can only recognize symbols not how many instances there are, so its incapable of recognizing a string, such as anbncn (that is, a number of a's, followed by the same number of b's followed by the same number of c's.). the second one can recognize the number, n, but not the symbols themselves. and the third can process both. so it's capable of recognizing any string, such as anbncn (that is, a number of a's, followed by the same number of b's followed by the same number of c's.) and anbkcu (that is, n number of a's, followed by k number of b's followed u number of c's.)
== commands ==
there are some changes:
* now + will now just push the length of the string to the second stack and keep the single symbols on the first stack
* {x push single symbol x onto the first stack
* |x push the code that would push the code that would push x onto the third stack
* ! + but it will push to the third stack
* ^ skip the following command if the top of the third stack has the length of the top of the second stack
* ?n pop the top of the n'th stack
* en push the empty string to the n'th stack
* >>x jump to line x if the n'th stack is not empty
* :n:reverse the n'th stack
* \n empty the n'th stack
* $ push user input to third stack
* each command that uses the stack will just have a number following it such that it chooses which stack
so the original looping counter becomes:
 1#11[1!=#3N#1]
and this is a Cat:
 $#3
== see also ==
* Not
* ):
Category:Languages Category:Stack-based Category:Unknown computational class Category:Low-level