nyuuzyou/wikis huggingface dataset:
Spyrodecimal

Spyrodecimal is an esoteric programming language created by Spyro543. It was designed to have only numbers as commands, but there are a few letters as commands, too.
==All Commands==
0 - Pauses the program execution for 1/10 second.
1 - Outputs the ASCII equivalent of the number in memory.
2 - Increases the number in memory by 1.
3 - Decreases the number in memory by 1.
4 - Gets input and stores it in memory.
5 - Outputs a new line.
6 - Generates a random number between 1 and 256 and stores it in memory.
7 - Moves the program reader back for the amount in memory. For example, if 5 is in memory, it will move back 5 spaces.
8 – Resets the memory to 0.
9 – Same as 7, except moves the reader forward instead of backward.
q – Quits the interpreter.
x – Quits the program, but not the interpreter.
s – Stores the current memory value into one of six variables (a, b, c, d, e, f). Variables are not affected by 8. Syntax (s example: sa)
r – Recalls the value stored into one of six variables (a, b, c, d, e, f) and stores it in memory. Syntax (r example: ra)
==Example Programs==
===Hello World program===
This program prints "HELLO, WORLD!" (split up for readability).
 22222222222222222222222222222222sc22222222222222222222222222222222222222221sd
 3331se
 222222211sa
 2221sb8
 rc2222222222221
 rc1
 rd2222222222222221
 rb1
 2221
 ra1
 re31
===What is your name? program===
This program asks you for your name then greets you. It's just a simple modification of the above program, again, split up for readability.
 4sa4sb4sc4sd4se4sf
 822222222222222222222222222222222222222222222222222222222222222222222222218
 22222222222222222222222222222222222222222222222222222222222222222222218
 2222222222222222222222222222222222222222222222222222222222222222222222222222118
 222222222222222222222222222222222222222222222222222222222222222222222222222222218
 2222222222222222222222222222222218
 ra1rb1rc1rd1re1rf1
The name must be no more than 6 characters.
==External resources==
Download links can be found at each of these sites.
* Spyrodecimal topic on Omnimaga
* Spyrodecimal topic on Cemetech
* Post on Spyro543's blog about Spyrodecimal
Category:Languages
Square-complete

Square-complete is a concept designed by PSTF.
== What Esolang can be called as "Square-complete"? ==
# This Esolang must be able to output "Hello, world!".
# This Esolang must be able to input at least 1 character.
# This Esolang must be able to count from 0 to 10 by looping.
# This Esolang must be able to calculate 1+1, 3-2, 4×6 and 9÷3.
# This Esolang must be able to can store 5 to a variable(or push into a stack, store into a cell, etc.)
# This Esolang must be able to judge that 4 is an even.
== Isn't "Square-complete" is Turing-complete? ==
Not exactly. Turing-complete means you can do any computation, but "Square-complete" means the Esolang can do the most basic things.
Also, Square-complete requires I/O, but Turing-complete doesn't.
Note: If an Esolang is Square-complete then it "must be Turing-complete".
Category:Concepts
Squarebrain

Squarebrain is a language I created after reading a book about learning coding, for children, for some reason I created this.
Square	On a Square
> 	Move right on the canvas
< 	Move left on the canvas
v 	Down
^ 	Up
x 	Mark Cell
n 	New canvas
o 	Output canvas
e 	End program
d 	define canvas
Category:Languages
Category:Graphical Output
Squick

Squick is a furry themed esoteric programing language designed to be harder than Malbolge and feel like “furry-themed hell”. It draws inspiration by Malbolge and Furcode (Esolang).
== Etomology: ==
Squick is furry slang referring to do/wear/say something unexpected with the intention of perplexing outsiders by advertising in an obvious manner one's affiliation with Furry fandom. Squick in in non-furry contexts refers to a source of psychological discomfort or to gross out, to disgust. 
== Virtual Command System: ==
Unlike traditional languages, Sqick keywords do not correlate to a commands instead together using a virtual pointer can convert to Unicode characters.
There are 20 key words:
# Fur
# Fursuit
# Fursona
# Yiff
# Avatar
# Anthro
# Furmeet
# Con
# Furotica
# Plushie
# Paw off
# Fan-zine
# Skritch
# Squick
# 'Zine
# Yerfday
# Fursecution
# Fursuit sex
# Furpile
# Yarf
These key words are then written on the same line and separated with spaces. Note that some words may contain a space in them like, if you write Paw, it is not a valid key word unless a space and of is written. On the line, all the key word's numbers are added this should represent, in reverse ASCII decimal order, a digit in the base which is defined using this formula: round((pen)^ϕ/π) where p is the currant key word counted from the beginning and n is the length of the words in the entire program, this process of making digits is repeated until a newline with no characters is encountered, after that the string of digits then are compressed together and turned into a number. That is then converted into into a Unicode in reverse Unicode order.
After that the Unicode are then converted to their Unicode numbers which then every number is converted to reverse Unicode in which is then are interpreted in a way where 10 Unicode characters are grouped as a word then interpreted as a number using the base of the currant hailstone number from the length of the program in Unicode. if 4 is ever reached, the input for Collatz's conjecture is doubled and the chosen hailstone number is cast back to the first one
== Sample Programs: ==
None exist!
== Interpreters/Compilers: ==
# Official C Interpreter (WIP)
Category:Languages Category:Thematic Category:Works-in-Progress
''
Squiggle

== About ==
Squiggle is an esoteric programming language that uses squiggles ("~") to represent integer values and arithmetic operators to perform calculations.
== Syntax ==
The syntax of Squiggle is simple and intuitive. Integer values are represented using squiggles, and arithmetic operations are performed using the following operators:
*+: Addition
*-: Subtraction
* *: Multiplication
*/: Division
For example, the squiggle sequence ~ ~ ~ represents the integer value 3, and the expression ~ ~ ~ + ~ ~ ~ ~ ~ would output 8 because it adds the values of 3 and 5. Note: You don't need to have spaces between squiggles.
== Usage ==
Currently, the only way you can use Squiggle is to go to use the interpreter on my website.
== Resources ==
* Squiggle Interpreter
Squishy2K

Squishy2K is an esoteric programming language created by Chris Pressey in 2000.
==Description==
Squishy2K was described by its creator as "a string-rewriting language (read: Thue) embedded within a state machine (read: beta-Juliet) with states-doubling-as-functions thrown in for good measure".
This is the grammar.
 Program ::= {State}.
 State ::= "*" Name "{" {Rule} ["!" Name] "}".
 Rule ::= LString "?" RString "!" [Name].
 LString ::= {quoted | "few" | "many" | "start" | "finish"}.
 RString ::= {quoted | digit | Name "(" RString ")"}.
==External resources==
* 
* Squishy2K to Perl 5 compiler
Category:Languages
Category:Implemented
Category:String-rewriting paradigm
Category:2000
Squi~~le

Too lazy to make an actual article. Here's the commands:
~1[x: Begin defining a function with the name x
~2[x: Stop defining a function
~3[x: Print x
~4[x~7[y: Define a variable with the name x with the contents y
~5[x~6[y: Concatenate x with y
~8[x: Call the function with the name x
~9[x: Return the xth letter of the alphabet
Hello world is probably possible
Category:Languages
Category:Unimplemented
Srry

srry is Sorry but with one change.
== the change ==
now we only have [] with a conditional. if they hold two nothings(two spaces) then we will do ^ else we will do []. also it pops top. if theres nothing to pop it just pushes without any of the if stuff. so now [x] is:
 [ ][x]
: is:
 [[][]][**][ ][ ]
^ is:
 [ ][ ][*][ ][ ]
Stable

Stable is an esoteric programming language that can push only zeroes. The only way to get nonzero number is to preserve the initial stack. This language is inspired by Volatile. This language can be interpreted as deterministic subset of Volatile with initial stack of [1], instead of empty stack.
== Notation ==
We use {stack}{program} notation. We also use <variable> for denoting variable. (...) is a single token that can be deconstructed to get its contents. Additionally, we use word "error" if the program errors. Output is indicated with output: clause after the rule.
== Original State ==
The original state of the program is:
 {1}{<program>}
== Instruction ==
The instructions are the same as Volatile, but without ~. Rule above is favored over the bottom ones.
 {<stack> a b}{+ <program>} => {<stack> a+b} {<program>}
 {<stack> a b}{- <program>} => {<stack> a-b} {<program>}
 {<stack> a b}{* <program>} => {<stack> a*b} {<program>}
 {<stack> a 0}{/ <program>} => error
 {<stack> a b}{/ <program>} => {<stack> a/b} {<program>}
 {<stack> a}{: <program>} => {<stack> a a} {<program>}
 {<stack> a}{. <program>} => {<stack> a} {<program>} output: a
 {<stack> 0}{(<loop>) <program>} => {<stack> 0} {<program>}
 {<stack> a}{(<loop>) <program>} => {<stack> a} {<loop> (<loop>) <program>}
 {<stack>}{<program>} => error
==See also==
* Volatile
Category:Languages
Category:2019
Category:Stack-based
Category:Unknown computational class
Stack-based+

Stack-based+ is a derivative of Stack-based, its goal is to make progrmming in Stack-based easier.
==Procedures==
Programs in Stack-based+ are separated into subprograms called procedures. Two procedures are separated by exactly one blank line.
For example:
 VAR a
 
 VAR b
has two procedures but:
 VAR a
 
 
 VAR b
has three.
By default, when procedure terminates, control flow goes to the next procedure.
Procedures makes coding more logical, it is convenient but not needed for one to write a comment for each procedure for what it does.
==Jumps==
Stack-based+ removes and , but there are two other commands for jumping: and .
 J x integer
Jump to the integer-th procedure if x is nonzero.
 NJ x integer
Jump to the integer-th procedure if x is zero.
==Examples==
===Hello World===
 P "Hello World!"
===Cat program===
 VAR c
 
 IC c
 OC c
 J c 2
==Stack-based improved==
Stack-based improved or Stack-based++ is an improved version of Stack-based. It adds another feature: labels.
===Commands===
 L "string"
Defineds a label named string
 JL "string"
Jump to the string-th label if x is nonzero.
 NJL "string"
Jump to the string-th label if x is zero.
==See also==
* Stack-based
Category:Languages
Category:Turing complete
Category:2023
Category:Unimplemented
Category:Stack-based
Stack-gpt

Stack-gpt is an esoteric programming language (esolang) created by ChatGPT 4o mini. It operates primarily on a stack structure, allowing manipulation of data through commands that push, pop, and perform operations on values.
== Commands ==
Below are the primary commands of the Stack-gpt language:
 
Stack-gpt is not turing complate please dont waste your time
 Commands Table
Command 	Description
+ 	Pops two numbers from the stack, adds them, and pushes the result.
- 	Pops two numbers, subtracts the second from the first, and pushes the result.
* 	Pops two numbers, multiplies them, and pushes the result.
/ 	Pops two numbers, divides the first by the second, and pushes the result.
% 	Pops two numbers, computes the modulus, and pushes the result.
^ 	Pops two numbers, performs a bitwise XOR, and pushes the result.
& 	Pops two numbers, performs a bitwise AND, and pushes the result.
 	Pops two numbers, performs a bitwise OR, and pushes the result.
push 	Pushes a given character, string, or number (int/float) onto the stack.
pop 	Pops the top value from the stack without further action.
dupe 	Duplicates the top item on the stack.
die 	Terminates the program.
print 	Prints the number on top of the stack with a newline.
printc 	Prints the ASCII character corresponding to the number on top of the stack. No newline is added.
len 	Pushes the length of the stack (plus 1) onto the stack.
negative 	If the top number is negative, pops it and pushes 0; otherwise, leaves the number unchanged.
input 	Takes a string input from the user and pushes each character (as ASCII values) onto the stack.
if number label	If the top number of the stack equals the given number, jumps to the specified label.
goto label 	Jumps to the specified label.
== Examples ==
=== truth machine ===
 push ">0ro1"
 start:
 len
 if 1 truthmachine
 pop 
 printc
 goto start
 truthmachine:
 input
 if 49 lep
 push 0
 print
 die
 lep:
 push 49
 printc
 goto lep
=== hello world ===
 push "!dlrow"
 push 32 
 push "olleh"
 start:
 len
 if 1 end
 pop 
 printc
 goto start
 end:
 die
yes this page generated by chatgpt 
 interpreter: https://github.com/serpentis64/stack-gpt/blob/main/main.py''
Category:Languages Category:Implemented Category:2024 Category:Stack-based
StackBBQ

StackBBQ is an Esolang designed by User:I am islptng. 
BBQ stands for Binary-Based Quine(because you have to write quine to perform loops)
It's a stack-based binary language, heavily inspired by bct and 1.
Yes, Binary. The program consists of 0s and 1s. And the stack is too.
Each bit is an instruction. Yes, no loops.
A 1 pushes a True to the stack, and what about 0?
A 0 first pops 3 values, first c, second b, third a.
 abc
 111: Push = not Pop
 110: Push = Pop or Pop
 101: Move bottom->top
 100: Duplicate
 011: Move top 3 to top
 010: Swap top 2
 001: Pop 1, if 0, input 8, else pop and output
 000: Pop a value, if it is 1, Pop and push to the end of the program, then push it back
== Interpreter ==
Quite buggy Python one.
prog = input("Enter program > ")
stack = []
inbuffer = []
outbuffer = []
i = -1
while i < len(prog):
	i = i + 1
	try: prog[i]
	except IndexError: break
	if prog[i] == "1":
		stack.append(1)
	elif prog[i] == "0":
		c = stack.pop()
		b = 2*stack.pop() + c
		a = 4*stack.pop() + b
		if a == 7:
			stack.append(not(stack.pop()))
		if a == 6:
			if len(stack) >= 2:
				stack.append(stack.pop() or stack.pop())
			else:
				stack.pop()
		if a == 5:
			stack.append(stack.pop(0))
		if a == 4:
			stack.append(stack[-1])
		if a == 3:
			stack.append(stack.pop(-3))
		if a == 2:
			stack.append(stack.pop(-2))
		if a == 1:
			ind = stack.pop()
			if ind == 0:
				if len(inbuffer) == 0:
					newbuffer = input() + '\n'
					for j in newbuffer:
						x = ord(i)
						temp = []
						for k in range(8):
							temp.append(x % 2)
							x = int(x/2)
						for k in range(8): inbuffer.append(temp.pop())
				stack.append(inbuffer.pop(0))
			else:
				outbuffer.append(stack.pop())
				if len(outbuffer) >= 8:
					outchar = 0
					for k in range(8):
						outchar *= 2
						outchar += outbuffer.pop(0)
					print(chr(outchar),end="")
		if a == 0:
			if stack[-1] == 1:
				prog += stack.pop(-2)
	else:
		pass
	# print("Instruction No.",i+1,"i.e.",prog[i],"\nProgram:",prog,"\nStack: ", end = "")
	for j in range(len(stack)):
		stack[j] = int(stack[j])
		# print(stack[j], end = "")
	# print("\n")
print("---------- Halts.")
while True: print(end="")
Category:Languages Category:Implemented Category:Stack-based Category:Low-level Category:2024 Category:Total
StackBit

StackBit is a Turing-complete esolang by User:ChuckEsoteric08 that is easy to implement.
==Specification==
Data is stored in two stacks.
 0 - push 0 to the current stack
 1 - push 1 to the current stack
 ~ - switch to another stack
 [...] - while top of the stack is 1
 * - pop top element
There is also optional command for debuging:
 . - outputs top of the stack
==StackBit minimalisation==
We could minimise number of instruction by combining ~ and 0 into command >
 > - switch between stacks and push 0
Then ~ would be:
 >*
And 0 is:
 >*>
We could also assune that [] is a NOP. Then we could combine ] and 1 into |
 | - end loop and push 1
Then ] would be:
 |*
And 1 would be:
 [|
==Turing-completness Proof==
The Turing-completeness can be proven by simulating BitBrain-R
 Start of the program: 0~000000000~
 + - ~0~
 > - ~0~[*~*1~0]*
 < - 0~[*~*1~0]*
 [...] is same
 * - ~1~[~*0~*0]~[*0~*1~]*~
Category:Languages Category:Turing complete Category:Turing tarpits
StackLang

StackLang is a Stack-based esoteric programming language made by Dominicentek. StackLang executes it's instructions depending on a value in the stack.
== Execution ==
Each line is pushed onto the stack. The line is converted into a number that will be pushed. If it cannot be converted into a number, it pushes a string onto the stack. Once all lines are pushed. The interpretation of the program begins. Each instruction value is popped once it starts executing another instruction. The stack is also used as a data stack, too.
== Instructions ==
Instruction	Description
0 	Prints the top value and pops it
1 	Loop, the top value of the stack is used for loop amount, when it reaches the bottom of the stack, it loops
2 	Infinite loop, when it reaches the bottom of the stack, it loops
3 	Breaks out of a loop
4 	Continue a loop
5 	Pushes the top value onto a stack twice (Duplicate)
6 	Pops the top value of the stack
7 	Gets user input and pushes it onto the stack
8 	If statement, if the top value matches the value below it, it continues, otherwise it skips amount of values defined by 3rd top value in the stack. Compared values will be popped.
9 	Moves the value below this instruction to the top
10 	Moves the pointer to the top
11 	Moves the pointer based on the top value of the stack, then pops it
12 	Exits out of the program
== Examples ==
=== Hello World ===
Hello, World!
0
=== Truth-machine ===
0
0
4
0
5
5
2
5
1
9
12
0
0
0
3
0
8
7
=== Cat Program ===
0
7
== Interpreter ==
Download
Category:Stack-basedCategory:2021
Category:LanguagesCategory:Implemented
StackMachine

This is an ordinary stack-based esolang that was created by a Discord bot(antigollark).
===First answer===
 push: Pushes a value onto the stack.
 pop: Pops a value from the stack and discards it.
 dup: Duplicates the top value on the stack.
 swap: Swaps the top two values on the stack.
 rot: Rotates the top three values on the stack.
 add: Adds the top two values on the stack and pushes the result.
 sub: Subtracts the top two values on the stack and pushes the result.
 mul: Multiplies the top two values on the stack and pushes the result.
 div: Divides the top two values on the stack and pushes the result.
 mod: Calculates the modulus of the top two values on the stack and pushes the result.
 store: Stores a value in a variable.
 load: Loads a value from a variable.
===Second answer===
prompt: "why it can't do loop"
 jnz: Jumps to a label if the top value on the stack is not zero.
 jmp: Jumps to a label unconditionally.
===Third answer, details given===
prompt: "give details about these 14 commands(the format, the errors, etc)"
and this answer also adds trigonomic functions and sqrt.
 push: Takes a value as an argument and pushes it onto the stack. If the value is not a valid number, an error is thrown.
 pop: No arguments. If the stack is empty, an error is thrown.
 dup: No arguments. If the stack is empty, an error is thrown.
 swap: No arguments. If the stack has less than two values, an error is thrown.
 rot: No arguments. If the stack has less than three values, an error is thrown.
 add: No arguments. If the stack has less than two values, an error is thrown.
 sub: No arguments. If the stack has less than two values, an error is thrown.
 mul: No arguments. If the stack has less than two values, an error is thrown.
 div: No arguments. If the stack has less than two values, an error is thrown.
 mod: No arguments. If the stack has less than two values, an error is thrown.
 sqrt: No arguments. If the stack is empty, an error is thrown.
 sin: No arguments. If the stack is empty, an error is thrown.
 cos: No arguments. If the stack is empty, an error is thrown.
 tan: No arguments. If the stack is empty, an error is thrown.
 jnz: Takes a label name as an argument. If the label does not exist, an error is thrown.
 jmp: Takes a label name as an argument. If the label does not exist, an error is thrown.
 All operations other than push can produce a value which is too large to be represented. In that case, an error is thrown.
===About rot===
The bot kept answering me this:
 It takes the top three values and pushes them back onto the stack in the order: 1, 3, 2.
it said, if the stack is
 [bottom] c b a [top]
after doing the command, the stack become
 [bottom] b a c [top]
Category:Languages Category:Stack-based Category:2024 Category:Unimplemented Category:Generated by AI
StackPoint

StackPoint is an esolang by User:ChuckEsoteric08 inspired by Bub and CINS.
==Description==
StackPoint has an unbonded stack with unbounded integers and unbounded tape with unbounded integers. Initialy it has one 0 in the stack. Here all commands
Command	Operation
> 	increment element on top of the stack
< 	decrement element on top of the stack
~ 	swap top two stack elements
# 	pop top element on the stack and discard it
+ 	increment current cell. Use top element of the stack as pointer
- 	same like + but decrement
abc: 	declare label abc. Label names can contain lowercase letters and digits
abc^ 	jump to label abc if cell pointed by top stack element is zero
abc@ 	jump to label abc if cell pointed by top stack element is nonzero
, 	set current cell to next input byte
. 	output current cell as ASCII character
" 	duplicate stack element
* 	push zero to the stack
& 	reverse stack
Category:Languages Category:Turing complete Category:Unimplemented
StackSwap

StackSwap is an esolang by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff designed around function calls.
== Syntax ==
A StackSwap program is a series of function definitions, which start with the function name, then a colon, and finally a list of function calls.
== Semantics ==
StackSwap contains two stacks, one of which is selected to be the current stack, as well as an instruction pointer. When a function is called the function calling it is placed onto the current stack and control moves to the called function.
== Built-in methods ==
* §: Swap the two control stacks. Note that this method returns to the function it was called from normally.
* out1: Send a 1 to the little-endian output buffer. When the buffer has eight bits, output that byte to stdout.
* out0: Send a 0 to the little-endian output buffer. When the buffer has eight bits, output that byte to stdout.
* read: Remove a bit from the front of the little-endian input buffer and execute § if it is a 1. If the buffer is empty, input a byte to the buffer.
== Examples ==
=== Hello, World! ===
a: out1 out0 out0 out1 out0 out0 out0 out1 out1 out0 out0 out1 out0 out1 out1 out1 out0 out1 out1
b: out0 out0 out1 out1 out0 out1 out1 out0 out0 out1 out1 out0 out1 out1 out1 out1 out1 out0 out1
c: out1 out0 out0 out1 out0 out0 out0 out0 out0 out1 out0 out1 out0 out1 out1 out1 out1 out1 out0
d: out1 out1 out1 out1 out1 out1 out1 out0 out0 out1 out0 out1 out1 out0 out1 out1 out0 out0 out1
e: out1 out0 out0 out1 out0 out0 out1 out0 out0 out0 out0 out1 
main: a b c d e
=== Truth-machine ===
waste: read read read read read read read
next: read § a
zero: § next out0 out0 out1 out1 out0 out0 out0 out0
main: waste next one
one: out0 out0 out1 out1 out0 out0 out0 out1 one
Category:Languages Category:Low-level Category:Stack-based Category:Unknown computational class