nyuuzyou/wikis huggingface dataset:
Numberix

Numberix is an esoteric programming language by Jeffry Johnston that was designed to make the source appear as lines of hex digits. It could be described as a mix of Befunge, Assembly, Brainfuck, Wierd, BASIC and INTERCAL.
==Sample programs==
Hello World:
 A0000159006CA9006C590057A9006F590064A90021000000000000000000000000000000000000
 59004809006559006F09002059007209006CFF0000
A standard input cat program in Numberix:
 5000016800E5FF0000000000000000000000000000000000000000000000000000000000000000
 00000009001B
A file reading cat program: 
 5000019F00805C0000590000F70001000000000000000000000000000000000000000000000000
 000000FF0000
UUencode:
 500200590053590074A9006F590064A90020A50100F90020590036A9003459000AFF0000000000
 A9000D7800F3F70033590072090065A90066F7000209003A090036A90020090064F9006E000000
 610005590020658001A50001A9006CF9006959006D090065090020650001A9000A090065000000
 550001F78022F90108F7000259006559006E09006159006909006EA90008A5000009000A000000
 6F0080F7000C5500005500FF5F8080590062590065090067000000F7802AF70001090060000000
 51010055000163002DA500005C0000958001550002AC00005D440F5F03045D500FA50005000000
 000000F78015A0002D510100A50001A002FFA30001F58002058003FD04F0A58004FD02FC000000
 000000050001A90020000000F70003520000920000530001A500030500045D3203AF0403F70013
 00000003000172000059000AA50000000000A003FFA58002FC00000D4003A58003FD503F090820
 000000000000000000000000F780510000005500015D363F550003058003590420590520090720
UUdecode:
 50000B59004F59007259006959006759006959006E59006159006C590020590066590069A9006C
 F70006F58001B1009EFC0000F50001BF0080F90020F9003AF90065F9006DF90061F9006EF90065
 F78013F10065BC009BFF0000F9000D590048590065590061590064590065590072590020A9006E
 F78023F10067BC0099FF000009002EF90064F9006EF90075F9006FF90066F90020F90074F9006F
 F78033F10069BC009709002EA90069F90066A90069F9006CF70039D3001F530101A50001000000
 F78043F1006EBC0092090065F9006C090020F90064090061FF00000C0000FF0000E100C0000000
 F78053F100207C00E05C03006F008059004959006E0900761F0080050001AC00E0F50001000000
 A58004FD04F0AD040FF500035C000063001F59000D5F8080050000AC00E0F50001F7802C000000
 AD203C050005A580030D3030F78025F9001FAC00E0F50001FC00E0F50001590800830001000000
 A500020D500FFF0403050001FD52FCF58003F20000590300A58003F7001CC30001F78029000000
 5D063F5580025F04025D50035500055D06C05580050F0501510040130001090700050000
Unix LF to MS-DOS CRLF convertor:
 A10002FF0000A9000A59000AF70012000000000000000000000000000000000000000000000000
 5F80801F00804C00F609000D
==External resources==
*Numberix Programming Language
*
Category:Languages
Category:Cell-based
Category:Turing complete
Category:Two-dimensional languages
Category:Low-level
Category:Implemented
Category:2000
Numberlist

Numberlist is an esoteric programming language created by User:A casual user. The program and memory is a list of numbers, which can be positive or negative. 
It also has a pointer, which points to a number in the list.
==Commands==
Every cycle, the pointer moves n numbers down, with n being the number it is pointing to. Every 3 cycles, the interpreter sees the numbers the pointer has pointed the last 3 cycles.
Depending on which ones were odd and even, a different command is performed.
Command 	Outcome
odd - odd - odd 	Prints the number the pointer is pointing to as a number.
odd - odd - even 	Adds the number the pointer is pointing to by the number next to the pointer and replaces the number the pointer is pointing to with the result.
odd - even - odd 	Subtracts the number the pointer is pointing to by the number next to the right of the pointer and replaces the number the pointer is pointing to with the result.
odd - even - even	Asks for a number from the user and puts it in the number the pointer is pointing to.
Anything else 	Does nothing.
If the pointer is pointing to a 0, the program ends.
===Notes (IMPORTANT)===
When, for example, input is put in a number, the pointer doesn't go input numbers to the right. The input is put in the number, but the pointer remembers what that number was before user input was put there, and goes that many numbers to the right. This works for all the other commands.
Also, the only way to end a program is by making the pointer point to a 0. However, it can be hard (or even impossible) to make programs end this way. A interpreter could have a limit, perhaps specified by the user, to how many jumps the pointer can make before the program stops.
==Examples==
===Adding program===
This program takes 2 inputs, a and b, adds them, and puts the result in input b.
 
 1
 2
 0
 2
 5 <---- Input b
 1 <---- Input a
 2
 0
 -4
 1
 -6
===Cat program===
 
Gets user input, stores it, then outputs it.
 
 1
 2
 3
 2
 0
 -3
==Interpreter==
An interpreter has been created by User:Dtp09 and has been uploaded here.
Category:2021
Category:Low-level
Category:Implemented
Category:Self-modifying
NumbersPlusWhat

Numbers+What is an esoteric programming language by User:FluixMakesEsolangs, the offical interpreter is made in a version of BrainFuck called Brainscratch, most if not all programs will end up in infinite loops. 
==How the language Works==
The language starts by moving right twice, and taking user input then going right, it does this 3 times.
The interpreter then starts 2 loops where it goes left prints the cell adds to it, and goes to the next cell and takes from it then the second loops ends and it adds one to the current cell and it goes left twice and decrements from the cell going right twice adding twice and then subtracting three times.
==Examples==
As theres nothing notable of this language there are sadly only one known example as of now.
Counter - This counts from 0 1 2 3 4... WITHOUT being cut off and being reset randomly
 1 0 0
==Known Interpreters==
- The offical interpreter made in Brainscratch. Source: >>,>,>,<<[[<.+>-]+<<->+>>++---] 
Category:Implemented
Category:2024
Category:Joke languages
Numberwang

NB: This language's specifications were changed on the 8th of August 2011.
Numberwang is a language created by Nathan van Doorn. It is inspired by Malbolge, Wang's basic machine B, and That Mitchell and Webb Look.
Programs in Numberwang are stored as a sequence of terminating decimals, delimited by "!". Whitespace is ignored.
Memory is stored on a bidirectionally unbounded tape, much like that esoteric programming language with derivatives that everyone loves to hate, brainfuck. Each cell has two possible values: marked, and unmarked.
At each step, the digital root of the sum of the current command, its position in the program, and the step number is calculated. The result modulo four is taken, and the appropriate instruction is ran:
0	Move the tape-head left.
1	Move the tape-head right
2	The goto operation: goes to the command with the place in the program equal to the current command mod the length of the program, if the current cell is marked. Going to a non-integer place in the program interpolates the neighbouring commands linearly, with the next command being at the subsequent integer position, that is to say, if we go to a command between integers x and x+1, the command executed following this is x+2.
3	iiiiiit's NUMBERWANG! Flip cell (if it's marked, unmark, and vice versa). Then the Numberwang program "12! 4.4! 92! 10! 49.8! 2! 2! 2!" is executed using the current tape and step count.
The step number and command position all start at zero.
== Computational Class ==
The computational class of Numberwang is unknown, but it is believed to be Turing-Complete.
== See also ==
* Implementations
Category:LanguagesCategory:2011Category:Cell-basedCategory:Usability unknownCategory:Unknown_computational_classCategory:No IOCategory:ImplementedCategory:Low-level
Numberwang/Implementations

Implementations for Numberwang
== Python ==
 def droot(n):
 	if n == 0:
 		return 0
 	elif n < 0:
 		return droot(0-n)
 	else:
 		return 1+((n-1)%9)
 def get_prog():
 	c = input("Insert program\n")
 	ds = []
 	de = []
 	sa = ""
 	ea = 0
 	dec = False
 	for i in range(len(c)):
 		if c[i] == "!":
 			ds.append(int(sa))
 			de.append(ea)
 			sa = ""
 			ea = 0
 		elif c[i].isdigit():
 			sa += c[i]
 			if dec:
 				ea -= 1
 		elif c[i]==".":
 			dec = True
 		elif not(c[i].isspace()):
 			return("invalid")
 	return [ds, de]
 def get_tape():
 	c = input("Insert tape\n")
 	d = []
 	for i in range(len(c)):
 		if c[i] == "0":
 			d.append(0)
 		elif c[i] == "1":
 			d.append(1)
 		elif not(c[i].isspace()):
 			return("invalid")
 	return d
 def interpolate(progs,proge,indexs,indexe):
 	pw = 10**-indexe
 	sm = indexs % pw
 	k = indexs // pw
 	s1 = (pw - sm)*progs[k]
 	s2 = sm*progs[k+1]
 	e1 = indexe + proge[k]
 	e2 = indexe + proge[k+1]
 	e = min(e1, e2)
 	s = s1*10**(e1-e) + s2*10**(e2-e)
 	return [s, e]
 def execute(progs,proge,step=-1,tape=[0],pointer=0):
 	indexs = 0
 	indexe = 0
 	while indexs < len(progs)*10**-indexe:
 		step += 1
 		if indexe == 0:
 			c = droot(droot(indexs) + droot(progs[indexs]) + droot(step))
 			#droot(a+b+c) = droot(droot(a)+droot(b)+droot(c)), and droot(s*10**e) = droot(s)
 		else:
 			c = droot(droot(indexs) + droot(interpolate(progs,proge,indexs,indexe)[0]) + droot(step))
 		c %= 4
 		rnd = True
 		if c == 0:
 			pointer -= 1
 			if pointer == -1:
 				pointer = 0
 				tape.insert(0,0)
 		elif c == 1:
 			pointer += 1
 			if pointer == len(tape):
 				tape.append(0)
 		elif c == 2:
 			if tape[pointer]:
 				if indexe == 0:
 					indexe = proge[indexs]
 					indexs = progs[indexs]
 				else:
 					tmp = interpolate(progs,proge,indexs,indexe)
 					indexs = tmp[0]
 					indexe = tmp[1]
 				L = len(progs)
 				pw = 10**-indexe
 				indexs = indexs//pw % L * pw + indexs % pw #this only holds true if indexe <= 0
 				rnd = False
 		else:
 			tape[pointer] ^= 1
 			print("iiiiiit's NUMBERWANG!")
 			try:
 				q = execute((12,44,92,10,498,2,2,2),(0,-1,0,0,-1,0,0,0),step,tape,pointer)
 			except RecursionError:
 				print("Infinite recursion!\nLast tape was:\n" + str(tape))
 				exit()
 			step = q[0]
 			tape = q[1]
 			pointer = q[2]
 		if rnd:
 			if indexe != 0:
 				indexs //= 10**-indexe
 				indexs += 1
 				indexe = 0
 			indexs += 1
 		rnd = True
 	return [step,tape,pointer]
 prog = get_prog()
 while prog == "invalid":
 	print("Invalid program!\n")
 	prog = get_prog()
 progs = prog[0]
 proge = prog[1]
 tape = get_tape()
 while tape == "invalid":
 	print("Invalid tape!\n")
 	tape = get_tape()
 print(execute(progs,proge,-1,tape)[1])
Category:Implementations
Numberwang (brainfuck derivative)

Numberwang is a language based on Brainfuck. All commands consist of single numbers and is meant to produce code that appears extremely random and impossible to understand.
==Commands==
Numberwang's command set consists of the commands in Brainfuck, although as numbers, plus two additional commands to increase the apparent randomness of the finished code.
* 0 - increment the pointer (to point to the next cell to the right)
* 1 - decrement the pointer (to point to the next cell to the left)
* 9 - increment (increase by one) the byte at the pointer
* 2 - decrement (decrease by one) the byte at the pointer
* 3 - output the value of the byte at the pointer
* 8 - accept one byte of input, storing its value in the byte at the pointer.
* 4 - start of loop, needs corresponding 7. Skips loop if active pointer equals 0
* 7 - end of loop, needs corresponding 4. Exits when active pointer equals 0
* 6 - directly increments the current pointer with the following number
* 5 - directly decrements the current pointer with the following number
All other characters are considered comments.
==Proof of Turing Completeness==
Numberwang has a trivial mapping to Brainfuck:
Brainfuck command	Numberwang equivalent
> 	1
< 	0
+ 	9
- 	2
. 	3
, 	8
[ 	4
] 	7
==Hello world example==
 068416902713063416902719936733633069415902719930694169027166358363356358306841590271653
Alternative style: Hello, World!
 69696969696969693696969623673363316969696968359533059595636969663633563583193
==External resources==
* http://numberwang.freehostia.com/ 
* Numberwang Interpreter in Java
* Try it online!
Category:Brainfuck derivatives
Category:Languages
Category:Implemented
Category:Low-level
Category:Cell-based
Numeric

Numeric is a an esolang based in Ascii and lisp syntax in Snap!
 Important Commands
Ascii	Equivalent
32 	space
34 	"
40 	(
41 	)
48 	0
57 	9
95 	_
=== Hello World!: ===
 40
 40 115 97 121 32 34 72 101 108 108 111 32 87 111 114 108 100 33 34 41
 40 115 116 111 112 32 34 91 116 104 105 115 32 115 99 114 105 112 116 93 34 41
 41
=== Cat Program: ===
 40
 40 100 111 65 115 107 32 34 32 34 41
 40 115 97 121 32 40 97 110 115 119 101 114 41 41
 40 115 116 111 112 32 34 91 116 104 105 115 32 115 99 114 105 112 116 93 34 41
 41
=== Thuth Machine: ===
 40
 40 100 111 65 115 107 32 34 32 34 41
 40 118 97 114 32 105 41
 40 115 101 116 32 105 32 40 108 105 115 116 41 32 41
 40 105 102 32 40 61 32 40 97 110 115 119 101 114 41 32 49 41 32 40 102 111 114 101 118 101 114 32 40 40 97 100 100 32 49 32 40 103 101 116 32 105 41 41 32 40 115 97 121 70 111 114 32 40 103 101 116 32 105 41 32 49 41 41 41 32 40 61 32 40 97 110 115 119 101 
 114 41 32 48 41 32 40 10 40 97 100 100 32 48 32 40 103 101 116 32 105 41 41 32 40 115 97 121 32 40 103 101 116 32 105 41 41 10 41 10 41
 40 115 116 111 112 32 34 91 116 104 105 115 32 115 99 114 105 112 116 93 34 41
 41
=== Kiwi Script: ===
 40
 40 115 97 121 32 107 105 119 105 41
 40 115 116 111 112 32 34 91 116 104 105 115 32 115 99 114 105 112 116 93 34 41
 41
Page for Numeric
Category:2025
Numeric Batch

Numeric Batch is an alternate form of Batch which has been entirely programmed in Batch. Created by User:Shubshub on 27 April 2012 in New Zealand.
==Information==
Numeric Batch was created by Shubshub to make programming in batch more challenging and to make it seem better as it is theoretically unreadable unless you use the translator.
The source code of the interpreter is here:
@echo off
call %1
set str=%str:?eighteen?=a%
set str=%str:?five?=b%
set str=%str:?one?=c%
set str=%str:?nineteen?=d%
set str=%str:?two?=e%
set str=%str:?four?=f%
set str=%str:?twentythree?=g%
set str=%str:?twenty?=h%
set str=%str:?fourteen?=i%
set str=%str:?sixteen?=j%
set str=%str:?twentyfive?=k%
set str=%str:?twentyfour?=l%
set str=%str:?twentyone?=m%
set str=%str:?nine?=n%
set str=%str:?twentytwo?=o%
set str=%str:?ten?=p%
set str=%str:?twentysix?=q%
set str=%str:?six?=r%
set str=%str:?three?=s%
set str=%str:?eight?=t%
set str=%str:?thirteen?=u%
set str=%str:?fifteen?=v%
set str=%str:?seven?=w%
set str=%str:?twelve?=x%
set str=%str:?eleven?=y%
set str=%str:?seventeen?=z%
set str=%str:?and?=&%
%str%
pause
Paste that source code into NumericBatch.cmd
and drag your NumericBatch script (can be either .bat or .cmd) onto the file and it will execute the code
by converting the code into pure batch
Here is hello world example in NumericBatch
set str=?two??one??twenty??twentytwo? ?twenty??two??twentyfour??twentyfour??twentytwo? ?seven??twentytwo??six??twentyfour??nineteen?
You can perform multiline commands by doing
set str=<first line of code>
set str=%str% ?and? <second line of code here>
set str=%str% ?and? <next line of code so on so on>
Without an infinite line translator code the program can only interpret things on the set str=
and does not handle set commands very well then executing another command after as it will most likely skip over that next command completely
==See also==
* MaybeNumericBatch
Category:Languages Category:String-rewriting paradigm Category:Implemented
Numeric Topline

This is an esoteric programming language by User:Zzo38 based on Topline, however Topline also uses the shift (not only the top line), and I could try to make it numeric only, also.
The count and address register are each 32-bits signed numbers, but values stored in addressed memory are 16-bits unsigned numbers.
Instructions:
* 00 end of a block loop.
* 01 begins a loop of while the count is odd.
* 02 begins a loop of while the count is even.
* 03 begins a loop of while the count is zero.
* 04 begins a loop of a number of times equal to absolute value of the count at the beginning of the loop.
* 05 begins a loop of while the count is negative.
* 07 begins a loop of while the count is positive.
* 08 begins a loop that runs infinite.
* 10 prints the count as a numeral.
* 110nn makes a system call.
* 111nn send a signal to another program. It also sends the value of this count with the signal.
* 112nn checks if this program is receiving that signal, if so it will set the count.
* 113nn selects the program for send/receive signals with.
* 16 takes a ASCII character input and alters the count via the polarity.
* 17 prints the count as a ASCII character.
* 2n adds a digit to the end of the program.
* 3nnnn defines a label number in the program.
* 40 skips a number of digits in the program equal to the count (negative count skips backwards). Skipping zero approaches only the next instruction after the digits of this instructions only.
* 41 set the low bit of the count.
* 42 clear the low bit of the count.
* 43 resets the count to zero.
* 45 set the polarity to negative.
* 46 toggles the polarity.
* 47 set the polarity to positive.
* 49 immediately ends the program, or returns from a subroutine call.
* 5nnnn goto a label. If there are multiple labels with this number, it will find the last one in the program.
* 60 copies the count to the address register.
* 61 copies the count to a memory address pointed to by the address register.
* 68 adds four digits to the end of the program, which are the count modulo ten thousand.
* 69 copies the count modulo ten to a location in the program pointed to by the address register (the first digit in the program is location zero).
* 7nnnn gosub to a label. If there are multiple labels with this number, it will find the last one in the program.
* 80 copies the address register to the count, and clears the extra register to zero.
* 81 copies the value at the memory address pointed to by the address register to the count.
* 83 find a label in the program with the number by count, and stores the result of where it is found, in the count. It will point directly to the label position (where the digit "3" is).
* 89 copies the digit in the location in the program pointed by the address register, to the count.
* 9nnnn alters the count via the polarity (adds or subtracts nnnn to/from the count).
Example copies input to output until zero:
 474316071743160049
Category:Languages
Category:Unimplemented
Category:2009
Numeric Underload

numeric Underload is a Underload derivative. It has the same instructions but...
 Replace ) with 0
 Replace ( with 1
 Replace ~ with 2
 Replace : with 3
 Replace ! with 4
 Replace * with 5
 Replace a with 6
 Replace ^ with 7
 Replace S with 8
==Computational class==
Since Underload is Turing-complete, so is this language.
Category:LanguagesCategory:UnimplementedCategory:Turing completeCategory:Stack-based
Numeriqueue

Category:LanguagesCategory:UnimplementedCategory:2017
Numeriqueue is a esolang based on Call Queue.
The program consists of a set of functions, which can have zero or arguments, and which have no return values. One function is the starting function.
The arguments of a function have types, which can be:
* A natural number
* A function name, with a list of argument types
The types are allowed to be polymorphic, but they must have types. Also, wherever a function with no arguments is expected, a number is also valid, although the converse is not true.
The function body consist of the list of zero or more statements. A statement consists of a number or a function call. A function call also specifies the argument values of the call, which can be numbers or function names (you can't specify the arguments of the arguments though). Anywhere a number or function name is expected, you can also give an argument to this function. In the case of a numeric argument, you can also specify a constant value to add to the argument value.
Execution is done with a queue of statements (with all argument values already filled in). The first statement is removed from the queue, and then does depending what it is:
* If a number, output that number and then that many further statements from the beginning of the queue are discarded without being executed.
* If a function call, then append all statements of that function to the queue, replacing all arguments with their values.
Once the queue is empty then it is finish.
Numlist

Numlist is a joke esolang invented by User:None1.
Every program is a list of integers separated by spaces.
An integer x tells the IP to move x cells forward, IP starts at left.
If the IP overflows, the program terminates. If the IP will underflow after an operation, the opposite number (the number of first instruction is 0) of IP after this operation will be printed as Unicode and the IP will move to the next instruction instead.
==Examples==
===Infinite loop===
 0
======
 -52
===Hello World===
 -72 -102 -110 -111 -115 -37 -93 -118 -122 -117 -110 -44
Category:Languages
Category:Joke languages
Category:Output only
Numobin

Numobin is a esoteric programming language invented by User:Zzo38. The memory is a stack, a boolean value, and a set of variables.
==Data Types==
Numobin's type system is subjected to a dichotomy into integer numbers and ASCII characters.
==Architecture==
The program state is defined by three storage components: a stack, a Boolean flag, and a variable registry.
===Stack===
The primary data repository, the stack provides the means for maintaining integer and character objects. No upper limit applies to this last-in first-out (LIFO) collection's capacity.
===Boolean value===
A Boolean value, utilized as a flag, permits the helming of the while loop, demarcated by the tokens [ and ]. Two instruction exert their influence on this flag: the unconditional * switch, and the = operation, which toggles the state if and only if the two top stack elements partake of equality.
===Variable registry===
Both the numeric and character objects may be employed in the agency of variable names, associated with values of the same degree in liberty. The operation { allows for the definition of a variable, whereas } queries and inserts its value into the stack.
==Commands==
Numobin's instruction set comprehends members for the manipulation of a program's three data repositories — stack, Boolean flag, and variable registry —, as well as an iteration construct, and input/output facilities.
Command	Description
# 	Push the number onto the stack of the number of # that are in the program before this one.
[ 	Begin loop while the Boolean value is true.
] 	End loop.
- 	Pop the two topmost numbers from the stack and push their absolute difference unto the same.
{ 	Pop the two topmost elements from the stack, using the first one as the variable value and the second as the variable name, and store this association in the variable set.
} 	Pop the topmost element from the stack, utilize it as a variable name, and push the associated value unto the stack.
~ 	Swap the top two entries of the stack.
* 	Toggle the Boolean value.
= 	Pop the two topmost numbers from the stack and, if they are equal, toggle the Boolean value.
( 	Pop the top value from the stack and output the ASCII character or number.
) 	Input an ASCII character or number and push it unto the stack.
? 	Set the number for starting with # to a random value.
 0 = ##-##--
 1 = ##-
 2 = ###~#=-
 3 = ###=#-
 4 = ###-#=#-
 5 = ##-##=##=#-
 6 = ###~#=~-#-
 7 = ###=#~-#-
See if there is shorter way of these things (and more numbers), without changing anything after it is done, other than push the number onto stack.
==Examples==
===Cat program===
The following cat program repeats infinitely:
 *[)(]
===Variables===
This program prompts the user for an input, stores it in the variable with the numeric name “1”, and prints its value to the standard output:
 ##-){##-}(
==Interpreter==
* Common Lisp implementation of the Numobin programming language.
Category:Languages
Category:2007
Category:Implemented